Loading...
1/* * This file is part of UBIFS.
2 *
3 * Copyright (C) 2006-2008 Nokia Corporation.
4 * Copyright (C) 2006, 2007 University of Szeged, Hungary
5 *
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.
9 *
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
13 * more details.
14 *
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
18 *
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
20 * Adrian Hunter
21 * Zoltan Sogor
22 */
23
24/*
25 * This file implements directory operations.
26 *
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.
33 *
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.
41 */
42
43#include "ubifs.h"
44
45/**
46 * inherit_flags - inherit flags of the parent inode.
47 * @dir: parent inode
48 * @mode: new inode mode flags
49 *
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.
56 *
57 * This function returns the inherited flags.
58 */
59static int inherit_flags(const struct inode *dir, umode_t mode)
60{
61 int flags;
62 const struct ubifs_inode *ui = ubifs_inode(dir);
63
64 if (!S_ISDIR(dir->i_mode))
65 /*
66 * The parent is not a directory, which means that an extended
67 * attribute inode is being created. No flags.
68 */
69 return 0;
70
71 flags = ui->flags & (UBIFS_COMPR_FL | UBIFS_SYNC_FL | UBIFS_DIRSYNC_FL);
72 if (!S_ISDIR(mode))
73 /* The "DIRSYNC" flag only applies to directories */
74 flags &= ~UBIFS_DIRSYNC_FL;
75 return flags;
76}
77
78/**
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
83 *
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
86 * case of failure.
87 */
88struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
89 umode_t mode)
90{
91 struct inode *inode;
92 struct ubifs_inode *ui;
93
94 inode = new_inode(c->vfs_sb);
95 ui = ubifs_inode(inode);
96 if (!inode)
97 return ERR_PTR(-ENOMEM);
98
99 /*
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.
104 */
105 inode->i_flags |= S_NOCMTIME;
106
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;
111 /* Disable readahead */
112 inode->i_mapping->backing_dev_info = &c->bdi;
113
114 switch (mode & S_IFMT) {
115 case S_IFREG:
116 inode->i_mapping->a_ops = &ubifs_file_address_operations;
117 inode->i_op = &ubifs_file_inode_operations;
118 inode->i_fop = &ubifs_file_operations;
119 break;
120 case S_IFDIR:
121 inode->i_op = &ubifs_dir_inode_operations;
122 inode->i_fop = &ubifs_dir_operations;
123 inode->i_size = ui->ui_size = UBIFS_INO_NODE_SZ;
124 break;
125 case S_IFLNK:
126 inode->i_op = &ubifs_symlink_inode_operations;
127 break;
128 case S_IFSOCK:
129 case S_IFIFO:
130 case S_IFBLK:
131 case S_IFCHR:
132 inode->i_op = &ubifs_file_inode_operations;
133 break;
134 default:
135 BUG();
136 }
137
138 ui->flags = inherit_flags(dir, mode);
139 ubifs_set_inode_flags(inode);
140 if (S_ISREG(mode))
141 ui->compr_type = c->default_compr;
142 else
143 ui->compr_type = UBIFS_COMPR_NONE;
144 ui->synced_i_size = 0;
145
146 spin_lock(&c->cnt_lock);
147 /* Inode number overflow is currently not supported */
148 if (c->highest_inum >= INUM_WARN_WATERMARK) {
149 if (c->highest_inum >= INUM_WATERMARK) {
150 spin_unlock(&c->cnt_lock);
151 ubifs_err("out of inode numbers");
152 make_bad_inode(inode);
153 iput(inode);
154 return ERR_PTR(-EINVAL);
155 }
156 ubifs_warn("running out of inode numbers (current %lu, max %d)",
157 (unsigned long)c->highest_inum, INUM_WATERMARK);
158 }
159
160 inode->i_ino = ++c->highest_inum;
161 /*
162 * The creation sequence number remains with this inode for its
163 * lifetime. All nodes for this inode have a greater sequence number,
164 * and so it is possible to distinguish obsolete nodes belonging to a
165 * previous incarnation of the same inode number - for example, for the
166 * purpose of rebuilding the index.
167 */
168 ui->creat_sqnum = ++c->max_sqnum;
169 spin_unlock(&c->cnt_lock);
170 return inode;
171}
172
173static int dbg_check_name(const struct ubifs_info *c,
174 const struct ubifs_dent_node *dent,
175 const struct qstr *nm)
176{
177 if (!dbg_is_chk_gen(c))
178 return 0;
179 if (le16_to_cpu(dent->nlen) != nm->len)
180 return -EINVAL;
181 if (memcmp(dent->name, nm->name, nm->len))
182 return -EINVAL;
183 return 0;
184}
185
186static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
187 unsigned int flags)
188{
189 int err;
190 union ubifs_key key;
191 struct inode *inode = NULL;
192 struct ubifs_dent_node *dent;
193 struct ubifs_info *c = dir->i_sb->s_fs_info;
194
195 dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
196
197 if (dentry->d_name.len > UBIFS_MAX_NLEN)
198 return ERR_PTR(-ENAMETOOLONG);
199
200 dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
201 if (!dent)
202 return ERR_PTR(-ENOMEM);
203
204 dent_key_init(c, &key, dir->i_ino, &dentry->d_name);
205
206 err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name);
207 if (err) {
208 if (err == -ENOENT) {
209 dbg_gen("not found");
210 goto done;
211 }
212 goto out;
213 }
214
215 if (dbg_check_name(c, dent, &dentry->d_name)) {
216 err = -EINVAL;
217 goto out;
218 }
219
220 inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
221 if (IS_ERR(inode)) {
222 /*
223 * This should not happen. Probably the file-system needs
224 * checking.
225 */
226 err = PTR_ERR(inode);
227 ubifs_err("dead directory entry '%pd', error %d",
228 dentry, err);
229 ubifs_ro_mode(c, err);
230 goto out;
231 }
232
233done:
234 kfree(dent);
235 /*
236 * Note, d_splice_alias() would be required instead if we supported
237 * NFS.
238 */
239 d_add(dentry, inode);
240 return NULL;
241
242out:
243 kfree(dent);
244 return ERR_PTR(err);
245}
246
247static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
248 bool excl)
249{
250 struct inode *inode;
251 struct ubifs_info *c = dir->i_sb->s_fs_info;
252 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
253 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
254 .dirtied_ino = 1 };
255 struct ubifs_inode *dir_ui = ubifs_inode(dir);
256
257 /*
258 * Budget request settings: new inode, new direntry, changing the
259 * parent directory inode.
260 */
261
262 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
263 dentry, mode, dir->i_ino);
264
265 err = ubifs_budget_space(c, &req);
266 if (err)
267 return err;
268
269 inode = ubifs_new_inode(c, dir, mode);
270 if (IS_ERR(inode)) {
271 err = PTR_ERR(inode);
272 goto out_budg;
273 }
274
275 mutex_lock(&dir_ui->ui_mutex);
276 dir->i_size += sz_change;
277 dir_ui->ui_size = dir->i_size;
278 dir->i_mtime = dir->i_ctime = inode->i_ctime;
279 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
280 if (err)
281 goto out_cancel;
282 mutex_unlock(&dir_ui->ui_mutex);
283
284 ubifs_release_budget(c, &req);
285 insert_inode_hash(inode);
286 d_instantiate(dentry, inode);
287 return 0;
288
289out_cancel:
290 dir->i_size -= sz_change;
291 dir_ui->ui_size = dir->i_size;
292 mutex_unlock(&dir_ui->ui_mutex);
293 make_bad_inode(inode);
294 iput(inode);
295out_budg:
296 ubifs_release_budget(c, &req);
297 ubifs_err("cannot create regular file, error %d", err);
298 return err;
299}
300
301/**
302 * vfs_dent_type - get VFS directory entry type.
303 * @type: UBIFS directory entry type
304 *
305 * This function converts UBIFS directory entry type into VFS directory entry
306 * type.
307 */
308static unsigned int vfs_dent_type(uint8_t type)
309{
310 switch (type) {
311 case UBIFS_ITYPE_REG:
312 return DT_REG;
313 case UBIFS_ITYPE_DIR:
314 return DT_DIR;
315 case UBIFS_ITYPE_LNK:
316 return DT_LNK;
317 case UBIFS_ITYPE_BLK:
318 return DT_BLK;
319 case UBIFS_ITYPE_CHR:
320 return DT_CHR;
321 case UBIFS_ITYPE_FIFO:
322 return DT_FIFO;
323 case UBIFS_ITYPE_SOCK:
324 return DT_SOCK;
325 default:
326 BUG();
327 }
328 return 0;
329}
330
331/*
332 * The classical Unix view for directory is that it is a linear array of
333 * (name, inode number) entries. Linux/VFS assumes this model as well.
334 * Particularly, 'readdir()' call wants us to return a directory entry offset
335 * which later may be used to continue 'readdir()'ing the directory or to
336 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
337 * model because directory entries are identified by keys, which may collide.
338 *
339 * UBIFS uses directory entry hash value for directory offsets, so
340 * 'seekdir()'/'telldir()' may not always work because of possible key
341 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
342 * properly by means of saving full directory entry name in the private field
343 * of the file description object.
344 *
345 * This means that UBIFS cannot support NFS which requires full
346 * 'seekdir()'/'telldir()' support.
347 */
348static int ubifs_readdir(struct file *file, struct dir_context *ctx)
349{
350 int err;
351 struct qstr nm;
352 union ubifs_key key;
353 struct ubifs_dent_node *dent;
354 struct inode *dir = file_inode(file);
355 struct ubifs_info *c = dir->i_sb->s_fs_info;
356
357 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
358
359 if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
360 /*
361 * The directory was seek'ed to a senseless position or there
362 * are no more entries.
363 */
364 return 0;
365
366 if (file->f_version == 0) {
367 /*
368 * The file was seek'ed, which means that @file->private_data
369 * is now invalid. This may also be just the first
370 * 'ubifs_readdir()' invocation, in which case
371 * @file->private_data is NULL, and the below code is
372 * basically a no-op.
373 */
374 kfree(file->private_data);
375 file->private_data = NULL;
376 }
377
378 /*
379 * 'generic_file_llseek()' unconditionally sets @file->f_version to
380 * zero, and we use this for detecting whether the file was seek'ed.
381 */
382 file->f_version = 1;
383
384 /* File positions 0 and 1 correspond to "." and ".." */
385 if (ctx->pos < 2) {
386 ubifs_assert(!file->private_data);
387 if (!dir_emit_dots(file, ctx))
388 return 0;
389
390 /* Find the first entry in TNC and save it */
391 lowest_dent_key(c, &key, dir->i_ino);
392 nm.name = NULL;
393 dent = ubifs_tnc_next_ent(c, &key, &nm);
394 if (IS_ERR(dent)) {
395 err = PTR_ERR(dent);
396 goto out;
397 }
398
399 ctx->pos = key_hash_flash(c, &dent->key);
400 file->private_data = dent;
401 }
402
403 dent = file->private_data;
404 if (!dent) {
405 /*
406 * The directory was seek'ed to and is now readdir'ed.
407 * Find the entry corresponding to @ctx->pos or the closest one.
408 */
409 dent_key_init_hash(c, &key, dir->i_ino, ctx->pos);
410 nm.name = NULL;
411 dent = ubifs_tnc_next_ent(c, &key, &nm);
412 if (IS_ERR(dent)) {
413 err = PTR_ERR(dent);
414 goto out;
415 }
416 ctx->pos = key_hash_flash(c, &dent->key);
417 file->private_data = dent;
418 }
419
420 while (1) {
421 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
422 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
423 key_hash_flash(c, &dent->key));
424 ubifs_assert(le64_to_cpu(dent->ch.sqnum) >
425 ubifs_inode(dir)->creat_sqnum);
426
427 nm.len = le16_to_cpu(dent->nlen);
428 if (!dir_emit(ctx, dent->name, nm.len,
429 le64_to_cpu(dent->inum),
430 vfs_dent_type(dent->type)))
431 return 0;
432
433 /* Switch to the next entry */
434 key_read(c, &dent->key, &key);
435 nm.name = dent->name;
436 dent = ubifs_tnc_next_ent(c, &key, &nm);
437 if (IS_ERR(dent)) {
438 err = PTR_ERR(dent);
439 goto out;
440 }
441
442 kfree(file->private_data);
443 ctx->pos = key_hash_flash(c, &dent->key);
444 file->private_data = dent;
445 cond_resched();
446 }
447
448out:
449 if (err != -ENOENT) {
450 ubifs_err("cannot find next direntry, error %d", err);
451 return err;
452 }
453
454 kfree(file->private_data);
455 file->private_data = NULL;
456 /* 2 is a special value indicating that there are no more direntries */
457 ctx->pos = 2;
458 return 0;
459}
460
461/* Free saved readdir() state when the directory is closed */
462static int ubifs_dir_release(struct inode *dir, struct file *file)
463{
464 kfree(file->private_data);
465 file->private_data = NULL;
466 return 0;
467}
468
469/**
470 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
471 * @inode1: first inode
472 * @inode2: second inode
473 *
474 * We do not implement any tricks to guarantee strict lock ordering, because
475 * VFS has already done it for us on the @i_mutex. So this is just a simple
476 * wrapper function.
477 */
478static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
479{
480 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
481 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
482}
483
484/**
485 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
486 * @inode1: first inode
487 * @inode2: second inode
488 */
489static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
490{
491 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
492 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
493}
494
495static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
496 struct dentry *dentry)
497{
498 struct ubifs_info *c = dir->i_sb->s_fs_info;
499 struct inode *inode = old_dentry->d_inode;
500 struct ubifs_inode *ui = ubifs_inode(inode);
501 struct ubifs_inode *dir_ui = ubifs_inode(dir);
502 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
503 struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
504 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
505
506 /*
507 * Budget request settings: new direntry, changing the target inode,
508 * changing the parent inode.
509 */
510
511 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
512 dentry, inode->i_ino,
513 inode->i_nlink, dir->i_ino);
514 ubifs_assert(mutex_is_locked(&dir->i_mutex));
515 ubifs_assert(mutex_is_locked(&inode->i_mutex));
516
517 err = dbg_check_synced_i_size(c, inode);
518 if (err)
519 return err;
520
521 err = ubifs_budget_space(c, &req);
522 if (err)
523 return err;
524
525 lock_2_inodes(dir, inode);
526 inc_nlink(inode);
527 ihold(inode);
528 inode->i_ctime = ubifs_current_time(inode);
529 dir->i_size += sz_change;
530 dir_ui->ui_size = dir->i_size;
531 dir->i_mtime = dir->i_ctime = inode->i_ctime;
532 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
533 if (err)
534 goto out_cancel;
535 unlock_2_inodes(dir, inode);
536
537 ubifs_release_budget(c, &req);
538 d_instantiate(dentry, inode);
539 return 0;
540
541out_cancel:
542 dir->i_size -= sz_change;
543 dir_ui->ui_size = dir->i_size;
544 drop_nlink(inode);
545 unlock_2_inodes(dir, inode);
546 ubifs_release_budget(c, &req);
547 iput(inode);
548 return err;
549}
550
551static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
552{
553 struct ubifs_info *c = dir->i_sb->s_fs_info;
554 struct inode *inode = dentry->d_inode;
555 struct ubifs_inode *dir_ui = ubifs_inode(dir);
556 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
557 int err, budgeted = 1;
558 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
559 unsigned int saved_nlink = inode->i_nlink;
560
561 /*
562 * Budget request settings: deletion direntry, deletion inode (+1 for
563 * @dirtied_ino), changing the parent directory inode. If budgeting
564 * fails, go ahead anyway because we have extra space reserved for
565 * deletions.
566 */
567
568 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
569 dentry, inode->i_ino,
570 inode->i_nlink, dir->i_ino);
571 ubifs_assert(mutex_is_locked(&dir->i_mutex));
572 ubifs_assert(mutex_is_locked(&inode->i_mutex));
573 err = dbg_check_synced_i_size(c, inode);
574 if (err)
575 return err;
576
577 err = ubifs_budget_space(c, &req);
578 if (err) {
579 if (err != -ENOSPC)
580 return err;
581 budgeted = 0;
582 }
583
584 lock_2_inodes(dir, inode);
585 inode->i_ctime = ubifs_current_time(dir);
586 drop_nlink(inode);
587 dir->i_size -= sz_change;
588 dir_ui->ui_size = dir->i_size;
589 dir->i_mtime = dir->i_ctime = inode->i_ctime;
590 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
591 if (err)
592 goto out_cancel;
593 unlock_2_inodes(dir, inode);
594
595 if (budgeted)
596 ubifs_release_budget(c, &req);
597 else {
598 /* We've deleted something - clean the "no space" flags */
599 c->bi.nospace = c->bi.nospace_rp = 0;
600 smp_wmb();
601 }
602 return 0;
603
604out_cancel:
605 dir->i_size += sz_change;
606 dir_ui->ui_size = dir->i_size;
607 set_nlink(inode, saved_nlink);
608 unlock_2_inodes(dir, inode);
609 if (budgeted)
610 ubifs_release_budget(c, &req);
611 return err;
612}
613
614/**
615 * check_dir_empty - check if a directory is empty or not.
616 * @c: UBIFS file-system description object
617 * @dir: VFS inode object of the directory to check
618 *
619 * This function checks if directory @dir is empty. Returns zero if the
620 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
621 * in case of of errors.
622 */
623static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
624{
625 struct qstr nm = { .name = NULL };
626 struct ubifs_dent_node *dent;
627 union ubifs_key key;
628 int err;
629
630 lowest_dent_key(c, &key, dir->i_ino);
631 dent = ubifs_tnc_next_ent(c, &key, &nm);
632 if (IS_ERR(dent)) {
633 err = PTR_ERR(dent);
634 if (err == -ENOENT)
635 err = 0;
636 } else {
637 kfree(dent);
638 err = -ENOTEMPTY;
639 }
640 return err;
641}
642
643static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
644{
645 struct ubifs_info *c = dir->i_sb->s_fs_info;
646 struct inode *inode = dentry->d_inode;
647 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
648 int err, budgeted = 1;
649 struct ubifs_inode *dir_ui = ubifs_inode(dir);
650 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
651
652 /*
653 * Budget request settings: deletion direntry, deletion inode and
654 * changing the parent inode. If budgeting fails, go ahead anyway
655 * because we have extra space reserved for deletions.
656 */
657
658 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
659 inode->i_ino, dir->i_ino);
660 ubifs_assert(mutex_is_locked(&dir->i_mutex));
661 ubifs_assert(mutex_is_locked(&inode->i_mutex));
662 err = check_dir_empty(c, dentry->d_inode);
663 if (err)
664 return err;
665
666 err = ubifs_budget_space(c, &req);
667 if (err) {
668 if (err != -ENOSPC)
669 return err;
670 budgeted = 0;
671 }
672
673 lock_2_inodes(dir, inode);
674 inode->i_ctime = ubifs_current_time(dir);
675 clear_nlink(inode);
676 drop_nlink(dir);
677 dir->i_size -= sz_change;
678 dir_ui->ui_size = dir->i_size;
679 dir->i_mtime = dir->i_ctime = inode->i_ctime;
680 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
681 if (err)
682 goto out_cancel;
683 unlock_2_inodes(dir, inode);
684
685 if (budgeted)
686 ubifs_release_budget(c, &req);
687 else {
688 /* We've deleted something - clean the "no space" flags */
689 c->bi.nospace = c->bi.nospace_rp = 0;
690 smp_wmb();
691 }
692 return 0;
693
694out_cancel:
695 dir->i_size += sz_change;
696 dir_ui->ui_size = dir->i_size;
697 inc_nlink(dir);
698 set_nlink(inode, 2);
699 unlock_2_inodes(dir, inode);
700 if (budgeted)
701 ubifs_release_budget(c, &req);
702 return err;
703}
704
705static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
706{
707 struct inode *inode;
708 struct ubifs_inode *dir_ui = ubifs_inode(dir);
709 struct ubifs_info *c = dir->i_sb->s_fs_info;
710 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
711 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
712
713 /*
714 * Budget request settings: new inode, new direntry and changing parent
715 * directory inode.
716 */
717
718 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
719 dentry, mode, dir->i_ino);
720
721 err = ubifs_budget_space(c, &req);
722 if (err)
723 return err;
724
725 inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
726 if (IS_ERR(inode)) {
727 err = PTR_ERR(inode);
728 goto out_budg;
729 }
730
731 mutex_lock(&dir_ui->ui_mutex);
732 insert_inode_hash(inode);
733 inc_nlink(inode);
734 inc_nlink(dir);
735 dir->i_size += sz_change;
736 dir_ui->ui_size = dir->i_size;
737 dir->i_mtime = dir->i_ctime = inode->i_ctime;
738 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
739 if (err) {
740 ubifs_err("cannot create directory, error %d", err);
741 goto out_cancel;
742 }
743 mutex_unlock(&dir_ui->ui_mutex);
744
745 ubifs_release_budget(c, &req);
746 d_instantiate(dentry, inode);
747 return 0;
748
749out_cancel:
750 dir->i_size -= sz_change;
751 dir_ui->ui_size = dir->i_size;
752 drop_nlink(dir);
753 mutex_unlock(&dir_ui->ui_mutex);
754 make_bad_inode(inode);
755 iput(inode);
756out_budg:
757 ubifs_release_budget(c, &req);
758 return err;
759}
760
761static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
762 umode_t mode, dev_t rdev)
763{
764 struct inode *inode;
765 struct ubifs_inode *ui;
766 struct ubifs_inode *dir_ui = ubifs_inode(dir);
767 struct ubifs_info *c = dir->i_sb->s_fs_info;
768 union ubifs_dev_desc *dev = NULL;
769 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
770 int err, devlen = 0;
771 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
772 .new_ino_d = ALIGN(devlen, 8),
773 .dirtied_ino = 1 };
774
775 /*
776 * Budget request settings: new inode, new direntry and changing parent
777 * directory inode.
778 */
779
780 dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
781
782 if (!new_valid_dev(rdev))
783 return -EINVAL;
784
785 if (S_ISBLK(mode) || S_ISCHR(mode)) {
786 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
787 if (!dev)
788 return -ENOMEM;
789 devlen = ubifs_encode_dev(dev, rdev);
790 }
791
792 err = ubifs_budget_space(c, &req);
793 if (err) {
794 kfree(dev);
795 return err;
796 }
797
798 inode = ubifs_new_inode(c, dir, mode);
799 if (IS_ERR(inode)) {
800 kfree(dev);
801 err = PTR_ERR(inode);
802 goto out_budg;
803 }
804
805 init_special_inode(inode, inode->i_mode, rdev);
806 inode->i_size = ubifs_inode(inode)->ui_size = devlen;
807 ui = ubifs_inode(inode);
808 ui->data = dev;
809 ui->data_len = devlen;
810
811 mutex_lock(&dir_ui->ui_mutex);
812 dir->i_size += sz_change;
813 dir_ui->ui_size = dir->i_size;
814 dir->i_mtime = dir->i_ctime = inode->i_ctime;
815 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
816 if (err)
817 goto out_cancel;
818 mutex_unlock(&dir_ui->ui_mutex);
819
820 ubifs_release_budget(c, &req);
821 insert_inode_hash(inode);
822 d_instantiate(dentry, inode);
823 return 0;
824
825out_cancel:
826 dir->i_size -= sz_change;
827 dir_ui->ui_size = dir->i_size;
828 mutex_unlock(&dir_ui->ui_mutex);
829 make_bad_inode(inode);
830 iput(inode);
831out_budg:
832 ubifs_release_budget(c, &req);
833 return err;
834}
835
836static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
837 const char *symname)
838{
839 struct inode *inode;
840 struct ubifs_inode *ui;
841 struct ubifs_inode *dir_ui = ubifs_inode(dir);
842 struct ubifs_info *c = dir->i_sb->s_fs_info;
843 int err, len = strlen(symname);
844 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
845 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
846 .new_ino_d = ALIGN(len, 8),
847 .dirtied_ino = 1 };
848
849 /*
850 * Budget request settings: new inode, new direntry and changing parent
851 * directory inode.
852 */
853
854 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
855 symname, dir->i_ino);
856
857 if (len > UBIFS_MAX_INO_DATA)
858 return -ENAMETOOLONG;
859
860 err = ubifs_budget_space(c, &req);
861 if (err)
862 return err;
863
864 inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO);
865 if (IS_ERR(inode)) {
866 err = PTR_ERR(inode);
867 goto out_budg;
868 }
869
870 ui = ubifs_inode(inode);
871 ui->data = kmalloc(len + 1, GFP_NOFS);
872 if (!ui->data) {
873 err = -ENOMEM;
874 goto out_inode;
875 }
876
877 memcpy(ui->data, symname, len);
878 ((char *)ui->data)[len] = '\0';
879 /*
880 * The terminating zero byte is not written to the flash media and it
881 * is put just to make later in-memory string processing simpler. Thus,
882 * data length is @len, not @len + %1.
883 */
884 ui->data_len = len;
885 inode->i_size = ubifs_inode(inode)->ui_size = len;
886
887 mutex_lock(&dir_ui->ui_mutex);
888 dir->i_size += sz_change;
889 dir_ui->ui_size = dir->i_size;
890 dir->i_mtime = dir->i_ctime = inode->i_ctime;
891 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
892 if (err)
893 goto out_cancel;
894 mutex_unlock(&dir_ui->ui_mutex);
895
896 ubifs_release_budget(c, &req);
897 insert_inode_hash(inode);
898 d_instantiate(dentry, inode);
899 return 0;
900
901out_cancel:
902 dir->i_size -= sz_change;
903 dir_ui->ui_size = dir->i_size;
904 mutex_unlock(&dir_ui->ui_mutex);
905out_inode:
906 make_bad_inode(inode);
907 iput(inode);
908out_budg:
909 ubifs_release_budget(c, &req);
910 return err;
911}
912
913/**
914 * lock_3_inodes - a wrapper for locking three UBIFS inodes.
915 * @inode1: first inode
916 * @inode2: second inode
917 * @inode3: third inode
918 *
919 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
920 * @inode2 whereas @inode3 may be %NULL.
921 *
922 * We do not implement any tricks to guarantee strict lock ordering, because
923 * VFS has already done it for us on the @i_mutex. So this is just a simple
924 * wrapper function.
925 */
926static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
927 struct inode *inode3)
928{
929 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
930 if (inode2 != inode1)
931 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
932 if (inode3)
933 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
934}
935
936/**
937 * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
938 * @inode1: first inode
939 * @inode2: second inode
940 * @inode3: third inode
941 */
942static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
943 struct inode *inode3)
944{
945 if (inode3)
946 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
947 if (inode1 != inode2)
948 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
949 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
950}
951
952static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
953 struct inode *new_dir, struct dentry *new_dentry)
954{
955 struct ubifs_info *c = old_dir->i_sb->s_fs_info;
956 struct inode *old_inode = old_dentry->d_inode;
957 struct inode *new_inode = new_dentry->d_inode;
958 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
959 int err, release, sync = 0, move = (new_dir != old_dir);
960 int is_dir = S_ISDIR(old_inode->i_mode);
961 int unlink = !!new_inode;
962 int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
963 int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
964 struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
965 .dirtied_ino = 3 };
966 struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
967 .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
968 struct timespec time;
969 unsigned int uninitialized_var(saved_nlink);
970
971 /*
972 * Budget request settings: deletion direntry, new direntry, removing
973 * the old inode, and changing old and new parent directory inodes.
974 *
975 * However, this operation also marks the target inode as dirty and
976 * does not write it, so we allocate budget for the target inode
977 * separately.
978 */
979
980 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu",
981 old_dentry, old_inode->i_ino, old_dir->i_ino,
982 new_dentry, new_dir->i_ino);
983 ubifs_assert(mutex_is_locked(&old_dir->i_mutex));
984 ubifs_assert(mutex_is_locked(&new_dir->i_mutex));
985 if (unlink)
986 ubifs_assert(mutex_is_locked(&new_inode->i_mutex));
987
988
989 if (unlink && is_dir) {
990 err = check_dir_empty(c, new_inode);
991 if (err)
992 return err;
993 }
994
995 err = ubifs_budget_space(c, &req);
996 if (err)
997 return err;
998 err = ubifs_budget_space(c, &ino_req);
999 if (err) {
1000 ubifs_release_budget(c, &req);
1001 return err;
1002 }
1003
1004 lock_3_inodes(old_dir, new_dir, new_inode);
1005
1006 /*
1007 * Like most other Unix systems, set the @i_ctime for inodes on a
1008 * rename.
1009 */
1010 time = ubifs_current_time(old_dir);
1011 old_inode->i_ctime = time;
1012
1013 /* We must adjust parent link count when renaming directories */
1014 if (is_dir) {
1015 if (move) {
1016 /*
1017 * @old_dir loses a link because we are moving
1018 * @old_inode to a different directory.
1019 */
1020 drop_nlink(old_dir);
1021 /*
1022 * @new_dir only gains a link if we are not also
1023 * overwriting an existing directory.
1024 */
1025 if (!unlink)
1026 inc_nlink(new_dir);
1027 } else {
1028 /*
1029 * @old_inode is not moving to a different directory,
1030 * but @old_dir still loses a link if we are
1031 * overwriting an existing directory.
1032 */
1033 if (unlink)
1034 drop_nlink(old_dir);
1035 }
1036 }
1037
1038 old_dir->i_size -= old_sz;
1039 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1040 old_dir->i_mtime = old_dir->i_ctime = time;
1041 new_dir->i_mtime = new_dir->i_ctime = time;
1042
1043 /*
1044 * And finally, if we unlinked a direntry which happened to have the
1045 * same name as the moved direntry, we have to decrement @i_nlink of
1046 * the unlinked inode and change its ctime.
1047 */
1048 if (unlink) {
1049 /*
1050 * Directories cannot have hard-links, so if this is a
1051 * directory, just clear @i_nlink.
1052 */
1053 saved_nlink = new_inode->i_nlink;
1054 if (is_dir)
1055 clear_nlink(new_inode);
1056 else
1057 drop_nlink(new_inode);
1058 new_inode->i_ctime = time;
1059 } else {
1060 new_dir->i_size += new_sz;
1061 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1062 }
1063
1064 /*
1065 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1066 * is dirty, because this will be done later on at the end of
1067 * 'ubifs_rename()'.
1068 */
1069 if (IS_SYNC(old_inode)) {
1070 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1071 if (unlink && IS_SYNC(new_inode))
1072 sync = 1;
1073 }
1074 err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1075 sync);
1076 if (err)
1077 goto out_cancel;
1078
1079 unlock_3_inodes(old_dir, new_dir, new_inode);
1080 ubifs_release_budget(c, &req);
1081
1082 mutex_lock(&old_inode_ui->ui_mutex);
1083 release = old_inode_ui->dirty;
1084 mark_inode_dirty_sync(old_inode);
1085 mutex_unlock(&old_inode_ui->ui_mutex);
1086
1087 if (release)
1088 ubifs_release_budget(c, &ino_req);
1089 if (IS_SYNC(old_inode))
1090 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1091 return err;
1092
1093out_cancel:
1094 if (unlink) {
1095 set_nlink(new_inode, saved_nlink);
1096 } else {
1097 new_dir->i_size -= new_sz;
1098 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1099 }
1100 old_dir->i_size += old_sz;
1101 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1102 if (is_dir) {
1103 if (move) {
1104 inc_nlink(old_dir);
1105 if (!unlink)
1106 drop_nlink(new_dir);
1107 } else {
1108 if (unlink)
1109 inc_nlink(old_dir);
1110 }
1111 }
1112 unlock_3_inodes(old_dir, new_dir, new_inode);
1113 ubifs_release_budget(c, &ino_req);
1114 ubifs_release_budget(c, &req);
1115 return err;
1116}
1117
1118int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1119 struct kstat *stat)
1120{
1121 loff_t size;
1122 struct inode *inode = dentry->d_inode;
1123 struct ubifs_inode *ui = ubifs_inode(inode);
1124
1125 mutex_lock(&ui->ui_mutex);
1126 generic_fillattr(inode, stat);
1127 stat->blksize = UBIFS_BLOCK_SIZE;
1128 stat->size = ui->ui_size;
1129
1130 /*
1131 * Unfortunately, the 'stat()' system call was designed for block
1132 * device based file systems, and it is not appropriate for UBIFS,
1133 * because UBIFS does not have notion of "block". For example, it is
1134 * difficult to tell how many block a directory takes - it actually
1135 * takes less than 300 bytes, but we have to round it to block size,
1136 * which introduces large mistake. This makes utilities like 'du' to
1137 * report completely senseless numbers. This is the reason why UBIFS
1138 * goes the same way as JFFS2 - it reports zero blocks for everything
1139 * but regular files, which makes more sense than reporting completely
1140 * wrong sizes.
1141 */
1142 if (S_ISREG(inode->i_mode)) {
1143 size = ui->xattr_size;
1144 size += stat->size;
1145 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1146 /*
1147 * Note, user-space expects 512-byte blocks count irrespectively
1148 * of what was reported in @stat->size.
1149 */
1150 stat->blocks = size >> 9;
1151 } else
1152 stat->blocks = 0;
1153 mutex_unlock(&ui->ui_mutex);
1154 return 0;
1155}
1156
1157const struct inode_operations ubifs_dir_inode_operations = {
1158 .lookup = ubifs_lookup,
1159 .create = ubifs_create,
1160 .link = ubifs_link,
1161 .symlink = ubifs_symlink,
1162 .unlink = ubifs_unlink,
1163 .mkdir = ubifs_mkdir,
1164 .rmdir = ubifs_rmdir,
1165 .mknod = ubifs_mknod,
1166 .rename = ubifs_rename,
1167 .setattr = ubifs_setattr,
1168 .getattr = ubifs_getattr,
1169 .setxattr = ubifs_setxattr,
1170 .getxattr = ubifs_getxattr,
1171 .listxattr = ubifs_listxattr,
1172 .removexattr = ubifs_removexattr,
1173};
1174
1175const struct file_operations ubifs_dir_operations = {
1176 .llseek = generic_file_llseek,
1177 .release = ubifs_dir_release,
1178 .read = generic_read_dir,
1179 .iterate = ubifs_readdir,
1180 .fsync = ubifs_fsync,
1181 .unlocked_ioctl = ubifs_ioctl,
1182#ifdef CONFIG_COMPAT
1183 .compat_ioctl = ubifs_compat_ioctl,
1184#endif
1185};
1/* * This file is part of UBIFS.
2 *
3 * Copyright (C) 2006-2008 Nokia Corporation.
4 * Copyright (C) 2006, 2007 University of Szeged, Hungary
5 *
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.
9 *
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
13 * more details.
14 *
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
18 *
19 * Authors: Artem Bityutskiy (Битюцкий Артём)
20 * Adrian Hunter
21 * Zoltan Sogor
22 */
23
24/*
25 * This file implements directory operations.
26 *
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.
33 *
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.
41 */
42
43#include "ubifs.h"
44
45/**
46 * inherit_flags - inherit flags of the parent inode.
47 * @dir: parent inode
48 * @mode: new inode mode flags
49 *
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.
56 *
57 * This function returns the inherited flags.
58 */
59static int inherit_flags(const struct inode *dir, umode_t mode)
60{
61 int flags;
62 const struct ubifs_inode *ui = ubifs_inode(dir);
63
64 if (!S_ISDIR(dir->i_mode))
65 /*
66 * The parent is not a directory, which means that an extended
67 * attribute inode is being created. No flags.
68 */
69 return 0;
70
71 flags = ui->flags & (UBIFS_COMPR_FL | UBIFS_SYNC_FL | UBIFS_DIRSYNC_FL);
72 if (!S_ISDIR(mode))
73 /* The "DIRSYNC" flag only applies to directories */
74 flags &= ~UBIFS_DIRSYNC_FL;
75 return flags;
76}
77
78/**
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
83 *
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
86 * case of failure.
87 */
88struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
89 umode_t mode)
90{
91 struct inode *inode;
92 struct ubifs_inode *ui;
93
94 inode = new_inode(c->vfs_sb);
95 ui = ubifs_inode(inode);
96 if (!inode)
97 return ERR_PTR(-ENOMEM);
98
99 /*
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.
104 */
105 inode->i_flags |= S_NOCMTIME;
106
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;
111
112 switch (mode & S_IFMT) {
113 case S_IFREG:
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;
117 break;
118 case S_IFDIR:
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;
122 break;
123 case S_IFLNK:
124 inode->i_op = &ubifs_symlink_inode_operations;
125 break;
126 case S_IFSOCK:
127 case S_IFIFO:
128 case S_IFBLK:
129 case S_IFCHR:
130 inode->i_op = &ubifs_file_inode_operations;
131 break;
132 default:
133 BUG();
134 }
135
136 ui->flags = inherit_flags(dir, mode);
137 ubifs_set_inode_flags(inode);
138 if (S_ISREG(mode))
139 ui->compr_type = c->default_compr;
140 else
141 ui->compr_type = UBIFS_COMPR_NONE;
142 ui->synced_i_size = 0;
143
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);
151 iput(inode);
152 return ERR_PTR(-EINVAL);
153 }
154 ubifs_warn(c, "running out of inode numbers (current %lu, max %u)",
155 (unsigned long)c->highest_inum, INUM_WATERMARK);
156 }
157
158 inode->i_ino = ++c->highest_inum;
159 /*
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.
165 */
166 ui->creat_sqnum = ++c->max_sqnum;
167 spin_unlock(&c->cnt_lock);
168 return inode;
169}
170
171static int dbg_check_name(const struct ubifs_info *c,
172 const struct ubifs_dent_node *dent,
173 const struct qstr *nm)
174{
175 if (!dbg_is_chk_gen(c))
176 return 0;
177 if (le16_to_cpu(dent->nlen) != nm->len)
178 return -EINVAL;
179 if (memcmp(dent->name, nm->name, nm->len))
180 return -EINVAL;
181 return 0;
182}
183
184static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
185 unsigned int flags)
186{
187 int err;
188 union ubifs_key key;
189 struct inode *inode = NULL;
190 struct ubifs_dent_node *dent;
191 struct ubifs_info *c = dir->i_sb->s_fs_info;
192
193 dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
194
195 if (dentry->d_name.len > UBIFS_MAX_NLEN)
196 return ERR_PTR(-ENAMETOOLONG);
197
198 dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
199 if (!dent)
200 return ERR_PTR(-ENOMEM);
201
202 dent_key_init(c, &key, dir->i_ino, &dentry->d_name);
203
204 err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name);
205 if (err) {
206 if (err == -ENOENT) {
207 dbg_gen("not found");
208 goto done;
209 }
210 goto out;
211 }
212
213 if (dbg_check_name(c, dent, &dentry->d_name)) {
214 err = -EINVAL;
215 goto out;
216 }
217
218 inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
219 if (IS_ERR(inode)) {
220 /*
221 * This should not happen. Probably the file-system needs
222 * checking.
223 */
224 err = PTR_ERR(inode);
225 ubifs_err(c, "dead directory entry '%pd', error %d",
226 dentry, err);
227 ubifs_ro_mode(c, err);
228 goto out;
229 }
230
231done:
232 kfree(dent);
233 /*
234 * Note, d_splice_alias() would be required instead if we supported
235 * NFS.
236 */
237 d_add(dentry, inode);
238 return NULL;
239
240out:
241 kfree(dent);
242 return ERR_PTR(err);
243}
244
245static int ubifs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
246 bool excl)
247{
248 struct inode *inode;
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,
252 .dirtied_ino = 1 };
253 struct ubifs_inode *dir_ui = ubifs_inode(dir);
254
255 /*
256 * Budget request settings: new inode, new direntry, changing the
257 * parent directory inode.
258 */
259
260 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
261 dentry, mode, dir->i_ino);
262
263 err = ubifs_budget_space(c, &req);
264 if (err)
265 return err;
266
267 inode = ubifs_new_inode(c, dir, mode);
268 if (IS_ERR(inode)) {
269 err = PTR_ERR(inode);
270 goto out_budg;
271 }
272
273 err = ubifs_init_security(dir, inode, &dentry->d_name);
274 if (err)
275 goto out_inode;
276
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);
282 if (err)
283 goto out_cancel;
284 mutex_unlock(&dir_ui->ui_mutex);
285
286 ubifs_release_budget(c, &req);
287 insert_inode_hash(inode);
288 d_instantiate(dentry, inode);
289 return 0;
290
291out_cancel:
292 dir->i_size -= sz_change;
293 dir_ui->ui_size = dir->i_size;
294 mutex_unlock(&dir_ui->ui_mutex);
295out_inode:
296 make_bad_inode(inode);
297 iput(inode);
298out_budg:
299 ubifs_release_budget(c, &req);
300 ubifs_err(c, "cannot create regular file, error %d", err);
301 return err;
302}
303
304/**
305 * vfs_dent_type - get VFS directory entry type.
306 * @type: UBIFS directory entry type
307 *
308 * This function converts UBIFS directory entry type into VFS directory entry
309 * type.
310 */
311static unsigned int vfs_dent_type(uint8_t type)
312{
313 switch (type) {
314 case UBIFS_ITYPE_REG:
315 return DT_REG;
316 case UBIFS_ITYPE_DIR:
317 return DT_DIR;
318 case UBIFS_ITYPE_LNK:
319 return DT_LNK;
320 case UBIFS_ITYPE_BLK:
321 return DT_BLK;
322 case UBIFS_ITYPE_CHR:
323 return DT_CHR;
324 case UBIFS_ITYPE_FIFO:
325 return DT_FIFO;
326 case UBIFS_ITYPE_SOCK:
327 return DT_SOCK;
328 default:
329 BUG();
330 }
331 return 0;
332}
333
334/*
335 * The classical Unix view for directory is that it is a linear array of
336 * (name, inode number) entries. Linux/VFS assumes this model as well.
337 * Particularly, 'readdir()' call wants us to return a directory entry offset
338 * which later may be used to continue 'readdir()'ing the directory or to
339 * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
340 * model because directory entries are identified by keys, which may collide.
341 *
342 * UBIFS uses directory entry hash value for directory offsets, so
343 * 'seekdir()'/'telldir()' may not always work because of possible key
344 * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
345 * properly by means of saving full directory entry name in the private field
346 * of the file description object.
347 *
348 * This means that UBIFS cannot support NFS which requires full
349 * 'seekdir()'/'telldir()' support.
350 */
351static int ubifs_readdir(struct file *file, struct dir_context *ctx)
352{
353 int err;
354 struct qstr nm;
355 union ubifs_key key;
356 struct ubifs_dent_node *dent;
357 struct inode *dir = file_inode(file);
358 struct ubifs_info *c = dir->i_sb->s_fs_info;
359
360 dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
361
362 if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
363 /*
364 * The directory was seek'ed to a senseless position or there
365 * are no more entries.
366 */
367 return 0;
368
369 if (file->f_version == 0) {
370 /*
371 * The file was seek'ed, which means that @file->private_data
372 * is now invalid. This may also be just the first
373 * 'ubifs_readdir()' invocation, in which case
374 * @file->private_data is NULL, and the below code is
375 * basically a no-op.
376 */
377 kfree(file->private_data);
378 file->private_data = NULL;
379 }
380
381 /*
382 * 'generic_file_llseek()' unconditionally sets @file->f_version to
383 * zero, and we use this for detecting whether the file was seek'ed.
384 */
385 file->f_version = 1;
386
387 /* File positions 0 and 1 correspond to "." and ".." */
388 if (ctx->pos < 2) {
389 ubifs_assert(!file->private_data);
390 if (!dir_emit_dots(file, ctx))
391 return 0;
392
393 /* Find the first entry in TNC and save it */
394 lowest_dent_key(c, &key, dir->i_ino);
395 nm.name = NULL;
396 dent = ubifs_tnc_next_ent(c, &key, &nm);
397 if (IS_ERR(dent)) {
398 err = PTR_ERR(dent);
399 goto out;
400 }
401
402 ctx->pos = key_hash_flash(c, &dent->key);
403 file->private_data = dent;
404 }
405
406 dent = file->private_data;
407 if (!dent) {
408 /*
409 * The directory was seek'ed to and is now readdir'ed.
410 * Find the entry corresponding to @ctx->pos or the closest one.
411 */
412 dent_key_init_hash(c, &key, dir->i_ino, ctx->pos);
413 nm.name = NULL;
414 dent = ubifs_tnc_next_ent(c, &key, &nm);
415 if (IS_ERR(dent)) {
416 err = PTR_ERR(dent);
417 goto out;
418 }
419 ctx->pos = key_hash_flash(c, &dent->key);
420 file->private_data = dent;
421 }
422
423 while (1) {
424 dbg_gen("feed '%s', ino %llu, new f_pos %#x",
425 dent->name, (unsigned long long)le64_to_cpu(dent->inum),
426 key_hash_flash(c, &dent->key));
427 ubifs_assert(le64_to_cpu(dent->ch.sqnum) >
428 ubifs_inode(dir)->creat_sqnum);
429
430 nm.len = le16_to_cpu(dent->nlen);
431 if (!dir_emit(ctx, dent->name, nm.len,
432 le64_to_cpu(dent->inum),
433 vfs_dent_type(dent->type)))
434 return 0;
435
436 /* Switch to the next entry */
437 key_read(c, &dent->key, &key);
438 nm.name = dent->name;
439 dent = ubifs_tnc_next_ent(c, &key, &nm);
440 if (IS_ERR(dent)) {
441 err = PTR_ERR(dent);
442 goto out;
443 }
444
445 kfree(file->private_data);
446 ctx->pos = key_hash_flash(c, &dent->key);
447 file->private_data = dent;
448 cond_resched();
449 }
450
451out:
452 kfree(file->private_data);
453 file->private_data = NULL;
454
455 if (err != -ENOENT) {
456 ubifs_err(c, "cannot find next direntry, error %d", err);
457 return err;
458 }
459
460 /* 2 is a special value indicating that there are no more direntries */
461 ctx->pos = 2;
462 return 0;
463}
464
465/* Free saved readdir() state when the directory is closed */
466static int ubifs_dir_release(struct inode *dir, struct file *file)
467{
468 kfree(file->private_data);
469 file->private_data = NULL;
470 return 0;
471}
472
473/**
474 * lock_2_inodes - a wrapper for locking two UBIFS inodes.
475 * @inode1: first inode
476 * @inode2: second inode
477 *
478 * We do not implement any tricks to guarantee strict lock ordering, because
479 * VFS has already done it for us on the @i_mutex. So this is just a simple
480 * wrapper function.
481 */
482static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
483{
484 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
485 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
486}
487
488/**
489 * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
490 * @inode1: first inode
491 * @inode2: second inode
492 */
493static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
494{
495 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
496 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
497}
498
499static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
500 struct dentry *dentry)
501{
502 struct ubifs_info *c = dir->i_sb->s_fs_info;
503 struct inode *inode = d_inode(old_dentry);
504 struct ubifs_inode *ui = ubifs_inode(inode);
505 struct ubifs_inode *dir_ui = ubifs_inode(dir);
506 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
507 struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
508 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
509
510 /*
511 * Budget request settings: new direntry, changing the target inode,
512 * changing the parent inode.
513 */
514
515 dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
516 dentry, inode->i_ino,
517 inode->i_nlink, dir->i_ino);
518 ubifs_assert(inode_is_locked(dir));
519 ubifs_assert(inode_is_locked(inode));
520
521 err = dbg_check_synced_i_size(c, inode);
522 if (err)
523 return err;
524
525 err = ubifs_budget_space(c, &req);
526 if (err)
527 return err;
528
529 lock_2_inodes(dir, inode);
530 inc_nlink(inode);
531 ihold(inode);
532 inode->i_ctime = ubifs_current_time(inode);
533 dir->i_size += sz_change;
534 dir_ui->ui_size = dir->i_size;
535 dir->i_mtime = dir->i_ctime = inode->i_ctime;
536 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
537 if (err)
538 goto out_cancel;
539 unlock_2_inodes(dir, inode);
540
541 ubifs_release_budget(c, &req);
542 d_instantiate(dentry, inode);
543 return 0;
544
545out_cancel:
546 dir->i_size -= sz_change;
547 dir_ui->ui_size = dir->i_size;
548 drop_nlink(inode);
549 unlock_2_inodes(dir, inode);
550 ubifs_release_budget(c, &req);
551 iput(inode);
552 return err;
553}
554
555static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
556{
557 struct ubifs_info *c = dir->i_sb->s_fs_info;
558 struct inode *inode = d_inode(dentry);
559 struct ubifs_inode *dir_ui = ubifs_inode(dir);
560 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
561 int err, budgeted = 1;
562 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
563 unsigned int saved_nlink = inode->i_nlink;
564
565 /*
566 * Budget request settings: deletion direntry, deletion inode (+1 for
567 * @dirtied_ino), changing the parent directory inode. If budgeting
568 * fails, go ahead anyway because we have extra space reserved for
569 * deletions.
570 */
571
572 dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
573 dentry, inode->i_ino,
574 inode->i_nlink, dir->i_ino);
575 ubifs_assert(inode_is_locked(dir));
576 ubifs_assert(inode_is_locked(inode));
577 err = dbg_check_synced_i_size(c, inode);
578 if (err)
579 return err;
580
581 err = ubifs_budget_space(c, &req);
582 if (err) {
583 if (err != -ENOSPC)
584 return err;
585 budgeted = 0;
586 }
587
588 lock_2_inodes(dir, inode);
589 inode->i_ctime = ubifs_current_time(dir);
590 drop_nlink(inode);
591 dir->i_size -= sz_change;
592 dir_ui->ui_size = dir->i_size;
593 dir->i_mtime = dir->i_ctime = inode->i_ctime;
594 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
595 if (err)
596 goto out_cancel;
597 unlock_2_inodes(dir, inode);
598
599 if (budgeted)
600 ubifs_release_budget(c, &req);
601 else {
602 /* We've deleted something - clean the "no space" flags */
603 c->bi.nospace = c->bi.nospace_rp = 0;
604 smp_wmb();
605 }
606 return 0;
607
608out_cancel:
609 dir->i_size += sz_change;
610 dir_ui->ui_size = dir->i_size;
611 set_nlink(inode, saved_nlink);
612 unlock_2_inodes(dir, inode);
613 if (budgeted)
614 ubifs_release_budget(c, &req);
615 return err;
616}
617
618/**
619 * check_dir_empty - check if a directory is empty or not.
620 * @c: UBIFS file-system description object
621 * @dir: VFS inode object of the directory to check
622 *
623 * This function checks if directory @dir is empty. Returns zero if the
624 * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
625 * in case of of errors.
626 */
627static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
628{
629 struct qstr nm = { .name = NULL };
630 struct ubifs_dent_node *dent;
631 union ubifs_key key;
632 int err;
633
634 lowest_dent_key(c, &key, dir->i_ino);
635 dent = ubifs_tnc_next_ent(c, &key, &nm);
636 if (IS_ERR(dent)) {
637 err = PTR_ERR(dent);
638 if (err == -ENOENT)
639 err = 0;
640 } else {
641 kfree(dent);
642 err = -ENOTEMPTY;
643 }
644 return err;
645}
646
647static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
648{
649 struct ubifs_info *c = dir->i_sb->s_fs_info;
650 struct inode *inode = d_inode(dentry);
651 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
652 int err, budgeted = 1;
653 struct ubifs_inode *dir_ui = ubifs_inode(dir);
654 struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
655
656 /*
657 * Budget request settings: deletion direntry, deletion inode and
658 * changing the parent inode. If budgeting fails, go ahead anyway
659 * because we have extra space reserved for deletions.
660 */
661
662 dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
663 inode->i_ino, dir->i_ino);
664 ubifs_assert(inode_is_locked(dir));
665 ubifs_assert(inode_is_locked(inode));
666 err = check_dir_empty(c, d_inode(dentry));
667 if (err)
668 return err;
669
670 err = ubifs_budget_space(c, &req);
671 if (err) {
672 if (err != -ENOSPC)
673 return err;
674 budgeted = 0;
675 }
676
677 lock_2_inodes(dir, inode);
678 inode->i_ctime = ubifs_current_time(dir);
679 clear_nlink(inode);
680 drop_nlink(dir);
681 dir->i_size -= sz_change;
682 dir_ui->ui_size = dir->i_size;
683 dir->i_mtime = dir->i_ctime = inode->i_ctime;
684 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
685 if (err)
686 goto out_cancel;
687 unlock_2_inodes(dir, inode);
688
689 if (budgeted)
690 ubifs_release_budget(c, &req);
691 else {
692 /* We've deleted something - clean the "no space" flags */
693 c->bi.nospace = c->bi.nospace_rp = 0;
694 smp_wmb();
695 }
696 return 0;
697
698out_cancel:
699 dir->i_size += sz_change;
700 dir_ui->ui_size = dir->i_size;
701 inc_nlink(dir);
702 set_nlink(inode, 2);
703 unlock_2_inodes(dir, inode);
704 if (budgeted)
705 ubifs_release_budget(c, &req);
706 return err;
707}
708
709static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
710{
711 struct inode *inode;
712 struct ubifs_inode *dir_ui = ubifs_inode(dir);
713 struct ubifs_info *c = dir->i_sb->s_fs_info;
714 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
715 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
716
717 /*
718 * Budget request settings: new inode, new direntry and changing parent
719 * directory inode.
720 */
721
722 dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
723 dentry, mode, dir->i_ino);
724
725 err = ubifs_budget_space(c, &req);
726 if (err)
727 return err;
728
729 inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
730 if (IS_ERR(inode)) {
731 err = PTR_ERR(inode);
732 goto out_budg;
733 }
734
735 err = ubifs_init_security(dir, inode, &dentry->d_name);
736 if (err)
737 goto out_inode;
738
739 mutex_lock(&dir_ui->ui_mutex);
740 insert_inode_hash(inode);
741 inc_nlink(inode);
742 inc_nlink(dir);
743 dir->i_size += sz_change;
744 dir_ui->ui_size = dir->i_size;
745 dir->i_mtime = dir->i_ctime = inode->i_ctime;
746 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
747 if (err) {
748 ubifs_err(c, "cannot create directory, error %d", err);
749 goto out_cancel;
750 }
751 mutex_unlock(&dir_ui->ui_mutex);
752
753 ubifs_release_budget(c, &req);
754 d_instantiate(dentry, inode);
755 return 0;
756
757out_cancel:
758 dir->i_size -= sz_change;
759 dir_ui->ui_size = dir->i_size;
760 drop_nlink(dir);
761 mutex_unlock(&dir_ui->ui_mutex);
762out_inode:
763 make_bad_inode(inode);
764 iput(inode);
765out_budg:
766 ubifs_release_budget(c, &req);
767 return err;
768}
769
770static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
771 umode_t mode, dev_t rdev)
772{
773 struct inode *inode;
774 struct ubifs_inode *ui;
775 struct ubifs_inode *dir_ui = ubifs_inode(dir);
776 struct ubifs_info *c = dir->i_sb->s_fs_info;
777 union ubifs_dev_desc *dev = NULL;
778 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
779 int err, devlen = 0;
780 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
781 .new_ino_d = ALIGN(devlen, 8),
782 .dirtied_ino = 1 };
783
784 /*
785 * Budget request settings: new inode, new direntry and changing parent
786 * directory inode.
787 */
788
789 dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
790
791 if (S_ISBLK(mode) || S_ISCHR(mode)) {
792 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
793 if (!dev)
794 return -ENOMEM;
795 devlen = ubifs_encode_dev(dev, rdev);
796 }
797
798 err = ubifs_budget_space(c, &req);
799 if (err) {
800 kfree(dev);
801 return err;
802 }
803
804 inode = ubifs_new_inode(c, dir, mode);
805 if (IS_ERR(inode)) {
806 kfree(dev);
807 err = PTR_ERR(inode);
808 goto out_budg;
809 }
810
811 init_special_inode(inode, inode->i_mode, rdev);
812 inode->i_size = ubifs_inode(inode)->ui_size = devlen;
813 ui = ubifs_inode(inode);
814 ui->data = dev;
815 ui->data_len = devlen;
816
817 err = ubifs_init_security(dir, inode, &dentry->d_name);
818 if (err)
819 goto out_inode;
820
821 mutex_lock(&dir_ui->ui_mutex);
822 dir->i_size += sz_change;
823 dir_ui->ui_size = dir->i_size;
824 dir->i_mtime = dir->i_ctime = inode->i_ctime;
825 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
826 if (err)
827 goto out_cancel;
828 mutex_unlock(&dir_ui->ui_mutex);
829
830 ubifs_release_budget(c, &req);
831 insert_inode_hash(inode);
832 d_instantiate(dentry, inode);
833 return 0;
834
835out_cancel:
836 dir->i_size -= sz_change;
837 dir_ui->ui_size = dir->i_size;
838 mutex_unlock(&dir_ui->ui_mutex);
839out_inode:
840 make_bad_inode(inode);
841 iput(inode);
842out_budg:
843 ubifs_release_budget(c, &req);
844 return err;
845}
846
847static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
848 const char *symname)
849{
850 struct inode *inode;
851 struct ubifs_inode *ui;
852 struct ubifs_inode *dir_ui = ubifs_inode(dir);
853 struct ubifs_info *c = dir->i_sb->s_fs_info;
854 int err, len = strlen(symname);
855 int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
856 struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
857 .new_ino_d = ALIGN(len, 8),
858 .dirtied_ino = 1 };
859
860 /*
861 * Budget request settings: new inode, new direntry and changing parent
862 * directory inode.
863 */
864
865 dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
866 symname, dir->i_ino);
867
868 if (len > UBIFS_MAX_INO_DATA)
869 return -ENAMETOOLONG;
870
871 err = ubifs_budget_space(c, &req);
872 if (err)
873 return err;
874
875 inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO);
876 if (IS_ERR(inode)) {
877 err = PTR_ERR(inode);
878 goto out_budg;
879 }
880
881 ui = ubifs_inode(inode);
882 ui->data = kmalloc(len + 1, GFP_NOFS);
883 if (!ui->data) {
884 err = -ENOMEM;
885 goto out_inode;
886 }
887
888 memcpy(ui->data, symname, len);
889 ((char *)ui->data)[len] = '\0';
890 inode->i_link = ui->data;
891 /*
892 * The terminating zero byte is not written to the flash media and it
893 * is put just to make later in-memory string processing simpler. Thus,
894 * data length is @len, not @len + %1.
895 */
896 ui->data_len = len;
897 inode->i_size = ubifs_inode(inode)->ui_size = len;
898
899 err = ubifs_init_security(dir, inode, &dentry->d_name);
900 if (err)
901 goto out_inode;
902
903 mutex_lock(&dir_ui->ui_mutex);
904 dir->i_size += sz_change;
905 dir_ui->ui_size = dir->i_size;
906 dir->i_mtime = dir->i_ctime = inode->i_ctime;
907 err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
908 if (err)
909 goto out_cancel;
910 mutex_unlock(&dir_ui->ui_mutex);
911
912 ubifs_release_budget(c, &req);
913 insert_inode_hash(inode);
914 d_instantiate(dentry, inode);
915 return 0;
916
917out_cancel:
918 dir->i_size -= sz_change;
919 dir_ui->ui_size = dir->i_size;
920 mutex_unlock(&dir_ui->ui_mutex);
921out_inode:
922 make_bad_inode(inode);
923 iput(inode);
924out_budg:
925 ubifs_release_budget(c, &req);
926 return err;
927}
928
929/**
930 * lock_3_inodes - a wrapper for locking three UBIFS inodes.
931 * @inode1: first inode
932 * @inode2: second inode
933 * @inode3: third inode
934 *
935 * This function is used for 'ubifs_rename()' and @inode1 may be the same as
936 * @inode2 whereas @inode3 may be %NULL.
937 *
938 * We do not implement any tricks to guarantee strict lock ordering, because
939 * VFS has already done it for us on the @i_mutex. So this is just a simple
940 * wrapper function.
941 */
942static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
943 struct inode *inode3)
944{
945 mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
946 if (inode2 != inode1)
947 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
948 if (inode3)
949 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
950}
951
952/**
953 * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
954 * @inode1: first inode
955 * @inode2: second inode
956 * @inode3: third inode
957 */
958static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
959 struct inode *inode3)
960{
961 if (inode3)
962 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
963 if (inode1 != inode2)
964 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
965 mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
966}
967
968static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
969 struct inode *new_dir, struct dentry *new_dentry)
970{
971 struct ubifs_info *c = old_dir->i_sb->s_fs_info;
972 struct inode *old_inode = d_inode(old_dentry);
973 struct inode *new_inode = d_inode(new_dentry);
974 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
975 int err, release, sync = 0, move = (new_dir != old_dir);
976 int is_dir = S_ISDIR(old_inode->i_mode);
977 int unlink = !!new_inode;
978 int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
979 int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
980 struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
981 .dirtied_ino = 3 };
982 struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
983 .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
984 struct timespec time;
985 unsigned int uninitialized_var(saved_nlink);
986
987 /*
988 * Budget request settings: deletion direntry, new direntry, removing
989 * the old inode, and changing old and new parent directory inodes.
990 *
991 * However, this operation also marks the target inode as dirty and
992 * does not write it, so we allocate budget for the target inode
993 * separately.
994 */
995
996 dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu",
997 old_dentry, old_inode->i_ino, old_dir->i_ino,
998 new_dentry, new_dir->i_ino);
999 ubifs_assert(inode_is_locked(old_dir));
1000 ubifs_assert(inode_is_locked(new_dir));
1001 if (unlink)
1002 ubifs_assert(inode_is_locked(new_inode));
1003
1004
1005 if (unlink && is_dir) {
1006 err = check_dir_empty(c, new_inode);
1007 if (err)
1008 return err;
1009 }
1010
1011 err = ubifs_budget_space(c, &req);
1012 if (err)
1013 return err;
1014 err = ubifs_budget_space(c, &ino_req);
1015 if (err) {
1016 ubifs_release_budget(c, &req);
1017 return err;
1018 }
1019
1020 lock_3_inodes(old_dir, new_dir, new_inode);
1021
1022 /*
1023 * Like most other Unix systems, set the @i_ctime for inodes on a
1024 * rename.
1025 */
1026 time = ubifs_current_time(old_dir);
1027 old_inode->i_ctime = time;
1028
1029 /* We must adjust parent link count when renaming directories */
1030 if (is_dir) {
1031 if (move) {
1032 /*
1033 * @old_dir loses a link because we are moving
1034 * @old_inode to a different directory.
1035 */
1036 drop_nlink(old_dir);
1037 /*
1038 * @new_dir only gains a link if we are not also
1039 * overwriting an existing directory.
1040 */
1041 if (!unlink)
1042 inc_nlink(new_dir);
1043 } else {
1044 /*
1045 * @old_inode is not moving to a different directory,
1046 * but @old_dir still loses a link if we are
1047 * overwriting an existing directory.
1048 */
1049 if (unlink)
1050 drop_nlink(old_dir);
1051 }
1052 }
1053
1054 old_dir->i_size -= old_sz;
1055 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1056 old_dir->i_mtime = old_dir->i_ctime = time;
1057 new_dir->i_mtime = new_dir->i_ctime = time;
1058
1059 /*
1060 * And finally, if we unlinked a direntry which happened to have the
1061 * same name as the moved direntry, we have to decrement @i_nlink of
1062 * the unlinked inode and change its ctime.
1063 */
1064 if (unlink) {
1065 /*
1066 * Directories cannot have hard-links, so if this is a
1067 * directory, just clear @i_nlink.
1068 */
1069 saved_nlink = new_inode->i_nlink;
1070 if (is_dir)
1071 clear_nlink(new_inode);
1072 else
1073 drop_nlink(new_inode);
1074 new_inode->i_ctime = time;
1075 } else {
1076 new_dir->i_size += new_sz;
1077 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1078 }
1079
1080 /*
1081 * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1082 * is dirty, because this will be done later on at the end of
1083 * 'ubifs_rename()'.
1084 */
1085 if (IS_SYNC(old_inode)) {
1086 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1087 if (unlink && IS_SYNC(new_inode))
1088 sync = 1;
1089 }
1090 err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1091 sync);
1092 if (err)
1093 goto out_cancel;
1094
1095 unlock_3_inodes(old_dir, new_dir, new_inode);
1096 ubifs_release_budget(c, &req);
1097
1098 mutex_lock(&old_inode_ui->ui_mutex);
1099 release = old_inode_ui->dirty;
1100 mark_inode_dirty_sync(old_inode);
1101 mutex_unlock(&old_inode_ui->ui_mutex);
1102
1103 if (release)
1104 ubifs_release_budget(c, &ino_req);
1105 if (IS_SYNC(old_inode))
1106 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1107 return err;
1108
1109out_cancel:
1110 if (unlink) {
1111 set_nlink(new_inode, saved_nlink);
1112 } else {
1113 new_dir->i_size -= new_sz;
1114 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1115 }
1116 old_dir->i_size += old_sz;
1117 ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1118 if (is_dir) {
1119 if (move) {
1120 inc_nlink(old_dir);
1121 if (!unlink)
1122 drop_nlink(new_dir);
1123 } else {
1124 if (unlink)
1125 inc_nlink(old_dir);
1126 }
1127 }
1128 unlock_3_inodes(old_dir, new_dir, new_inode);
1129 ubifs_release_budget(c, &ino_req);
1130 ubifs_release_budget(c, &req);
1131 return err;
1132}
1133
1134int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1135 struct kstat *stat)
1136{
1137 loff_t size;
1138 struct inode *inode = d_inode(dentry);
1139 struct ubifs_inode *ui = ubifs_inode(inode);
1140
1141 mutex_lock(&ui->ui_mutex);
1142 generic_fillattr(inode, stat);
1143 stat->blksize = UBIFS_BLOCK_SIZE;
1144 stat->size = ui->ui_size;
1145
1146 /*
1147 * Unfortunately, the 'stat()' system call was designed for block
1148 * device based file systems, and it is not appropriate for UBIFS,
1149 * because UBIFS does not have notion of "block". For example, it is
1150 * difficult to tell how many block a directory takes - it actually
1151 * takes less than 300 bytes, but we have to round it to block size,
1152 * which introduces large mistake. This makes utilities like 'du' to
1153 * report completely senseless numbers. This is the reason why UBIFS
1154 * goes the same way as JFFS2 - it reports zero blocks for everything
1155 * but regular files, which makes more sense than reporting completely
1156 * wrong sizes.
1157 */
1158 if (S_ISREG(inode->i_mode)) {
1159 size = ui->xattr_size;
1160 size += stat->size;
1161 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1162 /*
1163 * Note, user-space expects 512-byte blocks count irrespectively
1164 * of what was reported in @stat->size.
1165 */
1166 stat->blocks = size >> 9;
1167 } else
1168 stat->blocks = 0;
1169 mutex_unlock(&ui->ui_mutex);
1170 return 0;
1171}
1172
1173const struct inode_operations ubifs_dir_inode_operations = {
1174 .lookup = ubifs_lookup,
1175 .create = ubifs_create,
1176 .link = ubifs_link,
1177 .symlink = ubifs_symlink,
1178 .unlink = ubifs_unlink,
1179 .mkdir = ubifs_mkdir,
1180 .rmdir = ubifs_rmdir,
1181 .mknod = ubifs_mknod,
1182 .rename = ubifs_rename,
1183 .setattr = ubifs_setattr,
1184 .getattr = ubifs_getattr,
1185 .setxattr = ubifs_setxattr,
1186 .getxattr = ubifs_getxattr,
1187 .listxattr = ubifs_listxattr,
1188 .removexattr = ubifs_removexattr,
1189#ifdef CONFIG_UBIFS_ATIME_SUPPORT
1190 .update_time = ubifs_update_time,
1191#endif
1192};
1193
1194const struct file_operations ubifs_dir_operations = {
1195 .llseek = generic_file_llseek,
1196 .release = ubifs_dir_release,
1197 .read = generic_read_dir,
1198 .iterate = ubifs_readdir,
1199 .fsync = ubifs_fsync,
1200 .unlocked_ioctl = ubifs_ioctl,
1201#ifdef CONFIG_COMPAT
1202 .compat_ioctl = ubifs_compat_ioctl,
1203#endif
1204};