1 /* * This file is part of UBIFS.
3 * Copyright (C) 2006-2008 Nokia Corporation.
4 * Copyright (C) 2006, 2007 University of Szeged, Hungary
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc., 51
17 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
25 * This file implements directory operations.
27 * All FS operations in this file allocate budget before writing anything to the
28 * media. If they fail to allocate it, the error is returned. The only
29 * exceptions are 'ubifs_unlink()' and 'ubifs_rmdir()' which keep working even
30 * if they unable to allocate the budget, because deletion %-ENOSPC failure is
31 * not what users are usually ready to get. UBIFS budgeting subsystem has some
32 * space reserved for these purposes.
34 * All operations in this file write all inodes which they change straight
35 * away, instead of marking them dirty. For example, 'ubifs_link()' changes
36 * @i_size of the parent inode and writes the parent inode together with the
37 * target inode. This was done to simplify file-system recovery which would
38 * otherwise be very difficult to do. The only exception is rename which marks
39 * the re-named inode dirty (because its @i_ctime is updated) but does not
40 * write it, but just marks it as dirty.
46 * inherit_flags - inherit flags of the parent inode.
48 * @mode: new inode mode flags
50 * This is a helper function for 'ubifs_new_inode()' which inherits flag of the
51 * parent directory inode @dir. UBIFS inodes inherit the following flags:
52 * o %UBIFS_COMPR_FL, which is useful to switch compression on/of on
53 * sub-directory basis;
54 * o %UBIFS_SYNC_FL - useful for the same reasons;
55 * o %UBIFS_DIRSYNC_FL - similar, but relevant only to directories.
57 * This function returns the inherited flags.
59 static int inherit_flags(const struct inode
*dir
, umode_t mode
)
62 const struct ubifs_inode
*ui
= ubifs_inode(dir
);
64 if (!S_ISDIR(dir
->i_mode
))
66 * The parent is not a directory, which means that an extended
67 * attribute inode is being created. No flags.
71 flags
= ui
->flags
& (UBIFS_COMPR_FL
| UBIFS_SYNC_FL
| UBIFS_DIRSYNC_FL
);
73 /* The "DIRSYNC" flag only applies to directories */
74 flags
&= ~UBIFS_DIRSYNC_FL
;
79 * ubifs_new_inode - allocate new UBIFS inode object.
80 * @c: UBIFS file-system description object
81 * @dir: parent directory inode
82 * @mode: inode mode flags
84 * This function finds an unused inode number, allocates new inode and
85 * initializes it. Returns new inode in case of success and an error code in
88 struct inode
*ubifs_new_inode(struct ubifs_info
*c
, struct inode
*dir
,
93 struct ubifs_inode
*ui
;
94 bool encrypted
= false;
96 if (ubifs_crypt_is_encrypted(dir
)) {
97 err
= fscrypt_get_encryption_info(dir
);
99 ubifs_err(c
, "fscrypt_get_encryption_info failed: %i", err
);
103 if (!fscrypt_has_encryption_key(dir
))
104 return ERR_PTR(-EPERM
);
109 inode
= new_inode(c
->vfs_sb
);
110 ui
= ubifs_inode(inode
);
112 return ERR_PTR(-ENOMEM
);
115 * Set 'S_NOCMTIME' to prevent VFS form updating [mc]time of inodes and
116 * marking them dirty in file write path (see 'file_update_time()').
117 * UBIFS has to fully control "clean <-> dirty" transitions of inodes
118 * to make budgeting work.
120 inode
->i_flags
|= S_NOCMTIME
;
122 inode_init_owner(inode
, dir
, mode
);
123 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
=
125 inode
->i_mapping
->nrpages
= 0;
127 switch (mode
& S_IFMT
) {
129 inode
->i_mapping
->a_ops
= &ubifs_file_address_operations
;
130 inode
->i_op
= &ubifs_file_inode_operations
;
131 inode
->i_fop
= &ubifs_file_operations
;
134 inode
->i_op
= &ubifs_dir_inode_operations
;
135 inode
->i_fop
= &ubifs_dir_operations
;
136 inode
->i_size
= ui
->ui_size
= UBIFS_INO_NODE_SZ
;
139 inode
->i_op
= &ubifs_symlink_inode_operations
;
145 inode
->i_op
= &ubifs_file_inode_operations
;
152 ui
->flags
= inherit_flags(dir
, mode
);
153 ubifs_set_inode_flags(inode
);
155 ui
->compr_type
= c
->default_compr
;
157 ui
->compr_type
= UBIFS_COMPR_NONE
;
158 ui
->synced_i_size
= 0;
160 spin_lock(&c
->cnt_lock
);
161 /* Inode number overflow is currently not supported */
162 if (c
->highest_inum
>= INUM_WARN_WATERMARK
) {
163 if (c
->highest_inum
>= INUM_WATERMARK
) {
164 spin_unlock(&c
->cnt_lock
);
165 ubifs_err(c
, "out of inode numbers");
166 make_bad_inode(inode
);
168 return ERR_PTR(-EINVAL
);
170 ubifs_warn(c
, "running out of inode numbers (current %lu, max %u)",
171 (unsigned long)c
->highest_inum
, INUM_WATERMARK
);
174 inode
->i_ino
= ++c
->highest_inum
;
176 * The creation sequence number remains with this inode for its
177 * lifetime. All nodes for this inode have a greater sequence number,
178 * and so it is possible to distinguish obsolete nodes belonging to a
179 * previous incarnation of the same inode number - for example, for the
180 * purpose of rebuilding the index.
182 ui
->creat_sqnum
= ++c
->max_sqnum
;
183 spin_unlock(&c
->cnt_lock
);
186 err
= fscrypt_inherit_context(dir
, inode
, &encrypted
, true);
188 ubifs_err(c
, "fscrypt_inherit_context failed: %i", err
);
189 make_bad_inode(inode
);
198 static int dbg_check_name(const struct ubifs_info
*c
,
199 const struct ubifs_dent_node
*dent
,
200 const struct fscrypt_name
*nm
)
202 if (!dbg_is_chk_gen(c
))
204 if (le16_to_cpu(dent
->nlen
) != fname_len(nm
))
206 if (memcmp(dent
->name
, fname_name(nm
), fname_len(nm
)))
211 static struct dentry
*ubifs_lookup(struct inode
*dir
, struct dentry
*dentry
,
216 struct inode
*inode
= NULL
;
217 struct ubifs_dent_node
*dent
;
218 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
219 struct fscrypt_name nm
;
221 dbg_gen("'%pd' in dir ino %lu", dentry
, dir
->i_ino
);
223 if (ubifs_crypt_is_encrypted(dir
)) {
224 err
= fscrypt_get_encryption_info(dir
);
227 * DCACHE_ENCRYPTED_WITH_KEY is set if the dentry is
228 * created while the directory was encrypted and we
229 * have access to the key.
231 if (fscrypt_has_encryption_key(dir
))
232 fscrypt_set_encrypted_dentry(dentry
);
233 fscrypt_set_d_op(dentry
);
234 if (err
&& err
!= -ENOKEY
)
238 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, &nm
);
242 if (fname_len(&nm
) > UBIFS_MAX_NLEN
) {
247 dent
= kmalloc(UBIFS_MAX_DENT_NODE_SZ
, GFP_NOFS
);
254 ubifs_assert(fname_len(&nm
) == 0);
255 ubifs_assert(fname_name(&nm
) == NULL
);
256 dent_key_init_hash(c
, &key
, dir
->i_ino
, nm
.hash
);
257 err
= ubifs_tnc_lookup_dh(c
, &key
, dent
, nm
.minor_hash
);
259 dent_key_init(c
, &key
, dir
->i_ino
, &nm
);
260 err
= ubifs_tnc_lookup_nm(c
, &key
, dent
, &nm
);
264 if (err
== -ENOENT
) {
265 dbg_gen("not found");
271 if (dbg_check_name(c
, dent
, &nm
)) {
276 inode
= ubifs_iget(dir
->i_sb
, le64_to_cpu(dent
->inum
));
279 * This should not happen. Probably the file-system needs
282 err
= PTR_ERR(inode
);
283 ubifs_err(c
, "dead directory entry '%pd', error %d",
285 ubifs_ro_mode(c
, err
);
289 if (ubifs_crypt_is_encrypted(dir
) &&
290 (S_ISDIR(inode
->i_mode
) || S_ISLNK(inode
->i_mode
)) &&
291 !fscrypt_has_permitted_context(dir
, inode
)) {
292 ubifs_warn(c
, "Inconsistent encryption contexts: %lu/%lu",
293 dir
->i_ino
, inode
->i_ino
);
300 fscrypt_free_filename(&nm
);
302 * Note, d_splice_alias() would be required instead if we supported
305 d_add(dentry
, inode
);
313 fscrypt_free_filename(&nm
);
317 static int ubifs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
321 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
322 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
324 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
325 struct fscrypt_name nm
;
329 * Budget request settings: new inode, new direntry, changing the
330 * parent directory inode.
333 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
334 dentry
, mode
, dir
->i_ino
);
336 err
= ubifs_budget_space(c
, &req
);
340 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
344 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
346 inode
= ubifs_new_inode(c
, dir
, mode
);
348 err
= PTR_ERR(inode
);
352 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
356 mutex_lock(&dir_ui
->ui_mutex
);
357 dir
->i_size
+= sz_change
;
358 dir_ui
->ui_size
= dir
->i_size
;
359 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
360 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
363 mutex_unlock(&dir_ui
->ui_mutex
);
365 ubifs_release_budget(c
, &req
);
366 fscrypt_free_filename(&nm
);
367 insert_inode_hash(inode
);
368 d_instantiate(dentry
, inode
);
372 dir
->i_size
-= sz_change
;
373 dir_ui
->ui_size
= dir
->i_size
;
374 mutex_unlock(&dir_ui
->ui_mutex
);
376 make_bad_inode(inode
);
379 fscrypt_free_filename(&nm
);
381 ubifs_release_budget(c
, &req
);
382 ubifs_err(c
, "cannot create regular file, error %d", err
);
386 static int do_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
387 umode_t mode
, struct inode
**whiteout
)
390 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
391 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1};
392 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1 };
393 struct ubifs_inode
*ui
, *dir_ui
= ubifs_inode(dir
);
394 int err
, instantiated
= 0;
395 struct fscrypt_name nm
;
398 * Budget request settings: new dirty inode, new direntry,
399 * budget for dirtied inode will be released via writeback.
402 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
403 dentry
, mode
, dir
->i_ino
);
405 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
409 err
= ubifs_budget_space(c
, &req
);
411 fscrypt_free_filename(&nm
);
415 err
= ubifs_budget_space(c
, &ino_req
);
417 ubifs_release_budget(c
, &req
);
418 fscrypt_free_filename(&nm
);
422 inode
= ubifs_new_inode(c
, dir
, mode
);
424 err
= PTR_ERR(inode
);
427 ui
= ubifs_inode(inode
);
430 init_special_inode(inode
, inode
->i_mode
, WHITEOUT_DEV
);
431 ubifs_assert(inode
->i_op
== &ubifs_file_inode_operations
);
434 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
438 mutex_lock(&ui
->ui_mutex
);
439 insert_inode_hash(inode
);
442 mark_inode_dirty(inode
);
446 d_tmpfile(dentry
, inode
);
448 ubifs_assert(ui
->dirty
);
451 mutex_unlock(&ui
->ui_mutex
);
453 mutex_lock(&dir_ui
->ui_mutex
);
454 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 1, 0);
457 mutex_unlock(&dir_ui
->ui_mutex
);
459 ubifs_release_budget(c
, &req
);
464 mutex_unlock(&dir_ui
->ui_mutex
);
466 make_bad_inode(inode
);
470 ubifs_release_budget(c
, &req
);
472 ubifs_release_budget(c
, &ino_req
);
473 fscrypt_free_filename(&nm
);
474 ubifs_err(c
, "cannot create temporary file, error %d", err
);
478 static int ubifs_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
481 return do_tmpfile(dir
, dentry
, mode
, NULL
);
485 * vfs_dent_type - get VFS directory entry type.
486 * @type: UBIFS directory entry type
488 * This function converts UBIFS directory entry type into VFS directory entry
491 static unsigned int vfs_dent_type(uint8_t type
)
494 case UBIFS_ITYPE_REG
:
496 case UBIFS_ITYPE_DIR
:
498 case UBIFS_ITYPE_LNK
:
500 case UBIFS_ITYPE_BLK
:
502 case UBIFS_ITYPE_CHR
:
504 case UBIFS_ITYPE_FIFO
:
506 case UBIFS_ITYPE_SOCK
:
515 * The classical Unix view for directory is that it is a linear array of
516 * (name, inode number) entries. Linux/VFS assumes this model as well.
517 * Particularly, 'readdir()' call wants us to return a directory entry offset
518 * which later may be used to continue 'readdir()'ing the directory or to
519 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
520 * model because directory entries are identified by keys, which may collide.
522 * UBIFS uses directory entry hash value for directory offsets, so
523 * 'seekdir()'/'telldir()' may not always work because of possible key
524 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
525 * properly by means of saving full directory entry name in the private field
526 * of the file description object.
528 * This means that UBIFS cannot support NFS which requires full
529 * 'seekdir()'/'telldir()' support.
531 static int ubifs_readdir(struct file
*file
, struct dir_context
*ctx
)
533 int fstr_real_len
= 0, err
= 0;
534 struct fscrypt_name nm
;
535 struct fscrypt_str fstr
= {0};
537 struct ubifs_dent_node
*dent
;
538 struct inode
*dir
= file_inode(file
);
539 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
540 bool encrypted
= ubifs_crypt_is_encrypted(dir
);
542 dbg_gen("dir ino %lu, f_pos %#llx", dir
->i_ino
, ctx
->pos
);
544 if (ctx
->pos
> UBIFS_S_KEY_HASH_MASK
|| ctx
->pos
== 2)
546 * The directory was seek'ed to a senseless position or there
547 * are no more entries.
552 err
= fscrypt_get_encryption_info(dir
);
553 if (err
&& err
!= -ENOKEY
)
556 err
= fscrypt_fname_alloc_buffer(dir
, UBIFS_MAX_NLEN
, &fstr
);
560 fstr_real_len
= fstr
.len
;
563 if (file
->f_version
== 0) {
565 * The file was seek'ed, which means that @file->private_data
566 * is now invalid. This may also be just the first
567 * 'ubifs_readdir()' invocation, in which case
568 * @file->private_data is NULL, and the below code is
571 kfree(file
->private_data
);
572 file
->private_data
= NULL
;
576 * 'generic_file_llseek()' unconditionally sets @file->f_version to
577 * zero, and we use this for detecting whether the file was seek'ed.
581 /* File positions 0 and 1 correspond to "." and ".." */
583 ubifs_assert(!file
->private_data
);
584 if (!dir_emit_dots(file
, ctx
)) {
586 fscrypt_fname_free_buffer(&fstr
);
590 /* Find the first entry in TNC and save it */
591 lowest_dent_key(c
, &key
, dir
->i_ino
);
593 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
599 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
600 file
->private_data
= dent
;
603 dent
= file
->private_data
;
606 * The directory was seek'ed to and is now readdir'ed.
607 * Find the entry corresponding to @ctx->pos or the closest one.
609 dent_key_init_hash(c
, &key
, dir
->i_ino
, ctx
->pos
);
611 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
616 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
617 file
->private_data
= dent
;
621 dbg_gen("ino %llu, new f_pos %#x",
622 (unsigned long long)le64_to_cpu(dent
->inum
),
623 key_hash_flash(c
, &dent
->key
));
624 ubifs_assert(le64_to_cpu(dent
->ch
.sqnum
) >
625 ubifs_inode(dir
)->creat_sqnum
);
627 fname_len(&nm
) = le16_to_cpu(dent
->nlen
);
628 fname_name(&nm
) = dent
->name
;
631 fstr
.len
= fstr_real_len
;
633 err
= fscrypt_fname_disk_to_usr(dir
, key_hash_flash(c
,
635 le32_to_cpu(dent
->cookie
),
636 &nm
.disk_name
, &fstr
);
640 fstr
.len
= fname_len(&nm
);
641 fstr
.name
= fname_name(&nm
);
644 if (!dir_emit(ctx
, fstr
.name
, fstr
.len
,
645 le64_to_cpu(dent
->inum
),
646 vfs_dent_type(dent
->type
))) {
648 fscrypt_fname_free_buffer(&fstr
);
652 /* Switch to the next entry */
653 key_read(c
, &dent
->key
, &key
);
654 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
660 kfree(file
->private_data
);
661 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
662 file
->private_data
= dent
;
667 kfree(file
->private_data
);
668 file
->private_data
= NULL
;
671 fscrypt_fname_free_buffer(&fstr
);
674 ubifs_err(c
, "cannot find next direntry, error %d", err
);
677 * -ENOENT is a non-fatal error in this context, the TNC uses
678 * it to indicate that the cursor moved past the current directory
679 * and readdir() has to stop.
684 /* 2 is a special value indicating that there are no more direntries */
689 /* Free saved readdir() state when the directory is closed */
690 static int ubifs_dir_release(struct inode
*dir
, struct file
*file
)
692 kfree(file
->private_data
);
693 file
->private_data
= NULL
;
698 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
699 * @inode1: first inode
700 * @inode2: second inode
702 * We do not implement any tricks to guarantee strict lock ordering, because
703 * VFS has already done it for us on the @i_mutex. So this is just a simple
706 static void lock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
708 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
709 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
713 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
714 * @inode1: first inode
715 * @inode2: second inode
717 static void unlock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
719 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
720 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
723 static int ubifs_link(struct dentry
*old_dentry
, struct inode
*dir
,
724 struct dentry
*dentry
)
726 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
727 struct inode
*inode
= d_inode(old_dentry
);
728 struct ubifs_inode
*ui
= ubifs_inode(inode
);
729 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
730 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
731 struct ubifs_budget_req req
= { .new_dent
= 1, .dirtied_ino
= 2,
732 .dirtied_ino_d
= ALIGN(ui
->data_len
, 8) };
733 struct fscrypt_name nm
;
736 * Budget request settings: new direntry, changing the target inode,
737 * changing the parent inode.
740 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
741 dentry
, inode
->i_ino
,
742 inode
->i_nlink
, dir
->i_ino
);
743 ubifs_assert(inode_is_locked(dir
));
744 ubifs_assert(inode_is_locked(inode
));
746 if (ubifs_crypt_is_encrypted(dir
) &&
747 !fscrypt_has_permitted_context(dir
, inode
))
750 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
754 err
= dbg_check_synced_i_size(c
, inode
);
758 err
= ubifs_budget_space(c
, &req
);
762 lock_2_inodes(dir
, inode
);
764 /* Handle O_TMPFILE corner case, it is allowed to link a O_TMPFILE. */
765 if (inode
->i_nlink
== 0)
766 ubifs_delete_orphan(c
, inode
->i_ino
);
770 inode
->i_ctime
= current_time(inode
);
771 dir
->i_size
+= sz_change
;
772 dir_ui
->ui_size
= dir
->i_size
;
773 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
774 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
777 unlock_2_inodes(dir
, inode
);
779 ubifs_release_budget(c
, &req
);
780 d_instantiate(dentry
, inode
);
781 fscrypt_free_filename(&nm
);
785 dir
->i_size
-= sz_change
;
786 dir_ui
->ui_size
= dir
->i_size
;
788 if (inode
->i_nlink
== 0)
789 ubifs_add_orphan(c
, inode
->i_ino
);
790 unlock_2_inodes(dir
, inode
);
791 ubifs_release_budget(c
, &req
);
794 fscrypt_free_filename(&nm
);
798 static int ubifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
800 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
801 struct inode
*inode
= d_inode(dentry
);
802 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
803 int err
, sz_change
, budgeted
= 1;
804 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
805 unsigned int saved_nlink
= inode
->i_nlink
;
806 struct fscrypt_name nm
;
809 * Budget request settings: deletion direntry, deletion inode (+1 for
810 * @dirtied_ino), changing the parent directory inode. If budgeting
811 * fails, go ahead anyway because we have extra space reserved for
815 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
816 dentry
, inode
->i_ino
,
817 inode
->i_nlink
, dir
->i_ino
);
819 if (ubifs_crypt_is_encrypted(dir
)) {
820 err
= fscrypt_get_encryption_info(dir
);
821 if (err
&& err
!= -ENOKEY
)
825 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, &nm
);
829 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
831 ubifs_assert(inode_is_locked(dir
));
832 ubifs_assert(inode_is_locked(inode
));
833 err
= dbg_check_synced_i_size(c
, inode
);
837 err
= ubifs_budget_space(c
, &req
);
844 lock_2_inodes(dir
, inode
);
845 inode
->i_ctime
= current_time(dir
);
847 dir
->i_size
-= sz_change
;
848 dir_ui
->ui_size
= dir
->i_size
;
849 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
850 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 1, 0);
853 unlock_2_inodes(dir
, inode
);
856 ubifs_release_budget(c
, &req
);
858 /* We've deleted something - clean the "no space" flags */
859 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
862 fscrypt_free_filename(&nm
);
866 dir
->i_size
+= sz_change
;
867 dir_ui
->ui_size
= dir
->i_size
;
868 set_nlink(inode
, saved_nlink
);
869 unlock_2_inodes(dir
, inode
);
871 ubifs_release_budget(c
, &req
);
873 fscrypt_free_filename(&nm
);
878 * check_dir_empty - check if a directory is empty or not.
879 * @dir: VFS inode object of the directory to check
881 * This function checks if directory @dir is empty. Returns zero if the
882 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
883 * in case of of errors.
885 int ubifs_check_dir_empty(struct inode
*dir
)
887 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
888 struct fscrypt_name nm
= { 0 };
889 struct ubifs_dent_node
*dent
;
893 lowest_dent_key(c
, &key
, dir
->i_ino
);
894 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
906 static int ubifs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
908 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
909 struct inode
*inode
= d_inode(dentry
);
910 int err
, sz_change
, budgeted
= 1;
911 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
912 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
913 struct fscrypt_name nm
;
916 * Budget request settings: deletion direntry, deletion inode and
917 * changing the parent inode. If budgeting fails, go ahead anyway
918 * because we have extra space reserved for deletions.
921 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry
,
922 inode
->i_ino
, dir
->i_ino
);
923 ubifs_assert(inode_is_locked(dir
));
924 ubifs_assert(inode_is_locked(inode
));
925 err
= ubifs_check_dir_empty(d_inode(dentry
));
929 if (ubifs_crypt_is_encrypted(dir
)) {
930 err
= fscrypt_get_encryption_info(dir
);
931 if (err
&& err
!= -ENOKEY
)
935 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, &nm
);
939 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
941 err
= ubifs_budget_space(c
, &req
);
948 lock_2_inodes(dir
, inode
);
949 inode
->i_ctime
= current_time(dir
);
952 dir
->i_size
-= sz_change
;
953 dir_ui
->ui_size
= dir
->i_size
;
954 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
955 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 1, 0);
958 unlock_2_inodes(dir
, inode
);
961 ubifs_release_budget(c
, &req
);
963 /* We've deleted something - clean the "no space" flags */
964 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
967 fscrypt_free_filename(&nm
);
971 dir
->i_size
+= sz_change
;
972 dir_ui
->ui_size
= dir
->i_size
;
975 unlock_2_inodes(dir
, inode
);
977 ubifs_release_budget(c
, &req
);
979 fscrypt_free_filename(&nm
);
983 static int ubifs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
986 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
987 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
989 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1 };
990 struct fscrypt_name nm
;
993 * Budget request settings: new inode, new direntry and changing parent
997 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
998 dentry
, mode
, dir
->i_ino
);
1000 err
= ubifs_budget_space(c
, &req
);
1004 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
1008 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
1010 inode
= ubifs_new_inode(c
, dir
, S_IFDIR
| mode
);
1011 if (IS_ERR(inode
)) {
1012 err
= PTR_ERR(inode
);
1016 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
1020 mutex_lock(&dir_ui
->ui_mutex
);
1021 insert_inode_hash(inode
);
1024 dir
->i_size
+= sz_change
;
1025 dir_ui
->ui_size
= dir
->i_size
;
1026 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1027 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
1029 ubifs_err(c
, "cannot create directory, error %d", err
);
1032 mutex_unlock(&dir_ui
->ui_mutex
);
1034 ubifs_release_budget(c
, &req
);
1035 d_instantiate(dentry
, inode
);
1036 fscrypt_free_filename(&nm
);
1040 dir
->i_size
-= sz_change
;
1041 dir_ui
->ui_size
= dir
->i_size
;
1043 mutex_unlock(&dir_ui
->ui_mutex
);
1045 make_bad_inode(inode
);
1048 fscrypt_free_filename(&nm
);
1050 ubifs_release_budget(c
, &req
);
1054 static int ubifs_mknod(struct inode
*dir
, struct dentry
*dentry
,
1055 umode_t mode
, dev_t rdev
)
1057 struct inode
*inode
;
1058 struct ubifs_inode
*ui
;
1059 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
1060 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
1061 union ubifs_dev_desc
*dev
= NULL
;
1063 int err
, devlen
= 0;
1064 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
1066 struct fscrypt_name nm
;
1069 * Budget request settings: new inode, new direntry and changing parent
1073 dbg_gen("dent '%pd' in dir ino %lu", dentry
, dir
->i_ino
);
1075 if (S_ISBLK(mode
) || S_ISCHR(mode
)) {
1076 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
1079 devlen
= ubifs_encode_dev(dev
, rdev
);
1082 req
.new_ino_d
= ALIGN(devlen
, 8);
1083 err
= ubifs_budget_space(c
, &req
);
1089 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
1095 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
1097 inode
= ubifs_new_inode(c
, dir
, mode
);
1098 if (IS_ERR(inode
)) {
1100 err
= PTR_ERR(inode
);
1104 init_special_inode(inode
, inode
->i_mode
, rdev
);
1105 inode
->i_size
= ubifs_inode(inode
)->ui_size
= devlen
;
1106 ui
= ubifs_inode(inode
);
1108 ui
->data_len
= devlen
;
1110 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
1114 mutex_lock(&dir_ui
->ui_mutex
);
1115 dir
->i_size
+= sz_change
;
1116 dir_ui
->ui_size
= dir
->i_size
;
1117 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1118 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
1121 mutex_unlock(&dir_ui
->ui_mutex
);
1123 ubifs_release_budget(c
, &req
);
1124 insert_inode_hash(inode
);
1125 d_instantiate(dentry
, inode
);
1126 fscrypt_free_filename(&nm
);
1130 dir
->i_size
-= sz_change
;
1131 dir_ui
->ui_size
= dir
->i_size
;
1132 mutex_unlock(&dir_ui
->ui_mutex
);
1134 make_bad_inode(inode
);
1137 fscrypt_free_filename(&nm
);
1139 ubifs_release_budget(c
, &req
);
1143 static int ubifs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1144 const char *symname
)
1146 struct inode
*inode
;
1147 struct ubifs_inode
*ui
;
1148 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
1149 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
1150 int err
, sz_change
, len
= strlen(symname
);
1151 struct fscrypt_str disk_link
= FSTR_INIT((char *)symname
, len
+ 1);
1152 struct fscrypt_symlink_data
*sd
= NULL
;
1153 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
1154 .new_ino_d
= ALIGN(len
, 8),
1156 struct fscrypt_name nm
;
1158 if (ubifs_crypt_is_encrypted(dir
)) {
1159 err
= fscrypt_get_encryption_info(dir
);
1163 if (!fscrypt_has_encryption_key(dir
)) {
1168 disk_link
.len
= (fscrypt_fname_encrypted_size(dir
, len
) +
1169 sizeof(struct fscrypt_symlink_data
));
1173 * Budget request settings: new inode, new direntry and changing parent
1177 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry
,
1178 symname
, dir
->i_ino
);
1180 if (disk_link
.len
> UBIFS_MAX_INO_DATA
)
1181 return -ENAMETOOLONG
;
1183 err
= ubifs_budget_space(c
, &req
);
1187 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
1191 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
1193 inode
= ubifs_new_inode(c
, dir
, S_IFLNK
| S_IRWXUGO
);
1194 if (IS_ERR(inode
)) {
1195 err
= PTR_ERR(inode
);
1199 ui
= ubifs_inode(inode
);
1200 ui
->data
= kmalloc(disk_link
.len
, GFP_NOFS
);
1206 if (ubifs_crypt_is_encrypted(dir
)) {
1207 struct qstr istr
= QSTR_INIT(symname
, len
);
1208 struct fscrypt_str ostr
;
1210 sd
= kzalloc(disk_link
.len
, GFP_NOFS
);
1216 ostr
.name
= sd
->encrypted_path
;
1217 ostr
.len
= disk_link
.len
;
1219 err
= fscrypt_fname_usr_to_disk(inode
, &istr
, &ostr
);
1223 sd
->len
= cpu_to_le16(ostr
.len
);
1224 disk_link
.name
= (char *)sd
;
1226 inode
->i_link
= ui
->data
;
1229 memcpy(ui
->data
, disk_link
.name
, disk_link
.len
);
1230 ((char *)ui
->data
)[disk_link
.len
- 1] = '\0';
1233 * The terminating zero byte is not written to the flash media and it
1234 * is put just to make later in-memory string processing simpler. Thus,
1235 * data length is @len, not @len + %1.
1237 ui
->data_len
= disk_link
.len
- 1;
1238 inode
->i_size
= ubifs_inode(inode
)->ui_size
= disk_link
.len
- 1;
1240 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
1244 mutex_lock(&dir_ui
->ui_mutex
);
1245 dir
->i_size
+= sz_change
;
1246 dir_ui
->ui_size
= dir
->i_size
;
1247 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1248 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
1251 mutex_unlock(&dir_ui
->ui_mutex
);
1253 insert_inode_hash(inode
);
1254 d_instantiate(dentry
, inode
);
1259 dir
->i_size
-= sz_change
;
1260 dir_ui
->ui_size
= dir
->i_size
;
1261 mutex_unlock(&dir_ui
->ui_mutex
);
1263 make_bad_inode(inode
);
1266 fscrypt_free_filename(&nm
);
1268 ubifs_release_budget(c
, &req
);
1274 * lock_4_inodes - a wrapper for locking three UBIFS inodes.
1275 * @inode1: first inode
1276 * @inode2: second inode
1277 * @inode3: third inode
1278 * @inode4: fouth inode
1280 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
1281 * @inode2 whereas @inode3 and @inode4 may be %NULL.
1283 * We do not implement any tricks to guarantee strict lock ordering, because
1284 * VFS has already done it for us on the @i_mutex. So this is just a simple
1287 static void lock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1288 struct inode
*inode3
, struct inode
*inode4
)
1290 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
1291 if (inode2
!= inode1
)
1292 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
1294 mutex_lock_nested(&ubifs_inode(inode3
)->ui_mutex
, WB_MUTEX_3
);
1296 mutex_lock_nested(&ubifs_inode(inode4
)->ui_mutex
, WB_MUTEX_4
);
1300 * unlock_4_inodes - a wrapper for unlocking three UBIFS inodes for rename.
1301 * @inode1: first inode
1302 * @inode2: second inode
1303 * @inode3: third inode
1304 * @inode4: fouth inode
1306 static void unlock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1307 struct inode
*inode3
, struct inode
*inode4
)
1310 mutex_unlock(&ubifs_inode(inode4
)->ui_mutex
);
1312 mutex_unlock(&ubifs_inode(inode3
)->ui_mutex
);
1313 if (inode1
!= inode2
)
1314 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
1315 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
1318 static int do_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1319 struct inode
*new_dir
, struct dentry
*new_dentry
,
1322 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1323 struct inode
*old_inode
= d_inode(old_dentry
);
1324 struct inode
*new_inode
= d_inode(new_dentry
);
1325 struct inode
*whiteout
= NULL
;
1326 struct ubifs_inode
*old_inode_ui
= ubifs_inode(old_inode
);
1327 struct ubifs_inode
*whiteout_ui
= NULL
;
1328 int err
, release
, sync
= 0, move
= (new_dir
!= old_dir
);
1329 int is_dir
= S_ISDIR(old_inode
->i_mode
);
1330 int unlink
= !!new_inode
, new_sz
, old_sz
;
1331 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1333 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1,
1334 .dirtied_ino_d
= ALIGN(old_inode_ui
->data_len
, 8) };
1335 struct timespec time
;
1336 unsigned int uninitialized_var(saved_nlink
);
1337 struct fscrypt_name old_nm
, new_nm
;
1340 * Budget request settings: deletion direntry, new direntry, removing
1341 * the old inode, and changing old and new parent directory inodes.
1343 * However, this operation also marks the target inode as dirty and
1344 * does not write it, so we allocate budget for the target inode
1348 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1349 old_dentry
, old_inode
->i_ino
, old_dir
->i_ino
,
1350 new_dentry
, new_dir
->i_ino
, flags
);
1353 ubifs_assert(inode_is_locked(new_inode
));
1355 if (old_dir
!= new_dir
) {
1356 if (ubifs_crypt_is_encrypted(new_dir
) &&
1357 !fscrypt_has_permitted_context(new_dir
, old_inode
))
1361 if (unlink
&& is_dir
) {
1362 err
= ubifs_check_dir_empty(new_inode
);
1367 err
= fscrypt_setup_filename(old_dir
, &old_dentry
->d_name
, 0, &old_nm
);
1371 err
= fscrypt_setup_filename(new_dir
, &new_dentry
->d_name
, 0, &new_nm
);
1373 fscrypt_free_filename(&old_nm
);
1377 new_sz
= CALC_DENT_SIZE(fname_len(&new_nm
));
1378 old_sz
= CALC_DENT_SIZE(fname_len(&old_nm
));
1380 err
= ubifs_budget_space(c
, &req
);
1382 fscrypt_free_filename(&old_nm
);
1383 fscrypt_free_filename(&new_nm
);
1386 err
= ubifs_budget_space(c
, &ino_req
);
1388 fscrypt_free_filename(&old_nm
);
1389 fscrypt_free_filename(&new_nm
);
1390 ubifs_release_budget(c
, &req
);
1394 if (flags
& RENAME_WHITEOUT
) {
1395 union ubifs_dev_desc
*dev
= NULL
;
1397 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
1403 err
= do_tmpfile(old_dir
, old_dentry
, S_IFCHR
| WHITEOUT_MODE
, &whiteout
);
1409 whiteout
->i_state
|= I_LINKABLE
;
1410 whiteout_ui
= ubifs_inode(whiteout
);
1411 whiteout_ui
->data
= dev
;
1412 whiteout_ui
->data_len
= ubifs_encode_dev(dev
, MKDEV(0, 0));
1413 ubifs_assert(!whiteout_ui
->dirty
);
1416 lock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1419 * Like most other Unix systems, set the @i_ctime for inodes on a
1422 time
= current_time(old_dir
);
1423 old_inode
->i_ctime
= time
;
1425 /* We must adjust parent link count when renaming directories */
1429 * @old_dir loses a link because we are moving
1430 * @old_inode to a different directory.
1432 drop_nlink(old_dir
);
1434 * @new_dir only gains a link if we are not also
1435 * overwriting an existing directory.
1441 * @old_inode is not moving to a different directory,
1442 * but @old_dir still loses a link if we are
1443 * overwriting an existing directory.
1446 drop_nlink(old_dir
);
1450 old_dir
->i_size
-= old_sz
;
1451 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1452 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1453 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1456 * And finally, if we unlinked a direntry which happened to have the
1457 * same name as the moved direntry, we have to decrement @i_nlink of
1458 * the unlinked inode and change its ctime.
1462 * Directories cannot have hard-links, so if this is a
1463 * directory, just clear @i_nlink.
1465 saved_nlink
= new_inode
->i_nlink
;
1467 clear_nlink(new_inode
);
1469 drop_nlink(new_inode
);
1470 new_inode
->i_ctime
= time
;
1472 new_dir
->i_size
+= new_sz
;
1473 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1477 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1478 * is dirty, because this will be done later on at the end of
1481 if (IS_SYNC(old_inode
)) {
1482 sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1483 if (unlink
&& IS_SYNC(new_inode
))
1488 struct ubifs_budget_req wht_req
= { .dirtied_ino
= 1,
1490 ALIGN(ubifs_inode(whiteout
)->data_len
, 8) };
1492 err
= ubifs_budget_space(c
, &wht_req
);
1494 kfree(whiteout_ui
->data
);
1495 whiteout_ui
->data_len
= 0;
1500 inc_nlink(whiteout
);
1501 mark_inode_dirty(whiteout
);
1502 whiteout
->i_state
&= ~I_LINKABLE
;
1506 err
= ubifs_jnl_rename(c
, old_dir
, old_inode
, &old_nm
, new_dir
,
1507 new_inode
, &new_nm
, whiteout
, sync
);
1511 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1512 ubifs_release_budget(c
, &req
);
1514 mutex_lock(&old_inode_ui
->ui_mutex
);
1515 release
= old_inode_ui
->dirty
;
1516 mark_inode_dirty_sync(old_inode
);
1517 mutex_unlock(&old_inode_ui
->ui_mutex
);
1520 ubifs_release_budget(c
, &ino_req
);
1521 if (IS_SYNC(old_inode
))
1522 err
= old_inode
->i_sb
->s_op
->write_inode(old_inode
, NULL
);
1524 fscrypt_free_filename(&old_nm
);
1525 fscrypt_free_filename(&new_nm
);
1530 set_nlink(new_inode
, saved_nlink
);
1532 new_dir
->i_size
-= new_sz
;
1533 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1535 old_dir
->i_size
+= old_sz
;
1536 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1541 drop_nlink(new_dir
);
1548 drop_nlink(whiteout
);
1551 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1553 ubifs_release_budget(c
, &ino_req
);
1554 ubifs_release_budget(c
, &req
);
1555 fscrypt_free_filename(&old_nm
);
1556 fscrypt_free_filename(&new_nm
);
1560 static int ubifs_xrename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1561 struct inode
*new_dir
, struct dentry
*new_dentry
)
1563 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1564 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1566 int sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1567 struct inode
*fst_inode
= d_inode(old_dentry
);
1568 struct inode
*snd_inode
= d_inode(new_dentry
);
1569 struct timespec time
;
1571 struct fscrypt_name fst_nm
, snd_nm
;
1573 ubifs_assert(fst_inode
&& snd_inode
);
1575 if ((ubifs_crypt_is_encrypted(old_dir
) ||
1576 ubifs_crypt_is_encrypted(new_dir
)) &&
1577 (old_dir
!= new_dir
) &&
1578 (!fscrypt_has_permitted_context(new_dir
, fst_inode
) ||
1579 !fscrypt_has_permitted_context(old_dir
, snd_inode
)))
1582 err
= fscrypt_setup_filename(old_dir
, &old_dentry
->d_name
, 0, &fst_nm
);
1586 err
= fscrypt_setup_filename(new_dir
, &new_dentry
->d_name
, 0, &snd_nm
);
1588 fscrypt_free_filename(&fst_nm
);
1592 lock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1594 time
= current_time(old_dir
);
1595 fst_inode
->i_ctime
= time
;
1596 snd_inode
->i_ctime
= time
;
1597 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1598 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1600 if (old_dir
!= new_dir
) {
1601 if (S_ISDIR(fst_inode
->i_mode
) && !S_ISDIR(snd_inode
->i_mode
)) {
1603 drop_nlink(old_dir
);
1605 else if (!S_ISDIR(fst_inode
->i_mode
) && S_ISDIR(snd_inode
->i_mode
)) {
1606 drop_nlink(new_dir
);
1611 err
= ubifs_jnl_xrename(c
, old_dir
, fst_inode
, &fst_nm
, new_dir
,
1612 snd_inode
, &snd_nm
, sync
);
1614 unlock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1615 ubifs_release_budget(c
, &req
);
1617 fscrypt_free_filename(&fst_nm
);
1618 fscrypt_free_filename(&snd_nm
);
1622 static int ubifs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1623 struct inode
*new_dir
, struct dentry
*new_dentry
,
1626 if (flags
& ~(RENAME_NOREPLACE
| RENAME_WHITEOUT
| RENAME_EXCHANGE
))
1629 ubifs_assert(inode_is_locked(old_dir
));
1630 ubifs_assert(inode_is_locked(new_dir
));
1632 if (flags
& RENAME_EXCHANGE
)
1633 return ubifs_xrename(old_dir
, old_dentry
, new_dir
, new_dentry
);
1635 return do_rename(old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
1638 int ubifs_getattr(const struct path
*path
, struct kstat
*stat
,
1639 u32 request_mask
, unsigned int flags
)
1642 struct inode
*inode
= d_inode(path
->dentry
);
1643 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1645 mutex_lock(&ui
->ui_mutex
);
1647 if (ui
->flags
& UBIFS_APPEND_FL
)
1648 stat
->attributes
|= STATX_ATTR_APPEND
;
1649 if (ui
->flags
& UBIFS_COMPR_FL
)
1650 stat
->attributes
|= STATX_ATTR_COMPRESSED
;
1651 if (ui
->flags
& UBIFS_CRYPT_FL
)
1652 stat
->attributes
|= STATX_ATTR_ENCRYPTED
;
1653 if (ui
->flags
& UBIFS_IMMUTABLE_FL
)
1654 stat
->attributes
|= STATX_ATTR_IMMUTABLE
;
1656 stat
->attributes_mask
|= (STATX_ATTR_APPEND
|
1657 STATX_ATTR_COMPRESSED
|
1658 STATX_ATTR_ENCRYPTED
|
1659 STATX_ATTR_IMMUTABLE
);
1661 generic_fillattr(inode
, stat
);
1662 stat
->blksize
= UBIFS_BLOCK_SIZE
;
1663 stat
->size
= ui
->ui_size
;
1666 * Unfortunately, the 'stat()' system call was designed for block
1667 * device based file systems, and it is not appropriate for UBIFS,
1668 * because UBIFS does not have notion of "block". For example, it is
1669 * difficult to tell how many block a directory takes - it actually
1670 * takes less than 300 bytes, but we have to round it to block size,
1671 * which introduces large mistake. This makes utilities like 'du' to
1672 * report completely senseless numbers. This is the reason why UBIFS
1673 * goes the same way as JFFS2 - it reports zero blocks for everything
1674 * but regular files, which makes more sense than reporting completely
1677 if (S_ISREG(inode
->i_mode
)) {
1678 size
= ui
->xattr_size
;
1680 size
= ALIGN(size
, UBIFS_BLOCK_SIZE
);
1682 * Note, user-space expects 512-byte blocks count irrespectively
1683 * of what was reported in @stat->size.
1685 stat
->blocks
= size
>> 9;
1688 mutex_unlock(&ui
->ui_mutex
);
1692 static int ubifs_dir_open(struct inode
*dir
, struct file
*file
)
1694 if (ubifs_crypt_is_encrypted(dir
))
1695 return fscrypt_get_encryption_info(dir
) ? -EACCES
: 0;
1700 const struct inode_operations ubifs_dir_inode_operations
= {
1701 .lookup
= ubifs_lookup
,
1702 .create
= ubifs_create
,
1704 .symlink
= ubifs_symlink
,
1705 .unlink
= ubifs_unlink
,
1706 .mkdir
= ubifs_mkdir
,
1707 .rmdir
= ubifs_rmdir
,
1708 .mknod
= ubifs_mknod
,
1709 .rename
= ubifs_rename
,
1710 .setattr
= ubifs_setattr
,
1711 .getattr
= ubifs_getattr
,
1712 .listxattr
= ubifs_listxattr
,
1713 #ifdef CONFIG_UBIFS_ATIME_SUPPORT
1714 .update_time
= ubifs_update_time
,
1716 .tmpfile
= ubifs_tmpfile
,
1719 const struct file_operations ubifs_dir_operations
= {
1720 .llseek
= generic_file_llseek
,
1721 .release
= ubifs_dir_release
,
1722 .read
= generic_read_dir
,
1723 .iterate_shared
= ubifs_readdir
,
1724 .fsync
= ubifs_fsync
,
1725 .unlocked_ioctl
= ubifs_ioctl
,
1726 .open
= ubifs_dir_open
,
1727 #ifdef CONFIG_COMPAT
1728 .compat_ioctl
= ubifs_compat_ioctl
,