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