fs/ubifs/dir.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* * This file is part of UBIFS.
   3  *
   4  * Copyright (C) 2006-2008 Nokia Corporation.
   5  * Copyright (C) 2006, 2007 University of Szeged, Hungary
   6  *
   7  * Authors: Artem Bityutskiy (Битюцкий Артём)
   8  *          Adrian Hunter
   9  *          Zoltan Sogor
  10  */
  11
  12 /*
  13  * This file implements directory operations.
  14  *
  15  * All FS operations in this file allocate budget before writing anything to the
  16  * media. If they fail to allocate it, the error is returned. The only
  17  * exceptions are 'ubifs_unlink()' and 'ubifs_rmdir()' which keep working even
  18  * if they unable to allocate the budget, because deletion %-ENOSPC failure is
  19  * not what users are usually ready to get. UBIFS budgeting subsystem has some
  20  * space reserved for these purposes.
  21  *
  22  * All operations in this file write all inodes which they change straight
  23  * away, instead of marking them dirty. For example, 'ubifs_link()' changes
  24  * @i_size of the parent inode and writes the parent inode together with the
  25  * target inode. This was done to simplify file-system recovery which would
  26  * otherwise be very difficult to do. The only exception is rename which marks
  27  * the re-named inode dirty (because its @i_ctime is updated) but does not
  28  * write it, but just marks it as dirty.
  29  */
  30
  31 #include "ubifs.h"
  32
  33 /**
  34  * inherit_flags - inherit flags of the parent inode.
  35  * @dir: parent inode
  36  * @mode: new inode mode flags
  37  *
  38  * This is a helper function for 'ubifs_new_inode()' which inherits flag of the
  39  * parent directory inode @dir. UBIFS inodes inherit the following flags:
  40  * o %UBIFS_COMPR_FL, which is useful to switch compression on/of on
  41  *   sub-directory basis;
  42  * o %UBIFS_SYNC_FL - useful for the same reasons;
  43  * o %UBIFS_DIRSYNC_FL - similar, but relevant only to directories.
  44  *
  45  * This function returns the inherited flags.
  46  */
  47 static int inherit_flags(const struct inode *dir, umode_t mode)
  48 {
  49         int flags;
  50         const struct ubifs_inode *ui = ubifs_inode(dir);
  51
  52         if (!S_ISDIR(dir->i_mode))
  53                 /*
  54                  * The parent is not a directory, which means that an extended
  55                  * attribute inode is being created. No flags.
  56                  */
  57                 return 0;
  58
  59         flags = ui->flags & (UBIFS_COMPR_FL | UBIFS_SYNC_FL | UBIFS_DIRSYNC_FL);
  60         if (!S_ISDIR(mode))
  61                 /* The "DIRSYNC" flag only applies to directories */
  62                 flags &= ~UBIFS_DIRSYNC_FL;
  63         return flags;
  64 }
  65
  66 /**
  67  * ubifs_new_inode - allocate new UBIFS inode object.
  68  * @c: UBIFS file-system description object
  69  * @dir: parent directory inode
  70  * @mode: inode mode flags
  71  * @is_xattr: whether the inode is xattr inode
  72  *
  73  * This function finds an unused inode number, allocates new inode and
  74  * initializes it. Returns new inode in case of success and an error code in
  75  * case of failure.
  76  */
  77 struct inode *ubifs_new_inode(struct ubifs_info *c, struct inode *dir,
  78                               umode_t mode, bool is_xattr)
  79 {
  80         int err;
  81         struct inode *inode;
  82         struct ubifs_inode *ui;
  83         bool encrypted = false;
  84
  85         inode = new_inode(c->vfs_sb);
  86         ui = ubifs_inode(inode);
  87         if (!inode)
  88                 return ERR_PTR(-ENOMEM);
  89
  90         /*
  91          * Set 'S_NOCMTIME' to prevent VFS form updating [mc]time of inodes and
  92          * marking them dirty in file write path (see 'file_update_time()').
  93          * UBIFS has to fully control "clean <-> dirty" transitions of inodes
  94          * to make budgeting work.
  95          */
  96         inode->i_flags |= S_NOCMTIME;
  97
  98         inode_init_owner(&init_user_ns, inode, dir, mode);
  99         inode->i_mtime = inode->i_atime = inode->i_ctime =
 100                          current_time(inode);
 101         inode->i_mapping->nrpages = 0;
 102
 103         if (!is_xattr) {
 104                 err = fscrypt_prepare_new_inode(dir, inode, &encrypted);
 105                 if (err) {
 106                         ubifs_err(c, "fscrypt_prepare_new_inode failed: %i", err);
 107                         goto out_iput;
 108                 }
 109         }
 110
 111         switch (mode & S_IFMT) {
 112         case S_IFREG:
 113                 inode->i_mapping->a_ops = &ubifs_file_address_operations;
 114                 inode->i_op = &ubifs_file_inode_operations;
 115                 inode->i_fop = &ubifs_file_operations;
 116                 break;
 117         case S_IFDIR:
 118                 inode->i_op  = &ubifs_dir_inode_operations;
 119                 inode->i_fop = &ubifs_dir_operations;
 120                 inode->i_size = ui->ui_size = UBIFS_INO_NODE_SZ;
 121                 break;
 122         case S_IFLNK:
 123                 inode->i_op = &ubifs_symlink_inode_operations;
 124                 break;
 125         case S_IFSOCK:
 126         case S_IFIFO:
 127         case S_IFBLK:
 128         case S_IFCHR:
 129                 inode->i_op  = &ubifs_file_inode_operations;
 130                 break;
 131         default:
 132                 BUG();
 133         }
 134
 135         ui->flags = inherit_flags(dir, mode);
 136         ubifs_set_inode_flags(inode);
 137         if (S_ISREG(mode))
 138                 ui->compr_type = c->default_compr;
 139         else
 140                 ui->compr_type = UBIFS_COMPR_NONE;
 141         ui->synced_i_size = 0;
 142
 143         spin_lock(&c->cnt_lock);
 144         /* Inode number overflow is currently not supported */
 145         if (c->highest_inum >= INUM_WARN_WATERMARK) {
 146                 if (c->highest_inum >= INUM_WATERMARK) {
 147                         spin_unlock(&c->cnt_lock);
 148                         ubifs_err(c, "out of inode numbers");
 149                         err = -EINVAL;
 150                         goto out_iput;
 151                 }
 152                 ubifs_warn(c, "running out of inode numbers (current %lu, max %u)",
 153                            (unsigned long)c->highest_inum, INUM_WATERMARK);
 154         }
 155
 156         inode->i_ino = ++c->highest_inum;
 157         /*
 158          * The creation sequence number remains with this inode for its
 159          * lifetime. All nodes for this inode have a greater sequence number,
 160          * and so it is possible to distinguish obsolete nodes belonging to a
 161          * previous incarnation of the same inode number - for example, for the
 162          * purpose of rebuilding the index.
 163          */
 164         ui->creat_sqnum = ++c->max_sqnum;
 165         spin_unlock(&c->cnt_lock);
 166
 167         if (encrypted) {
 168                 err = fscrypt_set_context(inode, NULL);
 169                 if (err) {
 170                         ubifs_err(c, "fscrypt_set_context failed: %i", err);
 171                         goto out_iput;
 172                 }
 173         }
 174
 175         return inode;
 176
 177 out_iput:
 178         make_bad_inode(inode);
 179         iput(inode);
 180         return ERR_PTR(err);
 181 }
 182
 183 static int dbg_check_name(const struct ubifs_info *c,
 184                           const struct ubifs_dent_node *dent,
 185                           const struct fscrypt_name *nm)
 186 {
 187         if (!dbg_is_chk_gen(c))
 188                 return 0;
 189         if (le16_to_cpu(dent->nlen) != fname_len(nm))
 190                 return -EINVAL;
 191         if (memcmp(dent->name, fname_name(nm), fname_len(nm)))
 192                 return -EINVAL;
 193         return 0;
 194 }
 195
 196 static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
 197                                    unsigned int flags)
 198 {
 199         int err;
 200         union ubifs_key key;
 201         struct inode *inode = NULL;
 202         struct ubifs_dent_node *dent = NULL;
 203         struct ubifs_info *c = dir->i_sb->s_fs_info;
 204         struct fscrypt_name nm;
 205
 206         dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
 207
 208         err = fscrypt_prepare_lookup(dir, dentry, &nm);
 209         generic_set_encrypted_ci_d_ops(dentry);
 210         if (err == -ENOENT)
 211                 return d_splice_alias(NULL, dentry);
 212         if (err)
 213                 return ERR_PTR(err);
 214
 215         if (fname_len(&nm) > UBIFS_MAX_NLEN) {
 216                 inode = ERR_PTR(-ENAMETOOLONG);
 217                 goto done;
 218         }
 219
 220         dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
 221         if (!dent) {
 222                 inode = ERR_PTR(-ENOMEM);
 223                 goto done;
 224         }
 225
 226         if (fname_name(&nm) == NULL) {
 227                 if (nm.hash & ~UBIFS_S_KEY_HASH_MASK)
 228                         goto done; /* ENOENT */
 229                 dent_key_init_hash(c, &key, dir->i_ino, nm.hash);
 230                 err = ubifs_tnc_lookup_dh(c, &key, dent, nm.minor_hash);
 231         } else {
 232                 dent_key_init(c, &key, dir->i_ino, &nm);
 233                 err = ubifs_tnc_lookup_nm(c, &key, dent, &nm);
 234         }
 235
 236         if (err) {
 237                 if (err == -ENOENT)
 238                         dbg_gen("not found");
 239                 else
 240                         inode = ERR_PTR(err);
 241                 goto done;
 242         }
 243
 244         if (dbg_check_name(c, dent, &nm)) {
 245                 inode = ERR_PTR(-EINVAL);
 246                 goto done;
 247         }
 248
 249         inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
 250         if (IS_ERR(inode)) {
 251                 /*
 252                  * This should not happen. Probably the file-system needs
 253                  * checking.
 254                  */
 255                 err = PTR_ERR(inode);
 256                 ubifs_err(c, "dead directory entry '%pd', error %d",
 257                           dentry, err);
 258                 ubifs_ro_mode(c, err);
 259                 goto done;
 260         }
 261
 262         if (IS_ENCRYPTED(dir) &&
 263             (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
 264             !fscrypt_has_permitted_context(dir, inode)) {
 265                 ubifs_warn(c, "Inconsistent encryption contexts: %lu/%lu",
 266                            dir->i_ino, inode->i_ino);
 267                 iput(inode);
 268                 inode = ERR_PTR(-EPERM);
 269         }
 270
 271 done:
 272         kfree(dent);
 273         fscrypt_free_filename(&nm);
 274         return d_splice_alias(inode, dentry);
 275 }
 276
 277 static int ubifs_prepare_create(struct inode *dir, struct dentry *dentry,
 278                                 struct fscrypt_name *nm)
 279 {
 280         if (fscrypt_is_nokey_name(dentry))
 281                 return -ENOKEY;
 282
 283         return fscrypt_setup_filename(dir, &dentry->d_name, 0, nm);
 284 }
 285
 286 static int ubifs_create(struct user_namespace *mnt_userns, struct inode *dir,
 287                         struct dentry *dentry, umode_t mode, bool excl)
 288 {
 289         struct inode *inode;
 290         struct ubifs_info *c = dir->i_sb->s_fs_info;
 291         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
 292                                         .dirtied_ino = 1 };
 293         struct ubifs_inode *dir_ui = ubifs_inode(dir);
 294         struct fscrypt_name nm;
 295         int err, sz_change;
 296
 297         /*
 298          * Budget request settings: new inode, new direntry, changing the
 299          * parent directory inode.
 300          */
 301
 302         dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
 303                 dentry, mode, dir->i_ino);
 304
 305         err = ubifs_budget_space(c, &req);
 306         if (err)
 307                 return err;
 308
 309         err = ubifs_prepare_create(dir, dentry, &nm);
 310         if (err)
 311                 goto out_budg;
 312
 313         sz_change = CALC_DENT_SIZE(fname_len(&nm));
 314
 315         inode = ubifs_new_inode(c, dir, mode, false);
 316         if (IS_ERR(inode)) {
 317                 err = PTR_ERR(inode);
 318                 goto out_fname;
 319         }
 320
 321         err = ubifs_init_security(dir, inode, &dentry->d_name);
 322         if (err)
 323                 goto out_inode;
 324
 325         mutex_lock(&dir_ui->ui_mutex);
 326         dir->i_size += sz_change;
 327         dir_ui->ui_size = dir->i_size;
 328         dir->i_mtime = dir->i_ctime = inode->i_ctime;
 329         err = ubifs_jnl_update(c, dir, &nm, inode, 0, 0);
 330         if (err)
 331                 goto out_cancel;
 332         mutex_unlock(&dir_ui->ui_mutex);
 333
 334         ubifs_release_budget(c, &req);
 335         fscrypt_free_filename(&nm);
 336         insert_inode_hash(inode);
 337         d_instantiate(dentry, inode);
 338         return 0;
 339
 340 out_cancel:
 341         dir->i_size -= sz_change;
 342         dir_ui->ui_size = dir->i_size;
 343         mutex_unlock(&dir_ui->ui_mutex);
 344 out_inode:
 345         make_bad_inode(inode);
 346         iput(inode);
 347 out_fname:
 348         fscrypt_free_filename(&nm);
 349 out_budg:
 350         ubifs_release_budget(c, &req);
 351         ubifs_err(c, "cannot create regular file, error %d", err);
 352         return err;
 353 }
 354
 355 static struct inode *create_whiteout(struct inode *dir, struct dentry *dentry)
 356 {
 357         int err;
 358         umode_t mode = S_IFCHR | WHITEOUT_MODE;
 359         struct inode *inode;
 360         struct ubifs_info *c = dir->i_sb->s_fs_info;
 361
 362         /*
 363          * Create an inode('nlink = 1') for whiteout without updating journal,
 364          * let ubifs_jnl_rename() store it on flash to complete rename whiteout
 365          * atomically.
 366          */
 367
 368         dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
 369                 dentry, mode, dir->i_ino);
 370
 371         inode = ubifs_new_inode(c, dir, mode, false);
 372         if (IS_ERR(inode)) {
 373                 err = PTR_ERR(inode);
 374                 goto out_free;
 375         }
 376
 377         init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
 378         ubifs_assert(c, inode->i_op == &ubifs_file_inode_operations);
 379
 380         err = ubifs_init_security(dir, inode, &dentry->d_name);
 381         if (err)
 382                 goto out_inode;
 383
 384         /* The dir size is updated by do_rename. */
 385         insert_inode_hash(inode);
 386
 387         return inode;
 388
 389 out_inode:
 390         make_bad_inode(inode);
 391         iput(inode);
 392 out_free:
 393         ubifs_err(c, "cannot create whiteout file, error %d", err);
 394         return ERR_PTR(err);
 395 }
 396
 397 /**
 398  * lock_2_inodes - a wrapper for locking two UBIFS inodes.
 399  * @inode1: first inode
 400  * @inode2: second inode
 401  *
 402  * We do not implement any tricks to guarantee strict lock ordering, because
 403  * VFS has already done it for us on the @i_mutex. So this is just a simple
 404  * wrapper function.
 405  */
 406 static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
 407 {
 408         mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
 409         mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
 410 }
 411
 412 /**
 413  * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
 414  * @inode1: first inode
 415  * @inode2: second inode
 416  */
 417 static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
 418 {
 419         mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
 420         mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
 421 }
 422
 423 static int ubifs_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
 424                          struct dentry *dentry, umode_t mode)
 425 {
 426         struct inode *inode;
 427         struct ubifs_info *c = dir->i_sb->s_fs_info;
 428         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
 429                                         .dirtied_ino = 1};
 430         struct ubifs_budget_req ino_req = { .dirtied_ino = 1 };
 431         struct ubifs_inode *ui;
 432         int err, instantiated = 0;
 433         struct fscrypt_name nm;
 434
 435         /*
 436          * Budget request settings: new inode, new direntry, changing the
 437          * parent directory inode.
 438          * Allocate budget separately for new dirtied inode, the budget will
 439          * be released via writeback.
 440          */
 441
 442         dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
 443                 dentry, mode, dir->i_ino);
 444
 445         err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm);
 446         if (err)
 447                 return err;
 448
 449         err = ubifs_budget_space(c, &req);
 450         if (err) {
 451                 fscrypt_free_filename(&nm);
 452                 return err;
 453         }
 454
 455         err = ubifs_budget_space(c, &ino_req);
 456         if (err) {
 457                 ubifs_release_budget(c, &req);
 458                 fscrypt_free_filename(&nm);
 459                 return err;
 460         }
 461
 462         inode = ubifs_new_inode(c, dir, mode, false);
 463         if (IS_ERR(inode)) {
 464                 err = PTR_ERR(inode);
 465                 goto out_budg;
 466         }
 467         ui = ubifs_inode(inode);
 468
 469         err = ubifs_init_security(dir, inode, &dentry->d_name);
 470         if (err)
 471                 goto out_inode;
 472
 473         mutex_lock(&ui->ui_mutex);
 474         insert_inode_hash(inode);
 475         d_tmpfile(dentry, inode);
 476         ubifs_assert(c, ui->dirty);
 477
 478         instantiated = 1;
 479         mutex_unlock(&ui->ui_mutex);
 480
 481         lock_2_inodes(dir, inode);
 482         err = ubifs_jnl_update(c, dir, &nm, inode, 1, 0);
 483         if (err)
 484                 goto out_cancel;
 485         unlock_2_inodes(dir, inode);
 486
 487         ubifs_release_budget(c, &req);
 488         fscrypt_free_filename(&nm);
 489
 490         return 0;
 491
 492 out_cancel:
 493         unlock_2_inodes(dir, inode);
 494 out_inode:
 495         make_bad_inode(inode);
 496         if (!instantiated)
 497                 iput(inode);
 498 out_budg:
 499         ubifs_release_budget(c, &req);
 500         if (!instantiated)
 501                 ubifs_release_budget(c, &ino_req);
 502         fscrypt_free_filename(&nm);
 503         ubifs_err(c, "cannot create temporary file, error %d", err);
 504         return err;
 505 }
 506
 507 /**
 508  * vfs_dent_type - get VFS directory entry type.
 509  * @type: UBIFS directory entry type
 510  *
 511  * This function converts UBIFS directory entry type into VFS directory entry
 512  * type.
 513  */
 514 static unsigned int vfs_dent_type(uint8_t type)
 515 {
 516         switch (type) {
 517         case UBIFS_ITYPE_REG:
 518                 return DT_REG;
 519         case UBIFS_ITYPE_DIR:
 520                 return DT_DIR;
 521         case UBIFS_ITYPE_LNK:
 522                 return DT_LNK;
 523         case UBIFS_ITYPE_BLK:
 524                 return DT_BLK;
 525         case UBIFS_ITYPE_CHR:
 526                 return DT_CHR;
 527         case UBIFS_ITYPE_FIFO:
 528                 return DT_FIFO;
 529         case UBIFS_ITYPE_SOCK:
 530                 return DT_SOCK;
 531         default:
 532                 BUG();
 533         }
 534         return 0;
 535 }
 536
 537 /*
 538  * The classical Unix view for directory is that it is a linear array of
 539  * (name, inode number) entries. Linux/VFS assumes this model as well.
 540  * Particularly, 'readdir()' call wants us to return a directory entry offset
 541  * which later may be used to continue 'readdir()'ing the directory or to
 542  * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
 543  * model because directory entries are identified by keys, which may collide.
 544  *
 545  * UBIFS uses directory entry hash value for directory offsets, so
 546  * 'seekdir()'/'telldir()' may not always work because of possible key
 547  * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
 548  * properly by means of saving full directory entry name in the private field
 549  * of the file description object.
 550  *
 551  * This means that UBIFS cannot support NFS which requires full
 552  * 'seekdir()'/'telldir()' support.
 553  */
 554 static int ubifs_readdir(struct file *file, struct dir_context *ctx)
 555 {
 556         int fstr_real_len = 0, err = 0;
 557         struct fscrypt_name nm;
 558         struct fscrypt_str fstr = {0};
 559         union ubifs_key key;
 560         struct ubifs_dent_node *dent;
 561         struct inode *dir = file_inode(file);
 562         struct ubifs_info *c = dir->i_sb->s_fs_info;
 563         bool encrypted = IS_ENCRYPTED(dir);
 564
 565         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
 566
 567         if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
 568                 /*
 569                  * The directory was seek'ed to a senseless position or there
 570                  * are no more entries.
 571                  */
 572                 return 0;
 573
 574         if (encrypted) {
 575                 err = fscrypt_prepare_readdir(dir);
 576                 if (err)
 577                         return err;
 578
 579                 err = fscrypt_fname_alloc_buffer(UBIFS_MAX_NLEN, &fstr);
 580                 if (err)
 581                         return err;
 582
 583                 fstr_real_len = fstr.len;
 584         }
 585
 586         if (file->f_version == 0) {
 587                 /*
 588                  * The file was seek'ed, which means that @file->private_data
 589                  * is now invalid. This may also be just the first
 590                  * 'ubifs_readdir()' invocation, in which case
 591                  * @file->private_data is NULL, and the below code is
 592                  * basically a no-op.
 593                  */
 594                 kfree(file->private_data);
 595                 file->private_data = NULL;
 596         }
 597
 598         /*
 599          * 'generic_file_llseek()' unconditionally sets @file->f_version to
 600          * zero, and we use this for detecting whether the file was seek'ed.
 601          */
 602         file->f_version = 1;
 603
 604         /* File positions 0 and 1 correspond to "." and ".." */
 605         if (ctx->pos < 2) {
 606                 ubifs_assert(c, !file->private_data);
 607                 if (!dir_emit_dots(file, ctx)) {
 608                         if (encrypted)
 609                                 fscrypt_fname_free_buffer(&fstr);
 610                         return 0;
 611                 }
 612
 613                 /* Find the first entry in TNC and save it */
 614                 lowest_dent_key(c, &key, dir->i_ino);
 615                 fname_len(&nm) = 0;
 616                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 617                 if (IS_ERR(dent)) {
 618                         err = PTR_ERR(dent);
 619                         goto out;
 620                 }
 621
 622                 ctx->pos = key_hash_flash(c, &dent->key);
 623                 file->private_data = dent;
 624         }
 625
 626         dent = file->private_data;
 627         if (!dent) {
 628                 /*
 629                  * The directory was seek'ed to and is now readdir'ed.
 630                  * Find the entry corresponding to @ctx->pos or the closest one.
 631                  */
 632                 dent_key_init_hash(c, &key, dir->i_ino, ctx->pos);
 633                 fname_len(&nm) = 0;
 634                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 635                 if (IS_ERR(dent)) {
 636                         err = PTR_ERR(dent);
 637                         goto out;
 638                 }
 639                 ctx->pos = key_hash_flash(c, &dent->key);
 640                 file->private_data = dent;
 641         }
 642
 643         while (1) {
 644                 dbg_gen("ino %llu, new f_pos %#x",
 645                         (unsigned long long)le64_to_cpu(dent->inum),
 646                         key_hash_flash(c, &dent->key));
 647                 ubifs_assert(c, le64_to_cpu(dent->ch.sqnum) >
 648                              ubifs_inode(dir)->creat_sqnum);
 649
 650                 fname_len(&nm) = le16_to_cpu(dent->nlen);
 651                 fname_name(&nm) = dent->name;
 652
 653                 if (encrypted) {
 654                         fstr.len = fstr_real_len;
 655
 656                         err = fscrypt_fname_disk_to_usr(dir, key_hash_flash(c,
 657                                                         &dent->key),
 658                                                         le32_to_cpu(dent->cookie),
 659                                                         &nm.disk_name, &fstr);
 660                         if (err)
 661                                 goto out;
 662                 } else {
 663                         fstr.len = fname_len(&nm);
 664                         fstr.name = fname_name(&nm);
 665                 }
 666
 667                 if (!dir_emit(ctx, fstr.name, fstr.len,
 668                                le64_to_cpu(dent->inum),
 669                                vfs_dent_type(dent->type))) {
 670                         if (encrypted)
 671                                 fscrypt_fname_free_buffer(&fstr);
 672                         return 0;
 673                 }
 674
 675                 /* Switch to the next entry */
 676                 key_read(c, &dent->key, &key);
 677                 dent = ubifs_tnc_next_ent(c, &key, &nm);
 678                 if (IS_ERR(dent)) {
 679                         err = PTR_ERR(dent);
 680                         goto out;
 681                 }
 682
 683                 kfree(file->private_data);
 684                 ctx->pos = key_hash_flash(c, &dent->key);
 685                 file->private_data = dent;
 686                 cond_resched();
 687         }
 688
 689 out:
 690         kfree(file->private_data);
 691         file->private_data = NULL;
 692
 693         if (encrypted)
 694                 fscrypt_fname_free_buffer(&fstr);
 695
 696         if (err != -ENOENT)
 697                 ubifs_err(c, "cannot find next direntry, error %d", err);
 698         else
 699                 /*
 700                  * -ENOENT is a non-fatal error in this context, the TNC uses
 701                  * it to indicate that the cursor moved past the current directory
 702                  * and readdir() has to stop.
 703                  */
 704                 err = 0;
 705
 706
 707         /* 2 is a special value indicating that there are no more direntries */
 708         ctx->pos = 2;
 709         return err;
 710 }
 711
 712 /* Free saved readdir() state when the directory is closed */
 713 static int ubifs_dir_release(struct inode *dir, struct file *file)
 714 {
 715         kfree(file->private_data);
 716         file->private_data = NULL;
 717         return 0;
 718 }
 719
 720 static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
 721                       struct dentry *dentry)
 722 {
 723         struct ubifs_info *c = dir->i_sb->s_fs_info;
 724         struct inode *inode = d_inode(old_dentry);
 725         struct ubifs_inode *ui = ubifs_inode(inode);
 726         struct ubifs_inode *dir_ui = ubifs_inode(dir);
 727         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
 728         struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
 729                                 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
 730         struct fscrypt_name nm;
 731
 732         /*
 733          * Budget request settings: new direntry, changing the target inode,
 734          * changing the parent inode.
 735          */
 736
 737         dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
 738                 dentry, inode->i_ino,
 739                 inode->i_nlink, dir->i_ino);
 740         ubifs_assert(c, inode_is_locked(dir));
 741         ubifs_assert(c, inode_is_locked(inode));
 742
 743         err = fscrypt_prepare_link(old_dentry, dir, dentry);
 744         if (err)
 745                 return err;
 746
 747         err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm);
 748         if (err)
 749                 return err;
 750
 751         err = dbg_check_synced_i_size(c, inode);
 752         if (err)
 753                 goto out_fname;
 754
 755         err = ubifs_budget_space(c, &req);
 756         if (err)
 757                 goto out_fname;
 758
 759         lock_2_inodes(dir, inode);
 760
 761         /* Handle O_TMPFILE corner case, it is allowed to link a O_TMPFILE. */
 762         if (inode->i_nlink == 0)
 763                 ubifs_delete_orphan(c, inode->i_ino);
 764
 765         inc_nlink(inode);
 766         ihold(inode);
 767         inode->i_ctime = current_time(inode);
 768         dir->i_size += sz_change;
 769         dir_ui->ui_size = dir->i_size;
 770         dir->i_mtime = dir->i_ctime = inode->i_ctime;
 771         err = ubifs_jnl_update(c, dir, &nm, inode, 0, 0);
 772         if (err)
 773                 goto out_cancel;
 774         unlock_2_inodes(dir, inode);
 775
 776         ubifs_release_budget(c, &req);
 777         d_instantiate(dentry, inode);
 778         fscrypt_free_filename(&nm);
 779         return 0;
 780
 781 out_cancel:
 782         dir->i_size -= sz_change;
 783         dir_ui->ui_size = dir->i_size;
 784         drop_nlink(inode);
 785         if (inode->i_nlink == 0)
 786                 ubifs_add_orphan(c, inode->i_ino);
 787         unlock_2_inodes(dir, inode);
 788         ubifs_release_budget(c, &req);
 789         iput(inode);
 790 out_fname:
 791         fscrypt_free_filename(&nm);
 792         return err;
 793 }
 794
 795 static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
 796 {
 797         struct ubifs_info *c = dir->i_sb->s_fs_info;
 798         struct inode *inode = d_inode(dentry);
 799         struct ubifs_inode *dir_ui = ubifs_inode(dir);
 800         int err, sz_change, budgeted = 1;
 801         struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
 802         unsigned int saved_nlink = inode->i_nlink;
 803         struct fscrypt_name nm;
 804
 805         /*
 806          * Budget request settings: deletion direntry, deletion inode (+1 for
 807          * @dirtied_ino), changing the parent directory inode. If budgeting
 808          * fails, go ahead anyway because we have extra space reserved for
 809          * deletions.
 810          */
 811
 812         dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
 813                 dentry, inode->i_ino,
 814                 inode->i_nlink, dir->i_ino);
 815
 816         err = fscrypt_setup_filename(dir, &dentry->d_name, 1, &nm);
 817         if (err)
 818                 return err;
 819
 820         err = ubifs_purge_xattrs(inode);
 821         if (err)
 822                 return err;
 823
 824         sz_change = CALC_DENT_SIZE(fname_len(&nm));
 825
 826         ubifs_assert(c, inode_is_locked(dir));
 827         ubifs_assert(c, inode_is_locked(inode));
 828         err = dbg_check_synced_i_size(c, inode);
 829         if (err)
 830                 goto out_fname;
 831
 832         err = ubifs_budget_space(c, &req);
 833         if (err) {
 834                 if (err != -ENOSPC)
 835                         goto out_fname;
 836                 budgeted = 0;
 837         }
 838
 839         lock_2_inodes(dir, inode);
 840         inode->i_ctime = current_time(dir);
 841         drop_nlink(inode);
 842         dir->i_size -= sz_change;
 843         dir_ui->ui_size = dir->i_size;
 844         dir->i_mtime = dir->i_ctime = inode->i_ctime;
 845         err = ubifs_jnl_update(c, dir, &nm, inode, 1, 0);
 846         if (err)
 847                 goto out_cancel;
 848         unlock_2_inodes(dir, inode);
 849
 850         if (budgeted)
 851                 ubifs_release_budget(c, &req);
 852         else {
 853                 /* We've deleted something - clean the "no space" flags */
 854                 c->bi.nospace = c->bi.nospace_rp = 0;
 855                 smp_wmb();
 856         }
 857         fscrypt_free_filename(&nm);
 858         return 0;
 859
 860 out_cancel:
 861         dir->i_size += sz_change;
 862         dir_ui->ui_size = dir->i_size;
 863         set_nlink(inode, saved_nlink);
 864         unlock_2_inodes(dir, inode);
 865         if (budgeted)
 866                 ubifs_release_budget(c, &req);
 867 out_fname:
 868         fscrypt_free_filename(&nm);
 869         return err;
 870 }
 871
 872 /**
 873  * check_dir_empty - check if a directory is empty or not.
 874  * @dir: VFS inode object of the directory to check
 875  *
 876  * This function checks if directory @dir is empty. Returns zero if the
 877  * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
 878  * in case of errors.
 879  */
 880 int ubifs_check_dir_empty(struct inode *dir)
 881 {
 882         struct ubifs_info *c = dir->i_sb->s_fs_info;
 883         struct fscrypt_name nm = { 0 };
 884         struct ubifs_dent_node *dent;
 885         union ubifs_key key;
 886         int err;
 887
 888         lowest_dent_key(c, &key, dir->i_ino);
 889         dent = ubifs_tnc_next_ent(c, &key, &nm);
 890         if (IS_ERR(dent)) {
 891                 err = PTR_ERR(dent);
 892                 if (err == -ENOENT)
 893                         err = 0;
 894         } else {
 895                 kfree(dent);
 896                 err = -ENOTEMPTY;
 897         }
 898         return err;
 899 }
 900
 901 static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
 902 {
 903         struct ubifs_info *c = dir->i_sb->s_fs_info;
 904         struct inode *inode = d_inode(dentry);
 905         int err, sz_change, budgeted = 1;
 906         struct ubifs_inode *dir_ui = ubifs_inode(dir);
 907         struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
 908         struct fscrypt_name nm;
 909
 910         /*
 911          * Budget request settings: deletion direntry, deletion inode and
 912          * changing the parent inode. If budgeting fails, go ahead anyway
 913          * because we have extra space reserved for deletions.
 914          */
 915
 916         dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
 917                 inode->i_ino, dir->i_ino);
 918         ubifs_assert(c, inode_is_locked(dir));
 919         ubifs_assert(c, inode_is_locked(inode));
 920         err = ubifs_check_dir_empty(d_inode(dentry));
 921         if (err)
 922                 return err;
 923
 924         err = fscrypt_setup_filename(dir, &dentry->d_name, 1, &nm);
 925         if (err)
 926                 return err;
 927
 928         err = ubifs_purge_xattrs(inode);
 929         if (err)
 930                 return err;
 931
 932         sz_change = CALC_DENT_SIZE(fname_len(&nm));
 933
 934         err = ubifs_budget_space(c, &req);
 935         if (err) {
 936                 if (err != -ENOSPC)
 937                         goto out_fname;
 938                 budgeted = 0;
 939         }
 940
 941         lock_2_inodes(dir, inode);
 942         inode->i_ctime = current_time(dir);
 943         clear_nlink(inode);
 944         drop_nlink(dir);
 945         dir->i_size -= sz_change;
 946         dir_ui->ui_size = dir->i_size;
 947         dir->i_mtime = dir->i_ctime = inode->i_ctime;
 948         err = ubifs_jnl_update(c, dir, &nm, inode, 1, 0);
 949         if (err)
 950                 goto out_cancel;
 951         unlock_2_inodes(dir, inode);
 952
 953         if (budgeted)
 954                 ubifs_release_budget(c, &req);
 955         else {
 956                 /* We've deleted something - clean the "no space" flags */
 957                 c->bi.nospace = c->bi.nospace_rp = 0;
 958                 smp_wmb();
 959         }
 960         fscrypt_free_filename(&nm);
 961         return 0;
 962
 963 out_cancel:
 964         dir->i_size += sz_change;
 965         dir_ui->ui_size = dir->i_size;
 966         inc_nlink(dir);
 967         set_nlink(inode, 2);
 968         unlock_2_inodes(dir, inode);
 969         if (budgeted)
 970                 ubifs_release_budget(c, &req);
 971 out_fname:
 972         fscrypt_free_filename(&nm);
 973         return err;
 974 }
 975
 976 static int ubifs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
 977                        struct dentry *dentry, umode_t mode)
 978 {
 979         struct inode *inode;
 980         struct ubifs_inode *dir_ui = ubifs_inode(dir);
 981         struct ubifs_info *c = dir->i_sb->s_fs_info;
 982         int err, sz_change;
 983         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
 984                                         .dirtied_ino = 1};
 985         struct fscrypt_name nm;
 986
 987         /*
 988          * Budget request settings: new inode, new direntry and changing parent
 989          * directory inode.
 990          */
 991
 992         dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
 993                 dentry, mode, dir->i_ino);
 994
 995         err = ubifs_budget_space(c, &req);
 996         if (err)
 997                 return err;
 998
 999         err = ubifs_prepare_create(dir, dentry, &nm);
1000         if (err)
1001                 goto out_budg;
1002
1003         sz_change = CALC_DENT_SIZE(fname_len(&nm));
1004
1005         inode = ubifs_new_inode(c, dir, S_IFDIR | mode, false);
1006         if (IS_ERR(inode)) {
1007                 err = PTR_ERR(inode);
1008                 goto out_fname;
1009         }
1010
1011         err = ubifs_init_security(dir, inode, &dentry->d_name);
1012         if (err)
1013                 goto out_inode;
1014
1015         mutex_lock(&dir_ui->ui_mutex);
1016         insert_inode_hash(inode);
1017         inc_nlink(inode);
1018         inc_nlink(dir);
1019         dir->i_size += sz_change;
1020         dir_ui->ui_size = dir->i_size;
1021         dir->i_mtime = dir->i_ctime = inode->i_ctime;
1022         err = ubifs_jnl_update(c, dir, &nm, inode, 0, 0);
1023         if (err) {
1024                 ubifs_err(c, "cannot create directory, error %d", err);
1025                 goto out_cancel;
1026         }
1027         mutex_unlock(&dir_ui->ui_mutex);
1028
1029         ubifs_release_budget(c, &req);
1030         d_instantiate(dentry, inode);
1031         fscrypt_free_filename(&nm);
1032         return 0;
1033
1034 out_cancel:
1035         dir->i_size -= sz_change;
1036         dir_ui->ui_size = dir->i_size;
1037         drop_nlink(dir);
1038         mutex_unlock(&dir_ui->ui_mutex);
1039 out_inode:
1040         make_bad_inode(inode);
1041         iput(inode);
1042 out_fname:
1043         fscrypt_free_filename(&nm);
1044 out_budg:
1045         ubifs_release_budget(c, &req);
1046         return err;
1047 }
1048
1049 static int ubifs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
1050                        struct dentry *dentry, umode_t mode, dev_t rdev)
1051 {
1052         struct inode *inode;
1053         struct ubifs_inode *ui;
1054         struct ubifs_inode *dir_ui = ubifs_inode(dir);
1055         struct ubifs_info *c = dir->i_sb->s_fs_info;
1056         union ubifs_dev_desc *dev = NULL;
1057         int sz_change;
1058         int err, devlen = 0;
1059         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
1060                                         .dirtied_ino = 1 };
1061         struct fscrypt_name nm;
1062
1063         /*
1064          * Budget request settings: new inode, new direntry and changing parent
1065          * directory inode.
1066          */
1067
1068         dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
1069
1070         if (S_ISBLK(mode) || S_ISCHR(mode)) {
1071                 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
1072                 if (!dev)
1073                         return -ENOMEM;
1074                 devlen = ubifs_encode_dev(dev, rdev);
1075         }
1076
1077         req.new_ino_d = ALIGN(devlen, 8);
1078         err = ubifs_budget_space(c, &req);
1079         if (err) {
1080                 kfree(dev);
1081                 return err;
1082         }
1083
1084         err = ubifs_prepare_create(dir, dentry, &nm);
1085         if (err) {
1086                 kfree(dev);
1087                 goto out_budg;
1088         }
1089
1090         sz_change = CALC_DENT_SIZE(fname_len(&nm));
1091
1092         inode = ubifs_new_inode(c, dir, mode, false);
1093         if (IS_ERR(inode)) {
1094                 kfree(dev);
1095                 err = PTR_ERR(inode);
1096                 goto out_fname;
1097         }
1098
1099         init_special_inode(inode, inode->i_mode, rdev);
1100         inode->i_size = ubifs_inode(inode)->ui_size = devlen;
1101         ui = ubifs_inode(inode);
1102         ui->data = dev;
1103         ui->data_len = devlen;
1104
1105         err = ubifs_init_security(dir, inode, &dentry->d_name);
1106         if (err)
1107                 goto out_inode;
1108
1109         mutex_lock(&dir_ui->ui_mutex);
1110         dir->i_size += sz_change;
1111         dir_ui->ui_size = dir->i_size;
1112         dir->i_mtime = dir->i_ctime = inode->i_ctime;
1113         err = ubifs_jnl_update(c, dir, &nm, inode, 0, 0);
1114         if (err)
1115                 goto out_cancel;
1116         mutex_unlock(&dir_ui->ui_mutex);
1117
1118         ubifs_release_budget(c, &req);
1119         insert_inode_hash(inode);
1120         d_instantiate(dentry, inode);
1121         fscrypt_free_filename(&nm);
1122         return 0;
1123
1124 out_cancel:
1125         dir->i_size -= sz_change;
1126         dir_ui->ui_size = dir->i_size;
1127         mutex_unlock(&dir_ui->ui_mutex);
1128 out_inode:
1129         make_bad_inode(inode);
1130         iput(inode);
1131 out_fname:
1132         fscrypt_free_filename(&nm);
1133 out_budg:
1134         ubifs_release_budget(c, &req);
1135         return err;
1136 }
1137
1138 static int ubifs_symlink(struct user_namespace *mnt_userns, struct inode *dir,
1139                          struct dentry *dentry, const char *symname)
1140 {
1141         struct inode *inode;
1142         struct ubifs_inode *ui;
1143         struct ubifs_inode *dir_ui = ubifs_inode(dir);
1144         struct ubifs_info *c = dir->i_sb->s_fs_info;
1145         int err, sz_change, len = strlen(symname);
1146         struct fscrypt_str disk_link;
1147         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
1148                                         .dirtied_ino = 1 };
1149         struct fscrypt_name nm;
1150
1151         dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
1152                 symname, dir->i_ino);
1153
1154         err = fscrypt_prepare_symlink(dir, symname, len, UBIFS_MAX_INO_DATA,
1155                                       &disk_link);
1156         if (err)
1157                 return err;
1158
1159         /*
1160          * Budget request settings: new inode, new direntry and changing parent
1161          * directory inode.
1162          */
1163         req.new_ino_d = ALIGN(disk_link.len - 1, 8);
1164         err = ubifs_budget_space(c, &req);
1165         if (err)
1166                 return err;
1167
1168         err = ubifs_prepare_create(dir, dentry, &nm);
1169         if (err)
1170                 goto out_budg;
1171
1172         sz_change = CALC_DENT_SIZE(fname_len(&nm));
1173
1174         inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO, false);
1175         if (IS_ERR(inode)) {
1176                 err = PTR_ERR(inode);
1177                 goto out_fname;
1178         }
1179
1180         ui = ubifs_inode(inode);
1181         ui->data = kmalloc(disk_link.len, GFP_NOFS);
1182         if (!ui->data) {
1183                 err = -ENOMEM;
1184                 goto out_inode;
1185         }
1186
1187         if (IS_ENCRYPTED(inode)) {
1188                 disk_link.name = ui->data; /* encrypt directly into ui->data */
1189                 err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
1190                 if (err)
1191                         goto out_inode;
1192         } else {
1193                 memcpy(ui->data, disk_link.name, disk_link.len);
1194                 inode->i_link = ui->data;
1195         }
1196
1197         /*
1198          * The terminating zero byte is not written to the flash media and it
1199          * is put just to make later in-memory string processing simpler. Thus,
1200          * data length is @disk_link.len - 1, not @disk_link.len.
1201          */
1202         ui->data_len = disk_link.len - 1;
1203         inode->i_size = ubifs_inode(inode)->ui_size = disk_link.len - 1;
1204
1205         err = ubifs_init_security(dir, inode, &dentry->d_name);
1206         if (err)
1207                 goto out_inode;
1208
1209         mutex_lock(&dir_ui->ui_mutex);
1210         dir->i_size += sz_change;
1211         dir_ui->ui_size = dir->i_size;
1212         dir->i_mtime = dir->i_ctime = inode->i_ctime;
1213         err = ubifs_jnl_update(c, dir, &nm, inode, 0, 0);
1214         if (err)
1215                 goto out_cancel;
1216         mutex_unlock(&dir_ui->ui_mutex);
1217
1218         insert_inode_hash(inode);
1219         d_instantiate(dentry, inode);
1220         err = 0;
1221         goto out_fname;
1222
1223 out_cancel:
1224         dir->i_size -= sz_change;
1225         dir_ui->ui_size = dir->i_size;
1226         mutex_unlock(&dir_ui->ui_mutex);
1227 out_inode:
1228         make_bad_inode(inode);
1229         iput(inode);
1230 out_fname:
1231         fscrypt_free_filename(&nm);
1232 out_budg:
1233         ubifs_release_budget(c, &req);
1234         return err;
1235 }
1236
1237 /**
1238  * lock_4_inodes - a wrapper for locking three UBIFS inodes.
1239  * @inode1: first inode
1240  * @inode2: second inode
1241  * @inode3: third inode
1242  * @inode4: fouth inode
1243  *
1244  * This function is used for 'ubifs_rename()' and @inode1 may be the same as
1245  * @inode2 whereas @inode3 and @inode4 may be %NULL.
1246  *
1247  * We do not implement any tricks to guarantee strict lock ordering, because
1248  * VFS has already done it for us on the @i_mutex. So this is just a simple
1249  * wrapper function.
1250  */
1251 static void lock_4_inodes(struct inode *inode1, struct inode *inode2,
1252                           struct inode *inode3, struct inode *inode4)
1253 {
1254         mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
1255         if (inode2 != inode1)
1256                 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
1257         if (inode3)
1258                 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
1259         if (inode4)
1260                 mutex_lock_nested(&ubifs_inode(inode4)->ui_mutex, WB_MUTEX_4);
1261 }
1262
1263 /**
1264  * unlock_4_inodes - a wrapper for unlocking three UBIFS inodes for rename.
1265  * @inode1: first inode
1266  * @inode2: second inode
1267  * @inode3: third inode
1268  * @inode4: fouth inode
1269  */
1270 static void unlock_4_inodes(struct inode *inode1, struct inode *inode2,
1271                             struct inode *inode3, struct inode *inode4)
1272 {
1273         if (inode4)
1274                 mutex_unlock(&ubifs_inode(inode4)->ui_mutex);
1275         if (inode3)
1276                 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
1277         if (inode1 != inode2)
1278                 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
1279         mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
1280 }
1281
1282 static int do_rename(struct inode *old_dir, struct dentry *old_dentry,
1283                      struct inode *new_dir, struct dentry *new_dentry,
1284                      unsigned int flags)
1285 {
1286         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
1287         struct inode *old_inode = d_inode(old_dentry);
1288         struct inode *new_inode = d_inode(new_dentry);
1289         struct inode *whiteout = NULL;
1290         struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
1291         struct ubifs_inode *whiteout_ui = NULL;
1292         int err, release, sync = 0, move = (new_dir != old_dir);
1293         int is_dir = S_ISDIR(old_inode->i_mode);
1294         int unlink = !!new_inode, new_sz, old_sz;
1295         struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
1296                                         .dirtied_ino = 3 };
1297         struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
1298                         .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
1299         struct ubifs_budget_req wht_req;
1300         struct timespec64 time;
1301         unsigned int saved_nlink;
1302         struct fscrypt_name old_nm, new_nm;
1303
1304         /*
1305          * Budget request settings:
1306          *   req: deletion direntry, new direntry, removing the old inode,
1307          *   and changing old and new parent directory inodes.
1308          *
1309          *   wht_req: new whiteout inode for RENAME_WHITEOUT.
1310          *
1311          *   ino_req: marks the target inode as dirty and does not write it.
1312          */
1313
1314         dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1315                 old_dentry, old_inode->i_ino, old_dir->i_ino,
1316                 new_dentry, new_dir->i_ino, flags);
1317
1318         if (unlink) {
1319                 ubifs_assert(c, inode_is_locked(new_inode));
1320
1321                 /* Budget for old inode's data when its nlink > 1. */
1322                 req.dirtied_ino_d = ALIGN(ubifs_inode(new_inode)->data_len, 8);
1323                 err = ubifs_purge_xattrs(new_inode);
1324                 if (err)
1325                         return err;
1326         }
1327
1328         if (unlink && is_dir) {
1329                 err = ubifs_check_dir_empty(new_inode);
1330                 if (err)
1331                         return err;
1332         }
1333
1334         err = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_nm);
1335         if (err)
1336                 return err;
1337
1338         err = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_nm);
1339         if (err) {
1340                 fscrypt_free_filename(&old_nm);
1341                 return err;
1342         }
1343
1344         new_sz = CALC_DENT_SIZE(fname_len(&new_nm));
1345         old_sz = CALC_DENT_SIZE(fname_len(&old_nm));
1346
1347         err = ubifs_budget_space(c, &req);
1348         if (err) {
1349                 fscrypt_free_filename(&old_nm);
1350                 fscrypt_free_filename(&new_nm);
1351                 return err;
1352         }
1353         err = ubifs_budget_space(c, &ino_req);
1354         if (err) {
1355                 fscrypt_free_filename(&old_nm);
1356                 fscrypt_free_filename(&new_nm);
1357                 ubifs_release_budget(c, &req);
1358                 return err;
1359         }
1360
1361         if (flags & RENAME_WHITEOUT) {
1362                 union ubifs_dev_desc *dev = NULL;
1363
1364                 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
1365                 if (!dev) {
1366                         err = -ENOMEM;
1367                         goto out_release;
1368                 }
1369
1370                 /*
1371                  * The whiteout inode without dentry is pinned in memory,
1372                  * umount won't happen during rename process because we
1373                  * got parent dentry.
1374                  */
1375                 whiteout = create_whiteout(old_dir, old_dentry);
1376                 if (IS_ERR(whiteout)) {
1377                         err = PTR_ERR(whiteout);
1378                         kfree(dev);
1379                         goto out_release;
1380                 }
1381
1382                 whiteout_ui = ubifs_inode(whiteout);
1383                 whiteout_ui->data = dev;
1384                 whiteout_ui->data_len = ubifs_encode_dev(dev, MKDEV(0, 0));
1385                 ubifs_assert(c, !whiteout_ui->dirty);
1386
1387                 memset(&wht_req, 0, sizeof(struct ubifs_budget_req));
1388                 wht_req.new_ino = 1;
1389                 wht_req.new_ino_d = ALIGN(whiteout_ui->data_len, 8);
1390                 /*
1391                  * To avoid deadlock between space budget (holds ui_mutex and
1392                  * waits wb work) and writeback work(waits ui_mutex), do space
1393                  * budget before ubifs inodes locked.
1394                  */
1395                 err = ubifs_budget_space(c, &wht_req);
1396                 if (err) {
1397                         /*
1398                          * Whiteout inode can not be written on flash by
1399                          * ubifs_jnl_write_inode(), because it's neither
1400                          * dirty nor zero-nlink.
1401                          */
1402                         iput(whiteout);
1403                         goto out_release;
1404                 }
1405
1406                 /* Add the old_dentry size to the old_dir size. */
1407                 old_sz -= CALC_DENT_SIZE(fname_len(&old_nm));
1408         }
1409
1410         lock_4_inodes(old_dir, new_dir, new_inode, whiteout);
1411
1412         /*
1413          * Like most other Unix systems, set the @i_ctime for inodes on a
1414          * rename.
1415          */
1416         time = current_time(old_dir);
1417         old_inode->i_ctime = time;
1418
1419         /* We must adjust parent link count when renaming directories */
1420         if (is_dir) {
1421                 if (move) {
1422                         /*
1423                          * @old_dir loses a link because we are moving
1424                          * @old_inode to a different directory.
1425                          */
1426                         drop_nlink(old_dir);
1427                         /*
1428                          * @new_dir only gains a link if we are not also
1429                          * overwriting an existing directory.
1430                          */
1431                         if (!unlink)
1432                                 inc_nlink(new_dir);
1433                 } else {
1434                         /*
1435                          * @old_inode is not moving to a different directory,
1436                          * but @old_dir still loses a link if we are
1437                          * overwriting an existing directory.
1438                          */
1439                         if (unlink)
1440                                 drop_nlink(old_dir);
1441                 }
1442         }
1443
1444         old_dir->i_size -= old_sz;
1445         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1446         old_dir->i_mtime = old_dir->i_ctime = time;
1447         new_dir->i_mtime = new_dir->i_ctime = time;
1448
1449         /*
1450          * And finally, if we unlinked a direntry which happened to have the
1451          * same name as the moved direntry, we have to decrement @i_nlink of
1452          * the unlinked inode and change its ctime.
1453          */
1454         if (unlink) {
1455                 /*
1456                  * Directories cannot have hard-links, so if this is a
1457                  * directory, just clear @i_nlink.
1458                  */
1459                 saved_nlink = new_inode->i_nlink;
1460                 if (is_dir)
1461                         clear_nlink(new_inode);
1462                 else
1463                         drop_nlink(new_inode);
1464                 new_inode->i_ctime = time;
1465         } else {
1466                 new_dir->i_size += new_sz;
1467                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1468         }
1469
1470         /*
1471          * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1472          * is dirty, because this will be done later on at the end of
1473          * 'ubifs_rename()'.
1474          */
1475         if (IS_SYNC(old_inode)) {
1476                 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1477                 if (unlink && IS_SYNC(new_inode))
1478                         sync = 1;
1479                 /*
1480                  * S_SYNC flag of whiteout inherits from the old_dir, and we
1481                  * have already checked the old dir inode. So there is no need
1482                  * to check whiteout.
1483                  */
1484         }
1485
1486         err = ubifs_jnl_rename(c, old_dir, old_inode, &old_nm, new_dir,
1487                                new_inode, &new_nm, whiteout, sync);
1488         if (err)
1489                 goto out_cancel;
1490
1491         unlock_4_inodes(old_dir, new_dir, new_inode, whiteout);
1492         ubifs_release_budget(c, &req);
1493
1494         if (whiteout) {
1495                 ubifs_release_budget(c, &wht_req);
1496                 iput(whiteout);
1497         }
1498
1499         mutex_lock(&old_inode_ui->ui_mutex);
1500         release = old_inode_ui->dirty;
1501         mark_inode_dirty_sync(old_inode);
1502         mutex_unlock(&old_inode_ui->ui_mutex);
1503
1504         if (release)
1505                 ubifs_release_budget(c, &ino_req);
1506         if (IS_SYNC(old_inode))
1507                 /*
1508                  * Rename finished here. Although old inode cannot be updated
1509                  * on flash, old ctime is not a big problem, don't return err
1510                  * code to userspace.
1511                  */
1512                 old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1513
1514         fscrypt_free_filename(&old_nm);
1515         fscrypt_free_filename(&new_nm);
1516         return 0;
1517
1518 out_cancel:
1519         if (unlink) {
1520                 set_nlink(new_inode, saved_nlink);
1521         } else {
1522                 new_dir->i_size -= new_sz;
1523                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1524         }
1525         old_dir->i_size += old_sz;
1526         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1527         if (is_dir) {
1528                 if (move) {
1529                         inc_nlink(old_dir);
1530                         if (!unlink)
1531                                 drop_nlink(new_dir);
1532                 } else {
1533                         if (unlink)
1534                                 inc_nlink(old_dir);
1535                 }
1536         }
1537         unlock_4_inodes(old_dir, new_dir, new_inode, whiteout);
1538         if (whiteout) {
1539                 ubifs_release_budget(c, &wht_req);
1540                 iput(whiteout);
1541         }
1542 out_release:
1543         ubifs_release_budget(c, &ino_req);
1544         ubifs_release_budget(c, &req);
1545         fscrypt_free_filename(&old_nm);
1546         fscrypt_free_filename(&new_nm);
1547         return err;
1548 }
1549
1550 static int ubifs_xrename(struct inode *old_dir, struct dentry *old_dentry,
1551                         struct inode *new_dir, struct dentry *new_dentry)
1552 {
1553         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
1554         struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
1555                                 .dirtied_ino = 2 };
1556         int sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1557         struct inode *fst_inode = d_inode(old_dentry);
1558         struct inode *snd_inode = d_inode(new_dentry);
1559         struct timespec64 time;
1560         int err;
1561         struct fscrypt_name fst_nm, snd_nm;
1562
1563         ubifs_assert(c, fst_inode && snd_inode);
1564
1565         err = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &fst_nm);
1566         if (err)
1567                 return err;
1568
1569         err = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &snd_nm);
1570         if (err) {
1571                 fscrypt_free_filename(&fst_nm);
1572                 return err;
1573         }
1574
1575         err = ubifs_budget_space(c, &req);
1576         if (err)
1577                 goto out;
1578
1579         lock_4_inodes(old_dir, new_dir, NULL, NULL);
1580
1581         time = current_time(old_dir);
1582         fst_inode->i_ctime = time;
1583         snd_inode->i_ctime = time;
1584         old_dir->i_mtime = old_dir->i_ctime = time;
1585         new_dir->i_mtime = new_dir->i_ctime = time;
1586
1587         if (old_dir != new_dir) {
1588                 if (S_ISDIR(fst_inode->i_mode) && !S_ISDIR(snd_inode->i_mode)) {
1589                         inc_nlink(new_dir);
1590                         drop_nlink(old_dir);
1591                 }
1592                 else if (!S_ISDIR(fst_inode->i_mode) && S_ISDIR(snd_inode->i_mode)) {
1593                         drop_nlink(new_dir);
1594                         inc_nlink(old_dir);
1595                 }
1596         }
1597
1598         err = ubifs_jnl_xrename(c, old_dir, fst_inode, &fst_nm, new_dir,
1599                                 snd_inode, &snd_nm, sync);
1600
1601         unlock_4_inodes(old_dir, new_dir, NULL, NULL);
1602         ubifs_release_budget(c, &req);
1603
1604 out:
1605         fscrypt_free_filename(&fst_nm);
1606         fscrypt_free_filename(&snd_nm);
1607         return err;
1608 }
1609
1610 static int ubifs_rename(struct user_namespace *mnt_userns,
1611                         struct inode *old_dir, struct dentry *old_dentry,
1612                         struct inode *new_dir, struct dentry *new_dentry,
1613                         unsigned int flags)
1614 {
1615         int err;
1616         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
1617
1618         if (flags & ~(RENAME_NOREPLACE | RENAME_WHITEOUT | RENAME_EXCHANGE))
1619                 return -EINVAL;
1620
1621         ubifs_assert(c, inode_is_locked(old_dir));
1622         ubifs_assert(c, inode_is_locked(new_dir));
1623
1624         err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
1625                                      flags);
1626         if (err)
1627                 return err;
1628
1629         if (flags & RENAME_EXCHANGE)
1630                 return ubifs_xrename(old_dir, old_dentry, new_dir, new_dentry);
1631
1632         return do_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
1633 }
1634
1635 int ubifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
1636                   struct kstat *stat, u32 request_mask, unsigned int flags)
1637 {
1638         loff_t size;
1639         struct inode *inode = d_inode(path->dentry);
1640         struct ubifs_inode *ui = ubifs_inode(inode);
1641
1642         mutex_lock(&ui->ui_mutex);
1643
1644         if (ui->flags & UBIFS_APPEND_FL)
1645                 stat->attributes |= STATX_ATTR_APPEND;
1646         if (ui->flags & UBIFS_COMPR_FL)
1647                 stat->attributes |= STATX_ATTR_COMPRESSED;
1648         if (ui->flags & UBIFS_CRYPT_FL)
1649                 stat->attributes |= STATX_ATTR_ENCRYPTED;
1650         if (ui->flags & UBIFS_IMMUTABLE_FL)
1651                 stat->attributes |= STATX_ATTR_IMMUTABLE;
1652
1653         stat->attributes_mask |= (STATX_ATTR_APPEND |
1654                                 STATX_ATTR_COMPRESSED |
1655                                 STATX_ATTR_ENCRYPTED |
1656                                 STATX_ATTR_IMMUTABLE);
1657
1658         generic_fillattr(&init_user_ns, inode, stat);
1659         stat->blksize = UBIFS_BLOCK_SIZE;
1660         stat->size = ui->ui_size;
1661
1662         /*
1663          * Unfortunately, the 'stat()' system call was designed for block
1664          * device based file systems, and it is not appropriate for UBIFS,
1665          * because UBIFS does not have notion of "block". For example, it is
1666          * difficult to tell how many block a directory takes - it actually
1667          * takes less than 300 bytes, but we have to round it to block size,
1668          * which introduces large mistake. This makes utilities like 'du' to
1669          * report completely senseless numbers. This is the reason why UBIFS
1670          * goes the same way as JFFS2 - it reports zero blocks for everything
1671          * but regular files, which makes more sense than reporting completely
1672          * wrong sizes.
1673          */
1674         if (S_ISREG(inode->i_mode)) {
1675                 size = ui->xattr_size;
1676                 size += stat->size;
1677                 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1678                 /*
1679                  * Note, user-space expects 512-byte blocks count irrespectively
1680                  * of what was reported in @stat->size.
1681                  */
1682                 stat->blocks = size >> 9;
1683         } else
1684                 stat->blocks = 0;
1685         mutex_unlock(&ui->ui_mutex);
1686         return 0;
1687 }
1688
1689 const struct inode_operations ubifs_dir_inode_operations = {
1690         .lookup      = ubifs_lookup,
1691         .create      = ubifs_create,
1692         .link        = ubifs_link,
1693         .symlink     = ubifs_symlink,
1694         .unlink      = ubifs_unlink,
1695         .mkdir       = ubifs_mkdir,
1696         .rmdir       = ubifs_rmdir,
1697         .mknod       = ubifs_mknod,
1698         .rename      = ubifs_rename,
1699         .setattr     = ubifs_setattr,
1700         .getattr     = ubifs_getattr,
1701         .listxattr   = ubifs_listxattr,
1702         .update_time = ubifs_update_time,
1703         .tmpfile     = ubifs_tmpfile,
1704         .fileattr_get = ubifs_fileattr_get,
1705         .fileattr_set = ubifs_fileattr_set,
1706 };
1707
1708 const struct file_operations ubifs_dir_operations = {
1709         .llseek         = generic_file_llseek,
1710         .release        = ubifs_dir_release,
1711         .read           = generic_read_dir,
1712         .iterate_shared = ubifs_readdir,
1713         .fsync          = ubifs_fsync,
1714         .unlocked_ioctl = ubifs_ioctl,
1715 #ifdef CONFIG_COMPAT
1716         .compat_ioctl   = ubifs_compat_ioctl,
1717 #endif
1718 };