projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] slab: fix handling of pages from foreign NUMA nodes
[linux-2.6-block.git] / fs / ext3 / super.c
CommitLineData
1da177e4
LT		 1/*
2 * linux/fs/ext3/super.c
3 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *
9 * from
10 *
11 * linux/fs/minix/inode.c
12 *
13 * Copyright (C) 1991, 1992 Linus Torvalds
14 *
15 * Big-endian to little-endian byte-swapping/bitmaps by
16 * David S. Miller (davem@caip.rutgers.edu), 1995
17 */
18
19#include <linux/config.h>
20#include <linux/module.h>
21#include <linux/string.h>
22#include <linux/fs.h>
23#include <linux/time.h>
24#include <linux/jbd.h>
25#include <linux/ext3_fs.h>
26#include <linux/ext3_jbd.h>
27#include <linux/slab.h>
28#include <linux/init.h>
29#include <linux/blkdev.h>
30#include <linux/parser.h>
31#include <linux/smp_lock.h>
32#include <linux/buffer_head.h>
33#include <linux/vfs.h>
34#include <linux/random.h>
35#include <linux/mount.h>
36#include <linux/namei.h>
37#include <linux/quotaops.h>
8fc2751b 38#include <linux/seq_file.h>
1da177e4
LT		 39#include <asm/uaccess.h>
40#include "xattr.h"
41#include "acl.h"
42
43static int ext3_load_journal(struct super_block *, struct ext3_super_block *);
44static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
45 int);
46static void ext3_commit_super (struct super_block * sb,
47 struct ext3_super_block * es,
48 int sync);
49static void ext3_mark_recovery_complete(struct super_block * sb,
50 struct ext3_super_block * es);
51static void ext3_clear_journal_err(struct super_block * sb,
52 struct ext3_super_block * es);
53static int ext3_sync_fs(struct super_block *sb, int wait);
54static const char *ext3_decode_error(struct super_block * sb, int errno,
55 char nbuf[16]);
56static int ext3_remount (struct super_block * sb, int * flags, char * data);
57static int ext3_statfs (struct super_block * sb, struct kstatfs * buf);
58static void ext3_unlockfs(struct super_block *sb);
59static void ext3_write_super (struct super_block * sb);
60static void ext3_write_super_lockfs(struct super_block *sb);
61
62/*
63 * Wrappers for journal_start/end.
64 *
65 * The only special thing we need to do here is to make sure that all
66 * journal_end calls result in the superblock being marked dirty, so
67 * that sync() will call the filesystem's write_super callback if
68 * appropriate.
69 */
70handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks)
71{
72 journal_t *journal;
73
74 if (sb->s_flags & MS_RDONLY)
75 return ERR_PTR(-EROFS);
76
77 /* Special case here: if the journal has aborted behind our
78 * backs (eg. EIO in the commit thread), then we still need to
79 * take the FS itself readonly cleanly. */
80 journal = EXT3_SB(sb)->s_journal;
81 if (is_journal_aborted(journal)) {
82 ext3_abort(sb, __FUNCTION__,
83 "Detected aborted journal");
84 return ERR_PTR(-EROFS);
85 }
86
87 return journal_start(journal, nblocks);
88}
89
90/*
91 * The only special thing we need to do here is to make sure that all
92 * journal_stop calls result in the superblock being marked dirty, so
93 * that sync() will call the filesystem's write_super callback if
94 * appropriate.
95 */
96int __ext3_journal_stop(const char *where, handle_t *handle)
97{
98 struct super_block *sb;
99 int err;
100 int rc;
101
102 sb = handle->h_transaction->t_journal->j_private;
103 err = handle->h_err;
104 rc = journal_stop(handle);
105
106 if (!err)
107 err = rc;
108 if (err)
109 __ext3_std_error(sb, where, err);
110 return err;
111}
112
113void ext3_journal_abort_handle(const char *caller, const char *err_fn,
114 struct buffer_head *bh, handle_t *handle, int err)
115{
116 char nbuf[16];
117 const char *errstr = ext3_decode_error(NULL, err, nbuf);
118
119 if (bh)
120 BUFFER_TRACE(bh, "abort");
121
122 if (!handle->h_err)
123 handle->h_err = err;
124
125 if (is_handle_aborted(handle))
126 return;
127
128 printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
129 caller, errstr, err_fn);
130
131 journal_abort_handle(handle);
132}
133
134/* Deal with the reporting of failure conditions on a filesystem such as
135 * inconsistencies detected or read IO failures.
136 *
137 * On ext2, we can store the error state of the filesystem in the
138 * superblock. That is not possible on ext3, because we may have other
139 * write ordering constraints on the superblock which prevent us from
140 * writing it out straight away; and given that the journal is about to
141 * be aborted, we can't rely on the current, or future, transactions to
142 * write out the superblock safely.
143 *
144 * We'll just use the journal_abort() error code to record an error in
145 * the journal instead. On recovery, the journal will compain about
146 * that error until we've noted it down and cleared it.
147 */
148
149static void ext3_handle_error(struct super_block *sb)
150{
151 struct ext3_super_block *es = EXT3_SB(sb)->s_es;
152
153 EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
154 es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
155
156 if (sb->s_flags & MS_RDONLY)
157 return;
158
159 if (test_opt (sb, ERRORS_RO)) {
160 printk (KERN_CRIT "Remounting filesystem read-only\n");
161 sb->s_flags |= MS_RDONLY;
162 } else {
163 journal_t *journal = EXT3_SB(sb)->s_journal;
164
165 EXT3_SB(sb)->s_mount_opt |= EXT3_MOUNT_ABORT;
166 if (journal)
167 journal_abort(journal, -EIO);
168 }
169 if (test_opt(sb, ERRORS_PANIC))
170 panic("EXT3-fs (device %s): panic forced after error\n",
171 sb->s_id);
172 ext3_commit_super(sb, es, 1);
173}
174
175void ext3_error (struct super_block * sb, const char * function,
176 const char * fmt, ...)
177{
178 va_list args;
179
180 va_start(args, fmt);
181 printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
182 vprintk(fmt, args);
183 printk("\n");
184 va_end(args);
185
186 ext3_handle_error(sb);
187}
188
189static const char *ext3_decode_error(struct super_block * sb, int errno,
190 char nbuf[16])
191{
192 char *errstr = NULL;
193
194 switch (errno) {
195 case -EIO:
196 errstr = "IO failure";
197 break;
198 case -ENOMEM:
199 errstr = "Out of memory";
200 break;
201 case -EROFS:
202 if (!sb || EXT3_SB(sb)->s_journal->j_flags & JFS_ABORT)
203 errstr = "Journal has aborted";
204 else
205 errstr = "Readonly filesystem";
206 break;
207 default:
208 /* If the caller passed in an extra buffer for unknown
209 * errors, textualise them now. Else we just return
210 * NULL. */
211 if (nbuf) {
212 /* Check for truncated error codes... */
213 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
214 errstr = nbuf;
215 }
216 break;
217 }
218
219 return errstr;
220}
221
222/* __ext3_std_error decodes expected errors from journaling functions
223 * automatically and invokes the appropriate error response. */
224
225void __ext3_std_error (struct super_block * sb, const char * function,
226 int errno)
227{
228 char nbuf[16];
30121624 229 const char *errstr;
1da177e4 230
30121624
ST		 231 /* Special case: if the error is EROFS, and we're not already
232 * inside a transaction, then there's really no point in logging
233 * an error. */
234 if (errno == -EROFS && journal_current_handle() == NULL &&
235 (sb->s_flags & MS_RDONLY))
236 return;
237
238 errstr = ext3_decode_error(sb, errno, nbuf);
1da177e4
LT		 239 printk (KERN_CRIT "EXT3-fs error (device %s) in %s: %s\n",
240 sb->s_id, function, errstr);
241
242 ext3_handle_error(sb);
243}
244
245/*
246 * ext3_abort is a much stronger failure handler than ext3_error. The
247 * abort function may be used to deal with unrecoverable failures such
248 * as journal IO errors or ENOMEM at a critical moment in log management.
249 *
250 * We unconditionally force the filesystem into an ABORT|READONLY state,
251 * unless the error response on the fs has been set to panic in which
252 * case we take the easy way out and panic immediately.
253 */
254
255void ext3_abort (struct super_block * sb, const char * function,
256 const char * fmt, ...)
257{
258 va_list args;
259
260 printk (KERN_CRIT "ext3_abort called.\n");
261
262 va_start(args, fmt);
263 printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
264 vprintk(fmt, args);
265 printk("\n");
266 va_end(args);
267
268 if (test_opt(sb, ERRORS_PANIC))
269 panic("EXT3-fs panic from previous error\n");
270
271 if (sb->s_flags & MS_RDONLY)
272 return;
273
274 printk(KERN_CRIT "Remounting filesystem read-only\n");
275 EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
276 sb->s_flags |= MS_RDONLY;
277 EXT3_SB(sb)->s_mount_opt |= EXT3_MOUNT_ABORT;
278 journal_abort(EXT3_SB(sb)->s_journal, -EIO);
279}
280
281void ext3_warning (struct super_block * sb, const char * function,
282 const char * fmt, ...)
283{
284 va_list args;
285
286 va_start(args, fmt);
287 printk(KERN_WARNING "EXT3-fs warning (device %s): %s: ",
288 sb->s_id, function);
289 vprintk(fmt, args);
290 printk("\n");
291 va_end(args);
292}
293
294void ext3_update_dynamic_rev(struct super_block *sb)
295{
296 struct ext3_super_block *es = EXT3_SB(sb)->s_es;
297
298 if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
299 return;
300
301 ext3_warning(sb, __FUNCTION__,
302 "updating to rev %d because of new feature flag, "
303 "running e2fsck is recommended",
304 EXT3_DYNAMIC_REV);
305
306 es->s_first_ino = cpu_to_le32(EXT3_GOOD_OLD_FIRST_INO);
307 es->s_inode_size = cpu_to_le16(EXT3_GOOD_OLD_INODE_SIZE);
308 es->s_rev_level = cpu_to_le32(EXT3_DYNAMIC_REV);
309 /* leave es->s_feature_*compat flags alone */
310 /* es->s_uuid will be set by e2fsck if empty */
311
312 /*
313 * The rest of the superblock fields should be zero, and if not it
314 * means they are likely already in use, so leave them alone. We
315 * can leave it up to e2fsck to clean up any inconsistencies there.
316 */
317}
318
319/*
320 * Open the external journal device
321 */
322static struct block_device *ext3_blkdev_get(dev_t dev)
323{
324 struct block_device *bdev;
325 char b[BDEVNAME_SIZE];
326
327 bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
328 if (IS_ERR(bdev))
329 goto fail;
330 return bdev;
331
332fail:
333 printk(KERN_ERR "EXT3: failed to open journal device %s: %ld\n",
334 __bdevname(dev, b), PTR_ERR(bdev));
335 return NULL;
336}
337
338/*
339 * Release the journal device
340 */
341static int ext3_blkdev_put(struct block_device *bdev)
342{
343 bd_release(bdev);
344 return blkdev_put(bdev);
345}
346
347static int ext3_blkdev_remove(struct ext3_sb_info *sbi)
348{
349 struct block_device *bdev;
350 int ret = -ENODEV;
351
352 bdev = sbi->journal_bdev;
353 if (bdev) {
354 ret = ext3_blkdev_put(bdev);
355 sbi->journal_bdev = NULL;
356 }
357 return ret;
358}
359
360static inline struct inode *orphan_list_entry(struct list_head *l)
361{
362 return &list_entry(l, struct ext3_inode_info, i_orphan)->vfs_inode;
363}
364
365static void dump_orphan_list(struct super_block *sb, struct ext3_sb_info *sbi)
366{
367 struct list_head *l;
368
369 printk(KERN_ERR "sb orphan head is %d\n",
370 le32_to_cpu(sbi->s_es->s_last_orphan));
371
372 printk(KERN_ERR "sb_info orphan list:\n");
373 list_for_each(l, &sbi->s_orphan) {
374 struct inode *inode = orphan_list_entry(l);
375 printk(KERN_ERR " "
376 "inode %s:%ld at %p: mode %o, nlink %d, next %d\n",
377 inode->i_sb->s_id, inode->i_ino, inode,
378 inode->i_mode, inode->i_nlink,
379 NEXT_ORPHAN(inode));
380 }
381}
382
383static void ext3_put_super (struct super_block * sb)
384{
385 struct ext3_sb_info *sbi = EXT3_SB(sb);
386 struct ext3_super_block *es = sbi->s_es;
387 int i;
388
389 ext3_xattr_put_super(sb);
390 journal_destroy(sbi->s_journal);
391 if (!(sb->s_flags & MS_RDONLY)) {
392 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
393 es->s_state = cpu_to_le16(sbi->s_mount_state);
394 BUFFER_TRACE(sbi->s_sbh, "marking dirty");
395 mark_buffer_dirty(sbi->s_sbh);
396 ext3_commit_super(sb, es, 1);
397 }
398
399 for (i = 0; i < sbi->s_gdb_count; i++)
400 brelse(sbi->s_group_desc[i]);
401 kfree(sbi->s_group_desc);
402 percpu_counter_destroy(&sbi->s_freeblocks_counter);
403 percpu_counter_destroy(&sbi->s_freeinodes_counter);
404 percpu_counter_destroy(&sbi->s_dirs_counter);
405 brelse(sbi->s_sbh);
406#ifdef CONFIG_QUOTA
407 for (i = 0; i < MAXQUOTAS; i++)
408 kfree(sbi->s_qf_names[i]);
409#endif
410
411 /* Debugging code just in case the in-memory inode orphan list
412 * isn't empty. The on-disk one can be non-empty if we've
413 * detected an error and taken the fs readonly, but the
414 * in-memory list had better be clean by this point. */
415 if (!list_empty(&sbi->s_orphan))
416 dump_orphan_list(sb, sbi);
417 J_ASSERT(list_empty(&sbi->s_orphan));
418
419 invalidate_bdev(sb->s_bdev, 0);
420 if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
421 /*
422 * Invalidate the journal device's buffers. We don't want them
423 * floating about in memory - the physical journal device may
424 * hotswapped, and it breaks the `ro-after' testing code.
425 */
426 sync_blockdev(sbi->journal_bdev);
427 invalidate_bdev(sbi->journal_bdev, 0);
428 ext3_blkdev_remove(sbi);
429 }
430 sb->s_fs_info = NULL;
431 kfree(sbi);
432 return;
433}
434
435static kmem_cache_t *ext3_inode_cachep;
436
437/*
438 * Called inside transaction, so use GFP_NOFS
439 */
440static struct inode *ext3_alloc_inode(struct super_block *sb)
441{
442 struct ext3_inode_info *ei;
443
444 ei = kmem_cache_alloc(ext3_inode_cachep, SLAB_NOFS);
445 if (!ei)
446 return NULL;
447#ifdef CONFIG_EXT3_FS_POSIX_ACL
448 ei->i_acl = EXT3_ACL_NOT_CACHED;
449 ei->i_default_acl = EXT3_ACL_NOT_CACHED;
450#endif
451 ei->i_block_alloc_info = NULL;
452 ei->vfs_inode.i_version = 1;
453 return &ei->vfs_inode;
454}
455
456static void ext3_destroy_inode(struct inode *inode)
457{
458 kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
459}
460
461static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
462{
463 struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
464
465 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
466 SLAB_CTOR_CONSTRUCTOR) {
467 INIT_LIST_HEAD(&ei->i_orphan);
468#ifdef CONFIG_EXT3_FS_XATTR
469 init_rwsem(&ei->xattr_sem);
470#endif
471 init_MUTEX(&ei->truncate_sem);
472 inode_init_once(&ei->vfs_inode);
473 }
474}
475
476static int init_inodecache(void)
477{
478 ext3_inode_cachep = kmem_cache_create("ext3_inode_cache",
479 sizeof(struct ext3_inode_info),
480 0, SLAB_RECLAIM_ACCOUNT,
481 init_once, NULL);
482 if (ext3_inode_cachep == NULL)
483 return -ENOMEM;
484 return 0;
485}
486
487static void destroy_inodecache(void)
488{
489 if (kmem_cache_destroy(ext3_inode_cachep))
490 printk(KERN_INFO "ext3_inode_cache: not all structures were freed\n");
491}
492
493static void ext3_clear_inode(struct inode *inode)
494{
495 struct ext3_block_alloc_info *rsv = EXT3_I(inode)->i_block_alloc_info;
496#ifdef CONFIG_EXT3_FS_POSIX_ACL
497 if (EXT3_I(inode)->i_acl &&
498 EXT3_I(inode)->i_acl != EXT3_ACL_NOT_CACHED) {
499 posix_acl_release(EXT3_I(inode)->i_acl);
500 EXT3_I(inode)->i_acl = EXT3_ACL_NOT_CACHED;
501 }
502 if (EXT3_I(inode)->i_default_acl &&
503 EXT3_I(inode)->i_default_acl != EXT3_ACL_NOT_CACHED) {
504 posix_acl_release(EXT3_I(inode)->i_default_acl);
505 EXT3_I(inode)->i_default_acl = EXT3_ACL_NOT_CACHED;
506 }
507#endif
508 ext3_discard_reservation(inode);
509 EXT3_I(inode)->i_block_alloc_info = NULL;
510 kfree(rsv);
511}
512
8fc2751b
MB		 513static int ext3_show_options(struct seq_file *seq, struct vfsmount *vfs)
514{
515 struct ext3_sb_info *sbi = EXT3_SB(vfs->mnt_sb);
516
517 if (sbi->s_mount_opt & EXT3_MOUNT_JOURNAL_DATA)
518 seq_puts(seq, ",data=journal");
519
520 if (sbi->s_mount_opt & EXT3_MOUNT_ORDERED_DATA)
521 seq_puts(seq, ",data=ordered");
522
523 if (sbi->s_mount_opt & EXT3_MOUNT_WRITEBACK_DATA)
524 seq_puts(seq, ",data=writeback");
525
526#if defined(CONFIG_QUOTA)
527 if (sbi->s_jquota_fmt)
528 seq_printf(seq, ",jqfmt=%s",
529 (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
530
531 if (sbi->s_qf_names[USRQUOTA])
532 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
533
534 if (sbi->s_qf_names[GRPQUOTA])
535 seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
536
537 if (sbi->s_mount_opt & EXT3_MOUNT_USRQUOTA)
538 seq_puts(seq, ",usrquota");
539
540 if (sbi->s_mount_opt & EXT3_MOUNT_GRPQUOTA)
541 seq_puts(seq, ",grpquota");
542#endif
543
544 return 0;
545}
1da177e4 546
8fc2751b 547#ifdef CONFIG_QUOTA
1da177e4
LT		 548#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
549#define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
550
551static int ext3_dquot_initialize(struct inode *inode, int type);
552static int ext3_dquot_drop(struct inode *inode);
553static int ext3_write_dquot(struct dquot *dquot);
554static int ext3_acquire_dquot(struct dquot *dquot);
555static int ext3_release_dquot(struct dquot *dquot);
556static int ext3_mark_dquot_dirty(struct dquot *dquot);
557static int ext3_write_info(struct super_block *sb, int type);
558static int ext3_quota_on(struct super_block *sb, int type, int format_id, char *path);
559static int ext3_quota_on_mount(struct super_block *sb, int type);
560static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
561 size_t len, loff_t off);
562static ssize_t ext3_quota_write(struct super_block *sb, int type,
563 const char *data, size_t len, loff_t off);
564
565static struct dquot_operations ext3_quota_operations = {
566 .initialize = ext3_dquot_initialize,
567 .drop = ext3_dquot_drop,
568 .alloc_space = dquot_alloc_space,
569 .alloc_inode = dquot_alloc_inode,
570 .free_space = dquot_free_space,
571 .free_inode = dquot_free_inode,
572 .transfer = dquot_transfer,
573 .write_dquot = ext3_write_dquot,
574 .acquire_dquot = ext3_acquire_dquot,
575 .release_dquot = ext3_release_dquot,
576 .mark_dirty = ext3_mark_dquot_dirty,
577 .write_info = ext3_write_info
578};
579
580static struct quotactl_ops ext3_qctl_operations = {
581 .quota_on = ext3_quota_on,
582 .quota_off = vfs_quota_off,
583 .quota_sync = vfs_quota_sync,
584 .get_info = vfs_get_dqinfo,
585 .set_info = vfs_set_dqinfo,
586 .get_dqblk = vfs_get_dqblk,
587 .set_dqblk = vfs_set_dqblk
588};
589#endif
590
591static struct super_operations ext3_sops = {
592 .alloc_inode = ext3_alloc_inode,
593 .destroy_inode = ext3_destroy_inode,
594 .read_inode = ext3_read_inode,
595 .write_inode = ext3_write_inode,
596 .dirty_inode = ext3_dirty_inode,
597 .delete_inode = ext3_delete_inode,
598 .put_super = ext3_put_super,
599 .write_super = ext3_write_super,
600 .sync_fs = ext3_sync_fs,
601 .write_super_lockfs = ext3_write_super_lockfs,
602 .unlockfs = ext3_unlockfs,
603 .statfs = ext3_statfs,
604 .remount_fs = ext3_remount,
605 .clear_inode = ext3_clear_inode,
8fc2751b 606 .show_options = ext3_show_options,
1da177e4
LT		 607#ifdef CONFIG_QUOTA
608 .quota_read = ext3_quota_read,
609 .quota_write = ext3_quota_write,
610#endif
611};
612
613struct dentry *ext3_get_parent(struct dentry *child);
614static struct export_operations ext3_export_ops = {
615 .get_parent = ext3_get_parent,
616};
617
618enum {
619 Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
620 Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
621 Opt_nouid32, Opt_check, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
622 Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
623 Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh,
624 Opt_commit, Opt_journal_update, Opt_journal_inum,
625 Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
626 Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1f54587b 627 Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
8fc2751b
MB		 628 Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
629 Opt_grpquota
1da177e4
LT		 630};
631
632static match_table_t tokens = {
633 {Opt_bsd_df, "bsddf"},
634 {Opt_minix_df, "minixdf"},
635 {Opt_grpid, "grpid"},
636 {Opt_grpid, "bsdgroups"},
637 {Opt_nogrpid, "nogrpid"},
638 {Opt_nogrpid, "sysvgroups"},
639 {Opt_resgid, "resgid=%u"},
640 {Opt_resuid, "resuid=%u"},
641 {Opt_sb, "sb=%u"},
642 {Opt_err_cont, "errors=continue"},
643 {Opt_err_panic, "errors=panic"},
644 {Opt_err_ro, "errors=remount-ro"},
645 {Opt_nouid32, "nouid32"},
646 {Opt_nocheck, "nocheck"},
647 {Opt_nocheck, "check=none"},
648 {Opt_check, "check"},
649 {Opt_debug, "debug"},
650 {Opt_oldalloc, "oldalloc"},
651 {Opt_orlov, "orlov"},
652 {Opt_user_xattr, "user_xattr"},
653 {Opt_nouser_xattr, "nouser_xattr"},
654 {Opt_acl, "acl"},
655 {Opt_noacl, "noacl"},
656 {Opt_reservation, "reservation"},
657 {Opt_noreservation, "noreservation"},
658 {Opt_noload, "noload"},
659 {Opt_nobh, "nobh"},
660 {Opt_commit, "commit=%u"},
661 {Opt_journal_update, "journal=update"},
662 {Opt_journal_inum, "journal=%u"},
663 {Opt_abort, "abort"},
664 {Opt_data_journal, "data=journal"},
665 {Opt_data_ordered, "data=ordered"},
666 {Opt_data_writeback, "data=writeback"},
667 {Opt_offusrjquota, "usrjquota="},
668 {Opt_usrjquota, "usrjquota=%s"},
669 {Opt_offgrpjquota, "grpjquota="},
670 {Opt_grpjquota, "grpjquota=%s"},
671 {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
672 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
8fc2751b 673 {Opt_grpquota, "grpquota"},
1f54587b
JK		 674 {Opt_noquota, "noquota"},
675 {Opt_quota, "quota"},
8fc2751b 676 {Opt_usrquota, "usrquota"},
1da177e4
LT		 677 {Opt_barrier, "barrier=%u"},
678 {Opt_err, NULL},
679 {Opt_resize, "resize"},
680};
681
682static unsigned long get_sb_block(void **data)
683{
684 unsigned long sb_block;
685 char *options = (char *) *data;
686
687 if (!options || strncmp(options, "sb=", 3) != 0)
688 return 1; /* Default location */
689 options += 3;
690 sb_block = simple_strtoul(options, &options, 0);
691 if (*options && *options != ',') {
692 printk("EXT3-fs: Invalid sb specification: %s\n",
693 (char *) *data);
694 return 1;
695 }
696 if (*options == ',')
697 options++;
698 *data = (void *) options;
699 return sb_block;
700}
701
702static int parse_options (char * options, struct super_block *sb,
703 unsigned long * inum, unsigned long *n_blocks_count, int is_remount)
704{
705 struct ext3_sb_info *sbi = EXT3_SB(sb);
706 char * p;
707 substring_t args[MAX_OPT_ARGS];
708 int data_opt = 0;
709 int option;
710#ifdef CONFIG_QUOTA
711 int qtype;
712 char *qname;
713#endif
714
715 if (!options)
716 return 1;
717
718 while ((p = strsep (&options, ",")) != NULL) {
719 int token;
720 if (!*p)
721 continue;
722
723 token = match_token(p, tokens, args);
724 switch (token) {
725 case Opt_bsd_df:
726 clear_opt (sbi->s_mount_opt, MINIX_DF);
727 break;
728 case Opt_minix_df:
729 set_opt (sbi->s_mount_opt, MINIX_DF);
730 break;
731 case Opt_grpid:
732 set_opt (sbi->s_mount_opt, GRPID);
733 break;
734 case Opt_nogrpid:
735 clear_opt (sbi->s_mount_opt, GRPID);
736 break;
737 case Opt_resuid:
738 if (match_int(&args[0], &option))
739 return 0;
740 sbi->s_resuid = option;
741 break;
742 case Opt_resgid:
743 if (match_int(&args[0], &option))
744 return 0;
745 sbi->s_resgid = option;
746 break;
747 case Opt_sb:
748 /* handled by get_sb_block() instead of here */
749 /* *sb_block = match_int(&args[0]); */
750 break;
751 case Opt_err_panic:
752 clear_opt (sbi->s_mount_opt, ERRORS_CONT);
753 clear_opt (sbi->s_mount_opt, ERRORS_RO);
754 set_opt (sbi->s_mount_opt, ERRORS_PANIC);
755 break;
756 case Opt_err_ro:
757 clear_opt (sbi->s_mount_opt, ERRORS_CONT);
758 clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
759 set_opt (sbi->s_mount_opt, ERRORS_RO);
760 break;
761 case Opt_err_cont:
762 clear_opt (sbi->s_mount_opt, ERRORS_RO);
763 clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
764 set_opt (sbi->s_mount_opt, ERRORS_CONT);
765 break;
766 case Opt_nouid32:
767 set_opt (sbi->s_mount_opt, NO_UID32);
768 break;
769 case Opt_check:
770#ifdef CONFIG_EXT3_CHECK
771 set_opt (sbi->s_mount_opt, CHECK);
772#else
773 printk(KERN_ERR
774 "EXT3 Check option not supported\n");
775#endif
776 break;
777 case Opt_nocheck:
778 clear_opt (sbi->s_mount_opt, CHECK);
779 break;
780 case Opt_debug:
781 set_opt (sbi->s_mount_opt, DEBUG);
782 break;
783 case Opt_oldalloc:
784 set_opt (sbi->s_mount_opt, OLDALLOC);
785 break;
786 case Opt_orlov:
787 clear_opt (sbi->s_mount_opt, OLDALLOC);
788 break;
789#ifdef CONFIG_EXT3_FS_XATTR
790 case Opt_user_xattr:
791 set_opt (sbi->s_mount_opt, XATTR_USER);
792 break;
793 case Opt_nouser_xattr:
794 clear_opt (sbi->s_mount_opt, XATTR_USER);
795 break;
796#else
797 case Opt_user_xattr:
798 case Opt_nouser_xattr:
799 printk("EXT3 (no)user_xattr options not supported\n");
800 break;
801#endif
802#ifdef CONFIG_EXT3_FS_POSIX_ACL
803 case Opt_acl:
804 set_opt(sbi->s_mount_opt, POSIX_ACL);
805 break;
806 case Opt_noacl:
807 clear_opt(sbi->s_mount_opt, POSIX_ACL);
808 break;
809#else
810 case Opt_acl:
811 case Opt_noacl:
812 printk("EXT3 (no)acl options not supported\n");
813 break;
814#endif
815 case Opt_reservation:
816 set_opt(sbi->s_mount_opt, RESERVATION);
817 break;
818 case Opt_noreservation:
819 clear_opt(sbi->s_mount_opt, RESERVATION);
820 break;
821 case Opt_journal_update:
822 /* @@@ FIXME */
823 /* Eventually we will want to be able to create
824 a journal file here. For now, only allow the
825 user to specify an existing inode to be the
826 journal file. */
827 if (is_remount) {
828 printk(KERN_ERR "EXT3-fs: cannot specify "
829 "journal on remount\n");
830 return 0;
831 }
832 set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
833 break;
834 case Opt_journal_inum:
835 if (is_remount) {
836 printk(KERN_ERR "EXT3-fs: cannot specify "
837 "journal on remount\n");
838 return 0;
839 }
840 if (match_int(&args[0], &option))
841 return 0;
842 *inum = option;
843 break;
844 case Opt_noload:
845 set_opt (sbi->s_mount_opt, NOLOAD);
846 break;
847 case Opt_commit:
848 if (match_int(&args[0], &option))
849 return 0;
850 if (option < 0)
851 return 0;
852 if (option == 0)
853 option = JBD_DEFAULT_MAX_COMMIT_AGE;
854 sbi->s_commit_interval = HZ * option;
855 break;
856 case Opt_data_journal:
857 data_opt = EXT3_MOUNT_JOURNAL_DATA;
858 goto datacheck;
859 case Opt_data_ordered:
860 data_opt = EXT3_MOUNT_ORDERED_DATA;
861 goto datacheck;
862 case Opt_data_writeback:
863 data_opt = EXT3_MOUNT_WRITEBACK_DATA;
864 datacheck:
865 if (is_remount) {
866 if ((sbi->s_mount_opt & EXT3_MOUNT_DATA_FLAGS)
867 != data_opt) {
868 printk(KERN_ERR
869 "EXT3-fs: cannot change data "
870 "mode on remount\n");
871 return 0;
872 }
873 } else {
874 sbi->s_mount_opt &= ~EXT3_MOUNT_DATA_FLAGS;
875 sbi->s_mount_opt |= data_opt;
876 }
877 break;
878#ifdef CONFIG_QUOTA
879 case Opt_usrjquota:
880 qtype = USRQUOTA;
881 goto set_qf_name;
882 case Opt_grpjquota:
883 qtype = GRPQUOTA;
884set_qf_name:
885 if (sb_any_quota_enabled(sb)) {
886 printk(KERN_ERR
887 "EXT3-fs: Cannot change journalled "
888 "quota options when quota turned on.\n");
889 return 0;
890 }
891 qname = match_strdup(&args[0]);
892 if (!qname) {
893 printk(KERN_ERR
894 "EXT3-fs: not enough memory for "
895 "storing quotafile name.\n");
896 return 0;
897 }
898 if (sbi->s_qf_names[qtype] &&
899 strcmp(sbi->s_qf_names[qtype], qname)) {
900 printk(KERN_ERR
901 "EXT3-fs: %s quota file already "
902 "specified.\n", QTYPE2NAME(qtype));
903 kfree(qname);
904 return 0;
905 }
906 sbi->s_qf_names[qtype] = qname;
907 if (strchr(sbi->s_qf_names[qtype], '/')) {
908 printk(KERN_ERR
909 "EXT3-fs: quotafile must be on "
910 "filesystem root.\n");
911 kfree(sbi->s_qf_names[qtype]);
912 sbi->s_qf_names[qtype] = NULL;
913 return 0;
914 }
1f54587b 915 set_opt(sbi->s_mount_opt, QUOTA);
1da177e4
LT		 916 break;
917 case Opt_offusrjquota:
918 qtype = USRQUOTA;
919 goto clear_qf_name;
920 case Opt_offgrpjquota:
921 qtype = GRPQUOTA;
922clear_qf_name:
923 if (sb_any_quota_enabled(sb)) {
924 printk(KERN_ERR "EXT3-fs: Cannot change "
925 "journalled quota options when "
926 "quota turned on.\n");
927 return 0;
928 }
08c6a96f
JK		 929 /*
930 * The space will be released later when all options
931 * are confirmed to be correct
932 */
1da177e4
LT		 933 sbi->s_qf_names[qtype] = NULL;
934 break;
935 case Opt_jqfmt_vfsold:
936 sbi->s_jquota_fmt = QFMT_VFS_OLD;
937 break;
938 case Opt_jqfmt_vfsv0:
939 sbi->s_jquota_fmt = QFMT_VFS_V0;
940 break;
1f54587b 941 case Opt_quota:
8fc2751b
MB		 942 case Opt_usrquota:
943 set_opt(sbi->s_mount_opt, QUOTA);
944 set_opt(sbi->s_mount_opt, USRQUOTA);
945 break;
946 case Opt_grpquota:
1f54587b 947 set_opt(sbi->s_mount_opt, QUOTA);
8fc2751b 948 set_opt(sbi->s_mount_opt, GRPQUOTA);
1f54587b
JK		 949 break;
950 case Opt_noquota:
951 if (sb_any_quota_enabled(sb)) {
952 printk(KERN_ERR "EXT3-fs: Cannot change quota "
953 "options when quota turned on.\n");
954 return 0;
955 }
956 clear_opt(sbi->s_mount_opt, QUOTA);
8fc2751b
MB		 957 clear_opt(sbi->s_mount_opt, USRQUOTA);
958 clear_opt(sbi->s_mount_opt, GRPQUOTA);
1f54587b 959 break;
1da177e4 960#else
8fc2751b
MB		 961 case Opt_quota:
962 case Opt_usrquota:
963 case Opt_grpquota:
1da177e4
LT		 964 case Opt_usrjquota:
965 case Opt_grpjquota:
966 case Opt_offusrjquota:
967 case Opt_offgrpjquota:
968 case Opt_jqfmt_vfsold:
969 case Opt_jqfmt_vfsv0:
970 printk(KERN_ERR
971 "EXT3-fs: journalled quota options not "
972 "supported.\n");
973 break;
1f54587b
JK		 974 case Opt_noquota:
975 break;
1da177e4
LT		 976#endif
977 case Opt_abort:
978 set_opt(sbi->s_mount_opt, ABORT);
979 break;
980 case Opt_barrier:
981 if (match_int(&args[0], &option))
982 return 0;
983 if (option)
984 set_opt(sbi->s_mount_opt, BARRIER);
985 else
986 clear_opt(sbi->s_mount_opt, BARRIER);
987 break;
988 case Opt_ignore:
989 break;
990 case Opt_resize:
08c6a96f 991 if (!is_remount) {
1da177e4
LT		 992 printk("EXT3-fs: resize option only available "
993 "for remount\n");
994 return 0;
995 }
c7f1721e
KZ		 996 if (match_int(&args[0], &option) != 0)
997 return 0;
1da177e4
LT		 998 *n_blocks_count = option;
999 break;
1000 case Opt_nobh:
1001 set_opt(sbi->s_mount_opt, NOBH);
1002 break;
1003 default:
1004 printk (KERN_ERR
1005 "EXT3-fs: Unrecognized mount option \"%s\" "
1006 "or missing value\n", p);
1007 return 0;
1008 }
1009 }
1010#ifdef CONFIG_QUOTA
8fc2751b
MB		 1011 if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
1012 if ((sbi->s_mount_opt & EXT3_MOUNT_USRQUOTA) &&
1013 sbi->s_qf_names[USRQUOTA])
1014 clear_opt(sbi->s_mount_opt, USRQUOTA);
1015
1016 if ((sbi->s_mount_opt & EXT3_MOUNT_GRPQUOTA) &&
1017 sbi->s_qf_names[GRPQUOTA])
1018 clear_opt(sbi->s_mount_opt, GRPQUOTA);
1019
1020 if ((sbi->s_qf_names[USRQUOTA] &&
1021 (sbi->s_mount_opt & EXT3_MOUNT_GRPQUOTA)) ||
1022 (sbi->s_qf_names[GRPQUOTA] &&
1023 (sbi->s_mount_opt & EXT3_MOUNT_USRQUOTA))) {
1024 printk(KERN_ERR "EXT3-fs: old and new quota "
1025 "format mixing.\n");
1026 return 0;
1027 }
1028
1029 if (!sbi->s_jquota_fmt) {
1030 printk(KERN_ERR "EXT3-fs: journalled quota format "
1031 "not specified.\n");
1032 return 0;
1033 }
1034 } else {
1035 if (sbi->s_jquota_fmt) {
1036 printk(KERN_ERR "EXT3-fs: journalled quota format "
1037 "specified with no journalling "
1038 "enabled.\n");
1039 return 0;
1040 }
1da177e4
LT		 1041 }
1042#endif
1da177e4
LT		 1043 return 1;
1044}
1045
1046static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
1047 int read_only)
1048{
1049 struct ext3_sb_info *sbi = EXT3_SB(sb);
1050 int res = 0;
1051
1052 if (le32_to_cpu(es->s_rev_level) > EXT3_MAX_SUPP_REV) {
1053 printk (KERN_ERR "EXT3-fs warning: revision level too high, "
1054 "forcing read-only mode\n");
1055 res = MS_RDONLY;
1056 }
1057 if (read_only)
1058 return res;
1059 if (!(sbi->s_mount_state & EXT3_VALID_FS))
1060 printk (KERN_WARNING "EXT3-fs warning: mounting unchecked fs, "
1061 "running e2fsck is recommended\n");
1062 else if ((sbi->s_mount_state & EXT3_ERROR_FS))
1063 printk (KERN_WARNING
1064 "EXT3-fs warning: mounting fs with errors, "
1065 "running e2fsck is recommended\n");
1066 else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
1067 le16_to_cpu(es->s_mnt_count) >=
1068 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
1069 printk (KERN_WARNING
1070 "EXT3-fs warning: maximal mount count reached, "
1071 "running e2fsck is recommended\n");
1072 else if (le32_to_cpu(es->s_checkinterval) &&
1073 (le32_to_cpu(es->s_lastcheck) +
1074 le32_to_cpu(es->s_checkinterval) <= get_seconds()))
1075 printk (KERN_WARNING
1076 "EXT3-fs warning: checktime reached, "
1077 "running e2fsck is recommended\n");
1078#if 0
1079 /* @@@ We _will_ want to clear the valid bit if we find
1080 inconsistencies, to force a fsck at reboot. But for
1081 a plain journaled filesystem we can keep it set as
1082 valid forever! :) */
1083 es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) & ~EXT3_VALID_FS);
1084#endif
1085 if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
1086 es->s_max_mnt_count = cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
1087 es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
1088 es->s_mtime = cpu_to_le32(get_seconds());
1089 ext3_update_dynamic_rev(sb);
1090 EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
1091
1092 ext3_commit_super(sb, es, 1);
1093 if (test_opt(sb, DEBUG))
1094 printk(KERN_INFO "[EXT3 FS bs=%lu, gc=%lu, "
1095 "bpg=%lu, ipg=%lu, mo=%04lx]\n",
1096 sb->s_blocksize,
1097 sbi->s_groups_count,
1098 EXT3_BLOCKS_PER_GROUP(sb),
1099 EXT3_INODES_PER_GROUP(sb),
1100 sbi->s_mount_opt);
1101
1102 printk(KERN_INFO "EXT3 FS on %s, ", sb->s_id);
1103 if (EXT3_SB(sb)->s_journal->j_inode == NULL) {
1104 char b[BDEVNAME_SIZE];
1105
1106 printk("external journal on %s\n",
1107 bdevname(EXT3_SB(sb)->s_journal->j_dev, b));
1108 } else {
1109 printk("internal journal\n");
1110 }
1111#ifdef CONFIG_EXT3_CHECK
1112 if (test_opt (sb, CHECK)) {
1113 ext3_check_blocks_bitmap (sb);
1114 ext3_check_inodes_bitmap (sb);
1115 }
1116#endif
1117 return res;
1118}
1119
1120/* Called at mount-time, super-block is locked */
1121static int ext3_check_descriptors (struct super_block * sb)
1122{
1123 struct ext3_sb_info *sbi = EXT3_SB(sb);
1124 unsigned long block = le32_to_cpu(sbi->s_es->s_first_data_block);
1125 struct ext3_group_desc * gdp = NULL;
1126 int desc_block = 0;
1127 int i;
1128
1129 ext3_debug ("Checking group descriptors");
1130
1131 for (i = 0; i < sbi->s_groups_count; i++)
1132 {
1133 if ((i % EXT3_DESC_PER_BLOCK(sb)) == 0)
1134 gdp = (struct ext3_group_desc *)
1135 sbi->s_group_desc[desc_block++]->b_data;
1136 if (le32_to_cpu(gdp->bg_block_bitmap) < block ||
1137 le32_to_cpu(gdp->bg_block_bitmap) >=
1138 block + EXT3_BLOCKS_PER_GROUP(sb))
1139 {
1140 ext3_error (sb, "ext3_check_descriptors",
1141 "Block bitmap for group %d"
1142 " not in group (block %lu)!",
1143 i, (unsigned long)
1144 le32_to_cpu(gdp->bg_block_bitmap));
1145 return 0;
1146 }
1147 if (le32_to_cpu(gdp->bg_inode_bitmap) < block ||
1148 le32_to_cpu(gdp->bg_inode_bitmap) >=
1149 block + EXT3_BLOCKS_PER_GROUP(sb))
1150 {
1151 ext3_error (sb, "ext3_check_descriptors",
1152 "Inode bitmap for group %d"
1153 " not in group (block %lu)!",
1154 i, (unsigned long)
1155 le32_to_cpu(gdp->bg_inode_bitmap));
1156 return 0;
1157 }
1158 if (le32_to_cpu(gdp->bg_inode_table) < block ||
1159 le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >=
1160 block + EXT3_BLOCKS_PER_GROUP(sb))
1161 {
1162 ext3_error (sb, "ext3_check_descriptors",
1163 "Inode table for group %d"
1164 " not in group (block %lu)!",
1165 i, (unsigned long)
1166 le32_to_cpu(gdp->bg_inode_table));
1167 return 0;
1168 }
1169 block += EXT3_BLOCKS_PER_GROUP(sb);
1170 gdp++;
1171 }
1172
1173 sbi->s_es->s_free_blocks_count=cpu_to_le32(ext3_count_free_blocks(sb));
1174 sbi->s_es->s_free_inodes_count=cpu_to_le32(ext3_count_free_inodes(sb));
1175 return 1;
1176}
1177
1178
1179/* ext3_orphan_cleanup() walks a singly-linked list of inodes (starting at
1180 * the superblock) which were deleted from all directories, but held open by
1181 * a process at the time of a crash. We walk the list and try to delete these
1182 * inodes at recovery time (only with a read-write filesystem).
1183 *
1184 * In order to keep the orphan inode chain consistent during traversal (in
1185 * case of crash during recovery), we link each inode into the superblock
1186 * orphan list_head and handle it the same way as an inode deletion during
1187 * normal operation (which journals the operations for us).
1188 *
1189 * We only do an iget() and an iput() on each inode, which is very safe if we
1190 * accidentally point at an in-use or already deleted inode. The worst that
1191 * can happen in this case is that we get a "bit already cleared" message from
1192 * ext3_free_inode(). The only reason we would point at a wrong inode is if
1193 * e2fsck was run on this filesystem, and it must have already done the orphan
1194 * inode cleanup for us, so we can safely abort without any further action.
1195 */
1196static void ext3_orphan_cleanup (struct super_block * sb,
1197 struct ext3_super_block * es)
1198{
1199 unsigned int s_flags = sb->s_flags;
1200 int nr_orphans = 0, nr_truncates = 0;
1201#ifdef CONFIG_QUOTA
1202 int i;
1203#endif
1204 if (!es->s_last_orphan) {
1205 jbd_debug(4, "no orphan inodes to clean up\n");
1206 return;
1207 }
1208
1209 if (EXT3_SB(sb)->s_mount_state & EXT3_ERROR_FS) {
1210 if (es->s_last_orphan)
1211 jbd_debug(1, "Errors on filesystem, "
1212 "clearing orphan list.\n");
1213 es->s_last_orphan = 0;
1214 jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
1215 return;
1216 }
1217
1218 if (s_flags & MS_RDONLY) {
1219 printk(KERN_INFO "EXT3-fs: %s: orphan cleanup on readonly fs\n",
1220 sb->s_id);
1221 sb->s_flags &= ~MS_RDONLY;
1222 }
1223#ifdef CONFIG_QUOTA
1224 /* Needed for iput() to work correctly and not trash data */
1225 sb->s_flags |= MS_ACTIVE;
1226 /* Turn on quotas so that they are updated correctly */
1227 for (i = 0; i < MAXQUOTAS; i++) {
1228 if (EXT3_SB(sb)->s_qf_names[i]) {
1229 int ret = ext3_quota_on_mount(sb, i);
1230 if (ret < 0)
1231 printk(KERN_ERR
1232 "EXT3-fs: Cannot turn on journalled "
1233 "quota: error %d\n", ret);
1234 }
1235 }
1236#endif
1237
1238 while (es->s_last_orphan) {
1239 struct inode *inode;
1240
1241 if (!(inode =
1242 ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
1243 es->s_last_orphan = 0;
1244 break;
1245 }
1246
1247 list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
1248 DQUOT_INIT(inode);
1249 if (inode->i_nlink) {
1250 printk(KERN_DEBUG
1251 "%s: truncating inode %ld to %Ld bytes\n",
1252 __FUNCTION__, inode->i_ino, inode->i_size);
1253 jbd_debug(2, "truncating inode %ld to %Ld bytes\n",
1254 inode->i_ino, inode->i_size);
1255 ext3_truncate(inode);
1256 nr_truncates++;
1257 } else {
1258 printk(KERN_DEBUG
1259 "%s: deleting unreferenced inode %ld\n",
1260 __FUNCTION__, inode->i_ino);
1261 jbd_debug(2, "deleting unreferenced inode %ld\n",
1262 inode->i_ino);
1263 nr_orphans++;
1264 }
1265 iput(inode); /* The delete magic happens here! */
1266 }
1267
1268#define PLURAL(x) (x), ((x)==1) ? "" : "s"
1269
1270 if (nr_orphans)
1271 printk(KERN_INFO "EXT3-fs: %s: %d orphan inode%s deleted\n",
1272 sb->s_id, PLURAL(nr_orphans));
1273 if (nr_truncates)
1274 printk(KERN_INFO "EXT3-fs: %s: %d truncate%s cleaned up\n",
1275 sb->s_id, PLURAL(nr_truncates));
1276#ifdef CONFIG_QUOTA
1277 /* Turn quotas off */
1278 for (i = 0; i < MAXQUOTAS; i++) {
1279 if (sb_dqopt(sb)->files[i])
1280 vfs_quota_off(sb, i);
1281 }
1282#endif
1283 sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1284}
1285
1286#define log2(n) ffz(~(n))
1287
1288/*
1289 * Maximal file size. There is a direct, and {,double-,triple-}indirect
1290 * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
1291 * We need to be 1 filesystem block less than the 2^32 sector limit.
1292 */
1293static loff_t ext3_max_size(int bits)
1294{
1295 loff_t res = EXT3_NDIR_BLOCKS;
1296 /* This constant is calculated to be the largest file size for a
1297 * dense, 4k-blocksize file such that the total number of
1298 * sectors in the file, including data and all indirect blocks,
1299 * does not exceed 2^32. */
1300 const loff_t upper_limit = 0x1ff7fffd000LL;
1301
1302 res += 1LL << (bits-2);
1303 res += 1LL << (2*(bits-2));
1304 res += 1LL << (3*(bits-2));
1305 res <<= bits;
1306 if (res > upper_limit)
1307 res = upper_limit;
1308 return res;
1309}
1310
1311static unsigned long descriptor_loc(struct super_block *sb,
1312 unsigned long logic_sb_block,
1313 int nr)
1314{
1315 struct ext3_sb_info *sbi = EXT3_SB(sb);
1316 unsigned long bg, first_data_block, first_meta_bg;
1317 int has_super = 0;
1318
1319 first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
1320 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
1321
1322 if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
1323 nr < first_meta_bg)
1324 return (logic_sb_block + nr + 1);
1325 bg = sbi->s_desc_per_block * nr;
1326 if (ext3_bg_has_super(sb, bg))
1327 has_super = 1;
1328 return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
1329}
1330
1331
1332static int ext3_fill_super (struct super_block *sb, void *data, int silent)
1333{
1334 struct buffer_head * bh;
1335 struct ext3_super_block *es = NULL;
1336 struct ext3_sb_info *sbi;
1337 unsigned long block;
1338 unsigned long sb_block = get_sb_block(&data);
1339 unsigned long logic_sb_block;
1340 unsigned long offset = 0;
1341 unsigned long journal_inum = 0;
1342 unsigned long def_mount_opts;
1343 struct inode *root;
1344 int blocksize;
1345 int hblock;
1346 int db_count;
1347 int i;
1348 int needs_recovery;
1349 __le32 features;
1350
1351 sbi = kmalloc(sizeof(*sbi), GFP_KERNEL);
1352 if (!sbi)
1353 return -ENOMEM;
1354 sb->s_fs_info = sbi;
1355 memset(sbi, 0, sizeof(*sbi));
1356 sbi->s_mount_opt = 0;
1357 sbi->s_resuid = EXT3_DEF_RESUID;
1358 sbi->s_resgid = EXT3_DEF_RESGID;
1359
1360 unlock_kernel();
1361
1362 blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
1363 if (!blocksize) {
1364 printk(KERN_ERR "EXT3-fs: unable to set blocksize\n");
1365 goto out_fail;
1366 }
1367
1368 /*
1369 * The ext3 superblock will not be buffer aligned for other than 1kB
1370 * block sizes. We need to calculate the offset from buffer start.
1371 */
1372 if (blocksize != EXT3_MIN_BLOCK_SIZE) {
1373 logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
1374 offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
1375 } else {
1376 logic_sb_block = sb_block;
1377 }
1378
1379 if (!(bh = sb_bread(sb, logic_sb_block))) {
1380 printk (KERN_ERR "EXT3-fs: unable to read superblock\n");
1381 goto out_fail;
1382 }
1383 /*
1384 * Note: s_es must be initialized as soon as possible because
1385 * some ext3 macro-instructions depend on its value
1386 */
1387 es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
1388 sbi->s_es = es;
1389 sb->s_magic = le16_to_cpu(es->s_magic);
1390 if (sb->s_magic != EXT3_SUPER_MAGIC)
1391 goto cantfind_ext3;
1392
1393 /* Set defaults before we parse the mount options */
1394 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
1395 if (def_mount_opts & EXT3_DEFM_DEBUG)
1396 set_opt(sbi->s_mount_opt, DEBUG);
1397 if (def_mount_opts & EXT3_DEFM_BSDGROUPS)
1398 set_opt(sbi->s_mount_opt, GRPID);
1399 if (def_mount_opts & EXT3_DEFM_UID16)
1400 set_opt(sbi->s_mount_opt, NO_UID32);
1401 if (def_mount_opts & EXT3_DEFM_XATTR_USER)
1402 set_opt(sbi->s_mount_opt, XATTR_USER);
1403 if (def_mount_opts & EXT3_DEFM_ACL)
1404 set_opt(sbi->s_mount_opt, POSIX_ACL);
1405 if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_DATA)
1406 sbi->s_mount_opt |= EXT3_MOUNT_JOURNAL_DATA;
1407 else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_ORDERED)
1408 sbi->s_mount_opt |= EXT3_MOUNT_ORDERED_DATA;
1409 else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_WBACK)
1410 sbi->s_mount_opt |= EXT3_MOUNT_WRITEBACK_DATA;
1411
1412 if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_PANIC)
1413 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
1414 else if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_RO)
1415 set_opt(sbi->s_mount_opt, ERRORS_RO);
1416
1417 sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
1418 sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
1419
1420 set_opt(sbi->s_mount_opt, RESERVATION);
1421
1422 if (!parse_options ((char *) data, sb, &journal_inum, NULL, 0))
1423 goto failed_mount;
1424
1425 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1426 ((sbi->s_mount_opt & EXT3_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1427
1428 if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV &&
1429 (EXT3_HAS_COMPAT_FEATURE(sb, ~0U) ||
1430 EXT3_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
1431 EXT3_HAS_INCOMPAT_FEATURE(sb, ~0U)))
1432 printk(KERN_WARNING
1433 "EXT3-fs warning: feature flags set on rev 0 fs, "
1434 "running e2fsck is recommended\n");
1435 /*
1436 * Check feature flags regardless of the revision level, since we
1437 * previously didn't change the revision level when setting the flags,
1438 * so there is a chance incompat flags are set on a rev 0 filesystem.
1439 */
1440 features = EXT3_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP);
1441 if (features) {
1442 printk(KERN_ERR "EXT3-fs: %s: couldn't mount because of "
1443 "unsupported optional features (%x).\n",
1444 sb->s_id, le32_to_cpu(features));
1445 goto failed_mount;
1446 }
1447 features = EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP);
1448 if (!(sb->s_flags & MS_RDONLY) && features) {
1449 printk(KERN_ERR "EXT3-fs: %s: couldn't mount RDWR because of "
1450 "unsupported optional features (%x).\n",
1451 sb->s_id, le32_to_cpu(features));
1452 goto failed_mount;
1453 }
1454 blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
1455
1456 if (blocksize < EXT3_MIN_BLOCK_SIZE ||
1457 blocksize > EXT3_MAX_BLOCK_SIZE) {
1458 printk(KERN_ERR
1459 "EXT3-fs: Unsupported filesystem blocksize %d on %s.\n",
1460 blocksize, sb->s_id);
1461 goto failed_mount;
1462 }
1463
1464 hblock = bdev_hardsect_size(sb->s_bdev);
1465 if (sb->s_blocksize != blocksize) {
1466 /*
1467 * Make sure the blocksize for the filesystem is larger
1468 * than the hardware sectorsize for the machine.
1469 */
1470 if (blocksize < hblock) {
1471 printk(KERN_ERR "EXT3-fs: blocksize %d too small for "
1472 "device blocksize %d.\n", blocksize, hblock);
1473 goto failed_mount;
1474 }
1475
1476 brelse (bh);
1477 sb_set_blocksize(sb, blocksize);
1478 logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
1479 offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
1480 bh = sb_bread(sb, logic_sb_block);
1481 if (!bh) {
1482 printk(KERN_ERR
1483 "EXT3-fs: Can't read superblock on 2nd try.\n");
1484 goto failed_mount;
1485 }
1486 es = (struct ext3_super_block *)(((char *)bh->b_data) + offset);
1487 sbi->s_es = es;
1488 if (es->s_magic != cpu_to_le16(EXT3_SUPER_MAGIC)) {
1489 printk (KERN_ERR
1490 "EXT3-fs: Magic mismatch, very weird !\n");
1491 goto failed_mount;
1492 }
1493 }
1494
1495 sb->s_maxbytes = ext3_max_size(sb->s_blocksize_bits);
1496
1497 if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV) {
1498 sbi->s_inode_size = EXT3_GOOD_OLD_INODE_SIZE;
1499 sbi->s_first_ino = EXT3_GOOD_OLD_FIRST_INO;
1500 } else {
1501 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
1502 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
1503 if ((sbi->s_inode_size < EXT3_GOOD_OLD_INODE_SIZE) ||
1504 (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
1505 (sbi->s_inode_size > blocksize)) {
1506 printk (KERN_ERR
1507 "EXT3-fs: unsupported inode size: %d\n",
1508 sbi->s_inode_size);
1509 goto failed_mount;
1510 }
1511 }
1512 sbi->s_frag_size = EXT3_MIN_FRAG_SIZE <<
1513 le32_to_cpu(es->s_log_frag_size);
1514 if (blocksize != sbi->s_frag_size) {
1515 printk(KERN_ERR
1516 "EXT3-fs: fragsize %lu != blocksize %u (unsupported)\n",
1517 sbi->s_frag_size, blocksize);
1518 goto failed_mount;
1519 }
1520 sbi->s_frags_per_block = 1;
1521 sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
1522 sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
1523 sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
1524 if (EXT3_INODE_SIZE(sb) == 0)
1525 goto cantfind_ext3;
1526 sbi->s_inodes_per_block = blocksize / EXT3_INODE_SIZE(sb);
1527 if (sbi->s_inodes_per_block == 0)
1528 goto cantfind_ext3;
1529 sbi->s_itb_per_group = sbi->s_inodes_per_group /
1530 sbi->s_inodes_per_block;
1531 sbi->s_desc_per_block = blocksize / sizeof(struct ext3_group_desc);
1532 sbi->s_sbh = bh;
1533 sbi->s_mount_state = le16_to_cpu(es->s_state);
1534 sbi->s_addr_per_block_bits = log2(EXT3_ADDR_PER_BLOCK(sb));
1535 sbi->s_desc_per_block_bits = log2(EXT3_DESC_PER_BLOCK(sb));
1536 for (i=0; i < 4; i++)
1537 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
1538 sbi->s_def_hash_version = es->s_def_hash_version;
1539
1540 if (sbi->s_blocks_per_group > blocksize * 8) {
1541 printk (KERN_ERR
1542 "EXT3-fs: #blocks per group too big: %lu\n",
1543 sbi->s_blocks_per_group);
1544 goto failed_mount;
1545 }
1546 if (sbi->s_frags_per_group > blocksize * 8) {
1547 printk (KERN_ERR
1548 "EXT3-fs: #fragments per group too big: %lu\n",
1549 sbi->s_frags_per_group);
1550 goto failed_mount;
1551 }
1552 if (sbi->s_inodes_per_group > blocksize * 8) {
1553 printk (KERN_ERR
1554 "EXT3-fs: #inodes per group too big: %lu\n",
1555 sbi->s_inodes_per_group);
1556 goto failed_mount;
1557 }
1558
1559 if (EXT3_BLOCKS_PER_GROUP(sb) == 0)
1560 goto cantfind_ext3;
1561 sbi->s_groups_count = (le32_to_cpu(es->s_blocks_count) -
1562 le32_to_cpu(es->s_first_data_block) +
1563 EXT3_BLOCKS_PER_GROUP(sb) - 1) /
1564 EXT3_BLOCKS_PER_GROUP(sb);
1565 db_count = (sbi->s_groups_count + EXT3_DESC_PER_BLOCK(sb) - 1) /
1566 EXT3_DESC_PER_BLOCK(sb);
1567 sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
1568 GFP_KERNEL);
1569 if (sbi->s_group_desc == NULL) {
1570 printk (KERN_ERR "EXT3-fs: not enough memory\n");
1571 goto failed_mount;
1572 }
1573
1574 percpu_counter_init(&sbi->s_freeblocks_counter);
1575 percpu_counter_init(&sbi->s_freeinodes_counter);
1576 percpu_counter_init(&sbi->s_dirs_counter);
1577 bgl_lock_init(&sbi->s_blockgroup_lock);
1578
1579 for (i = 0; i < db_count; i++) {
1580 block = descriptor_loc(sb, logic_sb_block, i);
1581 sbi->s_group_desc[i] = sb_bread(sb, block);
1582 if (!sbi->s_group_desc[i]) {
1583 printk (KERN_ERR "EXT3-fs: "
1584 "can't read group descriptor %d\n", i);
1585 db_count = i;
1586 goto failed_mount2;
1587 }
1588 }
1589 if (!ext3_check_descriptors (sb)) {
1590 printk (KERN_ERR "EXT3-fs: group descriptors corrupted !\n");
1591 goto failed_mount2;
1592 }
1593 sbi->s_gdb_count = db_count;
1594 get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1595 spin_lock_init(&sbi->s_next_gen_lock);
1596 /* per fileystem reservation list head & lock */
1597 spin_lock_init(&sbi->s_rsv_window_lock);
1598 sbi->s_rsv_window_root = RB_ROOT;
1599 /* Add a single, static dummy reservation to the start of the
1600 * reservation window list --- it gives us a placeholder for
1601 * append-at-start-of-list which makes the allocation logic
1602 * _much_ simpler. */
1603 sbi->s_rsv_window_head.rsv_start = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
1604 sbi->s_rsv_window_head.rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
1605 sbi->s_rsv_window_head.rsv_alloc_hit = 0;
1606 sbi->s_rsv_window_head.rsv_goal_size = 0;
1607 ext3_rsv_window_add(sb, &sbi->s_rsv_window_head);
1608
1609 /*
1610 * set up enough so that it can read an inode
1611 */
1612 sb->s_op = &ext3_sops;
1613 sb->s_export_op = &ext3_export_ops;
1614 sb->s_xattr = ext3_xattr_handlers;
1615#ifdef CONFIG_QUOTA
1616 sb->s_qcop = &ext3_qctl_operations;
1617 sb->dq_op = &ext3_quota_operations;
1618#endif
1619 INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
1620
1621 sb->s_root = NULL;
1622
1623 needs_recovery = (es->s_last_orphan != 0 ||
1624 EXT3_HAS_INCOMPAT_FEATURE(sb,
1625 EXT3_FEATURE_INCOMPAT_RECOVER));
1626
1627 /*
1628 * The first inode we look at is the journal inode. Don't try
1629 * root first: it may be modified in the journal!
1630 */
1631 if (!test_opt(sb, NOLOAD) &&
1632 EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
1633 if (ext3_load_journal(sb, es))
1634 goto failed_mount2;
1635 } else if (journal_inum) {
1636 if (ext3_create_journal(sb, es, journal_inum))
1637 goto failed_mount2;
1638 } else {
1639 if (!silent)
1640 printk (KERN_ERR
1641 "ext3: No journal on filesystem on %s\n",
1642 sb->s_id);
1643 goto failed_mount2;
1644 }
1645
1646 /* We have now updated the journal if required, so we can
1647 * validate the data journaling mode. */
1648 switch (test_opt(sb, DATA_FLAGS)) {
1649 case 0:
1650 /* No mode set, assume a default based on the journal
1651 capabilities: ORDERED_DATA if the journal can
1652 cope, else JOURNAL_DATA */
1653 if (journal_check_available_features
1654 (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
1655 set_opt(sbi->s_mount_opt, ORDERED_DATA);
1656 else
1657 set_opt(sbi->s_mount_opt, JOURNAL_DATA);
1658 break;
1659
1660 case EXT3_MOUNT_ORDERED_DATA:
1661 case EXT3_MOUNT_WRITEBACK_DATA:
1662 if (!journal_check_available_features
1663 (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
1664 printk(KERN_ERR "EXT3-fs: Journal does not support "
1665 "requested data journaling mode\n");
1666 goto failed_mount3;
1667 }
1668 default:
1669 break;
1670 }
1671
1672 if (test_opt(sb, NOBH)) {
1673 if (sb->s_blocksize_bits != PAGE_CACHE_SHIFT) {
1674 printk(KERN_WARNING "EXT3-fs: Ignoring nobh option "
1675 "since filesystem blocksize doesn't match "
1676 "pagesize\n");
1677 clear_opt(sbi->s_mount_opt, NOBH);
1678 }
1679 if (!(test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)) {
1680 printk(KERN_WARNING "EXT3-fs: Ignoring nobh option - "
1681 "its supported only with writeback mode\n");
1682 clear_opt(sbi->s_mount_opt, NOBH);
1683 }
1684 }
1685 /*
1686 * The journal_load will have done any necessary log recovery,
1687 * so we can safely mount the rest of the filesystem now.
1688 */
1689
1690 root = iget(sb, EXT3_ROOT_INO);
1691 sb->s_root = d_alloc_root(root);
1692 if (!sb->s_root) {
1693 printk(KERN_ERR "EXT3-fs: get root inode failed\n");
1694 iput(root);
1695 goto failed_mount3;
1696 }
1697 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1698 dput(sb->s_root);
1699 sb->s_root = NULL;
1700 printk(KERN_ERR "EXT3-fs: corrupt root inode, run e2fsck\n");
1701 goto failed_mount3;
1702 }
1703
1704 ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
1705 /*
1706 * akpm: core read_super() calls in here with the superblock locked.
1707 * That deadlocks, because orphan cleanup needs to lock the superblock
1708 * in numerous places. Here we just pop the lock - it's relatively
1709 * harmless, because we are now ready to accept write_super() requests,
1710 * and aviro says that's the only reason for hanging onto the
1711 * superblock lock.
1712 */
1713 EXT3_SB(sb)->s_mount_state |= EXT3_ORPHAN_FS;
1714 ext3_orphan_cleanup(sb, es);
1715 EXT3_SB(sb)->s_mount_state &= ~EXT3_ORPHAN_FS;
1716 if (needs_recovery)
1717 printk (KERN_INFO "EXT3-fs: recovery complete.\n");
1718 ext3_mark_recovery_complete(sb, es);
1719 printk (KERN_INFO "EXT3-fs: mounted filesystem with %s data mode.\n",
1720 test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ? "journal":
1721 test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
1722 "writeback");
1723
1724 percpu_counter_mod(&sbi->s_freeblocks_counter,
1725 ext3_count_free_blocks(sb));
1726 percpu_counter_mod(&sbi->s_freeinodes_counter,
1727 ext3_count_free_inodes(sb));
1728 percpu_counter_mod(&sbi->s_dirs_counter,
1729 ext3_count_dirs(sb));
1730
1731 lock_kernel();
1732 return 0;
1733
1734cantfind_ext3:
1735 if (!silent)
1736 printk(KERN_ERR "VFS: Can't find ext3 filesystem on dev %s.\n",
1737 sb->s_id);
1738 goto failed_mount;
1739
1740failed_mount3:
1741 journal_destroy(sbi->s_journal);
1742failed_mount2:
1743 for (i = 0; i < db_count; i++)
1744 brelse(sbi->s_group_desc[i]);
1745 kfree(sbi->s_group_desc);
1746failed_mount:
1747#ifdef CONFIG_QUOTA
1748 for (i = 0; i < MAXQUOTAS; i++)
1749 kfree(sbi->s_qf_names[i]);
1750#endif
1751 ext3_blkdev_remove(sbi);
1752 brelse(bh);
1753out_fail:
1754 sb->s_fs_info = NULL;
1755 kfree(sbi);
1756 lock_kernel();
1757 return -EINVAL;
1758}
1759
1760/*
1761 * Setup any per-fs journal parameters now. We'll do this both on
1762 * initial mount, once the journal has been initialised but before we've
1763 * done any recovery; and again on any subsequent remount.
1764 */
1765static void ext3_init_journal_params(struct super_block *sb, journal_t *journal)
1766{
1767 struct ext3_sb_info *sbi = EXT3_SB(sb);
1768
1769 if (sbi->s_commit_interval)
1770 journal->j_commit_interval = sbi->s_commit_interval;
1771 /* We could also set up an ext3-specific default for the commit
1772 * interval here, but for now we'll just fall back to the jbd
1773 * default. */
1774
1775 spin_lock(&journal->j_state_lock);
1776 if (test_opt(sb, BARRIER))
1777 journal->j_flags |= JFS_BARRIER;
1778 else
1779 journal->j_flags &= ~JFS_BARRIER;
1780 spin_unlock(&journal->j_state_lock);
1781}
1782
1783static journal_t *ext3_get_journal(struct super_block *sb, int journal_inum)
1784{
1785 struct inode *journal_inode;
1786 journal_t *journal;
1787
1788 /* First, test for the existence of a valid inode on disk. Bad
1789 * things happen if we iget() an unused inode, as the subsequent
1790 * iput() will try to delete it. */
1791
1792 journal_inode = iget(sb, journal_inum);
1793 if (!journal_inode) {
1794 printk(KERN_ERR "EXT3-fs: no journal found.\n");
1795 return NULL;
1796 }
1797 if (!journal_inode->i_nlink) {
1798 make_bad_inode(journal_inode);
1799 iput(journal_inode);
1800 printk(KERN_ERR "EXT3-fs: journal inode is deleted.\n");
1801 return NULL;
1802 }
1803
1804 jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
1805 journal_inode, journal_inode->i_size);
1806 if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
1807 printk(KERN_ERR "EXT3-fs: invalid journal inode.\n");
1808 iput(journal_inode);
1809 return NULL;
1810 }
1811
1812 journal = journal_init_inode(journal_inode);
1813 if (!journal) {
1814 printk(KERN_ERR "EXT3-fs: Could not load journal inode\n");
1815 iput(journal_inode);
1816 return NULL;
1817 }
1818 journal->j_private = sb;
1819 ext3_init_journal_params(sb, journal);
1820 return journal;
1821}
1822
1823static journal_t *ext3_get_dev_journal(struct super_block *sb,
1824 dev_t j_dev)
1825{
1826 struct buffer_head * bh;
1827 journal_t *journal;
1828 int start;
1829 int len;
1830 int hblock, blocksize;
1831 unsigned long sb_block;
1832 unsigned long offset;
1833 struct ext3_super_block * es;
1834 struct block_device *bdev;
1835
1836 bdev = ext3_blkdev_get(j_dev);
1837 if (bdev == NULL)
1838 return NULL;
1839
1840 if (bd_claim(bdev, sb)) {
1841 printk(KERN_ERR
1842 "EXT3: failed to claim external journal device.\n");
1843 blkdev_put(bdev);
1844 return NULL;
1845 }
1846
1847 blocksize = sb->s_blocksize;
1848 hblock = bdev_hardsect_size(bdev);
1849 if (blocksize < hblock) {
1850 printk(KERN_ERR
1851 "EXT3-fs: blocksize too small for journal device.\n");
1852 goto out_bdev;
1853 }
1854
1855 sb_block = EXT3_MIN_BLOCK_SIZE / blocksize;
1856 offset = EXT3_MIN_BLOCK_SIZE % blocksize;
1857 set_blocksize(bdev, blocksize);
1858 if (!(bh = __bread(bdev, sb_block, blocksize))) {
1859 printk(KERN_ERR "EXT3-fs: couldn't read superblock of "
1860 "external journal\n");
1861 goto out_bdev;
1862 }
1863
1864 es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
1865 if ((le16_to_cpu(es->s_magic) != EXT3_SUPER_MAGIC) ||
1866 !(le32_to_cpu(es->s_feature_incompat) &
1867 EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
1868 printk(KERN_ERR "EXT3-fs: external journal has "
1869 "bad superblock\n");
1870 brelse(bh);
1871 goto out_bdev;
1872 }
1873
1874 if (memcmp(EXT3_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
1875 printk(KERN_ERR "EXT3-fs: journal UUID does not match\n");
1876 brelse(bh);
1877 goto out_bdev;
1878 }
1879
1880 len = le32_to_cpu(es->s_blocks_count);
1881 start = sb_block + 1;
1882 brelse(bh); /* we're done with the superblock */
1883
1884 journal = journal_init_dev(bdev, sb->s_bdev,
1885 start, len, blocksize);
1886 if (!journal) {
1887 printk(KERN_ERR "EXT3-fs: failed to create device journal\n");
1888 goto out_bdev;
1889 }
1890 journal->j_private = sb;
1891 ll_rw_block(READ, 1, &journal->j_sb_buffer);
1892 wait_on_buffer(journal->j_sb_buffer);
1893 if (!buffer_uptodate(journal->j_sb_buffer)) {
1894 printk(KERN_ERR "EXT3-fs: I/O error on journal device\n");
1895 goto out_journal;
1896 }
1897 if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
1898 printk(KERN_ERR "EXT3-fs: External journal has more than one "
1899 "user (unsupported) - %d\n",
1900 be32_to_cpu(journal->j_superblock->s_nr_users));
1901 goto out_journal;
1902 }
1903 EXT3_SB(sb)->journal_bdev = bdev;
1904 ext3_init_journal_params(sb, journal);
1905 return journal;
1906out_journal:
1907 journal_destroy(journal);
1908out_bdev:
1909 ext3_blkdev_put(bdev);
1910 return NULL;
1911}
1912
1913static int ext3_load_journal(struct super_block * sb,
1914 struct ext3_super_block * es)
1915{
1916 journal_t *journal;
1917 int journal_inum = le32_to_cpu(es->s_journal_inum);
1918 dev_t journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
1919 int err = 0;
1920 int really_read_only;
1921
1922 really_read_only = bdev_read_only(sb->s_bdev);
1923
1924 /*
1925 * Are we loading a blank journal or performing recovery after a
1926 * crash? For recovery, we need to check in advance whether we
1927 * can get read-write access to the device.
1928 */
1929
1930 if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER)) {
1931 if (sb->s_flags & MS_RDONLY) {
1932 printk(KERN_INFO "EXT3-fs: INFO: recovery "
1933 "required on readonly filesystem.\n");
1934 if (really_read_only) {
1935 printk(KERN_ERR "EXT3-fs: write access "
1936 "unavailable, cannot proceed.\n");
1937 return -EROFS;
1938 }
1939 printk (KERN_INFO "EXT3-fs: write access will "
1940 "be enabled during recovery.\n");
1941 }
1942 }
1943
1944 if (journal_inum && journal_dev) {
1945 printk(KERN_ERR "EXT3-fs: filesystem has both journal "
1946 "and inode journals!\n");
1947 return -EINVAL;
1948 }
1949
1950 if (journal_inum) {
1951 if (!(journal = ext3_get_journal(sb, journal_inum)))
1952 return -EINVAL;
1953 } else {
1954 if (!(journal = ext3_get_dev_journal(sb, journal_dev)))
1955 return -EINVAL;
1956 }
1957
1958 if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
1959 err = journal_update_format(journal);
1960 if (err) {
1961 printk(KERN_ERR "EXT3-fs: error updating journal.\n");
1962 journal_destroy(journal);
1963 return err;
1964 }
1965 }
1966
1967 if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER))
1968 err = journal_wipe(journal, !really_read_only);
1969 if (!err)
1970 err = journal_load(journal);
1971
1972 if (err) {
1973 printk(KERN_ERR "EXT3-fs: error loading journal.\n");
1974 journal_destroy(journal);
1975 return err;
1976 }
1977
1978 EXT3_SB(sb)->s_journal = journal;
1979 ext3_clear_journal_err(sb, es);
1980 return 0;
1981}
1982
1983static int ext3_create_journal(struct super_block * sb,
1984 struct ext3_super_block * es,
1985 int journal_inum)
1986{
1987 journal_t *journal;
1988
1989 if (sb->s_flags & MS_RDONLY) {
1990 printk(KERN_ERR "EXT3-fs: readonly filesystem when trying to "
1991 "create journal.\n");
1992 return -EROFS;
1993 }
1994
1995 if (!(journal = ext3_get_journal(sb, journal_inum)))
1996 return -EINVAL;
1997
1998 printk(KERN_INFO "EXT3-fs: creating new journal on inode %d\n",
1999 journal_inum);
2000
2001 if (journal_create(journal)) {
2002 printk(KERN_ERR "EXT3-fs: error creating journal.\n");
2003 journal_destroy(journal);
2004 return -EIO;
2005 }
2006
2007 EXT3_SB(sb)->s_journal = journal;
2008
2009 ext3_update_dynamic_rev(sb);
2010 EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2011 EXT3_SET_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL);
2012
2013 es->s_journal_inum = cpu_to_le32(journal_inum);
2014 sb->s_dirt = 1;
2015
2016 /* Make sure we flush the recovery flag to disk. */
2017 ext3_commit_super(sb, es, 1);
2018
2019 return 0;
2020}
2021
2022static void ext3_commit_super (struct super_block * sb,
2023 struct ext3_super_block * es,
2024 int sync)
2025{
2026 struct buffer_head *sbh = EXT3_SB(sb)->s_sbh;
2027
2028 if (!sbh)
2029 return;
2030 es->s_wtime = cpu_to_le32(get_seconds());
2031 es->s_free_blocks_count = cpu_to_le32(ext3_count_free_blocks(sb));
2032 es->s_free_inodes_count = cpu_to_le32(ext3_count_free_inodes(sb));
2033 BUFFER_TRACE(sbh, "marking dirty");
2034 mark_buffer_dirty(sbh);
2035 if (sync)
2036 sync_dirty_buffer(sbh);
2037}
2038
2039
2040/*
2041 * Have we just finished recovery? If so, and if we are mounting (or
2042 * remounting) the filesystem readonly, then we will end up with a
2043 * consistent fs on disk. Record that fact.
2044 */
2045static void ext3_mark_recovery_complete(struct super_block * sb,
2046 struct ext3_super_block * es)
2047{
2048 journal_t *journal = EXT3_SB(sb)->s_journal;
2049
2050 journal_lock_updates(journal);
2051 journal_flush(journal);
2052 if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
2053 sb->s_flags & MS_RDONLY) {
2054 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2055 sb->s_dirt = 0;
2056 ext3_commit_super(sb, es, 1);
2057 }
2058 journal_unlock_updates(journal);
2059}
2060
2061/*
2062 * If we are mounting (or read-write remounting) a filesystem whose journal
2063 * has recorded an error from a previous lifetime, move that error to the
2064 * main filesystem now.
2065 */
2066static void ext3_clear_journal_err(struct super_block * sb,
2067 struct ext3_super_block * es)
2068{
2069 journal_t *journal;
2070 int j_errno;
2071 const char *errstr;
2072
2073 journal = EXT3_SB(sb)->s_journal;
2074
2075 /*
2076 * Now check for any error status which may have been recorded in the
2077 * journal by a prior ext3_error() or ext3_abort()
2078 */
2079
2080 j_errno = journal_errno(journal);
2081 if (j_errno) {
2082 char nbuf[16];
2083
2084 errstr = ext3_decode_error(sb, j_errno, nbuf);
2085 ext3_warning(sb, __FUNCTION__, "Filesystem error recorded "
2086 "from previous mount: %s", errstr);
2087 ext3_warning(sb, __FUNCTION__, "Marking fs in need of "
2088 "filesystem check.");
2089
2090 EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
2091 es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
2092 ext3_commit_super (sb, es, 1);
2093
2094 journal_clear_err(journal);
2095 }
2096}
2097
2098/*
2099 * Force the running and committing transactions to commit,
2100 * and wait on the commit.
2101 */
2102int ext3_force_commit(struct super_block *sb)
2103{
2104 journal_t *journal;
2105 int ret;
2106
2107 if (sb->s_flags & MS_RDONLY)
2108 return 0;
2109
2110 journal = EXT3_SB(sb)->s_journal;
2111 sb->s_dirt = 0;
2112 ret = ext3_journal_force_commit(journal);
2113 return ret;
2114}
2115
2116/*
2117 * Ext3 always journals updates to the superblock itself, so we don't
2118 * have to propagate any other updates to the superblock on disk at this
2119 * point. Just start an async writeback to get the buffers on their way
2120 * to the disk.
2121 *
2122 * This implicitly triggers the writebehind on sync().
2123 */
2124
2125static void ext3_write_super (struct super_block * sb)
2126{
2127 if (down_trylock(&sb->s_lock) == 0)
2128 BUG();
2129 sb->s_dirt = 0;
2130}
2131
2132static int ext3_sync_fs(struct super_block *sb, int wait)
2133{
2134 tid_t target;
2135
2136 sb->s_dirt = 0;
2137 if (journal_start_commit(EXT3_SB(sb)->s_journal, &target)) {
2138 if (wait)
2139 log_wait_commit(EXT3_SB(sb)->s_journal, target);
2140 }
2141 return 0;
2142}
2143
2144/*
2145 * LVM calls this function before a (read-only) snapshot is created. This
2146 * gives us a chance to flush the journal completely and mark the fs clean.
2147 */
2148static void ext3_write_super_lockfs(struct super_block *sb)
2149{
2150 sb->s_dirt = 0;
2151
2152 if (!(sb->s_flags & MS_RDONLY)) {
2153 journal_t *journal = EXT3_SB(sb)->s_journal;
2154
2155 /* Now we set up the journal barrier. */
2156 journal_lock_updates(journal);
2157 journal_flush(journal);
2158
2159 /* Journal blocked and flushed, clear needs_recovery flag. */
2160 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2161 ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
2162 }
2163}
2164
2165/*
2166 * Called by LVM after the snapshot is done. We need to reset the RECOVER
2167 * flag here, even though the filesystem is not technically dirty yet.
2168 */
2169static void ext3_unlockfs(struct super_block *sb)
2170{
2171 if (!(sb->s_flags & MS_RDONLY)) {
2172 lock_super(sb);
2173 /* Reser the needs_recovery flag before the fs is unlocked. */
2174 EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2175 ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
2176 unlock_super(sb);
2177 journal_unlock_updates(EXT3_SB(sb)->s_journal);
2178 }
2179}
2180
2181static int ext3_remount (struct super_block * sb, int * flags, char * data)
2182{
2183 struct ext3_super_block * es;
2184 struct ext3_sb_info *sbi = EXT3_SB(sb);
1da177e4 2185 unsigned long n_blocks_count = 0;
08c6a96f
JK		 2186 unsigned long old_sb_flags;
2187 struct ext3_mount_options old_opts;
2188 int err;
2189#ifdef CONFIG_QUOTA
2190 int i;
2191#endif
2192
2193 /* Store the original options */
2194 old_sb_flags = sb->s_flags;
2195 old_opts.s_mount_opt = sbi->s_mount_opt;
2196 old_opts.s_resuid = sbi->s_resuid;
2197 old_opts.s_resgid = sbi->s_resgid;
2198 old_opts.s_commit_interval = sbi->s_commit_interval;
2199#ifdef CONFIG_QUOTA
2200 old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
2201 for (i = 0; i < MAXQUOTAS; i++)
2202 old_opts.s_qf_names[i] = sbi->s_qf_names[i];
2203#endif
1da177e4
LT		 2204
2205 /*
2206 * Allow the "check" option to be passed as a remount option.
2207 */
08c6a96f
JK		 2208 if (!parse_options(data, sb, NULL, &n_blocks_count, 1)) {
2209 err = -EINVAL;
2210 goto restore_opts;
2211 }
1da177e4
LT		 2212
2213 if (sbi->s_mount_opt & EXT3_MOUNT_ABORT)
2214 ext3_abort(sb, __FUNCTION__, "Abort forced by user");
2215
2216 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2217 ((sbi->s_mount_opt & EXT3_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
2218
2219 es = sbi->s_es;
2220
2221 ext3_init_journal_params(sb, sbi->s_journal);
2222
2223 if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
2224 n_blocks_count > le32_to_cpu(es->s_blocks_count)) {
08c6a96f
JK		 2225 if (sbi->s_mount_opt & EXT3_MOUNT_ABORT) {
2226 err = -EROFS;
2227 goto restore_opts;
2228 }
1da177e4
LT		 2229
2230 if (*flags & MS_RDONLY) {
2231 /*
2232 * First of all, the unconditional stuff we have to do
2233 * to disable replay of the journal when we next remount
2234 */
2235 sb->s_flags |= MS_RDONLY;
2236
2237 /*
2238 * OK, test if we are remounting a valid rw partition
2239 * readonly, and if so set the rdonly flag and then
2240 * mark the partition as valid again.
2241 */
2242 if (!(es->s_state & cpu_to_le16(EXT3_VALID_FS)) &&
2243 (sbi->s_mount_state & EXT3_VALID_FS))
2244 es->s_state = cpu_to_le16(sbi->s_mount_state);
2245
2246 ext3_mark_recovery_complete(sb, es);
2247 } else {
2248 __le32 ret;
2249 if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
2250 ~EXT3_FEATURE_RO_COMPAT_SUPP))) {
2251 printk(KERN_WARNING "EXT3-fs: %s: couldn't "
2252 "remount RDWR because of unsupported "
2253 "optional features (%x).\n",
2254 sb->s_id, le32_to_cpu(ret));
08c6a96f
JK		 2255 err = -EROFS;
2256 goto restore_opts;
1da177e4
LT		 2257 }
2258 /*
2259 * Mounting a RDONLY partition read-write, so reread
2260 * and store the current valid flag. (It may have
2261 * been changed by e2fsck since we originally mounted
2262 * the partition.)
2263 */
2264 ext3_clear_journal_err(sb, es);
2265 sbi->s_mount_state = le16_to_cpu(es->s_state);
08c6a96f
JK		 2266 if ((ret = ext3_group_extend(sb, es, n_blocks_count))) {
2267 err = ret;
2268 goto restore_opts;
2269 }
1da177e4
LT		 2270 if (!ext3_setup_super (sb, es, 0))
2271 sb->s_flags &= ~MS_RDONLY;
2272 }
2273 }
08c6a96f
JK		 2274#ifdef CONFIG_QUOTA
2275 /* Release old quota file names */
2276 for (i = 0; i < MAXQUOTAS; i++)
2277 if (old_opts.s_qf_names[i] &&
2278 old_opts.s_qf_names[i] != sbi->s_qf_names[i])
2279 kfree(old_opts.s_qf_names[i]);
2280#endif
1da177e4 2281 return 0;
08c6a96f
JK		 2282restore_opts:
2283 sb->s_flags = old_sb_flags;
2284 sbi->s_mount_opt = old_opts.s_mount_opt;
2285 sbi->s_resuid = old_opts.s_resuid;
2286 sbi->s_resgid = old_opts.s_resgid;
2287 sbi->s_commit_interval = old_opts.s_commit_interval;
2288#ifdef CONFIG_QUOTA
2289 sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
2290 for (i = 0; i < MAXQUOTAS; i++) {
2291 if (sbi->s_qf_names[i] &&
2292 old_opts.s_qf_names[i] != sbi->s_qf_names[i])
2293 kfree(sbi->s_qf_names[i]);
2294 sbi->s_qf_names[i] = old_opts.s_qf_names[i];
2295 }
2296#endif
2297 return err;
1da177e4
LT		 2298}
2299
2300static int ext3_statfs (struct super_block * sb, struct kstatfs * buf)
2301{
2302 struct ext3_super_block *es = EXT3_SB(sb)->s_es;
2303 unsigned long overhead;
2304 int i;
2305
2306 if (test_opt (sb, MINIX_DF))
2307 overhead = 0;
2308 else {
2309 unsigned long ngroups;
2310 ngroups = EXT3_SB(sb)->s_groups_count;
2311 smp_rmb();
2312
2313 /*
2314 * Compute the overhead (FS structures)
2315 */
2316
2317 /*
2318 * All of the blocks before first_data_block are
2319 * overhead
2320 */
2321 overhead = le32_to_cpu(es->s_first_data_block);
2322
2323 /*
2324 * Add the overhead attributed to the superblock and
2325 * block group descriptors. If the sparse superblocks
2326 * feature is turned on, then not all groups have this.
2327 */
2328 for (i = 0; i < ngroups; i++) {
2329 overhead += ext3_bg_has_super(sb, i) +
2330 ext3_bg_num_gdb(sb, i);
2331 cond_resched();
2332 }
2333
2334 /*
2335 * Every block group has an inode bitmap, a block
2336 * bitmap, and an inode table.
2337 */
2338 overhead += (ngroups * (2 + EXT3_SB(sb)->s_itb_per_group));
2339 }
2340
2341 buf->f_type = EXT3_SUPER_MAGIC;
2342 buf->f_bsize = sb->s_blocksize;
2343 buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
2344 buf->f_bfree = ext3_count_free_blocks (sb);
2345 buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
2346 if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
2347 buf->f_bavail = 0;
2348 buf->f_files = le32_to_cpu(es->s_inodes_count);
2349 buf->f_ffree = ext3_count_free_inodes (sb);
2350 buf->f_namelen = EXT3_NAME_LEN;
2351 return 0;
2352}
2353
2354/* Helper function for writing quotas on sync - we need to start transaction before quota file
2355 * is locked for write. Otherwise the are possible deadlocks:
2356 * Process 1 Process 2
2357 * ext3_create() quota_sync()
2358 * journal_start() write_dquot()
2359 * DQUOT_INIT() down(dqio_sem)
2360 * down(dqio_sem) journal_start()
2361 *
2362 */
2363
2364#ifdef CONFIG_QUOTA
2365
2366static inline struct inode *dquot_to_inode(struct dquot *dquot)
2367{
2368 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
2369}
2370
2371static int ext3_dquot_initialize(struct inode *inode, int type)
2372{
2373 handle_t *handle;
2374 int ret, err;
2375
2376 /* We may create quota structure so we need to reserve enough blocks */
1f54587b 2377 handle = ext3_journal_start(inode, 2*EXT3_QUOTA_INIT_BLOCKS(inode->i_sb));
1da177e4
LT		 2378 if (IS_ERR(handle))
2379 return PTR_ERR(handle);
2380 ret = dquot_initialize(inode, type);
2381 err = ext3_journal_stop(handle);
2382 if (!ret)
2383 ret = err;
2384 return ret;
2385}
2386
2387static int ext3_dquot_drop(struct inode *inode)
2388{
2389 handle_t *handle;
2390 int ret, err;
2391
2392 /* We may delete quota structure so we need to reserve enough blocks */
1f54587b 2393 handle = ext3_journal_start(inode, 2*EXT3_QUOTA_DEL_BLOCKS(inode->i_sb));
1da177e4
LT		 2394 if (IS_ERR(handle))
2395 return PTR_ERR(handle);
2396 ret = dquot_drop(inode);
2397 err = ext3_journal_stop(handle);
2398 if (!ret)
2399 ret = err;
2400 return ret;
2401}
2402
2403static int ext3_write_dquot(struct dquot *dquot)
2404{
2405 int ret, err;
2406 handle_t *handle;
2407 struct inode *inode;
2408
2409 inode = dquot_to_inode(dquot);
2410 handle = ext3_journal_start(inode,
1f54587b 2411 EXT3_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1da177e4
LT		 2412 if (IS_ERR(handle))
2413 return PTR_ERR(handle);
2414 ret = dquot_commit(dquot);
2415 err = ext3_journal_stop(handle);
2416 if (!ret)
2417 ret = err;
2418 return ret;
2419}
2420
2421static int ext3_acquire_dquot(struct dquot *dquot)
2422{
2423 int ret, err;
2424 handle_t *handle;
2425
2426 handle = ext3_journal_start(dquot_to_inode(dquot),
1f54587b 2427 EXT3_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1da177e4
LT		 2428 if (IS_ERR(handle))
2429 return PTR_ERR(handle);
2430 ret = dquot_acquire(dquot);
2431 err = ext3_journal_stop(handle);
2432 if (!ret)
2433 ret = err;
2434 return ret;
2435}
2436
2437static int ext3_release_dquot(struct dquot *dquot)
2438{
2439 int ret, err;
2440 handle_t *handle;
2441
2442 handle = ext3_journal_start(dquot_to_inode(dquot),
1f54587b 2443 EXT3_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1da177e4
LT		 2444 if (IS_ERR(handle))
2445 return PTR_ERR(handle);
2446 ret = dquot_release(dquot);
2447 err = ext3_journal_stop(handle);
2448 if (!ret)
2449 ret = err;
2450 return ret;
2451}
2452
2453static int ext3_mark_dquot_dirty(struct dquot *dquot)
2454{
2455 /* Are we journalling quotas? */
2456 if (EXT3_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2457 EXT3_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2458 dquot_mark_dquot_dirty(dquot);
2459 return ext3_write_dquot(dquot);
2460 } else {
2461 return dquot_mark_dquot_dirty(dquot);
2462 }
2463}
2464
2465static int ext3_write_info(struct super_block *sb, int type)
2466{
2467 int ret, err;
2468 handle_t *handle;
2469
2470 /* Data block + inode block */
2471 handle = ext3_journal_start(sb->s_root->d_inode, 2);
2472 if (IS_ERR(handle))
2473 return PTR_ERR(handle);
2474 ret = dquot_commit_info(sb, type);
2475 err = ext3_journal_stop(handle);
2476 if (!ret)
2477 ret = err;
2478 return ret;
2479}
2480
2481/*
2482 * Turn on quotas during mount time - we need to find
2483 * the quota file and such...
2484 */
2485static int ext3_quota_on_mount(struct super_block *sb, int type)
2486{
84de856e
CH		 2487 return vfs_quota_on_mount(sb, EXT3_SB(sb)->s_qf_names[type],
2488 EXT3_SB(sb)->s_jquota_fmt, type);
1da177e4
LT		 2489}
2490
2491/*
2492 * Standard function to be called on quota_on
2493 */
2494static int ext3_quota_on(struct super_block *sb, int type, int format_id,
2495 char *path)
2496{
2497 int err;
2498 struct nameidata nd;
2499
1f54587b
JK		 2500 if (!test_opt(sb, QUOTA))
2501 return -EINVAL;
1da177e4
LT		 2502 /* Not journalling quota? */
2503 if (!EXT3_SB(sb)->s_qf_names[USRQUOTA] &&
2504 !EXT3_SB(sb)->s_qf_names[GRPQUOTA])
2505 return vfs_quota_on(sb, type, format_id, path);
2506 err = path_lookup(path, LOOKUP_FOLLOW, &nd);
2507 if (err)
2508 return err;
2509 /* Quotafile not on the same filesystem? */
2510 if (nd.mnt->mnt_sb != sb) {
2511 path_release(&nd);
2512 return -EXDEV;
2513 }
2514 /* Quotafile not of fs root? */
2515 if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode)
2516 printk(KERN_WARNING
2517 "EXT3-fs: Quota file not on filesystem root. "
2518 "Journalled quota will not work.\n");
2519 path_release(&nd);
2520 return vfs_quota_on(sb, type, format_id, path);
2521}
2522
2523/* Read data from quotafile - avoid pagecache and such because we cannot afford
2524 * acquiring the locks... As quota files are never truncated and quota code
2525 * itself serializes the operations (and noone else should touch the files)
2526 * we don't have to be afraid of races */
2527static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
2528 size_t len, loff_t off)
2529{
2530 struct inode *inode = sb_dqopt(sb)->files[type];
2531 sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
2532 int err = 0;
2533 int offset = off & (sb->s_blocksize - 1);
2534 int tocopy;
2535 size_t toread;
2536 struct buffer_head *bh;
2537 loff_t i_size = i_size_read(inode);
2538
2539 if (off > i_size)
2540 return 0;
2541 if (off+len > i_size)
2542 len = i_size-off;
2543 toread = len;
2544 while (toread > 0) {
2545 tocopy = sb->s_blocksize - offset < toread ?
2546 sb->s_blocksize - offset : toread;
2547 bh = ext3_bread(NULL, inode, blk, 0, &err);
2548 if (err)
2549 return err;
2550 if (!bh) /* A hole? */
2551 memset(data, 0, tocopy);
2552 else
2553 memcpy(data, bh->b_data+offset, tocopy);
2554 brelse(bh);
2555 offset = 0;
2556 toread -= tocopy;
2557 data += tocopy;
2558 blk++;
2559 }
2560 return len;
2561}
2562
2563/* Write to quotafile (we know the transaction is already started and has
2564 * enough credits) */
2565static ssize_t ext3_quota_write(struct super_block *sb, int type,
2566 const char *data, size_t len, loff_t off)
2567{
2568 struct inode *inode = sb_dqopt(sb)->files[type];
2569 sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
2570 int err = 0;
2571 int offset = off & (sb->s_blocksize - 1);
2572 int tocopy;
2573 int journal_quota = EXT3_SB(sb)->s_qf_names[type] != NULL;
2574 size_t towrite = len;
2575 struct buffer_head *bh;
2576 handle_t *handle = journal_current_handle();
2577
2578 down(&inode->i_sem);
2579 while (towrite > 0) {
2580 tocopy = sb->s_blocksize - offset < towrite ?
2581 sb->s_blocksize - offset : towrite;
2582 bh = ext3_bread(handle, inode, blk, 1, &err);
2583 if (!bh)
2584 goto out;
2585 if (journal_quota) {
2586 err = ext3_journal_get_write_access(handle, bh);
2587 if (err) {
2588 brelse(bh);
2589 goto out;
2590 }
2591 }
2592 lock_buffer(bh);
2593 memcpy(bh->b_data+offset, data, tocopy);
2594 flush_dcache_page(bh->b_page);
2595 unlock_buffer(bh);
2596 if (journal_quota)
2597 err = ext3_journal_dirty_metadata(handle, bh);
2598 else {
2599 /* Always do at least ordered writes for quotas */
2600 err = ext3_journal_dirty_data(handle, bh);
2601 mark_buffer_dirty(bh);
2602 }
2603 brelse(bh);
2604 if (err)
2605 goto out;
2606 offset = 0;
2607 towrite -= tocopy;
2608 data += tocopy;
2609 blk++;
2610 }
2611out:
2612 if (len == towrite)
2613 return err;
2614 if (inode->i_size < off+len-towrite) {
2615 i_size_write(inode, off+len-towrite);
2616 EXT3_I(inode)->i_disksize = inode->i_size;
2617 }
2618 inode->i_version++;
2619 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2620 ext3_mark_inode_dirty(handle, inode);
2621 up(&inode->i_sem);
2622 return len - towrite;
2623}
2624
2625#endif
2626
2627static struct super_block *ext3_get_sb(struct file_system_type *fs_type,
2628 int flags, const char *dev_name, void *data)
2629{
2630 return get_sb_bdev(fs_type, flags, dev_name, data, ext3_fill_super);
2631}
2632
2633static struct file_system_type ext3_fs_type = {
2634 .owner = THIS_MODULE,
2635 .name = "ext3",
2636 .get_sb = ext3_get_sb,
2637 .kill_sb = kill_block_super,
2638 .fs_flags = FS_REQUIRES_DEV,
2639};
2640
2641static int __init init_ext3_fs(void)
2642{
2643 int err = init_ext3_xattr();
2644 if (err)
2645 return err;
2646 err = init_inodecache();
2647 if (err)
2648 goto out1;
2649 err = register_filesystem(&ext3_fs_type);
2650 if (err)
2651 goto out;
2652 return 0;
2653out:
2654 destroy_inodecache();
2655out1:
2656 exit_ext3_xattr();
2657 return err;
2658}
2659
2660static void __exit exit_ext3_fs(void)
2661{
2662 unregister_filesystem(&ext3_fs_type);
2663 destroy_inodecache();
2664 exit_ext3_xattr();
2665}
2666
2667MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
2668MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
2669MODULE_LICENSE("GPL");
2670module_init(init_ext3_fs)
2671module_exit(exit_ext3_fs)
Linux 6.x block layer and io_uring tree(s)