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
;
544 if (err
!= -ENOENT
) {
545 ubifs_err(c
, "cannot find next direntry, error %d", err
);
549 /* 2 is a special value indicating that there are no more direntries */
554 /* Free saved readdir() state when the directory is closed */
555 static int ubifs_dir_release(struct inode
*dir
, struct file
*file
)
557 kfree(file
->private_data
);
558 file
->private_data
= NULL
;
563 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
564 * @inode1: first inode
565 * @inode2: second inode
567 * We do not implement any tricks to guarantee strict lock ordering, because
568 * VFS has already done it for us on the @i_mutex. So this is just a simple
571 static void lock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
573 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
574 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
578 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
579 * @inode1: first inode
580 * @inode2: second inode
582 static void unlock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
584 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
585 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
588 static int ubifs_link(struct dentry
*old_dentry
, struct inode
*dir
,
589 struct dentry
*dentry
)
591 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
592 struct inode
*inode
= d_inode(old_dentry
);
593 struct ubifs_inode
*ui
= ubifs_inode(inode
);
594 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
595 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
596 struct ubifs_budget_req req
= { .new_dent
= 1, .dirtied_ino
= 2,
597 .dirtied_ino_d
= ALIGN(ui
->data_len
, 8) };
600 * Budget request settings: new direntry, changing the target inode,
601 * changing the parent inode.
604 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
605 dentry
, inode
->i_ino
,
606 inode
->i_nlink
, dir
->i_ino
);
607 ubifs_assert(inode_is_locked(dir
));
608 ubifs_assert(inode_is_locked(inode
));
610 err
= dbg_check_synced_i_size(c
, inode
);
614 err
= ubifs_budget_space(c
, &req
);
618 lock_2_inodes(dir
, inode
);
621 inode
->i_ctime
= ubifs_current_time(inode
);
622 dir
->i_size
+= sz_change
;
623 dir_ui
->ui_size
= dir
->i_size
;
624 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
625 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
628 unlock_2_inodes(dir
, inode
);
630 ubifs_release_budget(c
, &req
);
631 d_instantiate(dentry
, inode
);
635 dir
->i_size
-= sz_change
;
636 dir_ui
->ui_size
= dir
->i_size
;
638 unlock_2_inodes(dir
, inode
);
639 ubifs_release_budget(c
, &req
);
644 static int ubifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
646 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
647 struct inode
*inode
= d_inode(dentry
);
648 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
649 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
650 int err
, budgeted
= 1;
651 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
652 unsigned int saved_nlink
= inode
->i_nlink
;
655 * Budget request settings: deletion direntry, deletion inode (+1 for
656 * @dirtied_ino), changing the parent directory inode. If budgeting
657 * fails, go ahead anyway because we have extra space reserved for
661 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
662 dentry
, inode
->i_ino
,
663 inode
->i_nlink
, dir
->i_ino
);
664 ubifs_assert(inode_is_locked(dir
));
665 ubifs_assert(inode_is_locked(inode
));
666 err
= dbg_check_synced_i_size(c
, inode
);
670 err
= ubifs_budget_space(c
, &req
);
677 lock_2_inodes(dir
, inode
);
678 inode
->i_ctime
= ubifs_current_time(dir
);
680 dir
->i_size
-= sz_change
;
681 dir_ui
->ui_size
= dir
->i_size
;
682 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
683 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
686 unlock_2_inodes(dir
, inode
);
689 ubifs_release_budget(c
, &req
);
691 /* We've deleted something - clean the "no space" flags */
692 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
698 dir
->i_size
+= sz_change
;
699 dir_ui
->ui_size
= dir
->i_size
;
700 set_nlink(inode
, saved_nlink
);
701 unlock_2_inodes(dir
, inode
);
703 ubifs_release_budget(c
, &req
);
708 * check_dir_empty - check if a directory is empty or not.
709 * @c: UBIFS file-system description object
710 * @dir: VFS inode object of the directory to check
712 * This function checks if directory @dir is empty. Returns zero if the
713 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
714 * in case of of errors.
716 static int check_dir_empty(struct ubifs_info
*c
, struct inode
*dir
)
718 struct qstr nm
= { .name
= NULL
};
719 struct ubifs_dent_node
*dent
;
723 lowest_dent_key(c
, &key
, dir
->i_ino
);
724 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
736 static int ubifs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
738 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
739 struct inode
*inode
= d_inode(dentry
);
740 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
741 int err
, budgeted
= 1;
742 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
743 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
746 * Budget request settings: deletion direntry, deletion inode and
747 * changing the parent inode. If budgeting fails, go ahead anyway
748 * because we have extra space reserved for deletions.
751 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry
,
752 inode
->i_ino
, dir
->i_ino
);
753 ubifs_assert(inode_is_locked(dir
));
754 ubifs_assert(inode_is_locked(inode
));
755 err
= check_dir_empty(c
, d_inode(dentry
));
759 err
= ubifs_budget_space(c
, &req
);
766 lock_2_inodes(dir
, inode
);
767 inode
->i_ctime
= ubifs_current_time(dir
);
770 dir
->i_size
-= sz_change
;
771 dir_ui
->ui_size
= dir
->i_size
;
772 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
773 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
776 unlock_2_inodes(dir
, inode
);
779 ubifs_release_budget(c
, &req
);
781 /* We've deleted something - clean the "no space" flags */
782 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
788 dir
->i_size
+= sz_change
;
789 dir_ui
->ui_size
= dir
->i_size
;
792 unlock_2_inodes(dir
, inode
);
794 ubifs_release_budget(c
, &req
);
798 static int ubifs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
801 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
802 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
803 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
804 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1 };
807 * Budget request settings: new inode, new direntry and changing parent
811 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
812 dentry
, mode
, dir
->i_ino
);
814 err
= ubifs_budget_space(c
, &req
);
818 inode
= ubifs_new_inode(c
, dir
, S_IFDIR
| mode
);
820 err
= PTR_ERR(inode
);
824 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
828 mutex_lock(&dir_ui
->ui_mutex
);
829 insert_inode_hash(inode
);
832 dir
->i_size
+= sz_change
;
833 dir_ui
->ui_size
= dir
->i_size
;
834 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
835 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
837 ubifs_err(c
, "cannot create directory, error %d", err
);
840 mutex_unlock(&dir_ui
->ui_mutex
);
842 ubifs_release_budget(c
, &req
);
843 d_instantiate(dentry
, inode
);
847 dir
->i_size
-= sz_change
;
848 dir_ui
->ui_size
= dir
->i_size
;
850 mutex_unlock(&dir_ui
->ui_mutex
);
852 make_bad_inode(inode
);
855 ubifs_release_budget(c
, &req
);
859 static int ubifs_mknod(struct inode
*dir
, struct dentry
*dentry
,
860 umode_t mode
, dev_t rdev
)
863 struct ubifs_inode
*ui
;
864 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
865 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
866 union ubifs_dev_desc
*dev
= NULL
;
867 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
869 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
870 .new_ino_d
= ALIGN(devlen
, 8),
874 * Budget request settings: new inode, new direntry and changing parent
878 dbg_gen("dent '%pd' in dir ino %lu", dentry
, dir
->i_ino
);
880 if (S_ISBLK(mode
) || S_ISCHR(mode
)) {
881 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
884 devlen
= ubifs_encode_dev(dev
, rdev
);
887 err
= ubifs_budget_space(c
, &req
);
893 inode
= ubifs_new_inode(c
, dir
, mode
);
896 err
= PTR_ERR(inode
);
900 init_special_inode(inode
, inode
->i_mode
, rdev
);
901 inode
->i_size
= ubifs_inode(inode
)->ui_size
= devlen
;
902 ui
= ubifs_inode(inode
);
904 ui
->data_len
= devlen
;
906 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
910 mutex_lock(&dir_ui
->ui_mutex
);
911 dir
->i_size
+= sz_change
;
912 dir_ui
->ui_size
= dir
->i_size
;
913 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
914 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
917 mutex_unlock(&dir_ui
->ui_mutex
);
919 ubifs_release_budget(c
, &req
);
920 insert_inode_hash(inode
);
921 d_instantiate(dentry
, inode
);
925 dir
->i_size
-= sz_change
;
926 dir_ui
->ui_size
= dir
->i_size
;
927 mutex_unlock(&dir_ui
->ui_mutex
);
929 make_bad_inode(inode
);
932 ubifs_release_budget(c
, &req
);
936 static int ubifs_symlink(struct inode
*dir
, struct dentry
*dentry
,
940 struct ubifs_inode
*ui
;
941 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
942 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
943 int err
, len
= strlen(symname
);
944 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
945 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
946 .new_ino_d
= ALIGN(len
, 8),
950 * Budget request settings: new inode, new direntry and changing parent
954 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry
,
955 symname
, dir
->i_ino
);
957 if (len
> UBIFS_MAX_INO_DATA
)
958 return -ENAMETOOLONG
;
960 err
= ubifs_budget_space(c
, &req
);
964 inode
= ubifs_new_inode(c
, dir
, S_IFLNK
| S_IRWXUGO
);
966 err
= PTR_ERR(inode
);
970 ui
= ubifs_inode(inode
);
971 ui
->data
= kmalloc(len
+ 1, GFP_NOFS
);
977 memcpy(ui
->data
, symname
, len
);
978 ((char *)ui
->data
)[len
] = '\0';
979 inode
->i_link
= ui
->data
;
981 * The terminating zero byte is not written to the flash media and it
982 * is put just to make later in-memory string processing simpler. Thus,
983 * data length is @len, not @len + %1.
986 inode
->i_size
= ubifs_inode(inode
)->ui_size
= len
;
988 err
= ubifs_init_security(dir
, inode
, &dentry
->d_name
);
992 mutex_lock(&dir_ui
->ui_mutex
);
993 dir
->i_size
+= sz_change
;
994 dir_ui
->ui_size
= dir
->i_size
;
995 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
996 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
999 mutex_unlock(&dir_ui
->ui_mutex
);
1001 ubifs_release_budget(c
, &req
);
1002 insert_inode_hash(inode
);
1003 d_instantiate(dentry
, inode
);
1007 dir
->i_size
-= sz_change
;
1008 dir_ui
->ui_size
= dir
->i_size
;
1009 mutex_unlock(&dir_ui
->ui_mutex
);
1011 make_bad_inode(inode
);
1014 ubifs_release_budget(c
, &req
);
1019 * lock_4_inodes - a wrapper for locking three UBIFS inodes.
1020 * @inode1: first inode
1021 * @inode2: second inode
1022 * @inode3: third inode
1023 * @inode4: fouth inode
1025 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
1026 * @inode2 whereas @inode3 and @inode4 may be %NULL.
1028 * We do not implement any tricks to guarantee strict lock ordering, because
1029 * VFS has already done it for us on the @i_mutex. So this is just a simple
1032 static void lock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1033 struct inode
*inode3
, struct inode
*inode4
)
1035 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
1036 if (inode2
!= inode1
)
1037 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
1039 mutex_lock_nested(&ubifs_inode(inode3
)->ui_mutex
, WB_MUTEX_3
);
1041 mutex_lock_nested(&ubifs_inode(inode4
)->ui_mutex
, WB_MUTEX_4
);
1045 * unlock_4_inodes - a wrapper for unlocking three UBIFS inodes for rename.
1046 * @inode1: first inode
1047 * @inode2: second inode
1048 * @inode3: third inode
1049 * @inode4: fouth inode
1051 static void unlock_4_inodes(struct inode
*inode1
, struct inode
*inode2
,
1052 struct inode
*inode3
, struct inode
*inode4
)
1055 mutex_unlock(&ubifs_inode(inode4
)->ui_mutex
);
1057 mutex_unlock(&ubifs_inode(inode3
)->ui_mutex
);
1058 if (inode1
!= inode2
)
1059 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
1060 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
1063 static int ubifs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1064 struct inode
*new_dir
, struct dentry
*new_dentry
,
1067 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1068 struct inode
*old_inode
= d_inode(old_dentry
);
1069 struct inode
*new_inode
= d_inode(new_dentry
);
1070 struct inode
*whiteout
= NULL
;
1071 struct ubifs_inode
*old_inode_ui
= ubifs_inode(old_inode
);
1072 struct ubifs_inode
*whiteout_ui
= NULL
;
1073 int err
, release
, sync
= 0, move
= (new_dir
!= old_dir
);
1074 int is_dir
= S_ISDIR(old_inode
->i_mode
);
1075 int unlink
= !!new_inode
;
1076 int new_sz
= CALC_DENT_SIZE(new_dentry
->d_name
.len
);
1077 int old_sz
= CALC_DENT_SIZE(old_dentry
->d_name
.len
);
1078 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1080 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1,
1081 .dirtied_ino_d
= ALIGN(old_inode_ui
->data_len
, 8) };
1082 struct timespec time
;
1083 unsigned int uninitialized_var(saved_nlink
);
1086 * Budget request settings: deletion direntry, new direntry, removing
1087 * the old inode, and changing old and new parent directory inodes.
1089 * However, this operation also marks the target inode as dirty and
1090 * does not write it, so we allocate budget for the target inode
1094 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1095 old_dentry
, old_inode
->i_ino
, old_dir
->i_ino
,
1096 new_dentry
, new_dir
->i_ino
, flags
);
1099 ubifs_assert(inode_is_locked(new_inode
));
1101 if (unlink
&& is_dir
) {
1102 err
= check_dir_empty(c
, new_inode
);
1107 err
= ubifs_budget_space(c
, &req
);
1110 err
= ubifs_budget_space(c
, &ino_req
);
1112 ubifs_release_budget(c
, &req
);
1116 if (flags
& RENAME_WHITEOUT
) {
1117 union ubifs_dev_desc
*dev
= NULL
;
1119 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
1121 ubifs_release_budget(c
, &req
);
1122 ubifs_release_budget(c
, &ino_req
);
1126 err
= do_tmpfile(old_dir
, old_dentry
, S_IFCHR
| WHITEOUT_MODE
, &whiteout
);
1128 ubifs_release_budget(c
, &req
);
1129 ubifs_release_budget(c
, &ino_req
);
1134 whiteout
->i_state
|= I_LINKABLE
;
1135 whiteout_ui
= ubifs_inode(whiteout
);
1136 whiteout_ui
->data
= dev
;
1137 whiteout_ui
->data_len
= ubifs_encode_dev(dev
, MKDEV(0, 0));
1138 ubifs_assert(!whiteout_ui
->dirty
);
1141 lock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1144 * Like most other Unix systems, set the @i_ctime for inodes on a
1147 time
= ubifs_current_time(old_dir
);
1148 old_inode
->i_ctime
= time
;
1150 /* We must adjust parent link count when renaming directories */
1154 * @old_dir loses a link because we are moving
1155 * @old_inode to a different directory.
1157 drop_nlink(old_dir
);
1159 * @new_dir only gains a link if we are not also
1160 * overwriting an existing directory.
1166 * @old_inode is not moving to a different directory,
1167 * but @old_dir still loses a link if we are
1168 * overwriting an existing directory.
1171 drop_nlink(old_dir
);
1175 old_dir
->i_size
-= old_sz
;
1176 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1177 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1178 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1181 * And finally, if we unlinked a direntry which happened to have the
1182 * same name as the moved direntry, we have to decrement @i_nlink of
1183 * the unlinked inode and change its ctime.
1187 * Directories cannot have hard-links, so if this is a
1188 * directory, just clear @i_nlink.
1190 saved_nlink
= new_inode
->i_nlink
;
1192 clear_nlink(new_inode
);
1194 drop_nlink(new_inode
);
1195 new_inode
->i_ctime
= time
;
1197 new_dir
->i_size
+= new_sz
;
1198 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1202 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1203 * is dirty, because this will be done later on at the end of
1206 if (IS_SYNC(old_inode
)) {
1207 sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1208 if (unlink
&& IS_SYNC(new_inode
))
1213 struct ubifs_budget_req wht_req
= { .dirtied_ino
= 1,
1215 ALIGN(ubifs_inode(whiteout
)->data_len
, 8) };
1217 err
= ubifs_budget_space(c
, &wht_req
);
1219 ubifs_release_budget(c
, &req
);
1220 ubifs_release_budget(c
, &ino_req
);
1221 kfree(whiteout_ui
->data
);
1222 whiteout_ui
->data_len
= 0;
1227 inc_nlink(whiteout
);
1228 mark_inode_dirty(whiteout
);
1229 whiteout
->i_state
&= ~I_LINKABLE
;
1233 err
= ubifs_jnl_rename(c
, old_dir
, old_dentry
, new_dir
, new_dentry
, whiteout
,
1238 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1239 ubifs_release_budget(c
, &req
);
1241 mutex_lock(&old_inode_ui
->ui_mutex
);
1242 release
= old_inode_ui
->dirty
;
1243 mark_inode_dirty_sync(old_inode
);
1244 mutex_unlock(&old_inode_ui
->ui_mutex
);
1247 ubifs_release_budget(c
, &ino_req
);
1248 if (IS_SYNC(old_inode
))
1249 err
= old_inode
->i_sb
->s_op
->write_inode(old_inode
, NULL
);
1254 set_nlink(new_inode
, saved_nlink
);
1256 new_dir
->i_size
-= new_sz
;
1257 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1259 old_dir
->i_size
+= old_sz
;
1260 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1265 drop_nlink(new_dir
);
1272 drop_nlink(whiteout
);
1275 unlock_4_inodes(old_dir
, new_dir
, new_inode
, whiteout
);
1276 ubifs_release_budget(c
, &ino_req
);
1277 ubifs_release_budget(c
, &req
);
1281 static int ubifs_xrename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1282 struct inode
*new_dir
, struct dentry
*new_dentry
)
1284 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
1285 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
1287 int sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1288 struct inode
*fst_inode
= d_inode(old_dentry
);
1289 struct inode
*snd_inode
= d_inode(new_dentry
);
1290 struct timespec time
;
1293 ubifs_assert(fst_inode
&& snd_inode
);
1295 lock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1297 time
= ubifs_current_time(old_dir
);
1298 fst_inode
->i_ctime
= time
;
1299 snd_inode
->i_ctime
= time
;
1300 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1301 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1303 if (old_dir
!= new_dir
) {
1304 if (S_ISDIR(fst_inode
->i_mode
) && !S_ISDIR(snd_inode
->i_mode
)) {
1306 drop_nlink(old_dir
);
1308 else if (!S_ISDIR(fst_inode
->i_mode
) && S_ISDIR(snd_inode
->i_mode
)) {
1309 drop_nlink(new_dir
);
1314 err
= ubifs_jnl_xrename(c
, old_dir
, old_dentry
, new_dir
, new_dentry
,
1317 unlock_4_inodes(old_dir
, new_dir
, NULL
, NULL
);
1318 ubifs_release_budget(c
, &req
);
1323 static int ubifs_rename2(struct inode
*old_dir
, struct dentry
*old_dentry
,
1324 struct inode
*new_dir
, struct dentry
*new_dentry
,
1327 if (flags
& ~(RENAME_NOREPLACE
| RENAME_WHITEOUT
| RENAME_EXCHANGE
))
1330 ubifs_assert(inode_is_locked(old_dir
));
1331 ubifs_assert(inode_is_locked(new_dir
));
1333 if (flags
& RENAME_EXCHANGE
)
1334 return ubifs_xrename(old_dir
, old_dentry
, new_dir
, new_dentry
);
1336 return ubifs_rename(old_dir
, old_dentry
, new_dir
, new_dentry
, flags
);
1339 int ubifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1343 struct inode
*inode
= d_inode(dentry
);
1344 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1346 mutex_lock(&ui
->ui_mutex
);
1347 generic_fillattr(inode
, stat
);
1348 stat
->blksize
= UBIFS_BLOCK_SIZE
;
1349 stat
->size
= ui
->ui_size
;
1352 * Unfortunately, the 'stat()' system call was designed for block
1353 * device based file systems, and it is not appropriate for UBIFS,
1354 * because UBIFS does not have notion of "block". For example, it is
1355 * difficult to tell how many block a directory takes - it actually
1356 * takes less than 300 bytes, but we have to round it to block size,
1357 * which introduces large mistake. This makes utilities like 'du' to
1358 * report completely senseless numbers. This is the reason why UBIFS
1359 * goes the same way as JFFS2 - it reports zero blocks for everything
1360 * but regular files, which makes more sense than reporting completely
1363 if (S_ISREG(inode
->i_mode
)) {
1364 size
= ui
->xattr_size
;
1366 size
= ALIGN(size
, UBIFS_BLOCK_SIZE
);
1368 * Note, user-space expects 512-byte blocks count irrespectively
1369 * of what was reported in @stat->size.
1371 stat
->blocks
= size
>> 9;
1374 mutex_unlock(&ui
->ui_mutex
);
1378 const struct inode_operations ubifs_dir_inode_operations
= {
1379 .lookup
= ubifs_lookup
,
1380 .create
= ubifs_create
,
1382 .symlink
= ubifs_symlink
,
1383 .unlink
= ubifs_unlink
,
1384 .mkdir
= ubifs_mkdir
,
1385 .rmdir
= ubifs_rmdir
,
1386 .mknod
= ubifs_mknod
,
1387 .rename2
= ubifs_rename2
,
1388 .setattr
= ubifs_setattr
,
1389 .getattr
= ubifs_getattr
,
1390 .setxattr
= generic_setxattr
,
1391 .getxattr
= generic_getxattr
,
1392 .listxattr
= ubifs_listxattr
,
1393 .removexattr
= generic_removexattr
,
1394 #ifdef CONFIG_UBIFS_ATIME_SUPPORT
1395 .update_time
= ubifs_update_time
,
1397 .tmpfile
= ubifs_tmpfile
,
1400 const struct file_operations ubifs_dir_operations
= {
1401 .llseek
= generic_file_llseek
,
1402 .release
= ubifs_dir_release
,
1403 .read
= generic_read_dir
,
1404 .iterate_shared
= ubifs_readdir
,
1405 .fsync
= ubifs_fsync
,
1406 .unlocked_ioctl
= ubifs_ioctl
,
1407 #ifdef CONFIG_COMPAT
1408 .compat_ioctl
= ubifs_compat_ioctl
,