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
;
151 ui
->flags
= inherit_flags(dir
, mode
);
152 ubifs_set_inode_flags(inode
);
154 ui
->compr_type
= c
->default_compr
;
156 ui
->compr_type
= UBIFS_COMPR_NONE
;
157 ui
->synced_i_size
= 0;
159 spin_lock(&c
->cnt_lock
);
160 /* Inode number overflow is currently not supported */
161 if (c
->highest_inum
>= INUM_WARN_WATERMARK
) {
162 if (c
->highest_inum
>= INUM_WATERMARK
) {
163 spin_unlock(&c
->cnt_lock
);
164 ubifs_err(c
, "out of inode numbers");
165 make_bad_inode(inode
);
167 return ERR_PTR(-EINVAL
);
169 ubifs_warn(c
, "running out of inode numbers (current %lu, max %u)",
170 (unsigned long)c
->highest_inum
, INUM_WATERMARK
);
173 inode
->i_ino
= ++c
->highest_inum
;
175 * The creation sequence number remains with this inode for its
176 * lifetime. All nodes for this inode have a greater sequence number,
177 * and so it is possible to distinguish obsolete nodes belonging to a
178 * previous incarnation of the same inode number - for example, for the
179 * purpose of rebuilding the index.
181 ui
->creat_sqnum
= ++c
->max_sqnum
;
182 spin_unlock(&c
->cnt_lock
);
185 err
= fscrypt_inherit_context(dir
, inode
, &encrypted
, true);
187 ubifs_err(c
, "fscrypt_inherit_context failed: %i", err
);
188 make_bad_inode(inode
);
197 static int dbg_check_name(const struct ubifs_info
*c
,
198 const struct ubifs_dent_node
*dent
,
199 const struct fscrypt_name
*nm
)
201 if (!dbg_is_chk_gen(c
))
203 if (le16_to_cpu(dent
->nlen
) != fname_len(nm
))
205 if (memcmp(dent
->name
, fname_name(nm
), fname_len(nm
)))
210 static struct dentry
*ubifs_lookup(struct inode
*dir
, struct dentry
*dentry
,
215 struct inode
*inode
= NULL
;
216 struct ubifs_dent_node
*dent
;
217 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
218 struct fscrypt_name nm
;
220 dbg_gen("'%pd' in dir ino %lu", dentry
, dir
->i_ino
);
222 if (ubifs_crypt_is_encrypted(dir
)) {
223 err
= fscrypt_get_encryption_info(dir
);
226 * DCACHE_ENCRYPTED_WITH_KEY is set if the dentry is
227 * created while the directory was encrypted and we
228 * have access to the key.
230 if (fscrypt_has_encryption_key(dir
))
231 fscrypt_set_encrypted_dentry(dentry
);
232 fscrypt_set_d_op(dentry
);
233 if (err
&& err
!= -ENOKEY
)
237 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, &nm
);
241 if (fname_len(&nm
) > UBIFS_MAX_NLEN
) {
246 dent
= kmalloc(UBIFS_MAX_DENT_NODE_SZ
, GFP_NOFS
);
253 ubifs_assert(fname_len(&nm
) == 0);
254 ubifs_assert(fname_name(&nm
) == NULL
);
255 dent_key_init_hash(c
, &key
, dir
->i_ino
, nm
.hash
);
256 err
= ubifs_tnc_lookup_dh(c
, &key
, dent
, nm
.minor_hash
);
258 dent_key_init(c
, &key
, dir
->i_ino
, &nm
);
259 err
= ubifs_tnc_lookup_nm(c
, &key
, dent
, &nm
);
263 if (err
== -ENOENT
) {
264 dbg_gen("not found");
270 if (dbg_check_name(c
, dent
, &nm
)) {
275 inode
= ubifs_iget(dir
->i_sb
, le64_to_cpu(dent
->inum
));
278 * This should not happen. Probably the file-system needs
281 err
= PTR_ERR(inode
);
282 ubifs_err(c
, "dead directory entry '%pd', error %d",
284 ubifs_ro_mode(c
, err
);
290 fscrypt_free_filename(&nm
);
292 * Note, d_splice_alias() would be required instead if we supported
295 d_add(dentry
, inode
);
301 fscrypt_free_filename(&nm
);
305 static int ubifs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
309 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
310 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
312 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
313 struct fscrypt_name nm
;
317 * Budget request settings: new inode, new direntry, changing the
318 * parent directory inode.
321 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
322 dentry
, mode
, dir
->i_ino
);
324 err
= ubifs_budget_space(c
, &req
);
328 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
332 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
334 inode
= ubifs_new_inode(c
, dir
, mode
);
336 err
= PTR_ERR(inode
);
340 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
344 mutex_lock(&dir_ui
->ui_mutex
);
345 dir
->i_size
+= sz_change
;
346 dir_ui
->ui_size
= dir
->i_size
;
347 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
348 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
351 mutex_unlock(&dir_ui
->ui_mutex
);
353 ubifs_release_budget(c
, &req
);
354 fscrypt_free_filename(&nm
);
355 insert_inode_hash(inode
);
356 d_instantiate(dentry
, inode
);
360 dir
->i_size
-= sz_change
;
361 dir_ui
->ui_size
= dir
->i_size
;
362 mutex_unlock(&dir_ui
->ui_mutex
);
364 make_bad_inode(inode
);
367 fscrypt_free_filename(&nm
);
369 ubifs_release_budget(c
, &req
);
370 ubifs_err(c
, "cannot create regular file, error %d", err
);
374 static int do_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
375 umode_t mode
, struct inode
**whiteout
)
378 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
379 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1};
380 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1 };
381 struct ubifs_inode
*ui
, *dir_ui
= ubifs_inode(dir
);
382 int err
, instantiated
= 0;
383 struct fscrypt_name nm
;
386 * Budget request settings: new dirty inode, new direntry,
387 * budget for dirtied inode will be released via writeback.
390 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
391 dentry
, mode
, dir
->i_ino
);
393 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
397 err
= ubifs_budget_space(c
, &req
);
399 fscrypt_free_filename(&nm
);
403 err
= ubifs_budget_space(c
, &ino_req
);
405 ubifs_release_budget(c
, &req
);
406 fscrypt_free_filename(&nm
);
410 inode
= ubifs_new_inode(c
, dir
, mode
);
412 err
= PTR_ERR(inode
);
415 ui
= ubifs_inode(inode
);
418 init_special_inode(inode
, inode
->i_mode
, WHITEOUT_DEV
);
419 ubifs_assert(inode
->i_op
== &ubifs_file_inode_operations
);
422 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
426 mutex_lock(&ui
->ui_mutex
);
427 insert_inode_hash(inode
);
430 mark_inode_dirty(inode
);
434 d_tmpfile(dentry
, inode
);
436 ubifs_assert(ui
->dirty
);
439 mutex_unlock(&ui
->ui_mutex
);
441 mutex_lock(&dir_ui
->ui_mutex
);
442 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 1, 0);
445 mutex_unlock(&dir_ui
->ui_mutex
);
447 ubifs_release_budget(c
, &req
);
452 mutex_unlock(&dir_ui
->ui_mutex
);
454 make_bad_inode(inode
);
458 ubifs_release_budget(c
, &req
);
460 ubifs_release_budget(c
, &ino_req
);
461 fscrypt_free_filename(&nm
);
462 ubifs_err(c
, "cannot create temporary file, error %d", err
);
466 static int ubifs_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
469 return do_tmpfile(dir
, dentry
, mode
, NULL
);
473 * vfs_dent_type - get VFS directory entry type.
474 * @type: UBIFS directory entry type
476 * This function converts UBIFS directory entry type into VFS directory entry
479 static unsigned int vfs_dent_type(uint8_t type
)
482 case UBIFS_ITYPE_REG
:
484 case UBIFS_ITYPE_DIR
:
486 case UBIFS_ITYPE_LNK
:
488 case UBIFS_ITYPE_BLK
:
490 case UBIFS_ITYPE_CHR
:
492 case UBIFS_ITYPE_FIFO
:
494 case UBIFS_ITYPE_SOCK
:
503 * The classical Unix view for directory is that it is a linear array of
504 * (name, inode number) entries. Linux/VFS assumes this model as well.
505 * Particularly, 'readdir()' call wants us to return a directory entry offset
506 * which later may be used to continue 'readdir()'ing the directory or to
507 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
508 * model because directory entries are identified by keys, which may collide.
510 * UBIFS uses directory entry hash value for directory offsets, so
511 * 'seekdir()'/'telldir()' may not always work because of possible key
512 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
513 * properly by means of saving full directory entry name in the private field
514 * of the file description object.
516 * This means that UBIFS cannot support NFS which requires full
517 * 'seekdir()'/'telldir()' support.
519 static int ubifs_readdir(struct file
*file
, struct dir_context
*ctx
)
521 int fstr_real_len
= 0, err
= 0;
522 struct fscrypt_name nm
;
523 struct fscrypt_str fstr
= {0};
525 struct ubifs_dent_node
*dent
;
526 struct inode
*dir
= file_inode(file
);
527 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
528 bool encrypted
= ubifs_crypt_is_encrypted(dir
);
530 dbg_gen("dir ino %lu, f_pos %#llx", dir
->i_ino
, ctx
->pos
);
532 if (ctx
->pos
> UBIFS_S_KEY_HASH_MASK
|| ctx
->pos
== 2)
534 * The directory was seek'ed to a senseless position or there
535 * are no more entries.
540 err
= fscrypt_get_encryption_info(dir
);
541 if (err
&& err
!= -ENOKEY
)
544 err
= fscrypt_fname_alloc_buffer(dir
, UBIFS_MAX_NLEN
, &fstr
);
548 fstr_real_len
= fstr
.len
;
551 if (file
->f_version
== 0) {
553 * The file was seek'ed, which means that @file->private_data
554 * is now invalid. This may also be just the first
555 * 'ubifs_readdir()' invocation, in which case
556 * @file->private_data is NULL, and the below code is
559 kfree(file
->private_data
);
560 file
->private_data
= NULL
;
564 * 'generic_file_llseek()' unconditionally sets @file->f_version to
565 * zero, and we use this for detecting whether the file was seek'ed.
569 /* File positions 0 and 1 correspond to "." and ".." */
571 ubifs_assert(!file
->private_data
);
572 if (!dir_emit_dots(file
, ctx
)) {
574 fscrypt_fname_free_buffer(&fstr
);
578 /* Find the first entry in TNC and save it */
579 lowest_dent_key(c
, &key
, dir
->i_ino
);
581 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
587 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
588 file
->private_data
= dent
;
591 dent
= file
->private_data
;
594 * The directory was seek'ed to and is now readdir'ed.
595 * Find the entry corresponding to @ctx->pos or the closest one.
597 dent_key_init_hash(c
, &key
, dir
->i_ino
, ctx
->pos
);
599 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
604 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
605 file
->private_data
= dent
;
609 dbg_gen("ino %llu, new f_pos %#x",
610 (unsigned long long)le64_to_cpu(dent
->inum
),
611 key_hash_flash(c
, &dent
->key
));
612 ubifs_assert(le64_to_cpu(dent
->ch
.sqnum
) >
613 ubifs_inode(dir
)->creat_sqnum
);
615 fname_len(&nm
) = le16_to_cpu(dent
->nlen
);
616 fname_name(&nm
) = dent
->name
;
619 fstr
.len
= fstr_real_len
;
621 err
= fscrypt_fname_disk_to_usr(dir
, key_hash_flash(c
,
623 le32_to_cpu(dent
->cookie
),
624 &nm
.disk_name
, &fstr
);
628 fstr
.len
= fname_len(&nm
);
629 fstr
.name
= fname_name(&nm
);
632 if (!dir_emit(ctx
, fstr
.name
, fstr
.len
,
633 le64_to_cpu(dent
->inum
),
634 vfs_dent_type(dent
->type
))) {
636 fscrypt_fname_free_buffer(&fstr
);
640 /* Switch to the next entry */
641 key_read(c
, &dent
->key
, &key
);
642 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
648 kfree(file
->private_data
);
649 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
650 file
->private_data
= dent
;
655 kfree(file
->private_data
);
656 file
->private_data
= NULL
;
659 fscrypt_fname_free_buffer(&fstr
);
662 ubifs_err(c
, "cannot find next direntry, error %d", err
);
665 * -ENOENT is a non-fatal error in this context, the TNC uses
666 * it to indicate that the cursor moved past the current directory
667 * and readdir() has to stop.
672 /* 2 is a special value indicating that there are no more direntries */
677 /* Free saved readdir() state when the directory is closed */
678 static int ubifs_dir_release(struct inode
*dir
, struct file
*file
)
680 kfree(file
->private_data
);
681 file
->private_data
= NULL
;
686 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
687 * @inode1: first inode
688 * @inode2: second inode
690 * We do not implement any tricks to guarantee strict lock ordering, because
691 * VFS has already done it for us on the @i_mutex. So this is just a simple
694 static void lock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
696 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
697 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
701 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
702 * @inode1: first inode
703 * @inode2: second inode
705 static void unlock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
707 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
708 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
711 static int ubifs_link(struct dentry
*old_dentry
, struct inode
*dir
,
712 struct dentry
*dentry
)
714 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
715 struct inode
*inode
= d_inode(old_dentry
);
716 struct ubifs_inode
*ui
= ubifs_inode(inode
);
717 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
718 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
719 struct ubifs_budget_req req
= { .new_dent
= 1, .dirtied_ino
= 2,
720 .dirtied_ino_d
= ALIGN(ui
->data_len
, 8) };
721 struct fscrypt_name nm
;
724 * Budget request settings: new direntry, changing the target inode,
725 * changing the parent inode.
728 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
729 dentry
, inode
->i_ino
,
730 inode
->i_nlink
, dir
->i_ino
);
731 ubifs_assert(inode_is_locked(dir
));
732 ubifs_assert(inode_is_locked(inode
));
734 if (ubifs_crypt_is_encrypted(dir
) &&
735 !fscrypt_has_permitted_context(dir
, inode
))
738 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
742 err
= dbg_check_synced_i_size(c
, inode
);
746 err
= ubifs_budget_space(c
, &req
);
750 lock_2_inodes(dir
, inode
);
752 /* Handle O_TMPFILE corner case, it is allowed to link a O_TMPFILE. */
753 if (inode
->i_nlink
== 0)
754 ubifs_delete_orphan(c
, inode
->i_ino
);
758 inode
->i_ctime
= current_time(inode
);
759 dir
->i_size
+= sz_change
;
760 dir_ui
->ui_size
= dir
->i_size
;
761 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
762 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
765 unlock_2_inodes(dir
, inode
);
767 ubifs_release_budget(c
, &req
);
768 d_instantiate(dentry
, inode
);
769 fscrypt_free_filename(&nm
);
773 dir
->i_size
-= sz_change
;
774 dir_ui
->ui_size
= dir
->i_size
;
776 if (inode
->i_nlink
== 0)
777 ubifs_add_orphan(c
, inode
->i_ino
);
778 unlock_2_inodes(dir
, inode
);
779 ubifs_release_budget(c
, &req
);
782 fscrypt_free_filename(&nm
);
786 static int ubifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
788 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
789 struct inode
*inode
= d_inode(dentry
);
790 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
791 int err
, sz_change
, budgeted
= 1;
792 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
793 unsigned int saved_nlink
= inode
->i_nlink
;
794 struct fscrypt_name nm
;
797 * Budget request settings: deletion direntry, deletion inode (+1 for
798 * @dirtied_ino), changing the parent directory inode. If budgeting
799 * fails, go ahead anyway because we have extra space reserved for
803 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
804 dentry
, inode
->i_ino
,
805 inode
->i_nlink
, dir
->i_ino
);
807 if (ubifs_crypt_is_encrypted(dir
)) {
808 err
= fscrypt_get_encryption_info(dir
);
809 if (err
&& err
!= -ENOKEY
)
813 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, &nm
);
817 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
819 ubifs_assert(inode_is_locked(dir
));
820 ubifs_assert(inode_is_locked(inode
));
821 err
= dbg_check_synced_i_size(c
, inode
);
825 err
= ubifs_budget_space(c
, &req
);
832 lock_2_inodes(dir
, inode
);
833 inode
->i_ctime
= current_time(dir
);
835 dir
->i_size
-= sz_change
;
836 dir_ui
->ui_size
= dir
->i_size
;
837 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
838 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 1, 0);
841 unlock_2_inodes(dir
, inode
);
844 ubifs_release_budget(c
, &req
);
846 /* We've deleted something - clean the "no space" flags */
847 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
850 fscrypt_free_filename(&nm
);
854 dir
->i_size
+= sz_change
;
855 dir_ui
->ui_size
= dir
->i_size
;
856 set_nlink(inode
, saved_nlink
);
857 unlock_2_inodes(dir
, inode
);
859 ubifs_release_budget(c
, &req
);
861 fscrypt_free_filename(&nm
);
866 * check_dir_empty - check if a directory is empty or not.
867 * @dir: VFS inode object of the directory to check
869 * This function checks if directory @dir is empty. Returns zero if the
870 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
871 * in case of of errors.
873 int ubifs_check_dir_empty(struct inode
*dir
)
875 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
876 struct fscrypt_name nm
= { 0 };
877 struct ubifs_dent_node
*dent
;
881 lowest_dent_key(c
, &key
, dir
->i_ino
);
882 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
894 static int ubifs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
896 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
897 struct inode
*inode
= d_inode(dentry
);
898 int err
, sz_change
, budgeted
= 1;
899 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
900 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
901 struct fscrypt_name nm
;
904 * Budget request settings: deletion direntry, deletion inode and
905 * changing the parent inode. If budgeting fails, go ahead anyway
906 * because we have extra space reserved for deletions.
909 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry
,
910 inode
->i_ino
, dir
->i_ino
);
911 ubifs_assert(inode_is_locked(dir
));
912 ubifs_assert(inode_is_locked(inode
));
913 err
= ubifs_check_dir_empty(d_inode(dentry
));
917 if (ubifs_crypt_is_encrypted(dir
)) {
918 err
= fscrypt_get_encryption_info(dir
);
919 if (err
&& err
!= -ENOKEY
)
923 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 1, &nm
);
927 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
929 err
= ubifs_budget_space(c
, &req
);
936 lock_2_inodes(dir
, inode
);
937 inode
->i_ctime
= current_time(dir
);
940 dir
->i_size
-= sz_change
;
941 dir_ui
->ui_size
= dir
->i_size
;
942 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
943 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 1, 0);
946 unlock_2_inodes(dir
, inode
);
949 ubifs_release_budget(c
, &req
);
951 /* We've deleted something - clean the "no space" flags */
952 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
955 fscrypt_free_filename(&nm
);
959 dir
->i_size
+= sz_change
;
960 dir_ui
->ui_size
= dir
->i_size
;
963 unlock_2_inodes(dir
, inode
);
965 ubifs_release_budget(c
, &req
);
967 fscrypt_free_filename(&nm
);
971 static int ubifs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
974 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
975 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
977 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1 };
978 struct fscrypt_name nm
;
981 * Budget request settings: new inode, new direntry and changing parent
985 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
986 dentry
, mode
, dir
->i_ino
);
988 err
= ubifs_budget_space(c
, &req
);
992 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
996 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
998 inode
= ubifs_new_inode(c
, dir
, S_IFDIR
| mode
);
1000 err
= PTR_ERR(inode
);
1004 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
1008 mutex_lock(&dir_ui
->ui_mutex
);
1009 insert_inode_hash(inode
);
1012 dir
->i_size
+= sz_change
;
1013 dir_ui
->ui_size
= dir
->i_size
;
1014 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1015 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
1017 ubifs_err(c
, "cannot create directory, error %d", err
);
1020 mutex_unlock(&dir_ui
->ui_mutex
);
1022 ubifs_release_budget(c
, &req
);
1023 d_instantiate(dentry
, inode
);
1024 fscrypt_free_filename(&nm
);
1028 dir
->i_size
-= sz_change
;
1029 dir_ui
->ui_size
= dir
->i_size
;
1031 mutex_unlock(&dir_ui
->ui_mutex
);
1033 make_bad_inode(inode
);
1036 fscrypt_free_filename(&nm
);
1038 ubifs_release_budget(c
, &req
);
1042 static int ubifs_mknod(struct inode
*dir
, struct dentry
*dentry
,
1043 umode_t mode
, dev_t rdev
)
1045 struct inode
*inode
;
1046 struct ubifs_inode
*ui
;
1047 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
1048 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
1049 union ubifs_dev_desc
*dev
= NULL
;
1051 int err
, devlen
= 0;
1052 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
1053 .new_ino_d
= ALIGN(devlen
, 8),
1055 struct fscrypt_name nm
;
1058 * Budget request settings: new inode, new direntry and changing parent
1062 dbg_gen("dent '%pd' in dir ino %lu", dentry
, dir
->i_ino
);
1064 if (S_ISBLK(mode
) || S_ISCHR(mode
)) {
1065 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
1068 devlen
= ubifs_encode_dev(dev
, rdev
);
1071 err
= ubifs_budget_space(c
, &req
);
1077 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
1083 sz_change
= CALC_DENT_SIZE(fname_len(&nm
));
1085 inode
= ubifs_new_inode(c
, dir
, mode
);
1086 if (IS_ERR(inode
)) {
1088 err
= PTR_ERR(inode
);
1092 init_special_inode(inode
, inode
->i_mode
, rdev
);
1093 inode
->i_size
= ubifs_inode(inode
)->ui_size
= devlen
;
1094 ui
= ubifs_inode(inode
);
1096 ui
->data_len
= devlen
;
1098 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
1102 mutex_lock(&dir_ui
->ui_mutex
);
1103 dir
->i_size
+= sz_change
;
1104 dir_ui
->ui_size
= dir
->i_size
;
1105 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1106 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
1109 mutex_unlock(&dir_ui
->ui_mutex
);
1111 ubifs_release_budget(c
, &req
);
1112 insert_inode_hash(inode
);
1113 d_instantiate(dentry
, inode
);
1114 fscrypt_free_filename(&nm
);
1118 dir
->i_size
-= sz_change
;
1119 dir_ui
->ui_size
= dir
->i_size
;
1120 mutex_unlock(&dir_ui
->ui_mutex
);
1122 make_bad_inode(inode
);
1125 fscrypt_free_filename(&nm
);
1127 ubifs_release_budget(c
, &req
);
1131 static int ubifs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1132 const char *symname
)
1134 struct inode
*inode
;
1135 struct ubifs_inode
*ui
;
1136 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
1137 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
1138 int err
, len
= strlen(symname
);
1139 int sz_change
= CALC_DENT_SIZE(len
);
1140 struct fscrypt_str disk_link
= FSTR_INIT((char *)symname
, len
+ 1);
1141 struct fscrypt_symlink_data
*sd
= NULL
;
1142 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
1143 .new_ino_d
= ALIGN(len
, 8),
1145 struct fscrypt_name nm
;
1147 if (ubifs_crypt_is_encrypted(dir
)) {
1148 err
= fscrypt_get_encryption_info(dir
);
1152 if (!fscrypt_has_encryption_key(dir
)) {
1157 disk_link
.len
= (fscrypt_fname_encrypted_size(dir
, len
) +
1158 sizeof(struct fscrypt_symlink_data
));
1162 * Budget request settings: new inode, new direntry and changing parent
1166 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry
,
1167 symname
, dir
->i_ino
);
1169 if (disk_link
.len
> UBIFS_MAX_INO_DATA
)
1170 return -ENAMETOOLONG
;
1172 err
= ubifs_budget_space(c
, &req
);
1176 err
= fscrypt_setup_filename(dir
, &dentry
->d_name
, 0, &nm
);
1180 inode
= ubifs_new_inode(c
, dir
, S_IFLNK
| S_IRWXUGO
);
1181 if (IS_ERR(inode
)) {
1182 err
= PTR_ERR(inode
);
1186 ui
= ubifs_inode(inode
);
1187 ui
->data
= kmalloc(disk_link
.len
, GFP_NOFS
);
1193 if (ubifs_crypt_is_encrypted(dir
)) {
1194 struct qstr istr
= QSTR_INIT(symname
, len
);
1195 struct fscrypt_str ostr
;
1197 sd
= kzalloc(disk_link
.len
, GFP_NOFS
);
1203 ostr
.name
= sd
->encrypted_path
;
1204 ostr
.len
= disk_link
.len
;
1206 err
= fscrypt_fname_usr_to_disk(inode
, &istr
, &ostr
);
1212 sd
->len
= cpu_to_le16(ostr
.len
);
1213 disk_link
.name
= (char *)sd
;
1215 inode
->i_link
= ui
->data
;
1218 memcpy(ui
->data
, disk_link
.name
, disk_link
.len
);
1219 ((char *)ui
->data
)[disk_link
.len
- 1] = '\0';
1222 * The terminating zero byte is not written to the flash media and it
1223 * is put just to make later in-memory string processing simpler. Thus,
1224 * data length is @len, not @len + %1.
1226 ui
->data_len
= disk_link
.len
- 1;
1227 inode
->i_size
= ubifs_inode(inode
)->ui_size
= disk_link
.len
- 1;
1229 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
1233 mutex_lock(&dir_ui
->ui_mutex
);
1234 dir
->i_size
+= sz_change
;
1235 dir_ui
->ui_size
= dir
->i_size
;
1236 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1237 err
= ubifs_jnl_update(c
, dir
, &nm
, inode
, 0, 0);
1240 mutex_unlock(&dir_ui
->ui_mutex
);
1242 ubifs_release_budget(c
, &req
);
1243 insert_inode_hash(inode
);
1244 d_instantiate(dentry
, inode
);
1245 fscrypt_free_filename(&nm
);
1249 dir
->i_size
-= sz_change
;
1250 dir_ui
->ui_size
= dir
->i_size
;
1251 mutex_unlock(&dir_ui
->ui_mutex
);
1253 make_bad_inode(inode
);
1256 fscrypt_free_filename(&nm
);
1258 ubifs_release_budget(c
, &req
);
1263 * lock_4_inodes - a wrapper for locking three UBIFS inodes.
1264 * @inode1: first inode
1265 * @inode2: second inode
1266 * @inode3: third inode
1267 * @inode4: fouth inode
1269 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
1270 * @inode2 whereas @inode3 and @inode4 may be %NULL.
1272 * We do not implement any tricks to guarantee strict lock ordering, because
1273 * VFS has already done it for us on the @i_mutex. So this is just a simple
1276 static void lock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1277 struct inode
*inode3
, struct inode
*inode4
)
1279 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
1280 if (inode2
!= inode1
)
1281 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
1283 mutex_lock_nested(&ubifs_inode(inode3
)->ui_mutex
, WB_MUTEX_3
);
1285 mutex_lock_nested(&ubifs_inode(inode4
)->ui_mutex
, WB_MUTEX_4
);
1289 * unlock_4_inodes - a wrapper for unlocking three UBIFS inodes for rename.
1290 * @inode1: first inode
1291 * @inode2: second inode
1292 * @inode3: third inode
1293 * @inode4: fouth inode
1295 static void unlock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1296 struct inode
*inode3
, struct inode
*inode4
)
1299 mutex_unlock(&ubifs_inode(inode4
)->ui_mutex
);
1301 mutex_unlock(&ubifs_inode(inode3
)->ui_mutex
);
1302 if (inode1
!= inode2
)
1303 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
1304 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
1307 static int do_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1308 struct inode
*new_dir
, struct dentry
*new_dentry
,
1311 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1312 struct inode
*old_inode
= d_inode(old_dentry
);
1313 struct inode
*new_inode
= d_inode(new_dentry
);
1314 struct inode
*whiteout
= NULL
;
1315 struct ubifs_inode
*old_inode_ui
= ubifs_inode(old_inode
);
1316 struct ubifs_inode
*whiteout_ui
= NULL
;
1317 int err
, release
, sync
= 0, move
= (new_dir
!= old_dir
);
1318 int is_dir
= S_ISDIR(old_inode
->i_mode
);
1319 int unlink
= !!new_inode
, new_sz
, old_sz
;
1320 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1322 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1,
1323 .dirtied_ino_d
= ALIGN(old_inode_ui
->data_len
, 8) };
1324 struct timespec time
;
1325 unsigned int uninitialized_var(saved_nlink
);
1326 struct fscrypt_name old_nm
, new_nm
;
1329 * Budget request settings: deletion direntry, new direntry, removing
1330 * the old inode, and changing old and new parent directory inodes.
1332 * However, this operation also marks the target inode as dirty and
1333 * does not write it, so we allocate budget for the target inode
1337 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1338 old_dentry
, old_inode
->i_ino
, old_dir
->i_ino
,
1339 new_dentry
, new_dir
->i_ino
, flags
);
1342 ubifs_assert(inode_is_locked(new_inode
));
1344 if (old_dir
!= new_dir
) {
1345 if (ubifs_crypt_is_encrypted(new_dir
) &&
1346 !fscrypt_has_permitted_context(new_dir
, old_inode
))
1350 if (unlink
&& is_dir
) {
1351 err
= ubifs_check_dir_empty(new_inode
);
1356 err
= fscrypt_setup_filename(old_dir
, &old_dentry
->d_name
, 0, &old_nm
);
1360 err
= fscrypt_setup_filename(new_dir
, &new_dentry
->d_name
, 0, &new_nm
);
1362 fscrypt_free_filename(&old_nm
);
1366 new_sz
= CALC_DENT_SIZE(fname_len(&new_nm
));
1367 old_sz
= CALC_DENT_SIZE(fname_len(&old_nm
));
1369 err
= ubifs_budget_space(c
, &req
);
1371 fscrypt_free_filename(&old_nm
);
1372 fscrypt_free_filename(&new_nm
);
1375 err
= ubifs_budget_space(c
, &ino_req
);
1377 fscrypt_free_filename(&old_nm
);
1378 fscrypt_free_filename(&new_nm
);
1379 ubifs_release_budget(c
, &req
);
1383 if (flags
& RENAME_WHITEOUT
) {
1384 union ubifs_dev_desc
*dev
= NULL
;
1386 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
1388 ubifs_release_budget(c
, &req
);
1389 ubifs_release_budget(c
, &ino_req
);
1393 err
= do_tmpfile(old_dir
, old_dentry
, S_IFCHR
| WHITEOUT_MODE
, &whiteout
);
1395 ubifs_release_budget(c
, &req
);
1396 ubifs_release_budget(c
, &ino_req
);
1401 whiteout
->i_state
|= I_LINKABLE
;
1402 whiteout_ui
= ubifs_inode(whiteout
);
1403 whiteout_ui
->data
= dev
;
1404 whiteout_ui
->data_len
= ubifs_encode_dev(dev
, MKDEV(0, 0));
1405 ubifs_assert(!whiteout_ui
->dirty
);
1408 lock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1411 * Like most other Unix systems, set the @i_ctime for inodes on a
1414 time
= current_time(old_dir
);
1415 old_inode
->i_ctime
= time
;
1417 /* We must adjust parent link count when renaming directories */
1421 * @old_dir loses a link because we are moving
1422 * @old_inode to a different directory.
1424 drop_nlink(old_dir
);
1426 * @new_dir only gains a link if we are not also
1427 * overwriting an existing directory.
1433 * @old_inode is not moving to a different directory,
1434 * but @old_dir still loses a link if we are
1435 * overwriting an existing directory.
1438 drop_nlink(old_dir
);
1442 old_dir
->i_size
-= old_sz
;
1443 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1444 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1445 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1448 * And finally, if we unlinked a direntry which happened to have the
1449 * same name as the moved direntry, we have to decrement @i_nlink of
1450 * the unlinked inode and change its ctime.
1454 * Directories cannot have hard-links, so if this is a
1455 * directory, just clear @i_nlink.
1457 saved_nlink
= new_inode
->i_nlink
;
1459 clear_nlink(new_inode
);
1461 drop_nlink(new_inode
);
1462 new_inode
->i_ctime
= time
;
1464 new_dir
->i_size
+= new_sz
;
1465 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1469 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1470 * is dirty, because this will be done later on at the end of
1473 if (IS_SYNC(old_inode
)) {
1474 sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1475 if (unlink
&& IS_SYNC(new_inode
))
1480 struct ubifs_budget_req wht_req
= { .dirtied_ino
= 1,
1482 ALIGN(ubifs_inode(whiteout
)->data_len
, 8) };
1484 err
= ubifs_budget_space(c
, &wht_req
);
1486 ubifs_release_budget(c
, &req
);
1487 ubifs_release_budget(c
, &ino_req
);
1488 kfree(whiteout_ui
->data
);
1489 whiteout_ui
->data_len
= 0;
1494 inc_nlink(whiteout
);
1495 mark_inode_dirty(whiteout
);
1496 whiteout
->i_state
&= ~I_LINKABLE
;
1500 err
= ubifs_jnl_rename(c
, old_dir
, old_inode
, &old_nm
, new_dir
,
1501 new_inode
, &new_nm
, whiteout
, sync
);
1505 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1506 ubifs_release_budget(c
, &req
);
1508 mutex_lock(&old_inode_ui
->ui_mutex
);
1509 release
= old_inode_ui
->dirty
;
1510 mark_inode_dirty_sync(old_inode
);
1511 mutex_unlock(&old_inode_ui
->ui_mutex
);
1514 ubifs_release_budget(c
, &ino_req
);
1515 if (IS_SYNC(old_inode
))
1516 err
= old_inode
->i_sb
->s_op
->write_inode(old_inode
, NULL
);
1518 fscrypt_free_filename(&old_nm
);
1519 fscrypt_free_filename(&new_nm
);
1524 set_nlink(new_inode
, saved_nlink
);
1526 new_dir
->i_size
-= new_sz
;
1527 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1529 old_dir
->i_size
+= old_sz
;
1530 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1535 drop_nlink(new_dir
);
1542 drop_nlink(whiteout
);
1545 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1546 ubifs_release_budget(c
, &ino_req
);
1547 ubifs_release_budget(c
, &req
);
1548 fscrypt_free_filename(&old_nm
);
1549 fscrypt_free_filename(&new_nm
);
1553 static int ubifs_xrename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1554 struct inode
*new_dir
, struct dentry
*new_dentry
)
1556 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1557 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1559 int sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1560 struct inode
*fst_inode
= d_inode(old_dentry
);
1561 struct inode
*snd_inode
= d_inode(new_dentry
);
1562 struct timespec time
;
1564 struct fscrypt_name fst_nm
, snd_nm
;
1566 ubifs_assert(fst_inode
&& snd_inode
);
1568 if ((ubifs_crypt_is_encrypted(old_dir
) ||
1569 ubifs_crypt_is_encrypted(new_dir
)) &&
1570 (old_dir
!= new_dir
) &&
1571 (!fscrypt_has_permitted_context(new_dir
, fst_inode
) ||
1572 !fscrypt_has_permitted_context(old_dir
, snd_inode
)))
1575 err
= fscrypt_setup_filename(old_dir
, &old_dentry
->d_name
, 0, &fst_nm
);
1579 err
= fscrypt_setup_filename(new_dir
, &new_dentry
->d_name
, 0, &snd_nm
);
1581 fscrypt_free_filename(&fst_nm
);
1585 lock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1587 time
= current_time(old_dir
);
1588 fst_inode
->i_ctime
= time
;
1589 snd_inode
->i_ctime
= time
;
1590 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1591 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1593 if (old_dir
!= new_dir
) {
1594 if (S_ISDIR(fst_inode
->i_mode
) && !S_ISDIR(snd_inode
->i_mode
)) {
1596 drop_nlink(old_dir
);
1598 else if (!S_ISDIR(fst_inode
->i_mode
) && S_ISDIR(snd_inode
->i_mode
)) {
1599 drop_nlink(new_dir
);
1604 err
= ubifs_jnl_xrename(c
, old_dir
, fst_inode
, &fst_nm
, new_dir
,
1605 snd_inode
, &snd_nm
, sync
);
1607 unlock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1608 ubifs_release_budget(c
, &req
);
1610 fscrypt_free_filename(&fst_nm
);
1611 fscrypt_free_filename(&snd_nm
);
1615 static int ubifs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1616 struct inode
*new_dir
, struct dentry
*new_dentry
,
1619 if (flags
& ~(RENAME_NOREPLACE
| RENAME_WHITEOUT
| RENAME_EXCHANGE
))
1622 ubifs_assert(inode_is_locked(old_dir
));
1623 ubifs_assert(inode_is_locked(new_dir
));
1625 if (flags
& RENAME_EXCHANGE
)
1626 return ubifs_xrename(old_dir
, old_dentry
, new_dir
, new_dentry
);
1628 return do_rename(old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
1631 int ubifs_getattr(const struct path
*path
, struct kstat
*stat
,
1632 u32 request_mask
, unsigned int flags
)
1635 struct inode
*inode
= d_inode(path
->dentry
);
1636 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1638 mutex_lock(&ui
->ui_mutex
);
1639 generic_fillattr(inode
, stat
);
1640 stat
->blksize
= UBIFS_BLOCK_SIZE
;
1641 stat
->size
= ui
->ui_size
;
1644 * Unfortunately, the 'stat()' system call was designed for block
1645 * device based file systems, and it is not appropriate for UBIFS,
1646 * because UBIFS does not have notion of "block". For example, it is
1647 * difficult to tell how many block a directory takes - it actually
1648 * takes less than 300 bytes, but we have to round it to block size,
1649 * which introduces large mistake. This makes utilities like 'du' to
1650 * report completely senseless numbers. This is the reason why UBIFS
1651 * goes the same way as JFFS2 - it reports zero blocks for everything
1652 * but regular files, which makes more sense than reporting completely
1655 if (S_ISREG(inode
->i_mode
)) {
1656 size
= ui
->xattr_size
;
1658 size
= ALIGN(size
, UBIFS_BLOCK_SIZE
);
1660 * Note, user-space expects 512-byte blocks count irrespectively
1661 * of what was reported in @stat->size.
1663 stat
->blocks
= size
>> 9;
1666 mutex_unlock(&ui
->ui_mutex
);
1670 static int ubifs_dir_open(struct inode
*dir
, struct file
*file
)
1672 if (ubifs_crypt_is_encrypted(dir
))
1673 return fscrypt_get_encryption_info(dir
) ? -EACCES
: 0;
1678 const struct inode_operations ubifs_dir_inode_operations
= {
1679 .lookup
= ubifs_lookup
,
1680 .create
= ubifs_create
,
1682 .symlink
= ubifs_symlink
,
1683 .unlink
= ubifs_unlink
,
1684 .mkdir
= ubifs_mkdir
,
1685 .rmdir
= ubifs_rmdir
,
1686 .mknod
= ubifs_mknod
,
1687 .rename
= ubifs_rename
,
1688 .setattr
= ubifs_setattr
,
1689 .getattr
= ubifs_getattr
,
1690 .listxattr
= ubifs_listxattr
,
1691 #ifdef CONFIG_UBIFS_ATIME_SUPPORT
1692 .update_time
= ubifs_update_time
,
1694 .tmpfile
= ubifs_tmpfile
,
1697 const struct file_operations ubifs_dir_operations
= {
1698 .llseek
= generic_file_llseek
,
1699 .release
= ubifs_dir_release
,
1700 .read
= generic_read_dir
,
1701 .iterate_shared
= ubifs_readdir
,
1702 .fsync
= ubifs_fsync
,
1703 .unlocked_ioctl
= ubifs_ioctl
,
1704 .open
= ubifs_dir_open
,
1705 #ifdef CONFIG_COMPAT
1706 .compat_ioctl
= ubifs_compat_ioctl
,