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