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