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(&nop_mnt_idmap, inode, dir, mode);
  99         inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode);
 100         inode->i_mapping->nrpages = 0;
 101
 102         if (!is_xattr) {
 103                 err = fscrypt_prepare_new_inode(dir, inode, &encrypted);
 104                 if (err) {
 105                         ubifs_err(c, "fscrypt_prepare_new_inode failed: %i", err);
 106                         goto out_iput;
 107                 }
 108         }
 109
 110         switch (mode & S_IFMT) {
 111         case S_IFREG:
 112                 inode->i_mapping->a_ops = &ubifs_file_address_operations;
 113                 inode->i_op = &ubifs_file_inode_operations;
 114                 inode->i_fop = &ubifs_file_operations;
 115                 break;
 116         case S_IFDIR:
 117                 inode->i_op  = &ubifs_dir_inode_operations;
 118                 inode->i_fop = &ubifs_dir_operations;
 119                 inode->i_size = ui->ui_size = UBIFS_INO_NODE_SZ;
 120                 break;
 121         case S_IFLNK:
 122                 inode->i_op = &ubifs_symlink_inode_operations;
 123                 break;
 124         case S_IFSOCK:
 125         case S_IFIFO:
 126         case S_IFBLK:
 127         case S_IFCHR:
 128                 inode->i_op  = &ubifs_file_inode_operations;
 129                 break;
 130         default:
 131                 BUG();
 132         }
 133
 134         ui->flags = inherit_flags(dir, mode);
 135         ubifs_set_inode_flags(inode);
 136         if (S_ISREG(mode))
 137                 ui->compr_type = c->default_compr;
 138         else
 139                 ui->compr_type = UBIFS_COMPR_NONE;
 140         ui->synced_i_size = 0;
 141
 142         spin_lock(&c->cnt_lock);
 143         /* Inode number overflow is currently not supported */
 144         if (c->highest_inum >= INUM_WARN_WATERMARK) {
 145                 if (c->highest_inum >= INUM_WATERMARK) {
 146                         spin_unlock(&c->cnt_lock);
 147                         ubifs_err(c, "out of inode numbers");
 148                         err = -EINVAL;
 149                         goto out_iput;
 150                 }
 151                 ubifs_warn(c, "running out of inode numbers (current %lu, max %u)",
 152                            (unsigned long)c->highest_inum, INUM_WATERMARK);
 153         }
 154
 155         inode->i_ino = ++c->highest_inum;
 156         /*
 157          * The creation sequence number remains with this inode for its
 158          * lifetime. All nodes for this inode have a greater sequence number,
 159          * and so it is possible to distinguish obsolete nodes belonging to a
 160          * previous incarnation of the same inode number - for example, for the
 161          * purpose of rebuilding the index.
 162          */
 163         ui->creat_sqnum = ++c->max_sqnum;
 164         spin_unlock(&c->cnt_lock);
 165
 166         if (encrypted) {
 167                 err = fscrypt_set_context(inode, NULL);
 168                 if (err) {
 169                         ubifs_err(c, "fscrypt_set_context failed: %i", err);
 170                         goto out_iput;
 171                 }
 172         }
 173
 174         return inode;
 175
 176 out_iput:
 177         make_bad_inode(inode);
 178         iput(inode);
 179         return ERR_PTR(err);
 180 }
 181
 182 static int dbg_check_name(const struct ubifs_info *c,
 183                           const struct ubifs_dent_node *dent,
 184                           const struct fscrypt_name *nm)
 185 {
 186         if (!dbg_is_chk_gen(c))
 187                 return 0;
 188         if (le16_to_cpu(dent->nlen) != fname_len(nm))
 189                 return -EINVAL;
 190         if (memcmp(dent->name, fname_name(nm), fname_len(nm)))
 191                 return -EINVAL;
 192         return 0;
 193 }
 194
 195 static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
 196                                    unsigned int flags)
 197 {
 198         int err;
 199         union ubifs_key key;
 200         struct inode *inode = NULL;
 201         struct ubifs_dent_node *dent = NULL;
 202         struct ubifs_info *c = dir->i_sb->s_fs_info;
 203         struct fscrypt_name nm;
 204
 205         dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
 206
 207         err = fscrypt_prepare_lookup(dir, dentry, &nm);
 208         generic_set_encrypted_ci_d_ops(dentry);
 209         if (err == -ENOENT)
 210                 return d_splice_alias(NULL, dentry);
 211         if (err)
 212                 return ERR_PTR(err);
 213
 214         if (fname_len(&nm) > UBIFS_MAX_NLEN) {
 215                 inode = ERR_PTR(-ENAMETOOLONG);
 216                 goto done;
 217         }
 218
 219         dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
 220         if (!dent) {
 221                 inode = ERR_PTR(-ENOMEM);
 222                 goto done;
 223         }
 224
 225         if (fname_name(&nm) == NULL) {
 226                 if (nm.hash & ~UBIFS_S_KEY_HASH_MASK)
 227                         goto done; /* ENOENT */
 228                 dent_key_init_hash(c, &key, dir->i_ino, nm.hash);
 229                 err = ubifs_tnc_lookup_dh(c, &key, dent, nm.minor_hash);
 230         } else {
 231                 dent_key_init(c, &key, dir->i_ino, &nm);
 232                 err = ubifs_tnc_lookup_nm(c, &key, dent, &nm);
 233         }
 234
 235         if (err) {
 236                 if (err == -ENOENT)
 237                         dbg_gen("not found");
 238                 else
 239                         inode = ERR_PTR(err);
 240                 goto done;
 241         }
 242
 243         if (dbg_check_name(c, dent, &nm)) {
 244                 inode = ERR_PTR(-EINVAL);
 245                 goto done;
 246         }
 247
 248         inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
 249         if (IS_ERR(inode)) {
 250                 /*
 251                  * This should not happen. Probably the file-system needs
 252                  * checking.
 253                  */
 254                 err = PTR_ERR(inode);
 255                 ubifs_err(c, "dead directory entry '%pd', error %d",
 256                           dentry, err);
 257                 ubifs_ro_mode(c, err);
 258                 goto done;
 259         }
 260
 261         if (IS_ENCRYPTED(dir) &&
 262             (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
 263             !fscrypt_has_permitted_context(dir, inode)) {
 264                 ubifs_warn(c, "Inconsistent encryption contexts: %lu/%lu",
 265                            dir->i_ino, inode->i_ino);
 266                 iput(inode);
 267                 inode = ERR_PTR(-EPERM);
 268         }
 269
 270 done:
 271         kfree(dent);
 272         fscrypt_free_filename(&nm);
 273         return d_splice_alias(inode, dentry);
 274 }
 275
 276 static int ubifs_prepare_create(struct inode *dir, struct dentry *dentry,
 277                                 struct fscrypt_name *nm)
 278 {
 279         if (fscrypt_is_nokey_name(dentry))
 280                 return -ENOKEY;
 281
 282         return fscrypt_setup_filename(dir, &dentry->d_name, 0, nm);
 283 }
 284
 285 static int ubifs_create(struct mnt_idmap *idmap, struct inode *dir,
 286                         struct dentry *dentry, umode_t mode, bool excl)
 287 {
 288         struct inode *inode;
 289         struct ubifs_info *c = dir->i_sb->s_fs_info;
 290         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
 291                                         .dirtied_ino = 1 };
 292         struct ubifs_inode *dir_ui = ubifs_inode(dir);
 293         struct fscrypt_name nm;
 294         int err, sz_change;
 295
 296         /*
 297          * Budget request settings: new inode, new direntry, changing the
 298          * parent directory inode.
 299          */
 300
 301         dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
 302                 dentry, mode, dir->i_ino);
 303
 304         err = ubifs_budget_space(c, &req);
 305         if (err)
 306                 return err;
 307
 308         err = ubifs_prepare_create(dir, dentry, &nm);
 309         if (err)
 310                 goto out_budg;
 311
 312         sz_change = CALC_DENT_SIZE(fname_len(&nm));
 313
 314         inode = ubifs_new_inode(c, dir, mode, false);
 315         if (IS_ERR(inode)) {
 316                 err = PTR_ERR(inode);
 317                 goto out_fname;
 318         }
 319
 320         err = ubifs_init_security(dir, inode, &dentry->d_name);
 321         if (err)
 322                 goto out_inode;
 323
 324         mutex_lock(&dir_ui->ui_mutex);
 325         dir->i_size += sz_change;
 326         dir_ui->ui_size = dir->i_size;
 327         dir->i_mtime = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
 328         err = ubifs_jnl_update(c, dir, &nm, inode, 0, 0);
 329         if (err)
 330                 goto out_cancel;
 331         mutex_unlock(&dir_ui->ui_mutex);
 332
 333         ubifs_release_budget(c, &req);
 334         fscrypt_free_filename(&nm);
 335         insert_inode_hash(inode);
 336         d_instantiate(dentry, inode);
 337         return 0;
 338
 339 out_cancel:
 340         dir->i_size -= sz_change;
 341         dir_ui->ui_size = dir->i_size;
 342         mutex_unlock(&dir_ui->ui_mutex);
 343 out_inode:
 344         make_bad_inode(inode);
 345         iput(inode);
 346 out_fname:
 347         fscrypt_free_filename(&nm);
 348 out_budg:
 349         ubifs_release_budget(c, &req);
 350         ubifs_err(c, "cannot create regular file, error %d", err);
 351         return err;
 352 }
 353
 354 static struct inode *create_whiteout(struct inode *dir, struct dentry *dentry)
 355 {
 356         int err;
 357         umode_t mode = S_IFCHR | WHITEOUT_MODE;
 358         struct inode *inode;
 359         struct ubifs_info *c = dir->i_sb->s_fs_info;
 360
 361         /*
 362          * Create an inode('nlink = 1') for whiteout without updating journal,
 363          * let ubifs_jnl_rename() store it on flash to complete rename whiteout
 364          * atomically.
 365          */
 366
 367         dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
 368                 dentry, mode, dir->i_ino);
 369
 370         inode = ubifs_new_inode(c, dir, mode, false);
 371         if (IS_ERR(inode)) {
 372                 err = PTR_ERR(inode);
 373                 goto out_free;
 374         }
 375
 376         init_special_inode(inode, inode->i_mode, WHITEOUT_DEV);
 377         ubifs_assert(c, inode->i_op == &ubifs_file_inode_operations);
 378
 379         err = ubifs_init_security(dir, inode, &dentry->d_name);
 380         if (err)
 381                 goto out_inode;
 382
 383         /* The dir size is updated by do_rename. */
 384         insert_inode_hash(inode);
 385
 386         return inode;
 387
 388 out_inode:
 389         make_bad_inode(inode);
 390         iput(inode);
 391 out_free:
 392         ubifs_err(c, "cannot create whiteout file, error %d", err);
 393         return ERR_PTR(err);
 394 }
 395
 396 /**
 397  * lock_2_inodes - a wrapper for locking two UBIFS inodes.
 398  * @inode1: first inode
 399  * @inode2: second inode
 400  *
 401  * We do not implement any tricks to guarantee strict lock ordering, because
 402  * VFS has already done it for us on the @i_mutex. So this is just a simple
 403  * wrapper function.
 404  */
 405 static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
 406 {
 407         mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
 408         mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
 409 }
 410
 411 /**
 412  * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
 413  * @inode1: first inode
 414  * @inode2: second inode
 415  */
 416 static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
 417 {
 418         mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
 419         mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
 420 }
 421
 422 static int ubifs_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
 423                          struct file *file, umode_t mode)
 424 {
 425         struct dentry *dentry = file->f_path.dentry;
 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(file, 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 finish_open_simple(file, 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_set_ctime_current(inode);
 768         dir->i_size += sz_change;
 769         dir_ui->ui_size = dir->i_size;
 770         dir->i_mtime = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
 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_set_ctime_current(inode);
 841         drop_nlink(inode);
 842         dir->i_size -= sz_change;
 843         dir_ui->ui_size = dir->i_size;
 844         dir->i_mtime = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
 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  * ubifs_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_set_ctime_current(inode);
 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 = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
 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 mnt_idmap *idmap, 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 = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
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 mnt_idmap *idmap, 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 = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
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 mnt_idmap *idmap, 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 = inode_set_ctime_to_ts(dir, inode_get_ctime(inode));
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: fourth 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: fourth 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         unsigned int saved_nlink;
1301         struct fscrypt_name old_nm, new_nm;
1302
1303         /*
1304          * Budget request settings:
1305          *   req: deletion direntry, new direntry, removing the old inode,
1306          *   and changing old and new parent directory inodes.
1307          *
1308          *   wht_req: new whiteout inode for RENAME_WHITEOUT.
1309          *
1310          *   ino_req: marks the target inode as dirty and does not write it.
1311          */
1312
1313         dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1314                 old_dentry, old_inode->i_ino, old_dir->i_ino,
1315                 new_dentry, new_dir->i_ino, flags);
1316
1317         if (unlink) {
1318                 ubifs_assert(c, inode_is_locked(new_inode));
1319
1320                 /* Budget for old inode's data when its nlink > 1. */
1321                 req.dirtied_ino_d = ALIGN(ubifs_inode(new_inode)->data_len, 8);
1322                 err = ubifs_purge_xattrs(new_inode);
1323                 if (err)
1324                         return err;
1325         }
1326
1327         if (unlink && is_dir) {
1328                 err = ubifs_check_dir_empty(new_inode);
1329                 if (err)
1330                         return err;
1331         }
1332
1333         err = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &old_nm);
1334         if (err)
1335                 return err;
1336
1337         err = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &new_nm);
1338         if (err) {
1339                 fscrypt_free_filename(&old_nm);
1340                 return err;
1341         }
1342
1343         new_sz = CALC_DENT_SIZE(fname_len(&new_nm));
1344         old_sz = CALC_DENT_SIZE(fname_len(&old_nm));
1345
1346         err = ubifs_budget_space(c, &req);
1347         if (err) {
1348                 fscrypt_free_filename(&old_nm);
1349                 fscrypt_free_filename(&new_nm);
1350                 return err;
1351         }
1352         err = ubifs_budget_space(c, &ino_req);
1353         if (err) {
1354                 fscrypt_free_filename(&old_nm);
1355                 fscrypt_free_filename(&new_nm);
1356                 ubifs_release_budget(c, &req);
1357                 return err;
1358         }
1359
1360         if (flags & RENAME_WHITEOUT) {
1361                 union ubifs_dev_desc *dev = NULL;
1362
1363                 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
1364                 if (!dev) {
1365                         err = -ENOMEM;
1366                         goto out_release;
1367                 }
1368
1369                 /*
1370                  * The whiteout inode without dentry is pinned in memory,
1371                  * umount won't happen during rename process because we
1372                  * got parent dentry.
1373                  */
1374                 whiteout = create_whiteout(old_dir, old_dentry);
1375                 if (IS_ERR(whiteout)) {
1376                         err = PTR_ERR(whiteout);
1377                         kfree(dev);
1378                         goto out_release;
1379                 }
1380
1381                 whiteout_ui = ubifs_inode(whiteout);
1382                 whiteout_ui->data = dev;
1383                 whiteout_ui->data_len = ubifs_encode_dev(dev, MKDEV(0, 0));
1384                 ubifs_assert(c, !whiteout_ui->dirty);
1385
1386                 memset(&wht_req, 0, sizeof(struct ubifs_budget_req));
1387                 wht_req.new_ino = 1;
1388                 wht_req.new_ino_d = ALIGN(whiteout_ui->data_len, 8);
1389                 /*
1390                  * To avoid deadlock between space budget (holds ui_mutex and
1391                  * waits wb work) and writeback work(waits ui_mutex), do space
1392                  * budget before ubifs inodes locked.
1393                  */
1394                 err = ubifs_budget_space(c, &wht_req);
1395                 if (err) {
1396                         /*
1397                          * Whiteout inode can not be written on flash by
1398                          * ubifs_jnl_write_inode(), because it's neither
1399                          * dirty nor zero-nlink.
1400                          */
1401                         iput(whiteout);
1402                         goto out_release;
1403                 }
1404
1405                 /* Add the old_dentry size to the old_dir size. */
1406                 old_sz -= CALC_DENT_SIZE(fname_len(&old_nm));
1407         }
1408
1409         lock_4_inodes(old_dir, new_dir, new_inode, whiteout);
1410
1411         /*
1412          * Like most other Unix systems, set the @i_ctime for inodes on a
1413          * rename.
1414          */
1415         simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry);
1416
1417         /* We must adjust parent link count when renaming directories */
1418         if (is_dir) {
1419                 if (move) {
1420                         /*
1421                          * @old_dir loses a link because we are moving
1422                          * @old_inode to a different directory.
1423                          */
1424                         drop_nlink(old_dir);
1425                         /*
1426                          * @new_dir only gains a link if we are not also
1427                          * overwriting an existing directory.
1428                          */
1429                         if (!unlink)
1430                                 inc_nlink(new_dir);
1431                 } else {
1432                         /*
1433                          * @old_inode is not moving to a different directory,
1434                          * but @old_dir still loses a link if we are
1435                          * overwriting an existing directory.
1436                          */
1437                         if (unlink)
1438                                 drop_nlink(old_dir);
1439                 }
1440         }
1441
1442         old_dir->i_size -= old_sz;
1443         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1444
1445         /*
1446          * And finally, if we unlinked a direntry which happened to have the
1447          * same name as the moved direntry, we have to decrement @i_nlink of
1448          * the unlinked inode.
1449          */
1450         if (unlink) {
1451                 /*
1452                  * Directories cannot have hard-links, so if this is a
1453                  * directory, just clear @i_nlink.
1454                  */
1455                 saved_nlink = new_inode->i_nlink;
1456                 if (is_dir)
1457                         clear_nlink(new_inode);
1458                 else
1459                         drop_nlink(new_inode);
1460         } else {
1461                 new_dir->i_size += new_sz;
1462                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1463         }
1464
1465         /*
1466          * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1467          * is dirty, because this will be done later on at the end of
1468          * 'ubifs_rename()'.
1469          */
1470         if (IS_SYNC(old_inode)) {
1471                 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1472                 if (unlink && IS_SYNC(new_inode))
1473                         sync = 1;
1474                 /*
1475                  * S_SYNC flag of whiteout inherits from the old_dir, and we
1476                  * have already checked the old dir inode. So there is no need
1477                  * to check whiteout.
1478                  */
1479         }
1480
1481         err = ubifs_jnl_rename(c, old_dir, old_inode, &old_nm, new_dir,
1482                                new_inode, &new_nm, whiteout, sync);
1483         if (err)
1484                 goto out_cancel;
1485
1486         unlock_4_inodes(old_dir, new_dir, new_inode, whiteout);
1487         ubifs_release_budget(c, &req);
1488
1489         if (whiteout) {
1490                 ubifs_release_budget(c, &wht_req);
1491                 iput(whiteout);
1492         }
1493
1494         mutex_lock(&old_inode_ui->ui_mutex);
1495         release = old_inode_ui->dirty;
1496         mark_inode_dirty_sync(old_inode);
1497         mutex_unlock(&old_inode_ui->ui_mutex);
1498
1499         if (release)
1500                 ubifs_release_budget(c, &ino_req);
1501         if (IS_SYNC(old_inode))
1502                 /*
1503                  * Rename finished here. Although old inode cannot be updated
1504                  * on flash, old ctime is not a big problem, don't return err
1505                  * code to userspace.
1506                  */
1507                 old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1508
1509         fscrypt_free_filename(&old_nm);
1510         fscrypt_free_filename(&new_nm);
1511         return 0;
1512
1513 out_cancel:
1514         if (unlink) {
1515                 set_nlink(new_inode, saved_nlink);
1516         } else {
1517                 new_dir->i_size -= new_sz;
1518                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1519         }
1520         old_dir->i_size += old_sz;
1521         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1522         if (is_dir) {
1523                 if (move) {
1524                         inc_nlink(old_dir);
1525                         if (!unlink)
1526                                 drop_nlink(new_dir);
1527                 } else {
1528                         if (unlink)
1529                                 inc_nlink(old_dir);
1530                 }
1531         }
1532         unlock_4_inodes(old_dir, new_dir, new_inode, whiteout);
1533         if (whiteout) {
1534                 ubifs_release_budget(c, &wht_req);
1535                 iput(whiteout);
1536         }
1537 out_release:
1538         ubifs_release_budget(c, &ino_req);
1539         ubifs_release_budget(c, &req);
1540         fscrypt_free_filename(&old_nm);
1541         fscrypt_free_filename(&new_nm);
1542         return err;
1543 }
1544
1545 static int ubifs_xrename(struct inode *old_dir, struct dentry *old_dentry,
1546                         struct inode *new_dir, struct dentry *new_dentry)
1547 {
1548         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
1549         struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
1550                                 .dirtied_ino = 2 };
1551         int sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1552         struct inode *fst_inode = d_inode(old_dentry);
1553         struct inode *snd_inode = d_inode(new_dentry);
1554         int err;
1555         struct fscrypt_name fst_nm, snd_nm;
1556
1557         ubifs_assert(c, fst_inode && snd_inode);
1558
1559         /*
1560          * Budget request settings: changing two direntries, changing the two
1561          * parent directory inodes.
1562          */
1563
1564         dbg_gen("dent '%pd' ino %lu in dir ino %lu exchange dent '%pd' ino %lu in dir ino %lu",
1565                 old_dentry, fst_inode->i_ino, old_dir->i_ino,
1566                 new_dentry, snd_inode->i_ino, new_dir->i_ino);
1567
1568         err = fscrypt_setup_filename(old_dir, &old_dentry->d_name, 0, &fst_nm);
1569         if (err)
1570                 return err;
1571
1572         err = fscrypt_setup_filename(new_dir, &new_dentry->d_name, 0, &snd_nm);
1573         if (err) {
1574                 fscrypt_free_filename(&fst_nm);
1575                 return err;
1576         }
1577
1578         err = ubifs_budget_space(c, &req);
1579         if (err)
1580                 goto out;
1581
1582         lock_4_inodes(old_dir, new_dir, NULL, NULL);
1583
1584         simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry);
1585
1586         if (old_dir != new_dir) {
1587                 if (S_ISDIR(fst_inode->i_mode) && !S_ISDIR(snd_inode->i_mode)) {
1588                         inc_nlink(new_dir);
1589                         drop_nlink(old_dir);
1590                 }
1591                 else if (!S_ISDIR(fst_inode->i_mode) && S_ISDIR(snd_inode->i_mode)) {
1592                         drop_nlink(new_dir);
1593                         inc_nlink(old_dir);
1594                 }
1595         }
1596
1597         err = ubifs_jnl_xrename(c, old_dir, fst_inode, &fst_nm, new_dir,
1598                                 snd_inode, &snd_nm, sync);
1599
1600         unlock_4_inodes(old_dir, new_dir, NULL, NULL);
1601         ubifs_release_budget(c, &req);
1602
1603 out:
1604         fscrypt_free_filename(&fst_nm);
1605         fscrypt_free_filename(&snd_nm);
1606         return err;
1607 }
1608
1609 static int ubifs_rename(struct mnt_idmap *idmap,
1610                         struct inode *old_dir, struct dentry *old_dentry,
1611                         struct inode *new_dir, struct dentry *new_dentry,
1612                         unsigned int flags)
1613 {
1614         int err;
1615         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
1616
1617         if (flags & ~(RENAME_NOREPLACE | RENAME_WHITEOUT | RENAME_EXCHANGE))
1618                 return -EINVAL;
1619
1620         ubifs_assert(c, inode_is_locked(old_dir));
1621         ubifs_assert(c, inode_is_locked(new_dir));
1622
1623         err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
1624                                      flags);
1625         if (err)
1626                 return err;
1627
1628         if (flags & RENAME_EXCHANGE)
1629                 return ubifs_xrename(old_dir, old_dentry, new_dir, new_dentry);
1630
1631         return do_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
1632 }
1633
1634 int ubifs_getattr(struct mnt_idmap *idmap, const struct path *path,
1635                   struct kstat *stat, u32 request_mask, unsigned int flags)
1636 {
1637         loff_t size;
1638         struct inode *inode = d_inode(path->dentry);
1639         struct ubifs_inode *ui = ubifs_inode(inode);
1640
1641         mutex_lock(&ui->ui_mutex);
1642
1643         if (ui->flags & UBIFS_APPEND_FL)
1644                 stat->attributes |= STATX_ATTR_APPEND;
1645         if (ui->flags & UBIFS_COMPR_FL)
1646                 stat->attributes |= STATX_ATTR_COMPRESSED;
1647         if (ui->flags & UBIFS_CRYPT_FL)
1648                 stat->attributes |= STATX_ATTR_ENCRYPTED;
1649         if (ui->flags & UBIFS_IMMUTABLE_FL)
1650                 stat->attributes |= STATX_ATTR_IMMUTABLE;
1651
1652         stat->attributes_mask |= (STATX_ATTR_APPEND |
1653                                 STATX_ATTR_COMPRESSED |
1654                                 STATX_ATTR_ENCRYPTED |
1655                                 STATX_ATTR_IMMUTABLE);
1656
1657         generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
1658         stat->blksize = UBIFS_BLOCK_SIZE;
1659         stat->size = ui->ui_size;
1660
1661         /*
1662          * Unfortunately, the 'stat()' system call was designed for block
1663          * device based file systems, and it is not appropriate for UBIFS,
1664          * because UBIFS does not have notion of "block". For example, it is
1665          * difficult to tell how many block a directory takes - it actually
1666          * takes less than 300 bytes, but we have to round it to block size,
1667          * which introduces large mistake. This makes utilities like 'du' to
1668          * report completely senseless numbers. This is the reason why UBIFS
1669          * goes the same way as JFFS2 - it reports zero blocks for everything
1670          * but regular files, which makes more sense than reporting completely
1671          * wrong sizes.
1672          */
1673         if (S_ISREG(inode->i_mode)) {
1674                 size = ui->xattr_size;
1675                 size += stat->size;
1676                 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1677                 /*
1678                  * Note, user-space expects 512-byte blocks count irrespectively
1679                  * of what was reported in @stat->size.
1680                  */
1681                 stat->blocks = size >> 9;
1682         } else
1683                 stat->blocks = 0;
1684         mutex_unlock(&ui->ui_mutex);
1685         return 0;
1686 }
1687
1688 const struct inode_operations ubifs_dir_inode_operations = {
1689         .lookup      = ubifs_lookup,
1690         .create      = ubifs_create,
1691         .link        = ubifs_link,
1692         .symlink     = ubifs_symlink,
1693         .unlink      = ubifs_unlink,
1694         .mkdir       = ubifs_mkdir,
1695         .rmdir       = ubifs_rmdir,
1696         .mknod       = ubifs_mknod,
1697         .rename      = ubifs_rename,
1698         .setattr     = ubifs_setattr,
1699         .getattr     = ubifs_getattr,
1700         .listxattr   = ubifs_listxattr,
1701         .update_time = ubifs_update_time,
1702         .tmpfile     = ubifs_tmpfile,
1703         .fileattr_get = ubifs_fileattr_get,
1704         .fileattr_set = ubifs_fileattr_set,
1705 };
1706
1707 const struct file_operations ubifs_dir_operations = {
1708         .llseek         = generic_file_llseek,
1709         .release        = ubifs_dir_release,
1710         .read           = generic_read_dir,
1711         .iterate_shared = ubifs_readdir,
1712         .fsync          = ubifs_fsync,
1713         .unlocked_ioctl = ubifs_ioctl,
1714 #ifdef CONFIG_COMPAT
1715         .compat_ioctl   = ubifs_compat_ioctl,
1716 #endif
1717 };