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