Line data Source code
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/module.h>
20 : #include <linux/string.h>
21 : #include <linux/fs.h>
22 : #include <linux/slab.h>
23 : #include <linux/init.h>
24 : #include <linux/blkdev.h>
25 : #include <linux/parser.h>
26 : #include <linux/random.h>
27 : #include <linux/buffer_head.h>
28 : #include <linux/exportfs.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 <linux/log2.h>
34 : #include <linux/quotaops.h>
35 : #include <asm/uaccess.h>
36 : #include "ext2.h"
37 : #include "xattr.h"
38 : #include "acl.h"
39 : #include "xip.h"
40 :
41 : static void ext2_sync_super(struct super_block *sb,
42 : struct ext2_super_block *es);
43 : static int ext2_remount (struct super_block * sb, int * flags, char * data);
44 : static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf);
45 : static int ext2_sync_fs(struct super_block *sb, int wait);
46 :
47 : void ext2_error (struct super_block * sb, const char * function,
48 : const char * fmt, ...)
49 : {
50 7045 : va_list args;
51 28180 : struct ext2_sb_info *sbi = EXT2_SB(sb);
52 14090 : struct ext2_super_block *es = sbi->s_es;
53 7045 :
54 21135 : if (!(sb->s_flags & MS_RDONLY)) {
55 21135 : sbi->s_mount_state |= EXT2_ERROR_FS;
56 14090 : es->s_state |= cpu_to_le16(EXT2_ERROR_FS);
57 14050 : ext2_sync_super(sb, es);
58 : }
59 :
60 14090 : va_start(args, fmt);
61 14090 : printk(KERN_CRIT "EXT2-fs (%s): error: %s: ", sb->s_id, function);
62 14090 : vprintk(fmt, args);
63 14090 : printk("\n");
64 14090 : va_end(args);
65 :
66 42270 : if (test_opt(sb, ERRORS_PANIC))
67 7045 : panic("EXT2-fs: panic from previous error\n");
68 28180 : if (test_opt(sb, ERRORS_RO)) {
69 14090 : ext2_msg(sb, KERN_CRIT,
70 : "error: remounting filesystem read-only");
71 7045 : sb->s_flags |= MS_RDONLY;
72 : }
73 14090 : }
74 :
75 : void ext2_msg(struct super_block *sb, const char *prefix,
76 : const char *fmt, ...)
77 7082 : {
78 : va_list args;
79 :
80 7082 : va_start(args, fmt);
81 7082 : printk("%sEXT2-fs (%s): ", prefix, sb->s_id);
82 7082 : vprintk(fmt, args);
83 7082 : printk("\n");
84 7082 : va_end(args);
85 7082 : }
86 :
87 : void ext2_update_dynamic_rev(struct super_block *sb)
88 : {
89 16 : struct ext2_super_block *es = EXT2_SB(sb)->s_es;
90 4 :
91 8 : if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
92 4 : return;
93 :
94 8 : ext2_msg(sb, KERN_WARNING,
95 : "warning: updating to rev %d because of "
96 : "new feature flag, running e2fsck is recommended",
97 : EXT2_DYNAMIC_REV);
98 :
99 4 : es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);
100 4 : es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);
101 4 : es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);
102 4 : /* leave es->s_feature_*compat flags alone */
103 : /* es->s_uuid will be set by e2fsck if empty */
104 :
105 : /*
106 : * The rest of the superblock fields should be zero, and if not it
107 : * means they are likely already in use, so leave them alone. We
108 : * can leave it up to e2fsck to clean up any inconsistencies there.
109 : */
110 : }
111 :
112 : static void ext2_put_super (struct super_block * sb)
113 : {
114 1 : int db_count;
115 1 : int i;
116 4 : struct ext2_sb_info *sbi = EXT2_SB(sb);
117 1 :
118 2 : lock_kernel();
119 :
120 3 : if (sb->s_dirt)
121 3 : ext2_write_super(sb);
122 :
123 4 : ext2_xattr_put_super(sb);
124 2 : if (!(sb->s_flags & MS_RDONLY)) {
125 1 : struct ext2_super_block *es = sbi->s_es;
126 :
127 1 : es->s_state = cpu_to_le16(sbi->s_mount_state);
128 2 : ext2_sync_super(sb, es);
129 : }
130 4 : db_count = sbi->s_gdb_count;
131 8 : for (i = 0; i < db_count; i++)
132 5 : if (sbi->s_group_desc[i])
133 3 : brelse (sbi->s_group_desc[i]);
134 2 : kfree(sbi->s_group_desc);
135 2 : kfree(sbi->s_debts);
136 1 : percpu_counter_destroy(&sbi->s_freeblocks_counter);
137 1 : percpu_counter_destroy(&sbi->s_freeinodes_counter);
138 1 : percpu_counter_destroy(&sbi->s_dirs_counter);
139 2 : brelse (sbi->s_sbh);
140 1 : sb->s_fs_info = NULL;
141 2 : kfree(sbi->s_blockgroup_lock);
142 1 : kfree(sbi);
143 :
144 1 : unlock_kernel();
145 1 : }
146 :
147 1 : static struct kmem_cache * ext2_inode_cachep;
148 :
149 : static struct inode *ext2_alloc_inode(struct super_block *sb)
150 : {
151 1 : struct ext2_inode_info *ei;
152 3 : ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, GFP_KERNEL);
153 2 : if (!ei)
154 1 : return NULL;
155 1 : ei->i_block_alloc_info = NULL;
156 1 : ei->vfs_inode.i_version = 1;
157 1 : return &ei->vfs_inode;
158 : }
159 :
160 : static void ext2_destroy_inode(struct inode *inode)
161 : {
162 4 : kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
163 1 : }
164 :
165 : static void init_once(void *foo)
166 : {
167 0 : struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
168 0 :
169 0 : rwlock_init(&ei->i_meta_lock);
170 0 : #ifdef CONFIG_EXT2_FS_XATTR
171 0 : init_rwsem(&ei->xattr_sem);
172 : #endif
173 0 : mutex_init(&ei->truncate_mutex);
174 0 : inode_init_once(&ei->vfs_inode);
175 0 : }
176 :
177 : static int init_inodecache(void)
178 : {
179 1 : ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
180 : sizeof(struct ext2_inode_info),
181 : 0, (SLAB_RECLAIM_ACCOUNT|
182 : SLAB_MEM_SPREAD),
183 : init_once);
184 2 : if (ext2_inode_cachep == NULL)
185 1 : return -ENOMEM;
186 1 : return 0;
187 : }
188 :
189 : static void destroy_inodecache(void)
190 : {
191 3 : kmem_cache_destroy(ext2_inode_cachep);
192 3 : }
193 :
194 : static void ext2_clear_inode(struct inode *inode)
195 : {
196 4 : struct ext2_block_alloc_info *rsv = EXT2_I(inode)->i_block_alloc_info;
197 5 : ext2_discard_reservation(inode);
198 4 : EXT2_I(inode)->i_block_alloc_info = NULL;
199 5 : if (unlikely(rsv))
200 1 : kfree(rsv);
201 1 : }
202 :
203 : static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
204 : {
205 2 : struct super_block *sb = vfs->mnt_sb;
206 4 : struct ext2_sb_info *sbi = EXT2_SB(sb);
207 2 : struct ext2_super_block *es = sbi->s_es;
208 1 : unsigned long def_mount_opts;
209 1 :
210 3 : def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
211 1 :
212 3 : if (sbi->s_sb_block != 1)
213 2 : seq_printf(seq, ",sb=%lu", sbi->s_sb_block);
214 5 : if (test_opt(sb, MINIX_DF))
215 2 : seq_puts(seq, ",minixdf");
216 5 : if (test_opt(sb, GRPID))
217 2 : seq_puts(seq, ",grpid");
218 7 : if (!test_opt(sb, GRPID) && (def_mount_opts & EXT2_DEFM_BSDGROUPS))
219 2 : seq_puts(seq, ",nogrpid");
220 6 : if (sbi->s_resuid != EXT2_DEF_RESUID ||
221 1 : le16_to_cpu(es->s_def_resuid) != EXT2_DEF_RESUID) {
222 2 : seq_printf(seq, ",resuid=%u", sbi->s_resuid);
223 1 : }
224 5 : if (sbi->s_resgid != EXT2_DEF_RESGID ||
225 : le16_to_cpu(es->s_def_resgid) != EXT2_DEF_RESGID) {
226 1 : seq_printf(seq, ",resgid=%u", sbi->s_resgid);
227 : }
228 4 : if (test_opt(sb, ERRORS_RO)) {
229 2 : int def_errors = le16_to_cpu(es->s_errors);
230 :
231 4 : if (def_errors == EXT2_ERRORS_PANIC ||
232 : def_errors == EXT2_ERRORS_CONTINUE) {
233 1 : seq_puts(seq, ",errors=remount-ro");
234 : }
235 : }
236 4 : if (test_opt(sb, ERRORS_CONT))
237 1 : seq_puts(seq, ",errors=continue");
238 4 : if (test_opt(sb, ERRORS_PANIC))
239 1 : seq_puts(seq, ",errors=panic");
240 4 : if (test_opt(sb, NO_UID32))
241 1 : seq_puts(seq, ",nouid32");
242 4 : if (test_opt(sb, DEBUG))
243 1 : seq_puts(seq, ",debug");
244 4 : if (test_opt(sb, OLDALLOC))
245 1 : seq_puts(seq, ",oldalloc");
246 :
247 : #ifdef CONFIG_EXT2_FS_XATTR
248 4 : if (test_opt(sb, XATTR_USER))
249 1 : seq_puts(seq, ",user_xattr");
250 6 : if (!test_opt(sb, XATTR_USER) &&
251 : (def_mount_opts & EXT2_DEFM_XATTR_USER)) {
252 1 : seq_puts(seq, ",nouser_xattr");
253 : }
254 : #endif
255 :
256 : #ifdef CONFIG_EXT2_FS_POSIX_ACL
257 : if (test_opt(sb, POSIX_ACL))
258 : seq_puts(seq, ",acl");
259 : if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT2_DEFM_ACL))
260 : seq_puts(seq, ",noacl");
261 : #endif
262 :
263 4 : if (test_opt(sb, NOBH))
264 1 : seq_puts(seq, ",nobh");
265 :
266 : #if defined(CONFIG_QUOTA)
267 : if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)
268 : seq_puts(seq, ",usrquota");
269 :
270 : if (sbi->s_mount_opt & EXT2_MOUNT_GRPQUOTA)
271 : seq_puts(seq, ",grpquota");
272 : #endif
273 :
274 : #if defined(CONFIG_EXT2_FS_XIP)
275 : if (sbi->s_mount_opt & EXT2_MOUNT_XIP)
276 : seq_puts(seq, ",xip");
277 : #endif
278 :
279 4 : if (!test_opt(sb, RESERVATION))
280 1 : seq_puts(seq, ",noreservation");
281 :
282 1 : return 0;
283 : }
284 :
285 : #ifdef CONFIG_QUOTA
286 : static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data, size_t len, loff_t off);
287 : static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *data, size_t len, loff_t off);
288 : #endif
289 :
290 1 : static const struct super_operations ext2_sops = {
291 : .alloc_inode = ext2_alloc_inode,
292 : .destroy_inode = ext2_destroy_inode,
293 : .write_inode = ext2_write_inode,
294 : .delete_inode = ext2_delete_inode,
295 : .put_super = ext2_put_super,
296 : .write_super = ext2_write_super,
297 : .sync_fs = ext2_sync_fs,
298 : .statfs = ext2_statfs,
299 : .remount_fs = ext2_remount,
300 : .clear_inode = ext2_clear_inode,
301 : .show_options = ext2_show_options,
302 : #ifdef CONFIG_QUOTA
303 : .quota_read = ext2_quota_read,
304 : .quota_write = ext2_quota_write,
305 : #endif
306 : };
307 :
308 : static struct inode *ext2_nfs_get_inode(struct super_block *sb,
309 : u64 ino, u32 generation)
310 0 : {
311 0 : struct inode *inode;
312 0 :
313 0 : if (ino < EXT2_FIRST_INO(sb) && ino != EXT2_ROOT_INO)
314 0 : return ERR_PTR(-ESTALE);
315 0 : if (ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
316 0 : return ERR_PTR(-ESTALE);
317 0 :
318 : /* iget isn't really right if the inode is currently unallocated!!
319 : * ext2_read_inode currently does appropriate checks, but
320 : * it might be "neater" to call ext2_get_inode first and check
321 : * if the inode is valid.....
322 : */
323 0 : inode = ext2_iget(sb, ino);
324 0 : if (IS_ERR(inode))
325 0 : return ERR_CAST(inode);
326 0 : if (generation && inode->i_generation != generation) {
327 : /* we didn't find the right inode.. */
328 0 : iput(inode);
329 0 : return ERR_PTR(-ESTALE);
330 : }
331 0 : return inode;
332 : }
333 :
334 : static struct dentry *ext2_fh_to_dentry(struct super_block *sb, struct fid *fid,
335 : int fh_len, int fh_type)
336 : {
337 3 : return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
338 : ext2_nfs_get_inode);
339 : }
340 :
341 : static struct dentry *ext2_fh_to_parent(struct super_block *sb, struct fid *fid,
342 : int fh_len, int fh_type)
343 : {
344 3 : return generic_fh_to_parent(sb, fid, fh_len, fh_type,
345 : ext2_nfs_get_inode);
346 : }
347 :
348 : /* Yes, most of these are left as NULL!!
349 : * A NULL value implies the default, which works with ext2-like file
350 : * systems, but can be improved upon.
351 : * Currently only get_parent is required.
352 : */
353 1 : static const struct export_operations ext2_export_ops = {
354 : .fh_to_dentry = ext2_fh_to_dentry,
355 : .fh_to_parent = ext2_fh_to_parent,
356 : .get_parent = ext2_get_parent,
357 : };
358 :
359 : static unsigned long get_sb_block(void **data)
360 : {
361 0 : unsigned long sb_block;
362 0 : char *options = (char *) *data;
363 0 :
364 0 : if (!options || strncmp(options, "sb=", 3) != 0)
365 0 : return 1; /* Default location */
366 0 : options += 3;
367 0 : sb_block = simple_strtoul(options, &options, 0);
368 0 : if (*options && *options != ',') {
369 0 : printk("EXT2-fs: Invalid sb specification: %s\n",
370 : (char *) *data);
371 0 : return 1;
372 : }
373 0 : if (*options == ',')
374 0 : options++;
375 0 : *data = (void *) options;
376 0 : return sb_block;
377 : }
378 :
379 : enum {
380 : Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
381 : Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic,
382 : Opt_err_ro, Opt_nouid32, Opt_nocheck, Opt_debug,
383 : Opt_oldalloc, Opt_orlov, Opt_nobh, Opt_user_xattr, Opt_nouser_xattr,
384 : Opt_acl, Opt_noacl, Opt_xip, Opt_ignore, Opt_err, Opt_quota,
385 : Opt_usrquota, Opt_grpquota, Opt_reservation, Opt_noreservation
386 : };
387 :
388 1 : static const match_table_t tokens = {
389 : {Opt_bsd_df, "bsddf"},
390 : {Opt_minix_df, "minixdf"},
391 : {Opt_grpid, "grpid"},
392 : {Opt_grpid, "bsdgroups"},
393 : {Opt_nogrpid, "nogrpid"},
394 : {Opt_nogrpid, "sysvgroups"},
395 : {Opt_resgid, "resgid=%u"},
396 : {Opt_resuid, "resuid=%u"},
397 : {Opt_sb, "sb=%u"},
398 : {Opt_err_cont, "errors=continue"},
399 : {Opt_err_panic, "errors=panic"},
400 : {Opt_err_ro, "errors=remount-ro"},
401 : {Opt_nouid32, "nouid32"},
402 : {Opt_nocheck, "check=none"},
403 : {Opt_nocheck, "nocheck"},
404 : {Opt_debug, "debug"},
405 : {Opt_oldalloc, "oldalloc"},
406 : {Opt_orlov, "orlov"},
407 : {Opt_nobh, "nobh"},
408 : {Opt_user_xattr, "user_xattr"},
409 : {Opt_nouser_xattr, "nouser_xattr"},
410 : {Opt_acl, "acl"},
411 : {Opt_noacl, "noacl"},
412 : {Opt_xip, "xip"},
413 : {Opt_grpquota, "grpquota"},
414 : {Opt_ignore, "noquota"},
415 : {Opt_quota, "quota"},
416 : {Opt_usrquota, "usrquota"},
417 : {Opt_reservation, "reservation"},
418 : {Opt_noreservation, "noreservation"},
419 : {Opt_err, NULL}
420 : };
421 :
422 : static int parse_options(char *options, struct super_block *sb)
423 : {
424 1 : char *p;
425 4 : struct ext2_sb_info *sbi = EXT2_SB(sb);
426 1 : substring_t args[MAX_OPT_ARGS];
427 1 : int option;
428 1 :
429 3 : if (!options)
430 2 : return 1;
431 1 :
432 4 : while ((p = strsep (&options, ",")) != NULL) {
433 1 : int token;
434 3 : if (!*p)
435 1 : continue;
436 :
437 1 : token = match_token(p, tokens, args);
438 : switch (token) {
439 3 : case Opt_bsd_df:
440 1 : clear_opt (sbi->s_mount_opt, MINIX_DF);
441 1 : break;
442 4 : case Opt_minix_df:
443 1 : set_opt (sbi->s_mount_opt, MINIX_DF);
444 1 : break;
445 4 : case Opt_grpid:
446 1 : set_opt (sbi->s_mount_opt, GRPID);
447 1 : break;
448 4 : case Opt_nogrpid:
449 1 : clear_opt (sbi->s_mount_opt, GRPID);
450 1 : break;
451 4 : case Opt_resuid:
452 3 : if (match_int(&args[0], &option))
453 1 : return 0;
454 1 : sbi->s_resuid = option;
455 1 : break;
456 4 : case Opt_resgid:
457 3 : if (match_int(&args[0], &option))
458 1 : return 0;
459 1 : sbi->s_resgid = option;
460 1 : break;
461 4 : case Opt_sb:
462 : /* handled by get_sb_block() instead of here */
463 : /* *sb_block = match_int(&args[0]); */
464 1 : break;
465 4 : case Opt_err_panic:
466 1 : clear_opt (sbi->s_mount_opt, ERRORS_CONT);
467 1 : clear_opt (sbi->s_mount_opt, ERRORS_RO);
468 1 : set_opt (sbi->s_mount_opt, ERRORS_PANIC);
469 1 : break;
470 4 : case Opt_err_ro:
471 1 : clear_opt (sbi->s_mount_opt, ERRORS_CONT);
472 1 : clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
473 1 : set_opt (sbi->s_mount_opt, ERRORS_RO);
474 1 : break;
475 4 : case Opt_err_cont:
476 1 : clear_opt (sbi->s_mount_opt, ERRORS_RO);
477 1 : clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
478 1 : set_opt (sbi->s_mount_opt, ERRORS_CONT);
479 1 : break;
480 4 : case Opt_nouid32:
481 1 : set_opt (sbi->s_mount_opt, NO_UID32);
482 1 : break;
483 4 : case Opt_nocheck:
484 1 : clear_opt (sbi->s_mount_opt, CHECK);
485 1 : break;
486 4 : case Opt_debug:
487 1 : set_opt (sbi->s_mount_opt, DEBUG);
488 1 : break;
489 4 : case Opt_oldalloc:
490 1 : set_opt (sbi->s_mount_opt, OLDALLOC);
491 1 : break;
492 4 : case Opt_orlov:
493 1 : clear_opt (sbi->s_mount_opt, OLDALLOC);
494 1 : break;
495 4 : case Opt_nobh:
496 1 : set_opt (sbi->s_mount_opt, NOBH);
497 1 : break;
498 1 : #ifdef CONFIG_EXT2_FS_XATTR
499 3 : case Opt_user_xattr:
500 1 : set_opt (sbi->s_mount_opt, XATTR_USER);
501 1 : break;
502 4 : case Opt_nouser_xattr:
503 1 : clear_opt (sbi->s_mount_opt, XATTR_USER);
504 1 : break;
505 1 : #else
506 1 : case Opt_user_xattr:
507 : case Opt_nouser_xattr:
508 : ext2_msg(sb, KERN_INFO, "(no)user_xattr options"
509 : "not supported");
510 : break;
511 : #endif
512 : #ifdef CONFIG_EXT2_FS_POSIX_ACL
513 : case Opt_acl:
514 : set_opt(sbi->s_mount_opt, POSIX_ACL);
515 : break;
516 : case Opt_noacl:
517 : clear_opt(sbi->s_mount_opt, POSIX_ACL);
518 : break;
519 : #else
520 3 : case Opt_acl:
521 3 : case Opt_noacl:
522 2 : ext2_msg(sb, KERN_INFO,
523 : "(no)acl options not supported");
524 1 : break;
525 1 : #endif
526 3 : case Opt_xip:
527 : #ifdef CONFIG_EXT2_FS_XIP
528 : set_opt (sbi->s_mount_opt, XIP);
529 : #else
530 2 : ext2_msg(sb, KERN_INFO, "xip option not supported");
531 : #endif
532 1 : break;
533 1 :
534 1 : #if defined(CONFIG_QUOTA)
535 1 : case Opt_quota:
536 : case Opt_usrquota:
537 : set_opt(sbi->s_mount_opt, USRQUOTA);
538 : break;
539 :
540 : case Opt_grpquota:
541 : set_opt(sbi->s_mount_opt, GRPQUOTA);
542 : break;
543 : #else
544 3 : case Opt_quota:
545 3 : case Opt_usrquota:
546 3 : case Opt_grpquota:
547 2 : ext2_msg(sb, KERN_INFO,
548 : "quota operations not supported");
549 1 : break;
550 1 : #endif
551 :
552 3 : case Opt_reservation:
553 1 : set_opt(sbi->s_mount_opt, RESERVATION);
554 2 : ext2_msg(sb, KERN_INFO, "reservations ON");
555 1 : break;
556 4 : case Opt_noreservation:
557 1 : clear_opt(sbi->s_mount_opt, RESERVATION);
558 2 : ext2_msg(sb, KERN_INFO, "reservations OFF");
559 1 : break;
560 4 : case Opt_ignore:
561 1 : break;
562 2 : default:
563 2 : return 0;
564 : }
565 : }
566 1 : return 1;
567 6 : }
568 :
569 : static int ext2_setup_super (struct super_block * sb,
570 : struct ext2_super_block * es,
571 : int read_only)
572 1 : {
573 2 : int res = 0;
574 4 : struct ext2_sb_info *sbi = EXT2_SB(sb);
575 1 :
576 3 : if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {
577 3 : ext2_msg(sb, KERN_ERR,
578 1 : "error: revision level too high, "
579 : "forcing read-only mode");
580 1 : res = MS_RDONLY;
581 : }
582 4 : if (read_only)
583 2 : return res;
584 6 : if (!(sbi->s_mount_state & EXT2_VALID_FS))
585 4 : ext2_msg(sb, KERN_WARNING,
586 : "warning: mounting unchecked fs, "
587 : "running e2fsck is recommended");
588 6 : else if ((sbi->s_mount_state & EXT2_ERROR_FS))
589 4 : ext2_msg(sb, KERN_WARNING,
590 : "warning: mounting fs with errors, "
591 : "running e2fsck is recommended");
592 14 : else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
593 : le16_to_cpu(es->s_mnt_count) >=
594 : (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
595 4 : ext2_msg(sb, KERN_WARNING,
596 : "warning: maximal mount count reached, "
597 : "running e2fsck is recommended");
598 10 : else if (le32_to_cpu(es->s_checkinterval) &&
599 : (le32_to_cpu(es->s_lastcheck) +
600 : le32_to_cpu(es->s_checkinterval) <= get_seconds()))
601 4 : ext2_msg(sb, KERN_WARNING,
602 : "warning: checktime reached, "
603 : "running e2fsck is recommended");
604 18 : if (!le16_to_cpu(es->s_max_mnt_count))
605 6 : es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
606 12 : le16_add_cpu(&es->s_mnt_count, 1);
607 3 : ext2_write_super(sb);
608 4 : if (test_opt (sb, DEBUG))
609 6 : ext2_msg(sb, KERN_INFO, "%s, %s, bs=%lu, fs=%lu, gc=%lu, "
610 : "bpg=%lu, ipg=%lu, mo=%04lx]",
611 : EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,
612 : sbi->s_frag_size,
613 : sbi->s_groups_count,
614 : EXT2_BLOCKS_PER_GROUP(sb),
615 : EXT2_INODES_PER_GROUP(sb),
616 : sbi->s_mount_opt);
617 2 : return res;
618 : }
619 :
620 : static int ext2_check_descriptors(struct super_block *sb)
621 : {
622 0 : int i;
623 0 : struct ext2_sb_info *sbi = EXT2_SB(sb);
624 0 :
625 0 : ext2_debug ("Checking group descriptors");
626 0 :
627 0 : for (i = 0; i < sbi->s_groups_count; i++) {
628 0 : struct ext2_group_desc *gdp = ext2_get_group_desc(sb, i, NULL);
629 0 : ext2_fsblk_t first_block = ext2_group_first_block_no(sb, i);
630 0 : ext2_fsblk_t last_block;
631 :
632 0 : if (i == sbi->s_groups_count - 1)
633 0 : last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
634 : else
635 0 : last_block = first_block +
636 : (EXT2_BLOCKS_PER_GROUP(sb) - 1);
637 :
638 0 : if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
639 : le32_to_cpu(gdp->bg_block_bitmap) > last_block)
640 : {
641 0 : ext2_error (sb, "ext2_check_descriptors",
642 : "Block bitmap for group %d"
643 : " not in group (block %lu)!",
644 : i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));
645 0 : return 0;
646 : }
647 0 : if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
648 : le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
649 : {
650 0 : ext2_error (sb, "ext2_check_descriptors",
651 : "Inode bitmap for group %d"
652 : " not in group (block %lu)!",
653 : i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));
654 0 : return 0;
655 : }
656 0 : if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
657 : le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 >
658 : last_block)
659 : {
660 0 : ext2_error (sb, "ext2_check_descriptors",
661 : "Inode table for group %d"
662 : " not in group (block %lu)!",
663 : i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));
664 0 : return 0;
665 : }
666 : }
667 0 : return 1;
668 : }
669 :
670 : /*
671 : * Maximal file size. There is a direct, and {,double-,triple-}indirect
672 : * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
673 : * We need to be 1 filesystem block less than the 2^32 sector limit.
674 : */
675 : static loff_t ext2_max_size(int bits)
676 : {
677 0 : loff_t res = EXT2_NDIR_BLOCKS;
678 0 : int meta_blocks;
679 0 : loff_t upper_limit;
680 :
681 : /* This is calculated to be the largest file size for a
682 : * dense, file such that the total number of
683 : * sectors in the file, including data and all indirect blocks,
684 : * does not exceed 2^32 -1
685 : * __u32 i_blocks representing the total number of
686 : * 512 bytes blocks of the file
687 : */
688 0 : upper_limit = (1LL << 32) - 1;
689 :
690 : /* total blocks in file system block size */
691 0 : upper_limit >>= (bits - 9);
692 :
693 :
694 : /* indirect blocks */
695 0 : meta_blocks = 1;
696 : /* double indirect blocks */
697 0 : meta_blocks += 1 + (1LL << (bits-2));
698 : /* tripple indirect blocks */
699 0 : meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
700 :
701 0 : upper_limit -= meta_blocks;
702 0 : upper_limit <<= bits;
703 :
704 0 : res += 1LL << (bits-2);
705 0 : res += 1LL << (2*(bits-2));
706 0 : res += 1LL << (3*(bits-2));
707 0 : res <<= bits;
708 0 : if (res > upper_limit)
709 0 : res = upper_limit;
710 :
711 0 : if (res > MAX_LFS_FILESIZE)
712 0 : res = MAX_LFS_FILESIZE;
713 :
714 0 : return res;
715 : }
716 :
717 : static unsigned long descriptor_loc(struct super_block *sb,
718 : unsigned long logic_sb_block,
719 : int nr)
720 0 : {
721 0 : struct ext2_sb_info *sbi = EXT2_SB(sb);
722 0 : unsigned long bg, first_meta_bg;
723 0 : int has_super = 0;
724 0 :
725 0 : first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
726 0 :
727 0 : if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_META_BG) ||
728 : nr < first_meta_bg)
729 0 : return (logic_sb_block + nr + 1);
730 0 : bg = sbi->s_desc_per_block * nr;
731 0 : if (ext2_bg_has_super(sb, bg))
732 0 : has_super = 1;
733 :
734 0 : return ext2_group_first_block_no(sb, bg) + has_super;
735 : }
736 :
737 : static int ext2_fill_super(struct super_block *sb, void *data, int silent)
738 : {
739 0 : struct buffer_head * bh;
740 0 : struct ext2_sb_info * sbi;
741 0 : struct ext2_super_block * es;
742 0 : struct inode *root;
743 0 : unsigned long block;
744 0 : unsigned long sb_block = get_sb_block(&data);
745 0 : unsigned long logic_sb_block;
746 0 : unsigned long offset = 0;
747 0 : unsigned long def_mount_opts;
748 0 : long ret = -EINVAL;
749 0 : int blocksize = BLOCK_SIZE;
750 0 : int db_count;
751 0 : int i, j;
752 0 : __le32 features;
753 0 : int err;
754 0 :
755 0 : sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
756 0 : if (!sbi)
757 0 : return -ENOMEM;
758 0 :
759 0 : sbi->s_blockgroup_lock =
760 0 : kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
761 0 : if (!sbi->s_blockgroup_lock) {
762 0 : kfree(sbi);
763 0 : return -ENOMEM;
764 0 : }
765 0 : sb->s_fs_info = sbi;
766 0 : sbi->s_sb_block = sb_block;
767 0 :
768 0 : /*
769 0 : * See what the current blocksize for the device is, and
770 0 : * use that as the blocksize. Otherwise (or if the blocksize
771 0 : * is smaller than the default) use the default.
772 0 : * This is important for devices that have a hardware
773 0 : * sectorsize that is larger than the default.
774 0 : */
775 0 : blocksize = sb_min_blocksize(sb, BLOCK_SIZE);
776 0 : if (!blocksize) {
777 0 : ext2_msg(sb, KERN_ERR, "error: unable to set blocksize");
778 0 : goto failed_sbi;
779 0 : }
780 0 :
781 0 : /*
782 0 : * If the superblock doesn't start on a hardware sector boundary,
783 0 : * calculate the offset.
784 0 : */
785 0 : if (blocksize != BLOCK_SIZE) {
786 0 : logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
787 0 : offset = (sb_block*BLOCK_SIZE) % blocksize;
788 0 : } else {
789 0 : logic_sb_block = sb_block;
790 0 : }
791 0 :
792 0 : if (!(bh = sb_bread(sb, logic_sb_block))) {
793 0 : ext2_msg(sb, KERN_ERR, "error: unable to read superblock");
794 0 : goto failed_sbi;
795 : }
796 : /*
797 : * Note: s_es must be initialized as soon as possible because
798 : * some ext2 macro-instructions depend on its value
799 : */
800 0 : es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
801 0 : sbi->s_es = es;
802 0 : sb->s_magic = le16_to_cpu(es->s_magic);
803 :
804 0 : if (sb->s_magic != EXT2_SUPER_MAGIC)
805 0 : goto cantfind_ext2;
806 :
807 : /* Set defaults before we parse the mount options */
808 0 : def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
809 0 : if (def_mount_opts & EXT2_DEFM_DEBUG)
810 0 : set_opt(sbi->s_mount_opt, DEBUG);
811 0 : if (def_mount_opts & EXT2_DEFM_BSDGROUPS)
812 0 : set_opt(sbi->s_mount_opt, GRPID);
813 0 : if (def_mount_opts & EXT2_DEFM_UID16)
814 0 : set_opt(sbi->s_mount_opt, NO_UID32);
815 : #ifdef CONFIG_EXT2_FS_XATTR
816 0 : if (def_mount_opts & EXT2_DEFM_XATTR_USER)
817 0 : set_opt(sbi->s_mount_opt, XATTR_USER);
818 : #endif
819 : #ifdef CONFIG_EXT2_FS_POSIX_ACL
820 : if (def_mount_opts & EXT2_DEFM_ACL)
821 : set_opt(sbi->s_mount_opt, POSIX_ACL);
822 : #endif
823 :
824 0 : if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)
825 0 : set_opt(sbi->s_mount_opt, ERRORS_PANIC);
826 0 : else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_CONTINUE)
827 0 : set_opt(sbi->s_mount_opt, ERRORS_CONT);
828 : else
829 0 : set_opt(sbi->s_mount_opt, ERRORS_RO);
830 :
831 0 : sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
832 0 : sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
833 :
834 0 : set_opt(sbi->s_mount_opt, RESERVATION);
835 :
836 0 : if (!parse_options((char *) data, sb))
837 0 : goto failed_mount;
838 :
839 0 : sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
840 : ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
841 : MS_POSIXACL : 0);
842 :
843 : ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset
844 : EXT2_MOUNT_XIP if not */
845 :
846 0 : if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
847 : (EXT2_HAS_COMPAT_FEATURE(sb, ~0U) ||
848 : EXT2_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
849 : EXT2_HAS_INCOMPAT_FEATURE(sb, ~0U)))
850 0 : ext2_msg(sb, KERN_WARNING,
851 : "warning: feature flags set on rev 0 fs, "
852 : "running e2fsck is recommended");
853 : /*
854 : * Check feature flags regardless of the revision level, since we
855 : * previously didn't change the revision level when setting the flags,
856 : * so there is a chance incompat flags are set on a rev 0 filesystem.
857 : */
858 0 : features = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP);
859 0 : if (features) {
860 0 : ext2_msg(sb, KERN_ERR, "error: couldn't mount because of "
861 : "unsupported optional features (%x)",
862 : le32_to_cpu(features));
863 0 : goto failed_mount;
864 : }
865 0 : if (!(sb->s_flags & MS_RDONLY) &&
866 : (features = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){
867 0 : ext2_msg(sb, KERN_ERR, "error: couldn't mount RDWR because of "
868 : "unsupported optional features (%x)",
869 : le32_to_cpu(features));
870 0 : goto failed_mount;
871 : }
872 :
873 0 : blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
874 :
875 : if (ext2_use_xip(sb) && blocksize != PAGE_SIZE) {
876 : if (!silent)
877 : ext2_msg(sb, KERN_ERR,
878 : "error: unsupported blocksize for xip");
879 : goto failed_mount;
880 : }
881 :
882 : /* If the blocksize doesn't match, re-read the thing.. */
883 0 : if (sb->s_blocksize != blocksize) {
884 0 : brelse(bh);
885 :
886 0 : if (!sb_set_blocksize(sb, blocksize)) {
887 0 : ext2_msg(sb, KERN_ERR, "error: blocksize is too small");
888 0 : goto failed_sbi;
889 : }
890 :
891 0 : logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
892 0 : offset = (sb_block*BLOCK_SIZE) % blocksize;
893 0 : bh = sb_bread(sb, logic_sb_block);
894 0 : if(!bh) {
895 0 : ext2_msg(sb, KERN_ERR, "error: couldn't read"
896 : "superblock on 2nd try");
897 0 : goto failed_sbi;
898 : }
899 0 : es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
900 0 : sbi->s_es = es;
901 0 : if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
902 0 : ext2_msg(sb, KERN_ERR, "error: magic mismatch");
903 0 : goto failed_mount;
904 : }
905 : }
906 :
907 0 : sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
908 :
909 0 : if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
910 0 : sbi->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
911 0 : sbi->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
912 : } else {
913 0 : sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
914 0 : sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
915 0 : if ((sbi->s_inode_size < EXT2_GOOD_OLD_INODE_SIZE) ||
916 : !is_power_of_2(sbi->s_inode_size) ||
917 : (sbi->s_inode_size > blocksize)) {
918 0 : ext2_msg(sb, KERN_ERR,
919 : "error: unsupported inode size: %d",
920 : sbi->s_inode_size);
921 0 : goto failed_mount;
922 : }
923 : }
924 :
925 0 : sbi->s_frag_size = EXT2_MIN_FRAG_SIZE <<
926 : le32_to_cpu(es->s_log_frag_size);
927 0 : if (sbi->s_frag_size == 0)
928 0 : goto cantfind_ext2;
929 0 : sbi->s_frags_per_block = sb->s_blocksize / sbi->s_frag_size;
930 :
931 0 : sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
932 0 : sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
933 0 : sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
934 :
935 0 : if (EXT2_INODE_SIZE(sb) == 0)
936 0 : goto cantfind_ext2;
937 0 : sbi->s_inodes_per_block = sb->s_blocksize / EXT2_INODE_SIZE(sb);
938 0 : if (sbi->s_inodes_per_block == 0 || sbi->s_inodes_per_group == 0)
939 0 : goto cantfind_ext2;
940 0 : sbi->s_itb_per_group = sbi->s_inodes_per_group /
941 : sbi->s_inodes_per_block;
942 0 : sbi->s_desc_per_block = sb->s_blocksize /
943 : sizeof (struct ext2_group_desc);
944 0 : sbi->s_sbh = bh;
945 0 : sbi->s_mount_state = le16_to_cpu(es->s_state);
946 0 : sbi->s_addr_per_block_bits =
947 : ilog2 (EXT2_ADDR_PER_BLOCK(sb));
948 0 : sbi->s_desc_per_block_bits =
949 : ilog2 (EXT2_DESC_PER_BLOCK(sb));
950 :
951 0 : if (sb->s_magic != EXT2_SUPER_MAGIC)
952 0 : goto cantfind_ext2;
953 :
954 0 : if (sb->s_blocksize != bh->b_size) {
955 0 : if (!silent)
956 0 : ext2_msg(sb, KERN_ERR, "error: unsupported blocksize");
957 0 : goto failed_mount;
958 : }
959 :
960 0 : if (sb->s_blocksize != sbi->s_frag_size) {
961 0 : ext2_msg(sb, KERN_ERR,
962 : "error: fragsize %lu != blocksize %lu"
963 : "(not supported yet)",
964 : sbi->s_frag_size, sb->s_blocksize);
965 0 : goto failed_mount;
966 : }
967 :
968 0 : if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
969 0 : ext2_msg(sb, KERN_ERR,
970 : "error: #blocks per group too big: %lu",
971 : sbi->s_blocks_per_group);
972 0 : goto failed_mount;
973 : }
974 0 : if (sbi->s_frags_per_group > sb->s_blocksize * 8) {
975 0 : ext2_msg(sb, KERN_ERR,
976 : "error: #fragments per group too big: %lu",
977 : sbi->s_frags_per_group);
978 0 : goto failed_mount;
979 : }
980 0 : if (sbi->s_inodes_per_group > sb->s_blocksize * 8) {
981 0 : ext2_msg(sb, KERN_ERR,
982 : "error: #inodes per group too big: %lu",
983 : sbi->s_inodes_per_group);
984 0 : goto failed_mount;
985 : }
986 :
987 0 : if (EXT2_BLOCKS_PER_GROUP(sb) == 0)
988 0 : goto cantfind_ext2;
989 0 : sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
990 : le32_to_cpu(es->s_first_data_block) - 1)
991 : / EXT2_BLOCKS_PER_GROUP(sb)) + 1;
992 0 : db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
993 : EXT2_DESC_PER_BLOCK(sb);
994 0 : sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
995 0 : if (sbi->s_group_desc == NULL) {
996 0 : ext2_msg(sb, KERN_ERR, "error: not enough memory");
997 0 : goto failed_mount;
998 : }
999 0 : bgl_lock_init(sbi->s_blockgroup_lock);
1000 0 : sbi->s_debts = kcalloc(sbi->s_groups_count, sizeof(*sbi->s_debts), GFP_KERNEL);
1001 0 : if (!sbi->s_debts) {
1002 0 : ext2_msg(sb, KERN_ERR, "error: not enough memory");
1003 0 : goto failed_mount_group_desc;
1004 : }
1005 0 : for (i = 0; i < db_count; i++) {
1006 0 : block = descriptor_loc(sb, logic_sb_block, i);
1007 0 : sbi->s_group_desc[i] = sb_bread(sb, block);
1008 0 : if (!sbi->s_group_desc[i]) {
1009 0 : for (j = 0; j < i; j++)
1010 0 : brelse (sbi->s_group_desc[j]);
1011 0 : ext2_msg(sb, KERN_ERR,
1012 : "error: unable to read group descriptors");
1013 0 : goto failed_mount_group_desc;
1014 : }
1015 : }
1016 0 : if (!ext2_check_descriptors (sb)) {
1017 0 : ext2_msg(sb, KERN_ERR, "group descriptors corrupted");
1018 0 : goto failed_mount2;
1019 : }
1020 0 : sbi->s_gdb_count = db_count;
1021 0 : get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1022 0 : spin_lock_init(&sbi->s_next_gen_lock);
1023 :
1024 : /* per fileystem reservation list head & lock */
1025 0 : spin_lock_init(&sbi->s_rsv_window_lock);
1026 0 : sbi->s_rsv_window_root = RB_ROOT;
1027 : /*
1028 : * Add a single, static dummy reservation to the start of the
1029 : * reservation window list --- it gives us a placeholder for
1030 : * append-at-start-of-list which makes the allocation logic
1031 : * _much_ simpler.
1032 : */
1033 0 : sbi->s_rsv_window_head.rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
1034 0 : sbi->s_rsv_window_head.rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
1035 0 : sbi->s_rsv_window_head.rsv_alloc_hit = 0;
1036 0 : sbi->s_rsv_window_head.rsv_goal_size = 0;
1037 0 : ext2_rsv_window_add(sb, &sbi->s_rsv_window_head);
1038 :
1039 0 : err = percpu_counter_init(&sbi->s_freeblocks_counter,
1040 : ext2_count_free_blocks(sb));
1041 0 : if (!err) {
1042 0 : err = percpu_counter_init(&sbi->s_freeinodes_counter,
1043 : ext2_count_free_inodes(sb));
1044 : }
1045 0 : if (!err) {
1046 0 : err = percpu_counter_init(&sbi->s_dirs_counter,
1047 : ext2_count_dirs(sb));
1048 : }
1049 0 : if (err) {
1050 0 : ext2_msg(sb, KERN_ERR, "error: insufficient memory");
1051 0 : goto failed_mount3;
1052 : }
1053 : /*
1054 : * set up enough so that it can read an inode
1055 : */
1056 0 : sb->s_op = &ext2_sops;
1057 0 : sb->s_export_op = &ext2_export_ops;
1058 0 : sb->s_xattr = ext2_xattr_handlers;
1059 0 : root = ext2_iget(sb, EXT2_ROOT_INO);
1060 0 : if (IS_ERR(root)) {
1061 0 : ret = PTR_ERR(root);
1062 0 : goto failed_mount3;
1063 : }
1064 0 : if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1065 0 : iput(root);
1066 0 : ext2_msg(sb, KERN_ERR, "error: corrupt root inode, run e2fsck");
1067 0 : goto failed_mount3;
1068 : }
1069 :
1070 0 : sb->s_root = d_alloc_root(root);
1071 0 : if (!sb->s_root) {
1072 0 : iput(root);
1073 0 : ext2_msg(sb, KERN_ERR, "error: get root inode failed");
1074 0 : ret = -ENOMEM;
1075 0 : goto failed_mount3;
1076 : }
1077 0 : if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
1078 0 : ext2_msg(sb, KERN_WARNING,
1079 : "warning: mounting ext3 filesystem as ext2");
1080 0 : ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
1081 0 : return 0;
1082 0 :
1083 : cantfind_ext2:
1084 0 : if (!silent)
1085 0 : ext2_msg(sb, KERN_ERR,
1086 : "error: can't find an ext2 filesystem on dev %s.",
1087 : sb->s_id);
1088 0 : goto failed_mount;
1089 0 : failed_mount3:
1090 0 : percpu_counter_destroy(&sbi->s_freeblocks_counter);
1091 0 : percpu_counter_destroy(&sbi->s_freeinodes_counter);
1092 0 : percpu_counter_destroy(&sbi->s_dirs_counter);
1093 : failed_mount2:
1094 0 : for (i = 0; i < db_count; i++)
1095 0 : brelse(sbi->s_group_desc[i]);
1096 0 : failed_mount_group_desc:
1097 0 : kfree(sbi->s_group_desc);
1098 0 : kfree(sbi->s_debts);
1099 : failed_mount:
1100 0 : brelse(bh);
1101 0 : failed_sbi:
1102 0 : sb->s_fs_info = NULL;
1103 0 : kfree(sbi->s_blockgroup_lock);
1104 0 : kfree(sbi);
1105 0 : return ret;
1106 : }
1107 :
1108 : static void ext2_clear_super_error(struct super_block *sb)
1109 : {
1110 28108 : struct buffer_head *sbh = EXT2_SB(sb)->s_sbh;
1111 7027 :
1112 35135 : if (buffer_write_io_error(sbh)) {
1113 : /*
1114 : * Oh, dear. A previous attempt to write the
1115 : * superblock failed. This could happen because the
1116 : * USB device was yanked out. Or it could happen to
1117 : * be a transient write error and maybe the block will
1118 : * be remapped. Nothing we can do but to retry the
1119 : * write and hope for the best.
1120 : */
1121 7027 : printk(KERN_ERR "EXT2-fs: %s previous I/O error to "
1122 : "superblock detected", sb->s_id);
1123 14054 : clear_buffer_write_io_error(sbh);
1124 14054 : set_buffer_uptodate(sbh);
1125 : }
1126 14054 : }
1127 :
1128 : static void ext2_commit_super (struct super_block * sb,
1129 : struct ext2_super_block * es)
1130 12 : {
1131 48 : ext2_clear_super_error(sb);
1132 24 : es->s_wtime = cpu_to_le32(get_seconds());
1133 36 : mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
1134 12 : sb->s_dirt = 0;
1135 12 : }
1136 :
1137 : static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
1138 : {
1139 28060 : ext2_clear_super_error(sb);
1140 28032 : es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
1141 28014 : es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
1142 21045 : es->s_wtime = cpu_to_le32(get_seconds());
1143 28060 : mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
1144 21045 : sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
1145 7015 : sb->s_dirt = 0;
1146 7015 : }
1147 :
1148 : /*
1149 : * In the second extended file system, it is not necessary to
1150 : * write the super block since we use a mapping of the
1151 : * disk super block in a buffer.
1152 : *
1153 : * However, this function is still used to set the fs valid
1154 : * flags to 0. We need to set this flag to 0 since the fs
1155 : * may have been checked while mounted and e2fsck may have
1156 : * set s_state to EXT2_VALID_FS after some corrections.
1157 : */
1158 :
1159 : static int ext2_sync_fs(struct super_block *sb, int wait)
1160 : {
1161 24 : struct ext2_super_block *es = EXT2_SB(sb)->s_es;
1162 24 : struct buffer_head *sbh = EXT2_SB(sb)->s_sbh;
1163 6 :
1164 12 : lock_kernel();
1165 30 : if (buffer_write_io_error(sbh)) {
1166 6 : /*
1167 6 : * Oh, dear. A previous attempt to write the
1168 6 : * superblock failed. This could happen because the
1169 : * USB device was yanked out. Or it could happen to
1170 : * be a transient write error and maybe the block will
1171 : * be remapped. Nothing we can do but to retry the
1172 : * write and hope for the best.
1173 : */
1174 12 : ext2_msg(sb, KERN_ERR,
1175 : "previous I/O error to superblock detected\n");
1176 12 : clear_buffer_write_io_error(sbh);
1177 12 : set_buffer_uptodate(sbh);
1178 : }
1179 :
1180 36 : if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {
1181 : ext2_debug("setting valid to 0\n");
1182 24 : es->s_state &= cpu_to_le16(~EXT2_VALID_FS);
1183 30 : es->s_free_blocks_count =
1184 : cpu_to_le32(ext2_count_free_blocks(sb));
1185 18 : es->s_free_inodes_count =
1186 : cpu_to_le32(ext2_count_free_inodes(sb));
1187 12 : es->s_mtime = cpu_to_le32(get_seconds());
1188 12 : ext2_sync_super(sb, es);
1189 : } else {
1190 24 : ext2_commit_super(sb, es);
1191 : }
1192 12 : sb->s_dirt = 0;
1193 12 : unlock_kernel();
1194 :
1195 12 : return 0;
1196 : }
1197 :
1198 :
1199 : void ext2_write_super(struct super_block *sb)
1200 : {
1201 10 : if (!(sb->s_flags & MS_RDONLY))
1202 15 : ext2_sync_fs(sb, 1);
1203 : else
1204 5 : sb->s_dirt = 0;
1205 10 : }
1206 :
1207 : static int ext2_remount (struct super_block * sb, int * flags, char * data)
1208 : {
1209 4 : struct ext2_sb_info * sbi = EXT2_SB(sb);
1210 1 : struct ext2_super_block * es;
1211 2 : unsigned long old_mount_opt = sbi->s_mount_opt;
1212 1 : struct ext2_mount_options old_opts;
1213 1 : unsigned long old_sb_flags;
1214 1 : int err;
1215 1 :
1216 2 : lock_kernel();
1217 1 :
1218 1 : /* Store the old options */
1219 2 : old_sb_flags = sb->s_flags;
1220 2 : old_opts.s_mount_opt = sbi->s_mount_opt;
1221 2 : old_opts.s_resuid = sbi->s_resuid;
1222 1 : old_opts.s_resgid = sbi->s_resgid;
1223 :
1224 : /*
1225 : * Allow the "check" option to be passed as a remount option.
1226 : */
1227 5 : if (!parse_options(data, sb)) {
1228 1 : err = -EINVAL;
1229 1 : goto restore_opts;
1230 : }
1231 :
1232 6 : sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1233 : ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1234 :
1235 : ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset
1236 : EXT2_MOUNT_XIP if not */
1237 :
1238 : if ((ext2_use_xip(sb)) && (sb->s_blocksize != PAGE_SIZE)) {
1239 : ext2_msg(sb, KERN_WARNING,
1240 : "warning: unsupported blocksize for xip");
1241 : err = -EINVAL;
1242 : goto restore_opts;
1243 : }
1244 :
1245 1 : es = sbi->s_es;
1246 5 : if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=
1247 : (old_mount_opt & EXT2_MOUNT_XIP)) &&
1248 : invalidate_inodes(sb)) {
1249 2 : ext2_msg(sb, KERN_WARNING, "warning: refusing change of "
1250 : "xip flag with busy inodes while remounting");
1251 1 : sbi->s_mount_opt &= ~EXT2_MOUNT_XIP;
1252 1 : sbi->s_mount_opt |= old_mount_opt & EXT2_MOUNT_XIP;
1253 : }
1254 4 : if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
1255 2 : unlock_kernel();
1256 2 : return 0;
1257 : }
1258 4 : if (*flags & MS_RDONLY) {
1259 12 : if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
1260 : !(sbi->s_mount_state & EXT2_VALID_FS)) {
1261 2 : unlock_kernel();
1262 2 : return 0;
1263 : }
1264 : /*
1265 : * OK, we are remounting a valid rw partition rdonly, so set
1266 : * the rdonly flag and then mark the partition as valid again.
1267 : */
1268 2 : es->s_state = cpu_to_le16(sbi->s_mount_state);
1269 4 : es->s_mtime = cpu_to_le32(get_seconds());
1270 : } else {
1271 5 : __le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,
1272 : ~EXT2_FEATURE_RO_COMPAT_SUPP);
1273 2 : if (ret) {
1274 2 : ext2_msg(sb, KERN_WARNING,
1275 : "warning: couldn't remount RDWR because of "
1276 : "unsupported optional features (%x).",
1277 : le32_to_cpu(ret));
1278 1 : err = -EROFS;
1279 1 : goto restore_opts;
1280 : }
1281 : /*
1282 : * Mounting a RDONLY partition read-write, so reread and
1283 : * store the current valid flag. (It may have been changed
1284 : * by e2fsck since we originally mounted the partition.)
1285 : */
1286 1 : sbi->s_mount_state = le16_to_cpu(es->s_state);
1287 7 : if (!ext2_setup_super (sb, es, 0))
1288 1 : sb->s_flags &= ~MS_RDONLY;
1289 : }
1290 6 : ext2_sync_super(sb, es);
1291 1 : unlock_kernel();
1292 1 : return 0;
1293 2 : restore_opts:
1294 2 : sbi->s_mount_opt = old_opts.s_mount_opt;
1295 2 : sbi->s_resuid = old_opts.s_resuid;
1296 2 : sbi->s_resgid = old_opts.s_resgid;
1297 2 : sb->s_flags = old_sb_flags;
1298 2 : unlock_kernel();
1299 2 : return err;
1300 : }
1301 :
1302 : static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
1303 : {
1304 2 : struct super_block *sb = dentry->d_sb;
1305 4 : struct ext2_sb_info *sbi = EXT2_SB(sb);
1306 2 : struct ext2_super_block *es = sbi->s_es;
1307 1 : u64 fsid;
1308 1 :
1309 5 : if (test_opt (sb, MINIX_DF))
1310 2 : sbi->s_overhead_last = 0;
1311 4 : else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
1312 2 : unsigned long i, overhead = 0;
1313 2 : smp_rmb();
1314 1 :
1315 1 : /*
1316 1 : * Compute the overhead (FS structures). This is constant
1317 1 : * for a given filesystem unless the number of block groups
1318 : * changes so we cache the previous value until it does.
1319 : */
1320 :
1321 : /*
1322 : * All of the blocks before first_data_block are
1323 : * overhead
1324 : */
1325 2 : overhead = le32_to_cpu(es->s_first_data_block);
1326 :
1327 : /*
1328 : * Add the overhead attributed to the superblock and
1329 : * block group descriptors. If the sparse superblocks
1330 : * feature is turned on, then not all groups have this.
1331 : */
1332 5 : for (i = 0; i < sbi->s_groups_count; i++)
1333 8 : overhead += ext2_bg_has_super(sb, i) +
1334 2 : ext2_bg_num_gdb(sb, i);
1335 :
1336 : /*
1337 : * Every block group has an inode bitmap, a block
1338 : * bitmap, and an inode table.
1339 : */
1340 1 : overhead += (sbi->s_groups_count *
1341 : (2 + sbi->s_itb_per_group));
1342 1 : sbi->s_overhead_last = overhead;
1343 1 : smp_wmb();
1344 2 : sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
1345 : }
1346 :
1347 2 : buf->f_type = EXT2_SUPER_MAGIC;
1348 4 : buf->f_bsize = sb->s_blocksize;
1349 4 : buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
1350 5 : buf->f_bfree = ext2_count_free_blocks(sb);
1351 2 : es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
1352 2 : buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
1353 3 : if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
1354 1 : buf->f_bavail = 0;
1355 2 : buf->f_files = le32_to_cpu(es->s_inodes_count);
1356 3 : buf->f_ffree = ext2_count_free_inodes(sb);
1357 2 : es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
1358 1 : buf->f_namelen = EXT2_NAME_LEN;
1359 5 : fsid = le64_to_cpup((void *)es->s_uuid) ^
1360 : le64_to_cpup((void *)es->s_uuid + sizeof(u64));
1361 1 : buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
1362 1 : buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
1363 1 : return 0;
1364 : }
1365 :
1366 : static int ext2_get_sb(struct file_system_type *fs_type,
1367 : int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1368 : {
1369 3 : return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super, mnt);
1370 : }
1371 :
1372 : #ifdef CONFIG_QUOTA
1373 :
1374 : /* Read data from quotafile - avoid pagecache and such because we cannot afford
1375 : * acquiring the locks... As quota files are never truncated and quota code
1376 : * itself serializes the operations (and noone else should touch the files)
1377 : * we don't have to be afraid of races */
1378 : static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data,
1379 : size_t len, loff_t off)
1380 : {
1381 : struct inode *inode = sb_dqopt(sb)->files[type];
1382 : sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
1383 : int err = 0;
1384 : int offset = off & (sb->s_blocksize - 1);
1385 : int tocopy;
1386 : size_t toread;
1387 : struct buffer_head tmp_bh;
1388 : struct buffer_head *bh;
1389 : loff_t i_size = i_size_read(inode);
1390 :
1391 : if (off > i_size)
1392 : return 0;
1393 : if (off+len > i_size)
1394 : len = i_size-off;
1395 : toread = len;
1396 : while (toread > 0) {
1397 : tocopy = sb->s_blocksize - offset < toread ?
1398 : sb->s_blocksize - offset : toread;
1399 :
1400 : tmp_bh.b_state = 0;
1401 : tmp_bh.b_size = sb->s_blocksize;
1402 : err = ext2_get_block(inode, blk, &tmp_bh, 0);
1403 : if (err < 0)
1404 : return err;
1405 : if (!buffer_mapped(&tmp_bh)) /* A hole? */
1406 : memset(data, 0, tocopy);
1407 : else {
1408 : bh = sb_bread(sb, tmp_bh.b_blocknr);
1409 : if (!bh)
1410 : return -EIO;
1411 : memcpy(data, bh->b_data+offset, tocopy);
1412 : brelse(bh);
1413 : }
1414 : offset = 0;
1415 : toread -= tocopy;
1416 : data += tocopy;
1417 : blk++;
1418 : }
1419 : return len;
1420 : }
1421 :
1422 : /* Write to quotafile */
1423 : static ssize_t ext2_quota_write(struct super_block *sb, int type,
1424 : const char *data, size_t len, loff_t off)
1425 : {
1426 : struct inode *inode = sb_dqopt(sb)->files[type];
1427 : sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
1428 : int err = 0;
1429 : int offset = off & (sb->s_blocksize - 1);
1430 : int tocopy;
1431 : size_t towrite = len;
1432 : struct buffer_head tmp_bh;
1433 : struct buffer_head *bh;
1434 :
1435 : mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
1436 : while (towrite > 0) {
1437 : tocopy = sb->s_blocksize - offset < towrite ?
1438 : sb->s_blocksize - offset : towrite;
1439 :
1440 : tmp_bh.b_state = 0;
1441 : err = ext2_get_block(inode, blk, &tmp_bh, 1);
1442 : if (err < 0)
1443 : goto out;
1444 : if (offset || tocopy != EXT2_BLOCK_SIZE(sb))
1445 : bh = sb_bread(sb, tmp_bh.b_blocknr);
1446 : else
1447 : bh = sb_getblk(sb, tmp_bh.b_blocknr);
1448 : if (!bh) {
1449 : err = -EIO;
1450 : goto out;
1451 : }
1452 : lock_buffer(bh);
1453 : memcpy(bh->b_data+offset, data, tocopy);
1454 : flush_dcache_page(bh->b_page);
1455 : set_buffer_uptodate(bh);
1456 : mark_buffer_dirty(bh);
1457 : unlock_buffer(bh);
1458 : brelse(bh);
1459 : offset = 0;
1460 : towrite -= tocopy;
1461 : data += tocopy;
1462 : blk++;
1463 : }
1464 : out:
1465 : if (len == towrite) {
1466 : mutex_unlock(&inode->i_mutex);
1467 : return err;
1468 : }
1469 : if (inode->i_size < off+len-towrite)
1470 : i_size_write(inode, off+len-towrite);
1471 : inode->i_version++;
1472 : inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1473 : mark_inode_dirty(inode);
1474 : mutex_unlock(&inode->i_mutex);
1475 : return len - towrite;
1476 : }
1477 :
1478 : #endif
1479 :
1480 1 : static struct file_system_type ext2_fs_type = {
1481 : .owner = THIS_MODULE,
1482 : .name = "ext2",
1483 : .get_sb = ext2_get_sb,
1484 : .kill_sb = kill_block_super,
1485 : .fs_flags = FS_REQUIRES_DEV,
1486 : };
1487 :
1488 : static int __init init_ext2_fs(void)
1489 : {
1490 4 : int err = init_ext2_xattr();
1491 3 : if (err)
1492 1 : return err;
1493 2 : err = init_inodecache();
1494 2 : if (err)
1495 1 : goto out1;
1496 2 : err = register_filesystem(&ext2_fs_type);
1497 2 : if (err)
1498 1 : goto out;
1499 1 : return 0;
1500 1 : out:
1501 2 : destroy_inodecache();
1502 : out1:
1503 5 : exit_ext2_xattr();
1504 1 : return err;
1505 : }
1506 :
1507 : static void __exit exit_ext2_fs(void)
1508 : {
1509 4 : unregister_filesystem(&ext2_fs_type);
1510 4 : destroy_inodecache();
1511 4 : exit_ext2_xattr();
1512 2 : }
1513 :
1514 : module_init(init_ext2_fs)
1515 : module_exit(exit_ext2_fs)
|