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("out of inode numbers");
150 make_bad_inode(inode
);
152 return ERR_PTR(-EINVAL
);
154 ubifs_warn("running out of inode numbers (current %lu, max %d)",
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("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 mutex_lock(&dir_ui
->ui_mutex
);
274 dir
->i_size
+= sz_change
;
275 dir_ui
->ui_size
= dir
->i_size
;
276 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
277 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
280 mutex_unlock(&dir_ui
->ui_mutex
);
282 ubifs_release_budget(c
, &req
);
283 insert_inode_hash(inode
);
284 d_instantiate(dentry
, inode
);
288 dir
->i_size
-= sz_change
;
289 dir_ui
->ui_size
= dir
->i_size
;
290 mutex_unlock(&dir_ui
->ui_mutex
);
291 make_bad_inode(inode
);
294 ubifs_release_budget(c
, &req
);
295 ubifs_err("cannot create regular file, error %d", err
);
300 * vfs_dent_type - get VFS directory entry type.
301 * @type: UBIFS directory entry type
303 * This function converts UBIFS directory entry type into VFS directory entry
306 static unsigned int vfs_dent_type(uint8_t type
)
309 case UBIFS_ITYPE_REG
:
311 case UBIFS_ITYPE_DIR
:
313 case UBIFS_ITYPE_LNK
:
315 case UBIFS_ITYPE_BLK
:
317 case UBIFS_ITYPE_CHR
:
319 case UBIFS_ITYPE_FIFO
:
321 case UBIFS_ITYPE_SOCK
:
330 * The classical Unix view for directory is that it is a linear array of
331 * (name, inode number) entries. Linux/VFS assumes this model as well.
332 * Particularly, 'readdir()' call wants us to return a directory entry offset
333 * which later may be used to continue 'readdir()'ing the directory or to
334 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
335 * model because directory entries are identified by keys, which may collide.
337 * UBIFS uses directory entry hash value for directory offsets, so
338 * 'seekdir()'/'telldir()' may not always work because of possible key
339 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
340 * properly by means of saving full directory entry name in the private field
341 * of the file description object.
343 * This means that UBIFS cannot support NFS which requires full
344 * 'seekdir()'/'telldir()' support.
346 static int ubifs_readdir(struct file
*file
, struct dir_context
*ctx
)
351 struct ubifs_dent_node
*dent
;
352 struct inode
*dir
= file_inode(file
);
353 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
355 dbg_gen("dir ino %lu, f_pos %#llx", dir
->i_ino
, ctx
->pos
);
357 if (ctx
->pos
> UBIFS_S_KEY_HASH_MASK
|| ctx
->pos
== 2)
359 * The directory was seek'ed to a senseless position or there
360 * are no more entries.
364 if (file
->f_version
== 0) {
366 * The file was seek'ed, which means that @file->private_data
367 * is now invalid. This may also be just the first
368 * 'ubifs_readdir()' invocation, in which case
369 * @file->private_data is NULL, and the below code is
372 kfree(file
->private_data
);
373 file
->private_data
= NULL
;
377 * 'generic_file_llseek()' unconditionally sets @file->f_version to
378 * zero, and we use this for detecting whether the file was seek'ed.
382 /* File positions 0 and 1 correspond to "." and ".." */
384 ubifs_assert(!file
->private_data
);
385 if (!dir_emit_dots(file
, ctx
))
388 /* Find the first entry in TNC and save it */
389 lowest_dent_key(c
, &key
, dir
->i_ino
);
391 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
397 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
398 file
->private_data
= dent
;
401 dent
= file
->private_data
;
404 * The directory was seek'ed to and is now readdir'ed.
405 * Find the entry corresponding to @ctx->pos or the closest one.
407 dent_key_init_hash(c
, &key
, dir
->i_ino
, ctx
->pos
);
409 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
414 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
415 file
->private_data
= dent
;
419 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
420 dent
->name
, (unsigned long long)le64_to_cpu(dent
->inum
),
421 key_hash_flash(c
, &dent
->key
));
422 ubifs_assert(le64_to_cpu(dent
->ch
.sqnum
) >
423 ubifs_inode(dir
)->creat_sqnum
);
425 nm
.len
= le16_to_cpu(dent
->nlen
);
426 if (!dir_emit(ctx
, dent
->name
, nm
.len
,
427 le64_to_cpu(dent
->inum
),
428 vfs_dent_type(dent
->type
)))
431 /* Switch to the next entry */
432 key_read(c
, &dent
->key
, &key
);
433 nm
.name
= dent
->name
;
434 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
440 kfree(file
->private_data
);
441 ctx
->pos
= key_hash_flash(c
, &dent
->key
);
442 file
->private_data
= dent
;
447 if (err
!= -ENOENT
) {
448 ubifs_err("cannot find next direntry, error %d", err
);
452 kfree(file
->private_data
);
453 file
->private_data
= NULL
;
454 /* 2 is a special value indicating that there are no more direntries */
459 /* Free saved readdir() state when the directory is closed */
460 static int ubifs_dir_release(struct inode
*dir
, struct file
*file
)
462 kfree(file
->private_data
);
463 file
->private_data
= NULL
;
468 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
469 * @inode1: first inode
470 * @inode2: second inode
472 * We do not implement any tricks to guarantee strict lock ordering, because
473 * VFS has already done it for us on the @i_mutex. So this is just a simple
476 static void lock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
478 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
479 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
483 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
484 * @inode1: first inode
485 * @inode2: second inode
487 static void unlock_2_inodes(struct inode
*inode1
, struct inode
*inode2
)
489 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
490 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
493 static int ubifs_link(struct dentry
*old_dentry
, struct inode
*dir
,
494 struct dentry
*dentry
)
496 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
497 struct inode
*inode
= old_dentry
->d_inode
;
498 struct ubifs_inode
*ui
= ubifs_inode(inode
);
499 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
500 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
501 struct ubifs_budget_req req
= { .new_dent
= 1, .dirtied_ino
= 2,
502 .dirtied_ino_d
= ALIGN(ui
->data_len
, 8) };
505 * Budget request settings: new direntry, changing the target inode,
506 * changing the parent inode.
509 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
510 dentry
, inode
->i_ino
,
511 inode
->i_nlink
, dir
->i_ino
);
512 ubifs_assert(mutex_is_locked(&dir
->i_mutex
));
513 ubifs_assert(mutex_is_locked(&inode
->i_mutex
));
515 err
= dbg_check_synced_i_size(c
, inode
);
519 err
= ubifs_budget_space(c
, &req
);
523 lock_2_inodes(dir
, inode
);
526 inode
->i_ctime
= ubifs_current_time(inode
);
527 dir
->i_size
+= sz_change
;
528 dir_ui
->ui_size
= dir
->i_size
;
529 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
530 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
533 unlock_2_inodes(dir
, inode
);
535 ubifs_release_budget(c
, &req
);
536 d_instantiate(dentry
, inode
);
540 dir
->i_size
-= sz_change
;
541 dir_ui
->ui_size
= dir
->i_size
;
543 unlock_2_inodes(dir
, inode
);
544 ubifs_release_budget(c
, &req
);
549 static int ubifs_unlink(struct inode
*dir
, struct dentry
*dentry
)
551 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
552 struct inode
*inode
= dentry
->d_inode
;
553 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
554 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
555 int err
, budgeted
= 1;
556 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
557 unsigned int saved_nlink
= inode
->i_nlink
;
560 * Budget request settings: deletion direntry, deletion inode (+1 for
561 * @dirtied_ino), changing the parent directory inode. If budgeting
562 * fails, go ahead anyway because we have extra space reserved for
566 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
567 dentry
, inode
->i_ino
,
568 inode
->i_nlink
, dir
->i_ino
);
569 ubifs_assert(mutex_is_locked(&dir
->i_mutex
));
570 ubifs_assert(mutex_is_locked(&inode
->i_mutex
));
571 err
= dbg_check_synced_i_size(c
, inode
);
575 err
= ubifs_budget_space(c
, &req
);
582 lock_2_inodes(dir
, inode
);
583 inode
->i_ctime
= ubifs_current_time(dir
);
585 dir
->i_size
-= sz_change
;
586 dir_ui
->ui_size
= dir
->i_size
;
587 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
588 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
591 unlock_2_inodes(dir
, inode
);
594 ubifs_release_budget(c
, &req
);
596 /* We've deleted something - clean the "no space" flags */
597 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
603 dir
->i_size
+= sz_change
;
604 dir_ui
->ui_size
= dir
->i_size
;
605 set_nlink(inode
, saved_nlink
);
606 unlock_2_inodes(dir
, inode
);
608 ubifs_release_budget(c
, &req
);
613 * check_dir_empty - check if a directory is empty or not.
614 * @c: UBIFS file-system description object
615 * @dir: VFS inode object of the directory to check
617 * This function checks if directory @dir is empty. Returns zero if the
618 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
619 * in case of of errors.
621 static int check_dir_empty(struct ubifs_info
*c
, struct inode
*dir
)
623 struct qstr nm
= { .name
= NULL
};
624 struct ubifs_dent_node
*dent
;
628 lowest_dent_key(c
, &key
, dir
->i_ino
);
629 dent
= ubifs_tnc_next_ent(c
, &key
, &nm
);
641 static int ubifs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
643 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
644 struct inode
*inode
= dentry
->d_inode
;
645 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
646 int err
, budgeted
= 1;
647 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
648 struct ubifs_budget_req req
= { .mod_dent
= 1, .dirtied_ino
= 2 };
651 * Budget request settings: deletion direntry, deletion inode and
652 * changing the parent inode. If budgeting fails, go ahead anyway
653 * because we have extra space reserved for deletions.
656 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry
,
657 inode
->i_ino
, dir
->i_ino
);
658 ubifs_assert(mutex_is_locked(&dir
->i_mutex
));
659 ubifs_assert(mutex_is_locked(&inode
->i_mutex
));
660 err
= check_dir_empty(c
, dentry
->d_inode
);
664 err
= ubifs_budget_space(c
, &req
);
671 lock_2_inodes(dir
, inode
);
672 inode
->i_ctime
= ubifs_current_time(dir
);
675 dir
->i_size
-= sz_change
;
676 dir_ui
->ui_size
= dir
->i_size
;
677 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
678 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 1, 0);
681 unlock_2_inodes(dir
, inode
);
684 ubifs_release_budget(c
, &req
);
686 /* We've deleted something - clean the "no space" flags */
687 c
->bi
.nospace
= c
->bi
.nospace_rp
= 0;
693 dir
->i_size
+= sz_change
;
694 dir_ui
->ui_size
= dir
->i_size
;
697 unlock_2_inodes(dir
, inode
);
699 ubifs_release_budget(c
, &req
);
703 static int ubifs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
706 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
707 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
708 int err
, sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
709 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1 };
712 * Budget request settings: new inode, new direntry and changing parent
716 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
717 dentry
, mode
, dir
->i_ino
);
719 err
= ubifs_budget_space(c
, &req
);
723 inode
= ubifs_new_inode(c
, dir
, S_IFDIR
| mode
);
725 err
= PTR_ERR(inode
);
729 mutex_lock(&dir_ui
->ui_mutex
);
730 insert_inode_hash(inode
);
733 dir
->i_size
+= sz_change
;
734 dir_ui
->ui_size
= dir
->i_size
;
735 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
736 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
738 ubifs_err("cannot create directory, error %d", err
);
741 mutex_unlock(&dir_ui
->ui_mutex
);
743 ubifs_release_budget(c
, &req
);
744 d_instantiate(dentry
, inode
);
748 dir
->i_size
-= sz_change
;
749 dir_ui
->ui_size
= dir
->i_size
;
751 mutex_unlock(&dir_ui
->ui_mutex
);
752 make_bad_inode(inode
);
755 ubifs_release_budget(c
, &req
);
759 static int ubifs_mknod(struct inode
*dir
, struct dentry
*dentry
,
760 umode_t mode
, dev_t rdev
)
763 struct ubifs_inode
*ui
;
764 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
765 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
766 union ubifs_dev_desc
*dev
= NULL
;
767 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
769 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
770 .new_ino_d
= ALIGN(devlen
, 8),
774 * Budget request settings: new inode, new direntry and changing parent
778 dbg_gen("dent '%pd' in dir ino %lu", dentry
, dir
->i_ino
);
780 if (!new_valid_dev(rdev
))
783 if (S_ISBLK(mode
) || S_ISCHR(mode
)) {
784 dev
= kmalloc(sizeof(union ubifs_dev_desc
), GFP_NOFS
);
787 devlen
= ubifs_encode_dev(dev
, rdev
);
790 err
= ubifs_budget_space(c
, &req
);
796 inode
= ubifs_new_inode(c
, dir
, mode
);
799 err
= PTR_ERR(inode
);
803 init_special_inode(inode
, inode
->i_mode
, rdev
);
804 inode
->i_size
= ubifs_inode(inode
)->ui_size
= devlen
;
805 ui
= ubifs_inode(inode
);
807 ui
->data_len
= devlen
;
809 mutex_lock(&dir_ui
->ui_mutex
);
810 dir
->i_size
+= sz_change
;
811 dir_ui
->ui_size
= dir
->i_size
;
812 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
813 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
816 mutex_unlock(&dir_ui
->ui_mutex
);
818 ubifs_release_budget(c
, &req
);
819 insert_inode_hash(inode
);
820 d_instantiate(dentry
, inode
);
824 dir
->i_size
-= sz_change
;
825 dir_ui
->ui_size
= dir
->i_size
;
826 mutex_unlock(&dir_ui
->ui_mutex
);
827 make_bad_inode(inode
);
830 ubifs_release_budget(c
, &req
);
834 static int ubifs_symlink(struct inode
*dir
, struct dentry
*dentry
,
838 struct ubifs_inode
*ui
;
839 struct ubifs_inode
*dir_ui
= ubifs_inode(dir
);
840 struct ubifs_info
*c
= dir
->i_sb
->s_fs_info
;
841 int err
, len
= strlen(symname
);
842 int sz_change
= CALC_DENT_SIZE(dentry
->d_name
.len
);
843 struct ubifs_budget_req req
= { .new_ino
= 1, .new_dent
= 1,
844 .new_ino_d
= ALIGN(len
, 8),
848 * Budget request settings: new inode, new direntry and changing parent
852 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry
,
853 symname
, dir
->i_ino
);
855 if (len
> UBIFS_MAX_INO_DATA
)
856 return -ENAMETOOLONG
;
858 err
= ubifs_budget_space(c
, &req
);
862 inode
= ubifs_new_inode(c
, dir
, S_IFLNK
| S_IRWXUGO
);
864 err
= PTR_ERR(inode
);
868 ui
= ubifs_inode(inode
);
869 ui
->data
= kmalloc(len
+ 1, GFP_NOFS
);
875 memcpy(ui
->data
, symname
, len
);
876 ((char *)ui
->data
)[len
] = '\0';
878 * The terminating zero byte is not written to the flash media and it
879 * is put just to make later in-memory string processing simpler. Thus,
880 * data length is @len, not @len + %1.
883 inode
->i_size
= ubifs_inode(inode
)->ui_size
= len
;
885 mutex_lock(&dir_ui
->ui_mutex
);
886 dir
->i_size
+= sz_change
;
887 dir_ui
->ui_size
= dir
->i_size
;
888 dir
->i_mtime
= dir
->i_ctime
= inode
->i_ctime
;
889 err
= ubifs_jnl_update(c
, dir
, &dentry
->d_name
, inode
, 0, 0);
892 mutex_unlock(&dir_ui
->ui_mutex
);
894 ubifs_release_budget(c
, &req
);
895 insert_inode_hash(inode
);
896 d_instantiate(dentry
, inode
);
900 dir
->i_size
-= sz_change
;
901 dir_ui
->ui_size
= dir
->i_size
;
902 mutex_unlock(&dir_ui
->ui_mutex
);
904 make_bad_inode(inode
);
907 ubifs_release_budget(c
, &req
);
912 * lock_3_inodes - a wrapper for locking three UBIFS inodes.
913 * @inode1: first inode
914 * @inode2: second inode
915 * @inode3: third inode
917 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
918 * @inode2 whereas @inode3 may be %NULL.
920 * We do not implement any tricks to guarantee strict lock ordering, because
921 * VFS has already done it for us on the @i_mutex. So this is just a simple
924 static void lock_3_inodes(struct inode
*inode1
, struct inode
*inode2
,
925 struct inode
*inode3
)
927 mutex_lock_nested(&ubifs_inode(inode1
)->ui_mutex
, WB_MUTEX_1
);
928 if (inode2
!= inode1
)
929 mutex_lock_nested(&ubifs_inode(inode2
)->ui_mutex
, WB_MUTEX_2
);
931 mutex_lock_nested(&ubifs_inode(inode3
)->ui_mutex
, WB_MUTEX_3
);
935 * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
936 * @inode1: first inode
937 * @inode2: second inode
938 * @inode3: third inode
940 static void unlock_3_inodes(struct inode
*inode1
, struct inode
*inode2
,
941 struct inode
*inode3
)
944 mutex_unlock(&ubifs_inode(inode3
)->ui_mutex
);
945 if (inode1
!= inode2
)
946 mutex_unlock(&ubifs_inode(inode2
)->ui_mutex
);
947 mutex_unlock(&ubifs_inode(inode1
)->ui_mutex
);
950 static int ubifs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
951 struct inode
*new_dir
, struct dentry
*new_dentry
)
953 struct ubifs_info
*c
= old_dir
->i_sb
->s_fs_info
;
954 struct inode
*old_inode
= old_dentry
->d_inode
;
955 struct inode
*new_inode
= new_dentry
->d_inode
;
956 struct ubifs_inode
*old_inode_ui
= ubifs_inode(old_inode
);
957 int err
, release
, sync
= 0, move
= (new_dir
!= old_dir
);
958 int is_dir
= S_ISDIR(old_inode
->i_mode
);
959 int unlink
= !!new_inode
;
960 int new_sz
= CALC_DENT_SIZE(new_dentry
->d_name
.len
);
961 int old_sz
= CALC_DENT_SIZE(old_dentry
->d_name
.len
);
962 struct ubifs_budget_req req
= { .new_dent
= 1, .mod_dent
= 1,
964 struct ubifs_budget_req ino_req
= { .dirtied_ino
= 1,
965 .dirtied_ino_d
= ALIGN(old_inode_ui
->data_len
, 8) };
966 struct timespec time
;
967 unsigned int uninitialized_var(saved_nlink
);
970 * Budget request settings: deletion direntry, new direntry, removing
971 * the old inode, and changing old and new parent directory inodes.
973 * However, this operation also marks the target inode as dirty and
974 * does not write it, so we allocate budget for the target inode
978 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu",
979 old_dentry
, old_inode
->i_ino
, old_dir
->i_ino
,
980 new_dentry
, new_dir
->i_ino
);
981 ubifs_assert(mutex_is_locked(&old_dir
->i_mutex
));
982 ubifs_assert(mutex_is_locked(&new_dir
->i_mutex
));
984 ubifs_assert(mutex_is_locked(&new_inode
->i_mutex
));
987 if (unlink
&& is_dir
) {
988 err
= check_dir_empty(c
, new_inode
);
993 err
= ubifs_budget_space(c
, &req
);
996 err
= ubifs_budget_space(c
, &ino_req
);
998 ubifs_release_budget(c
, &req
);
1002 lock_3_inodes(old_dir
, new_dir
, new_inode
);
1005 * Like most other Unix systems, set the @i_ctime for inodes on a
1008 time
= ubifs_current_time(old_dir
);
1009 old_inode
->i_ctime
= time
;
1011 /* We must adjust parent link count when renaming directories */
1015 * @old_dir loses a link because we are moving
1016 * @old_inode to a different directory.
1018 drop_nlink(old_dir
);
1020 * @new_dir only gains a link if we are not also
1021 * overwriting an existing directory.
1027 * @old_inode is not moving to a different directory,
1028 * but @old_dir still loses a link if we are
1029 * overwriting an existing directory.
1032 drop_nlink(old_dir
);
1036 old_dir
->i_size
-= old_sz
;
1037 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1038 old_dir
->i_mtime
= old_dir
->i_ctime
= time
;
1039 new_dir
->i_mtime
= new_dir
->i_ctime
= time
;
1042 * And finally, if we unlinked a direntry which happened to have the
1043 * same name as the moved direntry, we have to decrement @i_nlink of
1044 * the unlinked inode and change its ctime.
1048 * Directories cannot have hard-links, so if this is a
1049 * directory, just clear @i_nlink.
1051 saved_nlink
= new_inode
->i_nlink
;
1053 clear_nlink(new_inode
);
1055 drop_nlink(new_inode
);
1056 new_inode
->i_ctime
= time
;
1058 new_dir
->i_size
+= new_sz
;
1059 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1063 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1064 * is dirty, because this will be done later on at the end of
1067 if (IS_SYNC(old_inode
)) {
1068 sync
= IS_DIRSYNC(old_dir
) || IS_DIRSYNC(new_dir
);
1069 if (unlink
&& IS_SYNC(new_inode
))
1072 err
= ubifs_jnl_rename(c
, old_dir
, old_dentry
, new_dir
, new_dentry
,
1077 unlock_3_inodes(old_dir
, new_dir
, new_inode
);
1078 ubifs_release_budget(c
, &req
);
1080 mutex_lock(&old_inode_ui
->ui_mutex
);
1081 release
= old_inode_ui
->dirty
;
1082 mark_inode_dirty_sync(old_inode
);
1083 mutex_unlock(&old_inode_ui
->ui_mutex
);
1086 ubifs_release_budget(c
, &ino_req
);
1087 if (IS_SYNC(old_inode
))
1088 err
= old_inode
->i_sb
->s_op
->write_inode(old_inode
, NULL
);
1093 set_nlink(new_inode
, saved_nlink
);
1095 new_dir
->i_size
-= new_sz
;
1096 ubifs_inode(new_dir
)->ui_size
= new_dir
->i_size
;
1098 old_dir
->i_size
+= old_sz
;
1099 ubifs_inode(old_dir
)->ui_size
= old_dir
->i_size
;
1104 drop_nlink(new_dir
);
1110 unlock_3_inodes(old_dir
, new_dir
, new_inode
);
1111 ubifs_release_budget(c
, &ino_req
);
1112 ubifs_release_budget(c
, &req
);
1116 int ubifs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
1120 struct inode
*inode
= dentry
->d_inode
;
1121 struct ubifs_inode
*ui
= ubifs_inode(inode
);
1123 mutex_lock(&ui
->ui_mutex
);
1124 generic_fillattr(inode
, stat
);
1125 stat
->blksize
= UBIFS_BLOCK_SIZE
;
1126 stat
->size
= ui
->ui_size
;
1129 * Unfortunately, the 'stat()' system call was designed for block
1130 * device based file systems, and it is not appropriate for UBIFS,
1131 * because UBIFS does not have notion of "block". For example, it is
1132 * difficult to tell how many block a directory takes - it actually
1133 * takes less than 300 bytes, but we have to round it to block size,
1134 * which introduces large mistake. This makes utilities like 'du' to
1135 * report completely senseless numbers. This is the reason why UBIFS
1136 * goes the same way as JFFS2 - it reports zero blocks for everything
1137 * but regular files, which makes more sense than reporting completely
1140 if (S_ISREG(inode
->i_mode
)) {
1141 size
= ui
->xattr_size
;
1143 size
= ALIGN(size
, UBIFS_BLOCK_SIZE
);
1145 * Note, user-space expects 512-byte blocks count irrespectively
1146 * of what was reported in @stat->size.
1148 stat
->blocks
= size
>> 9;
1151 mutex_unlock(&ui
->ui_mutex
);
1155 const struct inode_operations ubifs_dir_inode_operations
= {
1156 .lookup
= ubifs_lookup
,
1157 .create
= ubifs_create
,
1159 .symlink
= ubifs_symlink
,
1160 .unlink
= ubifs_unlink
,
1161 .mkdir
= ubifs_mkdir
,
1162 .rmdir
= ubifs_rmdir
,
1163 .mknod
= ubifs_mknod
,
1164 .rename
= ubifs_rename
,
1165 .setattr
= ubifs_setattr
,
1166 .getattr
= ubifs_getattr
,
1167 .setxattr
= ubifs_setxattr
,
1168 .getxattr
= ubifs_getxattr
,
1169 .listxattr
= ubifs_listxattr
,
1170 .removexattr
= ubifs_removexattr
,
1173 const struct file_operations ubifs_dir_operations
= {
1174 .llseek
= generic_file_llseek
,
1175 .release
= ubifs_dir_release
,
1176 .read
= generic_read_dir
,
1177 .iterate
= ubifs_readdir
,
1178 .fsync
= ubifs_fsync
,
1179 .unlocked_ioctl
= ubifs_ioctl
,
1180 #ifdef CONFIG_COMPAT
1181 .compat_ioctl
= ubifs_compat_ioctl
,