Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...
[~shefty/rdma-dev.git] / fs / ubifs / super.c
1 /*
2  * This file is part of UBIFS.
3  *
4  * Copyright (C) 2006-2008 Nokia Corporation.
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  */
22
23 /*
24  * This file implements UBIFS initialization and VFS superblock operations. Some
25  * initialization stuff which is rather large and complex is placed at
26  * corresponding subsystems, but most of it is here.
27  */
28
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/module.h>
32 #include <linux/ctype.h>
33 #include <linux/kthread.h>
34 #include <linux/parser.h>
35 #include <linux/seq_file.h>
36 #include <linux/mount.h>
37 #include <linux/math64.h>
38 #include <linux/writeback.h>
39 #include "ubifs.h"
40
41 /*
42  * Maximum amount of memory we may 'kmalloc()' without worrying that we are
43  * allocating too much.
44  */
45 #define UBIFS_KMALLOC_OK (128*1024)
46
47 /* Slab cache for UBIFS inodes */
48 struct kmem_cache *ubifs_inode_slab;
49
50 /* UBIFS TNC shrinker description */
51 static struct shrinker ubifs_shrinker_info = {
52         .shrink = ubifs_shrinker,
53         .seeks = DEFAULT_SEEKS,
54 };
55
56 /**
57  * validate_inode - validate inode.
58  * @c: UBIFS file-system description object
59  * @inode: the inode to validate
60  *
61  * This is a helper function for 'ubifs_iget()' which validates various fields
62  * of a newly built inode to make sure they contain sane values and prevent
63  * possible vulnerabilities. Returns zero if the inode is all right and
64  * a non-zero error code if not.
65  */
66 static int validate_inode(struct ubifs_info *c, const struct inode *inode)
67 {
68         int err;
69         const struct ubifs_inode *ui = ubifs_inode(inode);
70
71         if (inode->i_size > c->max_inode_sz) {
72                 ubifs_err("inode is too large (%lld)",
73                           (long long)inode->i_size);
74                 return 1;
75         }
76
77         if (ui->compr_type < 0 || ui->compr_type >= UBIFS_COMPR_TYPES_CNT) {
78                 ubifs_err("unknown compression type %d", ui->compr_type);
79                 return 2;
80         }
81
82         if (ui->xattr_names + ui->xattr_cnt > XATTR_LIST_MAX)
83                 return 3;
84
85         if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA)
86                 return 4;
87
88         if (ui->xattr && (inode->i_mode & S_IFMT) != S_IFREG)
89                 return 5;
90
91         if (!ubifs_compr_present(ui->compr_type)) {
92                 ubifs_warn("inode %lu uses '%s' compression, but it was not "
93                            "compiled in", inode->i_ino,
94                            ubifs_compr_name(ui->compr_type));
95         }
96
97         err = dbg_check_dir_size(c, inode);
98         return err;
99 }
100
101 struct inode *ubifs_iget(struct super_block *sb, unsigned long inum)
102 {
103         int err;
104         union ubifs_key key;
105         struct ubifs_ino_node *ino;
106         struct ubifs_info *c = sb->s_fs_info;
107         struct inode *inode;
108         struct ubifs_inode *ui;
109
110         dbg_gen("inode %lu", inum);
111
112         inode = iget_locked(sb, inum);
113         if (!inode)
114                 return ERR_PTR(-ENOMEM);
115         if (!(inode->i_state & I_NEW))
116                 return inode;
117         ui = ubifs_inode(inode);
118
119         ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
120         if (!ino) {
121                 err = -ENOMEM;
122                 goto out;
123         }
124
125         ino_key_init(c, &key, inode->i_ino);
126
127         err = ubifs_tnc_lookup(c, &key, ino);
128         if (err)
129                 goto out_ino;
130
131         inode->i_flags |= (S_NOCMTIME | S_NOATIME);
132         inode->i_nlink = le32_to_cpu(ino->nlink);
133         inode->i_uid   = le32_to_cpu(ino->uid);
134         inode->i_gid   = le32_to_cpu(ino->gid);
135         inode->i_atime.tv_sec  = (int64_t)le64_to_cpu(ino->atime_sec);
136         inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec);
137         inode->i_mtime.tv_sec  = (int64_t)le64_to_cpu(ino->mtime_sec);
138         inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec);
139         inode->i_ctime.tv_sec  = (int64_t)le64_to_cpu(ino->ctime_sec);
140         inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec);
141         inode->i_mode = le32_to_cpu(ino->mode);
142         inode->i_size = le64_to_cpu(ino->size);
143
144         ui->data_len    = le32_to_cpu(ino->data_len);
145         ui->flags       = le32_to_cpu(ino->flags);
146         ui->compr_type  = le16_to_cpu(ino->compr_type);
147         ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum);
148         ui->xattr_cnt   = le32_to_cpu(ino->xattr_cnt);
149         ui->xattr_size  = le32_to_cpu(ino->xattr_size);
150         ui->xattr_names = le32_to_cpu(ino->xattr_names);
151         ui->synced_i_size = ui->ui_size = inode->i_size;
152
153         ui->xattr = (ui->flags & UBIFS_XATTR_FL) ? 1 : 0;
154
155         err = validate_inode(c, inode);
156         if (err)
157                 goto out_invalid;
158
159         /* Disable read-ahead */
160         inode->i_mapping->backing_dev_info = &c->bdi;
161
162         switch (inode->i_mode & S_IFMT) {
163         case S_IFREG:
164                 inode->i_mapping->a_ops = &ubifs_file_address_operations;
165                 inode->i_op = &ubifs_file_inode_operations;
166                 inode->i_fop = &ubifs_file_operations;
167                 if (ui->xattr) {
168                         ui->data = kmalloc(ui->data_len + 1, GFP_NOFS);
169                         if (!ui->data) {
170                                 err = -ENOMEM;
171                                 goto out_ino;
172                         }
173                         memcpy(ui->data, ino->data, ui->data_len);
174                         ((char *)ui->data)[ui->data_len] = '\0';
175                 } else if (ui->data_len != 0) {
176                         err = 10;
177                         goto out_invalid;
178                 }
179                 break;
180         case S_IFDIR:
181                 inode->i_op  = &ubifs_dir_inode_operations;
182                 inode->i_fop = &ubifs_dir_operations;
183                 if (ui->data_len != 0) {
184                         err = 11;
185                         goto out_invalid;
186                 }
187                 break;
188         case S_IFLNK:
189                 inode->i_op = &ubifs_symlink_inode_operations;
190                 if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) {
191                         err = 12;
192                         goto out_invalid;
193                 }
194                 ui->data = kmalloc(ui->data_len + 1, GFP_NOFS);
195                 if (!ui->data) {
196                         err = -ENOMEM;
197                         goto out_ino;
198                 }
199                 memcpy(ui->data, ino->data, ui->data_len);
200                 ((char *)ui->data)[ui->data_len] = '\0';
201                 break;
202         case S_IFBLK:
203         case S_IFCHR:
204         {
205                 dev_t rdev;
206                 union ubifs_dev_desc *dev;
207
208                 ui->data = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
209                 if (!ui->data) {
210                         err = -ENOMEM;
211                         goto out_ino;
212                 }
213
214                 dev = (union ubifs_dev_desc *)ino->data;
215                 if (ui->data_len == sizeof(dev->new))
216                         rdev = new_decode_dev(le32_to_cpu(dev->new));
217                 else if (ui->data_len == sizeof(dev->huge))
218                         rdev = huge_decode_dev(le64_to_cpu(dev->huge));
219                 else {
220                         err = 13;
221                         goto out_invalid;
222                 }
223                 memcpy(ui->data, ino->data, ui->data_len);
224                 inode->i_op = &ubifs_file_inode_operations;
225                 init_special_inode(inode, inode->i_mode, rdev);
226                 break;
227         }
228         case S_IFSOCK:
229         case S_IFIFO:
230                 inode->i_op = &ubifs_file_inode_operations;
231                 init_special_inode(inode, inode->i_mode, 0);
232                 if (ui->data_len != 0) {
233                         err = 14;
234                         goto out_invalid;
235                 }
236                 break;
237         default:
238                 err = 15;
239                 goto out_invalid;
240         }
241
242         kfree(ino);
243         ubifs_set_inode_flags(inode);
244         unlock_new_inode(inode);
245         return inode;
246
247 out_invalid:
248         ubifs_err("inode %lu validation failed, error %d", inode->i_ino, err);
249         dbg_dump_node(c, ino);
250         dbg_dump_inode(c, inode);
251         err = -EINVAL;
252 out_ino:
253         kfree(ino);
254 out:
255         ubifs_err("failed to read inode %lu, error %d", inode->i_ino, err);
256         iget_failed(inode);
257         return ERR_PTR(err);
258 }
259
260 static struct inode *ubifs_alloc_inode(struct super_block *sb)
261 {
262         struct ubifs_inode *ui;
263
264         ui = kmem_cache_alloc(ubifs_inode_slab, GFP_NOFS);
265         if (!ui)
266                 return NULL;
267
268         memset((void *)ui + sizeof(struct inode), 0,
269                sizeof(struct ubifs_inode) - sizeof(struct inode));
270         mutex_init(&ui->ui_mutex);
271         spin_lock_init(&ui->ui_lock);
272         return &ui->vfs_inode;
273 };
274
275 static void ubifs_destroy_inode(struct inode *inode)
276 {
277         struct ubifs_inode *ui = ubifs_inode(inode);
278
279         kfree(ui->data);
280         kmem_cache_free(ubifs_inode_slab, inode);
281 }
282
283 /*
284  * Note, Linux write-back code calls this without 'i_mutex'.
285  */
286 static int ubifs_write_inode(struct inode *inode, int wait)
287 {
288         int err = 0;
289         struct ubifs_info *c = inode->i_sb->s_fs_info;
290         struct ubifs_inode *ui = ubifs_inode(inode);
291
292         ubifs_assert(!ui->xattr);
293         if (is_bad_inode(inode))
294                 return 0;
295
296         mutex_lock(&ui->ui_mutex);
297         /*
298          * Due to races between write-back forced by budgeting
299          * (see 'sync_some_inodes()') and pdflush write-back, the inode may
300          * have already been synchronized, do not do this again. This might
301          * also happen if it was synchronized in an VFS operation, e.g.
302          * 'ubifs_link()'.
303          */
304         if (!ui->dirty) {
305                 mutex_unlock(&ui->ui_mutex);
306                 return 0;
307         }
308
309         /*
310          * As an optimization, do not write orphan inodes to the media just
311          * because this is not needed.
312          */
313         dbg_gen("inode %lu, mode %#x, nlink %u",
314                 inode->i_ino, (int)inode->i_mode, inode->i_nlink);
315         if (inode->i_nlink) {
316                 err = ubifs_jnl_write_inode(c, inode);
317                 if (err)
318                         ubifs_err("can't write inode %lu, error %d",
319                                   inode->i_ino, err);
320                 else
321                         err = dbg_check_inode_size(c, inode, ui->ui_size);
322         }
323
324         ui->dirty = 0;
325         mutex_unlock(&ui->ui_mutex);
326         ubifs_release_dirty_inode_budget(c, ui);
327         return err;
328 }
329
330 static void ubifs_delete_inode(struct inode *inode)
331 {
332         int err;
333         struct ubifs_info *c = inode->i_sb->s_fs_info;
334         struct ubifs_inode *ui = ubifs_inode(inode);
335
336         if (ui->xattr)
337                 /*
338                  * Extended attribute inode deletions are fully handled in
339                  * 'ubifs_removexattr()'. These inodes are special and have
340                  * limited usage, so there is nothing to do here.
341                  */
342                 goto out;
343
344         dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
345         ubifs_assert(!atomic_read(&inode->i_count));
346         ubifs_assert(inode->i_nlink == 0);
347
348         truncate_inode_pages(&inode->i_data, 0);
349         if (is_bad_inode(inode))
350                 goto out;
351
352         ui->ui_size = inode->i_size = 0;
353         err = ubifs_jnl_delete_inode(c, inode);
354         if (err)
355                 /*
356                  * Worst case we have a lost orphan inode wasting space, so a
357                  * simple error message is OK here.
358                  */
359                 ubifs_err("can't delete inode %lu, error %d",
360                           inode->i_ino, err);
361
362 out:
363         if (ui->dirty)
364                 ubifs_release_dirty_inode_budget(c, ui);
365         else {
366                 /* We've deleted something - clean the "no space" flags */
367                 c->nospace = c->nospace_rp = 0;
368                 smp_wmb();
369         }
370         clear_inode(inode);
371 }
372
373 static void ubifs_dirty_inode(struct inode *inode)
374 {
375         struct ubifs_inode *ui = ubifs_inode(inode);
376
377         ubifs_assert(mutex_is_locked(&ui->ui_mutex));
378         if (!ui->dirty) {
379                 ui->dirty = 1;
380                 dbg_gen("inode %lu",  inode->i_ino);
381         }
382 }
383
384 static int ubifs_statfs(struct dentry *dentry, struct kstatfs *buf)
385 {
386         struct ubifs_info *c = dentry->d_sb->s_fs_info;
387         unsigned long long free;
388         __le32 *uuid = (__le32 *)c->uuid;
389
390         free = ubifs_get_free_space(c);
391         dbg_gen("free space %lld bytes (%lld blocks)",
392                 free, free >> UBIFS_BLOCK_SHIFT);
393
394         buf->f_type = UBIFS_SUPER_MAGIC;
395         buf->f_bsize = UBIFS_BLOCK_SIZE;
396         buf->f_blocks = c->block_cnt;
397         buf->f_bfree = free >> UBIFS_BLOCK_SHIFT;
398         if (free > c->report_rp_size)
399                 buf->f_bavail = (free - c->report_rp_size) >> UBIFS_BLOCK_SHIFT;
400         else
401                 buf->f_bavail = 0;
402         buf->f_files = 0;
403         buf->f_ffree = 0;
404         buf->f_namelen = UBIFS_MAX_NLEN;
405         buf->f_fsid.val[0] = le32_to_cpu(uuid[0]) ^ le32_to_cpu(uuid[2]);
406         buf->f_fsid.val[1] = le32_to_cpu(uuid[1]) ^ le32_to_cpu(uuid[3]);
407         ubifs_assert(buf->f_bfree <= c->block_cnt);
408         return 0;
409 }
410
411 static int ubifs_show_options(struct seq_file *s, struct vfsmount *mnt)
412 {
413         struct ubifs_info *c = mnt->mnt_sb->s_fs_info;
414
415         if (c->mount_opts.unmount_mode == 2)
416                 seq_printf(s, ",fast_unmount");
417         else if (c->mount_opts.unmount_mode == 1)
418                 seq_printf(s, ",norm_unmount");
419
420         if (c->mount_opts.bulk_read == 2)
421                 seq_printf(s, ",bulk_read");
422         else if (c->mount_opts.bulk_read == 1)
423                 seq_printf(s, ",no_bulk_read");
424
425         if (c->mount_opts.chk_data_crc == 2)
426                 seq_printf(s, ",chk_data_crc");
427         else if (c->mount_opts.chk_data_crc == 1)
428                 seq_printf(s, ",no_chk_data_crc");
429
430         if (c->mount_opts.override_compr) {
431                 seq_printf(s, ",compr=%s",
432                            ubifs_compr_name(c->mount_opts.compr_type));
433         }
434
435         return 0;
436 }
437
438 static int ubifs_sync_fs(struct super_block *sb, int wait)
439 {
440         int i, err;
441         struct ubifs_info *c = sb->s_fs_info;
442
443         /*
444          * Zero @wait is just an advisory thing to help the file system shove
445          * lots of data into the queues, and there will be the second
446          * '->sync_fs()' call, with non-zero @wait.
447          */
448         if (!wait)
449                 return 0;
450
451         /*
452          * Synchronize write buffers, because 'ubifs_run_commit()' does not
453          * do this if it waits for an already running commit.
454          */
455         for (i = 0; i < c->jhead_cnt; i++) {
456                 err = ubifs_wbuf_sync(&c->jheads[i].wbuf);
457                 if (err)
458                         return err;
459         }
460
461         /*
462          * Strictly speaking, it is not necessary to commit the journal here,
463          * synchronizing write-buffers would be enough. But committing makes
464          * UBIFS free space predictions much more accurate, so we want to let
465          * the user be able to get more accurate results of 'statfs()' after
466          * they synchronize the file system.
467          */
468         err = ubifs_run_commit(c);
469         if (err)
470                 return err;
471
472         return ubi_sync(c->vi.ubi_num);
473 }
474
475 /**
476  * init_constants_early - initialize UBIFS constants.
477  * @c: UBIFS file-system description object
478  *
479  * This function initialize UBIFS constants which do not need the superblock to
480  * be read. It also checks that the UBI volume satisfies basic UBIFS
481  * requirements. Returns zero in case of success and a negative error code in
482  * case of failure.
483  */
484 static int init_constants_early(struct ubifs_info *c)
485 {
486         if (c->vi.corrupted) {
487                 ubifs_warn("UBI volume is corrupted - read-only mode");
488                 c->ro_media = 1;
489         }
490
491         if (c->di.ro_mode) {
492                 ubifs_msg("read-only UBI device");
493                 c->ro_media = 1;
494         }
495
496         if (c->vi.vol_type == UBI_STATIC_VOLUME) {
497                 ubifs_msg("static UBI volume - read-only mode");
498                 c->ro_media = 1;
499         }
500
501         c->leb_cnt = c->vi.size;
502         c->leb_size = c->vi.usable_leb_size;
503         c->half_leb_size = c->leb_size / 2;
504         c->min_io_size = c->di.min_io_size;
505         c->min_io_shift = fls(c->min_io_size) - 1;
506
507         if (c->leb_size < UBIFS_MIN_LEB_SZ) {
508                 ubifs_err("too small LEBs (%d bytes), min. is %d bytes",
509                           c->leb_size, UBIFS_MIN_LEB_SZ);
510                 return -EINVAL;
511         }
512
513         if (c->leb_cnt < UBIFS_MIN_LEB_CNT) {
514                 ubifs_err("too few LEBs (%d), min. is %d",
515                           c->leb_cnt, UBIFS_MIN_LEB_CNT);
516                 return -EINVAL;
517         }
518
519         if (!is_power_of_2(c->min_io_size)) {
520                 ubifs_err("bad min. I/O size %d", c->min_io_size);
521                 return -EINVAL;
522         }
523
524         /*
525          * UBIFS aligns all node to 8-byte boundary, so to make function in
526          * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is
527          * less than 8.
528          */
529         if (c->min_io_size < 8) {
530                 c->min_io_size = 8;
531                 c->min_io_shift = 3;
532         }
533
534         c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size);
535         c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size);
536
537         /*
538          * Initialize node length ranges which are mostly needed for node
539          * length validation.
540          */
541         c->ranges[UBIFS_PAD_NODE].len  = UBIFS_PAD_NODE_SZ;
542         c->ranges[UBIFS_SB_NODE].len   = UBIFS_SB_NODE_SZ;
543         c->ranges[UBIFS_MST_NODE].len  = UBIFS_MST_NODE_SZ;
544         c->ranges[UBIFS_REF_NODE].len  = UBIFS_REF_NODE_SZ;
545         c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ;
546         c->ranges[UBIFS_CS_NODE].len   = UBIFS_CS_NODE_SZ;
547
548         c->ranges[UBIFS_INO_NODE].min_len  = UBIFS_INO_NODE_SZ;
549         c->ranges[UBIFS_INO_NODE].max_len  = UBIFS_MAX_INO_NODE_SZ;
550         c->ranges[UBIFS_ORPH_NODE].min_len =
551                                 UBIFS_ORPH_NODE_SZ + sizeof(__le64);
552         c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size;
553         c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ;
554         c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ;
555         c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ;
556         c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ;
557         c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ;
558         c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ;
559         /*
560          * Minimum indexing node size is amended later when superblock is
561          * read and the key length is known.
562          */
563         c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ;
564         /*
565          * Maximum indexing node size is amended later when superblock is
566          * read and the fanout is known.
567          */
568         c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX;
569
570         /*
571          * Initialize dead and dark LEB space watermarks. See gc.c for comments
572          * about these values.
573          */
574         c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size);
575         c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size);
576
577         /*
578          * Calculate how many bytes would be wasted at the end of LEB if it was
579          * fully filled with data nodes of maximum size. This is used in
580          * calculations when reporting free space.
581          */
582         c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ;
583
584         /* Buffer size for bulk-reads */
585         c->max_bu_buf_len = UBIFS_MAX_BULK_READ * UBIFS_MAX_DATA_NODE_SZ;
586         if (c->max_bu_buf_len > c->leb_size)
587                 c->max_bu_buf_len = c->leb_size;
588         return 0;
589 }
590
591 /**
592  * bud_wbuf_callback - bud LEB write-buffer synchronization call-back.
593  * @c: UBIFS file-system description object
594  * @lnum: LEB the write-buffer was synchronized to
595  * @free: how many free bytes left in this LEB
596  * @pad: how many bytes were padded
597  *
598  * This is a callback function which is called by the I/O unit when the
599  * write-buffer is synchronized. We need this to correctly maintain space
600  * accounting in bud logical eraseblocks. This function returns zero in case of
601  * success and a negative error code in case of failure.
602  *
603  * This function actually belongs to the journal, but we keep it here because
604  * we want to keep it static.
605  */
606 static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad)
607 {
608         return ubifs_update_one_lp(c, lnum, free, pad, 0, 0);
609 }
610
611 /*
612  * init_constants_sb - initialize UBIFS constants.
613  * @c: UBIFS file-system description object
614  *
615  * This is a helper function which initializes various UBIFS constants after
616  * the superblock has been read. It also checks various UBIFS parameters and
617  * makes sure they are all right. Returns zero in case of success and a
618  * negative error code in case of failure.
619  */
620 static int init_constants_sb(struct ubifs_info *c)
621 {
622         int tmp, err;
623         long long tmp64;
624
625         c->main_bytes = (long long)c->main_lebs * c->leb_size;
626         c->max_znode_sz = sizeof(struct ubifs_znode) +
627                                 c->fanout * sizeof(struct ubifs_zbranch);
628
629         tmp = ubifs_idx_node_sz(c, 1);
630         c->ranges[UBIFS_IDX_NODE].min_len = tmp;
631         c->min_idx_node_sz = ALIGN(tmp, 8);
632
633         tmp = ubifs_idx_node_sz(c, c->fanout);
634         c->ranges[UBIFS_IDX_NODE].max_len = tmp;
635         c->max_idx_node_sz = ALIGN(tmp, 8);
636
637         /* Make sure LEB size is large enough to fit full commit */
638         tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt;
639         tmp = ALIGN(tmp, c->min_io_size);
640         if (tmp > c->leb_size) {
641                 dbg_err("too small LEB size %d, at least %d needed",
642                         c->leb_size, tmp);
643                 return -EINVAL;
644         }
645
646         /*
647          * Make sure that the log is large enough to fit reference nodes for
648          * all buds plus one reserved LEB.
649          */
650         tmp64 = c->max_bud_bytes + c->leb_size - 1;
651         c->max_bud_cnt = div_u64(tmp64, c->leb_size);
652         tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1);
653         tmp /= c->leb_size;
654         tmp += 1;
655         if (c->log_lebs < tmp) {
656                 dbg_err("too small log %d LEBs, required min. %d LEBs",
657                         c->log_lebs, tmp);
658                 return -EINVAL;
659         }
660
661         /*
662          * When budgeting we assume worst-case scenarios when the pages are not
663          * be compressed and direntries are of the maximum size.
664          *
665          * Note, data, which may be stored in inodes is budgeted separately, so
666          * it is not included into 'c->inode_budget'.
667          */
668         c->page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE;
669         c->inode_budget = UBIFS_INO_NODE_SZ;
670         c->dent_budget = UBIFS_MAX_DENT_NODE_SZ;
671
672         /*
673          * When the amount of flash space used by buds becomes
674          * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit.
675          * The writers are unblocked when the commit is finished. To avoid
676          * writers to be blocked UBIFS initiates background commit in advance,
677          * when number of bud bytes becomes above the limit defined below.
678          */
679         c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4;
680
681         /*
682          * Ensure minimum journal size. All the bytes in the journal heads are
683          * considered to be used, when calculating the current journal usage.
684          * Consequently, if the journal is too small, UBIFS will treat it as
685          * always full.
686          */
687         tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1;
688         if (c->bg_bud_bytes < tmp64)
689                 c->bg_bud_bytes = tmp64;
690         if (c->max_bud_bytes < tmp64 + c->leb_size)
691                 c->max_bud_bytes = tmp64 + c->leb_size;
692
693         err = ubifs_calc_lpt_geom(c);
694         if (err)
695                 return err;
696
697         /* Initialize effective LEB size used in budgeting calculations */
698         c->idx_leb_size = c->leb_size - c->max_idx_node_sz;
699         return 0;
700 }
701
702 /*
703  * init_constants_master - initialize UBIFS constants.
704  * @c: UBIFS file-system description object
705  *
706  * This is a helper function which initializes various UBIFS constants after
707  * the master node has been read. It also checks various UBIFS parameters and
708  * makes sure they are all right.
709  */
710 static void init_constants_master(struct ubifs_info *c)
711 {
712         long long tmp64;
713
714         c->min_idx_lebs = ubifs_calc_min_idx_lebs(c);
715         c->report_rp_size = ubifs_reported_space(c, c->rp_size);
716
717         /*
718          * Calculate total amount of FS blocks. This number is not used
719          * internally because it does not make much sense for UBIFS, but it is
720          * necessary to report something for the 'statfs()' call.
721          *
722          * Subtract the LEB reserved for GC, the LEB which is reserved for
723          * deletions, minimum LEBs for the index, and assume only one journal
724          * head is available.
725          */
726         tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1;
727         tmp64 *= (long long)c->leb_size - c->leb_overhead;
728         tmp64 = ubifs_reported_space(c, tmp64);
729         c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT;
730 }
731
732 /**
733  * take_gc_lnum - reserve GC LEB.
734  * @c: UBIFS file-system description object
735  *
736  * This function ensures that the LEB reserved for garbage collection is marked
737  * as "taken" in lprops. We also have to set free space to LEB size and dirty
738  * space to zero, because lprops may contain out-of-date information if the
739  * file-system was un-mounted before it has been committed. This function
740  * returns zero in case of success and a negative error code in case of
741  * failure.
742  */
743 static int take_gc_lnum(struct ubifs_info *c)
744 {
745         int err;
746
747         if (c->gc_lnum == -1) {
748                 ubifs_err("no LEB for GC");
749                 return -EINVAL;
750         }
751
752         /* And we have to tell lprops that this LEB is taken */
753         err = ubifs_change_one_lp(c, c->gc_lnum, c->leb_size, 0,
754                                   LPROPS_TAKEN, 0, 0);
755         return err;
756 }
757
758 /**
759  * alloc_wbufs - allocate write-buffers.
760  * @c: UBIFS file-system description object
761  *
762  * This helper function allocates and initializes UBIFS write-buffers. Returns
763  * zero in case of success and %-ENOMEM in case of failure.
764  */
765 static int alloc_wbufs(struct ubifs_info *c)
766 {
767         int i, err;
768
769         c->jheads = kzalloc(c->jhead_cnt * sizeof(struct ubifs_jhead),
770                            GFP_KERNEL);
771         if (!c->jheads)
772                 return -ENOMEM;
773
774         /* Initialize journal heads */
775         for (i = 0; i < c->jhead_cnt; i++) {
776                 INIT_LIST_HEAD(&c->jheads[i].buds_list);
777                 err = ubifs_wbuf_init(c, &c->jheads[i].wbuf);
778                 if (err)
779                         return err;
780
781                 c->jheads[i].wbuf.sync_callback = &bud_wbuf_callback;
782                 c->jheads[i].wbuf.jhead = i;
783         }
784
785         c->jheads[BASEHD].wbuf.dtype = UBI_SHORTTERM;
786         /*
787          * Garbage Collector head likely contains long-term data and
788          * does not need to be synchronized by timer.
789          */
790         c->jheads[GCHD].wbuf.dtype = UBI_LONGTERM;
791         c->jheads[GCHD].wbuf.no_timer = 1;
792
793         return 0;
794 }
795
796 /**
797  * free_wbufs - free write-buffers.
798  * @c: UBIFS file-system description object
799  */
800 static void free_wbufs(struct ubifs_info *c)
801 {
802         int i;
803
804         if (c->jheads) {
805                 for (i = 0; i < c->jhead_cnt; i++) {
806                         kfree(c->jheads[i].wbuf.buf);
807                         kfree(c->jheads[i].wbuf.inodes);
808                 }
809                 kfree(c->jheads);
810                 c->jheads = NULL;
811         }
812 }
813
814 /**
815  * free_orphans - free orphans.
816  * @c: UBIFS file-system description object
817  */
818 static void free_orphans(struct ubifs_info *c)
819 {
820         struct ubifs_orphan *orph;
821
822         while (c->orph_dnext) {
823                 orph = c->orph_dnext;
824                 c->orph_dnext = orph->dnext;
825                 list_del(&orph->list);
826                 kfree(orph);
827         }
828
829         while (!list_empty(&c->orph_list)) {
830                 orph = list_entry(c->orph_list.next, struct ubifs_orphan, list);
831                 list_del(&orph->list);
832                 kfree(orph);
833                 dbg_err("orphan list not empty at unmount");
834         }
835
836         vfree(c->orph_buf);
837         c->orph_buf = NULL;
838 }
839
840 /**
841  * free_buds - free per-bud objects.
842  * @c: UBIFS file-system description object
843  */
844 static void free_buds(struct ubifs_info *c)
845 {
846         struct rb_node *this = c->buds.rb_node;
847         struct ubifs_bud *bud;
848
849         while (this) {
850                 if (this->rb_left)
851                         this = this->rb_left;
852                 else if (this->rb_right)
853                         this = this->rb_right;
854                 else {
855                         bud = rb_entry(this, struct ubifs_bud, rb);
856                         this = rb_parent(this);
857                         if (this) {
858                                 if (this->rb_left == &bud->rb)
859                                         this->rb_left = NULL;
860                                 else
861                                         this->rb_right = NULL;
862                         }
863                         kfree(bud);
864                 }
865         }
866 }
867
868 /**
869  * check_volume_empty - check if the UBI volume is empty.
870  * @c: UBIFS file-system description object
871  *
872  * This function checks if the UBIFS volume is empty by looking if its LEBs are
873  * mapped or not. The result of checking is stored in the @c->empty variable.
874  * Returns zero in case of success and a negative error code in case of
875  * failure.
876  */
877 static int check_volume_empty(struct ubifs_info *c)
878 {
879         int lnum, err;
880
881         c->empty = 1;
882         for (lnum = 0; lnum < c->leb_cnt; lnum++) {
883                 err = ubi_is_mapped(c->ubi, lnum);
884                 if (unlikely(err < 0))
885                         return err;
886                 if (err == 1) {
887                         c->empty = 0;
888                         break;
889                 }
890
891                 cond_resched();
892         }
893
894         return 0;
895 }
896
897 /*
898  * UBIFS mount options.
899  *
900  * Opt_fast_unmount: do not run a journal commit before un-mounting
901  * Opt_norm_unmount: run a journal commit before un-mounting
902  * Opt_bulk_read: enable bulk-reads
903  * Opt_no_bulk_read: disable bulk-reads
904  * Opt_chk_data_crc: check CRCs when reading data nodes
905  * Opt_no_chk_data_crc: do not check CRCs when reading data nodes
906  * Opt_override_compr: override default compressor
907  * Opt_err: just end of array marker
908  */
909 enum {
910         Opt_fast_unmount,
911         Opt_norm_unmount,
912         Opt_bulk_read,
913         Opt_no_bulk_read,
914         Opt_chk_data_crc,
915         Opt_no_chk_data_crc,
916         Opt_override_compr,
917         Opt_err,
918 };
919
920 static const match_table_t tokens = {
921         {Opt_fast_unmount, "fast_unmount"},
922         {Opt_norm_unmount, "norm_unmount"},
923         {Opt_bulk_read, "bulk_read"},
924         {Opt_no_bulk_read, "no_bulk_read"},
925         {Opt_chk_data_crc, "chk_data_crc"},
926         {Opt_no_chk_data_crc, "no_chk_data_crc"},
927         {Opt_override_compr, "compr=%s"},
928         {Opt_err, NULL},
929 };
930
931 /**
932  * parse_standard_option - parse a standard mount option.
933  * @option: the option to parse
934  *
935  * Normally, standard mount options like "sync" are passed to file-systems as
936  * flags. However, when a "rootflags=" kernel boot parameter is used, they may
937  * be present in the options string. This function tries to deal with this
938  * situation and parse standard options. Returns 0 if the option was not
939  * recognized, and the corresponding integer flag if it was.
940  *
941  * UBIFS is only interested in the "sync" option, so do not check for anything
942  * else.
943  */
944 static int parse_standard_option(const char *option)
945 {
946         ubifs_msg("parse %s", option);
947         if (!strcmp(option, "sync"))
948                 return MS_SYNCHRONOUS;
949         return 0;
950 }
951
952 /**
953  * ubifs_parse_options - parse mount parameters.
954  * @c: UBIFS file-system description object
955  * @options: parameters to parse
956  * @is_remount: non-zero if this is FS re-mount
957  *
958  * This function parses UBIFS mount options and returns zero in case success
959  * and a negative error code in case of failure.
960  */
961 static int ubifs_parse_options(struct ubifs_info *c, char *options,
962                                int is_remount)
963 {
964         char *p;
965         substring_t args[MAX_OPT_ARGS];
966
967         if (!options)
968                 return 0;
969
970         while ((p = strsep(&options, ","))) {
971                 int token;
972
973                 if (!*p)
974                         continue;
975
976                 token = match_token(p, tokens, args);
977                 switch (token) {
978                 /*
979                  * %Opt_fast_unmount and %Opt_norm_unmount options are ignored.
980                  * We accept them in order to be backward-compatible. But this
981                  * should be removed at some point.
982                  */
983                 case Opt_fast_unmount:
984                         c->mount_opts.unmount_mode = 2;
985                         break;
986                 case Opt_norm_unmount:
987                         c->mount_opts.unmount_mode = 1;
988                         break;
989                 case Opt_bulk_read:
990                         c->mount_opts.bulk_read = 2;
991                         c->bulk_read = 1;
992                         break;
993                 case Opt_no_bulk_read:
994                         c->mount_opts.bulk_read = 1;
995                         c->bulk_read = 0;
996                         break;
997                 case Opt_chk_data_crc:
998                         c->mount_opts.chk_data_crc = 2;
999                         c->no_chk_data_crc = 0;
1000                         break;
1001                 case Opt_no_chk_data_crc:
1002                         c->mount_opts.chk_data_crc = 1;
1003                         c->no_chk_data_crc = 1;
1004                         break;
1005                 case Opt_override_compr:
1006                 {
1007                         char *name = match_strdup(&args[0]);
1008
1009                         if (!name)
1010                                 return -ENOMEM;
1011                         if (!strcmp(name, "none"))
1012                                 c->mount_opts.compr_type = UBIFS_COMPR_NONE;
1013                         else if (!strcmp(name, "lzo"))
1014                                 c->mount_opts.compr_type = UBIFS_COMPR_LZO;
1015                         else if (!strcmp(name, "zlib"))
1016                                 c->mount_opts.compr_type = UBIFS_COMPR_ZLIB;
1017                         else {
1018                                 ubifs_err("unknown compressor \"%s\"", name);
1019                                 kfree(name);
1020                                 return -EINVAL;
1021                         }
1022                         kfree(name);
1023                         c->mount_opts.override_compr = 1;
1024                         c->default_compr = c->mount_opts.compr_type;
1025                         break;
1026                 }
1027                 default:
1028                 {
1029                         unsigned long flag;
1030                         struct super_block *sb = c->vfs_sb;
1031
1032                         flag = parse_standard_option(p);
1033                         if (!flag) {
1034                                 ubifs_err("unrecognized mount option \"%s\" "
1035                                           "or missing value", p);
1036                                 return -EINVAL;
1037                         }
1038                         sb->s_flags |= flag;
1039                         break;
1040                 }
1041                 }
1042         }
1043
1044         return 0;
1045 }
1046
1047 /**
1048  * destroy_journal - destroy journal data structures.
1049  * @c: UBIFS file-system description object
1050  *
1051  * This function destroys journal data structures including those that may have
1052  * been created by recovery functions.
1053  */
1054 static void destroy_journal(struct ubifs_info *c)
1055 {
1056         while (!list_empty(&c->unclean_leb_list)) {
1057                 struct ubifs_unclean_leb *ucleb;
1058
1059                 ucleb = list_entry(c->unclean_leb_list.next,
1060                                    struct ubifs_unclean_leb, list);
1061                 list_del(&ucleb->list);
1062                 kfree(ucleb);
1063         }
1064         while (!list_empty(&c->old_buds)) {
1065                 struct ubifs_bud *bud;
1066
1067                 bud = list_entry(c->old_buds.next, struct ubifs_bud, list);
1068                 list_del(&bud->list);
1069                 kfree(bud);
1070         }
1071         ubifs_destroy_idx_gc(c);
1072         ubifs_destroy_size_tree(c);
1073         ubifs_tnc_close(c);
1074         free_buds(c);
1075 }
1076
1077 /**
1078  * bu_init - initialize bulk-read information.
1079  * @c: UBIFS file-system description object
1080  */
1081 static void bu_init(struct ubifs_info *c)
1082 {
1083         ubifs_assert(c->bulk_read == 1);
1084
1085         if (c->bu.buf)
1086                 return; /* Already initialized */
1087
1088 again:
1089         c->bu.buf = kmalloc(c->max_bu_buf_len, GFP_KERNEL | __GFP_NOWARN);
1090         if (!c->bu.buf) {
1091                 if (c->max_bu_buf_len > UBIFS_KMALLOC_OK) {
1092                         c->max_bu_buf_len = UBIFS_KMALLOC_OK;
1093                         goto again;
1094                 }
1095
1096                 /* Just disable bulk-read */
1097                 ubifs_warn("Cannot allocate %d bytes of memory for bulk-read, "
1098                            "disabling it", c->max_bu_buf_len);
1099                 c->mount_opts.bulk_read = 1;
1100                 c->bulk_read = 0;
1101                 return;
1102         }
1103 }
1104
1105 /**
1106  * check_free_space - check if there is enough free space to mount.
1107  * @c: UBIFS file-system description object
1108  *
1109  * This function makes sure UBIFS has enough free space to be mounted in
1110  * read/write mode. UBIFS must always have some free space to allow deletions.
1111  */
1112 static int check_free_space(struct ubifs_info *c)
1113 {
1114         ubifs_assert(c->dark_wm > 0);
1115         if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) {
1116                 ubifs_err("insufficient free space to mount in read/write mode");
1117                 dbg_dump_budg(c);
1118                 dbg_dump_lprops(c);
1119                 return -ENOSPC;
1120         }
1121         return 0;
1122 }
1123
1124 /**
1125  * mount_ubifs - mount UBIFS file-system.
1126  * @c: UBIFS file-system description object
1127  *
1128  * This function mounts UBIFS file system. Returns zero in case of success and
1129  * a negative error code in case of failure.
1130  *
1131  * Note, the function does not de-allocate resources it it fails half way
1132  * through, and the caller has to do this instead.
1133  */
1134 static int mount_ubifs(struct ubifs_info *c)
1135 {
1136         struct super_block *sb = c->vfs_sb;
1137         int err, mounted_read_only = (sb->s_flags & MS_RDONLY);
1138         long long x;
1139         size_t sz;
1140
1141         err = init_constants_early(c);
1142         if (err)
1143                 return err;
1144
1145         err = ubifs_debugging_init(c);
1146         if (err)
1147                 return err;
1148
1149         err = check_volume_empty(c);
1150         if (err)
1151                 goto out_free;
1152
1153         if (c->empty && (mounted_read_only || c->ro_media)) {
1154                 /*
1155                  * This UBI volume is empty, and read-only, or the file system
1156                  * is mounted read-only - we cannot format it.
1157                  */
1158                 ubifs_err("can't format empty UBI volume: read-only %s",
1159                           c->ro_media ? "UBI volume" : "mount");
1160                 err = -EROFS;
1161                 goto out_free;
1162         }
1163
1164         if (c->ro_media && !mounted_read_only) {
1165                 ubifs_err("cannot mount read-write - read-only media");
1166                 err = -EROFS;
1167                 goto out_free;
1168         }
1169
1170         /*
1171          * The requirement for the buffer is that it should fit indexing B-tree
1172          * height amount of integers. We assume the height if the TNC tree will
1173          * never exceed 64.
1174          */
1175         err = -ENOMEM;
1176         c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL);
1177         if (!c->bottom_up_buf)
1178                 goto out_free;
1179
1180         c->sbuf = vmalloc(c->leb_size);
1181         if (!c->sbuf)
1182                 goto out_free;
1183
1184         if (!mounted_read_only) {
1185                 c->ileb_buf = vmalloc(c->leb_size);
1186                 if (!c->ileb_buf)
1187                         goto out_free;
1188         }
1189
1190         if (c->bulk_read == 1)
1191                 bu_init(c);
1192
1193         /*
1194          * We have to check all CRCs, even for data nodes, when we mount the FS
1195          * (specifically, when we are replaying).
1196          */
1197         c->always_chk_crc = 1;
1198
1199         err = ubifs_read_superblock(c);
1200         if (err)
1201                 goto out_free;
1202
1203         /*
1204          * Make sure the compressor which is set as default in the superblock
1205          * or overridden by mount options is actually compiled in.
1206          */
1207         if (!ubifs_compr_present(c->default_compr)) {
1208                 ubifs_err("'compressor \"%s\" is not compiled in",
1209                           ubifs_compr_name(c->default_compr));
1210                 err = -ENOTSUPP;
1211                 goto out_free;
1212         }
1213
1214         err = init_constants_sb(c);
1215         if (err)
1216                 goto out_free;
1217
1218         sz = ALIGN(c->max_idx_node_sz, c->min_io_size);
1219         sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size);
1220         c->cbuf = kmalloc(sz, GFP_NOFS);
1221         if (!c->cbuf) {
1222                 err = -ENOMEM;
1223                 goto out_free;
1224         }
1225
1226         sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id);
1227         if (!mounted_read_only) {
1228                 err = alloc_wbufs(c);
1229                 if (err)
1230                         goto out_cbuf;
1231
1232                 /* Create background thread */
1233                 c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name);
1234                 if (IS_ERR(c->bgt)) {
1235                         err = PTR_ERR(c->bgt);
1236                         c->bgt = NULL;
1237                         ubifs_err("cannot spawn \"%s\", error %d",
1238                                   c->bgt_name, err);
1239                         goto out_wbufs;
1240                 }
1241                 wake_up_process(c->bgt);
1242         }
1243
1244         err = ubifs_read_master(c);
1245         if (err)
1246                 goto out_master;
1247
1248         init_constants_master(c);
1249
1250         if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) {
1251                 ubifs_msg("recovery needed");
1252                 c->need_recovery = 1;
1253                 if (!mounted_read_only) {
1254                         err = ubifs_recover_inl_heads(c, c->sbuf);
1255                         if (err)
1256                                 goto out_master;
1257                 }
1258         } else if (!mounted_read_only) {
1259                 /*
1260                  * Set the "dirty" flag so that if we reboot uncleanly we
1261                  * will notice this immediately on the next mount.
1262                  */
1263                 c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY);
1264                 err = ubifs_write_master(c);
1265                 if (err)
1266                         goto out_master;
1267         }
1268
1269         err = ubifs_lpt_init(c, 1, !mounted_read_only);
1270         if (err)
1271                 goto out_lpt;
1272
1273         err = dbg_check_idx_size(c, c->old_idx_sz);
1274         if (err)
1275                 goto out_lpt;
1276
1277         err = ubifs_replay_journal(c);
1278         if (err)
1279                 goto out_journal;
1280
1281         /* Calculate 'min_idx_lebs' after journal replay */
1282         c->min_idx_lebs = ubifs_calc_min_idx_lebs(c);
1283
1284         err = ubifs_mount_orphans(c, c->need_recovery, mounted_read_only);
1285         if (err)
1286                 goto out_orphans;
1287
1288         if (!mounted_read_only) {
1289                 int lnum;
1290
1291                 err = check_free_space(c);
1292                 if (err)
1293                         goto out_orphans;
1294
1295                 /* Check for enough log space */
1296                 lnum = c->lhead_lnum + 1;
1297                 if (lnum >= UBIFS_LOG_LNUM + c->log_lebs)
1298                         lnum = UBIFS_LOG_LNUM;
1299                 if (lnum == c->ltail_lnum) {
1300                         err = ubifs_consolidate_log(c);
1301                         if (err)
1302                                 goto out_orphans;
1303                 }
1304
1305                 if (c->need_recovery) {
1306                         err = ubifs_recover_size(c);
1307                         if (err)
1308                                 goto out_orphans;
1309                         err = ubifs_rcvry_gc_commit(c);
1310                 } else {
1311                         err = take_gc_lnum(c);
1312                         if (err)
1313                                 goto out_orphans;
1314
1315                         /*
1316                          * GC LEB may contain garbage if there was an unclean
1317                          * reboot, and it should be un-mapped.
1318                          */
1319                         err = ubifs_leb_unmap(c, c->gc_lnum);
1320                         if (err)
1321                                 return err;
1322                 }
1323
1324                 err = dbg_check_lprops(c);
1325                 if (err)
1326                         goto out_orphans;
1327         } else if (c->need_recovery) {
1328                 err = ubifs_recover_size(c);
1329                 if (err)
1330                         goto out_orphans;
1331         } else {
1332                 /*
1333                  * Even if we mount read-only, we have to set space in GC LEB
1334                  * to proper value because this affects UBIFS free space
1335                  * reporting. We do not want to have a situation when
1336                  * re-mounting from R/O to R/W changes amount of free space.
1337                  */
1338                 err = take_gc_lnum(c);
1339                 if (err)
1340                         goto out_orphans;
1341         }
1342
1343         spin_lock(&ubifs_infos_lock);
1344         list_add_tail(&c->infos_list, &ubifs_infos);
1345         spin_unlock(&ubifs_infos_lock);
1346
1347         if (c->need_recovery) {
1348                 if (mounted_read_only)
1349                         ubifs_msg("recovery deferred");
1350                 else {
1351                         c->need_recovery = 0;
1352                         ubifs_msg("recovery completed");
1353                         /*
1354                          * GC LEB has to be empty and taken at this point. But
1355                          * the journal head LEBs may also be accounted as
1356                          * "empty taken" if they are empty.
1357                          */
1358                         ubifs_assert(c->lst.taken_empty_lebs > 0);
1359                 }
1360         } else
1361                 ubifs_assert(c->lst.taken_empty_lebs > 0);
1362
1363         err = dbg_check_filesystem(c);
1364         if (err)
1365                 goto out_infos;
1366
1367         err = dbg_debugfs_init_fs(c);
1368         if (err)
1369                 goto out_infos;
1370
1371         c->always_chk_crc = 0;
1372
1373         ubifs_msg("mounted UBI device %d, volume %d, name \"%s\"",
1374                   c->vi.ubi_num, c->vi.vol_id, c->vi.name);
1375         if (mounted_read_only)
1376                 ubifs_msg("mounted read-only");
1377         x = (long long)c->main_lebs * c->leb_size;
1378         ubifs_msg("file system size:   %lld bytes (%lld KiB, %lld MiB, %d "
1379                   "LEBs)", x, x >> 10, x >> 20, c->main_lebs);
1380         x = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes;
1381         ubifs_msg("journal size:       %lld bytes (%lld KiB, %lld MiB, %d "
1382                   "LEBs)", x, x >> 10, x >> 20, c->log_lebs + c->max_bud_cnt);
1383         ubifs_msg("media format:       w%d/r%d (latest is w%d/r%d)",
1384                   c->fmt_version, c->ro_compat_version,
1385                   UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION);
1386         ubifs_msg("default compressor: %s", ubifs_compr_name(c->default_compr));
1387         ubifs_msg("reserved for root:  %llu bytes (%llu KiB)",
1388                 c->report_rp_size, c->report_rp_size >> 10);
1389
1390         dbg_msg("compiled on:         " __DATE__ " at " __TIME__);
1391         dbg_msg("min. I/O unit size:  %d bytes", c->min_io_size);
1392         dbg_msg("LEB size:            %d bytes (%d KiB)",
1393                 c->leb_size, c->leb_size >> 10);
1394         dbg_msg("data journal heads:  %d",
1395                 c->jhead_cnt - NONDATA_JHEADS_CNT);
1396         dbg_msg("UUID:                %02X%02X%02X%02X-%02X%02X"
1397                "-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
1398                c->uuid[0], c->uuid[1], c->uuid[2], c->uuid[3],
1399                c->uuid[4], c->uuid[5], c->uuid[6], c->uuid[7],
1400                c->uuid[8], c->uuid[9], c->uuid[10], c->uuid[11],
1401                c->uuid[12], c->uuid[13], c->uuid[14], c->uuid[15]);
1402         dbg_msg("big_lpt              %d", c->big_lpt);
1403         dbg_msg("log LEBs:            %d (%d - %d)",
1404                 c->log_lebs, UBIFS_LOG_LNUM, c->log_last);
1405         dbg_msg("LPT area LEBs:       %d (%d - %d)",
1406                 c->lpt_lebs, c->lpt_first, c->lpt_last);
1407         dbg_msg("orphan area LEBs:    %d (%d - %d)",
1408                 c->orph_lebs, c->orph_first, c->orph_last);
1409         dbg_msg("main area LEBs:      %d (%d - %d)",
1410                 c->main_lebs, c->main_first, c->leb_cnt - 1);
1411         dbg_msg("index LEBs:          %d", c->lst.idx_lebs);
1412         dbg_msg("total index bytes:   %lld (%lld KiB, %lld MiB)",
1413                 c->old_idx_sz, c->old_idx_sz >> 10, c->old_idx_sz >> 20);
1414         dbg_msg("key hash type:       %d", c->key_hash_type);
1415         dbg_msg("tree fanout:         %d", c->fanout);
1416         dbg_msg("reserved GC LEB:     %d", c->gc_lnum);
1417         dbg_msg("first main LEB:      %d", c->main_first);
1418         dbg_msg("max. znode size      %d", c->max_znode_sz);
1419         dbg_msg("max. index node size %d", c->max_idx_node_sz);
1420         dbg_msg("node sizes:          data %zu, inode %zu, dentry %zu",
1421                 UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ);
1422         dbg_msg("node sizes:          trun %zu, sb %zu, master %zu",
1423                 UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ);
1424         dbg_msg("node sizes:          ref %zu, cmt. start %zu, orph %zu",
1425                 UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ);
1426         dbg_msg("max. node sizes:     data %zu, inode %zu dentry %zu",
1427                 UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ,
1428                 UBIFS_MAX_DENT_NODE_SZ);
1429         dbg_msg("dead watermark:      %d", c->dead_wm);
1430         dbg_msg("dark watermark:      %d", c->dark_wm);
1431         dbg_msg("LEB overhead:        %d", c->leb_overhead);
1432         x = (long long)c->main_lebs * c->dark_wm;
1433         dbg_msg("max. dark space:     %lld (%lld KiB, %lld MiB)",
1434                 x, x >> 10, x >> 20);
1435         dbg_msg("maximum bud bytes:   %lld (%lld KiB, %lld MiB)",
1436                 c->max_bud_bytes, c->max_bud_bytes >> 10,
1437                 c->max_bud_bytes >> 20);
1438         dbg_msg("BG commit bud bytes: %lld (%lld KiB, %lld MiB)",
1439                 c->bg_bud_bytes, c->bg_bud_bytes >> 10,
1440                 c->bg_bud_bytes >> 20);
1441         dbg_msg("current bud bytes    %lld (%lld KiB, %lld MiB)",
1442                 c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20);
1443         dbg_msg("max. seq. number:    %llu", c->max_sqnum);
1444         dbg_msg("commit number:       %llu", c->cmt_no);
1445
1446         return 0;
1447
1448 out_infos:
1449         spin_lock(&ubifs_infos_lock);
1450         list_del(&c->infos_list);
1451         spin_unlock(&ubifs_infos_lock);
1452 out_orphans:
1453         free_orphans(c);
1454 out_journal:
1455         destroy_journal(c);
1456 out_lpt:
1457         ubifs_lpt_free(c, 0);
1458 out_master:
1459         kfree(c->mst_node);
1460         kfree(c->rcvrd_mst_node);
1461         if (c->bgt)
1462                 kthread_stop(c->bgt);
1463 out_wbufs:
1464         free_wbufs(c);
1465 out_cbuf:
1466         kfree(c->cbuf);
1467 out_free:
1468         kfree(c->bu.buf);
1469         vfree(c->ileb_buf);
1470         vfree(c->sbuf);
1471         kfree(c->bottom_up_buf);
1472         ubifs_debugging_exit(c);
1473         return err;
1474 }
1475
1476 /**
1477  * ubifs_umount - un-mount UBIFS file-system.
1478  * @c: UBIFS file-system description object
1479  *
1480  * Note, this function is called to free allocated resourced when un-mounting,
1481  * as well as free resources when an error occurred while we were half way
1482  * through mounting (error path cleanup function). So it has to make sure the
1483  * resource was actually allocated before freeing it.
1484  */
1485 static void ubifs_umount(struct ubifs_info *c)
1486 {
1487         dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num,
1488                 c->vi.vol_id);
1489
1490         dbg_debugfs_exit_fs(c);
1491         spin_lock(&ubifs_infos_lock);
1492         list_del(&c->infos_list);
1493         spin_unlock(&ubifs_infos_lock);
1494
1495         if (c->bgt)
1496                 kthread_stop(c->bgt);
1497
1498         destroy_journal(c);
1499         free_wbufs(c);
1500         free_orphans(c);
1501         ubifs_lpt_free(c, 0);
1502
1503         kfree(c->cbuf);
1504         kfree(c->rcvrd_mst_node);
1505         kfree(c->mst_node);
1506         kfree(c->bu.buf);
1507         vfree(c->ileb_buf);
1508         vfree(c->sbuf);
1509         kfree(c->bottom_up_buf);
1510         ubifs_debugging_exit(c);
1511 }
1512
1513 /**
1514  * ubifs_remount_rw - re-mount in read-write mode.
1515  * @c: UBIFS file-system description object
1516  *
1517  * UBIFS avoids allocating many unnecessary resources when mounted in read-only
1518  * mode. This function allocates the needed resources and re-mounts UBIFS in
1519  * read-write mode.
1520  */
1521 static int ubifs_remount_rw(struct ubifs_info *c)
1522 {
1523         int err, lnum;
1524
1525         if (c->rw_incompat) {
1526                 ubifs_err("the file-system is not R/W-compatible");
1527                 ubifs_msg("on-flash format version is w%d/r%d, but software "
1528                           "only supports up to version w%d/r%d", c->fmt_version,
1529                           c->ro_compat_version, UBIFS_FORMAT_VERSION,
1530                           UBIFS_RO_COMPAT_VERSION);
1531                 return -EROFS;
1532         }
1533
1534         mutex_lock(&c->umount_mutex);
1535         dbg_save_space_info(c);
1536         c->remounting_rw = 1;
1537         c->always_chk_crc = 1;
1538
1539         err = check_free_space(c);
1540         if (err)
1541                 goto out;
1542
1543         if (c->old_leb_cnt != c->leb_cnt) {
1544                 struct ubifs_sb_node *sup;
1545
1546                 sup = ubifs_read_sb_node(c);
1547                 if (IS_ERR(sup)) {
1548                         err = PTR_ERR(sup);
1549                         goto out;
1550                 }
1551                 sup->leb_cnt = cpu_to_le32(c->leb_cnt);
1552                 err = ubifs_write_sb_node(c, sup);
1553                 if (err)
1554                         goto out;
1555         }
1556
1557         if (c->need_recovery) {
1558                 ubifs_msg("completing deferred recovery");
1559                 err = ubifs_write_rcvrd_mst_node(c);
1560                 if (err)
1561                         goto out;
1562                 err = ubifs_recover_size(c);
1563                 if (err)
1564                         goto out;
1565                 err = ubifs_clean_lebs(c, c->sbuf);
1566                 if (err)
1567                         goto out;
1568                 err = ubifs_recover_inl_heads(c, c->sbuf);
1569                 if (err)
1570                         goto out;
1571         } else {
1572                 /* A readonly mount is not allowed to have orphans */
1573                 ubifs_assert(c->tot_orphans == 0);
1574                 err = ubifs_clear_orphans(c);
1575                 if (err)
1576                         goto out;
1577         }
1578
1579         if (!(c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY))) {
1580                 c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY);
1581                 err = ubifs_write_master(c);
1582                 if (err)
1583                         goto out;
1584         }
1585
1586         c->ileb_buf = vmalloc(c->leb_size);
1587         if (!c->ileb_buf) {
1588                 err = -ENOMEM;
1589                 goto out;
1590         }
1591
1592         err = ubifs_lpt_init(c, 0, 1);
1593         if (err)
1594                 goto out;
1595
1596         err = alloc_wbufs(c);
1597         if (err)
1598                 goto out;
1599
1600         ubifs_create_buds_lists(c);
1601
1602         /* Create background thread */
1603         c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name);
1604         if (IS_ERR(c->bgt)) {
1605                 err = PTR_ERR(c->bgt);
1606                 c->bgt = NULL;
1607                 ubifs_err("cannot spawn \"%s\", error %d",
1608                           c->bgt_name, err);
1609                 goto out;
1610         }
1611         wake_up_process(c->bgt);
1612
1613         c->orph_buf = vmalloc(c->leb_size);
1614         if (!c->orph_buf) {
1615                 err = -ENOMEM;
1616                 goto out;
1617         }
1618
1619         /* Check for enough log space */
1620         lnum = c->lhead_lnum + 1;
1621         if (lnum >= UBIFS_LOG_LNUM + c->log_lebs)
1622                 lnum = UBIFS_LOG_LNUM;
1623         if (lnum == c->ltail_lnum) {
1624                 err = ubifs_consolidate_log(c);
1625                 if (err)
1626                         goto out;
1627         }
1628
1629         if (c->need_recovery)
1630                 err = ubifs_rcvry_gc_commit(c);
1631         else
1632                 err = ubifs_leb_unmap(c, c->gc_lnum);
1633         if (err)
1634                 goto out;
1635
1636         if (c->need_recovery) {
1637                 c->need_recovery = 0;
1638                 ubifs_msg("deferred recovery completed");
1639         }
1640
1641         dbg_gen("re-mounted read-write");
1642         c->vfs_sb->s_flags &= ~MS_RDONLY;
1643         c->remounting_rw = 0;
1644         c->always_chk_crc = 0;
1645         err = dbg_check_space_info(c);
1646         mutex_unlock(&c->umount_mutex);
1647         return err;
1648
1649 out:
1650         vfree(c->orph_buf);
1651         c->orph_buf = NULL;
1652         if (c->bgt) {
1653                 kthread_stop(c->bgt);
1654                 c->bgt = NULL;
1655         }
1656         free_wbufs(c);
1657         vfree(c->ileb_buf);
1658         c->ileb_buf = NULL;
1659         ubifs_lpt_free(c, 1);
1660         c->remounting_rw = 0;
1661         c->always_chk_crc = 0;
1662         mutex_unlock(&c->umount_mutex);
1663         return err;
1664 }
1665
1666 /**
1667  * ubifs_remount_ro - re-mount in read-only mode.
1668  * @c: UBIFS file-system description object
1669  *
1670  * We assume VFS has stopped writing. Possibly the background thread could be
1671  * running a commit, however kthread_stop will wait in that case.
1672  */
1673 static void ubifs_remount_ro(struct ubifs_info *c)
1674 {
1675         int i, err;
1676
1677         ubifs_assert(!c->need_recovery);
1678         ubifs_assert(!(c->vfs_sb->s_flags & MS_RDONLY));
1679
1680         mutex_lock(&c->umount_mutex);
1681         if (c->bgt) {
1682                 kthread_stop(c->bgt);
1683                 c->bgt = NULL;
1684         }
1685
1686         dbg_save_space_info(c);
1687
1688         for (i = 0; i < c->jhead_cnt; i++) {
1689                 ubifs_wbuf_sync(&c->jheads[i].wbuf);
1690                 hrtimer_cancel(&c->jheads[i].wbuf.timer);
1691         }
1692
1693         c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY);
1694         c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS);
1695         c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum);
1696         err = ubifs_write_master(c);
1697         if (err)
1698                 ubifs_ro_mode(c, err);
1699
1700         free_wbufs(c);
1701         vfree(c->orph_buf);
1702         c->orph_buf = NULL;
1703         vfree(c->ileb_buf);
1704         c->ileb_buf = NULL;
1705         ubifs_lpt_free(c, 1);
1706         err = dbg_check_space_info(c);
1707         if (err)
1708                 ubifs_ro_mode(c, err);
1709         mutex_unlock(&c->umount_mutex);
1710 }
1711
1712 static void ubifs_put_super(struct super_block *sb)
1713 {
1714         int i;
1715         struct ubifs_info *c = sb->s_fs_info;
1716
1717         ubifs_msg("un-mount UBI device %d, volume %d", c->vi.ubi_num,
1718                   c->vi.vol_id);
1719
1720         /*
1721          * The following asserts are only valid if there has not been a failure
1722          * of the media. For example, there will be dirty inodes if we failed
1723          * to write them back because of I/O errors.
1724          */
1725         ubifs_assert(atomic_long_read(&c->dirty_pg_cnt) == 0);
1726         ubifs_assert(c->budg_idx_growth == 0);
1727         ubifs_assert(c->budg_dd_growth == 0);
1728         ubifs_assert(c->budg_data_growth == 0);
1729
1730         /*
1731          * The 'c->umount_lock' prevents races between UBIFS memory shrinker
1732          * and file system un-mount. Namely, it prevents the shrinker from
1733          * picking this superblock for shrinking - it will be just skipped if
1734          * the mutex is locked.
1735          */
1736         mutex_lock(&c->umount_mutex);
1737         if (!(c->vfs_sb->s_flags & MS_RDONLY)) {
1738                 /*
1739                  * First of all kill the background thread to make sure it does
1740                  * not interfere with un-mounting and freeing resources.
1741                  */
1742                 if (c->bgt) {
1743                         kthread_stop(c->bgt);
1744                         c->bgt = NULL;
1745                 }
1746
1747                 /* Synchronize write-buffers */
1748                 if (c->jheads)
1749                         for (i = 0; i < c->jhead_cnt; i++)
1750                                 ubifs_wbuf_sync(&c->jheads[i].wbuf);
1751
1752                 /*
1753                  * On fatal errors c->ro_media is set to 1, in which case we do
1754                  * not write the master node.
1755                  */
1756                 if (!c->ro_media) {
1757                         /*
1758                          * We are being cleanly unmounted which means the
1759                          * orphans were killed - indicate this in the master
1760                          * node. Also save the reserved GC LEB number.
1761                          */
1762                         int err;
1763
1764                         c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY);
1765                         c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS);
1766                         c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum);
1767                         err = ubifs_write_master(c);
1768                         if (err)
1769                                 /*
1770                                  * Recovery will attempt to fix the master area
1771                                  * next mount, so we just print a message and
1772                                  * continue to unmount normally.
1773                                  */
1774                                 ubifs_err("failed to write master node, "
1775                                           "error %d", err);
1776                 }
1777         }
1778
1779         ubifs_umount(c);
1780         bdi_destroy(&c->bdi);
1781         ubi_close_volume(c->ubi);
1782         mutex_unlock(&c->umount_mutex);
1783         kfree(c);
1784 }
1785
1786 static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data)
1787 {
1788         int err;
1789         struct ubifs_info *c = sb->s_fs_info;
1790
1791         dbg_gen("old flags %#lx, new flags %#x", sb->s_flags, *flags);
1792
1793         err = ubifs_parse_options(c, data, 1);
1794         if (err) {
1795                 ubifs_err("invalid or unknown remount parameter");
1796                 return err;
1797         }
1798
1799         if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
1800                 if (c->ro_media) {
1801                         ubifs_msg("cannot re-mount due to prior errors");
1802                         return -EROFS;
1803                 }
1804                 err = ubifs_remount_rw(c);
1805                 if (err)
1806                         return err;
1807         } else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) {
1808                 if (c->ro_media) {
1809                         ubifs_msg("cannot re-mount due to prior errors");
1810                         return -EROFS;
1811                 }
1812                 ubifs_remount_ro(c);
1813         }
1814
1815         if (c->bulk_read == 1)
1816                 bu_init(c);
1817         else {
1818                 dbg_gen("disable bulk-read");
1819                 kfree(c->bu.buf);
1820                 c->bu.buf = NULL;
1821         }
1822
1823         ubifs_assert(c->lst.taken_empty_lebs > 0);
1824         return 0;
1825 }
1826
1827 const struct super_operations ubifs_super_operations = {
1828         .alloc_inode   = ubifs_alloc_inode,
1829         .destroy_inode = ubifs_destroy_inode,
1830         .put_super     = ubifs_put_super,
1831         .write_inode   = ubifs_write_inode,
1832         .delete_inode  = ubifs_delete_inode,
1833         .statfs        = ubifs_statfs,
1834         .dirty_inode   = ubifs_dirty_inode,
1835         .remount_fs    = ubifs_remount_fs,
1836         .show_options  = ubifs_show_options,
1837         .sync_fs       = ubifs_sync_fs,
1838 };
1839
1840 /**
1841  * open_ubi - parse UBI device name string and open the UBI device.
1842  * @name: UBI volume name
1843  * @mode: UBI volume open mode
1844  *
1845  * There are several ways to specify UBI volumes when mounting UBIFS:
1846  * o ubiX_Y    - UBI device number X, volume Y;
1847  * o ubiY      - UBI device number 0, volume Y;
1848  * o ubiX:NAME - mount UBI device X, volume with name NAME;
1849  * o ubi:NAME  - mount UBI device 0, volume with name NAME.
1850  *
1851  * Alternative '!' separator may be used instead of ':' (because some shells
1852  * like busybox may interpret ':' as an NFS host name separator). This function
1853  * returns ubi volume object in case of success and a negative error code in
1854  * case of failure.
1855  */
1856 static struct ubi_volume_desc *open_ubi(const char *name, int mode)
1857 {
1858         int dev, vol;
1859         char *endptr;
1860
1861         if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i')
1862                 return ERR_PTR(-EINVAL);
1863
1864         /* ubi:NAME method */
1865         if ((name[3] == ':' || name[3] == '!') && name[4] != '\0')
1866                 return ubi_open_volume_nm(0, name + 4, mode);
1867
1868         if (!isdigit(name[3]))
1869                 return ERR_PTR(-EINVAL);
1870
1871         dev = simple_strtoul(name + 3, &endptr, 0);
1872
1873         /* ubiY method */
1874         if (*endptr == '\0')
1875                 return ubi_open_volume(0, dev, mode);
1876
1877         /* ubiX_Y method */
1878         if (*endptr == '_' && isdigit(endptr[1])) {
1879                 vol = simple_strtoul(endptr + 1, &endptr, 0);
1880                 if (*endptr != '\0')
1881                         return ERR_PTR(-EINVAL);
1882                 return ubi_open_volume(dev, vol, mode);
1883         }
1884
1885         /* ubiX:NAME method */
1886         if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0')
1887                 return ubi_open_volume_nm(dev, ++endptr, mode);
1888
1889         return ERR_PTR(-EINVAL);
1890 }
1891
1892 static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
1893 {
1894         struct ubi_volume_desc *ubi = sb->s_fs_info;
1895         struct ubifs_info *c;
1896         struct inode *root;
1897         int err;
1898
1899         c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL);
1900         if (!c)
1901                 return -ENOMEM;
1902
1903         spin_lock_init(&c->cnt_lock);
1904         spin_lock_init(&c->cs_lock);
1905         spin_lock_init(&c->buds_lock);
1906         spin_lock_init(&c->space_lock);
1907         spin_lock_init(&c->orphan_lock);
1908         init_rwsem(&c->commit_sem);
1909         mutex_init(&c->lp_mutex);
1910         mutex_init(&c->tnc_mutex);
1911         mutex_init(&c->log_mutex);
1912         mutex_init(&c->mst_mutex);
1913         mutex_init(&c->umount_mutex);
1914         mutex_init(&c->bu_mutex);
1915         init_waitqueue_head(&c->cmt_wq);
1916         c->buds = RB_ROOT;
1917         c->old_idx = RB_ROOT;
1918         c->size_tree = RB_ROOT;
1919         c->orph_tree = RB_ROOT;
1920         INIT_LIST_HEAD(&c->infos_list);
1921         INIT_LIST_HEAD(&c->idx_gc);
1922         INIT_LIST_HEAD(&c->replay_list);
1923         INIT_LIST_HEAD(&c->replay_buds);
1924         INIT_LIST_HEAD(&c->uncat_list);
1925         INIT_LIST_HEAD(&c->empty_list);
1926         INIT_LIST_HEAD(&c->freeable_list);
1927         INIT_LIST_HEAD(&c->frdi_idx_list);
1928         INIT_LIST_HEAD(&c->unclean_leb_list);
1929         INIT_LIST_HEAD(&c->old_buds);
1930         INIT_LIST_HEAD(&c->orph_list);
1931         INIT_LIST_HEAD(&c->orph_new);
1932
1933         c->vfs_sb = sb;
1934         c->highest_inum = UBIFS_FIRST_INO;
1935         c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM;
1936
1937         ubi_get_volume_info(ubi, &c->vi);
1938         ubi_get_device_info(c->vi.ubi_num, &c->di);
1939
1940         /* Re-open the UBI device in read-write mode */
1941         c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READWRITE);
1942         if (IS_ERR(c->ubi)) {
1943                 err = PTR_ERR(c->ubi);
1944                 goto out_free;
1945         }
1946
1947         /*
1948          * UBIFS provides 'backing_dev_info' in order to disable read-ahead. For
1949          * UBIFS, I/O is not deferred, it is done immediately in readpage,
1950          * which means the user would have to wait not just for their own I/O
1951          * but the read-ahead I/O as well i.e. completely pointless.
1952          *
1953          * Read-ahead will be disabled because @c->bdi.ra_pages is 0.
1954          */
1955         c->bdi.name = "ubifs",
1956         c->bdi.capabilities = BDI_CAP_MAP_COPY;
1957         c->bdi.unplug_io_fn = default_unplug_io_fn;
1958         err  = bdi_init(&c->bdi);
1959         if (err)
1960                 goto out_close;
1961         err = bdi_register(&c->bdi, NULL, "ubifs_%d_%d",
1962                            c->vi.ubi_num, c->vi.vol_id);
1963         if (err)
1964                 goto out_bdi;
1965
1966         err = ubifs_parse_options(c, data, 0);
1967         if (err)
1968                 goto out_bdi;
1969
1970         sb->s_bdi = &c->bdi;
1971         sb->s_fs_info = c;
1972         sb->s_magic = UBIFS_SUPER_MAGIC;
1973         sb->s_blocksize = UBIFS_BLOCK_SIZE;
1974         sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT;
1975         sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c);
1976         if (c->max_inode_sz > MAX_LFS_FILESIZE)
1977                 sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE;
1978         sb->s_op = &ubifs_super_operations;
1979
1980         mutex_lock(&c->umount_mutex);
1981         err = mount_ubifs(c);
1982         if (err) {
1983                 ubifs_assert(err < 0);
1984                 goto out_unlock;
1985         }
1986
1987         /* Read the root inode */
1988         root = ubifs_iget(sb, UBIFS_ROOT_INO);
1989         if (IS_ERR(root)) {
1990                 err = PTR_ERR(root);
1991                 goto out_umount;
1992         }
1993
1994         sb->s_root = d_alloc_root(root);
1995         if (!sb->s_root)
1996                 goto out_iput;
1997
1998         mutex_unlock(&c->umount_mutex);
1999         return 0;
2000
2001 out_iput:
2002         iput(root);
2003 out_umount:
2004         ubifs_umount(c);
2005 out_unlock:
2006         mutex_unlock(&c->umount_mutex);
2007 out_bdi:
2008         bdi_destroy(&c->bdi);
2009 out_close:
2010         ubi_close_volume(c->ubi);
2011 out_free:
2012         kfree(c);
2013         return err;
2014 }
2015
2016 static int sb_test(struct super_block *sb, void *data)
2017 {
2018         dev_t *dev = data;
2019         struct ubifs_info *c = sb->s_fs_info;
2020
2021         return c->vi.cdev == *dev;
2022 }
2023
2024 static int ubifs_get_sb(struct file_system_type *fs_type, int flags,
2025                         const char *name, void *data, struct vfsmount *mnt)
2026 {
2027         struct ubi_volume_desc *ubi;
2028         struct ubi_volume_info vi;
2029         struct super_block *sb;
2030         int err;
2031
2032         dbg_gen("name %s, flags %#x", name, flags);
2033
2034         /*
2035          * Get UBI device number and volume ID. Mount it read-only so far
2036          * because this might be a new mount point, and UBI allows only one
2037          * read-write user at a time.
2038          */
2039         ubi = open_ubi(name, UBI_READONLY);
2040         if (IS_ERR(ubi)) {
2041                 ubifs_err("cannot open \"%s\", error %d",
2042                           name, (int)PTR_ERR(ubi));
2043                 return PTR_ERR(ubi);
2044         }
2045         ubi_get_volume_info(ubi, &vi);
2046
2047         dbg_gen("opened ubi%d_%d", vi.ubi_num, vi.vol_id);
2048
2049         sb = sget(fs_type, &sb_test, &set_anon_super, &vi.cdev);
2050         if (IS_ERR(sb)) {
2051                 err = PTR_ERR(sb);
2052                 goto out_close;
2053         }
2054
2055         if (sb->s_root) {
2056                 /* A new mount point for already mounted UBIFS */
2057                 dbg_gen("this ubi volume is already mounted");
2058                 if ((flags ^ sb->s_flags) & MS_RDONLY) {
2059                         err = -EBUSY;
2060                         goto out_deact;
2061                 }
2062         } else {
2063                 sb->s_flags = flags;
2064                 /*
2065                  * Pass 'ubi' to 'fill_super()' in sb->s_fs_info where it is
2066                  * replaced by 'c'.
2067                  */
2068                 sb->s_fs_info = ubi;
2069                 err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
2070                 if (err)
2071                         goto out_deact;
2072                 /* We do not support atime */
2073                 sb->s_flags |= MS_ACTIVE | MS_NOATIME;
2074         }
2075
2076         /* 'fill_super()' opens ubi again so we must close it here */
2077         ubi_close_volume(ubi);
2078
2079         simple_set_mnt(mnt, sb);
2080         return 0;
2081
2082 out_deact:
2083         deactivate_locked_super(sb);
2084 out_close:
2085         ubi_close_volume(ubi);
2086         return err;
2087 }
2088
2089 static struct file_system_type ubifs_fs_type = {
2090         .name    = "ubifs",
2091         .owner   = THIS_MODULE,
2092         .get_sb  = ubifs_get_sb,
2093         .kill_sb = kill_anon_super,
2094 };
2095
2096 /*
2097  * Inode slab cache constructor.
2098  */
2099 static void inode_slab_ctor(void *obj)
2100 {
2101         struct ubifs_inode *ui = obj;
2102         inode_init_once(&ui->vfs_inode);
2103 }
2104
2105 static int __init ubifs_init(void)
2106 {
2107         int err;
2108
2109         BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24);
2110
2111         /* Make sure node sizes are 8-byte aligned */
2112         BUILD_BUG_ON(UBIFS_CH_SZ        & 7);
2113         BUILD_BUG_ON(UBIFS_INO_NODE_SZ  & 7);
2114         BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7);
2115         BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7);
2116         BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7);
2117         BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7);
2118         BUILD_BUG_ON(UBIFS_SB_NODE_SZ   & 7);
2119         BUILD_BUG_ON(UBIFS_MST_NODE_SZ  & 7);
2120         BUILD_BUG_ON(UBIFS_REF_NODE_SZ  & 7);
2121         BUILD_BUG_ON(UBIFS_CS_NODE_SZ   & 7);
2122         BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7);
2123
2124         BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7);
2125         BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7);
2126         BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7);
2127         BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ  & 7);
2128         BUILD_BUG_ON(UBIFS_MAX_NODE_SZ      & 7);
2129         BUILD_BUG_ON(MIN_WRITE_SZ           & 7);
2130
2131         /* Check min. node size */
2132         BUILD_BUG_ON(UBIFS_INO_NODE_SZ  < MIN_WRITE_SZ);
2133         BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ);
2134         BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ);
2135         BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ);
2136
2137         BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ);
2138         BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ);
2139         BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ);
2140         BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ  > UBIFS_MAX_NODE_SZ);
2141
2142         /* Defined node sizes */
2143         BUILD_BUG_ON(UBIFS_SB_NODE_SZ  != 4096);
2144         BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512);
2145         BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160);
2146         BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64);
2147
2148         /*
2149          * We use 2 bit wide bit-fields to store compression type, which should
2150          * be amended if more compressors are added. The bit-fields are:
2151          * @compr_type in 'struct ubifs_inode', @default_compr in
2152          * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'.
2153          */
2154         BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4);
2155
2156         /*
2157          * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to
2158          * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2.
2159          */
2160         if (PAGE_CACHE_SIZE < UBIFS_BLOCK_SIZE) {
2161                 ubifs_err("VFS page cache size is %u bytes, but UBIFS requires"
2162                           " at least 4096 bytes",
2163                           (unsigned int)PAGE_CACHE_SIZE);
2164                 return -EINVAL;
2165         }
2166
2167         err = register_filesystem(&ubifs_fs_type);
2168         if (err) {
2169                 ubifs_err("cannot register file system, error %d", err);
2170                 return err;
2171         }
2172
2173         err = -ENOMEM;
2174         ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab",
2175                                 sizeof(struct ubifs_inode), 0,
2176                                 SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT,
2177                                 &inode_slab_ctor);
2178         if (!ubifs_inode_slab)
2179                 goto out_reg;
2180
2181         register_shrinker(&ubifs_shrinker_info);
2182
2183         err = ubifs_compressors_init();
2184         if (err)
2185                 goto out_shrinker;
2186
2187         err = dbg_debugfs_init();
2188         if (err)
2189                 goto out_compr;
2190
2191         return 0;
2192
2193 out_compr:
2194         ubifs_compressors_exit();
2195 out_shrinker:
2196         unregister_shrinker(&ubifs_shrinker_info);
2197         kmem_cache_destroy(ubifs_inode_slab);
2198 out_reg:
2199         unregister_filesystem(&ubifs_fs_type);
2200         return err;
2201 }
2202 /* late_initcall to let compressors initialize first */
2203 late_initcall(ubifs_init);
2204
2205 static void __exit ubifs_exit(void)
2206 {
2207         ubifs_assert(list_empty(&ubifs_infos));
2208         ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0);
2209
2210         dbg_debugfs_exit();
2211         ubifs_compressors_exit();
2212         unregister_shrinker(&ubifs_shrinker_info);
2213         kmem_cache_destroy(ubifs_inode_slab);
2214         unregister_filesystem(&ubifs_fs_type);
2215 }
2216 module_exit(ubifs_exit);
2217
2218 MODULE_LICENSE("GPL");
2219 MODULE_VERSION(__stringify(UBIFS_VERSION));
2220 MODULE_AUTHOR("Artem Bityutskiy, Adrian Hunter");
2221 MODULE_DESCRIPTION("UBIFS - UBI File System");