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
, const struct inode
*dir
,
92 struct ubifs_inode
*ui
;
94 inode
= new_inode(c
->vfs_sb
);
95 ui
= ubifs_inode(inode
);
97 return ERR_PTR(-ENOMEM
);
100 * Set 'S_NOCMTIME' to prevent VFS form updating [mc]time of inodes and
101 * marking them dirty in file write path (see 'file_update_time()').
102 * UBIFS has to fully control "clean <-> dirty" transitions of inodes
103 * to make budgeting work.
105 inode
->i_flags
|= S_NOCMTIME
;
107 inode_init_owner(inode
, dir
, mode
);
108 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
=
109 ubifs_current_time(inode
);
110 inode
->i_mapping
->nrpages
= 0;
112 switch (mode
& S_IFMT
) {
114 inode
->i_mapping
->a_ops
= &ubifs_file_address_operations
;
115 inode
->i_op
= &ubifs_file_inode_operations
;
116 inode
->i_fop
= &ubifs_file_operations
;
119 inode
->i_op
= &ubifs_dir_inode_operations
;
120 inode
->i_fop
= &ubifs_dir_operations
;
121 inode
->i_size
= ui
->ui_size
= UBIFS_INO_NODE_SZ
;
124 inode
->i_op
= &ubifs_symlink_inode_operations
;
130 inode
->i_op
= &ubifs_file_inode_operations
;
136 ui
->flags
= inherit_flags(dir
, mode
);
137 ubifs_set_inode_flags(inode
);
139 ui
->compr_type
= c
->default_compr
;
141 ui
->compr_type
= UBIFS_COMPR_NONE
;
142 ui
->synced_i_size
= 0;
144 spin_lock(&c
->cnt_lock
);
145 /* Inode number overflow is currently not supported */
146 if (c
->highest_inum
>= INUM_WARN_WATERMARK
) {
147 if (c
->highest_inum
>= INUM_WATERMARK
) {
148 spin_unlock(&c
->cnt_lock
);
149 ubifs_err(c
, "out of inode numbers");
150 make_bad_inode(inode
);
152 return ERR_PTR(-EINVAL
);
154 ubifs_warn(c
, "running out of inode numbers (current %lu, max %u)",
155 (unsigned long)c
->highest_inum
, INUM_WATERMARK
);
158 inode
->i_ino
= ++c
->highest_inum
;
160 * The creation sequence number remains with this inode for its
161 * lifetime. All nodes for this inode have a greater sequence number,
162 * and so it is possible to distinguish obsolete nodes belonging to a
163 * previous incarnation of the same inode number - for example, for the
164 * purpose of rebuilding the index.
166 ui
->creat_sqnum
= ++c
->max_sqnum
;
167 spin_unlock(&c
->cnt_lock
);
171 static int dbg_check_name(const struct ubifs_info
*c
,
172 const struct ubifs_dent_node
*dent
,
173 const struct qstr
*nm
)
175 if (!dbg_is_chk_gen(c
))
177 if (le16_to_cpu(dent
->nlen
) != nm
->len
)
179 if (memcmp(dent
->name
, nm
->name
, nm
->len
))
184 static struct dentry
*ubifs_lookup(struct inode
*dir
, struct dentry
*dentry
,
189 struct inode
*inode
= NULL
;
190 struct ubifs_dent_node
*dent
;
191 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
193 dbg_gen("'%pd' in dir ino %lu", dentry
, dir
->i_ino
);
195 if (dentry
->d_name
.len
> UBIFS_MAX_NLEN
)
196 return ERR_PTR(-ENAMETOOLONG
);
198 dent
= kmalloc(UBIFS_MAX_DENT_NODE_SZ
, GFP_NOFS
);
200 return ERR_PTR(-ENOMEM
);
202 dent_key_init(c
, &key
, dir
->i_ino
, &dentry
->d_name
);
204 err
= ubifs_tnc_lookup_nm(c
, &key
, dent
, &dentry
->d_name
);
206 if (err
== -ENOENT
) {
207 dbg_gen("not found");
213 if (dbg_check_name(c
, dent
, &dentry
->d_name
)) {
218 inode
= ubifs_iget(dir
->i_sb
, le64_to_cpu(dent
->inum
));
221 * This should not happen. Probably the file-system needs
224 err
= PTR_ERR(inode
);
225 ubifs_err(c
, "dead directory entry '%pd', error %d",
227 ubifs_ro_mode(c
, err
);
234 * Note, d_splice_alias() would be required instead if we supported
237 d_add(dentry
, inode
);
245 static int ubifs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
249 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
250 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
251 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
253 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
256 * Budget request settings: new inode, new direntry, changing the
257 * parent directory inode.
260 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
261 dentry
, mode
, dir
->i_ino
);
263 err
= ubifs_budget_space(c
, &req
);
267 inode
= ubifs_new_inode(c
, dir
, mode
);
269 err
= PTR_ERR(inode
);
273 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
277 mutex_lock(&dir_ui
->ui_mutex
);
278 dir
->i_size
+= sz_change
;
279 dir_ui
->ui_size
= dir
->i_size
;
280 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
281 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
284 mutex_unlock(&dir_ui
->ui_mutex
);
286 ubifs_release_budget(c
, &req
);
287 insert_inode_hash(inode
);
288 d_instantiate(dentry
, inode
);
292 dir
->i_size
-= sz_change
;
293 dir_ui
->ui_size
= dir
->i_size
;
294 mutex_unlock(&dir_ui
->ui_mutex
);
296 make_bad_inode(inode
);
299 ubifs_release_budget(c
, &req
);
300 ubifs_err(c
, "cannot create regular file, error %d", err
);
304 static int do_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
305 umode_t mode
, struct inode
**whiteout
)
308 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
309 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1};
310 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1 };
311 struct ubifs_inode
*ui
, *dir_ui
= ubifs_inode(dir
);
312 int err
, instantiated
= 0;
315 * Budget request settings: new dirty inode, new direntry,
316 * budget for dirtied inode will be released via writeback.
319 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
320 dentry
, mode
, dir
->i_ino
);
322 err
= ubifs_budget_space(c
, &req
);
326 err
= ubifs_budget_space(c
, &ino_req
);
328 ubifs_release_budget(c
, &req
);
332 inode
= ubifs_new_inode(c
, dir
, mode
);
334 err
= PTR_ERR(inode
);
337 ui
= ubifs_inode(inode
);
340 init_special_inode(inode
, inode
->i_mode
, WHITEOUT_DEV
);
341 ubifs_assert(inode
->i_op
== &ubifs_file_inode_operations
);
344 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
348 mutex_lock(&ui
->ui_mutex
);
349 insert_inode_hash(inode
);
352 mark_inode_dirty(inode
);
356 d_tmpfile(dentry
, inode
);
358 ubifs_assert(ui
->dirty
);
361 mutex_unlock(&ui
->ui_mutex
);
363 mutex_lock(&dir_ui
->ui_mutex
);
364 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
367 mutex_unlock(&dir_ui
->ui_mutex
);
369 ubifs_release_budget(c
, &req
);
374 mutex_unlock(&dir_ui
->ui_mutex
);
376 make_bad_inode(inode
);
380 ubifs_release_budget(c
, &req
);
382 ubifs_release_budget(c
, &ino_req
);
383 ubifs_err(c
, "cannot create temporary file, error %d", err
);
387 static int ubifs_tmpfile(struct inode
*dir
, struct dentry
*dentry
,
390 return do_tmpfile(dir
, dentry
, mode
, NULL
);
394 * vfs_dent_type - get VFS directory entry type.
395 * @type: UBIFS directory entry type
397 * This function converts UBIFS directory entry type into VFS directory entry
400 static unsigned int vfs_dent_type(uint8_t type
)
403 case UBIFS_ITYPE_REG
:
405 case UBIFS_ITYPE_DIR
:
407 case UBIFS_ITYPE_LNK
:
409 case UBIFS_ITYPE_BLK
:
411 case UBIFS_ITYPE_CHR
:
413 case UBIFS_ITYPE_FIFO
:
415 case UBIFS_ITYPE_SOCK
:
424 * The classical Unix view for directory is that it is a linear array of
425 * (name, inode number) entries. Linux/VFS assumes this model as well.
426 * Particularly, 'readdir()' call wants us to return a directory entry offset
427 * which later may be used to continue 'readdir()'ing the directory or to
428 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
429 * model because directory entries are identified by keys, which may collide.
431 * UBIFS uses directory entry hash value for directory offsets, so
432 * 'seekdir()'/'telldir()' may not always work because of possible key
433 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
434 * properly by means of saving full directory entry name in the private field
435 * of the file description object.
437 * This means that UBIFS cannot support NFS which requires full
438 * 'seekdir()'/'telldir()' support.
440 static int ubifs_readdir(struct file
*file
, struct dir_context
*ctx
)
445 struct ubifs_dent_node
*dent
;
446 struct inode
*dir
= file_inode(file
);
447 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
449 dbg_gen("dir ino %lu, f_pos %#llx", dir
->i_ino
, ctx
->pos
);
451 if (ctx
->pos
> UBIFS_S_KEY_HASH_MASK
|| ctx
->pos
== 2)
453 * The directory was seek'ed to a senseless position or there
454 * are no more entries.
458 if (file
->f_version
== 0) {
460 * The file was seek'ed, which means that @file->private_data
461 * is now invalid. This may also be just the first
462 * 'ubifs_readdir()' invocation, in which case
463 * @file->private_data is NULL, and the below code is
466 kfree(file
->private_data
);
467 file
->private_data
= NULL
;
471 * 'generic_file_llseek()' unconditionally sets @file->f_version to
472 * zero, and we use this for detecting whether the file was seek'ed.
476 /* File positions 0 and 1 correspond to "." and ".." */
478 ubifs_assert(!file
->private_data
);
479 if (!dir_emit_dots(file
, ctx
))
482 /* Find the first entry in TNC and save it */
483 lowest_dent_key(c
, &key
, dir
->i_ino
);
485 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
491 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
492 file
->private_data
= dent
;
495 dent
= file
->private_data
;
498 * The directory was seek'ed to and is now readdir'ed.
499 * Find the entry corresponding to @ctx->pos or the closest one.
501 dent_key_init_hash(c
, &key
, dir
->i_ino
, ctx
->pos
);
503 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
508 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
509 file
->private_data
= dent
;
513 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
514 dent
->name
, (unsigned long long)le64_to_cpu(dent
->inum
),
515 key_hash_flash(c
, &dent
->key
));
516 ubifs_assert(le64_to_cpu(dent
->ch
.sqnum
) >
517 ubifs_inode(dir
)->creat_sqnum
);
519 nm
.len
= le16_to_cpu(dent
->nlen
);
520 if (!dir_emit(ctx
, dent
->name
, nm
.len
,
521 le64_to_cpu(dent
->inum
),
522 vfs_dent_type(dent
->type
)))
525 /* Switch to the next entry */
526 key_read(c
, &dent
->key
, &key
);
527 nm
.name
= dent
->name
;
528 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
534 kfree(file
->private_data
);
535 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
536 file
->private_data
= dent
;
541 kfree(file
->private_data
);
542 file
->private_data
= NULL
;
545 ubifs_err(c
, "cannot find next direntry, error %d", err
);
548 * -ENOENT is a non-fatal error in this context, the TNC uses
549 * it to indicate that the cursor moved past the current directory
550 * and readdir() has to stop.
555 /* 2 is a special value indicating that there are no more direntries */
560 /* Free saved readdir() state when the directory is closed */
561 static int ubifs_dir_release(struct inode
*dir
, struct file
*file
)
563 kfree(file
->private_data
);
564 file
->private_data
= NULL
;
569 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
570 * @inode1: first inode
571 * @inode2: second inode
573 * We do not implement any tricks to guarantee strict lock ordering, because
574 * VFS has already done it for us on the @i_mutex. So this is just a simple
577 static void lock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
579 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
580 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
584 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
585 * @inode1: first inode
586 * @inode2: second inode
588 static void unlock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
590 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
591 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
594 static int ubifs_link(struct dentry
*old_dentry
, struct inode
*dir
,
595 struct dentry
*dentry
)
597 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
598 struct inode
*inode
= d_inode(old_dentry
);
599 struct ubifs_inode
*ui
= ubifs_inode(inode
);
600 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
601 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
602 struct ubifs_budget_req req
= { .new_dent
= 1, .dirtied_ino
= 2,
603 .dirtied_ino_d
= ALIGN(ui
->data_len
, 8) };
606 * Budget request settings: new direntry, changing the target inode,
607 * changing the parent inode.
610 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
611 dentry
, inode
->i_ino
,
612 inode
->i_nlink
, dir
->i_ino
);
613 ubifs_assert(inode_is_locked(dir
));
614 ubifs_assert(inode_is_locked(inode
));
616 err
= dbg_check_synced_i_size(c
, inode
);
620 err
= ubifs_budget_space(c
, &req
);
624 lock_2_inodes(dir
, inode
);
627 inode
->i_ctime
= ubifs_current_time(inode
);
628 dir
->i_size
+= sz_change
;
629 dir_ui
->ui_size
= dir
->i_size
;
630 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
631 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
634 unlock_2_inodes(dir
, inode
);
636 ubifs_release_budget(c
, &req
);
637 d_instantiate(dentry
, inode
);
641 dir
->i_size
-= sz_change
;
642 dir_ui
->ui_size
= dir
->i_size
;
644 unlock_2_inodes(dir
, inode
);
645 ubifs_release_budget(c
, &req
);
650 static int ubifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
652 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
653 struct inode
*inode
= d_inode(dentry
);
654 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
655 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
656 int err
, budgeted
= 1;
657 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
658 unsigned int saved_nlink
= inode
->i_nlink
;
661 * Budget request settings: deletion direntry, deletion inode (+1 for
662 * @dirtied_ino), changing the parent directory inode. If budgeting
663 * fails, go ahead anyway because we have extra space reserved for
667 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
668 dentry
, inode
->i_ino
,
669 inode
->i_nlink
, dir
->i_ino
);
670 ubifs_assert(inode_is_locked(dir
));
671 ubifs_assert(inode_is_locked(inode
));
672 err
= dbg_check_synced_i_size(c
, inode
);
676 err
= ubifs_budget_space(c
, &req
);
683 lock_2_inodes(dir
, inode
);
684 inode
->i_ctime
= ubifs_current_time(dir
);
686 dir
->i_size
-= sz_change
;
687 dir_ui
->ui_size
= dir
->i_size
;
688 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
689 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
692 unlock_2_inodes(dir
, inode
);
695 ubifs_release_budget(c
, &req
);
697 /* We've deleted something - clean the "no space" flags */
698 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
704 dir
->i_size
+= sz_change
;
705 dir_ui
->ui_size
= dir
->i_size
;
706 set_nlink(inode
, saved_nlink
);
707 unlock_2_inodes(dir
, inode
);
709 ubifs_release_budget(c
, &req
);
714 * check_dir_empty - check if a directory is empty or not.
715 * @c: UBIFS file-system description object
716 * @dir: VFS inode object of the directory to check
718 * This function checks if directory @dir is empty. Returns zero if the
719 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
720 * in case of of errors.
722 static int check_dir_empty(struct ubifs_info
*c
, struct inode
*dir
)
724 struct qstr nm
= { .name
= NULL
};
725 struct ubifs_dent_node
*dent
;
729 lowest_dent_key(c
, &key
, dir
->i_ino
);
730 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
742 static int ubifs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
744 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
745 struct inode
*inode
= d_inode(dentry
);
746 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
747 int err
, budgeted
= 1;
748 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
749 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
752 * Budget request settings: deletion direntry, deletion inode and
753 * changing the parent inode. If budgeting fails, go ahead anyway
754 * because we have extra space reserved for deletions.
757 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry
,
758 inode
->i_ino
, dir
->i_ino
);
759 ubifs_assert(inode_is_locked(dir
));
760 ubifs_assert(inode_is_locked(inode
));
761 err
= check_dir_empty(c
, d_inode(dentry
));
765 err
= ubifs_budget_space(c
, &req
);
772 lock_2_inodes(dir
, inode
);
773 inode
->i_ctime
= ubifs_current_time(dir
);
776 dir
->i_size
-= sz_change
;
777 dir_ui
->ui_size
= dir
->i_size
;
778 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
779 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
782 unlock_2_inodes(dir
, inode
);
785 ubifs_release_budget(c
, &req
);
787 /* We've deleted something - clean the "no space" flags */
788 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
794 dir
->i_size
+= sz_change
;
795 dir_ui
->ui_size
= dir
->i_size
;
798 unlock_2_inodes(dir
, inode
);
800 ubifs_release_budget(c
, &req
);
804 static int ubifs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
807 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
808 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
809 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
810 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1 };
813 * Budget request settings: new inode, new direntry and changing parent
817 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
818 dentry
, mode
, dir
->i_ino
);
820 err
= ubifs_budget_space(c
, &req
);
824 inode
= ubifs_new_inode(c
, dir
, S_IFDIR
| mode
);
826 err
= PTR_ERR(inode
);
830 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
834 mutex_lock(&dir_ui
->ui_mutex
);
835 insert_inode_hash(inode
);
838 dir
->i_size
+= sz_change
;
839 dir_ui
->ui_size
= dir
->i_size
;
840 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
841 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
843 ubifs_err(c
, "cannot create directory, error %d", err
);
846 mutex_unlock(&dir_ui
->ui_mutex
);
848 ubifs_release_budget(c
, &req
);
849 d_instantiate(dentry
, inode
);
853 dir
->i_size
-= sz_change
;
854 dir_ui
->ui_size
= dir
->i_size
;
856 mutex_unlock(&dir_ui
->ui_mutex
);
858 make_bad_inode(inode
);
861 ubifs_release_budget(c
, &req
);
865 static int ubifs_mknod(struct inode
*dir
, struct dentry
*dentry
,
866 umode_t mode
, dev_t rdev
)
869 struct ubifs_inode
*ui
;
870 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
871 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
872 union ubifs_dev_desc
*dev
= NULL
;
873 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
875 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
876 .new_ino_d
= ALIGN(devlen
, 8),
880 * Budget request settings: new inode, new direntry and changing parent
884 dbg_gen("dent '%pd' in dir ino %lu", dentry
, dir
->i_ino
);
886 if (S_ISBLK(mode
) || S_ISCHR(mode
)) {
887 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
890 devlen
= ubifs_encode_dev(dev
, rdev
);
893 err
= ubifs_budget_space(c
, &req
);
899 inode
= ubifs_new_inode(c
, dir
, mode
);
902 err
= PTR_ERR(inode
);
906 init_special_inode(inode
, inode
->i_mode
, rdev
);
907 inode
->i_size
= ubifs_inode(inode
)->ui_size
= devlen
;
908 ui
= ubifs_inode(inode
);
910 ui
->data_len
= devlen
;
912 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
916 mutex_lock(&dir_ui
->ui_mutex
);
917 dir
->i_size
+= sz_change
;
918 dir_ui
->ui_size
= dir
->i_size
;
919 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
920 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
923 mutex_unlock(&dir_ui
->ui_mutex
);
925 ubifs_release_budget(c
, &req
);
926 insert_inode_hash(inode
);
927 d_instantiate(dentry
, inode
);
931 dir
->i_size
-= sz_change
;
932 dir_ui
->ui_size
= dir
->i_size
;
933 mutex_unlock(&dir_ui
->ui_mutex
);
935 make_bad_inode(inode
);
938 ubifs_release_budget(c
, &req
);
942 static int ubifs_symlink(struct inode
*dir
, struct dentry
*dentry
,
946 struct ubifs_inode
*ui
;
947 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
948 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
949 int err
, len
= strlen(symname
);
950 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
951 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
952 .new_ino_d
= ALIGN(len
, 8),
956 * Budget request settings: new inode, new direntry and changing parent
960 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry
,
961 symname
, dir
->i_ino
);
963 if (len
> UBIFS_MAX_INO_DATA
)
964 return -ENAMETOOLONG
;
966 err
= ubifs_budget_space(c
, &req
);
970 inode
= ubifs_new_inode(c
, dir
, S_IFLNK
| S_IRWXUGO
);
972 err
= PTR_ERR(inode
);
976 ui
= ubifs_inode(inode
);
977 ui
->data
= kmalloc(len
+ 1, GFP_NOFS
);
983 memcpy(ui
->data
, symname
, len
);
984 ((char *)ui
->data
)[len
] = '\0';
985 inode
->i_link
= ui
->data
;
987 * The terminating zero byte is not written to the flash media and it
988 * is put just to make later in-memory string processing simpler. Thus,
989 * data length is @len, not @len + %1.
992 inode
->i_size
= ubifs_inode(inode
)->ui_size
= len
;
994 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
998 mutex_lock(&dir_ui
->ui_mutex
);
999 dir
->i_size
+= sz_change
;
1000 dir_ui
->ui_size
= dir
->i_size
;
1001 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
1002 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
1005 mutex_unlock(&dir_ui
->ui_mutex
);
1007 ubifs_release_budget(c
, &req
);
1008 insert_inode_hash(inode
);
1009 d_instantiate(dentry
, inode
);
1013 dir
->i_size
-= sz_change
;
1014 dir_ui
->ui_size
= dir
->i_size
;
1015 mutex_unlock(&dir_ui
->ui_mutex
);
1017 make_bad_inode(inode
);
1020 ubifs_release_budget(c
, &req
);
1025 * lock_4_inodes - a wrapper for locking three UBIFS inodes.
1026 * @inode1: first inode
1027 * @inode2: second inode
1028 * @inode3: third inode
1029 * @inode4: fouth inode
1031 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
1032 * @inode2 whereas @inode3 and @inode4 may be %NULL.
1034 * We do not implement any tricks to guarantee strict lock ordering, because
1035 * VFS has already done it for us on the @i_mutex. So this is just a simple
1038 static void lock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1039 struct inode
*inode3
, struct inode
*inode4
)
1041 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
1042 if (inode2
!= inode1
)
1043 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
1045 mutex_lock_nested(&ubifs_inode(inode3
)->ui_mutex
, WB_MUTEX_3
);
1047 mutex_lock_nested(&ubifs_inode(inode4
)->ui_mutex
, WB_MUTEX_4
);
1051 * unlock_4_inodes - a wrapper for unlocking three UBIFS inodes for rename.
1052 * @inode1: first inode
1053 * @inode2: second inode
1054 * @inode3: third inode
1055 * @inode4: fouth inode
1057 static void unlock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1058 struct inode
*inode3
, struct inode
*inode4
)
1061 mutex_unlock(&ubifs_inode(inode4
)->ui_mutex
);
1063 mutex_unlock(&ubifs_inode(inode3
)->ui_mutex
);
1064 if (inode1
!= inode2
)
1065 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
1066 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
1069 static int do_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1070 struct inode
*new_dir
, struct dentry
*new_dentry
,
1073 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1074 struct inode
*old_inode
= d_inode(old_dentry
);
1075 struct inode
*new_inode
= d_inode(new_dentry
);
1076 struct inode
*whiteout
= NULL
;
1077 struct ubifs_inode
*old_inode_ui
= ubifs_inode(old_inode
);
1078 struct ubifs_inode
*whiteout_ui
= NULL
;
1079 int err
, release
, sync
= 0, move
= (new_dir
!= old_dir
);
1080 int is_dir
= S_ISDIR(old_inode
->i_mode
);
1081 int unlink
= !!new_inode
;
1082 int new_sz
= CALC_DENT_SIZE(new_dentry
->d_name
.len
);
1083 int old_sz
= CALC_DENT_SIZE(old_dentry
->d_name
.len
);
1084 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1086 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1,
1087 .dirtied_ino_d
= ALIGN(old_inode_ui
->data_len
, 8) };
1088 struct timespec time
;
1089 unsigned int uninitialized_var(saved_nlink
);
1091 if (flags
& ~RENAME_NOREPLACE
)
1095 * Budget request settings: deletion direntry, new direntry, removing
1096 * the old inode, and changing old and new parent directory inodes.
1098 * However, this operation also marks the target inode as dirty and
1099 * does not write it, so we allocate budget for the target inode
1103 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1104 old_dentry
, old_inode
->i_ino
, old_dir
->i_ino
,
1105 new_dentry
, new_dir
->i_ino
, flags
);
1108 ubifs_assert(inode_is_locked(new_inode
));
1110 if (unlink
&& is_dir
) {
1111 err
= check_dir_empty(c
, new_inode
);
1116 err
= ubifs_budget_space(c
, &req
);
1119 err
= ubifs_budget_space(c
, &ino_req
);
1121 ubifs_release_budget(c
, &req
);
1125 if (flags
& RENAME_WHITEOUT
) {
1126 union ubifs_dev_desc
*dev
= NULL
;
1128 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
1130 ubifs_release_budget(c
, &req
);
1131 ubifs_release_budget(c
, &ino_req
);
1135 err
= do_tmpfile(old_dir
, old_dentry
, S_IFCHR
| WHITEOUT_MODE
, &whiteout
);
1137 ubifs_release_budget(c
, &req
);
1138 ubifs_release_budget(c
, &ino_req
);
1143 whiteout
->i_state
|= I_LINKABLE
;
1144 whiteout_ui
= ubifs_inode(whiteout
);
1145 whiteout_ui
->data
= dev
;
1146 whiteout_ui
->data_len
= ubifs_encode_dev(dev
, MKDEV(0, 0));
1147 ubifs_assert(!whiteout_ui
->dirty
);
1150 lock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1153 * Like most other Unix systems, set the @i_ctime for inodes on a
1156 time
= ubifs_current_time(old_dir
);
1157 old_inode
->i_ctime
= time
;
1159 /* We must adjust parent link count when renaming directories */
1163 * @old_dir loses a link because we are moving
1164 * @old_inode to a different directory.
1166 drop_nlink(old_dir
);
1168 * @new_dir only gains a link if we are not also
1169 * overwriting an existing directory.
1175 * @old_inode is not moving to a different directory,
1176 * but @old_dir still loses a link if we are
1177 * overwriting an existing directory.
1180 drop_nlink(old_dir
);
1184 old_dir
->i_size
-= old_sz
;
1185 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1186 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1187 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1190 * And finally, if we unlinked a direntry which happened to have the
1191 * same name as the moved direntry, we have to decrement @i_nlink of
1192 * the unlinked inode and change its ctime.
1196 * Directories cannot have hard-links, so if this is a
1197 * directory, just clear @i_nlink.
1199 saved_nlink
= new_inode
->i_nlink
;
1201 clear_nlink(new_inode
);
1203 drop_nlink(new_inode
);
1204 new_inode
->i_ctime
= time
;
1206 new_dir
->i_size
+= new_sz
;
1207 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1211 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1212 * is dirty, because this will be done later on at the end of
1215 if (IS_SYNC(old_inode
)) {
1216 sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1217 if (unlink
&& IS_SYNC(new_inode
))
1222 struct ubifs_budget_req wht_req
= { .dirtied_ino
= 1,
1224 ALIGN(ubifs_inode(whiteout
)->data_len
, 8) };
1226 err
= ubifs_budget_space(c
, &wht_req
);
1228 ubifs_release_budget(c
, &req
);
1229 ubifs_release_budget(c
, &ino_req
);
1230 kfree(whiteout_ui
->data
);
1231 whiteout_ui
->data_len
= 0;
1236 inc_nlink(whiteout
);
1237 mark_inode_dirty(whiteout
);
1238 whiteout
->i_state
&= ~I_LINKABLE
;
1242 err
= ubifs_jnl_rename(c
, old_dir
, old_dentry
, new_dir
, new_dentry
, whiteout
,
1247 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1248 ubifs_release_budget(c
, &req
);
1250 mutex_lock(&old_inode_ui
->ui_mutex
);
1251 release
= old_inode_ui
->dirty
;
1252 mark_inode_dirty_sync(old_inode
);
1253 mutex_unlock(&old_inode_ui
->ui_mutex
);
1256 ubifs_release_budget(c
, &ino_req
);
1257 if (IS_SYNC(old_inode
))
1258 err
= old_inode
->i_sb
->s_op
->write_inode(old_inode
, NULL
);
1263 set_nlink(new_inode
, saved_nlink
);
1265 new_dir
->i_size
-= new_sz
;
1266 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1268 old_dir
->i_size
+= old_sz
;
1269 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1274 drop_nlink(new_dir
);
1281 drop_nlink(whiteout
);
1284 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1285 ubifs_release_budget(c
, &ino_req
);
1286 ubifs_release_budget(c
, &req
);
1290 static int ubifs_xrename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1291 struct inode
*new_dir
, struct dentry
*new_dentry
)
1293 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1294 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1296 int sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1297 struct inode
*fst_inode
= d_inode(old_dentry
);
1298 struct inode
*snd_inode
= d_inode(new_dentry
);
1299 struct timespec time
;
1302 ubifs_assert(fst_inode
&& snd_inode
);
1304 lock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1306 time
= ubifs_current_time(old_dir
);
1307 fst_inode
->i_ctime
= time
;
1308 snd_inode
->i_ctime
= time
;
1309 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1310 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1312 if (old_dir
!= new_dir
) {
1313 if (S_ISDIR(fst_inode
->i_mode
) && !S_ISDIR(snd_inode
->i_mode
)) {
1315 drop_nlink(old_dir
);
1317 else if (!S_ISDIR(fst_inode
->i_mode
) && S_ISDIR(snd_inode
->i_mode
)) {
1318 drop_nlink(new_dir
);
1323 err
= ubifs_jnl_xrename(c
, old_dir
, old_dentry
, new_dir
, new_dentry
,
1326 unlock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1327 ubifs_release_budget(c
, &req
);
1332 static int ubifs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1333 struct inode
*new_dir
, struct dentry
*new_dentry
,
1336 if (flags
& ~(RENAME_NOREPLACE
| RENAME_WHITEOUT
| RENAME_EXCHANGE
))
1339 ubifs_assert(inode_is_locked(old_dir
));
1340 ubifs_assert(inode_is_locked(new_dir
));
1342 if (flags
& RENAME_EXCHANGE
)
1343 return ubifs_xrename(old_dir
, old_dentry
, new_dir
, new_dentry
);
1345 return do_rename(old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
1348 int ubifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1352 struct inode
*inode
= d_inode(dentry
);
1353 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1355 mutex_lock(&ui
->ui_mutex
);
1356 generic_fillattr(inode
, stat
);
1357 stat
->blksize
= UBIFS_BLOCK_SIZE
;
1358 stat
->size
= ui
->ui_size
;
1361 * Unfortunately, the 'stat()' system call was designed for block
1362 * device based file systems, and it is not appropriate for UBIFS,
1363 * because UBIFS does not have notion of "block". For example, it is
1364 * difficult to tell how many block a directory takes - it actually
1365 * takes less than 300 bytes, but we have to round it to block size,
1366 * which introduces large mistake. This makes utilities like 'du' to
1367 * report completely senseless numbers. This is the reason why UBIFS
1368 * goes the same way as JFFS2 - it reports zero blocks for everything
1369 * but regular files, which makes more sense than reporting completely
1372 if (S_ISREG(inode
->i_mode
)) {
1373 size
= ui
->xattr_size
;
1375 size
= ALIGN(size
, UBIFS_BLOCK_SIZE
);
1377 * Note, user-space expects 512-byte blocks count irrespectively
1378 * of what was reported in @stat->size.
1380 stat
->blocks
= size
>> 9;
1383 mutex_unlock(&ui
->ui_mutex
);
1387 const struct inode_operations ubifs_dir_inode_operations
= {
1388 .lookup
= ubifs_lookup
,
1389 .create
= ubifs_create
,
1391 .symlink
= ubifs_symlink
,
1392 .unlink
= ubifs_unlink
,
1393 .mkdir
= ubifs_mkdir
,
1394 .rmdir
= ubifs_rmdir
,
1395 .mknod
= ubifs_mknod
,
1396 .rename
= ubifs_rename
,
1397 .setattr
= ubifs_setattr
,
1398 .getattr
= ubifs_getattr
,
1399 .listxattr
= ubifs_listxattr
,
1400 #ifdef CONFIG_UBIFS_ATIME_SUPPORT
1401 .update_time
= ubifs_update_time
,
1403 .tmpfile
= ubifs_tmpfile
,
1406 const struct file_operations ubifs_dir_operations
= {
1407 .llseek
= generic_file_llseek
,
1408 .release
= ubifs_dir_release
,
1409 .read
= generic_read_dir
,
1410 .iterate_shared
= ubifs_readdir
,
1411 .fsync
= ubifs_fsync
,
1412 .unlocked_ioctl
= ubifs_ioctl
,
1413 #ifdef CONFIG_COMPAT
1414 .compat_ioctl
= ubifs_compat_ioctl
,