6ca9176c8f59f135e2b4c9a6d67abaf399f38060
[linux-3.10.git] / fs / ubifs / dir.c
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  */
59 static int inherit_flags(const struct inode *dir, int 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  */
88 struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
89                               int 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
173 #ifdef CONFIG_UBIFS_FS_DEBUG
174
175 static int dbg_check_name(struct ubifs_dent_node *dent, struct qstr *nm)
176 {
177         if (!(ubifs_chk_flags & UBIFS_CHK_GEN))
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
186 #else
187
188 #define dbg_check_name(dent, nm) 0
189
190 #endif
191
192 static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
193                                    struct nameidata *nd)
194 {
195         int err;
196         union ubifs_key key;
197         struct inode *inode = NULL;
198         struct ubifs_dent_node *dent;
199         struct ubifs_info *c = dir->i_sb->s_fs_info;
200
201         dbg_gen("'%.*s' in dir ino %lu",
202                 dentry->d_name.len, dentry->d_name.name, dir->i_ino);
203
204         if (dentry->d_name.len > UBIFS_MAX_NLEN)
205                 return ERR_PTR(-ENAMETOOLONG);
206
207         dent = kmalloc(UBIFS_MAX_DENT_NODE_SZ, GFP_NOFS);
208         if (!dent)
209                 return ERR_PTR(-ENOMEM);
210
211         dent_key_init(c, &key, dir->i_ino, &dentry->d_name);
212
213         err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name);
214         if (err) {
215                 if (err == -ENOENT) {
216                         dbg_gen("not found");
217                         goto done;
218                 }
219                 goto out;
220         }
221
222         if (dbg_check_name(dent, &dentry->d_name)) {
223                 err = -EINVAL;
224                 goto out;
225         }
226
227         inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum));
228         if (IS_ERR(inode)) {
229                 /*
230                  * This should not happen. Probably the file-system needs
231                  * checking.
232                  */
233                 err = PTR_ERR(inode);
234                 ubifs_err("dead directory entry '%.*s', error %d",
235                           dentry->d_name.len, dentry->d_name.name, err);
236                 ubifs_ro_mode(c, err);
237                 goto out;
238         }
239
240 done:
241         kfree(dent);
242         /*
243          * Note, d_splice_alias() would be required instead if we supported
244          * NFS.
245          */
246         d_add(dentry, inode);
247         return NULL;
248
249 out:
250         kfree(dent);
251         return ERR_PTR(err);
252 }
253
254 static int ubifs_create(struct inode *dir, struct dentry *dentry, int mode,
255                         struct nameidata *nd)
256 {
257         struct inode *inode;
258         struct ubifs_info *c = dir->i_sb->s_fs_info;
259         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
260         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
261                                         .dirtied_ino = 1 };
262         struct ubifs_inode *dir_ui = ubifs_inode(dir);
263
264         /*
265          * Budget request settings: new inode, new direntry, changing the
266          * parent directory inode.
267          */
268
269         dbg_gen("dent '%.*s', mode %#x in dir ino %lu",
270                 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
271
272         err = ubifs_budget_space(c, &req);
273         if (err)
274                 return err;
275
276         inode = ubifs_new_inode(c, dir, mode);
277         if (IS_ERR(inode)) {
278                 err = PTR_ERR(inode);
279                 goto out_budg;
280         }
281
282         mutex_lock(&dir_ui->ui_mutex);
283         dir->i_size += sz_change;
284         dir_ui->ui_size = dir->i_size;
285         dir->i_mtime = dir->i_ctime = inode->i_ctime;
286         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
287         if (err)
288                 goto out_cancel;
289         mutex_unlock(&dir_ui->ui_mutex);
290
291         ubifs_release_budget(c, &req);
292         insert_inode_hash(inode);
293         d_instantiate(dentry, inode);
294         return 0;
295
296 out_cancel:
297         dir->i_size -= sz_change;
298         dir_ui->ui_size = dir->i_size;
299         mutex_unlock(&dir_ui->ui_mutex);
300         make_bad_inode(inode);
301         iput(inode);
302 out_budg:
303         ubifs_release_budget(c, &req);
304         ubifs_err("cannot create regular file, error %d", err);
305         return err;
306 }
307
308 /**
309  * vfs_dent_type - get VFS directory entry type.
310  * @type: UBIFS directory entry type
311  *
312  * This function converts UBIFS directory entry type into VFS directory entry
313  * type.
314  */
315 static unsigned int vfs_dent_type(uint8_t type)
316 {
317         switch (type) {
318         case UBIFS_ITYPE_REG:
319                 return DT_REG;
320         case UBIFS_ITYPE_DIR:
321                 return DT_DIR;
322         case UBIFS_ITYPE_LNK:
323                 return DT_LNK;
324         case UBIFS_ITYPE_BLK:
325                 return DT_BLK;
326         case UBIFS_ITYPE_CHR:
327                 return DT_CHR;
328         case UBIFS_ITYPE_FIFO:
329                 return DT_FIFO;
330         case UBIFS_ITYPE_SOCK:
331                 return DT_SOCK;
332         default:
333                 BUG();
334         }
335         return 0;
336 }
337
338 /*
339  * The classical Unix view for directory is that it is a linear array of
340  * (name, inode number) entries. Linux/VFS assumes this model as well.
341  * Particularly, 'readdir()' call wants us to return a directory entry offset
342  * which later may be used to continue 'readdir()'ing the directory or to
343  * 'seek()' to that specific direntry. Obviously UBIFS does not really fit this
344  * model because directory entries are identified by keys, which may collide.
345  *
346  * UBIFS uses directory entry hash value for directory offsets, so
347  * 'seekdir()'/'telldir()' may not always work because of possible key
348  * collisions. But UBIFS guarantees that consecutive 'readdir()' calls work
349  * properly by means of saving full directory entry name in the private field
350  * of the file description object.
351  *
352  * This means that UBIFS cannot support NFS which requires full
353  * 'seekdir()'/'telldir()' support.
354  */
355 static int ubifs_readdir(struct file *file, void *dirent, filldir_t filldir)
356 {
357         int err, over = 0;
358         struct qstr nm;
359         union ubifs_key key;
360         struct ubifs_dent_node *dent;
361         struct inode *dir = file->f_path.dentry->d_inode;
362         struct ubifs_info *c = dir->i_sb->s_fs_info;
363
364         dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, file->f_pos);
365
366         if (file->f_pos > UBIFS_S_KEY_HASH_MASK || file->f_pos == 2)
367                 /*
368                  * The directory was seek'ed to a senseless position or there
369                  * are no more entries.
370                  */
371                 return 0;
372
373         /* File positions 0 and 1 correspond to "." and ".." */
374         if (file->f_pos == 0) {
375                 ubifs_assert(!file->private_data);
376                 over = filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR);
377                 if (over)
378                         return 0;
379                 file->f_pos = 1;
380         }
381
382         if (file->f_pos == 1) {
383                 ubifs_assert(!file->private_data);
384                 over = filldir(dirent, "..", 2, 1,
385                                parent_ino(file->f_path.dentry), DT_DIR);
386                 if (over)
387                         return 0;
388
389                 /* Find the first entry in TNC and save it */
390                 lowest_dent_key(c, &key, dir->i_ino);
391                 nm.name = NULL;
392                 dent = ubifs_tnc_next_ent(c, &key, &nm);
393                 if (IS_ERR(dent)) {
394                         err = PTR_ERR(dent);
395                         goto out;
396                 }
397
398                 file->f_pos = key_hash_flash(c, &dent->key);
399                 file->private_data = dent;
400         }
401
402         dent = file->private_data;
403         if (!dent) {
404                 /*
405                  * The directory was seek'ed to and is now readdir'ed.
406                  * Find the entry corresponding to @file->f_pos or the
407                  * closest one.
408                  */
409                 dent_key_init_hash(c, &key, dir->i_ino, file->f_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                 file->f_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                 over = filldir(dirent, dent->name, nm.len, file->f_pos,
429                                le64_to_cpu(dent->inum),
430                                vfs_dent_type(dent->type));
431                 if (over)
432                         return 0;
433
434                 /* Switch to the next entry */
435                 key_read(c, &dent->key, &key);
436                 nm.name = dent->name;
437                 dent = ubifs_tnc_next_ent(c, &key, &nm);
438                 if (IS_ERR(dent)) {
439                         err = PTR_ERR(dent);
440                         goto out;
441                 }
442
443                 kfree(file->private_data);
444                 file->f_pos = key_hash_flash(c, &dent->key);
445                 file->private_data = dent;
446                 cond_resched();
447         }
448
449 out:
450         if (err != -ENOENT) {
451                 ubifs_err("cannot find next direntry, error %d", err);
452                 return err;
453         }
454
455         kfree(file->private_data);
456         file->private_data = NULL;
457         file->f_pos = 2;
458         return 0;
459 }
460
461 /* If a directory is seeked, we have to free saved readdir() state */
462 static loff_t ubifs_dir_llseek(struct file *file, loff_t offset, int origin)
463 {
464         kfree(file->private_data);
465         file->private_data = NULL;
466         return generic_file_llseek(file, offset, origin);
467 }
468
469 /* Free saved readdir() state when the directory is closed */
470 static int ubifs_dir_release(struct inode *dir, struct file *file)
471 {
472         kfree(file->private_data);
473         file->private_data = NULL;
474         return 0;
475 }
476
477 /**
478  * lock_2_inodes - a wrapper for locking two UBIFS inodes.
479  * @inode1: first inode
480  * @inode2: second inode
481  *
482  * We do not implement any tricks to guarantee strict lock ordering, because
483  * VFS has already done it for us on the @i_mutex. So this is just a simple
484  * wrapper function.
485  */
486 static void lock_2_inodes(struct inode *inode1, struct inode *inode2)
487 {
488         mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
489         mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
490 }
491
492 /**
493  * unlock_2_inodes - a wrapper for unlocking two UBIFS inodes.
494  * @inode1: first inode
495  * @inode2: second inode
496  */
497 static void unlock_2_inodes(struct inode *inode1, struct inode *inode2)
498 {
499         mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
500         mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
501 }
502
503 static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
504                       struct dentry *dentry)
505 {
506         struct ubifs_info *c = dir->i_sb->s_fs_info;
507         struct inode *inode = old_dentry->d_inode;
508         struct ubifs_inode *ui = ubifs_inode(inode);
509         struct ubifs_inode *dir_ui = ubifs_inode(dir);
510         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
511         struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
512                                 .dirtied_ino_d = ALIGN(ui->data_len, 8) };
513
514         /*
515          * Budget request settings: new direntry, changing the target inode,
516          * changing the parent inode.
517          */
518
519         dbg_gen("dent '%.*s' to ino %lu (nlink %d) in dir ino %lu",
520                 dentry->d_name.len, dentry->d_name.name, inode->i_ino,
521                 inode->i_nlink, dir->i_ino);
522         ubifs_assert(mutex_is_locked(&dir->i_mutex));
523         ubifs_assert(mutex_is_locked(&inode->i_mutex));
524
525         err = dbg_check_synced_i_size(inode);
526         if (err)
527                 return err;
528
529         err = ubifs_budget_space(c, &req);
530         if (err)
531                 return err;
532
533         lock_2_inodes(dir, inode);
534         inc_nlink(inode);
535         ihold(inode);
536         inode->i_ctime = ubifs_current_time(inode);
537         dir->i_size += sz_change;
538         dir_ui->ui_size = dir->i_size;
539         dir->i_mtime = dir->i_ctime = inode->i_ctime;
540         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
541         if (err)
542                 goto out_cancel;
543         unlock_2_inodes(dir, inode);
544
545         ubifs_release_budget(c, &req);
546         d_instantiate(dentry, inode);
547         return 0;
548
549 out_cancel:
550         dir->i_size -= sz_change;
551         dir_ui->ui_size = dir->i_size;
552         drop_nlink(inode);
553         unlock_2_inodes(dir, inode);
554         ubifs_release_budget(c, &req);
555         iput(inode);
556         return err;
557 }
558
559 static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
560 {
561         struct ubifs_info *c = dir->i_sb->s_fs_info;
562         struct inode *inode = dentry->d_inode;
563         struct ubifs_inode *dir_ui = ubifs_inode(dir);
564         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
565         int err, budgeted = 1;
566         struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
567
568         /*
569          * Budget request settings: deletion direntry, deletion inode (+1 for
570          * @dirtied_ino), changing the parent directory inode. If budgeting
571          * fails, go ahead anyway because we have extra space reserved for
572          * deletions.
573          */
574
575         dbg_gen("dent '%.*s' from ino %lu (nlink %d) in dir ino %lu",
576                 dentry->d_name.len, dentry->d_name.name, inode->i_ino,
577                 inode->i_nlink, dir->i_ino);
578         ubifs_assert(mutex_is_locked(&dir->i_mutex));
579         ubifs_assert(mutex_is_locked(&inode->i_mutex));
580         err = dbg_check_synced_i_size(inode);
581         if (err)
582                 return err;
583
584         err = ubifs_budget_space(c, &req);
585         if (err) {
586                 if (err != -ENOSPC)
587                         return err;
588                 budgeted = 0;
589         }
590
591         lock_2_inodes(dir, inode);
592         inode->i_ctime = ubifs_current_time(dir);
593         drop_nlink(inode);
594         dir->i_size -= sz_change;
595         dir_ui->ui_size = dir->i_size;
596         dir->i_mtime = dir->i_ctime = inode->i_ctime;
597         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
598         if (err)
599                 goto out_cancel;
600         unlock_2_inodes(dir, inode);
601
602         if (budgeted)
603                 ubifs_release_budget(c, &req);
604         else {
605                 /* We've deleted something - clean the "no space" flags */
606                 c->nospace = c->nospace_rp = 0;
607                 smp_wmb();
608         }
609         return 0;
610
611 out_cancel:
612         dir->i_size += sz_change;
613         dir_ui->ui_size = dir->i_size;
614         inc_nlink(inode);
615         unlock_2_inodes(dir, inode);
616         if (budgeted)
617                 ubifs_release_budget(c, &req);
618         return err;
619 }
620
621 /**
622  * check_dir_empty - check if a directory is empty or not.
623  * @c: UBIFS file-system description object
624  * @dir: VFS inode object of the directory to check
625  *
626  * This function checks if directory @dir is empty. Returns zero if the
627  * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
628  * in case of of errors.
629  */
630 static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
631 {
632         struct qstr nm = { .name = NULL };
633         struct ubifs_dent_node *dent;
634         union ubifs_key key;
635         int err;
636
637         lowest_dent_key(c, &key, dir->i_ino);
638         dent = ubifs_tnc_next_ent(c, &key, &nm);
639         if (IS_ERR(dent)) {
640                 err = PTR_ERR(dent);
641                 if (err == -ENOENT)
642                         err = 0;
643         } else {
644                 kfree(dent);
645                 err = -ENOTEMPTY;
646         }
647         return err;
648 }
649
650 static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
651 {
652         struct ubifs_info *c = dir->i_sb->s_fs_info;
653         struct inode *inode = dentry->d_inode;
654         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
655         int err, budgeted = 1;
656         struct ubifs_inode *dir_ui = ubifs_inode(dir);
657         struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
658
659         dentry_unhash(dentry);
660
661         /*
662          * Budget request settings: deletion direntry, deletion inode and
663          * changing the parent inode. If budgeting fails, go ahead anyway
664          * because we have extra space reserved for deletions.
665          */
666
667         dbg_gen("directory '%.*s', ino %lu in dir ino %lu", dentry->d_name.len,
668                 dentry->d_name.name, inode->i_ino, dir->i_ino);
669         ubifs_assert(mutex_is_locked(&dir->i_mutex));
670         ubifs_assert(mutex_is_locked(&inode->i_mutex));
671         err = check_dir_empty(c, dentry->d_inode);
672         if (err)
673                 return err;
674
675         err = ubifs_budget_space(c, &req);
676         if (err) {
677                 if (err != -ENOSPC)
678                         return err;
679                 budgeted = 0;
680         }
681
682         lock_2_inodes(dir, inode);
683         inode->i_ctime = ubifs_current_time(dir);
684         clear_nlink(inode);
685         drop_nlink(dir);
686         dir->i_size -= sz_change;
687         dir_ui->ui_size = dir->i_size;
688         dir->i_mtime = dir->i_ctime = inode->i_ctime;
689         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
690         if (err)
691                 goto out_cancel;
692         unlock_2_inodes(dir, inode);
693
694         if (budgeted)
695                 ubifs_release_budget(c, &req);
696         else {
697                 /* We've deleted something - clean the "no space" flags */
698                 c->nospace = c->nospace_rp = 0;
699                 smp_wmb();
700         }
701         return 0;
702
703 out_cancel:
704         dir->i_size += sz_change;
705         dir_ui->ui_size = dir->i_size;
706         inc_nlink(dir);
707         inc_nlink(inode);
708         inc_nlink(inode);
709         unlock_2_inodes(dir, inode);
710         if (budgeted)
711                 ubifs_release_budget(c, &req);
712         return err;
713 }
714
715 static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
716 {
717         struct inode *inode;
718         struct ubifs_inode *dir_ui = ubifs_inode(dir);
719         struct ubifs_info *c = dir->i_sb->s_fs_info;
720         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
721         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
722
723         /*
724          * Budget request settings: new inode, new direntry and changing parent
725          * directory inode.
726          */
727
728         dbg_gen("dent '%.*s', mode %#x in dir ino %lu",
729                 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
730
731         err = ubifs_budget_space(c, &req);
732         if (err)
733                 return err;
734
735         inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
736         if (IS_ERR(inode)) {
737                 err = PTR_ERR(inode);
738                 goto out_budg;
739         }
740
741         mutex_lock(&dir_ui->ui_mutex);
742         insert_inode_hash(inode);
743         inc_nlink(inode);
744         inc_nlink(dir);
745         dir->i_size += sz_change;
746         dir_ui->ui_size = dir->i_size;
747         dir->i_mtime = dir->i_ctime = inode->i_ctime;
748         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
749         if (err) {
750                 ubifs_err("cannot create directory, error %d", err);
751                 goto out_cancel;
752         }
753         mutex_unlock(&dir_ui->ui_mutex);
754
755         ubifs_release_budget(c, &req);
756         d_instantiate(dentry, inode);
757         return 0;
758
759 out_cancel:
760         dir->i_size -= sz_change;
761         dir_ui->ui_size = dir->i_size;
762         drop_nlink(dir);
763         mutex_unlock(&dir_ui->ui_mutex);
764         make_bad_inode(inode);
765         iput(inode);
766 out_budg:
767         ubifs_release_budget(c, &req);
768         return err;
769 }
770
771 static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
772                        int mode, dev_t rdev)
773 {
774         struct inode *inode;
775         struct ubifs_inode *ui;
776         struct ubifs_inode *dir_ui = ubifs_inode(dir);
777         struct ubifs_info *c = dir->i_sb->s_fs_info;
778         union ubifs_dev_desc *dev = NULL;
779         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
780         int err, devlen = 0;
781         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
782                                         .new_ino_d = ALIGN(devlen, 8),
783                                         .dirtied_ino = 1 };
784
785         /*
786          * Budget request settings: new inode, new direntry and changing parent
787          * directory inode.
788          */
789
790         dbg_gen("dent '%.*s' in dir ino %lu",
791                 dentry->d_name.len, dentry->d_name.name, dir->i_ino);
792
793         if (!new_valid_dev(rdev))
794                 return -EINVAL;
795
796         if (S_ISBLK(mode) || S_ISCHR(mode)) {
797                 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
798                 if (!dev)
799                         return -ENOMEM;
800                 devlen = ubifs_encode_dev(dev, rdev);
801         }
802
803         err = ubifs_budget_space(c, &req);
804         if (err) {
805                 kfree(dev);
806                 return err;
807         }
808
809         inode = ubifs_new_inode(c, dir, mode);
810         if (IS_ERR(inode)) {
811                 kfree(dev);
812                 err = PTR_ERR(inode);
813                 goto out_budg;
814         }
815
816         init_special_inode(inode, inode->i_mode, rdev);
817         inode->i_size = ubifs_inode(inode)->ui_size = devlen;
818         ui = ubifs_inode(inode);
819         ui->data = dev;
820         ui->data_len = devlen;
821
822         mutex_lock(&dir_ui->ui_mutex);
823         dir->i_size += sz_change;
824         dir_ui->ui_size = dir->i_size;
825         dir->i_mtime = dir->i_ctime = inode->i_ctime;
826         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
827         if (err)
828                 goto out_cancel;
829         mutex_unlock(&dir_ui->ui_mutex);
830
831         ubifs_release_budget(c, &req);
832         insert_inode_hash(inode);
833         d_instantiate(dentry, inode);
834         return 0;
835
836 out_cancel:
837         dir->i_size -= sz_change;
838         dir_ui->ui_size = dir->i_size;
839         mutex_unlock(&dir_ui->ui_mutex);
840         make_bad_inode(inode);
841         iput(inode);
842 out_budg:
843         ubifs_release_budget(c, &req);
844         return err;
845 }
846
847 static 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 '%.*s', target '%s' in dir ino %lu", dentry->d_name.len,
866                 dentry->d_name.name, 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         /*
891          * The terminating zero byte is not written to the flash media and it
892          * is put just to make later in-memory string processing simpler. Thus,
893          * data length is @len, not @len + %1.
894          */
895         ui->data_len = len;
896         inode->i_size = ubifs_inode(inode)->ui_size = len;
897
898         mutex_lock(&dir_ui->ui_mutex);
899         dir->i_size += sz_change;
900         dir_ui->ui_size = dir->i_size;
901         dir->i_mtime = dir->i_ctime = inode->i_ctime;
902         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
903         if (err)
904                 goto out_cancel;
905         mutex_unlock(&dir_ui->ui_mutex);
906
907         ubifs_release_budget(c, &req);
908         insert_inode_hash(inode);
909         d_instantiate(dentry, inode);
910         return 0;
911
912 out_cancel:
913         dir->i_size -= sz_change;
914         dir_ui->ui_size = dir->i_size;
915         mutex_unlock(&dir_ui->ui_mutex);
916 out_inode:
917         make_bad_inode(inode);
918         iput(inode);
919 out_budg:
920         ubifs_release_budget(c, &req);
921         return err;
922 }
923
924 /**
925  * lock_3_inodes - a wrapper for locking three UBIFS inodes.
926  * @inode1: first inode
927  * @inode2: second inode
928  * @inode3: third inode
929  *
930  * This function is used for 'ubifs_rename()' and @inode1 may be the same as
931  * @inode2 whereas @inode3 may be %NULL.
932  *
933  * We do not implement any tricks to guarantee strict lock ordering, because
934  * VFS has already done it for us on the @i_mutex. So this is just a simple
935  * wrapper function.
936  */
937 static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
938                           struct inode *inode3)
939 {
940         mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
941         if (inode2 != inode1)
942                 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
943         if (inode3)
944                 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
945 }
946
947 /**
948  * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
949  * @inode1: first inode
950  * @inode2: second inode
951  * @inode3: third inode
952  */
953 static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
954                             struct inode *inode3)
955 {
956         if (inode3)
957                 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
958         if (inode1 != inode2)
959                 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
960         mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
961 }
962
963 static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
964                         struct inode *new_dir, struct dentry *new_dentry)
965 {
966         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
967         struct inode *old_inode = old_dentry->d_inode;
968         struct inode *new_inode = new_dentry->d_inode;
969         struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
970         int err, release, sync = 0, move = (new_dir != old_dir);
971         int is_dir = S_ISDIR(old_inode->i_mode);
972         int unlink = !!new_inode;
973         int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
974         int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
975         struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
976                                         .dirtied_ino = 3 };
977         struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
978                         .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
979         struct timespec time;
980
981         /*
982          * Budget request settings: deletion direntry, new direntry, removing
983          * the old inode, and changing old and new parent directory inodes.
984          *
985          * However, this operation also marks the target inode as dirty and
986          * does not write it, so we allocate budget for the target inode
987          * separately.
988          */
989
990         dbg_gen("dent '%.*s' ino %lu in dir ino %lu to dent '%.*s' in "
991                 "dir ino %lu", old_dentry->d_name.len, old_dentry->d_name.name,
992                 old_inode->i_ino, old_dir->i_ino, new_dentry->d_name.len,
993                 new_dentry->d_name.name, new_dir->i_ino);
994         ubifs_assert(mutex_is_locked(&old_dir->i_mutex));
995         ubifs_assert(mutex_is_locked(&new_dir->i_mutex));
996         if (unlink)
997                 ubifs_assert(mutex_is_locked(&new_inode->i_mutex));
998
999
1000         if (unlink && is_dir) {
1001                 err = check_dir_empty(c, new_inode);
1002                 if (err)
1003                         return err;
1004         }
1005
1006         err = ubifs_budget_space(c, &req);
1007         if (err)
1008                 return err;
1009         err = ubifs_budget_space(c, &ino_req);
1010         if (err) {
1011                 ubifs_release_budget(c, &req);
1012                 return err;
1013         }
1014
1015         lock_3_inodes(old_dir, new_dir, new_inode);
1016
1017         /*
1018          * Like most other Unix systems, set the @i_ctime for inodes on a
1019          * rename.
1020          */
1021         time = ubifs_current_time(old_dir);
1022         old_inode->i_ctime = time;
1023
1024         /* We must adjust parent link count when renaming directories */
1025         if (is_dir) {
1026                 if (move) {
1027                         /*
1028                          * @old_dir loses a link because we are moving
1029                          * @old_inode to a different directory.
1030                          */
1031                         drop_nlink(old_dir);
1032                         /*
1033                          * @new_dir only gains a link if we are not also
1034                          * overwriting an existing directory.
1035                          */
1036                         if (!unlink)
1037                                 inc_nlink(new_dir);
1038                 } else {
1039                         /*
1040                          * @old_inode is not moving to a different directory,
1041                          * but @old_dir still loses a link if we are
1042                          * overwriting an existing directory.
1043                          */
1044                         if (unlink)
1045                                 drop_nlink(old_dir);
1046                 }
1047         }
1048
1049         old_dir->i_size -= old_sz;
1050         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1051         old_dir->i_mtime = old_dir->i_ctime = time;
1052         new_dir->i_mtime = new_dir->i_ctime = time;
1053
1054         /*
1055          * And finally, if we unlinked a direntry which happened to have the
1056          * same name as the moved direntry, we have to decrement @i_nlink of
1057          * the unlinked inode and change its ctime.
1058          */
1059         if (unlink) {
1060                 /*
1061                  * Directories cannot have hard-links, so if this is a
1062                  * directory, decrement its @i_nlink twice because an empty
1063                  * directory has @i_nlink 2.
1064                  */
1065                 if (is_dir)
1066                         drop_nlink(new_inode);
1067                 new_inode->i_ctime = time;
1068                 drop_nlink(new_inode);
1069         } else {
1070                 new_dir->i_size += new_sz;
1071                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1072         }
1073
1074         /*
1075          * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1076          * is dirty, because this will be done later on at the end of
1077          * 'ubifs_rename()'.
1078          */
1079         if (IS_SYNC(old_inode)) {
1080                 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1081                 if (unlink && IS_SYNC(new_inode))
1082                         sync = 1;
1083         }
1084         err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1085                                sync);
1086         if (err)
1087                 goto out_cancel;
1088
1089         unlock_3_inodes(old_dir, new_dir, new_inode);
1090         ubifs_release_budget(c, &req);
1091
1092         mutex_lock(&old_inode_ui->ui_mutex);
1093         release = old_inode_ui->dirty;
1094         mark_inode_dirty_sync(old_inode);
1095         mutex_unlock(&old_inode_ui->ui_mutex);
1096
1097         if (release)
1098                 ubifs_release_budget(c, &ino_req);
1099         if (IS_SYNC(old_inode))
1100                 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1101         return err;
1102
1103 out_cancel:
1104         if (unlink) {
1105                 if (is_dir)
1106                         inc_nlink(new_inode);
1107                 inc_nlink(new_inode);
1108         } else {
1109                 new_dir->i_size -= new_sz;
1110                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1111         }
1112         old_dir->i_size += old_sz;
1113         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1114         if (is_dir) {
1115                 if (move) {
1116                         inc_nlink(old_dir);
1117                         if (!unlink)
1118                                 drop_nlink(new_dir);
1119                 } else {
1120                         if (unlink)
1121                                 inc_nlink(old_dir);
1122                 }
1123         }
1124         unlock_3_inodes(old_dir, new_dir, new_inode);
1125         ubifs_release_budget(c, &ino_req);
1126         ubifs_release_budget(c, &req);
1127         return err;
1128 }
1129
1130 int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1131                   struct kstat *stat)
1132 {
1133         loff_t size;
1134         struct inode *inode = dentry->d_inode;
1135         struct ubifs_inode *ui = ubifs_inode(inode);
1136
1137         mutex_lock(&ui->ui_mutex);
1138         stat->dev = inode->i_sb->s_dev;
1139         stat->ino = inode->i_ino;
1140         stat->mode = inode->i_mode;
1141         stat->nlink = inode->i_nlink;
1142         stat->uid = inode->i_uid;
1143         stat->gid = inode->i_gid;
1144         stat->rdev = inode->i_rdev;
1145         stat->atime = inode->i_atime;
1146         stat->mtime = inode->i_mtime;
1147         stat->ctime = inode->i_ctime;
1148         stat->blksize = UBIFS_BLOCK_SIZE;
1149         stat->size = ui->ui_size;
1150
1151         /*
1152          * Unfortunately, the 'stat()' system call was designed for block
1153          * device based file systems, and it is not appropriate for UBIFS,
1154          * because UBIFS does not have notion of "block". For example, it is
1155          * difficult to tell how many block a directory takes - it actually
1156          * takes less than 300 bytes, but we have to round it to block size,
1157          * which introduces large mistake. This makes utilities like 'du' to
1158          * report completely senseless numbers. This is the reason why UBIFS
1159          * goes the same way as JFFS2 - it reports zero blocks for everything
1160          * but regular files, which makes more sense than reporting completely
1161          * wrong sizes.
1162          */
1163         if (S_ISREG(inode->i_mode)) {
1164                 size = ui->xattr_size;
1165                 size += stat->size;
1166                 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1167                 /*
1168                  * Note, user-space expects 512-byte blocks count irrespectively
1169                  * of what was reported in @stat->size.
1170                  */
1171                 stat->blocks = size >> 9;
1172         } else
1173                 stat->blocks = 0;
1174         mutex_unlock(&ui->ui_mutex);
1175         return 0;
1176 }
1177
1178 const struct inode_operations ubifs_dir_inode_operations = {
1179         .lookup      = ubifs_lookup,
1180         .create      = ubifs_create,
1181         .link        = ubifs_link,
1182         .symlink     = ubifs_symlink,
1183         .unlink      = ubifs_unlink,
1184         .mkdir       = ubifs_mkdir,
1185         .rmdir       = ubifs_rmdir,
1186         .mknod       = ubifs_mknod,
1187         .rename      = ubifs_rename,
1188         .setattr     = ubifs_setattr,
1189         .getattr     = ubifs_getattr,
1190 #ifdef CONFIG_UBIFS_FS_XATTR
1191         .setxattr    = ubifs_setxattr,
1192         .getxattr    = ubifs_getxattr,
1193         .listxattr   = ubifs_listxattr,
1194         .removexattr = ubifs_removexattr,
1195 #endif
1196 };
1197
1198 const struct file_operations ubifs_dir_operations = {
1199         .llseek         = ubifs_dir_llseek,
1200         .release        = ubifs_dir_release,
1201         .read           = generic_read_dir,
1202         .readdir        = ubifs_readdir,
1203         .fsync          = ubifs_fsync,
1204         .unlocked_ioctl = ubifs_ioctl,
1205 #ifdef CONFIG_COMPAT
1206         .compat_ioctl   = ubifs_compat_ioctl,
1207 #endif
1208 };