fs/ubifs/xattr.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This file is part of UBIFS.
   4  *
   5  * Copyright (C) 2006-2008 Nokia Corporation.
   6  *
   7  * Authors: Artem Bityutskiy (Битюцкий Артём)
   8  *          Adrian Hunter
   9  */
  10
  11 /*
  12  * This file implements UBIFS extended attributes support.
  13  *
  14  * Extended attributes are implemented as regular inodes with attached data,
  15  * which limits extended attribute size to UBIFS block size (4KiB). Names of
  16  * extended attributes are described by extended attribute entries (xentries),
  17  * which are almost identical to directory entries, but have different key type.
  18  *
  19  * In other words, the situation with extended attributes is very similar to
  20  * directories. Indeed, any inode (but of course not xattr inodes) may have a
  21  * number of associated xentries, just like directory inodes have associated
  22  * directory entries. Extended attribute entries store the name of the extended
  23  * attribute, the host inode number, and the extended attribute inode number.
  24  * Similarly, direntries store the name, the parent and the target inode
  25  * numbers. Thus, most of the common UBIFS mechanisms may be re-used for
  26  * extended attributes.
  27  *
  28  * The number of extended attributes is not limited, but there is Linux
  29  * limitation on the maximum possible size of the list of all extended
  30  * attributes associated with an inode (%XATTR_LIST_MAX), so UBIFS makes sure
  31  * the sum of all extended attribute names of the inode does not exceed that
  32  * limit.
  33  *
  34  * Extended attributes are synchronous, which means they are written to the
  35  * flash media synchronously and there is no write-back for extended attribute
  36  * inodes. The extended attribute values are not stored in compressed form on
  37  * the media.
  38  *
  39  * Since extended attributes are represented by regular inodes, they are cached
  40  * in the VFS inode cache. The xentries are cached in the LNC cache (see
  41  * tnc.c).
  42  *
  43  * ACL support is not implemented.
  44  */
  45
  46 #include "ubifs.h"
  47 #include <linux/fs.h>
  48 #include <linux/slab.h>
  49 #include <linux/xattr.h>
  50
  51 /*
  52  * Extended attribute type constants.
  53  *
  54  * USER_XATTR: user extended attribute ("user.*")
  55  * TRUSTED_XATTR: trusted extended attribute ("trusted.*)
  56  * SECURITY_XATTR: security extended attribute ("security.*")
  57  */
  58 enum {
  59         USER_XATTR,
  60         TRUSTED_XATTR,
  61         SECURITY_XATTR,
  62 };
  63
  64 static const struct inode_operations empty_iops;
  65 static const struct file_operations empty_fops;
  66
  67 /**
  68  * create_xattr - create an extended attribute.
  69  * @c: UBIFS file-system description object
  70  * @host: host inode
  71  * @nm: extended attribute name
  72  * @value: extended attribute value
  73  * @size: size of extended attribute value
  74  *
  75  * This is a helper function which creates an extended attribute of name @nm
  76  * and value @value for inode @host. The host inode is also updated on flash
  77  * because the ctime and extended attribute accounting data changes. This
  78  * function returns zero in case of success and a negative error code in case
  79  * of failure.
  80  */
  81 static int create_xattr(struct ubifs_info *c, struct inode *host,
  82                         const struct fscrypt_name *nm, const void *value, int size)
  83 {
  84         int err, names_len;
  85         struct inode *inode;
  86         struct ubifs_inode *ui, *host_ui = ubifs_inode(host);
  87         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
  88                                 .new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
  89                                 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
  90
  91         if (host_ui->xattr_cnt >= ubifs_xattr_max_cnt(c)) {
  92                 ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
  93                           host->i_ino, host_ui->xattr_cnt);
  94                 return -ENOSPC;
  95         }
  96         /*
  97          * Linux limits the maximum size of the extended attribute names list
  98          * to %XATTR_LIST_MAX. This means we should not allow creating more
  99          * extended attributes if the name list becomes larger. This limitation
 100          * is artificial for UBIFS, though.
 101          */
 102         names_len = host_ui->xattr_names + host_ui->xattr_cnt + fname_len(nm) + 1;
 103         if (names_len > XATTR_LIST_MAX) {
 104                 ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
 105                           host->i_ino, names_len, XATTR_LIST_MAX);
 106                 return -ENOSPC;
 107         }
 108
 109         err = ubifs_budget_space(c, &req);
 110         if (err)
 111                 return err;
 112
 113         inode = ubifs_new_inode(c, host, S_IFREG | S_IRWXUGO);
 114         if (IS_ERR(inode)) {
 115                 err = PTR_ERR(inode);
 116                 goto out_budg;
 117         }
 118
 119         /* Re-define all operations to be "nothing" */
 120         inode->i_mapping->a_ops = &empty_aops;
 121         inode->i_op = &empty_iops;
 122         inode->i_fop = &empty_fops;
 123
 124         inode->i_flags |= S_SYNC | S_NOATIME | S_NOCMTIME;
 125         ui = ubifs_inode(inode);
 126         ui->xattr = 1;
 127         ui->flags |= UBIFS_XATTR_FL;
 128         ui->data = kmemdup(value, size, GFP_NOFS);
 129         if (!ui->data) {
 130                 err = -ENOMEM;
 131                 goto out_free;
 132         }
 133         inode->i_size = ui->ui_size = size;
 134         ui->data_len = size;
 135
 136         mutex_lock(&host_ui->ui_mutex);
 137         host->i_ctime = current_time(host);
 138         host_ui->xattr_cnt += 1;
 139         host_ui->xattr_size += CALC_DENT_SIZE(fname_len(nm));
 140         host_ui->xattr_size += CALC_XATTR_BYTES(size);
 141         host_ui->xattr_names += fname_len(nm);
 142
 143         /*
 144          * We handle UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT here because we
 145          * have to set the UBIFS_CRYPT_FL flag on the host inode.
 146          * To avoid multiple updates of the same inode in the same operation,
 147          * let's do it here.
 148          */
 149         if (strcmp(fname_name(nm), UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT) == 0)
 150                 host_ui->flags |= UBIFS_CRYPT_FL;
 151
 152         err = ubifs_jnl_update(c, host, nm, inode, 0, 1);
 153         if (err)
 154                 goto out_cancel;
 155         ubifs_set_inode_flags(host);
 156         mutex_unlock(&host_ui->ui_mutex);
 157
 158         ubifs_release_budget(c, &req);
 159         insert_inode_hash(inode);
 160         iput(inode);
 161         return 0;
 162
 163 out_cancel:
 164         host_ui->xattr_cnt -= 1;
 165         host_ui->xattr_size -= CALC_DENT_SIZE(fname_len(nm));
 166         host_ui->xattr_size -= CALC_XATTR_BYTES(size);
 167         host_ui->xattr_names -= fname_len(nm);
 168         host_ui->flags &= ~UBIFS_CRYPT_FL;
 169         mutex_unlock(&host_ui->ui_mutex);
 170 out_free:
 171         make_bad_inode(inode);
 172         iput(inode);
 173 out_budg:
 174         ubifs_release_budget(c, &req);
 175         return err;
 176 }
 177
 178 /**
 179  * change_xattr - change an extended attribute.
 180  * @c: UBIFS file-system description object
 181  * @host: host inode
 182  * @inode: extended attribute inode
 183  * @value: extended attribute value
 184  * @size: size of extended attribute value
 185  *
 186  * This helper function changes the value of extended attribute @inode with new
 187  * data from @value. Returns zero in case of success and a negative error code
 188  * in case of failure.
 189  */
 190 static int change_xattr(struct ubifs_info *c, struct inode *host,
 191                         struct inode *inode, const void *value, int size)
 192 {
 193         int err;
 194         struct ubifs_inode *host_ui = ubifs_inode(host);
 195         struct ubifs_inode *ui = ubifs_inode(inode);
 196         void *buf = NULL;
 197         int old_size;
 198         struct ubifs_budget_req req = { .dirtied_ino = 2,
 199                 .dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
 200
 201         ubifs_assert(c, ui->data_len == inode->i_size);
 202         err = ubifs_budget_space(c, &req);
 203         if (err)
 204                 return err;
 205
 206         buf = kmemdup(value, size, GFP_NOFS);
 207         if (!buf) {
 208                 err = -ENOMEM;
 209                 goto out_free;
 210         }
 211         mutex_lock(&ui->ui_mutex);
 212         kfree(ui->data);
 213         ui->data = buf;
 214         inode->i_size = ui->ui_size = size;
 215         old_size = ui->data_len;
 216         ui->data_len = size;
 217         mutex_unlock(&ui->ui_mutex);
 218
 219         mutex_lock(&host_ui->ui_mutex);
 220         host->i_ctime = current_time(host);
 221         host_ui->xattr_size -= CALC_XATTR_BYTES(old_size);
 222         host_ui->xattr_size += CALC_XATTR_BYTES(size);
 223
 224         /*
 225          * It is important to write the host inode after the xattr inode
 226          * because if the host inode gets synchronized (via 'fsync()'), then
 227          * the extended attribute inode gets synchronized, because it goes
 228          * before the host inode in the write-buffer.
 229          */
 230         err = ubifs_jnl_change_xattr(c, inode, host);
 231         if (err)
 232                 goto out_cancel;
 233         mutex_unlock(&host_ui->ui_mutex);
 234
 235         ubifs_release_budget(c, &req);
 236         return 0;
 237
 238 out_cancel:
 239         host_ui->xattr_size -= CALC_XATTR_BYTES(size);
 240         host_ui->xattr_size += CALC_XATTR_BYTES(old_size);
 241         mutex_unlock(&host_ui->ui_mutex);
 242         make_bad_inode(inode);
 243 out_free:
 244         ubifs_release_budget(c, &req);
 245         return err;
 246 }
 247
 248 static struct inode *iget_xattr(struct ubifs_info *c, ino_t inum)
 249 {
 250         struct inode *inode;
 251
 252         inode = ubifs_iget(c->vfs_sb, inum);
 253         if (IS_ERR(inode)) {
 254                 ubifs_err(c, "dead extended attribute entry, error %d",
 255                           (int)PTR_ERR(inode));
 256                 return inode;
 257         }
 258         if (ubifs_inode(inode)->xattr)
 259                 return inode;
 260         ubifs_err(c, "corrupt extended attribute entry");
 261         iput(inode);
 262         return ERR_PTR(-EINVAL);
 263 }
 264
 265 int ubifs_xattr_set(struct inode *host, const char *name, const void *value,
 266                     size_t size, int flags, bool check_lock)
 267 {
 268         struct inode *inode;
 269         struct ubifs_info *c = host->i_sb->s_fs_info;
 270         struct fscrypt_name nm = { .disk_name = FSTR_INIT((char *)name, strlen(name))};
 271         struct ubifs_dent_node *xent;
 272         union ubifs_key key;
 273         int err;
 274
 275         if (check_lock)
 276                 ubifs_assert(c, inode_is_locked(host));
 277
 278         if (size > UBIFS_MAX_INO_DATA)
 279                 return -ERANGE;
 280
 281         if (fname_len(&nm) > UBIFS_MAX_NLEN)
 282                 return -ENAMETOOLONG;
 283
 284         xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
 285         if (!xent)
 286                 return -ENOMEM;
 287
 288         down_write(&ubifs_inode(host)->xattr_sem);
 289         /*
 290          * The extended attribute entries are stored in LNC, so multiple
 291          * look-ups do not involve reading the flash.
 292          */
 293         xent_key_init(c, &key, host->i_ino, &nm);
 294         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
 295         if (err) {
 296                 if (err != -ENOENT)
 297                         goto out_free;
 298
 299                 if (flags & XATTR_REPLACE)
 300                         /* We are asked not to create the xattr */
 301                         err = -ENODATA;
 302                 else
 303                         err = create_xattr(c, host, &nm, value, size);
 304                 goto out_free;
 305         }
 306
 307         if (flags & XATTR_CREATE) {
 308                 /* We are asked not to replace the xattr */
 309                 err = -EEXIST;
 310                 goto out_free;
 311         }
 312
 313         inode = iget_xattr(c, le64_to_cpu(xent->inum));
 314         if (IS_ERR(inode)) {
 315                 err = PTR_ERR(inode);
 316                 goto out_free;
 317         }
 318
 319         err = change_xattr(c, host, inode, value, size);
 320         iput(inode);
 321
 322 out_free:
 323         up_write(&ubifs_inode(host)->xattr_sem);
 324         kfree(xent);
 325         return err;
 326 }
 327
 328 ssize_t ubifs_xattr_get(struct inode *host, const char *name, void *buf,
 329                         size_t size)
 330 {
 331         struct inode *inode;
 332         struct ubifs_info *c = host->i_sb->s_fs_info;
 333         struct fscrypt_name nm = { .disk_name = FSTR_INIT((char *)name, strlen(name))};
 334         struct ubifs_inode *ui;
 335         struct ubifs_dent_node *xent;
 336         union ubifs_key key;
 337         int err;
 338
 339         if (fname_len(&nm) > UBIFS_MAX_NLEN)
 340                 return -ENAMETOOLONG;
 341
 342         xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
 343         if (!xent)
 344                 return -ENOMEM;
 345
 346         down_read(&ubifs_inode(host)->xattr_sem);
 347         xent_key_init(c, &key, host->i_ino, &nm);
 348         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
 349         if (err) {
 350                 if (err == -ENOENT)
 351                         err = -ENODATA;
 352                 goto out_cleanup;
 353         }
 354
 355         inode = iget_xattr(c, le64_to_cpu(xent->inum));
 356         if (IS_ERR(inode)) {
 357                 err = PTR_ERR(inode);
 358                 goto out_cleanup;
 359         }
 360
 361         ui = ubifs_inode(inode);
 362         ubifs_assert(c, inode->i_size == ui->data_len);
 363         ubifs_assert(c, ubifs_inode(host)->xattr_size > ui->data_len);
 364
 365         mutex_lock(&ui->ui_mutex);
 366         if (buf) {
 367                 /* If @buf is %NULL we are supposed to return the length */
 368                 if (ui->data_len > size) {
 369                         err = -ERANGE;
 370                         goto out_iput;
 371                 }
 372
 373                 memcpy(buf, ui->data, ui->data_len);
 374         }
 375         err = ui->data_len;
 376
 377 out_iput:
 378         mutex_unlock(&ui->ui_mutex);
 379         iput(inode);
 380 out_cleanup:
 381         up_read(&ubifs_inode(host)->xattr_sem);
 382         kfree(xent);
 383         return err;
 384 }
 385
 386 static bool xattr_visible(const char *name)
 387 {
 388         /* File encryption related xattrs are for internal use only */
 389         if (strcmp(name, UBIFS_XATTR_NAME_ENCRYPTION_CONTEXT) == 0)
 390                 return false;
 391
 392         /* Show trusted namespace only for "power" users */
 393         if (strncmp(name, XATTR_TRUSTED_PREFIX,
 394                     XATTR_TRUSTED_PREFIX_LEN) == 0 && !capable(CAP_SYS_ADMIN))
 395                 return false;
 396
 397         return true;
 398 }
 399
 400 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 401 {
 402         union ubifs_key key;
 403         struct inode *host = d_inode(dentry);
 404         struct ubifs_info *c = host->i_sb->s_fs_info;
 405         struct ubifs_inode *host_ui = ubifs_inode(host);
 406         struct ubifs_dent_node *xent, *pxent = NULL;
 407         int err, len, written = 0;
 408         struct fscrypt_name nm = {0};
 409
 410         dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino,
 411                 dentry, size);
 412
 413         down_read(&host_ui->xattr_sem);
 414         len = host_ui->xattr_names + host_ui->xattr_cnt;
 415         if (!buffer) {
 416                 /*
 417                  * We should return the minimum buffer size which will fit a
 418                  * null-terminated list of all the extended attribute names.
 419                  */
 420                 err = len;
 421                 goto out_err;
 422         }
 423
 424         if (len > size) {
 425                 err = -ERANGE;
 426                 goto out_err;
 427         }
 428
 429         lowest_xent_key(c, &key, host->i_ino);
 430         while (1) {
 431                 xent = ubifs_tnc_next_ent(c, &key, &nm);
 432                 if (IS_ERR(xent)) {
 433                         err = PTR_ERR(xent);
 434                         break;
 435                 }
 436
 437                 fname_name(&nm) = xent->name;
 438                 fname_len(&nm) = le16_to_cpu(xent->nlen);
 439
 440                 if (xattr_visible(xent->name)) {
 441                         memcpy(buffer + written, fname_name(&nm), fname_len(&nm) + 1);
 442                         written += fname_len(&nm) + 1;
 443                 }
 444
 445                 kfree(pxent);
 446                 pxent = xent;
 447                 key_read(c, &xent->key, &key);
 448         }
 449         kfree(pxent);
 450         up_read(&host_ui->xattr_sem);
 451
 452         if (err != -ENOENT) {
 453                 ubifs_err(c, "cannot find next direntry, error %d", err);
 454                 return err;
 455         }
 456
 457         ubifs_assert(c, written <= size);
 458         return written;
 459
 460 out_err:
 461         up_read(&host_ui->xattr_sem);
 462         return err;
 463 }
 464
 465 static int remove_xattr(struct ubifs_info *c, struct inode *host,
 466                         struct inode *inode, const struct fscrypt_name *nm)
 467 {
 468         int err;
 469         struct ubifs_inode *host_ui = ubifs_inode(host);
 470         struct ubifs_inode *ui = ubifs_inode(inode);
 471         struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
 472                                 .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
 473
 474         ubifs_assert(c, ui->data_len == inode->i_size);
 475
 476         err = ubifs_budget_space(c, &req);
 477         if (err)
 478                 return err;
 479
 480         mutex_lock(&host_ui->ui_mutex);
 481         host->i_ctime = current_time(host);
 482         host_ui->xattr_cnt -= 1;
 483         host_ui->xattr_size -= CALC_DENT_SIZE(fname_len(nm));
 484         host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
 485         host_ui->xattr_names -= fname_len(nm);
 486
 487         err = ubifs_jnl_delete_xattr(c, host, inode, nm);
 488         if (err)
 489                 goto out_cancel;
 490         mutex_unlock(&host_ui->ui_mutex);
 491
 492         ubifs_release_budget(c, &req);
 493         return 0;
 494
 495 out_cancel:
 496         host_ui->xattr_cnt += 1;
 497         host_ui->xattr_size += CALC_DENT_SIZE(fname_len(nm));
 498         host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
 499         host_ui->xattr_names += fname_len(nm);
 500         mutex_unlock(&host_ui->ui_mutex);
 501         ubifs_release_budget(c, &req);
 502         make_bad_inode(inode);
 503         return err;
 504 }
 505
 506 int ubifs_purge_xattrs(struct inode *host)
 507 {
 508         union ubifs_key key;
 509         struct ubifs_info *c = host->i_sb->s_fs_info;
 510         struct ubifs_dent_node *xent, *pxent = NULL;
 511         struct inode *xino;
 512         struct fscrypt_name nm = {0};
 513         int err;
 514
 515         if (ubifs_inode(host)->xattr_cnt <= ubifs_xattr_max_cnt(c))
 516                 return 0;
 517
 518         ubifs_warn(c, "inode %lu has too many xattrs, doing a non-atomic deletion",
 519                    host->i_ino);
 520
 521         down_write(&ubifs_inode(host)->xattr_sem);
 522         lowest_xent_key(c, &key, host->i_ino);
 523         while (1) {
 524                 xent = ubifs_tnc_next_ent(c, &key, &nm);
 525                 if (IS_ERR(xent)) {
 526                         err = PTR_ERR(xent);
 527                         break;
 528                 }
 529
 530                 fname_name(&nm) = xent->name;
 531                 fname_len(&nm) = le16_to_cpu(xent->nlen);
 532
 533                 xino = ubifs_iget(c->vfs_sb, le64_to_cpu(xent->inum));
 534                 if (IS_ERR(xino)) {
 535                         err = PTR_ERR(xino);
 536                         ubifs_err(c, "dead directory entry '%s', error %d",
 537                                   xent->name, err);
 538                         ubifs_ro_mode(c, err);
 539                         kfree(pxent);
 540                         kfree(xent);
 541                         goto out_err;
 542                 }
 543
 544                 ubifs_assert(c, ubifs_inode(xino)->xattr);
 545
 546                 clear_nlink(xino);
 547                 err = remove_xattr(c, host, xino, &nm);
 548                 if (err) {
 549                         kfree(pxent);
 550                         kfree(xent);
 551                         iput(xino);
 552                         ubifs_err(c, "cannot remove xattr, error %d", err);
 553                         goto out_err;
 554                 }
 555
 556                 iput(xino);
 557
 558                 kfree(pxent);
 559                 pxent = xent;
 560                 key_read(c, &xent->key, &key);
 561         }
 562         kfree(pxent);
 563         up_write(&ubifs_inode(host)->xattr_sem);
 564
 565         if (err != -ENOENT) {
 566                 ubifs_err(c, "cannot find next direntry, error %d", err);
 567                 return err;
 568         }
 569
 570         return 0;
 571
 572 out_err:
 573         up_write(&ubifs_inode(host)->xattr_sem);
 574         return err;
 575 }
 576
 577 /**
 578  * ubifs_evict_xattr_inode - Evict an xattr inode.
 579  * @c: UBIFS file-system description object
 580  * @xattr_inum: xattr inode number
 581  *
 582  * When an inode that hosts xattrs is being removed we have to make sure
 583  * that cached inodes of the xattrs also get removed from the inode cache
 584  * otherwise we'd waste memory. This function looks up an inode from the
 585  * inode cache and clears the link counter such that iput() will evict
 586  * the inode.
 587  */
 588 void ubifs_evict_xattr_inode(struct ubifs_info *c, ino_t xattr_inum)
 589 {
 590         struct inode *inode;
 591
 592         inode = ilookup(c->vfs_sb, xattr_inum);
 593         if (inode) {
 594                 clear_nlink(inode);
 595                 iput(inode);
 596         }
 597 }
 598
 599 static int ubifs_xattr_remove(struct inode *host, const char *name)
 600 {
 601         struct inode *inode;
 602         struct ubifs_info *c = host->i_sb->s_fs_info;
 603         struct fscrypt_name nm = { .disk_name = FSTR_INIT((char *)name, strlen(name))};
 604         struct ubifs_dent_node *xent;
 605         union ubifs_key key;
 606         int err;
 607
 608         ubifs_assert(c, inode_is_locked(host));
 609
 610         if (fname_len(&nm) > UBIFS_MAX_NLEN)
 611                 return -ENAMETOOLONG;
 612
 613         xent = kmalloc(UBIFS_MAX_XENT_NODE_SZ, GFP_NOFS);
 614         if (!xent)
 615                 return -ENOMEM;
 616
 617         down_write(&ubifs_inode(host)->xattr_sem);
 618         xent_key_init(c, &key, host->i_ino, &nm);
 619         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
 620         if (err) {
 621                 if (err == -ENOENT)
 622                         err = -ENODATA;
 623                 goto out_free;
 624         }
 625
 626         inode = iget_xattr(c, le64_to_cpu(xent->inum));
 627         if (IS_ERR(inode)) {
 628                 err = PTR_ERR(inode);
 629                 goto out_free;
 630         }
 631
 632         ubifs_assert(c, inode->i_nlink == 1);
 633         clear_nlink(inode);
 634         err = remove_xattr(c, host, inode, &nm);
 635         if (err)
 636                 set_nlink(inode, 1);
 637
 638         /* If @i_nlink is 0, 'iput()' will delete the inode */
 639         iput(inode);
 640
 641 out_free:
 642         up_write(&ubifs_inode(host)->xattr_sem);
 643         kfree(xent);
 644         return err;
 645 }
 646
 647 #ifdef CONFIG_UBIFS_FS_SECURITY
 648 static int init_xattrs(struct inode *inode, const struct xattr *xattr_array,
 649                       void *fs_info)
 650 {
 651         const struct xattr *xattr;
 652         char *name;
 653         int err = 0;
 654
 655         for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 656                 name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
 657                                strlen(xattr->name) + 1, GFP_NOFS);
 658                 if (!name) {
 659                         err = -ENOMEM;
 660                         break;
 661                 }
 662                 strcpy(name, XATTR_SECURITY_PREFIX);
 663                 strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
 664                 /*
 665                  * creating a new inode without holding the inode rwsem,
 666                  * no need to check whether inode is locked.
 667                  */
 668                 err = ubifs_xattr_set(inode, name, xattr->value,
 669                                       xattr->value_len, 0, false);
 670                 kfree(name);
 671                 if (err < 0)
 672                         break;
 673         }
 674
 675         return err;
 676 }
 677
 678 int ubifs_init_security(struct inode *dentry, struct inode *inode,
 679                         const struct qstr *qstr)
 680 {
 681         int err;
 682
 683         err = security_inode_init_security(inode, dentry, qstr,
 684                                            &init_xattrs, 0);
 685         if (err) {
 686                 struct ubifs_info *c = dentry->i_sb->s_fs_info;
 687                 ubifs_err(c, "cannot initialize security for inode %lu, error %d",
 688                           inode->i_ino, err);
 689         }
 690         return err;
 691 }
 692 #endif
 693
 694 static int xattr_get(const struct xattr_handler *handler,
 695                            struct dentry *dentry, struct inode *inode,
 696                            const char *name, void *buffer, size_t size)
 697 {
 698         dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name,
 699                 inode->i_ino, dentry, size);
 700
 701         name = xattr_full_name(handler, name);
 702         return ubifs_xattr_get(inode, name, buffer, size);
 703 }
 704
 705 static int xattr_set(const struct xattr_handler *handler,
 706                            struct dentry *dentry, struct inode *inode,
 707                            const char *name, const void *value,
 708                            size_t size, int flags)
 709 {
 710         dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
 711                 name, inode->i_ino, dentry, size);
 712
 713         name = xattr_full_name(handler, name);
 714
 715         if (value)
 716                 return ubifs_xattr_set(inode, name, value, size, flags, true);
 717         else
 718                 return ubifs_xattr_remove(inode, name);
 719 }
 720
 721 static const struct xattr_handler ubifs_user_xattr_handler = {
 722         .prefix = XATTR_USER_PREFIX,
 723         .get = xattr_get,
 724         .set = xattr_set,
 725 };
 726
 727 static const struct xattr_handler ubifs_trusted_xattr_handler = {
 728         .prefix = XATTR_TRUSTED_PREFIX,
 729         .get = xattr_get,
 730         .set = xattr_set,
 731 };
 732
 733 #ifdef CONFIG_UBIFS_FS_SECURITY
 734 static const struct xattr_handler ubifs_security_xattr_handler = {
 735         .prefix = XATTR_SECURITY_PREFIX,
 736         .get = xattr_get,
 737         .set = xattr_set,
 738 };
 739 #endif
 740
 741 const struct xattr_handler *ubifs_xattr_handlers[] = {
 742         &ubifs_user_xattr_handler,
 743         &ubifs_trusted_xattr_handler,
 744 #ifdef CONFIG_UBIFS_FS_SECURITY
 745         &ubifs_security_xattr_handler,
 746 #endif
 747         NULL
 748 };