kernel/fs/ubifs/xattr.c

   1 /*
   2  * This file is part of UBIFS.
   3  *
   4  * Copyright (C) 2006-2008 Nokia Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc., 51
  17  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18  *
  19  * Authors: Artem Bityutskiy (Битюцкий Артём)
  20  *          Adrian Hunter
  21  */
  22
  23 /*
  24  * This file implements UBIFS extended attributes support.
  25  *
  26  * Extended attributes are implemented as regular inodes with attached data,
  27  * which limits extended attribute size to UBIFS block size (4KiB). Names of
  28  * extended attributes are described by extended attribute entries (xentries),
  29  * which are almost identical to directory entries, but have different key type.
  30  *
  31  * In other words, the situation with extended attributes is very similar to
  32  * directories. Indeed, any inode (but of course not xattr inodes) may have a
  33  * number of associated xentries, just like directory inodes have associated
  34  * directory entries. Extended attribute entries store the name of the extended
  35  * attribute, the host inode number, and the extended attribute inode number.
  36  * Similarly, direntries store the name, the parent and the target inode
  37  * numbers. Thus, most of the common UBIFS mechanisms may be re-used for
  38  * extended attributes.
  39  *
  40  * The number of extended attributes is not limited, but there is Linux
  41  * limitation on the maximum possible size of the list of all extended
  42  * attributes associated with an inode (%XATTR_LIST_MAX), so UBIFS makes sure
  43  * the sum of all extended attribute names of the inode does not exceed that
  44  * limit.
  45  *
  46  * Extended attributes are synchronous, which means they are written to the
  47  * flash media synchronously and there is no write-back for extended attribute
  48  * inodes. The extended attribute values are not stored in compressed form on
  49  * the media.
  50  *
  51  * Since extended attributes are represented by regular inodes, they are cached
  52  * in the VFS inode cache. The xentries are cached in the LNC cache (see
  53  * tnc.c).
  54  *
  55  * ACL support is not implemented.
  56  */
  57
  58 #include "ubifs.h"
  59 #include <linux/fs.h>
  60 #include <linux/slab.h>
  61 #include <linux/xattr.h>
  62 #include <linux/posix_acl_xattr.h>
  63
  64 /*
  65  * Limit the number of extended attributes per inode so that the total size
  66  * (@xattr_size) is guaranteeded to fit in an 'unsigned int'.
  67  */
  68 #define MAX_XATTRS_PER_INODE 65535
  69
  70 /*
  71  * Extended attribute type constants.
  72  *
  73  * USER_XATTR: user extended attribute ("user.*")
  74  * TRUSTED_XATTR: trusted extended attribute ("trusted.*)
  75  * SECURITY_XATTR: security extended attribute ("security.*")
  76  */
  77 enum {
  78         USER_XATTR,
  79         TRUSTED_XATTR,
  80         SECURITY_XATTR,
  81 };
  82
  83 static const struct inode_operations empty_iops;
  84 static const struct file_operations empty_fops;
  85
  86 /**
  87  * create_xattr - create an extended attribute.
  88  * @c: UBIFS file-system description object
  89  * @host: host inode
  90  * @nm: extended attribute name
  91  * @value: extended attribute value
  92  * @size: size of extended attribute value
  93  *
  94  * This is a helper function which creates an extended attribute of name @nm
  95  * and value @value for inode @host. The host inode is also updated on flash
  96  * because the ctime and extended attribute accounting data changes. This
  97  * function returns zero in case of success and a negative error code in case
  98  * of failure.
  99  */
 100 static int create_xattr(struct ubifs_info *c, struct inode *host,
 101                         const struct qstr *nm, const void *value, int size)
 102 {
 103         int err, names_len;
 104         struct inode *inode;
 105         struct ubifs_inode *ui, *host_ui = ubifs_inode(host);
 106         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
 107                                 .new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
 108                                 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
 109
 110         if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE) {
 111                 ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
 112                           host->i_ino, host_ui->xattr_cnt);
 113                 return -ENOSPC;
 114         }
 115         /*
 116          * Linux limits the maximum size of the extended attribute names list
 117          * to %XATTR_LIST_MAX. This means we should not allow creating more
 118          * extended attributes if the name list becomes larger. This limitation
 119          * is artificial for UBIFS, though.
 120          */
 121         names_len = host_ui->xattr_names + host_ui->xattr_cnt + nm->len + 1;
 122         if (names_len > XATTR_LIST_MAX) {
 123                 ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
 124                           host->i_ino, names_len, XATTR_LIST_MAX);
 125                 return -ENOSPC;
 126         }
 127
 128         err = ubifs_budget_space(c, &req);
 129         if (err)
 130                 return err;
 131
 132         inode = ubifs_new_inode(c, host, S_IFREG | S_IRWXUGO);
 133         if (IS_ERR(inode)) {
 134                 err = PTR_ERR(inode);
 135                 goto out_budg;
 136         }
 137
 138         /* Re-define all operations to be "nothing" */
 139         inode->i_mapping->a_ops = &empty_aops;
 140         inode->i_op = &empty_iops;
 141         inode->i_fop = &empty_fops;
 142
 143         inode->i_flags |= S_SYNC | S_NOATIME | S_NOCMTIME | S_NOQUOTA;
 144         ui = ubifs_inode(inode);
 145         ui->xattr = 1;
 146         ui->flags |= UBIFS_XATTR_FL;
 147         ui->data = kmemdup(value, size, GFP_NOFS);
 148         if (!ui->data) {
 149                 err = -ENOMEM;
 150                 goto out_free;
 151         }
 152         inode->i_size = ui->ui_size = size;
 153         ui->data_len = size;
 154
 155         mutex_lock(&host_ui->ui_mutex);
 156         host->i_ctime = ubifs_current_time(host);
 157         host_ui->xattr_cnt += 1;
 158         host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
 159         host_ui->xattr_size += CALC_XATTR_BYTES(size);
 160         host_ui->xattr_names += nm->len;
 161
 162         err = ubifs_jnl_update(c, host, nm, inode, 0, 1);
 163         if (err)
 164                 goto out_cancel;
 165         mutex_unlock(&host_ui->ui_mutex);
 166
 167         ubifs_release_budget(c, &req);
 168         insert_inode_hash(inode);
 169         iput(inode);
 170         return 0;
 171
 172 out_cancel:
 173         host_ui->xattr_cnt -= 1;
 174         host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
 175         host_ui->xattr_size -= CALC_XATTR_BYTES(size);
 176         host_ui->xattr_names -= nm->len;
 177         mutex_unlock(&host_ui->ui_mutex);
 178 out_free:
 179         make_bad_inode(inode);
 180         iput(inode);
 181 out_budg:
 182         ubifs_release_budget(c, &req);
 183         return err;
 184 }
 185
 186 /**
 187  * change_xattr - change an extended attribute.
 188  * @c: UBIFS file-system description object
 189  * @host: host inode
 190  * @inode: extended attribute inode
 191  * @value: extended attribute value
 192  * @size: size of extended attribute value
 193  *
 194  * This helper function changes the value of extended attribute @inode with new
 195  * data from @value. Returns zero in case of success and a negative error code
 196  * in case of failure.
 197  */
 198 static int change_xattr(struct ubifs_info *c, struct inode *host,
 199                         struct inode *inode, const void *value, int size)
 200 {
 201         int err;
 202         struct ubifs_inode *host_ui = ubifs_inode(host);
 203         struct ubifs_inode *ui = ubifs_inode(inode);
 204         void *buf = NULL;
 205         struct ubifs_budget_req req = { .dirtied_ino = 2,
 206                 .dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
 207
 208         ubifs_assert(ui->data_len == inode->i_size);
 209         err = ubifs_budget_space(c, &req);
 210         if (err)
 211                 return err;
 212
 213         buf = kmemdup(value, size, GFP_NOFS);
 214         if (!buf) {
 215                 err = -ENOMEM;
 216                 goto out_free;
 217         }
 218         mutex_lock(&ui->ui_mutex);
 219         kfree(ui->data);
 220         ui->data = buf;
 221         inode->i_size = ui->ui_size = size;
 222         ui->data_len = size;
 223         mutex_unlock(&ui->ui_mutex);
 224
 225         mutex_lock(&host_ui->ui_mutex);
 226         host->i_ctime = ubifs_current_time(host);
 227         host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
 228         host_ui->xattr_size += CALC_XATTR_BYTES(size);
 229
 230         /*
 231          * It is important to write the host inode after the xattr inode
 232          * because if the host inode gets synchronized (via 'fsync()'), then
 233          * the extended attribute inode gets synchronized, because it goes
 234          * before the host inode in the write-buffer.
 235          */
 236         err = ubifs_jnl_change_xattr(c, inode, host);
 237         if (err)
 238                 goto out_cancel;
 239         mutex_unlock(&host_ui->ui_mutex);
 240
 241         ubifs_release_budget(c, &req);
 242         return 0;
 243
 244 out_cancel:
 245         host_ui->xattr_size -= CALC_XATTR_BYTES(size);
 246         host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
 247         mutex_unlock(&host_ui->ui_mutex);
 248         make_bad_inode(inode);
 249 out_free:
 250         ubifs_release_budget(c, &req);
 251         return err;
 252 }
 253
 254 /**
 255  * check_namespace - check extended attribute name-space.
 256  * @nm: extended attribute name
 257  *
 258  * This function makes sure the extended attribute name belongs to one of the
 259  * supported extended attribute name-spaces. Returns name-space index in case
 260  * of success and a negative error code in case of failure.
 261  */
 262 static int check_namespace(const struct qstr *nm)
 263 {
 264         int type;
 265
 266         if (nm->len > UBIFS_MAX_NLEN)
 267                 return -ENAMETOOLONG;
 268
 269         if (!strncmp(nm->name, XATTR_TRUSTED_PREFIX,
 270                      XATTR_TRUSTED_PREFIX_LEN)) {
 271                 if (nm->name[sizeof(XATTR_TRUSTED_PREFIX) - 1] == '\0')
 272                         return -EINVAL;
 273                 type = TRUSTED_XATTR;
 274         } else if (!strncmp(nm->name, XATTR_USER_PREFIX,
 275                                       XATTR_USER_PREFIX_LEN)) {
 276                 if (nm->name[XATTR_USER_PREFIX_LEN] == '\0')
 277                         return -EINVAL;
 278                 type = USER_XATTR;
 279         } else if (!strncmp(nm->name, XATTR_SECURITY_PREFIX,
 280                                      XATTR_SECURITY_PREFIX_LEN)) {
 281                 if (nm->name[sizeof(XATTR_SECURITY_PREFIX) - 1] == '\0')
 282                         return -EINVAL;
 283                 type = SECURITY_XATTR;
 284         } else
 285                 return -EOPNOTSUPP;
 286
 287         return type;
 288 }
 289
 290 static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
 291 {
 292         struct inode *inode;
 293
 294         inode = ubifs_iget(c->vfs_sb, inum);
 295         if (IS_ERR(inode)) {
 296                 ubifs_err(c, "dead extended attribute entry, error %d",
 297                           (int)PTR_ERR(inode));
 298                 return inode;
 299         }
 300         if (ubifs_inode(inode)->xattr)
 301                 return inode;
 302         ubifs_err(c, "corrupt extended attribute entry");
 303         iput(inode);
 304         return ERR_PTR(-EINVAL);
 305 }
 306
 307 static int setxattr(struct inode *host, const char *name, const void *value,
 308                     size_t size, int flags)
 309 {
 310         struct inode *inode;
 311         struct ubifs_info *c = host->i_sb->s_fs_info;
 312         struct qstr nm = QSTR_INIT(name, strlen(name));
 313         struct ubifs_dent_node *xent;
 314         union ubifs_key key;
 315         int err, type;
 316
 317         ubifs_assert(mutex_is_locked(&host->i_mutex));
 318
 319         if (size > UBIFS_MAX_INO_DATA)
 320                 return -ERANGE;
 321
 322         type = check_namespace(&nm);
 323         if (type < 0)
 324                 return type;
 325
 326         xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
 327         if (!xent)
 328                 return -ENOMEM;
 329
 330         /*
 331          * The extended attribute entries are stored in LNC, so multiple
 332          * look-ups do not involve reading the flash.
 333          */
 334         xent_key_init(c, &key, host->i_ino, &nm);
 335         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
 336         if (err) {
 337                 if (err != -ENOENT)
 338                         goto out_free;
 339
 340                 if (flags & XATTR_REPLACE)
 341                         /* We are asked not to create the xattr */
 342                         err = -ENODATA;
 343                 else
 344                         err = create_xattr(c, host, &nm, value, size);
 345                 goto out_free;
 346         }
 347
 348         if (flags & XATTR_CREATE) {
 349                 /* We are asked not to replace the xattr */
 350                 err = -EEXIST;
 351                 goto out_free;
 352         }
 353
 354         inode = iget_xattr(c, le64_to_cpu(xent->inum));
 355         if (IS_ERR(inode)) {
 356                 err = PTR_ERR(inode);
 357                 goto out_free;
 358         }
 359
 360         err = change_xattr(c, host, inode, value, size);
 361         iput(inode);
 362
 363 out_free:
 364         kfree(xent);
 365         return err;
 366 }
 367
 368 int ubifs_setxattr(struct dentry *dentry, const char *name,
 369                    const void *value, size_t size, int flags)
 370 {
 371         dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
 372                 name, d_inode(dentry)->i_ino, dentry, size);
 373
 374         return setxattr(d_inode(dentry), name, value, size, flags);
 375 }
 376
 377 ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
 378                        size_t size)
 379 {
 380         struct inode *inode, *host = d_inode(dentry);
 381         struct ubifs_info *c = host->i_sb->s_fs_info;
 382         struct qstr nm = QSTR_INIT(name, strlen(name));
 383         struct ubifs_inode *ui;
 384         struct ubifs_dent_node *xent;
 385         union ubifs_key key;
 386         int err;
 387
 388         dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name,
 389                 host->i_ino, dentry, size);
 390
 391         err = check_namespace(&nm);
 392         if (err < 0)
 393                 return err;
 394
 395         xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
 396         if (!xent)
 397                 return -ENOMEM;
 398
 399         xent_key_init(c, &key, host->i_ino, &nm);
 400         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
 401         if (err) {
 402                 if (err == -ENOENT)
 403                         err = -ENODATA;
 404                 goto out_unlock;
 405         }
 406
 407         inode = iget_xattr(c, le64_to_cpu(xent->inum));
 408         if (IS_ERR(inode)) {
 409                 err = PTR_ERR(inode);
 410                 goto out_unlock;
 411         }
 412
 413         ui = ubifs_inode(inode);
 414         ubifs_assert(inode->i_size == ui->data_len);
 415         ubifs_assert(ubifs_inode(host)->xattr_size > ui->data_len);
 416
 417         mutex_lock(&ui->ui_mutex);
 418         if (buf) {
 419                 /* If @buf is %NULL we are supposed to return the length */
 420                 if (ui->data_len > size) {
 421                         ubifs_err(c, "buffer size %zd, xattr len %d",
 422                                   size, ui->data_len);
 423                         err = -ERANGE;
 424                         goto out_iput;
 425                 }
 426
 427                 memcpy(buf, ui->data, ui->data_len);
 428         }
 429         err = ui->data_len;
 430
 431 out_iput:
 432         mutex_unlock(&ui->ui_mutex);
 433         iput(inode);
 434 out_unlock:
 435         kfree(xent);
 436         return err;
 437 }
 438
 439 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 440 {
 441         union ubifs_key key;
 442         struct inode *host = d_inode(dentry);
 443         struct ubifs_info *c = host->i_sb->s_fs_info;
 444         struct ubifs_inode *host_ui = ubifs_inode(host);
 445         struct ubifs_dent_node *xent, *pxent = NULL;
 446         int err, len, written = 0;
 447         struct qstr nm = { .name = NULL };
 448
 449         dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino,
 450                 dentry, size);
 451
 452         len = host_ui->xattr_names + host_ui->xattr_cnt;
 453         if (!buffer)
 454                 /*
 455                  * We should return the minimum buffer size which will fit a
 456                  * null-terminated list of all the extended attribute names.
 457                  */
 458                 return len;
 459
 460         if (len > size)
 461                 return -ERANGE;
 462
 463         lowest_xent_key(c, &key, host->i_ino);
 464         while (1) {
 465                 int type;
 466
 467                 xent = ubifs_tnc_next_ent(c, &key, &nm);
 468                 if (IS_ERR(xent)) {
 469                         err = PTR_ERR(xent);
 470                         break;
 471                 }
 472
 473                 nm.name = xent->name;
 474                 nm.len = le16_to_cpu(xent->nlen);
 475
 476                 type = check_namespace(&nm);
 477                 if (unlikely(type < 0)) {
 478                         err = type;
 479                         break;
 480                 }
 481
 482                 /* Show trusted namespace only for "power" users */
 483                 if (type != TRUSTED_XATTR || capable(CAP_SYS_ADMIN)) {
 484                         memcpy(buffer + written, nm.name, nm.len + 1);
 485                         written += nm.len + 1;
 486                 }
 487
 488                 kfree(pxent);
 489                 pxent = xent;
 490                 key_read(c, &xent->key, &key);
 491         }
 492
 493         kfree(pxent);
 494         if (err != -ENOENT) {
 495                 ubifs_err(c, "cannot find next direntry, error %d", err);
 496                 return err;
 497         }
 498
 499         ubifs_assert(written <= size);
 500         return written;
 501 }
 502
 503 static int remove_xattr(struct ubifs_info *c, struct inode *host,
 504                         struct inode *inode, const struct qstr *nm)
 505 {
 506         int err;
 507         struct ubifs_inode *host_ui = ubifs_inode(host);
 508         struct ubifs_inode *ui = ubifs_inode(inode);
 509         struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
 510                                 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
 511
 512         ubifs_assert(ui->data_len == inode->i_size);
 513
 514         err = ubifs_budget_space(c, &req);
 515         if (err)
 516                 return err;
 517
 518         mutex_lock(&host_ui->ui_mutex);
 519         host->i_ctime = ubifs_current_time(host);
 520         host_ui->xattr_cnt -= 1;
 521         host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
 522         host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
 523         host_ui->xattr_names -= nm->len;
 524
 525         err = ubifs_jnl_delete_xattr(c, host, inode, nm);
 526         if (err)
 527                 goto out_cancel;
 528         mutex_unlock(&host_ui->ui_mutex);
 529
 530         ubifs_release_budget(c, &req);
 531         return 0;
 532
 533 out_cancel:
 534         host_ui->xattr_cnt += 1;
 535         host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
 536         host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
 537         host_ui->xattr_names += nm->len;
 538         mutex_unlock(&host_ui->ui_mutex);
 539         ubifs_release_budget(c, &req);
 540         make_bad_inode(inode);
 541         return err;
 542 }
 543
 544 int ubifs_removexattr(struct dentry *dentry, const char *name)
 545 {
 546         struct inode *inode, *host = d_inode(dentry);
 547         struct ubifs_info *c = host->i_sb->s_fs_info;
 548         struct qstr nm = QSTR_INIT(name, strlen(name));
 549         struct ubifs_dent_node *xent;
 550         union ubifs_key key;
 551         int err;
 552
 553         dbg_gen("xattr '%s', ino %lu ('%pd')", name,
 554                 host->i_ino, dentry);
 555         ubifs_assert(mutex_is_locked(&host->i_mutex));
 556
 557         err = check_namespace(&nm);
 558         if (err < 0)
 559                 return err;
 560
 561         xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
 562         if (!xent)
 563                 return -ENOMEM;
 564
 565         xent_key_init(c, &key, host->i_ino, &nm);
 566         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
 567         if (err) {
 568                 if (err == -ENOENT)
 569                         err = -ENODATA;
 570                 goto out_free;
 571         }
 572
 573         inode = iget_xattr(c, le64_to_cpu(xent->inum));
 574         if (IS_ERR(inode)) {
 575                 err = PTR_ERR(inode);
 576                 goto out_free;
 577         }
 578
 579         ubifs_assert(inode->i_nlink == 1);
 580         clear_nlink(inode);
 581         err = remove_xattr(c, host, inode, &nm);
 582         if (err)
 583                 set_nlink(inode, 1);
 584
 585         /* If @i_nlink is 0, 'iput()' will delete the inode */
 586         iput(inode);
 587
 588 out_free:
 589         kfree(xent);
 590         return err;
 591 }
 592
 593 static int init_xattrs(struct inode *inode, const struct xattr *xattr_array,
 594                       void *fs_info)
 595 {
 596         const struct xattr *xattr;
 597         char *name;
 598         int err = 0;
 599
 600         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 601                 name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
 602                                strlen(xattr->name) + 1, GFP_NOFS);
 603                 if (!name) {
 604                         err = -ENOMEM;
 605                         break;
 606                 }
 607                 strcpy(name, XATTR_SECURITY_PREFIX);
 608                 strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
 609                 err = setxattr(inode, name, xattr->value, xattr->value_len, 0);
 610                 kfree(name);
 611                 if (err < 0)
 612                         break;
 613         }
 614
 615         return err;
 616 }
 617
 618 int ubifs_init_security(struct inode *dentry, struct inode *inode,
 619                         const struct qstr *qstr)
 620 {
 621         int err;
 622
 623         err = security_inode_init_security(inode, dentry, qstr,
 624                                            &init_xattrs, 0);
 625         if (err) {
 626                 struct ubifs_info *c = dentry->i_sb->s_fs_info;
 627                 ubifs_err(c, "cannot initialize security for inode %lu, error %d",
 628                           inode->i_ino, err);
 629         }
 630         return err;
 631 }