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