super.c 60.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*
 * This file is part of UBIFS.
 *
 * Copyright (C) 2006-2008 Nokia Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * Authors: Artem Bityutskiy (Битюцкий Артём)
 *          Adrian Hunter
 */

/*
 * This file implements UBIFS initialization and VFS superblock operations. Some
 * initialization stuff which is rather large and complex is placed at
 * corresponding subsystems, but most of it is here.
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/ctype.h>
#include <linux/kthread.h>
#include <linux/parser.h>
#include <linux/seq_file.h>
#include <linux/mount.h>
A
Artem Bityutskiy 已提交
37
#include <linux/math64.h>
38
#include <linux/writeback.h>
39 40
#include "ubifs.h"

41 42 43 44 45 46
/*
 * Maximum amount of memory we may 'kmalloc()' without worrying that we are
 * allocating too much.
 */
#define UBIFS_KMALLOC_OK (128*1024)

47 48 49 50 51
/* Slab cache for UBIFS inodes */
struct kmem_cache *ubifs_inode_slab;

/* UBIFS TNC shrinker description */
static struct shrinker ubifs_shrinker_info = {
52 53
	.scan_objects = ubifs_shrink_scan,
	.count_objects = ubifs_shrink_count,
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
	.seeks = DEFAULT_SEEKS,
};

/**
 * validate_inode - validate inode.
 * @c: UBIFS file-system description object
 * @inode: the inode to validate
 *
 * This is a helper function for 'ubifs_iget()' which validates various fields
 * of a newly built inode to make sure they contain sane values and prevent
 * possible vulnerabilities. Returns zero if the inode is all right and
 * a non-zero error code if not.
 */
static int validate_inode(struct ubifs_info *c, const struct inode *inode)
{
	int err;
	const struct ubifs_inode *ui = ubifs_inode(inode);

	if (inode->i_size > c->max_inode_sz) {
73
		ubifs_err(c, "inode is too large (%lld)",
74 75 76 77
			  (long long)inode->i_size);
		return 1;
	}

H
hujianyang 已提交
78
	if (ui->compr_type >= UBIFS_COMPR_TYPES_CNT) {
79
		ubifs_err(c, "unknown compression type %d", ui->compr_type);
80 81 82 83 84 85 86 87 88
		return 2;
	}

	if (ui->xattr_names + ui->xattr_cnt > XATTR_LIST_MAX)
		return 3;

	if (ui->data_len < 0 || ui->data_len > UBIFS_MAX_INO_DATA)
		return 4;

89
	if (ui->xattr && !S_ISREG(inode->i_mode))
90 91 92
		return 5;

	if (!ubifs_compr_present(ui->compr_type)) {
93
		ubifs_warn(c, "inode %lu uses '%s' compression, but it was not compiled in",
94
			   inode->i_ino, ubifs_compr_name(ui->compr_type));
95 96
	}

97
	err = dbg_check_dir(c, inode);
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
	return err;
}

struct inode *ubifs_iget(struct super_block *sb, unsigned long inum)
{
	int err;
	union ubifs_key key;
	struct ubifs_ino_node *ino;
	struct ubifs_info *c = sb->s_fs_info;
	struct inode *inode;
	struct ubifs_inode *ui;

	dbg_gen("inode %lu", inum);

	inode = iget_locked(sb, inum);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;
	ui = ubifs_inode(inode);

	ino = kmalloc(UBIFS_MAX_INO_NODE_SZ, GFP_NOFS);
	if (!ino) {
		err = -ENOMEM;
		goto out;
	}

	ino_key_init(c, &key, inode->i_ino);

	err = ubifs_tnc_lookup(c, &key, ino);
	if (err)
		goto out_ino;

131 132 133 134
	inode->i_flags |= S_NOCMTIME;
#ifndef CONFIG_UBIFS_ATIME_SUPPORT
	inode->i_flags |= S_NOATIME;
#endif
M
Miklos Szeredi 已提交
135
	set_nlink(inode, le32_to_cpu(ino->nlink));
136 137
	i_uid_write(inode, le32_to_cpu(ino->uid));
	i_gid_write(inode, le32_to_cpu(ino->gid));
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
	inode->i_atime.tv_sec  = (int64_t)le64_to_cpu(ino->atime_sec);
	inode->i_atime.tv_nsec = le32_to_cpu(ino->atime_nsec);
	inode->i_mtime.tv_sec  = (int64_t)le64_to_cpu(ino->mtime_sec);
	inode->i_mtime.tv_nsec = le32_to_cpu(ino->mtime_nsec);
	inode->i_ctime.tv_sec  = (int64_t)le64_to_cpu(ino->ctime_sec);
	inode->i_ctime.tv_nsec = le32_to_cpu(ino->ctime_nsec);
	inode->i_mode = le32_to_cpu(ino->mode);
	inode->i_size = le64_to_cpu(ino->size);

	ui->data_len    = le32_to_cpu(ino->data_len);
	ui->flags       = le32_to_cpu(ino->flags);
	ui->compr_type  = le16_to_cpu(ino->compr_type);
	ui->creat_sqnum = le64_to_cpu(ino->creat_sqnum);
	ui->xattr_cnt   = le32_to_cpu(ino->xattr_cnt);
	ui->xattr_size  = le32_to_cpu(ino->xattr_size);
	ui->xattr_names = le32_to_cpu(ino->xattr_names);
	ui->synced_i_size = ui->ui_size = inode->i_size;

	ui->xattr = (ui->flags & UBIFS_XATTR_FL) ? 1 : 0;

	err = validate_inode(c, inode);
	if (err)
		goto out_invalid;

	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_mapping->a_ops = &ubifs_file_address_operations;
		inode->i_op = &ubifs_file_inode_operations;
		inode->i_fop = &ubifs_file_operations;
		if (ui->xattr) {
			ui->data = kmalloc(ui->data_len + 1, GFP_NOFS);
			if (!ui->data) {
				err = -ENOMEM;
				goto out_ino;
			}
			memcpy(ui->data, ino->data, ui->data_len);
			((char *)ui->data)[ui->data_len] = '\0';
		} else if (ui->data_len != 0) {
			err = 10;
			goto out_invalid;
		}
		break;
	case S_IFDIR:
		inode->i_op  = &ubifs_dir_inode_operations;
		inode->i_fop = &ubifs_dir_operations;
		if (ui->data_len != 0) {
			err = 11;
			goto out_invalid;
		}
		break;
	case S_IFLNK:
		inode->i_op = &ubifs_symlink_inode_operations;
		if (ui->data_len <= 0 || ui->data_len > UBIFS_MAX_INO_DATA) {
			err = 12;
			goto out_invalid;
		}
		ui->data = kmalloc(ui->data_len + 1, GFP_NOFS);
		if (!ui->data) {
			err = -ENOMEM;
			goto out_ino;
		}
		memcpy(ui->data, ino->data, ui->data_len);
		((char *)ui->data)[ui->data_len] = '\0';
A
Al Viro 已提交
201
		inode->i_link = ui->data;
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
		break;
	case S_IFBLK:
	case S_IFCHR:
	{
		dev_t rdev;
		union ubifs_dev_desc *dev;

		ui->data = kmalloc(sizeof(union ubifs_dev_desc), GFP_NOFS);
		if (!ui->data) {
			err = -ENOMEM;
			goto out_ino;
		}

		dev = (union ubifs_dev_desc *)ino->data;
		if (ui->data_len == sizeof(dev->new))
			rdev = new_decode_dev(le32_to_cpu(dev->new));
		else if (ui->data_len == sizeof(dev->huge))
			rdev = huge_decode_dev(le64_to_cpu(dev->huge));
		else {
			err = 13;
			goto out_invalid;
		}
		memcpy(ui->data, ino->data, ui->data_len);
		inode->i_op = &ubifs_file_inode_operations;
		init_special_inode(inode, inode->i_mode, rdev);
		break;
	}
	case S_IFSOCK:
	case S_IFIFO:
		inode->i_op = &ubifs_file_inode_operations;
		init_special_inode(inode, inode->i_mode, 0);
		if (ui->data_len != 0) {
			err = 14;
			goto out_invalid;
		}
		break;
	default:
		err = 15;
		goto out_invalid;
	}

	kfree(ino);
	ubifs_set_inode_flags(inode);
	unlock_new_inode(inode);
	return inode;

out_invalid:
249
	ubifs_err(c, "inode %lu validation failed, error %d", inode->i_ino, err);
250 251
	ubifs_dump_node(c, ino);
	ubifs_dump_inode(c, inode);
252 253 254 255
	err = -EINVAL;
out_ino:
	kfree(ino);
out:
256
	ubifs_err(c, "failed to read inode %lu, error %d", inode->i_ino, err);
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
	iget_failed(inode);
	return ERR_PTR(err);
}

static struct inode *ubifs_alloc_inode(struct super_block *sb)
{
	struct ubifs_inode *ui;

	ui = kmem_cache_alloc(ubifs_inode_slab, GFP_NOFS);
	if (!ui)
		return NULL;

	memset((void *)ui + sizeof(struct inode), 0,
	       sizeof(struct ubifs_inode) - sizeof(struct inode));
	mutex_init(&ui->ui_mutex);
	spin_lock_init(&ui->ui_lock);
	return &ui->vfs_inode;
};

N
Nick Piggin 已提交
276 277 278 279 280 281 282
static void ubifs_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	struct ubifs_inode *ui = ubifs_inode(inode);
	kmem_cache_free(ubifs_inode_slab, ui);
}

283 284 285 286 287
static void ubifs_destroy_inode(struct inode *inode)
{
	struct ubifs_inode *ui = ubifs_inode(inode);

	kfree(ui->data);
N
Nick Piggin 已提交
288
	call_rcu(&inode->i_rcu, ubifs_i_callback);
289 290 291 292 293
}

/*
 * Note, Linux write-back code calls this without 'i_mutex'.
 */
294
static int ubifs_write_inode(struct inode *inode, struct writeback_control *wbc)
295
{
296
	int err = 0;
297 298 299 300 301 302 303 304 305 306
	struct ubifs_info *c = inode->i_sb->s_fs_info;
	struct ubifs_inode *ui = ubifs_inode(inode);

	ubifs_assert(!ui->xattr);
	if (is_bad_inode(inode))
		return 0;

	mutex_lock(&ui->ui_mutex);
	/*
	 * Due to races between write-back forced by budgeting
307
	 * (see 'sync_some_inodes()') and background write-back, the inode may
308 309 310 311 312 313 314 315 316
	 * have already been synchronized, do not do this again. This might
	 * also happen if it was synchronized in an VFS operation, e.g.
	 * 'ubifs_link()'.
	 */
	if (!ui->dirty) {
		mutex_unlock(&ui->ui_mutex);
		return 0;
	}

317 318 319 320 321 322 323
	/*
	 * As an optimization, do not write orphan inodes to the media just
	 * because this is not needed.
	 */
	dbg_gen("inode %lu, mode %#x, nlink %u",
		inode->i_ino, (int)inode->i_mode, inode->i_nlink);
	if (inode->i_nlink) {
324
		err = ubifs_jnl_write_inode(c, inode);
325
		if (err)
326
			ubifs_err(c, "can't write inode %lu, error %d",
327
				  inode->i_ino, err);
328 329
		else
			err = dbg_check_inode_size(c, inode, ui->ui_size);
330
	}
331 332 333 334 335 336 337

	ui->dirty = 0;
	mutex_unlock(&ui->ui_mutex);
	ubifs_release_dirty_inode_budget(c, ui);
	return err;
}

A
Al Viro 已提交
338
static void ubifs_evict_inode(struct inode *inode)
339 340 341
{
	int err;
	struct ubifs_info *c = inode->i_sb->s_fs_info;
342
	struct ubifs_inode *ui = ubifs_inode(inode);
343

344
	if (ui->xattr)
345 346 347 348 349 350 351
		/*
		 * Extended attribute inode deletions are fully handled in
		 * 'ubifs_removexattr()'. These inodes are special and have
		 * limited usage, so there is nothing to do here.
		 */
		goto out;

A
Artem Bityutskiy 已提交
352
	dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
353 354
	ubifs_assert(!atomic_read(&inode->i_count));

355
	truncate_inode_pages_final(&inode->i_data);
A
Al Viro 已提交
356 357 358 359

	if (inode->i_nlink)
		goto done;

360 361 362
	if (is_bad_inode(inode))
		goto out;

363
	ui->ui_size = inode->i_size = 0;
A
Artem Bityutskiy 已提交
364
	err = ubifs_jnl_delete_inode(c, inode);
365 366 367
	if (err)
		/*
		 * Worst case we have a lost orphan inode wasting space, so a
A
Artem Bityutskiy 已提交
368
		 * simple error message is OK here.
369
		 */
370
		ubifs_err(c, "can't delete inode %lu, error %d",
A
Artem Bityutskiy 已提交
371 372
			  inode->i_ino, err);

373
out:
374 375
	if (ui->dirty)
		ubifs_release_dirty_inode_budget(c, ui);
376 377
	else {
		/* We've deleted something - clean the "no space" flags */
378
		c->bi.nospace = c->bi.nospace_rp = 0;
379 380
		smp_wmb();
	}
A
Al Viro 已提交
381
done:
382
	clear_inode(inode);
383 384 385
#ifdef CONFIG_UBIFS_FS_ENCRYPTION
	fscrypt_put_encryption_info(inode, NULL);
#endif
386 387
}

388
static void ubifs_dirty_inode(struct inode *inode, int flags)
389 390 391 392 393 394 395 396 397 398 399 400 401 402
{
	struct ubifs_inode *ui = ubifs_inode(inode);

	ubifs_assert(mutex_is_locked(&ui->ui_mutex));
	if (!ui->dirty) {
		ui->dirty = 1;
		dbg_gen("inode %lu",  inode->i_ino);
	}
}

static int ubifs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct ubifs_info *c = dentry->d_sb->s_fs_info;
	unsigned long long free;
A
Artem Bityutskiy 已提交
403
	__le32 *uuid = (__le32 *)c->uuid;
404

405
	free = ubifs_get_free_space(c);
406 407 408 409 410 411 412 413 414 415 416 417 418 419
	dbg_gen("free space %lld bytes (%lld blocks)",
		free, free >> UBIFS_BLOCK_SHIFT);

	buf->f_type = UBIFS_SUPER_MAGIC;
	buf->f_bsize = UBIFS_BLOCK_SIZE;
	buf->f_blocks = c->block_cnt;
	buf->f_bfree = free >> UBIFS_BLOCK_SHIFT;
	if (free > c->report_rp_size)
		buf->f_bavail = (free - c->report_rp_size) >> UBIFS_BLOCK_SHIFT;
	else
		buf->f_bavail = 0;
	buf->f_files = 0;
	buf->f_ffree = 0;
	buf->f_namelen = UBIFS_MAX_NLEN;
A
Artem Bityutskiy 已提交
420 421
	buf->f_fsid.val[0] = le32_to_cpu(uuid[0]) ^ le32_to_cpu(uuid[2]);
	buf->f_fsid.val[1] = le32_to_cpu(uuid[1]) ^ le32_to_cpu(uuid[3]);
422
	ubifs_assert(buf->f_bfree <= c->block_cnt);
423 424 425
	return 0;
}

426
static int ubifs_show_options(struct seq_file *s, struct dentry *root)
427
{
428
	struct ubifs_info *c = root->d_sb->s_fs_info;
429 430

	if (c->mount_opts.unmount_mode == 2)
431
		seq_puts(s, ",fast_unmount");
432
	else if (c->mount_opts.unmount_mode == 1)
433
		seq_puts(s, ",norm_unmount");
434

A
Adrian Hunter 已提交
435
	if (c->mount_opts.bulk_read == 2)
436
		seq_puts(s, ",bulk_read");
A
Adrian Hunter 已提交
437
	else if (c->mount_opts.bulk_read == 1)
438
		seq_puts(s, ",no_bulk_read");
A
Adrian Hunter 已提交
439

440
	if (c->mount_opts.chk_data_crc == 2)
441
		seq_puts(s, ",chk_data_crc");
442
	else if (c->mount_opts.chk_data_crc == 1)
443
		seq_puts(s, ",no_chk_data_crc");
444

445
	if (c->mount_opts.override_compr) {
H
Hunter Adrian 已提交
446 447
		seq_printf(s, ",compr=%s",
			   ubifs_compr_name(c->mount_opts.compr_type));
448 449
	}

450 451 452 453 454
	return 0;
}

static int ubifs_sync_fs(struct super_block *sb, int wait)
{
A
Artem Bityutskiy 已提交
455
	int i, err;
456
	struct ubifs_info *c = sb->s_fs_info;
457

458
	/*
A
Artem Bityutskiy 已提交
459 460
	 * Zero @wait is just an advisory thing to help the file system shove
	 * lots of data into the queues, and there will be the second
461 462
	 * '->sync_fs()' call, with non-zero @wait.
	 */
A
Artem Bityutskiy 已提交
463 464
	if (!wait)
		return 0;
465

466 467 468 469 470 471 472 473 474 475
	/*
	 * Synchronize write buffers, because 'ubifs_run_commit()' does not
	 * do this if it waits for an already running commit.
	 */
	for (i = 0; i < c->jhead_cnt; i++) {
		err = ubifs_wbuf_sync(&c->jheads[i].wbuf);
		if (err)
			return err;
	}

476 477 478 479 480 481 482
	/*
	 * Strictly speaking, it is not necessary to commit the journal here,
	 * synchronizing write-buffers would be enough. But committing makes
	 * UBIFS free space predictions much more accurate, so we want to let
	 * the user be able to get more accurate results of 'statfs()' after
	 * they synchronize the file system.
	 */
A
Artem Bityutskiy 已提交
483 484 485
	err = ubifs_run_commit(c);
	if (err)
		return err;
A
Artem Bityutskiy 已提交
486

A
Artem Bityutskiy 已提交
487
	return ubi_sync(c->vi.ubi_num);
488 489 490 491 492 493 494 495 496 497 498 499 500 501
}

/**
 * init_constants_early - initialize UBIFS constants.
 * @c: UBIFS file-system description object
 *
 * This function initialize UBIFS constants which do not need the superblock to
 * be read. It also checks that the UBI volume satisfies basic UBIFS
 * requirements. Returns zero in case of success and a negative error code in
 * case of failure.
 */
static int init_constants_early(struct ubifs_info *c)
{
	if (c->vi.corrupted) {
502
		ubifs_warn(c, "UBI volume is corrupted - read-only mode");
503 504 505 506
		c->ro_media = 1;
	}

	if (c->di.ro_mode) {
507
		ubifs_msg(c, "read-only UBI device");
508 509 510 511
		c->ro_media = 1;
	}

	if (c->vi.vol_type == UBI_STATIC_VOLUME) {
512
		ubifs_msg(c, "static UBI volume - read-only mode");
513 514 515 516 517
		c->ro_media = 1;
	}

	c->leb_cnt = c->vi.size;
	c->leb_size = c->vi.usable_leb_size;
518
	c->leb_start = c->di.leb_start;
519 520 521
	c->half_leb_size = c->leb_size / 2;
	c->min_io_size = c->di.min_io_size;
	c->min_io_shift = fls(c->min_io_size) - 1;
522 523
	c->max_write_size = c->di.max_write_size;
	c->max_write_shift = fls(c->max_write_size) - 1;
524 525

	if (c->leb_size < UBIFS_MIN_LEB_SZ) {
526 527
		ubifs_errc(c, "too small LEBs (%d bytes), min. is %d bytes",
			   c->leb_size, UBIFS_MIN_LEB_SZ);
528 529 530 531
		return -EINVAL;
	}

	if (c->leb_cnt < UBIFS_MIN_LEB_CNT) {
532 533
		ubifs_errc(c, "too few LEBs (%d), min. is %d",
			   c->leb_cnt, UBIFS_MIN_LEB_CNT);
534 535 536 537
		return -EINVAL;
	}

	if (!is_power_of_2(c->min_io_size)) {
538
		ubifs_errc(c, "bad min. I/O size %d", c->min_io_size);
539 540 541
		return -EINVAL;
	}

542 543 544 545 546 547 548
	/*
	 * Maximum write size has to be greater or equivalent to min. I/O
	 * size, and be multiple of min. I/O size.
	 */
	if (c->max_write_size < c->min_io_size ||
	    c->max_write_size % c->min_io_size ||
	    !is_power_of_2(c->max_write_size)) {
549 550
		ubifs_errc(c, "bad write buffer size %d for %d min. I/O unit",
			   c->max_write_size, c->min_io_size);
551 552 553
		return -EINVAL;
	}

554 555 556 557 558 559 560 561
	/*
	 * UBIFS aligns all node to 8-byte boundary, so to make function in
	 * io.c simpler, assume minimum I/O unit size to be 8 bytes if it is
	 * less than 8.
	 */
	if (c->min_io_size < 8) {
		c->min_io_size = 8;
		c->min_io_shift = 3;
562 563 564 565
		if (c->max_write_size < c->min_io_size) {
			c->max_write_size = c->min_io_size;
			c->max_write_shift = c->min_io_shift;
		}
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
	}

	c->ref_node_alsz = ALIGN(UBIFS_REF_NODE_SZ, c->min_io_size);
	c->mst_node_alsz = ALIGN(UBIFS_MST_NODE_SZ, c->min_io_size);

	/*
	 * Initialize node length ranges which are mostly needed for node
	 * length validation.
	 */
	c->ranges[UBIFS_PAD_NODE].len  = UBIFS_PAD_NODE_SZ;
	c->ranges[UBIFS_SB_NODE].len   = UBIFS_SB_NODE_SZ;
	c->ranges[UBIFS_MST_NODE].len  = UBIFS_MST_NODE_SZ;
	c->ranges[UBIFS_REF_NODE].len  = UBIFS_REF_NODE_SZ;
	c->ranges[UBIFS_TRUN_NODE].len = UBIFS_TRUN_NODE_SZ;
	c->ranges[UBIFS_CS_NODE].len   = UBIFS_CS_NODE_SZ;

	c->ranges[UBIFS_INO_NODE].min_len  = UBIFS_INO_NODE_SZ;
	c->ranges[UBIFS_INO_NODE].max_len  = UBIFS_MAX_INO_NODE_SZ;
	c->ranges[UBIFS_ORPH_NODE].min_len =
				UBIFS_ORPH_NODE_SZ + sizeof(__le64);
	c->ranges[UBIFS_ORPH_NODE].max_len = c->leb_size;
	c->ranges[UBIFS_DENT_NODE].min_len = UBIFS_DENT_NODE_SZ;
	c->ranges[UBIFS_DENT_NODE].max_len = UBIFS_MAX_DENT_NODE_SZ;
	c->ranges[UBIFS_XENT_NODE].min_len = UBIFS_XENT_NODE_SZ;
	c->ranges[UBIFS_XENT_NODE].max_len = UBIFS_MAX_XENT_NODE_SZ;
	c->ranges[UBIFS_DATA_NODE].min_len = UBIFS_DATA_NODE_SZ;
	c->ranges[UBIFS_DATA_NODE].max_len = UBIFS_MAX_DATA_NODE_SZ;
	/*
	 * Minimum indexing node size is amended later when superblock is
	 * read and the key length is known.
	 */
	c->ranges[UBIFS_IDX_NODE].min_len = UBIFS_IDX_NODE_SZ + UBIFS_BRANCH_SZ;
	/*
	 * Maximum indexing node size is amended later when superblock is
	 * read and the fanout is known.
	 */
	c->ranges[UBIFS_IDX_NODE].max_len = INT_MAX;

	/*
605 606
	 * Initialize dead and dark LEB space watermarks. See gc.c for comments
	 * about these values.
607 608 609 610
	 */
	c->dead_wm = ALIGN(MIN_WRITE_SZ, c->min_io_size);
	c->dark_wm = ALIGN(UBIFS_MAX_NODE_SZ, c->min_io_size);

A
Artem Bityutskiy 已提交
611 612 613 614 615 616
	/*
	 * Calculate how many bytes would be wasted at the end of LEB if it was
	 * fully filled with data nodes of maximum size. This is used in
	 * calculations when reporting free space.
	 */
	c->leb_overhead = c->leb_size % UBIFS_MAX_DATA_NODE_SZ;
617

A
Adrian Hunter 已提交
618
	/* Buffer size for bulk-reads */
A
Artem Bityutskiy 已提交
619 620 621
	c->max_bu_buf_len = UBIFS_MAX_BULK_READ * UBIFS_MAX_DATA_NODE_SZ;
	if (c->max_bu_buf_len > c->leb_size)
		c->max_bu_buf_len = c->leb_size;
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
	return 0;
}

/**
 * bud_wbuf_callback - bud LEB write-buffer synchronization call-back.
 * @c: UBIFS file-system description object
 * @lnum: LEB the write-buffer was synchronized to
 * @free: how many free bytes left in this LEB
 * @pad: how many bytes were padded
 *
 * This is a callback function which is called by the I/O unit when the
 * write-buffer is synchronized. We need this to correctly maintain space
 * accounting in bud logical eraseblocks. This function returns zero in case of
 * success and a negative error code in case of failure.
 *
 * This function actually belongs to the journal, but we keep it here because
 * we want to keep it static.
 */
static int bud_wbuf_callback(struct ubifs_info *c, int lnum, int free, int pad)
{
	return ubifs_update_one_lp(c, lnum, free, pad, 0, 0);
}

/*
646
 * init_constants_sb - initialize UBIFS constants.
647 648 649 650 651 652 653
 * @c: UBIFS file-system description object
 *
 * This is a helper function which initializes various UBIFS constants after
 * the superblock has been read. It also checks various UBIFS parameters and
 * makes sure they are all right. Returns zero in case of success and a
 * negative error code in case of failure.
 */
654
static int init_constants_sb(struct ubifs_info *c)
655 656
{
	int tmp, err;
A
Artem Bityutskiy 已提交
657
	long long tmp64;
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674

	c->main_bytes = (long long)c->main_lebs * c->leb_size;
	c->max_znode_sz = sizeof(struct ubifs_znode) +
				c->fanout * sizeof(struct ubifs_zbranch);

	tmp = ubifs_idx_node_sz(c, 1);
	c->ranges[UBIFS_IDX_NODE].min_len = tmp;
	c->min_idx_node_sz = ALIGN(tmp, 8);

	tmp = ubifs_idx_node_sz(c, c->fanout);
	c->ranges[UBIFS_IDX_NODE].max_len = tmp;
	c->max_idx_node_sz = ALIGN(tmp, 8);

	/* Make sure LEB size is large enough to fit full commit */
	tmp = UBIFS_CS_NODE_SZ + UBIFS_REF_NODE_SZ * c->jhead_cnt;
	tmp = ALIGN(tmp, c->min_io_size);
	if (tmp > c->leb_size) {
675
		ubifs_err(c, "too small LEB size %d, at least %d needed",
A
Artem Bityutskiy 已提交
676
			  c->leb_size, tmp);
677 678 679 680 681 682 683
		return -EINVAL;
	}

	/*
	 * Make sure that the log is large enough to fit reference nodes for
	 * all buds plus one reserved LEB.
	 */
A
Artem Bityutskiy 已提交
684 685
	tmp64 = c->max_bud_bytes + c->leb_size - 1;
	c->max_bud_cnt = div_u64(tmp64, c->leb_size);
686 687 688 689
	tmp = (c->ref_node_alsz * c->max_bud_cnt + c->leb_size - 1);
	tmp /= c->leb_size;
	tmp += 1;
	if (c->log_lebs < tmp) {
690
		ubifs_err(c, "too small log %d LEBs, required min. %d LEBs",
A
Artem Bityutskiy 已提交
691
			  c->log_lebs, tmp);
692 693 694 695 696 697 698 699
		return -EINVAL;
	}

	/*
	 * When budgeting we assume worst-case scenarios when the pages are not
	 * be compressed and direntries are of the maximum size.
	 *
	 * Note, data, which may be stored in inodes is budgeted separately, so
700
	 * it is not included into 'c->bi.inode_budget'.
701
	 */
702 703 704
	c->bi.page_budget = UBIFS_MAX_DATA_NODE_SZ * UBIFS_BLOCKS_PER_PAGE;
	c->bi.inode_budget = UBIFS_INO_NODE_SZ;
	c->bi.dent_budget = UBIFS_MAX_DENT_NODE_SZ;
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720

	/*
	 * When the amount of flash space used by buds becomes
	 * 'c->max_bud_bytes', UBIFS just blocks all writers and starts commit.
	 * The writers are unblocked when the commit is finished. To avoid
	 * writers to be blocked UBIFS initiates background commit in advance,
	 * when number of bud bytes becomes above the limit defined below.
	 */
	c->bg_bud_bytes = (c->max_bud_bytes * 13) >> 4;

	/*
	 * Ensure minimum journal size. All the bytes in the journal heads are
	 * considered to be used, when calculating the current journal usage.
	 * Consequently, if the journal is too small, UBIFS will treat it as
	 * always full.
	 */
A
Artem Bityutskiy 已提交
721
	tmp64 = (long long)(c->jhead_cnt + 1) * c->leb_size + 1;
722 723 724 725 726 727 728 729 730
	if (c->bg_bud_bytes < tmp64)
		c->bg_bud_bytes = tmp64;
	if (c->max_bud_bytes < tmp64 + c->leb_size)
		c->max_bud_bytes = tmp64 + c->leb_size;

	err = ubifs_calc_lpt_geom(c);
	if (err)
		return err;

731 732
	/* Initialize effective LEB size used in budgeting calculations */
	c->idx_leb_size = c->leb_size - c->max_idx_node_sz;
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	return 0;
}

/*
 * init_constants_master - initialize UBIFS constants.
 * @c: UBIFS file-system description object
 *
 * This is a helper function which initializes various UBIFS constants after
 * the master node has been read. It also checks various UBIFS parameters and
 * makes sure they are all right.
 */
static void init_constants_master(struct ubifs_info *c)
{
	long long tmp64;

748
	c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c);
749
	c->report_rp_size = ubifs_reported_space(c, c->rp_size);
750 751 752 753 754 755

	/*
	 * Calculate total amount of FS blocks. This number is not used
	 * internally because it does not make much sense for UBIFS, but it is
	 * necessary to report something for the 'statfs()' call.
	 *
756
	 * Subtract the LEB reserved for GC, the LEB which is reserved for
757 758
	 * deletions, minimum LEBs for the index, and assume only one journal
	 * head is available.
759
	 */
760
	tmp64 = c->main_lebs - 1 - 1 - MIN_INDEX_LEBS - c->jhead_cnt + 1;
A
Artem Bityutskiy 已提交
761
	tmp64 *= (long long)c->leb_size - c->leb_overhead;
762 763 764 765 766 767 768 769
	tmp64 = ubifs_reported_space(c, tmp64);
	c->block_cnt = tmp64 >> UBIFS_BLOCK_SHIFT;
}

/**
 * take_gc_lnum - reserve GC LEB.
 * @c: UBIFS file-system description object
 *
770 771 772 773 774 775
 * This function ensures that the LEB reserved for garbage collection is marked
 * as "taken" in lprops. We also have to set free space to LEB size and dirty
 * space to zero, because lprops may contain out-of-date information if the
 * file-system was un-mounted before it has been committed. This function
 * returns zero in case of success and a negative error code in case of
 * failure.
776 777 778 779 780 781
 */
static int take_gc_lnum(struct ubifs_info *c)
{
	int err;

	if (c->gc_lnum == -1) {
782
		ubifs_err(c, "no LEB for GC");
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
		return -EINVAL;
	}

	/* And we have to tell lprops that this LEB is taken */
	err = ubifs_change_one_lp(c, c->gc_lnum, c->leb_size, 0,
				  LPROPS_TAKEN, 0, 0);
	return err;
}

/**
 * alloc_wbufs - allocate write-buffers.
 * @c: UBIFS file-system description object
 *
 * This helper function allocates and initializes UBIFS write-buffers. Returns
 * zero in case of success and %-ENOMEM in case of failure.
 */
static int alloc_wbufs(struct ubifs_info *c)
{
	int i, err;

803 804
	c->jheads = kcalloc(c->jhead_cnt, sizeof(struct ubifs_jhead),
			    GFP_KERNEL);
805 806 807 808 809 810 811 812 813 814 815 816
	if (!c->jheads)
		return -ENOMEM;

	/* Initialize journal heads */
	for (i = 0; i < c->jhead_cnt; i++) {
		INIT_LIST_HEAD(&c->jheads[i].buds_list);
		err = ubifs_wbuf_init(c, &c->jheads[i].wbuf);
		if (err)
			return err;

		c->jheads[i].wbuf.sync_callback = &bud_wbuf_callback;
		c->jheads[i].wbuf.jhead = i;
817
		c->jheads[i].grouped = 1;
818 819 820
	}

	/*
821 822
	 * Garbage Collector head does not need to be synchronized by timer.
	 * Also GC head nodes are not grouped.
823
	 */
824
	c->jheads[GCHD].wbuf.no_timer = 1;
825
	c->jheads[GCHD].grouped = 0;
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866

	return 0;
}

/**
 * free_wbufs - free write-buffers.
 * @c: UBIFS file-system description object
 */
static void free_wbufs(struct ubifs_info *c)
{
	int i;

	if (c->jheads) {
		for (i = 0; i < c->jhead_cnt; i++) {
			kfree(c->jheads[i].wbuf.buf);
			kfree(c->jheads[i].wbuf.inodes);
		}
		kfree(c->jheads);
		c->jheads = NULL;
	}
}

/**
 * free_orphans - free orphans.
 * @c: UBIFS file-system description object
 */
static void free_orphans(struct ubifs_info *c)
{
	struct ubifs_orphan *orph;

	while (c->orph_dnext) {
		orph = c->orph_dnext;
		c->orph_dnext = orph->dnext;
		list_del(&orph->list);
		kfree(orph);
	}

	while (!list_empty(&c->orph_list)) {
		orph = list_entry(c->orph_list.next, struct ubifs_orphan, list);
		list_del(&orph->list);
		kfree(orph);
867
		ubifs_err(c, "orphan list not empty at unmount");
868 869 870 871 872 873 874 875 876 877 878 879
	}

	vfree(c->orph_buf);
	c->orph_buf = NULL;
}

/**
 * free_buds - free per-bud objects.
 * @c: UBIFS file-system description object
 */
static void free_buds(struct ubifs_info *c)
{
880 881 882 883
	struct ubifs_bud *bud, *n;

	rbtree_postorder_for_each_entry_safe(bud, n, &c->buds, rb)
		kfree(bud);
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
}

/**
 * check_volume_empty - check if the UBI volume is empty.
 * @c: UBIFS file-system description object
 *
 * This function checks if the UBIFS volume is empty by looking if its LEBs are
 * mapped or not. The result of checking is stored in the @c->empty variable.
 * Returns zero in case of success and a negative error code in case of
 * failure.
 */
static int check_volume_empty(struct ubifs_info *c)
{
	int lnum, err;

	c->empty = 1;
	for (lnum = 0; lnum < c->leb_cnt; lnum++) {
A
Artem Bityutskiy 已提交
901
		err = ubifs_is_mapped(c, lnum);
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
		if (unlikely(err < 0))
			return err;
		if (err == 1) {
			c->empty = 0;
			break;
		}

		cond_resched();
	}

	return 0;
}

/*
 * UBIFS mount options.
 *
 * Opt_fast_unmount: do not run a journal commit before un-mounting
 * Opt_norm_unmount: run a journal commit before un-mounting
A
Adrian Hunter 已提交
920 921
 * Opt_bulk_read: enable bulk-reads
 * Opt_no_bulk_read: disable bulk-reads
922 923
 * Opt_chk_data_crc: check CRCs when reading data nodes
 * Opt_no_chk_data_crc: do not check CRCs when reading data nodes
924
 * Opt_override_compr: override default compressor
925 926 927 928 929
 * Opt_err: just end of array marker
 */
enum {
	Opt_fast_unmount,
	Opt_norm_unmount,
A
Adrian Hunter 已提交
930 931
	Opt_bulk_read,
	Opt_no_bulk_read,
932 933
	Opt_chk_data_crc,
	Opt_no_chk_data_crc,
934
	Opt_override_compr,
935 936 937
	Opt_err,
};

938
static const match_table_t tokens = {
939 940
	{Opt_fast_unmount, "fast_unmount"},
	{Opt_norm_unmount, "norm_unmount"},
A
Adrian Hunter 已提交
941 942
	{Opt_bulk_read, "bulk_read"},
	{Opt_no_bulk_read, "no_bulk_read"},
943 944
	{Opt_chk_data_crc, "chk_data_crc"},
	{Opt_no_chk_data_crc, "no_chk_data_crc"},
945
	{Opt_override_compr, "compr=%s"},
946 947 948
	{Opt_err, NULL},
};

949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
/**
 * parse_standard_option - parse a standard mount option.
 * @option: the option to parse
 *
 * Normally, standard mount options like "sync" are passed to file-systems as
 * flags. However, when a "rootflags=" kernel boot parameter is used, they may
 * be present in the options string. This function tries to deal with this
 * situation and parse standard options. Returns 0 if the option was not
 * recognized, and the corresponding integer flag if it was.
 *
 * UBIFS is only interested in the "sync" option, so do not check for anything
 * else.
 */
static int parse_standard_option(const char *option)
{
964 965

	pr_notice("UBIFS: parse %s\n", option);
966 967 968 969 970
	if (!strcmp(option, "sync"))
		return MS_SYNCHRONOUS;
	return 0;
}

971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996
/**
 * ubifs_parse_options - parse mount parameters.
 * @c: UBIFS file-system description object
 * @options: parameters to parse
 * @is_remount: non-zero if this is FS re-mount
 *
 * This function parses UBIFS mount options and returns zero in case success
 * and a negative error code in case of failure.
 */
static int ubifs_parse_options(struct ubifs_info *c, char *options,
			       int is_remount)
{
	char *p;
	substring_t args[MAX_OPT_ARGS];

	if (!options)
		return 0;

	while ((p = strsep(&options, ","))) {
		int token;

		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
A
Artem Bityutskiy 已提交
997 998
		/*
		 * %Opt_fast_unmount and %Opt_norm_unmount options are ignored.
A
Artem Bityutskiy 已提交
999
		 * We accept them in order to be backward-compatible. But this
A
Artem Bityutskiy 已提交
1000 1001
		 * should be removed at some point.
		 */
1002 1003 1004 1005 1006 1007
		case Opt_fast_unmount:
			c->mount_opts.unmount_mode = 2;
			break;
		case Opt_norm_unmount:
			c->mount_opts.unmount_mode = 1;
			break;
A
Adrian Hunter 已提交
1008 1009 1010 1011 1012 1013 1014 1015
		case Opt_bulk_read:
			c->mount_opts.bulk_read = 2;
			c->bulk_read = 1;
			break;
		case Opt_no_bulk_read:
			c->mount_opts.bulk_read = 1;
			c->bulk_read = 0;
			break;
1016 1017 1018 1019 1020 1021 1022 1023
		case Opt_chk_data_crc:
			c->mount_opts.chk_data_crc = 2;
			c->no_chk_data_crc = 0;
			break;
		case Opt_no_chk_data_crc:
			c->mount_opts.chk_data_crc = 1;
			c->no_chk_data_crc = 1;
			break;
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
		case Opt_override_compr:
		{
			char *name = match_strdup(&args[0]);

			if (!name)
				return -ENOMEM;
			if (!strcmp(name, "none"))
				c->mount_opts.compr_type = UBIFS_COMPR_NONE;
			else if (!strcmp(name, "lzo"))
				c->mount_opts.compr_type = UBIFS_COMPR_LZO;
			else if (!strcmp(name, "zlib"))
				c->mount_opts.compr_type = UBIFS_COMPR_ZLIB;
			else {
1037
				ubifs_err(c, "unknown compressor \"%s\"", name); //FIXME: is c ready?
1038 1039 1040 1041 1042 1043 1044 1045
				kfree(name);
				return -EINVAL;
			}
			kfree(name);
			c->mount_opts.override_compr = 1;
			c->default_compr = c->mount_opts.compr_type;
			break;
		}
1046
		default:
1047 1048 1049 1050 1051 1052
		{
			unsigned long flag;
			struct super_block *sb = c->vfs_sb;

			flag = parse_standard_option(p);
			if (!flag) {
1053
				ubifs_err(c, "unrecognized mount option \"%s\" or missing value",
1054
					  p);
1055 1056 1057 1058 1059
				return -EINVAL;
			}
			sb->s_flags |= flag;
			break;
		}
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
		}
	}

	return 0;
}

/**
 * destroy_journal - destroy journal data structures.
 * @c: UBIFS file-system description object
 *
 * This function destroys journal data structures including those that may have
 * been created by recovery functions.
 */
static void destroy_journal(struct ubifs_info *c)
{
	while (!list_empty(&c->unclean_leb_list)) {
		struct ubifs_unclean_leb *ucleb;

		ucleb = list_entry(c->unclean_leb_list.next,
				   struct ubifs_unclean_leb, list);
		list_del(&ucleb->list);
		kfree(ucleb);
	}
	while (!list_empty(&c->old_buds)) {
		struct ubifs_bud *bud;

		bud = list_entry(c->old_buds.next, struct ubifs_bud, list);
		list_del(&bud->list);
		kfree(bud);
	}
	ubifs_destroy_idx_gc(c);
	ubifs_destroy_size_tree(c);
	ubifs_tnc_close(c);
	free_buds(c);
}

1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
/**
 * bu_init - initialize bulk-read information.
 * @c: UBIFS file-system description object
 */
static void bu_init(struct ubifs_info *c)
{
	ubifs_assert(c->bulk_read == 1);

	if (c->bu.buf)
		return; /* Already initialized */

again:
	c->bu.buf = kmalloc(c->max_bu_buf_len, GFP_KERNEL | __GFP_NOWARN);
	if (!c->bu.buf) {
		if (c->max_bu_buf_len > UBIFS_KMALLOC_OK) {
			c->max_bu_buf_len = UBIFS_KMALLOC_OK;
			goto again;
		}

		/* Just disable bulk-read */
1116
		ubifs_warn(c, "cannot allocate %d bytes of memory for bulk-read, disabling it",
1117
			   c->max_bu_buf_len);
1118 1119 1120 1121 1122 1123
		c->mount_opts.bulk_read = 1;
		c->bulk_read = 0;
		return;
	}
}

1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
/**
 * check_free_space - check if there is enough free space to mount.
 * @c: UBIFS file-system description object
 *
 * This function makes sure UBIFS has enough free space to be mounted in
 * read/write mode. UBIFS must always have some free space to allow deletions.
 */
static int check_free_space(struct ubifs_info *c)
{
	ubifs_assert(c->dark_wm > 0);
	if (c->lst.total_free + c->lst.total_dirty < c->dark_wm) {
1135
		ubifs_err(c, "insufficient free space to mount in R/W mode");
1136 1137
		ubifs_dump_budg(c, &c->bi);
		ubifs_dump_lprops(c);
1138
		return -ENOSPC;
1139 1140 1141 1142
	}
	return 0;
}

1143 1144 1145 1146 1147 1148 1149 1150 1151
/**
 * mount_ubifs - mount UBIFS file-system.
 * @c: UBIFS file-system description object
 *
 * This function mounts UBIFS file system. Returns zero in case of success and
 * a negative error code in case of failure.
 */
static int mount_ubifs(struct ubifs_info *c)
{
1152
	int err;
A
Artem Bityutskiy 已提交
1153
	long long x, y;
1154 1155
	size_t sz;

1156
	c->ro_mount = !!(c->vfs_sb->s_flags & MS_RDONLY);
1157 1158 1159
	/* Suppress error messages while probing if MS_SILENT is set */
	c->probing = !!(c->vfs_sb->s_flags & MS_SILENT);

1160 1161 1162 1163
	err = init_constants_early(c);
	if (err)
		return err;

1164 1165 1166
	err = ubifs_debugging_init(c);
	if (err)
		return err;
1167 1168 1169 1170 1171

	err = check_volume_empty(c);
	if (err)
		goto out_free;

1172
	if (c->empty && (c->ro_mount || c->ro_media)) {
1173 1174 1175 1176
		/*
		 * This UBI volume is empty, and read-only, or the file system
		 * is mounted read-only - we cannot format it.
		 */
1177
		ubifs_err(c, "can't format empty UBI volume: read-only %s",
1178 1179 1180 1181 1182
			  c->ro_media ? "UBI volume" : "mount");
		err = -EROFS;
		goto out_free;
	}

1183
	if (c->ro_media && !c->ro_mount) {
1184
		ubifs_err(c, "cannot mount read-write - read-only media");
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
		err = -EROFS;
		goto out_free;
	}

	/*
	 * The requirement for the buffer is that it should fit indexing B-tree
	 * height amount of integers. We assume the height if the TNC tree will
	 * never exceed 64.
	 */
	err = -ENOMEM;
	c->bottom_up_buf = kmalloc(BOTTOM_UP_HEIGHT * sizeof(int), GFP_KERNEL);
	if (!c->bottom_up_buf)
		goto out_free;

	c->sbuf = vmalloc(c->leb_size);
	if (!c->sbuf)
		goto out_free;

1203
	if (!c->ro_mount) {
1204 1205 1206 1207 1208
		c->ileb_buf = vmalloc(c->leb_size);
		if (!c->ileb_buf)
			goto out_free;
	}

1209 1210 1211
	if (c->bulk_read == 1)
		bu_init(c);

1212 1213 1214 1215 1216 1217 1218
	if (!c->ro_mount) {
		c->write_reserve_buf = kmalloc(COMPRESSED_DATA_NODE_BUF_SZ,
					       GFP_KERNEL);
		if (!c->write_reserve_buf)
			goto out_free;
	}

1219
	c->mounting = 1;
1220

1221 1222 1223 1224
	err = ubifs_read_superblock(c);
	if (err)
		goto out_free;

1225 1226
	c->probing = 0;

1227
	/*
1228
	 * Make sure the compressor which is set as default in the superblock
1229
	 * or overridden by mount options is actually compiled in.
1230 1231
	 */
	if (!ubifs_compr_present(c->default_compr)) {
1232
		ubifs_err(c, "'compressor \"%s\" is not compiled in",
1233
			  ubifs_compr_name(c->default_compr));
1234
		err = -ENOTSUPP;
1235
		goto out_free;
1236 1237
	}

1238
	err = init_constants_sb(c);
1239
	if (err)
1240
		goto out_free;
1241 1242 1243 1244 1245 1246

	sz = ALIGN(c->max_idx_node_sz, c->min_io_size);
	sz = ALIGN(sz + c->max_idx_node_sz, c->min_io_size);
	c->cbuf = kmalloc(sz, GFP_NOFS);
	if (!c->cbuf) {
		err = -ENOMEM;
1247
		goto out_free;
1248 1249
	}

1250 1251 1252 1253
	err = alloc_wbufs(c);
	if (err)
		goto out_cbuf;

1254
	sprintf(c->bgt_name, BGT_NAME_PATTERN, c->vi.ubi_num, c->vi.vol_id);
1255
	if (!c->ro_mount) {
1256
		/* Create background thread */
H
Hunter Adrian 已提交
1257
		c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name);
1258 1259 1260
		if (IS_ERR(c->bgt)) {
			err = PTR_ERR(c->bgt);
			c->bgt = NULL;
1261
			ubifs_err(c, "cannot spawn \"%s\", error %d",
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
				  c->bgt_name, err);
			goto out_wbufs;
		}
		wake_up_process(c->bgt);
	}

	err = ubifs_read_master(c);
	if (err)
		goto out_master;

B
Ben Gardiner 已提交
1272 1273
	init_constants_master(c);

1274
	if ((c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY)) != 0) {
1275
		ubifs_msg(c, "recovery needed");
1276
		c->need_recovery = 1;
B
Ben Gardiner 已提交
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
	}

	if (c->need_recovery && !c->ro_mount) {
		err = ubifs_recover_inl_heads(c, c->sbuf);
		if (err)
			goto out_master;
	}

	err = ubifs_lpt_init(c, 1, !c->ro_mount);
	if (err)
		goto out_master;

B
Ben Gardiner 已提交
1289 1290 1291
	if (!c->ro_mount && c->space_fixup) {
		err = ubifs_fixup_free_space(c);
		if (err)
1292
			goto out_lpt;
B
Ben Gardiner 已提交
1293 1294
	}

1295
	if (!c->ro_mount && !c->need_recovery) {
1296 1297 1298 1299 1300 1301 1302
		/*
		 * Set the "dirty" flag so that if we reboot uncleanly we
		 * will notice this immediately on the next mount.
		 */
		c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY);
		err = ubifs_write_master(c);
		if (err)
B
Ben Gardiner 已提交
1303
			goto out_lpt;
1304 1305
	}

1306
	err = dbg_check_idx_size(c, c->bi.old_idx_sz);
1307 1308 1309 1310 1311 1312 1313
	if (err)
		goto out_lpt;

	err = ubifs_replay_journal(c);
	if (err)
		goto out_journal;

A
Artem Bityutskiy 已提交
1314
	/* Calculate 'min_idx_lebs' after journal replay */
1315
	c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c);
A
Artem Bityutskiy 已提交
1316

1317
	err = ubifs_mount_orphans(c, c->need_recovery, c->ro_mount);
1318 1319 1320
	if (err)
		goto out_orphans;

1321
	if (!c->ro_mount) {
1322 1323
		int lnum;

1324 1325
		err = check_free_space(c);
		if (err)
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
			goto out_orphans;

		/* Check for enough log space */
		lnum = c->lhead_lnum + 1;
		if (lnum >= UBIFS_LOG_LNUM + c->log_lebs)
			lnum = UBIFS_LOG_LNUM;
		if (lnum == c->ltail_lnum) {
			err = ubifs_consolidate_log(c);
			if (err)
				goto out_orphans;
		}

		if (c->need_recovery) {
			err = ubifs_recover_size(c);
			if (err)
				goto out_orphans;
			err = ubifs_rcvry_gc_commit(c);
A
Artem Bityutskiy 已提交
1343 1344
			if (err)
				goto out_orphans;
1345
		} else {
1346
			err = take_gc_lnum(c);
1347 1348 1349 1350 1351 1352 1353 1354 1355
			if (err)
				goto out_orphans;

			/*
			 * GC LEB may contain garbage if there was an unclean
			 * reboot, and it should be un-mapped.
			 */
			err = ubifs_leb_unmap(c, c->gc_lnum);
			if (err)
1356
				goto out_orphans;
1357
		}
1358 1359 1360 1361 1362 1363 1364 1365

		err = dbg_check_lprops(c);
		if (err)
			goto out_orphans;
	} else if (c->need_recovery) {
		err = ubifs_recover_size(c);
		if (err)
			goto out_orphans;
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
	} else {
		/*
		 * Even if we mount read-only, we have to set space in GC LEB
		 * to proper value because this affects UBIFS free space
		 * reporting. We do not want to have a situation when
		 * re-mounting from R/O to R/W changes amount of free space.
		 */
		err = take_gc_lnum(c);
		if (err)
			goto out_orphans;
1376 1377 1378 1379 1380 1381 1382
	}

	spin_lock(&ubifs_infos_lock);
	list_add_tail(&c->infos_list, &ubifs_infos);
	spin_unlock(&ubifs_infos_lock);

	if (c->need_recovery) {
1383
		if (c->ro_mount)
1384
			ubifs_msg(c, "recovery deferred");
1385 1386
		else {
			c->need_recovery = 0;
1387
			ubifs_msg(c, "recovery completed");
A
Artem Bityutskiy 已提交
1388 1389 1390 1391 1392 1393
			/*
			 * GC LEB has to be empty and taken at this point. But
			 * the journal head LEBs may also be accounted as
			 * "empty taken" if they are empty.
			 */
			ubifs_assert(c->lst.taken_empty_lebs > 0);
1394
		}
A
Artem Bityutskiy 已提交
1395
	} else
A
Artem Bityutskiy 已提交
1396
		ubifs_assert(c->lst.taken_empty_lebs > 0);
1397

A
Artem Bityutskiy 已提交
1398
	err = dbg_check_filesystem(c);
A
Artem Bityutskiy 已提交
1399 1400 1401
	if (err)
		goto out_infos;

A
Artem Bityutskiy 已提交
1402
	err = dbg_debugfs_init_fs(c);
1403 1404 1405
	if (err)
		goto out_infos;

1406
	c->mounting = 0;
1407

1408
	ubifs_msg(c, "UBIFS: mounted UBI device %d, volume %d, name \"%s\"%s",
A
Artem Bityutskiy 已提交
1409
		  c->vi.ubi_num, c->vi.vol_id, c->vi.name,
R
Richard Genoud 已提交
1410
		  c->ro_mount ? ", R/O mode" : "");
1411
	x = (long long)c->main_lebs * c->leb_size;
A
Artem Bityutskiy 已提交
1412
	y = (long long)c->log_lebs * c->leb_size + c->max_bud_bytes;
1413
	ubifs_msg(c, "LEB size: %d bytes (%d KiB), min./max. I/O unit sizes: %d bytes/%d bytes",
A
Artem Bityutskiy 已提交
1414 1415
		  c->leb_size, c->leb_size >> 10, c->min_io_size,
		  c->max_write_size);
1416
	ubifs_msg(c, "FS size: %lld bytes (%lld MiB, %d LEBs), journal size %lld bytes (%lld MiB, %d LEBs)",
A
Artem Bityutskiy 已提交
1417 1418
		  x, x >> 20, c->main_lebs,
		  y, y >> 20, c->log_lebs + c->max_bud_cnt);
1419
	ubifs_msg(c, "reserved for root: %llu bytes (%llu KiB)",
A
Artem Bityutskiy 已提交
1420
		  c->report_rp_size, c->report_rp_size >> 10);
1421
	ubifs_msg(c, "media format: w%d/r%d (latest is w%d/r%d), UUID %pUB%s",
A
Artem Bityutskiy 已提交
1422
		  c->fmt_version, c->ro_compat_version,
A
Artem Bityutskiy 已提交
1423 1424 1425 1426 1427
		  UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION, c->uuid,
		  c->big_lpt ? ", big LPT model" : ", small LPT model");

	dbg_gen("default compressor:  %s", ubifs_compr_name(c->default_compr));
	dbg_gen("data journal heads:  %d",
1428
		c->jhead_cnt - NONDATA_JHEADS_CNT);
A
Artem Bityutskiy 已提交
1429
	dbg_gen("log LEBs:            %d (%d - %d)",
1430
		c->log_lebs, UBIFS_LOG_LNUM, c->log_last);
A
Artem Bityutskiy 已提交
1431
	dbg_gen("LPT area LEBs:       %d (%d - %d)",
1432
		c->lpt_lebs, c->lpt_first, c->lpt_last);
A
Artem Bityutskiy 已提交
1433
	dbg_gen("orphan area LEBs:    %d (%d - %d)",
1434
		c->orph_lebs, c->orph_first, c->orph_last);
A
Artem Bityutskiy 已提交
1435
	dbg_gen("main area LEBs:      %d (%d - %d)",
1436
		c->main_lebs, c->main_first, c->leb_cnt - 1);
A
Artem Bityutskiy 已提交
1437 1438
	dbg_gen("index LEBs:          %d", c->lst.idx_lebs);
	dbg_gen("total index bytes:   %lld (%lld KiB, %lld MiB)",
1439 1440
		c->bi.old_idx_sz, c->bi.old_idx_sz >> 10,
		c->bi.old_idx_sz >> 20);
A
Artem Bityutskiy 已提交
1441 1442 1443 1444 1445 1446
	dbg_gen("key hash type:       %d", c->key_hash_type);
	dbg_gen("tree fanout:         %d", c->fanout);
	dbg_gen("reserved GC LEB:     %d", c->gc_lnum);
	dbg_gen("max. znode size      %d", c->max_znode_sz);
	dbg_gen("max. index node size %d", c->max_idx_node_sz);
	dbg_gen("node sizes:          data %zu, inode %zu, dentry %zu",
1447
		UBIFS_DATA_NODE_SZ, UBIFS_INO_NODE_SZ, UBIFS_DENT_NODE_SZ);
A
Artem Bityutskiy 已提交
1448
	dbg_gen("node sizes:          trun %zu, sb %zu, master %zu",
1449
		UBIFS_TRUN_NODE_SZ, UBIFS_SB_NODE_SZ, UBIFS_MST_NODE_SZ);
A
Artem Bityutskiy 已提交
1450
	dbg_gen("node sizes:          ref %zu, cmt. start %zu, orph %zu",
1451
		UBIFS_REF_NODE_SZ, UBIFS_CS_NODE_SZ, UBIFS_ORPH_NODE_SZ);
A
Artem Bityutskiy 已提交
1452
	dbg_gen("max. node sizes:     data %zu, inode %zu dentry %zu, idx %d",
1453
		UBIFS_MAX_DATA_NODE_SZ, UBIFS_MAX_INO_NODE_SZ,
1454
		UBIFS_MAX_DENT_NODE_SZ, ubifs_idx_node_sz(c, c->fanout));
A
Artem Bityutskiy 已提交
1455 1456 1457
	dbg_gen("dead watermark:      %d", c->dead_wm);
	dbg_gen("dark watermark:      %d", c->dark_wm);
	dbg_gen("LEB overhead:        %d", c->leb_overhead);
1458
	x = (long long)c->main_lebs * c->dark_wm;
A
Artem Bityutskiy 已提交
1459
	dbg_gen("max. dark space:     %lld (%lld KiB, %lld MiB)",
1460
		x, x >> 10, x >> 20);
A
Artem Bityutskiy 已提交
1461
	dbg_gen("maximum bud bytes:   %lld (%lld KiB, %lld MiB)",
1462 1463
		c->max_bud_bytes, c->max_bud_bytes >> 10,
		c->max_bud_bytes >> 20);
A
Artem Bityutskiy 已提交
1464
	dbg_gen("BG commit bud bytes: %lld (%lld KiB, %lld MiB)",
1465 1466
		c->bg_bud_bytes, c->bg_bud_bytes >> 10,
		c->bg_bud_bytes >> 20);
A
Artem Bityutskiy 已提交
1467
	dbg_gen("current bud bytes    %lld (%lld KiB, %lld MiB)",
1468
		c->bud_bytes, c->bud_bytes >> 10, c->bud_bytes >> 20);
A
Artem Bityutskiy 已提交
1469 1470
	dbg_gen("max. seq. number:    %llu", c->max_sqnum);
	dbg_gen("commit number:       %llu", c->cmt_no);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493

	return 0;

out_infos:
	spin_lock(&ubifs_infos_lock);
	list_del(&c->infos_list);
	spin_unlock(&ubifs_infos_lock);
out_orphans:
	free_orphans(c);
out_journal:
	destroy_journal(c);
out_lpt:
	ubifs_lpt_free(c, 0);
out_master:
	kfree(c->mst_node);
	kfree(c->rcvrd_mst_node);
	if (c->bgt)
		kthread_stop(c->bgt);
out_wbufs:
	free_wbufs(c);
out_cbuf:
	kfree(c->cbuf);
out_free:
1494
	kfree(c->write_reserve_buf);
1495
	kfree(c->bu.buf);
1496 1497 1498
	vfree(c->ileb_buf);
	vfree(c->sbuf);
	kfree(c->bottom_up_buf);
1499
	ubifs_debugging_exit(c);
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
	return err;
}

/**
 * ubifs_umount - un-mount UBIFS file-system.
 * @c: UBIFS file-system description object
 *
 * Note, this function is called to free allocated resourced when un-mounting,
 * as well as free resources when an error occurred while we were half way
 * through mounting (error path cleanup function). So it has to make sure the
 * resource was actually allocated before freeing it.
 */
static void ubifs_umount(struct ubifs_info *c)
{
	dbg_gen("un-mounting UBI device %d, volume %d", c->vi.ubi_num,
		c->vi.vol_id);

A
Artem Bityutskiy 已提交
1517
	dbg_debugfs_exit_fs(c);
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
	spin_lock(&ubifs_infos_lock);
	list_del(&c->infos_list);
	spin_unlock(&ubifs_infos_lock);

	if (c->bgt)
		kthread_stop(c->bgt);

	destroy_journal(c);
	free_wbufs(c);
	free_orphans(c);
	ubifs_lpt_free(c, 0);

	kfree(c->cbuf);
	kfree(c->rcvrd_mst_node);
	kfree(c->mst_node);
1533
	kfree(c->write_reserve_buf);
1534 1535
	kfree(c->bu.buf);
	vfree(c->ileb_buf);
1536 1537
	vfree(c->sbuf);
	kfree(c->bottom_up_buf);
1538
	ubifs_debugging_exit(c);
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
}

/**
 * ubifs_remount_rw - re-mount in read-write mode.
 * @c: UBIFS file-system description object
 *
 * UBIFS avoids allocating many unnecessary resources when mounted in read-only
 * mode. This function allocates the needed resources and re-mounts UBIFS in
 * read-write mode.
 */
static int ubifs_remount_rw(struct ubifs_info *c)
{
	int err, lnum;

A
Artem Bityutskiy 已提交
1553
	if (c->rw_incompat) {
1554 1555
		ubifs_err(c, "the file-system is not R/W-compatible");
		ubifs_msg(c, "on-flash format version is w%d/r%d, but software only supports up to version w%d/r%d",
1556 1557
			  c->fmt_version, c->ro_compat_version,
			  UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION);
A
Artem Bityutskiy 已提交
1558 1559 1560
		return -EROFS;
	}

1561
	mutex_lock(&c->umount_mutex);
1562
	dbg_save_space_info(c);
1563
	c->remounting_rw = 1;
A
Artem Bityutskiy 已提交
1564
	c->ro_mount = 0;
1565

1566 1567 1568
	if (c->space_fixup) {
		err = ubifs_fixup_free_space(c);
		if (err)
A
Artem Bityutskiy 已提交
1569
			goto out;
1570 1571
	}

1572 1573
	err = check_free_space(c);
	if (err)
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
		goto out;

	if (c->old_leb_cnt != c->leb_cnt) {
		struct ubifs_sb_node *sup;

		sup = ubifs_read_sb_node(c);
		if (IS_ERR(sup)) {
			err = PTR_ERR(sup);
			goto out;
		}
		sup->leb_cnt = cpu_to_le32(c->leb_cnt);
		err = ubifs_write_sb_node(c, sup);
1586
		kfree(sup);
1587 1588 1589 1590 1591
		if (err)
			goto out;
	}

	if (c->need_recovery) {
1592
		ubifs_msg(c, "completing deferred recovery");
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
		err = ubifs_write_rcvrd_mst_node(c);
		if (err)
			goto out;
		err = ubifs_recover_size(c);
		if (err)
			goto out;
		err = ubifs_clean_lebs(c, c->sbuf);
		if (err)
			goto out;
		err = ubifs_recover_inl_heads(c, c->sbuf);
		if (err)
			goto out;
1605 1606 1607 1608 1609 1610
	} else {
		/* A readonly mount is not allowed to have orphans */
		ubifs_assert(c->tot_orphans == 0);
		err = ubifs_clear_orphans(c);
		if (err)
			goto out;
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
	}

	if (!(c->mst_node->flags & cpu_to_le32(UBIFS_MST_DIRTY))) {
		c->mst_node->flags |= cpu_to_le32(UBIFS_MST_DIRTY);
		err = ubifs_write_master(c);
		if (err)
			goto out;
	}

	c->ileb_buf = vmalloc(c->leb_size);
	if (!c->ileb_buf) {
		err = -ENOMEM;
		goto out;
	}

1626
	c->write_reserve_buf = kmalloc(COMPRESSED_DATA_NODE_BUF_SZ, GFP_KERNEL);
W
Wei Yongjun 已提交
1627 1628
	if (!c->write_reserve_buf) {
		err = -ENOMEM;
1629
		goto out;
W
Wei Yongjun 已提交
1630
	}
1631

1632 1633 1634 1635 1636
	err = ubifs_lpt_init(c, 0, 1);
	if (err)
		goto out;

	/* Create background thread */
H
Hunter Adrian 已提交
1637
	c->bgt = kthread_create(ubifs_bg_thread, c, "%s", c->bgt_name);
1638 1639 1640
	if (IS_ERR(c->bgt)) {
		err = PTR_ERR(c->bgt);
		c->bgt = NULL;
1641
		ubifs_err(c, "cannot spawn \"%s\", error %d",
1642
			  c->bgt_name, err);
1643
		goto out;
1644 1645 1646 1647
	}
	wake_up_process(c->bgt);

	c->orph_buf = vmalloc(c->leb_size);
1648 1649 1650 1651
	if (!c->orph_buf) {
		err = -ENOMEM;
		goto out;
	}
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665

	/* Check for enough log space */
	lnum = c->lhead_lnum + 1;
	if (lnum >= UBIFS_LOG_LNUM + c->log_lebs)
		lnum = UBIFS_LOG_LNUM;
	if (lnum == c->ltail_lnum) {
		err = ubifs_consolidate_log(c);
		if (err)
			goto out;
	}

	if (c->need_recovery)
		err = ubifs_rcvry_gc_commit(c);
	else
1666
		err = ubifs_leb_unmap(c, c->gc_lnum);
1667 1668 1669
	if (err)
		goto out;

1670 1671 1672
	dbg_gen("re-mounted read-write");
	c->remounting_rw = 0;

1673 1674
	if (c->need_recovery) {
		c->need_recovery = 0;
1675
		ubifs_msg(c, "deferred recovery completed");
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
	} else {
		/*
		 * Do not run the debugging space check if the were doing
		 * recovery, because when we saved the information we had the
		 * file-system in a state where the TNC and lprops has been
		 * modified in memory, but all the I/O operations (including a
		 * commit) were deferred. So the file-system was in
		 * "non-committed" state. Now the file-system is in committed
		 * state, and of course the amount of free space will change
		 * because, for example, the old index size was imprecise.
		 */
		err = dbg_check_space_info(c);
1688
	}
1689

1690
	mutex_unlock(&c->umount_mutex);
1691
	return err;
1692 1693

out:
A
Artem Bityutskiy 已提交
1694
	c->ro_mount = 1;
1695 1696 1697 1698 1699 1700 1701
	vfree(c->orph_buf);
	c->orph_buf = NULL;
	if (c->bgt) {
		kthread_stop(c->bgt);
		c->bgt = NULL;
	}
	free_wbufs(c);
1702 1703
	kfree(c->write_reserve_buf);
	c->write_reserve_buf = NULL;
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
	vfree(c->ileb_buf);
	c->ileb_buf = NULL;
	ubifs_lpt_free(c, 1);
	c->remounting_rw = 0;
	mutex_unlock(&c->umount_mutex);
	return err;
}

/**
 * ubifs_remount_ro - re-mount in read-only mode.
 * @c: UBIFS file-system description object
 *
1716 1717
 * We assume VFS has stopped writing. Possibly the background thread could be
 * running a commit, however kthread_stop will wait in that case.
1718 1719 1720 1721 1722 1723
 */
static void ubifs_remount_ro(struct ubifs_info *c)
{
	int i, err;

	ubifs_assert(!c->need_recovery);
1724
	ubifs_assert(!c->ro_mount);
A
Artem Bityutskiy 已提交
1725

1726 1727 1728 1729 1730 1731
	mutex_lock(&c->umount_mutex);
	if (c->bgt) {
		kthread_stop(c->bgt);
		c->bgt = NULL;
	}

1732 1733
	dbg_save_space_info(c);

1734
	for (i = 0; i < c->jhead_cnt; i++)
1735 1736
		ubifs_wbuf_sync(&c->jheads[i].wbuf);

A
Artem Bityutskiy 已提交
1737 1738 1739 1740 1741 1742 1743
	c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY);
	c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS);
	c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum);
	err = ubifs_write_master(c);
	if (err)
		ubifs_ro_mode(c, err);

1744 1745
	vfree(c->orph_buf);
	c->orph_buf = NULL;
1746 1747
	kfree(c->write_reserve_buf);
	c->write_reserve_buf = NULL;
1748 1749 1750
	vfree(c->ileb_buf);
	c->ileb_buf = NULL;
	ubifs_lpt_free(c, 1);
1751
	c->ro_mount = 1;
1752 1753 1754
	err = dbg_check_space_info(c);
	if (err)
		ubifs_ro_mode(c, err);
1755 1756 1757 1758 1759 1760 1761 1762
	mutex_unlock(&c->umount_mutex);
}

static void ubifs_put_super(struct super_block *sb)
{
	int i;
	struct ubifs_info *c = sb->s_fs_info;

1763
	ubifs_msg(c, "un-mount UBI device %d", c->vi.ubi_num);
1764

1765 1766 1767 1768 1769
	/*
	 * The following asserts are only valid if there has not been a failure
	 * of the media. For example, there will be dirty inodes if we failed
	 * to write them back because of I/O errors.
	 */
1770
	if (!c->ro_error) {
1771 1772 1773
		ubifs_assert(c->bi.idx_growth == 0);
		ubifs_assert(c->bi.dd_growth == 0);
		ubifs_assert(c->bi.data_growth == 0);
1774
	}
1775 1776 1777 1778 1779 1780 1781 1782

	/*
	 * The 'c->umount_lock' prevents races between UBIFS memory shrinker
	 * and file system un-mount. Namely, it prevents the shrinker from
	 * picking this superblock for shrinking - it will be just skipped if
	 * the mutex is locked.
	 */
	mutex_lock(&c->umount_mutex);
1783
	if (!c->ro_mount) {
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
		/*
		 * First of all kill the background thread to make sure it does
		 * not interfere with un-mounting and freeing resources.
		 */
		if (c->bgt) {
			kthread_stop(c->bgt);
			c->bgt = NULL;
		}

		/*
1794
		 * On fatal errors c->ro_error is set to 1, in which case we do
1795 1796
		 * not write the master node.
		 */
1797
		if (!c->ro_error) {
1798 1799 1800
			int err;

			/* Synchronize write-buffers */
1801 1802
			for (i = 0; i < c->jhead_cnt; i++)
				ubifs_wbuf_sync(&c->jheads[i].wbuf);
1803

1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
			/*
			 * We are being cleanly unmounted which means the
			 * orphans were killed - indicate this in the master
			 * node. Also save the reserved GC LEB number.
			 */
			c->mst_node->flags &= ~cpu_to_le32(UBIFS_MST_DIRTY);
			c->mst_node->flags |= cpu_to_le32(UBIFS_MST_NO_ORPHS);
			c->mst_node->gc_lnum = cpu_to_le32(c->gc_lnum);
			err = ubifs_write_master(c);
			if (err)
				/*
				 * Recovery will attempt to fix the master area
				 * next mount, so we just print a message and
				 * continue to unmount normally.
				 */
1819
				ubifs_err(c, "failed to write master node, error %d",
1820
					  err);
1821 1822 1823 1824
		} else {
			for (i = 0; i < c->jhead_cnt; i++)
				/* Make sure write-buffer timers are canceled */
				hrtimer_cancel(&c->jheads[i].wbuf.timer);
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
		}
	}

	ubifs_umount(c);
	bdi_destroy(&c->bdi);
	ubi_close_volume(c->ubi);
	mutex_unlock(&c->umount_mutex);
}

static int ubifs_remount_fs(struct super_block *sb, int *flags, char *data)
{
	int err;
	struct ubifs_info *c = sb->s_fs_info;

1839
	sync_filesystem(sb);
1840 1841 1842 1843
	dbg_gen("old flags %#lx, new flags %#x", sb->s_flags, *flags);

	err = ubifs_parse_options(c, data, 1);
	if (err) {
1844
		ubifs_err(c, "invalid or unknown remount parameter");
1845 1846
		return err;
	}
1847

1848
	if (c->ro_mount && !(*flags & MS_RDONLY)) {
1849
		if (c->ro_error) {
1850
			ubifs_msg(c, "cannot re-mount R/W due to prior errors");
1851 1852
			return -EROFS;
		}
A
Artem Bityutskiy 已提交
1853
		if (c->ro_media) {
1854
			ubifs_msg(c, "cannot re-mount R/W - UBI volume is R/O");
1855
			return -EROFS;
A
Artem Bityutskiy 已提交
1856
		}
1857
		err = ubifs_remount_rw(c);
A
Artem Bityutskiy 已提交
1858
		if (err)
1859
			return err;
1860
	} else if (!c->ro_mount && (*flags & MS_RDONLY)) {
1861
		if (c->ro_error) {
1862
			ubifs_msg(c, "cannot re-mount R/O due to prior errors");
1863
			return -EROFS;
A
Adrian Hunter 已提交
1864
		}
1865
		ubifs_remount_ro(c);
A
Adrian Hunter 已提交
1866
	}
1867

1868 1869 1870 1871 1872 1873 1874 1875
	if (c->bulk_read == 1)
		bu_init(c);
	else {
		dbg_gen("disable bulk-read");
		kfree(c->bu.buf);
		c->bu.buf = NULL;
	}

A
Artem Bityutskiy 已提交
1876
	ubifs_assert(c->lst.taken_empty_lebs > 0);
1877 1878 1879
	return 0;
}

A
Artem Bityutskiy 已提交
1880
const struct super_operations ubifs_super_operations = {
1881 1882 1883 1884
	.alloc_inode   = ubifs_alloc_inode,
	.destroy_inode = ubifs_destroy_inode,
	.put_super     = ubifs_put_super,
	.write_inode   = ubifs_write_inode,
A
Al Viro 已提交
1885
	.evict_inode   = ubifs_evict_inode,
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
	.statfs        = ubifs_statfs,
	.dirty_inode   = ubifs_dirty_inode,
	.remount_fs    = ubifs_remount_fs,
	.show_options  = ubifs_show_options,
	.sync_fs       = ubifs_sync_fs,
};

/**
 * open_ubi - parse UBI device name string and open the UBI device.
 * @name: UBI volume name
 * @mode: UBI volume open mode
 *
1898 1899 1900 1901 1902 1903
 * The primary method of mounting UBIFS is by specifying the UBI volume
 * character device node path. However, UBIFS may also be mounted withoug any
 * character device node using one of the following methods:
 *
 * o ubiX_Y    - mount UBI device number X, volume Y;
 * o ubiY      - mount UBI device number 0, volume Y;
1904 1905 1906 1907 1908
 * o ubiX:NAME - mount UBI device X, volume with name NAME;
 * o ubi:NAME  - mount UBI device 0, volume with name NAME.
 *
 * Alternative '!' separator may be used instead of ':' (because some shells
 * like busybox may interpret ':' as an NFS host name separator). This function
1909 1910
 * returns UBI volume description object in case of success and a negative
 * error code in case of failure.
1911 1912 1913
 */
static struct ubi_volume_desc *open_ubi(const char *name, int mode)
{
1914
	struct ubi_volume_desc *ubi;
1915 1916 1917
	int dev, vol;
	char *endptr;

1918 1919 1920 1921 1922 1923
	/* First, try to open using the device node path method */
	ubi = ubi_open_volume_path(name, mode);
	if (!IS_ERR(ubi))
		return ubi;

	/* Try the "nodev" method */
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954
	if (name[0] != 'u' || name[1] != 'b' || name[2] != 'i')
		return ERR_PTR(-EINVAL);

	/* ubi:NAME method */
	if ((name[3] == ':' || name[3] == '!') && name[4] != '\0')
		return ubi_open_volume_nm(0, name + 4, mode);

	if (!isdigit(name[3]))
		return ERR_PTR(-EINVAL);

	dev = simple_strtoul(name + 3, &endptr, 0);

	/* ubiY method */
	if (*endptr == '\0')
		return ubi_open_volume(0, dev, mode);

	/* ubiX_Y method */
	if (*endptr == '_' && isdigit(endptr[1])) {
		vol = simple_strtoul(endptr + 1, &endptr, 0);
		if (*endptr != '\0')
			return ERR_PTR(-EINVAL);
		return ubi_open_volume(dev, vol, mode);
	}

	/* ubiX:NAME method */
	if ((*endptr == ':' || *endptr == '!') && endptr[1] != '\0')
		return ubi_open_volume_nm(dev, ++endptr, mode);

	return ERR_PTR(-EINVAL);
}

1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
static struct ubifs_info *alloc_ubifs_info(struct ubi_volume_desc *ubi)
{
	struct ubifs_info *c;

	c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL);
	if (c) {
		spin_lock_init(&c->cnt_lock);
		spin_lock_init(&c->cs_lock);
		spin_lock_init(&c->buds_lock);
		spin_lock_init(&c->space_lock);
		spin_lock_init(&c->orphan_lock);
		init_rwsem(&c->commit_sem);
		mutex_init(&c->lp_mutex);
		mutex_init(&c->tnc_mutex);
		mutex_init(&c->log_mutex);
		mutex_init(&c->umount_mutex);
		mutex_init(&c->bu_mutex);
		mutex_init(&c->write_reserve_mutex);
		init_waitqueue_head(&c->cmt_wq);
		c->buds = RB_ROOT;
		c->old_idx = RB_ROOT;
		c->size_tree = RB_ROOT;
		c->orph_tree = RB_ROOT;
		INIT_LIST_HEAD(&c->infos_list);
		INIT_LIST_HEAD(&c->idx_gc);
		INIT_LIST_HEAD(&c->replay_list);
		INIT_LIST_HEAD(&c->replay_buds);
		INIT_LIST_HEAD(&c->uncat_list);
		INIT_LIST_HEAD(&c->empty_list);
		INIT_LIST_HEAD(&c->freeable_list);
		INIT_LIST_HEAD(&c->frdi_idx_list);
		INIT_LIST_HEAD(&c->unclean_leb_list);
		INIT_LIST_HEAD(&c->old_buds);
		INIT_LIST_HEAD(&c->orph_list);
		INIT_LIST_HEAD(&c->orph_new);
		c->no_chk_data_crc = 1;

		c->highest_inum = UBIFS_FIRST_INO;
		c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM;

		ubi_get_volume_info(ubi, &c->vi);
		ubi_get_device_info(c->vi.ubi_num, &c->di);
	}
	return c;
}

2001 2002 2003 2004 2005 2006
#ifndef CONFIG_UBIFS_FS_ENCRYPTION
struct fscrypt_operations ubifs_crypt_operations = {
	.is_encrypted		= ubifs_crypt_is_encrypted,
};
#endif

2007 2008
static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
{
A
Al Viro 已提交
2009
	struct ubifs_info *c = sb->s_fs_info;
2010 2011 2012
	struct inode *root;
	int err;

2013
	c->vfs_sb = sb;
2014 2015 2016 2017
	/* Re-open the UBI device in read-write mode */
	c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READWRITE);
	if (IS_ERR(c->ubi)) {
		err = PTR_ERR(c->ubi);
A
Al Viro 已提交
2018
		goto out;
2019 2020 2021
	}

	/*
A
Artem Bityutskiy 已提交
2022
	 * UBIFS provides 'backing_dev_info' in order to disable read-ahead. For
2023 2024
	 * UBIFS, I/O is not deferred, it is done immediately in readpage,
	 * which means the user would have to wait not just for their own I/O
A
Artem Bityutskiy 已提交
2025
	 * but the read-ahead I/O as well i.e. completely pointless.
2026 2027 2028
	 *
	 * Read-ahead will be disabled because @c->bdi.ra_pages is 0.
	 */
2029
	c->bdi.name = "ubifs",
2030
	c->bdi.capabilities = 0;
2031 2032 2033
	err  = bdi_init(&c->bdi);
	if (err)
		goto out_close;
2034 2035
	err = bdi_register(&c->bdi, NULL, "ubifs_%d_%d",
			   c->vi.ubi_num, c->vi.vol_id);
J
Jens Axboe 已提交
2036 2037
	if (err)
		goto out_bdi;
2038 2039 2040 2041 2042

	err = ubifs_parse_options(c, data, 0);
	if (err)
		goto out_bdi;

J
Jens Axboe 已提交
2043
	sb->s_bdi = &c->bdi;
2044 2045 2046 2047 2048 2049 2050 2051
	sb->s_fs_info = c;
	sb->s_magic = UBIFS_SUPER_MAGIC;
	sb->s_blocksize = UBIFS_BLOCK_SIZE;
	sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT;
	sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c);
	if (c->max_inode_sz > MAX_LFS_FILESIZE)
		sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE;
	sb->s_op = &ubifs_super_operations;
2052
	sb->s_xattr = ubifs_xattr_handlers;
2053
	sb->s_cop = &ubifs_crypt_operations;
2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068

	mutex_lock(&c->umount_mutex);
	err = mount_ubifs(c);
	if (err) {
		ubifs_assert(err < 0);
		goto out_unlock;
	}

	/* Read the root inode */
	root = ubifs_iget(sb, UBIFS_ROOT_INO);
	if (IS_ERR(root)) {
		err = PTR_ERR(root);
		goto out_umount;
	}

2069
	sb->s_root = d_make_root(root);
W
Wei Yongjun 已提交
2070 2071
	if (!sb->s_root) {
		err = -ENOMEM;
2072
		goto out_umount;
W
Wei Yongjun 已提交
2073
	}
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085

	mutex_unlock(&c->umount_mutex);
	return 0;

out_umount:
	ubifs_umount(c);
out_unlock:
	mutex_unlock(&c->umount_mutex);
out_bdi:
	bdi_destroy(&c->bdi);
out_close:
	ubi_close_volume(c->ubi);
A
Al Viro 已提交
2086
out:
2087 2088 2089 2090 2091
	return err;
}

static int sb_test(struct super_block *sb, void *data)
{
A
Al Viro 已提交
2092
	struct ubifs_info *c1 = data;
A
Artem Bityutskiy 已提交
2093
	struct ubifs_info *c = sb->s_fs_info;
2094

A
Al Viro 已提交
2095 2096 2097 2098 2099 2100 2101
	return c->vi.cdev == c1->vi.cdev;
}

static int sb_set(struct super_block *sb, void *data)
{
	sb->s_fs_info = data;
	return set_anon_super(sb, NULL);
2102 2103
}

A
Al Viro 已提交
2104 2105
static struct dentry *ubifs_mount(struct file_system_type *fs_type, int flags,
			const char *name, void *data)
2106 2107
{
	struct ubi_volume_desc *ubi;
A
Al Viro 已提交
2108
	struct ubifs_info *c;
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
	struct super_block *sb;
	int err;

	dbg_gen("name %s, flags %#x", name, flags);

	/*
	 * Get UBI device number and volume ID. Mount it read-only so far
	 * because this might be a new mount point, and UBI allows only one
	 * read-write user at a time.
	 */
	ubi = open_ubi(name, UBI_READONLY);
	if (IS_ERR(ubi)) {
2121 2122 2123
		if (!(flags & MS_SILENT))
			pr_err("UBIFS error (pid: %d): cannot open \"%s\", error %d",
			       current->pid, name, (int)PTR_ERR(ubi));
A
Al Viro 已提交
2124
		return ERR_CAST(ubi);
2125 2126
	}

A
Al Viro 已提交
2127 2128 2129 2130 2131 2132 2133
	c = alloc_ubifs_info(ubi);
	if (!c) {
		err = -ENOMEM;
		goto out_close;
	}

	dbg_gen("opened ubi%d_%d", c->vi.ubi_num, c->vi.vol_id);
2134

D
David Howells 已提交
2135
	sb = sget(fs_type, sb_test, sb_set, flags, c);
2136 2137
	if (IS_ERR(sb)) {
		err = PTR_ERR(sb);
A
Al Viro 已提交
2138
		kfree(c);
2139
		goto out_close;
2140 2141 2142
	}

	if (sb->s_root) {
2143
		struct ubifs_info *c1 = sb->s_fs_info;
A
Al Viro 已提交
2144
		kfree(c);
2145 2146
		/* A new mount point for already mounted UBIFS */
		dbg_gen("this ubi volume is already mounted");
2147
		if (!!(flags & MS_RDONLY) != c1->ro_mount) {
2148 2149 2150 2151 2152 2153 2154 2155
			err = -EBUSY;
			goto out_deact;
		}
	} else {
		err = ubifs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
		if (err)
			goto out_deact;
		/* We do not support atime */
2156 2157 2158 2159 2160 2161
		sb->s_flags |= MS_ACTIVE;
#ifndef CONFIG_UBIFS_ATIME_SUPPORT
		sb->s_flags |= MS_NOATIME;
#else
		ubifs_msg(c, "full atime support is enabled.");
#endif
2162 2163 2164 2165 2166
	}

	/* 'fill_super()' opens ubi again so we must close it here */
	ubi_close_volume(ubi);

A
Al Viro 已提交
2167
	return dget(sb->s_root);
2168 2169

out_deact:
2170
	deactivate_locked_super(sb);
2171 2172
out_close:
	ubi_close_volume(ubi);
A
Al Viro 已提交
2173
	return ERR_PTR(err);
2174 2175
}

A
Al Viro 已提交
2176 2177 2178 2179 2180 2181 2182
static void kill_ubifs_super(struct super_block *s)
{
	struct ubifs_info *c = s->s_fs_info;
	kill_anon_super(s);
	kfree(c);
}

2183 2184 2185
static struct file_system_type ubifs_fs_type = {
	.name    = "ubifs",
	.owner   = THIS_MODULE,
A
Al Viro 已提交
2186
	.mount   = ubifs_mount,
A
Al Viro 已提交
2187
	.kill_sb = kill_ubifs_super,
2188
};
2189
MODULE_ALIAS_FS("ubifs");
2190 2191 2192 2193

/*
 * Inode slab cache constructor.
 */
2194
static void inode_slab_ctor(void *obj)
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
{
	struct ubifs_inode *ui = obj;
	inode_init_once(&ui->vfs_inode);
}

static int __init ubifs_init(void)
{
	int err;

	BUILD_BUG_ON(sizeof(struct ubifs_ch) != 24);

	/* Make sure node sizes are 8-byte aligned */
	BUILD_BUG_ON(UBIFS_CH_SZ        & 7);
	BUILD_BUG_ON(UBIFS_INO_NODE_SZ  & 7);
	BUILD_BUG_ON(UBIFS_DENT_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_XENT_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_DATA_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_SB_NODE_SZ   & 7);
	BUILD_BUG_ON(UBIFS_MST_NODE_SZ  & 7);
	BUILD_BUG_ON(UBIFS_REF_NODE_SZ  & 7);
	BUILD_BUG_ON(UBIFS_CS_NODE_SZ   & 7);
	BUILD_BUG_ON(UBIFS_ORPH_NODE_SZ & 7);

	BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ & 7);
	BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ  & 7);
	BUILD_BUG_ON(UBIFS_MAX_NODE_SZ      & 7);
	BUILD_BUG_ON(MIN_WRITE_SZ           & 7);

	/* Check min. node size */
	BUILD_BUG_ON(UBIFS_INO_NODE_SZ  < MIN_WRITE_SZ);
	BUILD_BUG_ON(UBIFS_DENT_NODE_SZ < MIN_WRITE_SZ);
	BUILD_BUG_ON(UBIFS_XENT_NODE_SZ < MIN_WRITE_SZ);
	BUILD_BUG_ON(UBIFS_TRUN_NODE_SZ < MIN_WRITE_SZ);

	BUILD_BUG_ON(UBIFS_MAX_DENT_NODE_SZ > UBIFS_MAX_NODE_SZ);
	BUILD_BUG_ON(UBIFS_MAX_XENT_NODE_SZ > UBIFS_MAX_NODE_SZ);
	BUILD_BUG_ON(UBIFS_MAX_DATA_NODE_SZ > UBIFS_MAX_NODE_SZ);
	BUILD_BUG_ON(UBIFS_MAX_INO_NODE_SZ  > UBIFS_MAX_NODE_SZ);

	/* Defined node sizes */
	BUILD_BUG_ON(UBIFS_SB_NODE_SZ  != 4096);
	BUILD_BUG_ON(UBIFS_MST_NODE_SZ != 512);
	BUILD_BUG_ON(UBIFS_INO_NODE_SZ != 160);
	BUILD_BUG_ON(UBIFS_REF_NODE_SZ != 64);

2243 2244 2245
	/*
	 * We use 2 bit wide bit-fields to store compression type, which should
	 * be amended if more compressors are added. The bit-fields are:
2246 2247
	 * @compr_type in 'struct ubifs_inode', @default_compr in
	 * 'struct ubifs_info' and @compr_type in 'struct ubifs_mount_opts'.
2248 2249 2250
	 */
	BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4);

2251
	/*
2252
	 * We require that PAGE_SIZE is greater-than-or-equal-to
2253 2254
	 * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2.
	 */
2255
	if (PAGE_SIZE < UBIFS_BLOCK_SIZE) {
2256
		pr_err("UBIFS error (pid %d): VFS page cache size is %u bytes, but UBIFS requires at least 4096 bytes",
2257
		       current->pid, (unsigned int)PAGE_SIZE);
2258 2259 2260 2261 2262
		return -EINVAL;
	}

	ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab",
				sizeof(struct ubifs_inode), 0,
2263 2264
				SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT |
				SLAB_ACCOUNT, &inode_slab_ctor);
2265
	if (!ubifs_inode_slab)
A
Al Viro 已提交
2266
		return -ENOMEM;
2267

2268 2269 2270
	err = register_shrinker(&ubifs_shrinker_info);
	if (err)
		goto out_slab;
2271 2272

	err = ubifs_compressors_init();
A
Artem Bityutskiy 已提交
2273 2274 2275 2276
	if (err)
		goto out_shrinker;

	err = dbg_debugfs_init();
2277 2278 2279
	if (err)
		goto out_compr;

A
Al Viro 已提交
2280 2281
	err = register_filesystem(&ubifs_fs_type);
	if (err) {
2282 2283
		pr_err("UBIFS error (pid %d): cannot register file system, error %d",
		       current->pid, err);
A
Al Viro 已提交
2284 2285
		goto out_dbg;
	}
2286 2287
	return 0;

A
Al Viro 已提交
2288 2289
out_dbg:
	dbg_debugfs_exit();
2290
out_compr:
A
Artem Bityutskiy 已提交
2291 2292
	ubifs_compressors_exit();
out_shrinker:
2293
	unregister_shrinker(&ubifs_shrinker_info);
2294
out_slab:
2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305
	kmem_cache_destroy(ubifs_inode_slab);
	return err;
}
/* late_initcall to let compressors initialize first */
late_initcall(ubifs_init);

static void __exit ubifs_exit(void)
{
	ubifs_assert(list_empty(&ubifs_infos));
	ubifs_assert(atomic_long_read(&ubifs_clean_zn_cnt) == 0);

A
Artem Bityutskiy 已提交
2306
	dbg_debugfs_exit();
2307 2308
	ubifs_compressors_exit();
	unregister_shrinker(&ubifs_shrinker_info);
2309 2310 2311 2312 2313 2314

	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();
2315 2316 2317 2318 2319 2320 2321 2322 2323
	kmem_cache_destroy(ubifs_inode_slab);
	unregister_filesystem(&ubifs_fs_type);
}
module_exit(ubifs_exit);

MODULE_LICENSE("GPL");
MODULE_VERSION(__stringify(UBIFS_VERSION));
MODULE_AUTHOR("Artem Bityutskiy, Adrian Hunter");
MODULE_DESCRIPTION("UBIFS - UBI File System");