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