new helper: ihold()
[linux-2.6.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         /*
526          * Return -ENOENT if we've raced with unlink and i_nlink is 0.  Doing
527          * otherwise has the potential to corrupt the orphan inode list.
528          *
529          * Indeed, consider a scenario when 'vfs_link(dirA/fileA)' and
530          * 'vfs_unlink(dirA/fileA, dirB/fileB)' race. 'vfs_link()' does not
531          * lock 'dirA->i_mutex', so this is possible. Both of the functions
532          * lock 'fileA->i_mutex' though. Suppose 'vfs_unlink()' wins, and takes
533          * 'fileA->i_mutex' mutex first. Suppose 'fileA->i_nlink' is 1. In this
534          * case 'ubifs_unlink()' will drop the last reference, and put 'inodeA'
535          * to the list of orphans. After this, 'vfs_link()' will link
536          * 'dirB/fileB' to 'inodeA'. This is a problem because, for example,
537          * the subsequent 'vfs_unlink(dirB/fileB)' will add the same inode
538          * to the list of orphans.
539          */
540          if (inode->i_nlink == 0)
541                  return -ENOENT;
542
543         err = dbg_check_synced_i_size(inode);
544         if (err)
545                 return err;
546
547         err = ubifs_budget_space(c, &req);
548         if (err)
549                 return err;
550
551         lock_2_inodes(dir, inode);
552         inc_nlink(inode);
553         ihold(inode);
554         inode->i_ctime = ubifs_current_time(inode);
555         dir->i_size += sz_change;
556         dir_ui->ui_size = dir->i_size;
557         dir->i_mtime = dir->i_ctime = inode->i_ctime;
558         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
559         if (err)
560                 goto out_cancel;
561         unlock_2_inodes(dir, inode);
562
563         ubifs_release_budget(c, &req);
564         d_instantiate(dentry, inode);
565         return 0;
566
567 out_cancel:
568         dir->i_size -= sz_change;
569         dir_ui->ui_size = dir->i_size;
570         drop_nlink(inode);
571         unlock_2_inodes(dir, inode);
572         ubifs_release_budget(c, &req);
573         iput(inode);
574         return err;
575 }
576
577 static int ubifs_unlink(struct inode *dir, struct dentry *dentry)
578 {
579         struct ubifs_info *c = dir->i_sb->s_fs_info;
580         struct inode *inode = dentry->d_inode;
581         struct ubifs_inode *dir_ui = ubifs_inode(dir);
582         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
583         int err, budgeted = 1;
584         struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
585
586         /*
587          * Budget request settings: deletion direntry, deletion inode (+1 for
588          * @dirtied_ino), changing the parent directory inode. If budgeting
589          * fails, go ahead anyway because we have extra space reserved for
590          * deletions.
591          */
592
593         dbg_gen("dent '%.*s' from ino %lu (nlink %d) in dir ino %lu",
594                 dentry->d_name.len, dentry->d_name.name, inode->i_ino,
595                 inode->i_nlink, dir->i_ino);
596         ubifs_assert(mutex_is_locked(&dir->i_mutex));
597         ubifs_assert(mutex_is_locked(&inode->i_mutex));
598         err = dbg_check_synced_i_size(inode);
599         if (err)
600                 return err;
601
602         err = ubifs_budget_space(c, &req);
603         if (err) {
604                 if (err != -ENOSPC)
605                         return err;
606                 budgeted = 0;
607         }
608
609         lock_2_inodes(dir, inode);
610         inode->i_ctime = ubifs_current_time(dir);
611         drop_nlink(inode);
612         dir->i_size -= sz_change;
613         dir_ui->ui_size = dir->i_size;
614         dir->i_mtime = dir->i_ctime = inode->i_ctime;
615         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
616         if (err)
617                 goto out_cancel;
618         unlock_2_inodes(dir, inode);
619
620         if (budgeted)
621                 ubifs_release_budget(c, &req);
622         else {
623                 /* We've deleted something - clean the "no space" flags */
624                 c->nospace = c->nospace_rp = 0;
625                 smp_wmb();
626         }
627         return 0;
628
629 out_cancel:
630         dir->i_size += sz_change;
631         dir_ui->ui_size = dir->i_size;
632         inc_nlink(inode);
633         unlock_2_inodes(dir, inode);
634         if (budgeted)
635                 ubifs_release_budget(c, &req);
636         return err;
637 }
638
639 /**
640  * check_dir_empty - check if a directory is empty or not.
641  * @c: UBIFS file-system description object
642  * @dir: VFS inode object of the directory to check
643  *
644  * This function checks if directory @dir is empty. Returns zero if the
645  * directory is empty, %-ENOTEMPTY if it is not, and other negative error codes
646  * in case of of errors.
647  */
648 static int check_dir_empty(struct ubifs_info *c, struct inode *dir)
649 {
650         struct qstr nm = { .name = NULL };
651         struct ubifs_dent_node *dent;
652         union ubifs_key key;
653         int err;
654
655         lowest_dent_key(c, &key, dir->i_ino);
656         dent = ubifs_tnc_next_ent(c, &key, &nm);
657         if (IS_ERR(dent)) {
658                 err = PTR_ERR(dent);
659                 if (err == -ENOENT)
660                         err = 0;
661         } else {
662                 kfree(dent);
663                 err = -ENOTEMPTY;
664         }
665         return err;
666 }
667
668 static int ubifs_rmdir(struct inode *dir, struct dentry *dentry)
669 {
670         struct ubifs_info *c = dir->i_sb->s_fs_info;
671         struct inode *inode = dentry->d_inode;
672         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
673         int err, budgeted = 1;
674         struct ubifs_inode *dir_ui = ubifs_inode(dir);
675         struct ubifs_budget_req req = { .mod_dent = 1, .dirtied_ino = 2 };
676
677         /*
678          * Budget request settings: deletion direntry, deletion inode and
679          * changing the parent inode. If budgeting fails, go ahead anyway
680          * because we have extra space reserved for deletions.
681          */
682
683         dbg_gen("directory '%.*s', ino %lu in dir ino %lu", dentry->d_name.len,
684                 dentry->d_name.name, inode->i_ino, dir->i_ino);
685         ubifs_assert(mutex_is_locked(&dir->i_mutex));
686         ubifs_assert(mutex_is_locked(&inode->i_mutex));
687         err = check_dir_empty(c, dentry->d_inode);
688         if (err)
689                 return err;
690
691         err = ubifs_budget_space(c, &req);
692         if (err) {
693                 if (err != -ENOSPC)
694                         return err;
695                 budgeted = 0;
696         }
697
698         lock_2_inodes(dir, inode);
699         inode->i_ctime = ubifs_current_time(dir);
700         clear_nlink(inode);
701         drop_nlink(dir);
702         dir->i_size -= sz_change;
703         dir_ui->ui_size = dir->i_size;
704         dir->i_mtime = dir->i_ctime = inode->i_ctime;
705         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 1, 0);
706         if (err)
707                 goto out_cancel;
708         unlock_2_inodes(dir, inode);
709
710         if (budgeted)
711                 ubifs_release_budget(c, &req);
712         else {
713                 /* We've deleted something - clean the "no space" flags */
714                 c->nospace = c->nospace_rp = 0;
715                 smp_wmb();
716         }
717         return 0;
718
719 out_cancel:
720         dir->i_size += sz_change;
721         dir_ui->ui_size = dir->i_size;
722         inc_nlink(dir);
723         inc_nlink(inode);
724         inc_nlink(inode);
725         unlock_2_inodes(dir, inode);
726         if (budgeted)
727                 ubifs_release_budget(c, &req);
728         return err;
729 }
730
731 static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
732 {
733         struct inode *inode;
734         struct ubifs_inode *dir_ui = ubifs_inode(dir);
735         struct ubifs_info *c = dir->i_sb->s_fs_info;
736         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
737         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
738
739         /*
740          * Budget request settings: new inode, new direntry and changing parent
741          * directory inode.
742          */
743
744         dbg_gen("dent '%.*s', mode %#x in dir ino %lu",
745                 dentry->d_name.len, dentry->d_name.name, mode, dir->i_ino);
746
747         err = ubifs_budget_space(c, &req);
748         if (err)
749                 return err;
750
751         inode = ubifs_new_inode(c, dir, S_IFDIR | mode);
752         if (IS_ERR(inode)) {
753                 err = PTR_ERR(inode);
754                 goto out_budg;
755         }
756
757         mutex_lock(&dir_ui->ui_mutex);
758         insert_inode_hash(inode);
759         inc_nlink(inode);
760         inc_nlink(dir);
761         dir->i_size += sz_change;
762         dir_ui->ui_size = dir->i_size;
763         dir->i_mtime = dir->i_ctime = inode->i_ctime;
764         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
765         if (err) {
766                 ubifs_err("cannot create directory, error %d", err);
767                 goto out_cancel;
768         }
769         mutex_unlock(&dir_ui->ui_mutex);
770
771         ubifs_release_budget(c, &req);
772         d_instantiate(dentry, inode);
773         return 0;
774
775 out_cancel:
776         dir->i_size -= sz_change;
777         dir_ui->ui_size = dir->i_size;
778         drop_nlink(dir);
779         mutex_unlock(&dir_ui->ui_mutex);
780         make_bad_inode(inode);
781         iput(inode);
782 out_budg:
783         ubifs_release_budget(c, &req);
784         return err;
785 }
786
787 static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
788                        int mode, dev_t rdev)
789 {
790         struct inode *inode;
791         struct ubifs_inode *ui;
792         struct ubifs_inode *dir_ui = ubifs_inode(dir);
793         struct ubifs_info *c = dir->i_sb->s_fs_info;
794         union ubifs_dev_desc *dev = NULL;
795         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
796         int err, devlen = 0;
797         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
798                                         .new_ino_d = ALIGN(devlen, 8),
799                                         .dirtied_ino = 1 };
800
801         /*
802          * Budget request settings: new inode, new direntry and changing parent
803          * directory inode.
804          */
805
806         dbg_gen("dent '%.*s' in dir ino %lu",
807                 dentry->d_name.len, dentry->d_name.name, dir->i_ino);
808
809         if (!new_valid_dev(rdev))
810                 return -EINVAL;
811
812         if (S_ISBLK(mode) || S_ISCHR(mode)) {
813                 dev = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
814                 if (!dev)
815                         return -ENOMEM;
816                 devlen = ubifs_encode_dev(dev, rdev);
817         }
818
819         err = ubifs_budget_space(c, &req);
820         if (err) {
821                 kfree(dev);
822                 return err;
823         }
824
825         inode = ubifs_new_inode(c, dir, mode);
826         if (IS_ERR(inode)) {
827                 kfree(dev);
828                 err = PTR_ERR(inode);
829                 goto out_budg;
830         }
831
832         init_special_inode(inode, inode->i_mode, rdev);
833         inode->i_size = ubifs_inode(inode)->ui_size = devlen;
834         ui = ubifs_inode(inode);
835         ui->data = dev;
836         ui->data_len = devlen;
837
838         mutex_lock(&dir_ui->ui_mutex);
839         dir->i_size += sz_change;
840         dir_ui->ui_size = dir->i_size;
841         dir->i_mtime = dir->i_ctime = inode->i_ctime;
842         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
843         if (err)
844                 goto out_cancel;
845         mutex_unlock(&dir_ui->ui_mutex);
846
847         ubifs_release_budget(c, &req);
848         insert_inode_hash(inode);
849         d_instantiate(dentry, inode);
850         return 0;
851
852 out_cancel:
853         dir->i_size -= sz_change;
854         dir_ui->ui_size = dir->i_size;
855         mutex_unlock(&dir_ui->ui_mutex);
856         make_bad_inode(inode);
857         iput(inode);
858 out_budg:
859         ubifs_release_budget(c, &req);
860         return err;
861 }
862
863 static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
864                          const char *symname)
865 {
866         struct inode *inode;
867         struct ubifs_inode *ui;
868         struct ubifs_inode *dir_ui = ubifs_inode(dir);
869         struct ubifs_info *c = dir->i_sb->s_fs_info;
870         int err, len = strlen(symname);
871         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
872         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
873                                         .new_ino_d = ALIGN(len, 8),
874                                         .dirtied_ino = 1 };
875
876         /*
877          * Budget request settings: new inode, new direntry and changing parent
878          * directory inode.
879          */
880
881         dbg_gen("dent '%.*s', target '%s' in dir ino %lu", dentry->d_name.len,
882                 dentry->d_name.name, symname, dir->i_ino);
883
884         if (len > UBIFS_MAX_INO_DATA)
885                 return -ENAMETOOLONG;
886
887         err = ubifs_budget_space(c, &req);
888         if (err)
889                 return err;
890
891         inode = ubifs_new_inode(c, dir, S_IFLNK | S_IRWXUGO);
892         if (IS_ERR(inode)) {
893                 err = PTR_ERR(inode);
894                 goto out_budg;
895         }
896
897         ui = ubifs_inode(inode);
898         ui->data = kmalloc(len + 1, GFP_NOFS);
899         if (!ui->data) {
900                 err = -ENOMEM;
901                 goto out_inode;
902         }
903
904         memcpy(ui->data, symname, len);
905         ((char *)ui->data)[len] = '\0';
906         /*
907          * The terminating zero byte is not written to the flash media and it
908          * is put just to make later in-memory string processing simpler. Thus,
909          * data length is @len, not @len + %1.
910          */
911         ui->data_len = len;
912         inode->i_size = ubifs_inode(inode)->ui_size = len;
913
914         mutex_lock(&dir_ui->ui_mutex);
915         dir->i_size += sz_change;
916         dir_ui->ui_size = dir->i_size;
917         dir->i_mtime = dir->i_ctime = inode->i_ctime;
918         err = ubifs_jnl_update(c, dir, &dentry->d_name, inode, 0, 0);
919         if (err)
920                 goto out_cancel;
921         mutex_unlock(&dir_ui->ui_mutex);
922
923         ubifs_release_budget(c, &req);
924         insert_inode_hash(inode);
925         d_instantiate(dentry, inode);
926         return 0;
927
928 out_cancel:
929         dir->i_size -= sz_change;
930         dir_ui->ui_size = dir->i_size;
931         mutex_unlock(&dir_ui->ui_mutex);
932 out_inode:
933         make_bad_inode(inode);
934         iput(inode);
935 out_budg:
936         ubifs_release_budget(c, &req);
937         return err;
938 }
939
940 /**
941  * lock_3_inodes - a wrapper for locking three UBIFS inodes.
942  * @inode1: first inode
943  * @inode2: second inode
944  * @inode3: third inode
945  *
946  * This function is used for 'ubifs_rename()' and @inode1 may be the same as
947  * @inode2 whereas @inode3 may be %NULL.
948  *
949  * We do not implement any tricks to guarantee strict lock ordering, because
950  * VFS has already done it for us on the @i_mutex. So this is just a simple
951  * wrapper function.
952  */
953 static void lock_3_inodes(struct inode *inode1, struct inode *inode2,
954                           struct inode *inode3)
955 {
956         mutex_lock_nested(&ubifs_inode(inode1)->ui_mutex, WB_MUTEX_1);
957         if (inode2 != inode1)
958                 mutex_lock_nested(&ubifs_inode(inode2)->ui_mutex, WB_MUTEX_2);
959         if (inode3)
960                 mutex_lock_nested(&ubifs_inode(inode3)->ui_mutex, WB_MUTEX_3);
961 }
962
963 /**
964  * unlock_3_inodes - a wrapper for unlocking three UBIFS inodes for rename.
965  * @inode1: first inode
966  * @inode2: second inode
967  * @inode3: third inode
968  */
969 static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
970                             struct inode *inode3)
971 {
972         if (inode3)
973                 mutex_unlock(&ubifs_inode(inode3)->ui_mutex);
974         if (inode1 != inode2)
975                 mutex_unlock(&ubifs_inode(inode2)->ui_mutex);
976         mutex_unlock(&ubifs_inode(inode1)->ui_mutex);
977 }
978
979 static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
980                         struct inode *new_dir, struct dentry *new_dentry)
981 {
982         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
983         struct inode *old_inode = old_dentry->d_inode;
984         struct inode *new_inode = new_dentry->d_inode;
985         struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode);
986         int err, release, sync = 0, move = (new_dir != old_dir);
987         int is_dir = S_ISDIR(old_inode->i_mode);
988         int unlink = !!new_inode;
989         int new_sz = CALC_DENT_SIZE(new_dentry->d_name.len);
990         int old_sz = CALC_DENT_SIZE(old_dentry->d_name.len);
991         struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
992                                         .dirtied_ino = 3 };
993         struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
994                         .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
995         struct timespec time;
996
997         /*
998          * Budget request settings: deletion direntry, new direntry, removing
999          * the old inode, and changing old and new parent directory inodes.
1000          *
1001          * However, this operation also marks the target inode as dirty and
1002          * does not write it, so we allocate budget for the target inode
1003          * separately.
1004          */
1005
1006         dbg_gen("dent '%.*s' ino %lu in dir ino %lu to dent '%.*s' in "
1007                 "dir ino %lu", old_dentry->d_name.len, old_dentry->d_name.name,
1008                 old_inode->i_ino, old_dir->i_ino, new_dentry->d_name.len,
1009                 new_dentry->d_name.name, new_dir->i_ino);
1010         ubifs_assert(mutex_is_locked(&old_dir->i_mutex));
1011         ubifs_assert(mutex_is_locked(&new_dir->i_mutex));
1012         if (unlink)
1013                 ubifs_assert(mutex_is_locked(&new_inode->i_mutex));
1014
1015
1016         if (unlink && is_dir) {
1017                 err = check_dir_empty(c, new_inode);
1018                 if (err)
1019                         return err;
1020         }
1021
1022         err = ubifs_budget_space(c, &req);
1023         if (err)
1024                 return err;
1025         err = ubifs_budget_space(c, &ino_req);
1026         if (err) {
1027                 ubifs_release_budget(c, &req);
1028                 return err;
1029         }
1030
1031         lock_3_inodes(old_dir, new_dir, new_inode);
1032
1033         /*
1034          * Like most other Unix systems, set the @i_ctime for inodes on a
1035          * rename.
1036          */
1037         time = ubifs_current_time(old_dir);
1038         old_inode->i_ctime = time;
1039
1040         /* We must adjust parent link count when renaming directories */
1041         if (is_dir) {
1042                 if (move) {
1043                         /*
1044                          * @old_dir loses a link because we are moving
1045                          * @old_inode to a different directory.
1046                          */
1047                         drop_nlink(old_dir);
1048                         /*
1049                          * @new_dir only gains a link if we are not also
1050                          * overwriting an existing directory.
1051                          */
1052                         if (!unlink)
1053                                 inc_nlink(new_dir);
1054                 } else {
1055                         /*
1056                          * @old_inode is not moving to a different directory,
1057                          * but @old_dir still loses a link if we are
1058                          * overwriting an existing directory.
1059                          */
1060                         if (unlink)
1061                                 drop_nlink(old_dir);
1062                 }
1063         }
1064
1065         old_dir->i_size -= old_sz;
1066         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1067         old_dir->i_mtime = old_dir->i_ctime = time;
1068         new_dir->i_mtime = new_dir->i_ctime = time;
1069
1070         /*
1071          * And finally, if we unlinked a direntry which happened to have the
1072          * same name as the moved direntry, we have to decrement @i_nlink of
1073          * the unlinked inode and change its ctime.
1074          */
1075         if (unlink) {
1076                 /*
1077                  * Directories cannot have hard-links, so if this is a
1078                  * directory, decrement its @i_nlink twice because an empty
1079                  * directory has @i_nlink 2.
1080                  */
1081                 if (is_dir)
1082                         drop_nlink(new_inode);
1083                 new_inode->i_ctime = time;
1084                 drop_nlink(new_inode);
1085         } else {
1086                 new_dir->i_size += new_sz;
1087                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1088         }
1089
1090         /*
1091          * Do not ask 'ubifs_jnl_rename()' to flush write-buffer if @old_inode
1092          * is dirty, because this will be done later on at the end of
1093          * 'ubifs_rename()'.
1094          */
1095         if (IS_SYNC(old_inode)) {
1096                 sync = IS_DIRSYNC(old_dir) || IS_DIRSYNC(new_dir);
1097                 if (unlink && IS_SYNC(new_inode))
1098                         sync = 1;
1099         }
1100         err = ubifs_jnl_rename(c, old_dir, old_dentry, new_dir, new_dentry,
1101                                sync);
1102         if (err)
1103                 goto out_cancel;
1104
1105         unlock_3_inodes(old_dir, new_dir, new_inode);
1106         ubifs_release_budget(c, &req);
1107
1108         mutex_lock(&old_inode_ui->ui_mutex);
1109         release = old_inode_ui->dirty;
1110         mark_inode_dirty_sync(old_inode);
1111         mutex_unlock(&old_inode_ui->ui_mutex);
1112
1113         if (release)
1114                 ubifs_release_budget(c, &ino_req);
1115         if (IS_SYNC(old_inode))
1116                 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL);
1117         return err;
1118
1119 out_cancel:
1120         if (unlink) {
1121                 if (is_dir)
1122                         inc_nlink(new_inode);
1123                 inc_nlink(new_inode);
1124         } else {
1125                 new_dir->i_size -= new_sz;
1126                 ubifs_inode(new_dir)->ui_size = new_dir->i_size;
1127         }
1128         old_dir->i_size += old_sz;
1129         ubifs_inode(old_dir)->ui_size = old_dir->i_size;
1130         if (is_dir) {
1131                 if (move) {
1132                         inc_nlink(old_dir);
1133                         if (!unlink)
1134                                 drop_nlink(new_dir);
1135                 } else {
1136                         if (unlink)
1137                                 inc_nlink(old_dir);
1138                 }
1139         }
1140         unlock_3_inodes(old_dir, new_dir, new_inode);
1141         ubifs_release_budget(c, &ino_req);
1142         ubifs_release_budget(c, &req);
1143         return err;
1144 }
1145
1146 int ubifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1147                   struct kstat *stat)
1148 {
1149         loff_t size;
1150         struct inode *inode = dentry->d_inode;
1151         struct ubifs_inode *ui = ubifs_inode(inode);
1152
1153         mutex_lock(&ui->ui_mutex);
1154         stat->dev = inode->i_sb->s_dev;
1155         stat->ino = inode->i_ino;
1156         stat->mode = inode->i_mode;
1157         stat->nlink = inode->i_nlink;
1158         stat->uid = inode->i_uid;
1159         stat->gid = inode->i_gid;
1160         stat->rdev = inode->i_rdev;
1161         stat->atime = inode->i_atime;
1162         stat->mtime = inode->i_mtime;
1163         stat->ctime = inode->i_ctime;
1164         stat->blksize = UBIFS_BLOCK_SIZE;
1165         stat->size = ui->ui_size;
1166
1167         /*
1168          * Unfortunately, the 'stat()' system call was designed for block
1169          * device based file systems, and it is not appropriate for UBIFS,
1170          * because UBIFS does not have notion of "block". For example, it is
1171          * difficult to tell how many block a directory takes - it actually
1172          * takes less than 300 bytes, but we have to round it to block size,
1173          * which introduces large mistake. This makes utilities like 'du' to
1174          * report completely senseless numbers. This is the reason why UBIFS
1175          * goes the same way as JFFS2 - it reports zero blocks for everything
1176          * but regular files, which makes more sense than reporting completely
1177          * wrong sizes.
1178          */
1179         if (S_ISREG(inode->i_mode)) {
1180                 size = ui->xattr_size;
1181                 size += stat->size;
1182                 size = ALIGN(size, UBIFS_BLOCK_SIZE);
1183                 /*
1184                  * Note, user-space expects 512-byte blocks count irrespectively
1185                  * of what was reported in @stat->size.
1186                  */
1187                 stat->blocks = size >> 9;
1188         } else
1189                 stat->blocks = 0;
1190         mutex_unlock(&ui->ui_mutex);
1191         return 0;
1192 }
1193
1194 const struct inode_operations ubifs_dir_inode_operations = {
1195         .lookup      = ubifs_lookup,
1196         .create      = ubifs_create,
1197         .link        = ubifs_link,
1198         .symlink     = ubifs_symlink,
1199         .unlink      = ubifs_unlink,
1200         .mkdir       = ubifs_mkdir,
1201         .rmdir       = ubifs_rmdir,
1202         .mknod       = ubifs_mknod,
1203         .rename      = ubifs_rename,
1204         .setattr     = ubifs_setattr,
1205         .getattr     = ubifs_getattr,
1206 #ifdef CONFIG_UBIFS_FS_XATTR
1207         .setxattr    = ubifs_setxattr,
1208         .getxattr    = ubifs_getxattr,
1209         .listxattr   = ubifs_listxattr,
1210         .removexattr = ubifs_removexattr,
1211 #endif
1212 };
1213
1214 const struct file_operations ubifs_dir_operations = {
1215         .llseek         = ubifs_dir_llseek,
1216         .release        = ubifs_dir_release,
1217         .read           = generic_read_dir,
1218         .readdir        = ubifs_readdir,
1219         .fsync          = ubifs_fsync,
1220         .unlocked_ioctl = ubifs_ioctl,
1221 #ifdef CONFIG_COMPAT
1222         .compat_ioctl   = ubifs_compat_ioctl,
1223 #endif
1224 };