xref: /openbmc/linux/fs/ext2/super.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *  linux/fs/ext2/super.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card (card@masi.ibp.fr)
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  *
9  *  from
10  *
11  *  linux/fs/minix/inode.c
12  *
13  *  Copyright (C) 1991, 1992  Linus Torvalds
14  *
15  *  Big-endian to little-endian byte-swapping/bitmaps by
16  *        David S. Miller (davem@caip.rutgers.edu), 1995
17  */
18 
19 #include <linux/config.h>
20 #include <linux/module.h>
21 #include <linux/string.h>
22 #include <linux/fs.h>
23 #include <linux/slab.h>
24 #include <linux/init.h>
25 #include <linux/blkdev.h>
26 #include <linux/parser.h>
27 #include <linux/random.h>
28 #include <linux/buffer_head.h>
29 #include <linux/smp_lock.h>
30 #include <linux/vfs.h>
31 #include <linux/seq_file.h>
32 #include <linux/mount.h>
33 #include <asm/uaccess.h>
34 #include "ext2.h"
35 #include "xattr.h"
36 #include "acl.h"
37 #include "xip.h"
38 
39 static void ext2_sync_super(struct super_block *sb,
40 			    struct ext2_super_block *es);
41 static int ext2_remount (struct super_block * sb, int * flags, char * data);
42 static int ext2_statfs (struct super_block * sb, struct kstatfs * buf);
43 
44 void ext2_error (struct super_block * sb, const char * function,
45 		 const char * fmt, ...)
46 {
47 	va_list args;
48 	struct ext2_sb_info *sbi = EXT2_SB(sb);
49 	struct ext2_super_block *es = sbi->s_es;
50 
51 	if (!(sb->s_flags & MS_RDONLY)) {
52 		sbi->s_mount_state |= EXT2_ERROR_FS;
53 		es->s_state =
54 			cpu_to_le16(le16_to_cpu(es->s_state) | EXT2_ERROR_FS);
55 		ext2_sync_super(sb, es);
56 	}
57 
58 	va_start(args, fmt);
59 	printk(KERN_CRIT "EXT2-fs error (device %s): %s: ",sb->s_id, function);
60 	vprintk(fmt, args);
61 	printk("\n");
62 	va_end(args);
63 
64 	if (test_opt(sb, ERRORS_PANIC))
65 		panic("EXT2-fs panic from previous error\n");
66 	if (test_opt(sb, ERRORS_RO)) {
67 		printk("Remounting filesystem read-only\n");
68 		sb->s_flags |= MS_RDONLY;
69 	}
70 }
71 
72 void ext2_warning (struct super_block * sb, const char * function,
73 		   const char * fmt, ...)
74 {
75 	va_list args;
76 
77 	va_start(args, fmt);
78 	printk(KERN_WARNING "EXT2-fs warning (device %s): %s: ",
79 	       sb->s_id, function);
80 	vprintk(fmt, args);
81 	printk("\n");
82 	va_end(args);
83 }
84 
85 void ext2_update_dynamic_rev(struct super_block *sb)
86 {
87 	struct ext2_super_block *es = EXT2_SB(sb)->s_es;
88 
89 	if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
90 		return;
91 
92 	ext2_warning(sb, __FUNCTION__,
93 		     "updating to rev %d because of new feature flag, "
94 		     "running e2fsck is recommended",
95 		     EXT2_DYNAMIC_REV);
96 
97 	es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);
98 	es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);
99 	es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);
100 	/* leave es->s_feature_*compat flags alone */
101 	/* es->s_uuid will be set by e2fsck if empty */
102 
103 	/*
104 	 * The rest of the superblock fields should be zero, and if not it
105 	 * means they are likely already in use, so leave them alone.  We
106 	 * can leave it up to e2fsck to clean up any inconsistencies there.
107 	 */
108 }
109 
110 static void ext2_put_super (struct super_block * sb)
111 {
112 	int db_count;
113 	int i;
114 	struct ext2_sb_info *sbi = EXT2_SB(sb);
115 
116 	ext2_xattr_put_super(sb);
117 	if (!(sb->s_flags & MS_RDONLY)) {
118 		struct ext2_super_block *es = sbi->s_es;
119 
120 		es->s_state = cpu_to_le16(sbi->s_mount_state);
121 		ext2_sync_super(sb, es);
122 	}
123 	db_count = sbi->s_gdb_count;
124 	for (i = 0; i < db_count; i++)
125 		if (sbi->s_group_desc[i])
126 			brelse (sbi->s_group_desc[i]);
127 	kfree(sbi->s_group_desc);
128 	kfree(sbi->s_debts);
129 	percpu_counter_destroy(&sbi->s_freeblocks_counter);
130 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
131 	percpu_counter_destroy(&sbi->s_dirs_counter);
132 	brelse (sbi->s_sbh);
133 	sb->s_fs_info = NULL;
134 	kfree(sbi);
135 
136 	return;
137 }
138 
139 static kmem_cache_t * ext2_inode_cachep;
140 
141 static struct inode *ext2_alloc_inode(struct super_block *sb)
142 {
143 	struct ext2_inode_info *ei;
144 	ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, SLAB_KERNEL);
145 	if (!ei)
146 		return NULL;
147 #ifdef CONFIG_EXT2_FS_POSIX_ACL
148 	ei->i_acl = EXT2_ACL_NOT_CACHED;
149 	ei->i_default_acl = EXT2_ACL_NOT_CACHED;
150 #endif
151 	ei->vfs_inode.i_version = 1;
152 	return &ei->vfs_inode;
153 }
154 
155 static void ext2_destroy_inode(struct inode *inode)
156 {
157 	kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
158 }
159 
160 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
161 {
162 	struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
163 
164 	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
165 	    SLAB_CTOR_CONSTRUCTOR) {
166 		rwlock_init(&ei->i_meta_lock);
167 #ifdef CONFIG_EXT2_FS_XATTR
168 		init_rwsem(&ei->xattr_sem);
169 #endif
170 		inode_init_once(&ei->vfs_inode);
171 	}
172 }
173 
174 static int init_inodecache(void)
175 {
176 	ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
177 					     sizeof(struct ext2_inode_info),
178 					     0, SLAB_RECLAIM_ACCOUNT,
179 					     init_once, NULL);
180 	if (ext2_inode_cachep == NULL)
181 		return -ENOMEM;
182 	return 0;
183 }
184 
185 static void destroy_inodecache(void)
186 {
187 	if (kmem_cache_destroy(ext2_inode_cachep))
188 		printk(KERN_INFO "ext2_inode_cache: not all structures were freed\n");
189 }
190 
191 static void ext2_clear_inode(struct inode *inode)
192 {
193 #ifdef CONFIG_EXT2_FS_POSIX_ACL
194 	struct ext2_inode_info *ei = EXT2_I(inode);
195 
196 	if (ei->i_acl && ei->i_acl != EXT2_ACL_NOT_CACHED) {
197 		posix_acl_release(ei->i_acl);
198 		ei->i_acl = EXT2_ACL_NOT_CACHED;
199 	}
200 	if (ei->i_default_acl && ei->i_default_acl != EXT2_ACL_NOT_CACHED) {
201 		posix_acl_release(ei->i_default_acl);
202 		ei->i_default_acl = EXT2_ACL_NOT_CACHED;
203 	}
204 #endif
205 }
206 
207 static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
208 {
209 	struct ext2_sb_info *sbi = EXT2_SB(vfs->mnt_sb);
210 
211 	if (sbi->s_mount_opt & EXT2_MOUNT_GRPID)
212 		seq_puts(seq, ",grpid");
213 	else
214 		seq_puts(seq, ",nogrpid");
215 
216 #if defined(CONFIG_QUOTA)
217 	if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)
218 		seq_puts(seq, ",usrquota");
219 
220 	if (sbi->s_mount_opt & EXT2_MOUNT_GRPQUOTA)
221 		seq_puts(seq, ",grpquota");
222 #endif
223 
224 	return 0;
225 }
226 
227 #ifdef CONFIG_QUOTA
228 static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data, size_t len, loff_t off);
229 static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *data, size_t len, loff_t off);
230 #endif
231 
232 static struct super_operations ext2_sops = {
233 	.alloc_inode	= ext2_alloc_inode,
234 	.destroy_inode	= ext2_destroy_inode,
235 	.read_inode	= ext2_read_inode,
236 	.write_inode	= ext2_write_inode,
237 	.put_inode	= ext2_put_inode,
238 	.delete_inode	= ext2_delete_inode,
239 	.put_super	= ext2_put_super,
240 	.write_super	= ext2_write_super,
241 	.statfs		= ext2_statfs,
242 	.remount_fs	= ext2_remount,
243 	.clear_inode	= ext2_clear_inode,
244 	.show_options	= ext2_show_options,
245 #ifdef CONFIG_QUOTA
246 	.quota_read	= ext2_quota_read,
247 	.quota_write	= ext2_quota_write,
248 #endif
249 };
250 
251 /* Yes, most of these are left as NULL!!
252  * A NULL value implies the default, which works with ext2-like file
253  * systems, but can be improved upon.
254  * Currently only get_parent is required.
255  */
256 struct dentry *ext2_get_parent(struct dentry *child);
257 static struct export_operations ext2_export_ops = {
258 	.get_parent = ext2_get_parent,
259 };
260 
261 static unsigned long get_sb_block(void **data)
262 {
263 	unsigned long 	sb_block;
264 	char 		*options = (char *) *data;
265 
266 	if (!options || strncmp(options, "sb=", 3) != 0)
267 		return 1;	/* Default location */
268 	options += 3;
269 	sb_block = simple_strtoul(options, &options, 0);
270 	if (*options && *options != ',') {
271 		printk("EXT2-fs: Invalid sb specification: %s\n",
272 		       (char *) *data);
273 		return 1;
274 	}
275 	if (*options == ',')
276 		options++;
277 	*data = (void *) options;
278 	return sb_block;
279 }
280 
281 enum {
282 	Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
283 	Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic,
284 	Opt_err_ro, Opt_nouid32, Opt_check, Opt_nocheck, Opt_debug,
285 	Opt_oldalloc, Opt_orlov, Opt_nobh, Opt_user_xattr, Opt_nouser_xattr,
286 	Opt_acl, Opt_noacl, Opt_xip, Opt_ignore, Opt_err, Opt_quota,
287 	Opt_usrquota, Opt_grpquota
288 };
289 
290 static match_table_t tokens = {
291 	{Opt_bsd_df, "bsddf"},
292 	{Opt_minix_df, "minixdf"},
293 	{Opt_grpid, "grpid"},
294 	{Opt_grpid, "bsdgroups"},
295 	{Opt_nogrpid, "nogrpid"},
296 	{Opt_nogrpid, "sysvgroups"},
297 	{Opt_resgid, "resgid=%u"},
298 	{Opt_resuid, "resuid=%u"},
299 	{Opt_sb, "sb=%u"},
300 	{Opt_err_cont, "errors=continue"},
301 	{Opt_err_panic, "errors=panic"},
302 	{Opt_err_ro, "errors=remount-ro"},
303 	{Opt_nouid32, "nouid32"},
304 	{Opt_nocheck, "check=none"},
305 	{Opt_nocheck, "nocheck"},
306 	{Opt_check, "check"},
307 	{Opt_debug, "debug"},
308 	{Opt_oldalloc, "oldalloc"},
309 	{Opt_orlov, "orlov"},
310 	{Opt_nobh, "nobh"},
311 	{Opt_user_xattr, "user_xattr"},
312 	{Opt_nouser_xattr, "nouser_xattr"},
313 	{Opt_acl, "acl"},
314 	{Opt_noacl, "noacl"},
315 	{Opt_xip, "xip"},
316 	{Opt_grpquota, "grpquota"},
317 	{Opt_ignore, "noquota"},
318 	{Opt_quota, "quota"},
319 	{Opt_usrquota, "usrquota"},
320 	{Opt_err, NULL}
321 };
322 
323 static int parse_options (char * options,
324 			  struct ext2_sb_info *sbi)
325 {
326 	char * p;
327 	substring_t args[MAX_OPT_ARGS];
328 	unsigned long kind = EXT2_MOUNT_ERRORS_CONT;
329 	int option;
330 
331 	if (!options)
332 		return 1;
333 
334 	while ((p = strsep (&options, ",")) != NULL) {
335 		int token;
336 		if (!*p)
337 			continue;
338 
339 		token = match_token(p, tokens, args);
340 		switch (token) {
341 		case Opt_bsd_df:
342 			clear_opt (sbi->s_mount_opt, MINIX_DF);
343 			break;
344 		case Opt_minix_df:
345 			set_opt (sbi->s_mount_opt, MINIX_DF);
346 			break;
347 		case Opt_grpid:
348 			set_opt (sbi->s_mount_opt, GRPID);
349 			break;
350 		case Opt_nogrpid:
351 			clear_opt (sbi->s_mount_opt, GRPID);
352 			break;
353 		case Opt_resuid:
354 			if (match_int(&args[0], &option))
355 				return 0;
356 			sbi->s_resuid = option;
357 			break;
358 		case Opt_resgid:
359 			if (match_int(&args[0], &option))
360 				return 0;
361 			sbi->s_resgid = option;
362 			break;
363 		case Opt_sb:
364 			/* handled by get_sb_block() instead of here */
365 			/* *sb_block = match_int(&args[0]); */
366 			break;
367 		case Opt_err_panic:
368 			kind = EXT2_MOUNT_ERRORS_PANIC;
369 			break;
370 		case Opt_err_ro:
371 			kind = EXT2_MOUNT_ERRORS_RO;
372 			break;
373 		case Opt_err_cont:
374 			kind = EXT2_MOUNT_ERRORS_CONT;
375 			break;
376 		case Opt_nouid32:
377 			set_opt (sbi->s_mount_opt, NO_UID32);
378 			break;
379 		case Opt_check:
380 #ifdef CONFIG_EXT2_CHECK
381 			set_opt (sbi->s_mount_opt, CHECK);
382 #else
383 			printk("EXT2 Check option not supported\n");
384 #endif
385 			break;
386 		case Opt_nocheck:
387 			clear_opt (sbi->s_mount_opt, CHECK);
388 			break;
389 		case Opt_debug:
390 			set_opt (sbi->s_mount_opt, DEBUG);
391 			break;
392 		case Opt_oldalloc:
393 			set_opt (sbi->s_mount_opt, OLDALLOC);
394 			break;
395 		case Opt_orlov:
396 			clear_opt (sbi->s_mount_opt, OLDALLOC);
397 			break;
398 		case Opt_nobh:
399 			set_opt (sbi->s_mount_opt, NOBH);
400 			break;
401 #ifdef CONFIG_EXT2_FS_XATTR
402 		case Opt_user_xattr:
403 			set_opt (sbi->s_mount_opt, XATTR_USER);
404 			break;
405 		case Opt_nouser_xattr:
406 			clear_opt (sbi->s_mount_opt, XATTR_USER);
407 			break;
408 #else
409 		case Opt_user_xattr:
410 		case Opt_nouser_xattr:
411 			printk("EXT2 (no)user_xattr options not supported\n");
412 			break;
413 #endif
414 #ifdef CONFIG_EXT2_FS_POSIX_ACL
415 		case Opt_acl:
416 			set_opt(sbi->s_mount_opt, POSIX_ACL);
417 			break;
418 		case Opt_noacl:
419 			clear_opt(sbi->s_mount_opt, POSIX_ACL);
420 			break;
421 #else
422 		case Opt_acl:
423 		case Opt_noacl:
424 			printk("EXT2 (no)acl options not supported\n");
425 			break;
426 #endif
427 		case Opt_xip:
428 #ifdef CONFIG_EXT2_FS_XIP
429 			set_opt (sbi->s_mount_opt, XIP);
430 #else
431 			printk("EXT2 xip option not supported\n");
432 #endif
433 			break;
434 
435 #if defined(CONFIG_QUOTA)
436 		case Opt_quota:
437 		case Opt_usrquota:
438 			set_opt(sbi->s_mount_opt, USRQUOTA);
439 			break;
440 
441 		case Opt_grpquota:
442 			set_opt(sbi->s_mount_opt, GRPQUOTA);
443 			break;
444 #else
445 		case Opt_quota:
446 		case Opt_usrquota:
447 		case Opt_grpquota:
448 			printk(KERN_ERR
449 				"EXT2-fs: quota operations not supported.\n");
450 
451 			break;
452 #endif
453 
454 		case Opt_ignore:
455 			break;
456 		default:
457 			return 0;
458 		}
459 	}
460 	sbi->s_mount_opt |= kind;
461 	return 1;
462 }
463 
464 static int ext2_setup_super (struct super_block * sb,
465 			      struct ext2_super_block * es,
466 			      int read_only)
467 {
468 	int res = 0;
469 	struct ext2_sb_info *sbi = EXT2_SB(sb);
470 
471 	if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {
472 		printk ("EXT2-fs warning: revision level too high, "
473 			"forcing read-only mode\n");
474 		res = MS_RDONLY;
475 	}
476 	if (read_only)
477 		return res;
478 	if (!(sbi->s_mount_state & EXT2_VALID_FS))
479 		printk ("EXT2-fs warning: mounting unchecked fs, "
480 			"running e2fsck is recommended\n");
481 	else if ((sbi->s_mount_state & EXT2_ERROR_FS))
482 		printk ("EXT2-fs warning: mounting fs with errors, "
483 			"running e2fsck is recommended\n");
484 	else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
485 		 le16_to_cpu(es->s_mnt_count) >=
486 		 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
487 		printk ("EXT2-fs warning: maximal mount count reached, "
488 			"running e2fsck is recommended\n");
489 	else if (le32_to_cpu(es->s_checkinterval) &&
490 		(le32_to_cpu(es->s_lastcheck) + le32_to_cpu(es->s_checkinterval) <= get_seconds()))
491 		printk ("EXT2-fs warning: checktime reached, "
492 			"running e2fsck is recommended\n");
493 	if (!le16_to_cpu(es->s_max_mnt_count))
494 		es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
495 	es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
496 	ext2_write_super(sb);
497 	if (test_opt (sb, DEBUG))
498 		printk ("[EXT II FS %s, %s, bs=%lu, fs=%lu, gc=%lu, "
499 			"bpg=%lu, ipg=%lu, mo=%04lx]\n",
500 			EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,
501 			sbi->s_frag_size,
502 			sbi->s_groups_count,
503 			EXT2_BLOCKS_PER_GROUP(sb),
504 			EXT2_INODES_PER_GROUP(sb),
505 			sbi->s_mount_opt);
506 #ifdef CONFIG_EXT2_CHECK
507 	if (test_opt (sb, CHECK)) {
508 		ext2_check_blocks_bitmap (sb);
509 		ext2_check_inodes_bitmap (sb);
510 	}
511 #endif
512 	return res;
513 }
514 
515 static int ext2_check_descriptors (struct super_block * sb)
516 {
517 	int i;
518 	int desc_block = 0;
519 	struct ext2_sb_info *sbi = EXT2_SB(sb);
520 	unsigned long block = le32_to_cpu(sbi->s_es->s_first_data_block);
521 	struct ext2_group_desc * gdp = NULL;
522 
523 	ext2_debug ("Checking group descriptors");
524 
525 	for (i = 0; i < sbi->s_groups_count; i++)
526 	{
527 		if ((i % EXT2_DESC_PER_BLOCK(sb)) == 0)
528 			gdp = (struct ext2_group_desc *) sbi->s_group_desc[desc_block++]->b_data;
529 		if (le32_to_cpu(gdp->bg_block_bitmap) < block ||
530 		    le32_to_cpu(gdp->bg_block_bitmap) >= block + EXT2_BLOCKS_PER_GROUP(sb))
531 		{
532 			ext2_error (sb, "ext2_check_descriptors",
533 				    "Block bitmap for group %d"
534 				    " not in group (block %lu)!",
535 				    i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));
536 			return 0;
537 		}
538 		if (le32_to_cpu(gdp->bg_inode_bitmap) < block ||
539 		    le32_to_cpu(gdp->bg_inode_bitmap) >= block + EXT2_BLOCKS_PER_GROUP(sb))
540 		{
541 			ext2_error (sb, "ext2_check_descriptors",
542 				    "Inode bitmap for group %d"
543 				    " not in group (block %lu)!",
544 				    i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));
545 			return 0;
546 		}
547 		if (le32_to_cpu(gdp->bg_inode_table) < block ||
548 		    le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >=
549 		    block + EXT2_BLOCKS_PER_GROUP(sb))
550 		{
551 			ext2_error (sb, "ext2_check_descriptors",
552 				    "Inode table for group %d"
553 				    " not in group (block %lu)!",
554 				    i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));
555 			return 0;
556 		}
557 		block += EXT2_BLOCKS_PER_GROUP(sb);
558 		gdp++;
559 	}
560 	return 1;
561 }
562 
563 #define log2(n) ffz(~(n))
564 
565 /*
566  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
567  * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
568  * We need to be 1 filesystem block less than the 2^32 sector limit.
569  */
570 static loff_t ext2_max_size(int bits)
571 {
572 	loff_t res = EXT2_NDIR_BLOCKS;
573 	/* This constant is calculated to be the largest file size for a
574 	 * dense, 4k-blocksize file such that the total number of
575 	 * sectors in the file, including data and all indirect blocks,
576 	 * does not exceed 2^32. */
577 	const loff_t upper_limit = 0x1ff7fffd000LL;
578 
579 	res += 1LL << (bits-2);
580 	res += 1LL << (2*(bits-2));
581 	res += 1LL << (3*(bits-2));
582 	res <<= bits;
583 	if (res > upper_limit)
584 		res = upper_limit;
585 	return res;
586 }
587 
588 static unsigned long descriptor_loc(struct super_block *sb,
589 				    unsigned long logic_sb_block,
590 				    int nr)
591 {
592 	struct ext2_sb_info *sbi = EXT2_SB(sb);
593 	unsigned long bg, first_data_block, first_meta_bg;
594 	int has_super = 0;
595 
596 	first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
597 	first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
598 
599 	if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_META_BG) ||
600 	    nr < first_meta_bg)
601 		return (logic_sb_block + nr + 1);
602 	bg = sbi->s_desc_per_block * nr;
603 	if (ext2_bg_has_super(sb, bg))
604 		has_super = 1;
605 	return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
606 }
607 
608 static int ext2_fill_super(struct super_block *sb, void *data, int silent)
609 {
610 	struct buffer_head * bh;
611 	struct ext2_sb_info * sbi;
612 	struct ext2_super_block * es;
613 	struct inode *root;
614 	unsigned long block;
615 	unsigned long sb_block = get_sb_block(&data);
616 	unsigned long logic_sb_block;
617 	unsigned long offset = 0;
618 	unsigned long def_mount_opts;
619 	int blocksize = BLOCK_SIZE;
620 	int db_count;
621 	int i, j;
622 	__le32 features;
623 
624 	sbi = kmalloc(sizeof(*sbi), GFP_KERNEL);
625 	if (!sbi)
626 		return -ENOMEM;
627 	sb->s_fs_info = sbi;
628 	memset(sbi, 0, sizeof(*sbi));
629 
630 	/*
631 	 * See what the current blocksize for the device is, and
632 	 * use that as the blocksize.  Otherwise (or if the blocksize
633 	 * is smaller than the default) use the default.
634 	 * This is important for devices that have a hardware
635 	 * sectorsize that is larger than the default.
636 	 */
637 	blocksize = sb_min_blocksize(sb, BLOCK_SIZE);
638 	if (!blocksize) {
639 		printk ("EXT2-fs: unable to set blocksize\n");
640 		goto failed_sbi;
641 	}
642 
643 	/*
644 	 * If the superblock doesn't start on a hardware sector boundary,
645 	 * calculate the offset.
646 	 */
647 	if (blocksize != BLOCK_SIZE) {
648 		logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
649 		offset = (sb_block*BLOCK_SIZE) % blocksize;
650 	} else {
651 		logic_sb_block = sb_block;
652 	}
653 
654 	if (!(bh = sb_bread(sb, logic_sb_block))) {
655 		printk ("EXT2-fs: unable to read superblock\n");
656 		goto failed_sbi;
657 	}
658 	/*
659 	 * Note: s_es must be initialized as soon as possible because
660 	 *       some ext2 macro-instructions depend on its value
661 	 */
662 	es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
663 	sbi->s_es = es;
664 	sb->s_magic = le16_to_cpu(es->s_magic);
665 
666 	if (sb->s_magic != EXT2_SUPER_MAGIC)
667 		goto cantfind_ext2;
668 
669 	/* Set defaults before we parse the mount options */
670 	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
671 	if (def_mount_opts & EXT2_DEFM_DEBUG)
672 		set_opt(sbi->s_mount_opt, DEBUG);
673 	if (def_mount_opts & EXT2_DEFM_BSDGROUPS)
674 		set_opt(sbi->s_mount_opt, GRPID);
675 	if (def_mount_opts & EXT2_DEFM_UID16)
676 		set_opt(sbi->s_mount_opt, NO_UID32);
677 	if (def_mount_opts & EXT2_DEFM_XATTR_USER)
678 		set_opt(sbi->s_mount_opt, XATTR_USER);
679 	if (def_mount_opts & EXT2_DEFM_ACL)
680 		set_opt(sbi->s_mount_opt, POSIX_ACL);
681 
682 	if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)
683 		set_opt(sbi->s_mount_opt, ERRORS_PANIC);
684 	else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_RO)
685 		set_opt(sbi->s_mount_opt, ERRORS_RO);
686 
687 	sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
688 	sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
689 
690 	if (!parse_options ((char *) data, sbi))
691 		goto failed_mount;
692 
693 	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
694 		((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
695 		 MS_POSIXACL : 0);
696 
697 	ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset
698 				    EXT2_MOUNT_XIP if not */
699 
700 	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
701 	    (EXT2_HAS_COMPAT_FEATURE(sb, ~0U) ||
702 	     EXT2_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
703 	     EXT2_HAS_INCOMPAT_FEATURE(sb, ~0U)))
704 		printk("EXT2-fs warning: feature flags set on rev 0 fs, "
705 		       "running e2fsck is recommended\n");
706 	/*
707 	 * Check feature flags regardless of the revision level, since we
708 	 * previously didn't change the revision level when setting the flags,
709 	 * so there is a chance incompat flags are set on a rev 0 filesystem.
710 	 */
711 	features = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP);
712 	if (features) {
713 		printk("EXT2-fs: %s: couldn't mount because of "
714 		       "unsupported optional features (%x).\n",
715 		       sb->s_id, le32_to_cpu(features));
716 		goto failed_mount;
717 	}
718 	if (!(sb->s_flags & MS_RDONLY) &&
719 	    (features = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){
720 		printk("EXT2-fs: %s: couldn't mount RDWR because of "
721 		       "unsupported optional features (%x).\n",
722 		       sb->s_id, le32_to_cpu(features));
723 		goto failed_mount;
724 	}
725 
726 	blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
727 
728 	if ((ext2_use_xip(sb)) && ((blocksize != PAGE_SIZE) ||
729 				  (sb->s_blocksize != blocksize))) {
730 		if (!silent)
731 			printk("XIP: Unsupported blocksize\n");
732 		goto failed_mount;
733 	}
734 
735 	/* If the blocksize doesn't match, re-read the thing.. */
736 	if (sb->s_blocksize != blocksize) {
737 		brelse(bh);
738 
739 		if (!sb_set_blocksize(sb, blocksize)) {
740 			printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");
741 			goto failed_sbi;
742 		}
743 
744 		logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
745 		offset = (sb_block*BLOCK_SIZE) % blocksize;
746 		bh = sb_bread(sb, logic_sb_block);
747 		if(!bh) {
748 			printk("EXT2-fs: Couldn't read superblock on "
749 			       "2nd try.\n");
750 			goto failed_sbi;
751 		}
752 		es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
753 		sbi->s_es = es;
754 		if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
755 			printk ("EXT2-fs: Magic mismatch, very weird !\n");
756 			goto failed_mount;
757 		}
758 	}
759 
760 	sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
761 
762 	if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
763 		sbi->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
764 		sbi->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
765 	} else {
766 		sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
767 		sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
768 		if ((sbi->s_inode_size < EXT2_GOOD_OLD_INODE_SIZE) ||
769 		    (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
770 		    (sbi->s_inode_size > blocksize)) {
771 			printk ("EXT2-fs: unsupported inode size: %d\n",
772 				sbi->s_inode_size);
773 			goto failed_mount;
774 		}
775 	}
776 
777 	sbi->s_frag_size = EXT2_MIN_FRAG_SIZE <<
778 				   le32_to_cpu(es->s_log_frag_size);
779 	if (sbi->s_frag_size == 0)
780 		goto cantfind_ext2;
781 	sbi->s_frags_per_block = sb->s_blocksize / sbi->s_frag_size;
782 
783 	sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
784 	sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
785 	sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
786 
787 	if (EXT2_INODE_SIZE(sb) == 0)
788 		goto cantfind_ext2;
789 	sbi->s_inodes_per_block = sb->s_blocksize / EXT2_INODE_SIZE(sb);
790 	if (sbi->s_inodes_per_block == 0)
791 		goto cantfind_ext2;
792 	sbi->s_itb_per_group = sbi->s_inodes_per_group /
793 					sbi->s_inodes_per_block;
794 	sbi->s_desc_per_block = sb->s_blocksize /
795 					sizeof (struct ext2_group_desc);
796 	sbi->s_sbh = bh;
797 	sbi->s_mount_state = le16_to_cpu(es->s_state);
798 	sbi->s_addr_per_block_bits =
799 		log2 (EXT2_ADDR_PER_BLOCK(sb));
800 	sbi->s_desc_per_block_bits =
801 		log2 (EXT2_DESC_PER_BLOCK(sb));
802 
803 	if (sb->s_magic != EXT2_SUPER_MAGIC)
804 		goto cantfind_ext2;
805 
806 	if (sb->s_blocksize != bh->b_size) {
807 		if (!silent)
808 			printk ("VFS: Unsupported blocksize on dev "
809 				"%s.\n", sb->s_id);
810 		goto failed_mount;
811 	}
812 
813 	if (sb->s_blocksize != sbi->s_frag_size) {
814 		printk ("EXT2-fs: fragsize %lu != blocksize %lu (not supported yet)\n",
815 			sbi->s_frag_size, sb->s_blocksize);
816 		goto failed_mount;
817 	}
818 
819 	if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
820 		printk ("EXT2-fs: #blocks per group too big: %lu\n",
821 			sbi->s_blocks_per_group);
822 		goto failed_mount;
823 	}
824 	if (sbi->s_frags_per_group > sb->s_blocksize * 8) {
825 		printk ("EXT2-fs: #fragments per group too big: %lu\n",
826 			sbi->s_frags_per_group);
827 		goto failed_mount;
828 	}
829 	if (sbi->s_inodes_per_group > sb->s_blocksize * 8) {
830 		printk ("EXT2-fs: #inodes per group too big: %lu\n",
831 			sbi->s_inodes_per_group);
832 		goto failed_mount;
833 	}
834 
835 	if (EXT2_BLOCKS_PER_GROUP(sb) == 0)
836 		goto cantfind_ext2;
837 	sbi->s_groups_count = (le32_to_cpu(es->s_blocks_count) -
838 				        le32_to_cpu(es->s_first_data_block) +
839 				       EXT2_BLOCKS_PER_GROUP(sb) - 1) /
840 				       EXT2_BLOCKS_PER_GROUP(sb);
841 	db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
842 		   EXT2_DESC_PER_BLOCK(sb);
843 	sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
844 	if (sbi->s_group_desc == NULL) {
845 		printk ("EXT2-fs: not enough memory\n");
846 		goto failed_mount;
847 	}
848 	percpu_counter_init(&sbi->s_freeblocks_counter);
849 	percpu_counter_init(&sbi->s_freeinodes_counter);
850 	percpu_counter_init(&sbi->s_dirs_counter);
851 	bgl_lock_init(&sbi->s_blockgroup_lock);
852 	sbi->s_debts = kmalloc(sbi->s_groups_count * sizeof(*sbi->s_debts),
853 			       GFP_KERNEL);
854 	if (!sbi->s_debts) {
855 		printk ("EXT2-fs: not enough memory\n");
856 		goto failed_mount_group_desc;
857 	}
858 	memset(sbi->s_debts, 0, sbi->s_groups_count * sizeof(*sbi->s_debts));
859 	for (i = 0; i < db_count; i++) {
860 		block = descriptor_loc(sb, logic_sb_block, i);
861 		sbi->s_group_desc[i] = sb_bread(sb, block);
862 		if (!sbi->s_group_desc[i]) {
863 			for (j = 0; j < i; j++)
864 				brelse (sbi->s_group_desc[j]);
865 			printk ("EXT2-fs: unable to read group descriptors\n");
866 			goto failed_mount_group_desc;
867 		}
868 	}
869 	if (!ext2_check_descriptors (sb)) {
870 		printk ("EXT2-fs: group descriptors corrupted!\n");
871 		db_count = i;
872 		goto failed_mount2;
873 	}
874 	sbi->s_gdb_count = db_count;
875 	get_random_bytes(&sbi->s_next_generation, sizeof(u32));
876 	spin_lock_init(&sbi->s_next_gen_lock);
877 	/*
878 	 * set up enough so that it can read an inode
879 	 */
880 	sb->s_op = &ext2_sops;
881 	sb->s_export_op = &ext2_export_ops;
882 	sb->s_xattr = ext2_xattr_handlers;
883 	root = iget(sb, EXT2_ROOT_INO);
884 	sb->s_root = d_alloc_root(root);
885 	if (!sb->s_root) {
886 		iput(root);
887 		printk(KERN_ERR "EXT2-fs: get root inode failed\n");
888 		goto failed_mount2;
889 	}
890 	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
891 		dput(sb->s_root);
892 		sb->s_root = NULL;
893 		printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
894 		goto failed_mount2;
895 	}
896 	if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
897 		ext2_warning(sb, __FUNCTION__,
898 			"mounting ext3 filesystem as ext2\n");
899 	ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
900 	percpu_counter_mod(&sbi->s_freeblocks_counter,
901 				ext2_count_free_blocks(sb));
902 	percpu_counter_mod(&sbi->s_freeinodes_counter,
903 				ext2_count_free_inodes(sb));
904 	percpu_counter_mod(&sbi->s_dirs_counter,
905 				ext2_count_dirs(sb));
906 	return 0;
907 
908 cantfind_ext2:
909 	if (!silent)
910 		printk("VFS: Can't find an ext2 filesystem on dev %s.\n",
911 		       sb->s_id);
912 	goto failed_mount;
913 
914 failed_mount2:
915 	for (i = 0; i < db_count; i++)
916 		brelse(sbi->s_group_desc[i]);
917 failed_mount_group_desc:
918 	kfree(sbi->s_group_desc);
919 	kfree(sbi->s_debts);
920 failed_mount:
921 	brelse(bh);
922 failed_sbi:
923 	sb->s_fs_info = NULL;
924 	kfree(sbi);
925 	return -EINVAL;
926 }
927 
928 static void ext2_commit_super (struct super_block * sb,
929 			       struct ext2_super_block * es)
930 {
931 	es->s_wtime = cpu_to_le32(get_seconds());
932 	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
933 	sb->s_dirt = 0;
934 }
935 
936 static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
937 {
938 	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
939 	es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
940 	es->s_wtime = cpu_to_le32(get_seconds());
941 	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
942 	sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
943 	sb->s_dirt = 0;
944 }
945 
946 /*
947  * In the second extended file system, it is not necessary to
948  * write the super block since we use a mapping of the
949  * disk super block in a buffer.
950  *
951  * However, this function is still used to set the fs valid
952  * flags to 0.  We need to set this flag to 0 since the fs
953  * may have been checked while mounted and e2fsck may have
954  * set s_state to EXT2_VALID_FS after some corrections.
955  */
956 
957 void ext2_write_super (struct super_block * sb)
958 {
959 	struct ext2_super_block * es;
960 	lock_kernel();
961 	if (!(sb->s_flags & MS_RDONLY)) {
962 		es = EXT2_SB(sb)->s_es;
963 
964 		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS) {
965 			ext2_debug ("setting valid to 0\n");
966 			es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) &
967 						  ~EXT2_VALID_FS);
968 			es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
969 			es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
970 			es->s_mtime = cpu_to_le32(get_seconds());
971 			ext2_sync_super(sb, es);
972 		} else
973 			ext2_commit_super (sb, es);
974 	}
975 	sb->s_dirt = 0;
976 	unlock_kernel();
977 }
978 
979 static int ext2_remount (struct super_block * sb, int * flags, char * data)
980 {
981 	struct ext2_sb_info * sbi = EXT2_SB(sb);
982 	struct ext2_super_block * es;
983 	unsigned long old_mount_opt = sbi->s_mount_opt;
984 	struct ext2_mount_options old_opts;
985 	unsigned long old_sb_flags;
986 	int err;
987 
988 	/* Store the old options */
989 	old_sb_flags = sb->s_flags;
990 	old_opts.s_mount_opt = sbi->s_mount_opt;
991 	old_opts.s_resuid = sbi->s_resuid;
992 	old_opts.s_resgid = sbi->s_resgid;
993 
994 	/*
995 	 * Allow the "check" option to be passed as a remount option.
996 	 */
997 	if (!parse_options (data, sbi)) {
998 		err = -EINVAL;
999 		goto restore_opts;
1000 	}
1001 
1002 	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1003 		((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1004 
1005 	es = sbi->s_es;
1006 	if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=
1007 	    (old_mount_opt & EXT2_MOUNT_XIP)) &&
1008 	    invalidate_inodes(sb))
1009 		ext2_warning(sb, __FUNCTION__, "busy inodes while remounting "\
1010 			     "xip remain in cache (no functional problem)");
1011 	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
1012 		return 0;
1013 	if (*flags & MS_RDONLY) {
1014 		if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
1015 		    !(sbi->s_mount_state & EXT2_VALID_FS))
1016 			return 0;
1017 		/*
1018 		 * OK, we are remounting a valid rw partition rdonly, so set
1019 		 * the rdonly flag and then mark the partition as valid again.
1020 		 */
1021 		es->s_state = cpu_to_le16(sbi->s_mount_state);
1022 		es->s_mtime = cpu_to_le32(get_seconds());
1023 	} else {
1024 		__le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,
1025 					       ~EXT2_FEATURE_RO_COMPAT_SUPP);
1026 		if (ret) {
1027 			printk("EXT2-fs: %s: couldn't remount RDWR because of "
1028 			       "unsupported optional features (%x).\n",
1029 			       sb->s_id, le32_to_cpu(ret));
1030 			err = -EROFS;
1031 			goto restore_opts;
1032 		}
1033 		/*
1034 		 * Mounting a RDONLY partition read-write, so reread and
1035 		 * store the current valid flag.  (It may have been changed
1036 		 * by e2fsck since we originally mounted the partition.)
1037 		 */
1038 		sbi->s_mount_state = le16_to_cpu(es->s_state);
1039 		if (!ext2_setup_super (sb, es, 0))
1040 			sb->s_flags &= ~MS_RDONLY;
1041 	}
1042 	ext2_sync_super(sb, es);
1043 	return 0;
1044 restore_opts:
1045 	sbi->s_mount_opt = old_opts.s_mount_opt;
1046 	sbi->s_resuid = old_opts.s_resuid;
1047 	sbi->s_resgid = old_opts.s_resgid;
1048 	sb->s_flags = old_sb_flags;
1049 	return err;
1050 }
1051 
1052 static int ext2_statfs (struct super_block * sb, struct kstatfs * buf)
1053 {
1054 	struct ext2_sb_info *sbi = EXT2_SB(sb);
1055 	unsigned long overhead;
1056 	int i;
1057 
1058 	if (test_opt (sb, MINIX_DF))
1059 		overhead = 0;
1060 	else {
1061 		/*
1062 		 * Compute the overhead (FS structures)
1063 		 */
1064 
1065 		/*
1066 		 * All of the blocks before first_data_block are
1067 		 * overhead
1068 		 */
1069 		overhead = le32_to_cpu(sbi->s_es->s_first_data_block);
1070 
1071 		/*
1072 		 * Add the overhead attributed to the superblock and
1073 		 * block group descriptors.  If the sparse superblocks
1074 		 * feature is turned on, then not all groups have this.
1075 		 */
1076 		for (i = 0; i < sbi->s_groups_count; i++)
1077 			overhead += ext2_bg_has_super(sb, i) +
1078 				ext2_bg_num_gdb(sb, i);
1079 
1080 		/*
1081 		 * Every block group has an inode bitmap, a block
1082 		 * bitmap, and an inode table.
1083 		 */
1084 		overhead += (sbi->s_groups_count *
1085 			     (2 + sbi->s_itb_per_group));
1086 	}
1087 
1088 	buf->f_type = EXT2_SUPER_MAGIC;
1089 	buf->f_bsize = sb->s_blocksize;
1090 	buf->f_blocks = le32_to_cpu(sbi->s_es->s_blocks_count) - overhead;
1091 	buf->f_bfree = ext2_count_free_blocks(sb);
1092 	buf->f_bavail = buf->f_bfree - le32_to_cpu(sbi->s_es->s_r_blocks_count);
1093 	if (buf->f_bfree < le32_to_cpu(sbi->s_es->s_r_blocks_count))
1094 		buf->f_bavail = 0;
1095 	buf->f_files = le32_to_cpu(sbi->s_es->s_inodes_count);
1096 	buf->f_ffree = ext2_count_free_inodes (sb);
1097 	buf->f_namelen = EXT2_NAME_LEN;
1098 	return 0;
1099 }
1100 
1101 static struct super_block *ext2_get_sb(struct file_system_type *fs_type,
1102 	int flags, const char *dev_name, void *data)
1103 {
1104 	return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super);
1105 }
1106 
1107 #ifdef CONFIG_QUOTA
1108 
1109 /* Read data from quotafile - avoid pagecache and such because we cannot afford
1110  * acquiring the locks... As quota files are never truncated and quota code
1111  * itself serializes the operations (and noone else should touch the files)
1112  * we don't have to be afraid of races */
1113 static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data,
1114 			       size_t len, loff_t off)
1115 {
1116 	struct inode *inode = sb_dqopt(sb)->files[type];
1117 	sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
1118 	int err = 0;
1119 	int offset = off & (sb->s_blocksize - 1);
1120 	int tocopy;
1121 	size_t toread;
1122 	struct buffer_head tmp_bh;
1123 	struct buffer_head *bh;
1124 	loff_t i_size = i_size_read(inode);
1125 
1126 	if (off > i_size)
1127 		return 0;
1128 	if (off+len > i_size)
1129 		len = i_size-off;
1130 	toread = len;
1131 	while (toread > 0) {
1132 		tocopy = sb->s_blocksize - offset < toread ?
1133 				sb->s_blocksize - offset : toread;
1134 
1135 		tmp_bh.b_state = 0;
1136 		err = ext2_get_block(inode, blk, &tmp_bh, 0);
1137 		if (err)
1138 			return err;
1139 		if (!buffer_mapped(&tmp_bh))	/* A hole? */
1140 			memset(data, 0, tocopy);
1141 		else {
1142 			bh = sb_bread(sb, tmp_bh.b_blocknr);
1143 			if (!bh)
1144 				return -EIO;
1145 			memcpy(data, bh->b_data+offset, tocopy);
1146 			brelse(bh);
1147 		}
1148 		offset = 0;
1149 		toread -= tocopy;
1150 		data += tocopy;
1151 		blk++;
1152 	}
1153 	return len;
1154 }
1155 
1156 /* Write to quotafile */
1157 static ssize_t ext2_quota_write(struct super_block *sb, int type,
1158 				const char *data, size_t len, loff_t off)
1159 {
1160 	struct inode *inode = sb_dqopt(sb)->files[type];
1161 	sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
1162 	int err = 0;
1163 	int offset = off & (sb->s_blocksize - 1);
1164 	int tocopy;
1165 	size_t towrite = len;
1166 	struct buffer_head tmp_bh;
1167 	struct buffer_head *bh;
1168 
1169 	down(&inode->i_sem);
1170 	while (towrite > 0) {
1171 		tocopy = sb->s_blocksize - offset < towrite ?
1172 				sb->s_blocksize - offset : towrite;
1173 
1174 		tmp_bh.b_state = 0;
1175 		err = ext2_get_block(inode, blk, &tmp_bh, 1);
1176 		if (err)
1177 			goto out;
1178 		if (offset || tocopy != EXT2_BLOCK_SIZE(sb))
1179 			bh = sb_bread(sb, tmp_bh.b_blocknr);
1180 		else
1181 			bh = sb_getblk(sb, tmp_bh.b_blocknr);
1182 		if (!bh) {
1183 			err = -EIO;
1184 			goto out;
1185 		}
1186 		lock_buffer(bh);
1187 		memcpy(bh->b_data+offset, data, tocopy);
1188 		flush_dcache_page(bh->b_page);
1189 		set_buffer_uptodate(bh);
1190 		mark_buffer_dirty(bh);
1191 		unlock_buffer(bh);
1192 		brelse(bh);
1193 		offset = 0;
1194 		towrite -= tocopy;
1195 		data += tocopy;
1196 		blk++;
1197 	}
1198 out:
1199 	if (len == towrite)
1200 		return err;
1201 	if (inode->i_size < off+len-towrite)
1202 		i_size_write(inode, off+len-towrite);
1203 	inode->i_version++;
1204 	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1205 	mark_inode_dirty(inode);
1206 	up(&inode->i_sem);
1207 	return len - towrite;
1208 }
1209 
1210 #endif
1211 
1212 static struct file_system_type ext2_fs_type = {
1213 	.owner		= THIS_MODULE,
1214 	.name		= "ext2",
1215 	.get_sb		= ext2_get_sb,
1216 	.kill_sb	= kill_block_super,
1217 	.fs_flags	= FS_REQUIRES_DEV,
1218 };
1219 
1220 static int __init init_ext2_fs(void)
1221 {
1222 	int err = init_ext2_xattr();
1223 	if (err)
1224 		return err;
1225 	err = init_inodecache();
1226 	if (err)
1227 		goto out1;
1228         err = register_filesystem(&ext2_fs_type);
1229 	if (err)
1230 		goto out;
1231 	return 0;
1232 out:
1233 	destroy_inodecache();
1234 out1:
1235 	exit_ext2_xattr();
1236 	return err;
1237 }
1238 
1239 static void __exit exit_ext2_fs(void)
1240 {
1241 	unregister_filesystem(&ext2_fs_type);
1242 	destroy_inodecache();
1243 	exit_ext2_xattr();
1244 }
1245 
1246 module_init(init_ext2_fs)
1247 module_exit(exit_ext2_fs)
1248