Branch data Line data Source code
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/module.h>
20 : : #include <linux/blkdev.h>
21 : : #include <linux/parser.h>
22 : : #include <linux/exportfs.h>
23 : : #include <linux/statfs.h>
24 : : #include <linux/random.h>
25 : : #include <linux/mount.h>
26 : : #include <linux/quotaops.h>
27 : : #include <linux/seq_file.h>
28 : : #include <linux/log2.h>
29 : : #include <linux/cleancache.h>
30 : : #include <linux/namei.h>
31 : :
32 : : #include <asm/uaccess.h>
33 : :
34 : : #define CREATE_TRACE_POINTS
35 : :
36 : : #include "ext3.h"
37 : : #include "xattr.h"
38 : : #include "acl.h"
39 : : #include "namei.h"
40 : :
41 : : #ifdef CONFIG_EXT3_DEFAULTS_TO_ORDERED
42 : : #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_ORDERED_DATA
43 : : #else
44 : : #define EXT3_MOUNT_DEFAULT_DATA_MODE EXT3_MOUNT_WRITEBACK_DATA
45 : : #endif
46 : :
47 : : static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
48 : : unsigned long journal_devnum);
49 : : static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
50 : : unsigned int);
51 : : static int ext3_commit_super(struct super_block *sb,
52 : : struct ext3_super_block *es,
53 : : int sync);
54 : : static void ext3_mark_recovery_complete(struct super_block * sb,
55 : : struct ext3_super_block * es);
56 : : static void ext3_clear_journal_err(struct super_block * sb,
57 : : struct ext3_super_block * es);
58 : : static int ext3_sync_fs(struct super_block *sb, int wait);
59 : : static const char *ext3_decode_error(struct super_block * sb, int errno,
60 : : char nbuf[16]);
61 : : static int ext3_remount (struct super_block * sb, int * flags, char * data);
62 : : static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf);
63 : : static int ext3_unfreeze(struct super_block *sb);
64 : : static int ext3_freeze(struct super_block *sb);
65 : :
66 : : /*
67 : : * Wrappers for journal_start/end.
68 : : */
69 : 0 : handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks)
70 : : {
71 : 0 : journal_t *journal;
72 : :
73 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY)
74 : : return ERR_PTR(-EROFS);
75 : :
76 : : /* Special case here: if the journal has aborted behind our
77 : : * backs (eg. EIO in the commit thread), then we still need to
78 : : * take the FS itself readonly cleanly. */
79 : 0 : journal = EXT3_SB(sb)->s_journal;
80 [ # # ]: 0 : if (is_journal_aborted(journal)) {
81 : 0 : ext3_abort(sb, __func__,
82 : : "Detected aborted journal");
83 : 0 : return ERR_PTR(-EROFS);
84 : : }
85 : :
86 : 0 : return journal_start(journal, nblocks);
87 : : }
88 : :
89 : 0 : int __ext3_journal_stop(const char *where, handle_t *handle)
90 : : {
91 : : struct super_block *sb;
92 : : int err;
93 : : int rc;
94 : :
95 : 0 : sb = handle->h_transaction->t_journal->j_private;
96 : 0 : err = handle->h_err;
97 : 0 : rc = journal_stop(handle);
98 : :
99 [ # # ]: 0 : if (!err)
100 : : err = rc;
101 [ # # ]: 0 : if (err)
102 : 0 : __ext3_std_error(sb, where, err);
103 : 0 : return err;
104 : : }
105 : :
106 : 0 : void ext3_journal_abort_handle(const char *caller, const char *err_fn,
107 : : struct buffer_head *bh, handle_t *handle, int err)
108 : : {
109 : : char nbuf[16];
110 : 0 : const char *errstr = ext3_decode_error(NULL, err, nbuf);
111 : :
112 : : if (bh)
113 : : BUFFER_TRACE(bh, "abort");
114 : :
115 [ # # ]: 0 : if (!handle->h_err)
116 : 0 : handle->h_err = err;
117 : :
118 [ # # ]: 0 : if (is_handle_aborted(handle))
119 : 0 : return;
120 : :
121 : 0 : printk(KERN_ERR "EXT3-fs: %s: aborting transaction: %s in %s\n",
122 : : caller, errstr, err_fn);
123 : :
124 : : journal_abort_handle(handle);
125 : : }
126 : :
127 : 0 : void ext3_msg(struct super_block *sb, const char *prefix,
128 : : const char *fmt, ...)
129 : : {
130 : : struct va_format vaf;
131 : : va_list args;
132 : :
133 : 0 : va_start(args, fmt);
134 : :
135 : 0 : vaf.fmt = fmt;
136 : 0 : vaf.va = &args;
137 : :
138 : 0 : printk("%sEXT3-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
139 : :
140 : 0 : va_end(args);
141 : 0 : }
142 : :
143 : : /* Deal with the reporting of failure conditions on a filesystem such as
144 : : * inconsistencies detected or read IO failures.
145 : : *
146 : : * On ext2, we can store the error state of the filesystem in the
147 : : * superblock. That is not possible on ext3, because we may have other
148 : : * write ordering constraints on the superblock which prevent us from
149 : : * writing it out straight away; and given that the journal is about to
150 : : * be aborted, we can't rely on the current, or future, transactions to
151 : : * write out the superblock safely.
152 : : *
153 : : * We'll just use the journal_abort() error code to record an error in
154 : : * the journal instead. On recovery, the journal will complain about
155 : : * that error until we've noted it down and cleared it.
156 : : */
157 : :
158 : 0 : static void ext3_handle_error(struct super_block *sb)
159 : : {
160 : 0 : struct ext3_super_block *es = EXT3_SB(sb)->s_es;
161 : :
162 : 0 : EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
163 : 0 : es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
164 : :
165 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY)
166 : 0 : return;
167 : :
168 [ # # ]: 0 : if (!test_opt (sb, ERRORS_CONT)) {
169 : 0 : journal_t *journal = EXT3_SB(sb)->s_journal;
170 : :
171 : 0 : set_opt(EXT3_SB(sb)->s_mount_opt, ABORT);
172 [ # # ]: 0 : if (journal)
173 : 0 : journal_abort(journal, -EIO);
174 : : }
175 [ # # ]: 0 : if (test_opt (sb, ERRORS_RO)) {
176 : 0 : ext3_msg(sb, KERN_CRIT,
177 : : "error: remounting filesystem read-only");
178 : : /*
179 : : * Make sure updated value of ->s_mount_state will be visible
180 : : * before ->s_flags update.
181 : : */
182 : 0 : smp_wmb();
183 : 0 : sb->s_flags |= MS_RDONLY;
184 : : }
185 : 0 : ext3_commit_super(sb, es, 1);
186 [ # # ]: 0 : if (test_opt(sb, ERRORS_PANIC))
187 : 0 : panic("EXT3-fs (%s): panic forced after error\n",
188 : 0 : sb->s_id);
189 : : }
190 : :
191 : 0 : void ext3_error(struct super_block *sb, const char *function,
192 : : const char *fmt, ...)
193 : : {
194 : : struct va_format vaf;
195 : : va_list args;
196 : :
197 : 0 : va_start(args, fmt);
198 : :
199 : 0 : vaf.fmt = fmt;
200 : 0 : vaf.va = &args;
201 : :
202 : 0 : printk(KERN_CRIT "EXT3-fs error (device %s): %s: %pV\n",
203 : 0 : sb->s_id, function, &vaf);
204 : :
205 : 0 : va_end(args);
206 : :
207 : 0 : ext3_handle_error(sb);
208 : 0 : }
209 : :
210 : 0 : static const char *ext3_decode_error(struct super_block * sb, int errno,
211 : : char nbuf[16])
212 : : {
213 : : char *errstr = NULL;
214 : :
215 [ # # # # ]: 0 : switch (errno) {
216 : : case -EIO:
217 : : errstr = "IO failure";
218 : : break;
219 : : case -ENOMEM:
220 : : errstr = "Out of memory";
221 : 0 : break;
222 : : case -EROFS:
223 [ # # ][ # # ]: 0 : if (!sb || EXT3_SB(sb)->s_journal->j_flags & JFS_ABORT)
224 : : errstr = "Journal has aborted";
225 : : else
226 : : errstr = "Readonly filesystem";
227 : : break;
228 : : default:
229 : : /* If the caller passed in an extra buffer for unknown
230 : : * errors, textualise them now. Else we just return
231 : : * NULL. */
232 [ # # ]: 0 : if (nbuf) {
233 : : /* Check for truncated error codes... */
234 [ # # ]: 0 : if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
235 : : errstr = nbuf;
236 : : }
237 : : break;
238 : : }
239 : :
240 : 0 : return errstr;
241 : : }
242 : :
243 : : /* __ext3_std_error decodes expected errors from journaling functions
244 : : * automatically and invokes the appropriate error response. */
245 : :
246 : 0 : void __ext3_std_error (struct super_block * sb, const char * function,
247 : : int errno)
248 : : {
249 : : char nbuf[16];
250 : : const char *errstr;
251 : :
252 : : /* Special case: if the error is EROFS, and we're not already
253 : : * inside a transaction, then there's really no point in logging
254 : : * an error. */
255 [ # # ][ # # ]: 0 : if (errno == -EROFS && journal_current_handle() == NULL &&
[ # # ]
256 : 0 : (sb->s_flags & MS_RDONLY))
257 : 0 : return;
258 : :
259 : 0 : errstr = ext3_decode_error(sb, errno, nbuf);
260 : 0 : ext3_msg(sb, KERN_CRIT, "error in %s: %s", function, errstr);
261 : :
262 : 0 : ext3_handle_error(sb);
263 : : }
264 : :
265 : : /*
266 : : * ext3_abort is a much stronger failure handler than ext3_error. The
267 : : * abort function may be used to deal with unrecoverable failures such
268 : : * as journal IO errors or ENOMEM at a critical moment in log management.
269 : : *
270 : : * We unconditionally force the filesystem into an ABORT|READONLY state,
271 : : * unless the error response on the fs has been set to panic in which
272 : : * case we take the easy way out and panic immediately.
273 : : */
274 : :
275 : 0 : void ext3_abort(struct super_block *sb, const char *function,
276 : : const char *fmt, ...)
277 : : {
278 : : struct va_format vaf;
279 : : va_list args;
280 : :
281 : 0 : va_start(args, fmt);
282 : :
283 : 0 : vaf.fmt = fmt;
284 : 0 : vaf.va = &args;
285 : :
286 : 0 : printk(KERN_CRIT "EXT3-fs (%s): error: %s: %pV\n",
287 : 0 : sb->s_id, function, &vaf);
288 : :
289 : 0 : va_end(args);
290 : :
291 [ # # ]: 0 : if (test_opt(sb, ERRORS_PANIC))
292 : 0 : panic("EXT3-fs: panic from previous error\n");
293 : :
294 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY)
295 : 0 : return;
296 : :
297 : 0 : ext3_msg(sb, KERN_CRIT,
298 : : "error: remounting filesystem read-only");
299 : 0 : EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
300 : 0 : set_opt(EXT3_SB(sb)->s_mount_opt, ABORT);
301 : : /*
302 : : * Make sure updated value of ->s_mount_state will be visible
303 : : * before ->s_flags update.
304 : : */
305 : 0 : smp_wmb();
306 : 0 : sb->s_flags |= MS_RDONLY;
307 : :
308 [ # # ]: 0 : if (EXT3_SB(sb)->s_journal)
309 : 0 : journal_abort(EXT3_SB(sb)->s_journal, -EIO);
310 : : }
311 : :
312 : 0 : void ext3_warning(struct super_block *sb, const char *function,
313 : : const char *fmt, ...)
314 : : {
315 : : struct va_format vaf;
316 : : va_list args;
317 : :
318 : 0 : va_start(args, fmt);
319 : :
320 : 0 : vaf.fmt = fmt;
321 : 0 : vaf.va = &args;
322 : :
323 : 0 : printk(KERN_WARNING "EXT3-fs (%s): warning: %s: %pV\n",
324 : 0 : sb->s_id, function, &vaf);
325 : :
326 : 0 : va_end(args);
327 : 0 : }
328 : :
329 : 0 : void ext3_update_dynamic_rev(struct super_block *sb)
330 : : {
331 : 0 : struct ext3_super_block *es = EXT3_SB(sb)->s_es;
332 : :
333 [ # # ]: 0 : if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
334 : 0 : return;
335 : :
336 : 0 : ext3_msg(sb, KERN_WARNING,
337 : : "warning: updating to rev %d because of "
338 : : "new feature flag, running e2fsck is recommended",
339 : : EXT3_DYNAMIC_REV);
340 : :
341 : 0 : es->s_first_ino = cpu_to_le32(EXT3_GOOD_OLD_FIRST_INO);
342 : 0 : es->s_inode_size = cpu_to_le16(EXT3_GOOD_OLD_INODE_SIZE);
343 : 0 : es->s_rev_level = cpu_to_le32(EXT3_DYNAMIC_REV);
344 : : /* leave es->s_feature_*compat flags alone */
345 : : /* es->s_uuid will be set by e2fsck if empty */
346 : :
347 : : /*
348 : : * The rest of the superblock fields should be zero, and if not it
349 : : * means they are likely already in use, so leave them alone. We
350 : : * can leave it up to e2fsck to clean up any inconsistencies there.
351 : : */
352 : : }
353 : :
354 : : /*
355 : : * Open the external journal device
356 : : */
357 : 0 : static struct block_device *ext3_blkdev_get(dev_t dev, struct super_block *sb)
358 : : {
359 : : struct block_device *bdev;
360 : : char b[BDEVNAME_SIZE];
361 : :
362 : 0 : bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb);
363 [ # # ]: 0 : if (IS_ERR(bdev))
364 : : goto fail;
365 : : return bdev;
366 : :
367 : : fail:
368 : 0 : ext3_msg(sb, KERN_ERR, "error: failed to open journal device %s: %ld",
369 : : __bdevname(dev, b), PTR_ERR(bdev));
370 : :
371 : 0 : return NULL;
372 : : }
373 : :
374 : : /*
375 : : * Release the journal device
376 : : */
377 : : static void ext3_blkdev_put(struct block_device *bdev)
378 : : {
379 : 0 : blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
380 : : }
381 : :
382 : : static void ext3_blkdev_remove(struct ext3_sb_info *sbi)
383 : : {
384 : : struct block_device *bdev;
385 : 0 : bdev = sbi->journal_bdev;
386 [ # # # # ]: 0 : if (bdev) {
387 : : ext3_blkdev_put(bdev);
388 : 0 : sbi->journal_bdev = NULL;
389 : : }
390 : : }
391 : :
392 : : static inline struct inode *orphan_list_entry(struct list_head *l)
393 : : {
394 : : return &list_entry(l, struct ext3_inode_info, i_orphan)->vfs_inode;
395 : : }
396 : :
397 : 0 : static void dump_orphan_list(struct super_block *sb, struct ext3_sb_info *sbi)
398 : : {
399 : : struct list_head *l;
400 : :
401 : 0 : ext3_msg(sb, KERN_ERR, "error: sb orphan head is %d",
402 : 0 : le32_to_cpu(sbi->s_es->s_last_orphan));
403 : :
404 : 0 : ext3_msg(sb, KERN_ERR, "sb_info orphan list:");
405 [ # # ]: 0 : list_for_each(l, &sbi->s_orphan) {
406 : 0 : struct inode *inode = orphan_list_entry(l);
407 : 0 : ext3_msg(sb, KERN_ERR, " "
408 : : "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
409 : 0 : inode->i_sb->s_id, inode->i_ino, inode,
410 : 0 : inode->i_mode, inode->i_nlink,
411 : : NEXT_ORPHAN(inode));
412 : : }
413 : 0 : }
414 : :
415 : 0 : static void ext3_put_super (struct super_block * sb)
416 : : {
417 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
418 : 0 : struct ext3_super_block *es = sbi->s_es;
419 : : int i, err;
420 : :
421 : 0 : dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
422 : 0 : ext3_xattr_put_super(sb);
423 : 0 : err = journal_destroy(sbi->s_journal);
424 : 0 : sbi->s_journal = NULL;
425 [ # # ]: 0 : if (err < 0)
426 : 0 : ext3_abort(sb, __func__, "Couldn't clean up the journal");
427 : :
428 [ # # ]: 0 : if (!(sb->s_flags & MS_RDONLY)) {
429 : 0 : EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
430 : 0 : es->s_state = cpu_to_le16(sbi->s_mount_state);
431 : : BUFFER_TRACE(sbi->s_sbh, "marking dirty");
432 : 0 : mark_buffer_dirty(sbi->s_sbh);
433 : 0 : ext3_commit_super(sb, es, 1);
434 : : }
435 : :
436 [ # # ]: 0 : for (i = 0; i < sbi->s_gdb_count; i++)
437 : 0 : brelse(sbi->s_group_desc[i]);
438 : 0 : kfree(sbi->s_group_desc);
439 : 0 : percpu_counter_destroy(&sbi->s_freeblocks_counter);
440 : 0 : percpu_counter_destroy(&sbi->s_freeinodes_counter);
441 : 0 : percpu_counter_destroy(&sbi->s_dirs_counter);
442 : 0 : brelse(sbi->s_sbh);
443 : : #ifdef CONFIG_QUOTA
444 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
445 : 0 : kfree(sbi->s_qf_names[i]);
446 : : #endif
447 : :
448 : : /* Debugging code just in case the in-memory inode orphan list
449 : : * isn't empty. The on-disk one can be non-empty if we've
450 : : * detected an error and taken the fs readonly, but the
451 : : * in-memory list had better be clean by this point. */
452 [ # # ]: 0 : if (!list_empty(&sbi->s_orphan))
453 : 0 : dump_orphan_list(sb, sbi);
454 [ # # ]: 0 : J_ASSERT(list_empty(&sbi->s_orphan));
455 : :
456 : 0 : invalidate_bdev(sb->s_bdev);
457 [ # # ][ # # ]: 0 : if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
458 : : /*
459 : : * Invalidate the journal device's buffers. We don't want them
460 : : * floating about in memory - the physical journal device may
461 : : * hotswapped, and it breaks the `ro-after' testing code.
462 : : */
463 : 0 : sync_blockdev(sbi->journal_bdev);
464 : 0 : invalidate_bdev(sbi->journal_bdev);
465 : : ext3_blkdev_remove(sbi);
466 : : }
467 : 0 : sb->s_fs_info = NULL;
468 : 0 : kfree(sbi->s_blockgroup_lock);
469 : 0 : kfree(sbi);
470 : 0 : }
471 : :
472 : : static struct kmem_cache *ext3_inode_cachep;
473 : :
474 : : /*
475 : : * Called inside transaction, so use GFP_NOFS
476 : : */
477 : 0 : static struct inode *ext3_alloc_inode(struct super_block *sb)
478 : : {
479 : : struct ext3_inode_info *ei;
480 : :
481 : 0 : ei = kmem_cache_alloc(ext3_inode_cachep, GFP_NOFS);
482 [ # # ]: 0 : if (!ei)
483 : : return NULL;
484 : 0 : ei->i_block_alloc_info = NULL;
485 : 0 : ei->vfs_inode.i_version = 1;
486 : 0 : atomic_set(&ei->i_datasync_tid, 0);
487 : 0 : atomic_set(&ei->i_sync_tid, 0);
488 : 0 : return &ei->vfs_inode;
489 : : }
490 : :
491 : 0 : static int ext3_drop_inode(struct inode *inode)
492 : : {
493 : : int drop = generic_drop_inode(inode);
494 : :
495 : : trace_ext3_drop_inode(inode, drop);
496 : 0 : return drop;
497 : : }
498 : :
499 : 0 : static void ext3_i_callback(struct rcu_head *head)
500 : : {
501 : : struct inode *inode = container_of(head, struct inode, i_rcu);
502 : 0 : kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
503 : 0 : }
504 : :
505 : 0 : static void ext3_destroy_inode(struct inode *inode)
506 : : {
507 [ # # ]: 0 : if (!list_empty(&(EXT3_I(inode)->i_orphan))) {
508 : 0 : printk("EXT3 Inode %p: orphan list check failed!\n",
509 : : EXT3_I(inode));
510 : 0 : print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
511 : : EXT3_I(inode), sizeof(struct ext3_inode_info),
512 : : false);
513 : 0 : dump_stack();
514 : : }
515 : 0 : call_rcu(&inode->i_rcu, ext3_i_callback);
516 : 0 : }
517 : :
518 : 0 : static void init_once(void *foo)
519 : : {
520 : : struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
521 : :
522 : 0 : INIT_LIST_HEAD(&ei->i_orphan);
523 : : #ifdef CONFIG_EXT3_FS_XATTR
524 : 0 : init_rwsem(&ei->xattr_sem);
525 : : #endif
526 : 0 : mutex_init(&ei->truncate_mutex);
527 : 0 : inode_init_once(&ei->vfs_inode);
528 : 0 : }
529 : :
530 : 0 : static int init_inodecache(void)
531 : : {
532 : 0 : ext3_inode_cachep = kmem_cache_create("ext3_inode_cache",
533 : : sizeof(struct ext3_inode_info),
534 : : 0, (SLAB_RECLAIM_ACCOUNT|
535 : : SLAB_MEM_SPREAD),
536 : : init_once);
537 [ # # ]: 0 : if (ext3_inode_cachep == NULL)
538 : : return -ENOMEM;
539 : 0 : return 0;
540 : : }
541 : :
542 : : static void destroy_inodecache(void)
543 : : {
544 : : /*
545 : : * Make sure all delayed rcu free inodes are flushed before we
546 : : * destroy cache.
547 : : */
548 : 0 : rcu_barrier();
549 : 0 : kmem_cache_destroy(ext3_inode_cachep);
550 : : }
551 : :
552 : 0 : static inline void ext3_show_quota_options(struct seq_file *seq, struct super_block *sb)
553 : : {
554 : : #if defined(CONFIG_QUOTA)
555 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
556 : :
557 [ # # ]: 0 : if (sbi->s_jquota_fmt) {
558 : : char *fmtname = "";
559 : :
560 [ # # ]: 0 : switch (sbi->s_jquota_fmt) {
561 : : case QFMT_VFS_OLD:
562 : : fmtname = "vfsold";
563 : : break;
564 : : case QFMT_VFS_V0:
565 : : fmtname = "vfsv0";
566 : : break;
567 : : case QFMT_VFS_V1:
568 : : fmtname = "vfsv1";
569 : : break;
570 : : }
571 : 0 : seq_printf(seq, ",jqfmt=%s", fmtname);
572 : : }
573 : :
574 [ # # ]: 0 : if (sbi->s_qf_names[USRQUOTA])
575 : 0 : seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
576 : :
577 [ # # ]: 0 : if (sbi->s_qf_names[GRPQUOTA])
578 : 0 : seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
579 : :
580 [ # # ]: 0 : if (test_opt(sb, USRQUOTA))
581 : 0 : seq_puts(seq, ",usrquota");
582 : :
583 [ # # ]: 0 : if (test_opt(sb, GRPQUOTA))
584 : 0 : seq_puts(seq, ",grpquota");
585 : : #endif
586 : : }
587 : :
588 : : static char *data_mode_string(unsigned long mode)
589 : : {
590 [ # # # # ]: 0 : switch (mode) {
[ # # # # ]
[ # # # # ]
591 : : case EXT3_MOUNT_JOURNAL_DATA:
592 : : return "journal";
593 : : case EXT3_MOUNT_ORDERED_DATA:
594 : : return "ordered";
595 : : case EXT3_MOUNT_WRITEBACK_DATA:
596 : : return "writeback";
597 : : }
598 : : return "unknown";
599 : : }
600 : :
601 : : /*
602 : : * Show an option if
603 : : * - it's set to a non-default value OR
604 : : * - if the per-sb default is different from the global default
605 : : */
606 : 0 : static int ext3_show_options(struct seq_file *seq, struct dentry *root)
607 : : {
608 : 0 : struct super_block *sb = root->d_sb;
609 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
610 : 0 : struct ext3_super_block *es = sbi->s_es;
611 : : unsigned long def_mount_opts;
612 : :
613 : 0 : def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
614 : :
615 [ # # ]: 0 : if (sbi->s_sb_block != 1)
616 : 0 : seq_printf(seq, ",sb=%lu", sbi->s_sb_block);
617 [ # # ]: 0 : if (test_opt(sb, MINIX_DF))
618 : 0 : seq_puts(seq, ",minixdf");
619 [ # # ]: 0 : if (test_opt(sb, GRPID))
620 : 0 : seq_puts(seq, ",grpid");
621 [ # # ][ # # ]: 0 : if (!test_opt(sb, GRPID) && (def_mount_opts & EXT3_DEFM_BSDGROUPS))
622 : 0 : seq_puts(seq, ",nogrpid");
623 [ # # ][ # # ]: 0 : if (!uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT3_DEF_RESUID)) ||
624 : 0 : le16_to_cpu(es->s_def_resuid) != EXT3_DEF_RESUID) {
625 : 0 : seq_printf(seq, ",resuid=%u",
626 : : from_kuid_munged(&init_user_ns, sbi->s_resuid));
627 : : }
628 [ # # ][ # # ]: 0 : if (!gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT3_DEF_RESGID)) ||
629 : 0 : le16_to_cpu(es->s_def_resgid) != EXT3_DEF_RESGID) {
630 : 0 : seq_printf(seq, ",resgid=%u",
631 : : from_kgid_munged(&init_user_ns, sbi->s_resgid));
632 : : }
633 [ # # ]: 0 : if (test_opt(sb, ERRORS_RO)) {
634 : 0 : int def_errors = le16_to_cpu(es->s_errors);
635 : :
636 [ # # ]: 0 : if (def_errors == EXT3_ERRORS_PANIC ||
637 : 0 : def_errors == EXT3_ERRORS_CONTINUE) {
638 : 0 : seq_puts(seq, ",errors=remount-ro");
639 : : }
640 : : }
641 [ # # ]: 0 : if (test_opt(sb, ERRORS_CONT))
642 : 0 : seq_puts(seq, ",errors=continue");
643 [ # # ]: 0 : if (test_opt(sb, ERRORS_PANIC))
644 : 0 : seq_puts(seq, ",errors=panic");
645 [ # # ]: 0 : if (test_opt(sb, NO_UID32))
646 : 0 : seq_puts(seq, ",nouid32");
647 [ # # ]: 0 : if (test_opt(sb, DEBUG))
648 : 0 : seq_puts(seq, ",debug");
649 : : #ifdef CONFIG_EXT3_FS_XATTR
650 [ # # ]: 0 : if (test_opt(sb, XATTR_USER))
651 : 0 : seq_puts(seq, ",user_xattr");
652 [ # # ][ # # ]: 0 : if (!test_opt(sb, XATTR_USER) &&
653 : 0 : (def_mount_opts & EXT3_DEFM_XATTR_USER)) {
654 : 0 : seq_puts(seq, ",nouser_xattr");
655 : : }
656 : : #endif
657 : : #ifdef CONFIG_EXT3_FS_POSIX_ACL
658 : : if (test_opt(sb, POSIX_ACL))
659 : : seq_puts(seq, ",acl");
660 : : if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT3_DEFM_ACL))
661 : : seq_puts(seq, ",noacl");
662 : : #endif
663 [ # # ]: 0 : if (!test_opt(sb, RESERVATION))
664 : 0 : seq_puts(seq, ",noreservation");
665 [ # # ]: 0 : if (sbi->s_commit_interval) {
666 : 0 : seq_printf(seq, ",commit=%u",
667 : 0 : (unsigned) (sbi->s_commit_interval / HZ));
668 : : }
669 : :
670 : : /*
671 : : * Always display barrier state so it's clear what the status is.
672 : : */
673 : 0 : seq_puts(seq, ",barrier=");
674 [ # # ]: 0 : seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
675 : 0 : seq_printf(seq, ",data=%s", data_mode_string(test_opt(sb, DATA_FLAGS)));
676 [ # # ]: 0 : if (test_opt(sb, DATA_ERR_ABORT))
677 : 0 : seq_puts(seq, ",data_err=abort");
678 : :
679 [ # # ]: 0 : if (test_opt(sb, NOLOAD))
680 : 0 : seq_puts(seq, ",norecovery");
681 : :
682 : : ext3_show_quota_options(seq, sb);
683 : :
684 : 0 : return 0;
685 : : }
686 : :
687 : :
688 : 0 : static struct inode *ext3_nfs_get_inode(struct super_block *sb,
689 : : u64 ino, u32 generation)
690 : : {
691 : : struct inode *inode;
692 : :
693 [ # # ][ # # ]: 0 : if (ino < EXT3_FIRST_INO(sb) && ino != EXT3_ROOT_INO)
694 : : return ERR_PTR(-ESTALE);
695 [ # # ]: 0 : if (ino > le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count))
696 : : return ERR_PTR(-ESTALE);
697 : :
698 : : /* iget isn't really right if the inode is currently unallocated!!
699 : : *
700 : : * ext3_read_inode will return a bad_inode if the inode had been
701 : : * deleted, so we should be safe.
702 : : *
703 : : * Currently we don't know the generation for parent directory, so
704 : : * a generation of 0 means "accept any"
705 : : */
706 : 0 : inode = ext3_iget(sb, ino);
707 [ # # ]: 0 : if (IS_ERR(inode))
708 : : return ERR_CAST(inode);
709 [ # # ][ # # ]: 0 : if (generation && inode->i_generation != generation) {
710 : 0 : iput(inode);
711 : 0 : return ERR_PTR(-ESTALE);
712 : : }
713 : :
714 : : return inode;
715 : : }
716 : :
717 : 0 : static struct dentry *ext3_fh_to_dentry(struct super_block *sb, struct fid *fid,
718 : : int fh_len, int fh_type)
719 : : {
720 : 0 : return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
721 : : ext3_nfs_get_inode);
722 : : }
723 : :
724 : 0 : static struct dentry *ext3_fh_to_parent(struct super_block *sb, struct fid *fid,
725 : : int fh_len, int fh_type)
726 : : {
727 : 0 : return generic_fh_to_parent(sb, fid, fh_len, fh_type,
728 : : ext3_nfs_get_inode);
729 : : }
730 : :
731 : : /*
732 : : * Try to release metadata pages (indirect blocks, directories) which are
733 : : * mapped via the block device. Since these pages could have journal heads
734 : : * which would prevent try_to_free_buffers() from freeing them, we must use
735 : : * jbd layer's try_to_free_buffers() function to release them.
736 : : */
737 : 0 : static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
738 : : gfp_t wait)
739 : : {
740 : 0 : journal_t *journal = EXT3_SB(sb)->s_journal;
741 : :
742 [ # # ]: 0 : WARN_ON(PageChecked(page));
743 [ # # ]: 0 : if (!page_has_buffers(page))
744 : : return 0;
745 [ # # ]: 0 : if (journal)
746 : 0 : return journal_try_to_free_buffers(journal, page,
747 : : wait & ~__GFP_WAIT);
748 : 0 : return try_to_free_buffers(page);
749 : : }
750 : :
751 : : #ifdef CONFIG_QUOTA
752 : : #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
753 : : #define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
754 : :
755 : : static int ext3_write_dquot(struct dquot *dquot);
756 : : static int ext3_acquire_dquot(struct dquot *dquot);
757 : : static int ext3_release_dquot(struct dquot *dquot);
758 : : static int ext3_mark_dquot_dirty(struct dquot *dquot);
759 : : static int ext3_write_info(struct super_block *sb, int type);
760 : : static int ext3_quota_on(struct super_block *sb, int type, int format_id,
761 : : struct path *path);
762 : : static int ext3_quota_on_mount(struct super_block *sb, int type);
763 : : static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
764 : : size_t len, loff_t off);
765 : : static ssize_t ext3_quota_write(struct super_block *sb, int type,
766 : : const char *data, size_t len, loff_t off);
767 : :
768 : : static const struct dquot_operations ext3_quota_operations = {
769 : : .write_dquot = ext3_write_dquot,
770 : : .acquire_dquot = ext3_acquire_dquot,
771 : : .release_dquot = ext3_release_dquot,
772 : : .mark_dirty = ext3_mark_dquot_dirty,
773 : : .write_info = ext3_write_info,
774 : : .alloc_dquot = dquot_alloc,
775 : : .destroy_dquot = dquot_destroy,
776 : : };
777 : :
778 : : static const struct quotactl_ops ext3_qctl_operations = {
779 : : .quota_on = ext3_quota_on,
780 : : .quota_off = dquot_quota_off,
781 : : .quota_sync = dquot_quota_sync,
782 : : .get_info = dquot_get_dqinfo,
783 : : .set_info = dquot_set_dqinfo,
784 : : .get_dqblk = dquot_get_dqblk,
785 : : .set_dqblk = dquot_set_dqblk
786 : : };
787 : : #endif
788 : :
789 : : static const struct super_operations ext3_sops = {
790 : : .alloc_inode = ext3_alloc_inode,
791 : : .destroy_inode = ext3_destroy_inode,
792 : : .write_inode = ext3_write_inode,
793 : : .dirty_inode = ext3_dirty_inode,
794 : : .drop_inode = ext3_drop_inode,
795 : : .evict_inode = ext3_evict_inode,
796 : : .put_super = ext3_put_super,
797 : : .sync_fs = ext3_sync_fs,
798 : : .freeze_fs = ext3_freeze,
799 : : .unfreeze_fs = ext3_unfreeze,
800 : : .statfs = ext3_statfs,
801 : : .remount_fs = ext3_remount,
802 : : .show_options = ext3_show_options,
803 : : #ifdef CONFIG_QUOTA
804 : : .quota_read = ext3_quota_read,
805 : : .quota_write = ext3_quota_write,
806 : : #endif
807 : : .bdev_try_to_free_page = bdev_try_to_free_page,
808 : : };
809 : :
810 : : static const struct export_operations ext3_export_ops = {
811 : : .fh_to_dentry = ext3_fh_to_dentry,
812 : : .fh_to_parent = ext3_fh_to_parent,
813 : : .get_parent = ext3_get_parent,
814 : : };
815 : :
816 : : enum {
817 : : Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
818 : : Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
819 : : Opt_nouid32, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
820 : : Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
821 : : Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
822 : : Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
823 : : Opt_journal_path,
824 : : Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
825 : : Opt_data_err_abort, Opt_data_err_ignore,
826 : : Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
827 : : Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
828 : : Opt_noquota, Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err,
829 : : Opt_resize, Opt_usrquota, Opt_grpquota
830 : : };
831 : :
832 : : static const match_table_t tokens = {
833 : : {Opt_bsd_df, "bsddf"},
834 : : {Opt_minix_df, "minixdf"},
835 : : {Opt_grpid, "grpid"},
836 : : {Opt_grpid, "bsdgroups"},
837 : : {Opt_nogrpid, "nogrpid"},
838 : : {Opt_nogrpid, "sysvgroups"},
839 : : {Opt_resgid, "resgid=%u"},
840 : : {Opt_resuid, "resuid=%u"},
841 : : {Opt_sb, "sb=%u"},
842 : : {Opt_err_cont, "errors=continue"},
843 : : {Opt_err_panic, "errors=panic"},
844 : : {Opt_err_ro, "errors=remount-ro"},
845 : : {Opt_nouid32, "nouid32"},
846 : : {Opt_nocheck, "nocheck"},
847 : : {Opt_nocheck, "check=none"},
848 : : {Opt_debug, "debug"},
849 : : {Opt_oldalloc, "oldalloc"},
850 : : {Opt_orlov, "orlov"},
851 : : {Opt_user_xattr, "user_xattr"},
852 : : {Opt_nouser_xattr, "nouser_xattr"},
853 : : {Opt_acl, "acl"},
854 : : {Opt_noacl, "noacl"},
855 : : {Opt_reservation, "reservation"},
856 : : {Opt_noreservation, "noreservation"},
857 : : {Opt_noload, "noload"},
858 : : {Opt_noload, "norecovery"},
859 : : {Opt_nobh, "nobh"},
860 : : {Opt_bh, "bh"},
861 : : {Opt_commit, "commit=%u"},
862 : : {Opt_journal_update, "journal=update"},
863 : : {Opt_journal_inum, "journal=%u"},
864 : : {Opt_journal_dev, "journal_dev=%u"},
865 : : {Opt_journal_path, "journal_path=%s"},
866 : : {Opt_abort, "abort"},
867 : : {Opt_data_journal, "data=journal"},
868 : : {Opt_data_ordered, "data=ordered"},
869 : : {Opt_data_writeback, "data=writeback"},
870 : : {Opt_data_err_abort, "data_err=abort"},
871 : : {Opt_data_err_ignore, "data_err=ignore"},
872 : : {Opt_offusrjquota, "usrjquota="},
873 : : {Opt_usrjquota, "usrjquota=%s"},
874 : : {Opt_offgrpjquota, "grpjquota="},
875 : : {Opt_grpjquota, "grpjquota=%s"},
876 : : {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
877 : : {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
878 : : {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
879 : : {Opt_grpquota, "grpquota"},
880 : : {Opt_noquota, "noquota"},
881 : : {Opt_quota, "quota"},
882 : : {Opt_usrquota, "usrquota"},
883 : : {Opt_barrier, "barrier=%u"},
884 : : {Opt_barrier, "barrier"},
885 : : {Opt_nobarrier, "nobarrier"},
886 : : {Opt_resize, "resize"},
887 : : {Opt_err, NULL},
888 : : };
889 : :
890 : 0 : static ext3_fsblk_t get_sb_block(void **data, struct super_block *sb)
891 : : {
892 : : ext3_fsblk_t sb_block;
893 : 0 : char *options = (char *) *data;
894 : :
895 [ # # ][ # # ]: 0 : if (!options || strncmp(options, "sb=", 3) != 0)
896 : : return 1; /* Default location */
897 : 0 : options += 3;
898 : : /*todo: use simple_strtoll with >32bit ext3 */
899 : 0 : sb_block = simple_strtoul(options, &options, 0);
900 [ # # ]: 0 : if (*options && *options != ',') {
901 : 0 : ext3_msg(sb, KERN_ERR, "error: invalid sb specification: %s",
902 : : (char *) *data);
903 : 0 : return 1;
904 : : }
905 [ # # ]: 0 : if (*options == ',')
906 : 0 : options++;
907 : 0 : *data = (void *) options;
908 : 0 : return sb_block;
909 : : }
910 : :
911 : : #ifdef CONFIG_QUOTA
912 : 0 : static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
913 : : {
914 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
915 : : char *qname;
916 : :
917 [ # # ][ # # ]: 0 : if (sb_any_quota_loaded(sb) &&
918 : 0 : !sbi->s_qf_names[qtype]) {
919 : 0 : ext3_msg(sb, KERN_ERR,
920 : : "Cannot change journaled "
921 : : "quota options when quota turned on");
922 : 0 : return 0;
923 : : }
924 : 0 : qname = match_strdup(args);
925 [ # # ]: 0 : if (!qname) {
926 : 0 : ext3_msg(sb, KERN_ERR,
927 : : "Not enough memory for storing quotafile name");
928 : 0 : return 0;
929 : : }
930 [ # # ]: 0 : if (sbi->s_qf_names[qtype]) {
931 : 0 : int same = !strcmp(sbi->s_qf_names[qtype], qname);
932 : :
933 : 0 : kfree(qname);
934 [ # # ]: 0 : if (!same) {
935 [ # # ]: 0 : ext3_msg(sb, KERN_ERR,
936 : : "%s quota file already specified",
937 : : QTYPE2NAME(qtype));
938 : : }
939 : 0 : return same;
940 : : }
941 [ # # ]: 0 : if (strchr(qname, '/')) {
942 : 0 : ext3_msg(sb, KERN_ERR,
943 : : "quotafile must be on filesystem root");
944 : 0 : kfree(qname);
945 : 0 : return 0;
946 : : }
947 : 0 : sbi->s_qf_names[qtype] = qname;
948 : 0 : set_opt(sbi->s_mount_opt, QUOTA);
949 : 0 : return 1;
950 : : }
951 : :
952 : 0 : static int clear_qf_name(struct super_block *sb, int qtype) {
953 : :
954 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
955 : :
956 [ # # ][ # # ]: 0 : if (sb_any_quota_loaded(sb) &&
957 : 0 : sbi->s_qf_names[qtype]) {
958 : 0 : ext3_msg(sb, KERN_ERR, "Cannot change journaled quota options"
959 : : " when quota turned on");
960 : 0 : return 0;
961 : : }
962 [ # # ]: 0 : if (sbi->s_qf_names[qtype]) {
963 : 0 : kfree(sbi->s_qf_names[qtype]);
964 : 0 : sbi->s_qf_names[qtype] = NULL;
965 : : }
966 : : return 1;
967 : : }
968 : : #endif
969 : :
970 : 0 : static int parse_options (char *options, struct super_block *sb,
971 : : unsigned int *inum, unsigned long *journal_devnum,
972 : : ext3_fsblk_t *n_blocks_count, int is_remount)
973 : : {
974 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
975 : : char * p;
976 : : substring_t args[MAX_OPT_ARGS];
977 : : int data_opt = 0;
978 : : int option;
979 : : kuid_t uid;
980 : : kgid_t gid;
981 : : char *journal_path;
982 : : struct inode *journal_inode;
983 : : struct path path;
984 : : int error;
985 : :
986 : : #ifdef CONFIG_QUOTA
987 : : int qfmt;
988 : : #endif
989 : :
990 [ # # ]: 0 : if (!options)
991 : : return 1;
992 : :
993 [ # # ]: 0 : while ((p = strsep (&options, ",")) != NULL) {
994 : : int token;
995 [ # # ]: 0 : if (!*p)
996 : 0 : continue;
997 : : /*
998 : : * Initialize args struct so we know whether arg was
999 : : * found; some options take optional arguments.
1000 : : */
1001 : 0 : args[0].to = args[0].from = NULL;
1002 : 0 : token = match_token(p, tokens, args);
1003 [ # # # # : 0 : switch (token) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
1004 : : case Opt_bsd_df:
1005 : 0 : clear_opt (sbi->s_mount_opt, MINIX_DF);
1006 : 0 : break;
1007 : : case Opt_minix_df:
1008 : 0 : set_opt (sbi->s_mount_opt, MINIX_DF);
1009 : 0 : break;
1010 : : case Opt_grpid:
1011 : 0 : set_opt (sbi->s_mount_opt, GRPID);
1012 : 0 : break;
1013 : : case Opt_nogrpid:
1014 : 0 : clear_opt (sbi->s_mount_opt, GRPID);
1015 : 0 : break;
1016 : : case Opt_resuid:
1017 [ # # ]: 0 : if (match_int(&args[0], &option))
1018 : : return 0;
1019 : 0 : uid = make_kuid(current_user_ns(), option);
1020 [ # # ]: 0 : if (!uid_valid(uid)) {
1021 : 0 : ext3_msg(sb, KERN_ERR, "Invalid uid value %d", option);
1022 : 0 : return 0;
1023 : :
1024 : : }
1025 : 0 : sbi->s_resuid = uid;
1026 : 0 : break;
1027 : : case Opt_resgid:
1028 [ # # ]: 0 : if (match_int(&args[0], &option))
1029 : : return 0;
1030 : 0 : gid = make_kgid(current_user_ns(), option);
1031 [ # # ]: 0 : if (!gid_valid(gid)) {
1032 : 0 : ext3_msg(sb, KERN_ERR, "Invalid gid value %d", option);
1033 : 0 : return 0;
1034 : : }
1035 : 0 : sbi->s_resgid = gid;
1036 : 0 : break;
1037 : : case Opt_sb:
1038 : : /* handled by get_sb_block() instead of here */
1039 : : /* *sb_block = match_int(&args[0]); */
1040 : : break;
1041 : : case Opt_err_panic:
1042 : 0 : clear_opt (sbi->s_mount_opt, ERRORS_CONT);
1043 : 0 : clear_opt (sbi->s_mount_opt, ERRORS_RO);
1044 : 0 : set_opt (sbi->s_mount_opt, ERRORS_PANIC);
1045 : 0 : break;
1046 : : case Opt_err_ro:
1047 : 0 : clear_opt (sbi->s_mount_opt, ERRORS_CONT);
1048 : 0 : clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
1049 : 0 : set_opt (sbi->s_mount_opt, ERRORS_RO);
1050 : 0 : break;
1051 : : case Opt_err_cont:
1052 : 0 : clear_opt (sbi->s_mount_opt, ERRORS_RO);
1053 : 0 : clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
1054 : 0 : set_opt (sbi->s_mount_opt, ERRORS_CONT);
1055 : 0 : break;
1056 : : case Opt_nouid32:
1057 : 0 : set_opt (sbi->s_mount_opt, NO_UID32);
1058 : 0 : break;
1059 : : case Opt_nocheck:
1060 : 0 : clear_opt (sbi->s_mount_opt, CHECK);
1061 : 0 : break;
1062 : : case Opt_debug:
1063 : 0 : set_opt (sbi->s_mount_opt, DEBUG);
1064 : 0 : break;
1065 : : case Opt_oldalloc:
1066 : 0 : ext3_msg(sb, KERN_WARNING,
1067 : : "Ignoring deprecated oldalloc option");
1068 : 0 : break;
1069 : : case Opt_orlov:
1070 : 0 : ext3_msg(sb, KERN_WARNING,
1071 : : "Ignoring deprecated orlov option");
1072 : 0 : break;
1073 : : #ifdef CONFIG_EXT3_FS_XATTR
1074 : : case Opt_user_xattr:
1075 : 0 : set_opt (sbi->s_mount_opt, XATTR_USER);
1076 : 0 : break;
1077 : : case Opt_nouser_xattr:
1078 : 0 : clear_opt (sbi->s_mount_opt, XATTR_USER);
1079 : 0 : break;
1080 : : #else
1081 : : case Opt_user_xattr:
1082 : : case Opt_nouser_xattr:
1083 : : ext3_msg(sb, KERN_INFO,
1084 : : "(no)user_xattr options not supported");
1085 : : break;
1086 : : #endif
1087 : : #ifdef CONFIG_EXT3_FS_POSIX_ACL
1088 : : case Opt_acl:
1089 : : set_opt(sbi->s_mount_opt, POSIX_ACL);
1090 : : break;
1091 : : case Opt_noacl:
1092 : : clear_opt(sbi->s_mount_opt, POSIX_ACL);
1093 : : break;
1094 : : #else
1095 : : case Opt_acl:
1096 : : case Opt_noacl:
1097 : 0 : ext3_msg(sb, KERN_INFO,
1098 : : "(no)acl options not supported");
1099 : 0 : break;
1100 : : #endif
1101 : : case Opt_reservation:
1102 : 0 : set_opt(sbi->s_mount_opt, RESERVATION);
1103 : 0 : break;
1104 : : case Opt_noreservation:
1105 : 0 : clear_opt(sbi->s_mount_opt, RESERVATION);
1106 : 0 : break;
1107 : : case Opt_journal_update:
1108 : : /* @@@ FIXME */
1109 : : /* Eventually we will want to be able to create
1110 : : a journal file here. For now, only allow the
1111 : : user to specify an existing inode to be the
1112 : : journal file. */
1113 [ # # ]: 0 : if (is_remount) {
1114 : 0 : ext3_msg(sb, KERN_ERR, "error: cannot specify "
1115 : : "journal on remount");
1116 : 0 : return 0;
1117 : : }
1118 : 0 : set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
1119 : 0 : break;
1120 : : case Opt_journal_inum:
1121 [ # # ]: 0 : if (is_remount) {
1122 : 0 : ext3_msg(sb, KERN_ERR, "error: cannot specify "
1123 : : "journal on remount");
1124 : 0 : return 0;
1125 : : }
1126 [ # # ]: 0 : if (match_int(&args[0], &option))
1127 : : return 0;
1128 : 0 : *inum = option;
1129 : 0 : break;
1130 : : case Opt_journal_dev:
1131 [ # # ]: 0 : if (is_remount) {
1132 : 0 : ext3_msg(sb, KERN_ERR, "error: cannot specify "
1133 : : "journal on remount");
1134 : 0 : return 0;
1135 : : }
1136 [ # # ]: 0 : if (match_int(&args[0], &option))
1137 : : return 0;
1138 : 0 : *journal_devnum = option;
1139 : 0 : break;
1140 : : case Opt_journal_path:
1141 [ # # ]: 0 : if (is_remount) {
1142 : 0 : ext3_msg(sb, KERN_ERR, "error: cannot specify "
1143 : : "journal on remount");
1144 : 0 : return 0;
1145 : : }
1146 : :
1147 : 0 : journal_path = match_strdup(&args[0]);
1148 [ # # ]: 0 : if (!journal_path) {
1149 : 0 : ext3_msg(sb, KERN_ERR, "error: could not dup "
1150 : : "journal device string");
1151 : 0 : return 0;
1152 : : }
1153 : :
1154 : 0 : error = kern_path(journal_path, LOOKUP_FOLLOW, &path);
1155 [ # # ]: 0 : if (error) {
1156 : 0 : ext3_msg(sb, KERN_ERR, "error: could not find "
1157 : : "journal device path: error %d", error);
1158 : 0 : kfree(journal_path);
1159 : 0 : return 0;
1160 : : }
1161 : :
1162 : 0 : journal_inode = path.dentry->d_inode;
1163 [ # # ]: 0 : if (!S_ISBLK(journal_inode->i_mode)) {
1164 : 0 : ext3_msg(sb, KERN_ERR, "error: journal path %s "
1165 : : "is not a block device", journal_path);
1166 : 0 : path_put(&path);
1167 : 0 : kfree(journal_path);
1168 : 0 : return 0;
1169 : : }
1170 : :
1171 : 0 : *journal_devnum = new_encode_dev(journal_inode->i_rdev);
1172 : 0 : path_put(&path);
1173 : 0 : kfree(journal_path);
1174 : 0 : break;
1175 : : case Opt_noload:
1176 : 0 : set_opt (sbi->s_mount_opt, NOLOAD);
1177 : 0 : break;
1178 : : case Opt_commit:
1179 [ # # ]: 0 : if (match_int(&args[0], &option))
1180 : : return 0;
1181 [ # # ]: 0 : if (option < 0)
1182 : : return 0;
1183 [ # # ]: 0 : if (option == 0)
1184 : 0 : option = JBD_DEFAULT_MAX_COMMIT_AGE;
1185 : 0 : sbi->s_commit_interval = HZ * option;
1186 : 0 : break;
1187 : : case Opt_data_journal:
1188 : : data_opt = EXT3_MOUNT_JOURNAL_DATA;
1189 : : goto datacheck;
1190 : : case Opt_data_ordered:
1191 : : data_opt = EXT3_MOUNT_ORDERED_DATA;
1192 : 0 : goto datacheck;
1193 : : case Opt_data_writeback:
1194 : : data_opt = EXT3_MOUNT_WRITEBACK_DATA;
1195 : : datacheck:
1196 [ # # ]: 0 : if (is_remount) {
1197 [ # # ]: 0 : if (test_opt(sb, DATA_FLAGS) == data_opt)
1198 : : break;
1199 : 0 : ext3_msg(sb, KERN_ERR,
1200 : : "error: cannot change "
1201 : : "data mode on remount. The filesystem "
1202 : : "is mounted in data=%s mode and you "
1203 : : "try to remount it in data=%s mode.",
1204 : : data_mode_string(test_opt(sb,
1205 : : DATA_FLAGS)),
1206 : : data_mode_string(data_opt));
1207 : 0 : return 0;
1208 : : } else {
1209 : 0 : clear_opt(sbi->s_mount_opt, DATA_FLAGS);
1210 : 0 : sbi->s_mount_opt |= data_opt;
1211 : : }
1212 : 0 : break;
1213 : : case Opt_data_err_abort:
1214 : 0 : set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1215 : 0 : break;
1216 : : case Opt_data_err_ignore:
1217 : 0 : clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1218 : 0 : break;
1219 : : #ifdef CONFIG_QUOTA
1220 : : case Opt_usrjquota:
1221 [ # # ]: 0 : if (!set_qf_name(sb, USRQUOTA, &args[0]))
1222 : : return 0;
1223 : : break;
1224 : : case Opt_grpjquota:
1225 [ # # ]: 0 : if (!set_qf_name(sb, GRPQUOTA, &args[0]))
1226 : : return 0;
1227 : : break;
1228 : : case Opt_offusrjquota:
1229 [ # # ]: 0 : if (!clear_qf_name(sb, USRQUOTA))
1230 : : return 0;
1231 : : break;
1232 : : case Opt_offgrpjquota:
1233 [ # # ]: 0 : if (!clear_qf_name(sb, GRPQUOTA))
1234 : : return 0;
1235 : : break;
1236 : : case Opt_jqfmt_vfsold:
1237 : : qfmt = QFMT_VFS_OLD;
1238 : : goto set_qf_format;
1239 : : case Opt_jqfmt_vfsv0:
1240 : : qfmt = QFMT_VFS_V0;
1241 : 0 : goto set_qf_format;
1242 : : case Opt_jqfmt_vfsv1:
1243 : : qfmt = QFMT_VFS_V1;
1244 : : set_qf_format:
1245 [ # # ][ # # ]: 0 : if (sb_any_quota_loaded(sb) &&
1246 : 0 : sbi->s_jquota_fmt != qfmt) {
1247 : 0 : ext3_msg(sb, KERN_ERR, "error: cannot change "
1248 : : "journaled quota options when "
1249 : : "quota turned on.");
1250 : 0 : return 0;
1251 : : }
1252 : 0 : sbi->s_jquota_fmt = qfmt;
1253 : 0 : break;
1254 : : case Opt_quota:
1255 : : case Opt_usrquota:
1256 : 0 : set_opt(sbi->s_mount_opt, QUOTA);
1257 : 0 : set_opt(sbi->s_mount_opt, USRQUOTA);
1258 : 0 : break;
1259 : : case Opt_grpquota:
1260 : 0 : set_opt(sbi->s_mount_opt, QUOTA);
1261 : 0 : set_opt(sbi->s_mount_opt, GRPQUOTA);
1262 : 0 : break;
1263 : : case Opt_noquota:
1264 [ # # ]: 0 : if (sb_any_quota_loaded(sb)) {
1265 : 0 : ext3_msg(sb, KERN_ERR, "error: cannot change "
1266 : : "quota options when quota turned on.");
1267 : 0 : return 0;
1268 : : }
1269 : 0 : clear_opt(sbi->s_mount_opt, QUOTA);
1270 : 0 : clear_opt(sbi->s_mount_opt, USRQUOTA);
1271 : 0 : clear_opt(sbi->s_mount_opt, GRPQUOTA);
1272 : 0 : break;
1273 : : #else
1274 : : case Opt_quota:
1275 : : case Opt_usrquota:
1276 : : case Opt_grpquota:
1277 : : ext3_msg(sb, KERN_ERR,
1278 : : "error: quota options not supported.");
1279 : : break;
1280 : : case Opt_usrjquota:
1281 : : case Opt_grpjquota:
1282 : : case Opt_offusrjquota:
1283 : : case Opt_offgrpjquota:
1284 : : case Opt_jqfmt_vfsold:
1285 : : case Opt_jqfmt_vfsv0:
1286 : : case Opt_jqfmt_vfsv1:
1287 : : ext3_msg(sb, KERN_ERR,
1288 : : "error: journaled quota options not "
1289 : : "supported.");
1290 : : break;
1291 : : case Opt_noquota:
1292 : : break;
1293 : : #endif
1294 : : case Opt_abort:
1295 : 0 : set_opt(sbi->s_mount_opt, ABORT);
1296 : 0 : break;
1297 : : case Opt_nobarrier:
1298 : 0 : clear_opt(sbi->s_mount_opt, BARRIER);
1299 : 0 : break;
1300 : : case Opt_barrier:
1301 [ # # ]: 0 : if (args[0].from) {
1302 [ # # ]: 0 : if (match_int(&args[0], &option))
1303 : : return 0;
1304 : : } else
1305 : 0 : option = 1; /* No argument, default to 1 */
1306 [ # # ]: 0 : if (option)
1307 : 0 : set_opt(sbi->s_mount_opt, BARRIER);
1308 : : else
1309 : 0 : clear_opt(sbi->s_mount_opt, BARRIER);
1310 : : break;
1311 : : case Opt_ignore:
1312 : : break;
1313 : : case Opt_resize:
1314 [ # # ]: 0 : if (!is_remount) {
1315 : 0 : ext3_msg(sb, KERN_ERR,
1316 : : "error: resize option only available "
1317 : : "for remount");
1318 : 0 : return 0;
1319 : : }
1320 [ # # ]: 0 : if (match_int(&args[0], &option) != 0)
1321 : : return 0;
1322 : 0 : *n_blocks_count = option;
1323 : 0 : break;
1324 : : case Opt_nobh:
1325 : 0 : ext3_msg(sb, KERN_WARNING,
1326 : : "warning: ignoring deprecated nobh option");
1327 : 0 : break;
1328 : : case Opt_bh:
1329 : 0 : ext3_msg(sb, KERN_WARNING,
1330 : : "warning: ignoring deprecated bh option");
1331 : 0 : break;
1332 : : default:
1333 : 0 : ext3_msg(sb, KERN_ERR,
1334 : : "error: unrecognized mount option \"%s\" "
1335 : : "or missing value", p);
1336 : 0 : return 0;
1337 : : }
1338 : : }
1339 : : #ifdef CONFIG_QUOTA
1340 [ # # ][ # # ]: 0 : if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
1341 [ # # ][ # # ]: 0 : if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA])
1342 : 0 : clear_opt(sbi->s_mount_opt, USRQUOTA);
1343 [ # # ][ # # ]: 0 : if (test_opt(sb, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA])
1344 : 0 : clear_opt(sbi->s_mount_opt, GRPQUOTA);
1345 : :
1346 [ # # ][ # # ]: 0 : if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
1347 : 0 : ext3_msg(sb, KERN_ERR, "error: old and new quota "
1348 : : "format mixing.");
1349 : 0 : return 0;
1350 : : }
1351 : :
1352 [ # # ]: 0 : if (!sbi->s_jquota_fmt) {
1353 : 0 : ext3_msg(sb, KERN_ERR, "error: journaled quota format "
1354 : : "not specified.");
1355 : 0 : return 0;
1356 : : }
1357 : : } else {
1358 [ # # ]: 0 : if (sbi->s_jquota_fmt) {
1359 : 0 : ext3_msg(sb, KERN_ERR, "error: journaled quota format "
1360 : : "specified with no journaling "
1361 : : "enabled.");
1362 : 0 : return 0;
1363 : : }
1364 : : }
1365 : : #endif
1366 : : return 1;
1367 : : }
1368 : :
1369 : 0 : static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
1370 : : int read_only)
1371 : : {
1372 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
1373 : : int res = 0;
1374 : :
1375 [ # # ]: 0 : if (le32_to_cpu(es->s_rev_level) > EXT3_MAX_SUPP_REV) {
1376 : 0 : ext3_msg(sb, KERN_ERR,
1377 : : "error: revision level too high, "
1378 : : "forcing read-only mode");
1379 : : res = MS_RDONLY;
1380 : : }
1381 [ # # ]: 0 : if (read_only)
1382 : : return res;
1383 [ # # ]: 0 : if (!(sbi->s_mount_state & EXT3_VALID_FS))
1384 : 0 : ext3_msg(sb, KERN_WARNING,
1385 : : "warning: mounting unchecked fs, "
1386 : : "running e2fsck is recommended");
1387 [ # # ]: 0 : else if ((sbi->s_mount_state & EXT3_ERROR_FS))
1388 : 0 : ext3_msg(sb, KERN_WARNING,
1389 : : "warning: mounting fs with errors, "
1390 : : "running e2fsck is recommended");
1391 [ # # ][ # # ]: 0 : else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
1392 : 0 : le16_to_cpu(es->s_mnt_count) >=
1393 : : le16_to_cpu(es->s_max_mnt_count))
1394 : 0 : ext3_msg(sb, KERN_WARNING,
1395 : : "warning: maximal mount count reached, "
1396 : : "running e2fsck is recommended");
1397 [ # # # # ]: 0 : else if (le32_to_cpu(es->s_checkinterval) &&
1398 : 0 : (le32_to_cpu(es->s_lastcheck) +
1399 : 0 : le32_to_cpu(es->s_checkinterval) <= get_seconds()))
1400 : 0 : ext3_msg(sb, KERN_WARNING,
1401 : : "warning: checktime reached, "
1402 : : "running e2fsck is recommended");
1403 : : #if 0
1404 : : /* @@@ We _will_ want to clear the valid bit if we find
1405 : : inconsistencies, to force a fsck at reboot. But for
1406 : : a plain journaled filesystem we can keep it set as
1407 : : valid forever! :) */
1408 : : es->s_state &= cpu_to_le16(~EXT3_VALID_FS);
1409 : : #endif
1410 [ # # ]: 0 : if (!le16_to_cpu(es->s_max_mnt_count))
1411 : 0 : es->s_max_mnt_count = cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
1412 : : le16_add_cpu(&es->s_mnt_count, 1);
1413 : 0 : es->s_mtime = cpu_to_le32(get_seconds());
1414 : 0 : ext3_update_dynamic_rev(sb);
1415 : 0 : EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
1416 : :
1417 : 0 : ext3_commit_super(sb, es, 1);
1418 [ # # ]: 0 : if (test_opt(sb, DEBUG))
1419 : 0 : ext3_msg(sb, KERN_INFO, "[bs=%lu, gc=%lu, "
1420 : : "bpg=%lu, ipg=%lu, mo=%04lx]",
1421 : : sb->s_blocksize,
1422 : : sbi->s_groups_count,
1423 : : EXT3_BLOCKS_PER_GROUP(sb),
1424 : : EXT3_INODES_PER_GROUP(sb),
1425 : : sbi->s_mount_opt);
1426 : :
1427 [ # # ]: 0 : if (EXT3_SB(sb)->s_journal->j_inode == NULL) {
1428 : : char b[BDEVNAME_SIZE];
1429 : 0 : ext3_msg(sb, KERN_INFO, "using external journal on %s",
1430 : : bdevname(EXT3_SB(sb)->s_journal->j_dev, b));
1431 : : } else {
1432 : 0 : ext3_msg(sb, KERN_INFO, "using internal journal");
1433 : : }
1434 : : cleancache_init_fs(sb);
1435 : : return res;
1436 : : }
1437 : :
1438 : : /* Called at mount-time, super-block is locked */
1439 : 0 : static int ext3_check_descriptors(struct super_block *sb)
1440 : : {
1441 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
1442 : : int i;
1443 : :
1444 : : ext3_debug ("Checking group descriptors");
1445 : :
1446 [ # # ]: 0 : for (i = 0; i < sbi->s_groups_count; i++) {
1447 : 0 : struct ext3_group_desc *gdp = ext3_get_group_desc(sb, i, NULL);
1448 : : ext3_fsblk_t first_block = ext3_group_first_block_no(sb, i);
1449 : : ext3_fsblk_t last_block;
1450 : :
1451 [ # # ]: 0 : if (i == sbi->s_groups_count - 1)
1452 : 0 : last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
1453 : : else
1454 : 0 : last_block = first_block +
1455 : : (EXT3_BLOCKS_PER_GROUP(sb) - 1);
1456 : :
1457 [ # # ][ # # ]: 0 : if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
1458 : : le32_to_cpu(gdp->bg_block_bitmap) > last_block)
1459 : : {
1460 : 0 : ext3_error (sb, "ext3_check_descriptors",
1461 : : "Block bitmap for group %d"
1462 : : " not in group (block %lu)!",
1463 : : i, (unsigned long)
1464 : : le32_to_cpu(gdp->bg_block_bitmap));
1465 : 0 : return 0;
1466 : : }
1467 [ # # ][ # # ]: 0 : if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
1468 : : le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
1469 : : {
1470 : 0 : ext3_error (sb, "ext3_check_descriptors",
1471 : : "Inode bitmap for group %d"
1472 : : " not in group (block %lu)!",
1473 : : i, (unsigned long)
1474 : : le32_to_cpu(gdp->bg_inode_bitmap));
1475 : 0 : return 0;
1476 : : }
1477 [ # # ][ # # ]: 0 : if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
1478 : 0 : le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 >
1479 : : last_block)
1480 : : {
1481 : 0 : ext3_error (sb, "ext3_check_descriptors",
1482 : : "Inode table for group %d"
1483 : : " not in group (block %lu)!",
1484 : : i, (unsigned long)
1485 : : le32_to_cpu(gdp->bg_inode_table));
1486 : 0 : return 0;
1487 : : }
1488 : : }
1489 : :
1490 : 0 : sbi->s_es->s_free_blocks_count=cpu_to_le32(ext3_count_free_blocks(sb));
1491 : 0 : sbi->s_es->s_free_inodes_count=cpu_to_le32(ext3_count_free_inodes(sb));
1492 : 0 : return 1;
1493 : : }
1494 : :
1495 : :
1496 : : /* ext3_orphan_cleanup() walks a singly-linked list of inodes (starting at
1497 : : * the superblock) which were deleted from all directories, but held open by
1498 : : * a process at the time of a crash. We walk the list and try to delete these
1499 : : * inodes at recovery time (only with a read-write filesystem).
1500 : : *
1501 : : * In order to keep the orphan inode chain consistent during traversal (in
1502 : : * case of crash during recovery), we link each inode into the superblock
1503 : : * orphan list_head and handle it the same way as an inode deletion during
1504 : : * normal operation (which journals the operations for us).
1505 : : *
1506 : : * We only do an iget() and an iput() on each inode, which is very safe if we
1507 : : * accidentally point at an in-use or already deleted inode. The worst that
1508 : : * can happen in this case is that we get a "bit already cleared" message from
1509 : : * ext3_free_inode(). The only reason we would point at a wrong inode is if
1510 : : * e2fsck was run on this filesystem, and it must have already done the orphan
1511 : : * inode cleanup for us, so we can safely abort without any further action.
1512 : : */
1513 : 0 : static void ext3_orphan_cleanup (struct super_block * sb,
1514 : : struct ext3_super_block * es)
1515 : : {
1516 : 0 : unsigned int s_flags = sb->s_flags;
1517 : : int nr_orphans = 0, nr_truncates = 0;
1518 : : #ifdef CONFIG_QUOTA
1519 : : int i;
1520 : : #endif
1521 [ # # ]: 0 : if (!es->s_last_orphan) {
1522 : : jbd_debug(4, "no orphan inodes to clean up\n");
1523 : : return;
1524 : : }
1525 : :
1526 [ # # ]: 0 : if (bdev_read_only(sb->s_bdev)) {
1527 : 0 : ext3_msg(sb, KERN_ERR, "error: write access "
1528 : : "unavailable, skipping orphan cleanup.");
1529 : : return;
1530 : : }
1531 : :
1532 : : /* Check if feature set allows readwrite operations */
1533 [ # # ]: 0 : if (EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP)) {
1534 : 0 : ext3_msg(sb, KERN_INFO, "Skipping orphan cleanup due to "
1535 : : "unknown ROCOMPAT features");
1536 : : return;
1537 : : }
1538 : :
1539 [ # # ]: 0 : if (EXT3_SB(sb)->s_mount_state & EXT3_ERROR_FS) {
1540 : : /* don't clear list on RO mount w/ errors */
1541 [ # # ][ # # ]: 0 : if (es->s_last_orphan && !(s_flags & MS_RDONLY)) {
1542 : : jbd_debug(1, "Errors on filesystem, "
1543 : : "clearing orphan list.\n");
1544 : 0 : es->s_last_orphan = 0;
1545 : : }
1546 : : jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
1547 : : return;
1548 : : }
1549 : :
1550 [ # # ]: 0 : if (s_flags & MS_RDONLY) {
1551 : 0 : ext3_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
1552 : 0 : sb->s_flags &= ~MS_RDONLY;
1553 : : }
1554 : : #ifdef CONFIG_QUOTA
1555 : : /* Needed for iput() to work correctly and not trash data */
1556 : 0 : sb->s_flags |= MS_ACTIVE;
1557 : : /* Turn on quotas so that they are updated correctly */
1558 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
1559 [ # # ]: 0 : if (EXT3_SB(sb)->s_qf_names[i]) {
1560 : : int ret = ext3_quota_on_mount(sb, i);
1561 [ # # ]: 0 : if (ret < 0)
1562 : 0 : ext3_msg(sb, KERN_ERR,
1563 : : "error: cannot turn on journaled "
1564 : : "quota: %d", ret);
1565 : : }
1566 : : }
1567 : : #endif
1568 : :
1569 [ # # ]: 0 : while (es->s_last_orphan) {
1570 : : struct inode *inode;
1571 : :
1572 : 0 : inode = ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
1573 [ # # ]: 0 : if (IS_ERR(inode)) {
1574 : 0 : es->s_last_orphan = 0;
1575 : : break;
1576 : : }
1577 : :
1578 : 0 : list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
1579 : 0 : dquot_initialize(inode);
1580 [ # # ]: 0 : if (inode->i_nlink) {
1581 : 0 : printk(KERN_DEBUG
1582 : : "%s: truncating inode %lu to %Ld bytes\n",
1583 : : __func__, inode->i_ino, inode->i_size);
1584 : : jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
1585 : : inode->i_ino, inode->i_size);
1586 : 0 : ext3_truncate(inode);
1587 : 0 : nr_truncates++;
1588 : : } else {
1589 : 0 : printk(KERN_DEBUG
1590 : : "%s: deleting unreferenced inode %lu\n",
1591 : : __func__, inode->i_ino);
1592 : : jbd_debug(2, "deleting unreferenced inode %lu\n",
1593 : : inode->i_ino);
1594 : 0 : nr_orphans++;
1595 : : }
1596 : 0 : iput(inode); /* The delete magic happens here! */
1597 : : }
1598 : :
1599 : : #define PLURAL(x) (x), ((x)==1) ? "" : "s"
1600 : :
1601 [ # # ]: 0 : if (nr_orphans)
1602 [ # # ]: 0 : ext3_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
1603 : : PLURAL(nr_orphans));
1604 [ # # ]: 0 : if (nr_truncates)
1605 [ # # ]: 0 : ext3_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
1606 : : PLURAL(nr_truncates));
1607 : : #ifdef CONFIG_QUOTA
1608 : : /* Turn quotas off */
1609 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
1610 [ # # ]: 0 : if (sb_dqopt(sb)->files[i])
1611 : 0 : dquot_quota_off(sb, i);
1612 : : }
1613 : : #endif
1614 : 0 : sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1615 : : }
1616 : :
1617 : : /*
1618 : : * Maximal file size. There is a direct, and {,double-,triple-}indirect
1619 : : * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
1620 : : * We need to be 1 filesystem block less than the 2^32 sector limit.
1621 : : */
1622 : 0 : static loff_t ext3_max_size(int bits)
1623 : : {
1624 : : loff_t res = EXT3_NDIR_BLOCKS;
1625 : : int meta_blocks;
1626 : : loff_t upper_limit;
1627 : :
1628 : : /* This is calculated to be the largest file size for a
1629 : : * dense, file such that the total number of
1630 : : * sectors in the file, including data and all indirect blocks,
1631 : : * does not exceed 2^32 -1
1632 : : * __u32 i_blocks representing the total number of
1633 : : * 512 bytes blocks of the file
1634 : : */
1635 : : upper_limit = (1LL << 32) - 1;
1636 : :
1637 : : /* total blocks in file system block size */
1638 : 0 : upper_limit >>= (bits - 9);
1639 : :
1640 : :
1641 : : /* indirect blocks */
1642 : : meta_blocks = 1;
1643 : : /* double indirect blocks */
1644 : 0 : meta_blocks += 1 + (1LL << (bits-2));
1645 : : /* tripple indirect blocks */
1646 : 0 : meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
1647 : :
1648 : 0 : upper_limit -= meta_blocks;
1649 : 0 : upper_limit <<= bits;
1650 : :
1651 : 0 : res += 1LL << (bits-2);
1652 : 0 : res += 1LL << (2*(bits-2));
1653 : 0 : res += 1LL << (3*(bits-2));
1654 : 0 : res <<= bits;
1655 [ # # ]: 0 : if (res > upper_limit)
1656 : : res = upper_limit;
1657 : :
1658 [ # # ]: 0 : if (res > MAX_LFS_FILESIZE)
1659 : : res = MAX_LFS_FILESIZE;
1660 : :
1661 : 0 : return res;
1662 : : }
1663 : :
1664 : 0 : static ext3_fsblk_t descriptor_loc(struct super_block *sb,
1665 : : ext3_fsblk_t logic_sb_block,
1666 : : int nr)
1667 : : {
1668 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
1669 : : unsigned long bg, first_meta_bg;
1670 : : int has_super = 0;
1671 : :
1672 : 0 : first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
1673 : :
1674 [ # # ][ # # ]: 0 : if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
1675 : 0 : nr < first_meta_bg)
1676 : 0 : return (logic_sb_block + nr + 1);
1677 : 0 : bg = sbi->s_desc_per_block * nr;
1678 [ # # ]: 0 : if (ext3_bg_has_super(sb, bg))
1679 : : has_super = 1;
1680 : 0 : return (has_super + ext3_group_first_block_no(sb, bg));
1681 : : }
1682 : :
1683 : :
1684 : 0 : static int ext3_fill_super (struct super_block *sb, void *data, int silent)
1685 : : {
1686 : : struct buffer_head * bh;
1687 : : struct ext3_super_block *es = NULL;
1688 : : struct ext3_sb_info *sbi;
1689 : : ext3_fsblk_t block;
1690 : 0 : ext3_fsblk_t sb_block = get_sb_block(&data, sb);
1691 : : ext3_fsblk_t logic_sb_block;
1692 : : unsigned long offset = 0;
1693 : 0 : unsigned int journal_inum = 0;
1694 : 0 : unsigned long journal_devnum = 0;
1695 : : unsigned long def_mount_opts;
1696 : : struct inode *root;
1697 : : int blocksize;
1698 : : int hblock;
1699 : : int db_count;
1700 : : int i;
1701 : : int needs_recovery;
1702 : : int ret = -EINVAL;
1703 : : __le32 features;
1704 : : int err;
1705 : :
1706 : : sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
1707 [ # # ]: 0 : if (!sbi)
1708 : : return -ENOMEM;
1709 : :
1710 : 0 : sbi->s_blockgroup_lock =
1711 : : kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
1712 [ # # ]: 0 : if (!sbi->s_blockgroup_lock) {
1713 : 0 : kfree(sbi);
1714 : 0 : return -ENOMEM;
1715 : : }
1716 : 0 : sb->s_fs_info = sbi;
1717 : 0 : sbi->s_sb_block = sb_block;
1718 : :
1719 : 0 : blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
1720 [ # # ]: 0 : if (!blocksize) {
1721 : 0 : ext3_msg(sb, KERN_ERR, "error: unable to set blocksize");
1722 : 0 : goto out_fail;
1723 : : }
1724 : :
1725 : : /*
1726 : : * The ext3 superblock will not be buffer aligned for other than 1kB
1727 : : * block sizes. We need to calculate the offset from buffer start.
1728 : : */
1729 [ # # ]: 0 : if (blocksize != EXT3_MIN_BLOCK_SIZE) {
1730 : 0 : logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
1731 : 0 : offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
1732 : : } else {
1733 : : logic_sb_block = sb_block;
1734 : : }
1735 : :
1736 [ # # ]: 0 : if (!(bh = sb_bread(sb, logic_sb_block))) {
1737 : 0 : ext3_msg(sb, KERN_ERR, "error: unable to read superblock");
1738 : 0 : goto out_fail;
1739 : : }
1740 : : /*
1741 : : * Note: s_es must be initialized as soon as possible because
1742 : : * some ext3 macro-instructions depend on its value
1743 : : */
1744 : 0 : es = (struct ext3_super_block *) (bh->b_data + offset);
1745 : 0 : sbi->s_es = es;
1746 : 0 : sb->s_magic = le16_to_cpu(es->s_magic);
1747 [ # # ]: 0 : if (sb->s_magic != EXT3_SUPER_MAGIC)
1748 : : goto cantfind_ext3;
1749 : :
1750 : : /* Set defaults before we parse the mount options */
1751 : 0 : def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
1752 [ # # ]: 0 : if (def_mount_opts & EXT3_DEFM_DEBUG)
1753 : 0 : set_opt(sbi->s_mount_opt, DEBUG);
1754 [ # # ]: 0 : if (def_mount_opts & EXT3_DEFM_BSDGROUPS)
1755 : 0 : set_opt(sbi->s_mount_opt, GRPID);
1756 [ # # ]: 0 : if (def_mount_opts & EXT3_DEFM_UID16)
1757 : 0 : set_opt(sbi->s_mount_opt, NO_UID32);
1758 : : #ifdef CONFIG_EXT3_FS_XATTR
1759 [ # # ]: 0 : if (def_mount_opts & EXT3_DEFM_XATTR_USER)
1760 : 0 : set_opt(sbi->s_mount_opt, XATTR_USER);
1761 : : #endif
1762 : : #ifdef CONFIG_EXT3_FS_POSIX_ACL
1763 : : if (def_mount_opts & EXT3_DEFM_ACL)
1764 : : set_opt(sbi->s_mount_opt, POSIX_ACL);
1765 : : #endif
1766 [ # # ]: 0 : if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_DATA)
1767 : 0 : set_opt(sbi->s_mount_opt, JOURNAL_DATA);
1768 [ # # ]: 0 : else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_ORDERED)
1769 : 0 : set_opt(sbi->s_mount_opt, ORDERED_DATA);
1770 [ # # ]: 0 : else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_WBACK)
1771 : 0 : set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
1772 : :
1773 [ # # ]: 0 : if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_PANIC)
1774 : 0 : set_opt(sbi->s_mount_opt, ERRORS_PANIC);
1775 [ # # ]: 0 : else if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_CONTINUE)
1776 : 0 : set_opt(sbi->s_mount_opt, ERRORS_CONT);
1777 : : else
1778 : 0 : set_opt(sbi->s_mount_opt, ERRORS_RO);
1779 : :
1780 : 0 : sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
1781 : 0 : sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
1782 : :
1783 : : /* enable barriers by default */
1784 : 0 : set_opt(sbi->s_mount_opt, BARRIER);
1785 : 0 : set_opt(sbi->s_mount_opt, RESERVATION);
1786 : :
1787 [ # # ]: 0 : if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
1788 : : NULL, 0))
1789 : : goto failed_mount;
1790 : :
1791 [ # # ]: 0 : sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1792 : 0 : (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
1793 : :
1794 [ # # ][ # # ]: 0 : if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV &&
1795 [ # # ]: 0 : (EXT3_HAS_COMPAT_FEATURE(sb, ~0U) ||
1796 [ # # ]: 0 : EXT3_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
1797 : 0 : EXT3_HAS_INCOMPAT_FEATURE(sb, ~0U)))
1798 : 0 : ext3_msg(sb, KERN_WARNING,
1799 : : "warning: feature flags set on rev 0 fs, "
1800 : : "running e2fsck is recommended");
1801 : : /*
1802 : : * Check feature flags regardless of the revision level, since we
1803 : : * previously didn't change the revision level when setting the flags,
1804 : : * so there is a chance incompat flags are set on a rev 0 filesystem.
1805 : : */
1806 : 0 : features = EXT3_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP);
1807 [ # # ]: 0 : if (features) {
1808 : 0 : ext3_msg(sb, KERN_ERR,
1809 : : "error: couldn't mount because of unsupported "
1810 : : "optional features (%x)", le32_to_cpu(features));
1811 : 0 : goto failed_mount;
1812 : : }
1813 : 0 : features = EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP);
1814 [ # # ][ # # ]: 0 : if (!(sb->s_flags & MS_RDONLY) && features) {
1815 : 0 : ext3_msg(sb, KERN_ERR,
1816 : : "error: couldn't mount RDWR because of unsupported "
1817 : : "optional features (%x)", le32_to_cpu(features));
1818 : 0 : goto failed_mount;
1819 : : }
1820 : 0 : blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
1821 : :
1822 [ # # ]: 0 : if (blocksize < EXT3_MIN_BLOCK_SIZE ||
1823 : : blocksize > EXT3_MAX_BLOCK_SIZE) {
1824 : 0 : ext3_msg(sb, KERN_ERR,
1825 : : "error: couldn't mount because of unsupported "
1826 : : "filesystem blocksize %d", blocksize);
1827 : 0 : goto failed_mount;
1828 : : }
1829 : :
1830 : 0 : hblock = bdev_logical_block_size(sb->s_bdev);
1831 [ # # ]: 0 : if (sb->s_blocksize != blocksize) {
1832 : : /*
1833 : : * Make sure the blocksize for the filesystem is larger
1834 : : * than the hardware sectorsize for the machine.
1835 : : */
1836 [ # # ]: 0 : if (blocksize < hblock) {
1837 : 0 : ext3_msg(sb, KERN_ERR,
1838 : : "error: fsblocksize %d too small for "
1839 : : "hardware sectorsize %d", blocksize, hblock);
1840 : 0 : goto failed_mount;
1841 : : }
1842 : :
1843 : : brelse (bh);
1844 [ # # ]: 0 : if (!sb_set_blocksize(sb, blocksize)) {
1845 : 0 : ext3_msg(sb, KERN_ERR,
1846 : : "error: bad blocksize %d", blocksize);
1847 : 0 : goto out_fail;
1848 : : }
1849 : 0 : logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
1850 : 0 : offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
1851 : 0 : bh = sb_bread(sb, logic_sb_block);
1852 [ # # ]: 0 : if (!bh) {
1853 : 0 : ext3_msg(sb, KERN_ERR,
1854 : : "error: can't read superblock on 2nd try");
1855 : 0 : goto failed_mount;
1856 : : }
1857 : 0 : es = (struct ext3_super_block *)(bh->b_data + offset);
1858 : 0 : sbi->s_es = es;
1859 [ # # ]: 0 : if (es->s_magic != cpu_to_le16(EXT3_SUPER_MAGIC)) {
1860 : 0 : ext3_msg(sb, KERN_ERR,
1861 : : "error: magic mismatch");
1862 : 0 : goto failed_mount;
1863 : : }
1864 : : }
1865 : :
1866 : 0 : sb->s_maxbytes = ext3_max_size(sb->s_blocksize_bits);
1867 : :
1868 [ # # ]: 0 : if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV) {
1869 : 0 : sbi->s_inode_size = EXT3_GOOD_OLD_INODE_SIZE;
1870 : 0 : sbi->s_first_ino = EXT3_GOOD_OLD_FIRST_INO;
1871 : : } else {
1872 : 0 : sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
1873 : 0 : sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
1874 [ # # ][ # # ]: 0 : if ((sbi->s_inode_size < EXT3_GOOD_OLD_INODE_SIZE) ||
1875 [ # # ]: 0 : (!is_power_of_2(sbi->s_inode_size)) ||
1876 : : (sbi->s_inode_size > blocksize)) {
1877 : 0 : ext3_msg(sb, KERN_ERR,
1878 : : "error: unsupported inode size: %d",
1879 : : sbi->s_inode_size);
1880 : 0 : goto failed_mount;
1881 : : }
1882 : : }
1883 : 0 : sbi->s_frag_size = EXT3_MIN_FRAG_SIZE <<
1884 : 0 : le32_to_cpu(es->s_log_frag_size);
1885 [ # # ]: 0 : if (blocksize != sbi->s_frag_size) {
1886 : 0 : ext3_msg(sb, KERN_ERR,
1887 : : "error: fragsize %lu != blocksize %u (unsupported)",
1888 : : sbi->s_frag_size, blocksize);
1889 : 0 : goto failed_mount;
1890 : : }
1891 : 0 : sbi->s_frags_per_block = 1;
1892 : 0 : sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
1893 : 0 : sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
1894 : 0 : sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
1895 [ # # ][ # # ]: 0 : if (EXT3_INODE_SIZE(sb) == 0 || EXT3_INODES_PER_GROUP(sb) == 0)
1896 : : goto cantfind_ext3;
1897 : 0 : sbi->s_inodes_per_block = blocksize / EXT3_INODE_SIZE(sb);
1898 [ # # ]: 0 : if (sbi->s_inodes_per_block == 0)
1899 : : goto cantfind_ext3;
1900 : 0 : sbi->s_itb_per_group = sbi->s_inodes_per_group /
1901 : : sbi->s_inodes_per_block;
1902 : 0 : sbi->s_desc_per_block = blocksize / sizeof(struct ext3_group_desc);
1903 : 0 : sbi->s_sbh = bh;
1904 : 0 : sbi->s_mount_state = le16_to_cpu(es->s_state);
1905 [ # # ][ # # ]: 0 : sbi->s_addr_per_block_bits = ilog2(EXT3_ADDR_PER_BLOCK(sb));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1906 : 0 : sbi->s_desc_per_block_bits = ilog2(EXT3_DESC_PER_BLOCK(sb));
1907 [ # # ]: 0 : for (i=0; i < 4; i++)
1908 : 0 : sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
1909 : 0 : sbi->s_def_hash_version = es->s_def_hash_version;
1910 : 0 : i = le32_to_cpu(es->s_flags);
1911 [ # # ]: 0 : if (i & EXT2_FLAGS_UNSIGNED_HASH)
1912 : 0 : sbi->s_hash_unsigned = 3;
1913 [ # # ]: 0 : else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
1914 : : #ifdef __CHAR_UNSIGNED__
1915 : 0 : es->s_flags |= cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
1916 : 0 : sbi->s_hash_unsigned = 3;
1917 : : #else
1918 : : es->s_flags |= cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
1919 : : #endif
1920 : : }
1921 : :
1922 [ # # ]: 0 : if (sbi->s_blocks_per_group > blocksize * 8) {
1923 : 0 : ext3_msg(sb, KERN_ERR,
1924 : : "#blocks per group too big: %lu",
1925 : : sbi->s_blocks_per_group);
1926 : 0 : goto failed_mount;
1927 : : }
1928 [ # # ]: 0 : if (sbi->s_frags_per_group > blocksize * 8) {
1929 : 0 : ext3_msg(sb, KERN_ERR,
1930 : : "error: #fragments per group too big: %lu",
1931 : : sbi->s_frags_per_group);
1932 : 0 : goto failed_mount;
1933 : : }
1934 [ # # ]: 0 : if (sbi->s_inodes_per_group > blocksize * 8) {
1935 : 0 : ext3_msg(sb, KERN_ERR,
1936 : : "error: #inodes per group too big: %lu",
1937 : : sbi->s_inodes_per_group);
1938 : 0 : goto failed_mount;
1939 : : }
1940 : :
1941 : 0 : err = generic_check_addressable(sb->s_blocksize_bits,
1942 : 0 : le32_to_cpu(es->s_blocks_count));
1943 [ # # ]: 0 : if (err) {
1944 : 0 : ext3_msg(sb, KERN_ERR,
1945 : : "error: filesystem is too large to mount safely");
1946 : : if (sizeof(sector_t) < 8)
1947 : : ext3_msg(sb, KERN_ERR,
1948 : : "error: CONFIG_LBDAF not enabled");
1949 : : ret = err;
1950 : 0 : goto failed_mount;
1951 : : }
1952 : :
1953 [ # # ]: 0 : if (EXT3_BLOCKS_PER_GROUP(sb) == 0)
1954 : : goto cantfind_ext3;
1955 : 0 : sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
1956 : 0 : le32_to_cpu(es->s_first_data_block) - 1)
1957 : 0 : / EXT3_BLOCKS_PER_GROUP(sb)) + 1;
1958 : 0 : db_count = DIV_ROUND_UP(sbi->s_groups_count, EXT3_DESC_PER_BLOCK(sb));
1959 : 0 : sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
1960 : : GFP_KERNEL);
1961 [ # # ]: 0 : if (sbi->s_group_desc == NULL) {
1962 : 0 : ext3_msg(sb, KERN_ERR,
1963 : : "error: not enough memory");
1964 : : ret = -ENOMEM;
1965 : 0 : goto failed_mount;
1966 : : }
1967 : :
1968 : 0 : bgl_lock_init(sbi->s_blockgroup_lock);
1969 : :
1970 [ # # ]: 0 : for (i = 0; i < db_count; i++) {
1971 : 0 : block = descriptor_loc(sb, logic_sb_block, i);
1972 : 0 : sbi->s_group_desc[i] = sb_bread(sb, block);
1973 [ # # ]: 0 : if (!sbi->s_group_desc[i]) {
1974 : 0 : ext3_msg(sb, KERN_ERR,
1975 : : "error: can't read group descriptor %d", i);
1976 : : db_count = i;
1977 : 0 : goto failed_mount2;
1978 : : }
1979 : : }
1980 [ # # ]: 0 : if (!ext3_check_descriptors (sb)) {
1981 : 0 : ext3_msg(sb, KERN_ERR,
1982 : : "error: group descriptors corrupted");
1983 : 0 : goto failed_mount2;
1984 : : }
1985 : 0 : sbi->s_gdb_count = db_count;
1986 : 0 : get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1987 : 0 : spin_lock_init(&sbi->s_next_gen_lock);
1988 : :
1989 : : /* per fileystem reservation list head & lock */
1990 : 0 : spin_lock_init(&sbi->s_rsv_window_lock);
1991 : 0 : sbi->s_rsv_window_root = RB_ROOT;
1992 : : /* Add a single, static dummy reservation to the start of the
1993 : : * reservation window list --- it gives us a placeholder for
1994 : : * append-at-start-of-list which makes the allocation logic
1995 : : * _much_ simpler. */
1996 : 0 : sbi->s_rsv_window_head.rsv_start = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
1997 : 0 : sbi->s_rsv_window_head.rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
1998 : 0 : sbi->s_rsv_window_head.rsv_alloc_hit = 0;
1999 : 0 : sbi->s_rsv_window_head.rsv_goal_size = 0;
2000 : 0 : ext3_rsv_window_add(sb, &sbi->s_rsv_window_head);
2001 : :
2002 : : /*
2003 : : * set up enough so that it can read an inode
2004 : : */
2005 : 0 : sb->s_op = &ext3_sops;
2006 : 0 : sb->s_export_op = &ext3_export_ops;
2007 : 0 : sb->s_xattr = ext3_xattr_handlers;
2008 : : #ifdef CONFIG_QUOTA
2009 : 0 : sb->s_qcop = &ext3_qctl_operations;
2010 : 0 : sb->dq_op = &ext3_quota_operations;
2011 : : #endif
2012 : 0 : memcpy(sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
2013 : 0 : INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
2014 : 0 : mutex_init(&sbi->s_orphan_lock);
2015 : 0 : mutex_init(&sbi->s_resize_lock);
2016 : :
2017 : 0 : sb->s_root = NULL;
2018 : :
2019 [ # # ][ # # ]: 0 : needs_recovery = (es->s_last_orphan != 0 ||
2020 : 0 : EXT3_HAS_INCOMPAT_FEATURE(sb,
2021 : : EXT3_FEATURE_INCOMPAT_RECOVER));
2022 : :
2023 : : /*
2024 : : * The first inode we look at is the journal inode. Don't try
2025 : : * root first: it may be modified in the journal!
2026 : : */
2027 [ # # ][ # # ]: 0 : if (!test_opt(sb, NOLOAD) &&
2028 : 0 : EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
2029 [ # # ]: 0 : if (ext3_load_journal(sb, es, journal_devnum))
2030 : : goto failed_mount2;
2031 [ # # ]: 0 : } else if (journal_inum) {
2032 [ # # ]: 0 : if (ext3_create_journal(sb, es, journal_inum))
2033 : : goto failed_mount2;
2034 : : } else {
2035 [ # # ]: 0 : if (!silent)
2036 : 0 : ext3_msg(sb, KERN_ERR,
2037 : : "error: no journal found. "
2038 : : "mounting ext3 over ext2?");
2039 : : goto failed_mount2;
2040 : : }
2041 : 0 : err = percpu_counter_init(&sbi->s_freeblocks_counter,
2042 : : ext3_count_free_blocks(sb));
2043 [ # # ]: 0 : if (!err) {
2044 : 0 : err = percpu_counter_init(&sbi->s_freeinodes_counter,
2045 : : ext3_count_free_inodes(sb));
2046 : : }
2047 [ # # ]: 0 : if (!err) {
2048 : 0 : err = percpu_counter_init(&sbi->s_dirs_counter,
2049 : : ext3_count_dirs(sb));
2050 : : }
2051 [ # # ]: 0 : if (err) {
2052 : 0 : ext3_msg(sb, KERN_ERR, "error: insufficient memory");
2053 : : ret = err;
2054 : 0 : goto failed_mount3;
2055 : : }
2056 : :
2057 : : /* We have now updated the journal if required, so we can
2058 : : * validate the data journaling mode. */
2059 [ # # # ]: 0 : switch (test_opt(sb, DATA_FLAGS)) {
2060 : : case 0:
2061 : : /* No mode set, assume a default based on the journal
2062 : : capabilities: ORDERED_DATA if the journal can
2063 : : cope, else JOURNAL_DATA */
2064 [ # # ]: 0 : if (journal_check_available_features
2065 : 0 : (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
2066 : 0 : set_opt(sbi->s_mount_opt, DEFAULT_DATA_MODE);
2067 : : else
2068 : 0 : set_opt(sbi->s_mount_opt, JOURNAL_DATA);
2069 : : break;
2070 : :
2071 : : case EXT3_MOUNT_ORDERED_DATA:
2072 : : case EXT3_MOUNT_WRITEBACK_DATA:
2073 [ # # ]: 0 : if (!journal_check_available_features
2074 : 0 : (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
2075 : 0 : ext3_msg(sb, KERN_ERR,
2076 : : "error: journal does not support "
2077 : : "requested data journaling mode");
2078 : 0 : goto failed_mount3;
2079 : : }
2080 : : default:
2081 : : break;
2082 : : }
2083 : :
2084 : : /*
2085 : : * The journal_load will have done any necessary log recovery,
2086 : : * so we can safely mount the rest of the filesystem now.
2087 : : */
2088 : :
2089 : 0 : root = ext3_iget(sb, EXT3_ROOT_INO);
2090 [ # # ]: 0 : if (IS_ERR(root)) {
2091 : 0 : ext3_msg(sb, KERN_ERR, "error: get root inode failed");
2092 : : ret = PTR_ERR(root);
2093 : 0 : goto failed_mount3;
2094 : : }
2095 [ # # ][ # # ]: 0 : if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
[ # # ]
2096 : 0 : iput(root);
2097 : 0 : ext3_msg(sb, KERN_ERR, "error: corrupt root inode, run e2fsck");
2098 : 0 : goto failed_mount3;
2099 : : }
2100 : 0 : sb->s_root = d_make_root(root);
2101 [ # # ]: 0 : if (!sb->s_root) {
2102 : 0 : ext3_msg(sb, KERN_ERR, "error: get root dentry failed");
2103 : : ret = -ENOMEM;
2104 : 0 : goto failed_mount3;
2105 : : }
2106 : :
2107 [ # # ]: 0 : if (ext3_setup_super(sb, es, sb->s_flags & MS_RDONLY))
2108 : 0 : sb->s_flags |= MS_RDONLY;
2109 : :
2110 : 0 : EXT3_SB(sb)->s_mount_state |= EXT3_ORPHAN_FS;
2111 : 0 : ext3_orphan_cleanup(sb, es);
2112 : 0 : EXT3_SB(sb)->s_mount_state &= ~EXT3_ORPHAN_FS;
2113 [ # # ]: 0 : if (needs_recovery) {
2114 : 0 : ext3_mark_recovery_complete(sb, es);
2115 : 0 : ext3_msg(sb, KERN_INFO, "recovery complete");
2116 : : }
2117 [ # # ]: 0 : ext3_msg(sb, KERN_INFO, "mounted filesystem with %s data mode",
2118 : 0 : test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ? "journal":
2119 [ # # ]: 0 : test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
2120 : : "writeback");
2121 : :
2122 : 0 : return 0;
2123 : :
2124 : : cantfind_ext3:
2125 [ # # ]: 0 : if (!silent)
2126 : 0 : ext3_msg(sb, KERN_INFO,
2127 : : "error: can't find ext3 filesystem on dev %s.",
2128 : 0 : sb->s_id);
2129 : : goto failed_mount;
2130 : :
2131 : : failed_mount3:
2132 : 0 : percpu_counter_destroy(&sbi->s_freeblocks_counter);
2133 : 0 : percpu_counter_destroy(&sbi->s_freeinodes_counter);
2134 : 0 : percpu_counter_destroy(&sbi->s_dirs_counter);
2135 : 0 : journal_destroy(sbi->s_journal);
2136 : : failed_mount2:
2137 [ # # ]: 0 : for (i = 0; i < db_count; i++)
2138 : 0 : brelse(sbi->s_group_desc[i]);
2139 : 0 : kfree(sbi->s_group_desc);
2140 : : failed_mount:
2141 : : #ifdef CONFIG_QUOTA
2142 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
2143 : 0 : kfree(sbi->s_qf_names[i]);
2144 : : #endif
2145 : : ext3_blkdev_remove(sbi);
2146 : : brelse(bh);
2147 : : out_fail:
2148 : 0 : sb->s_fs_info = NULL;
2149 : 0 : kfree(sbi->s_blockgroup_lock);
2150 : 0 : kfree(sbi);
2151 : 0 : return ret;
2152 : : }
2153 : :
2154 : : /*
2155 : : * Setup any per-fs journal parameters now. We'll do this both on
2156 : : * initial mount, once the journal has been initialised but before we've
2157 : : * done any recovery; and again on any subsequent remount.
2158 : : */
2159 : 0 : static void ext3_init_journal_params(struct super_block *sb, journal_t *journal)
2160 : : {
2161 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
2162 : :
2163 [ # # ]: 0 : if (sbi->s_commit_interval)
2164 : 0 : journal->j_commit_interval = sbi->s_commit_interval;
2165 : : /* We could also set up an ext3-specific default for the commit
2166 : : * interval here, but for now we'll just fall back to the jbd
2167 : : * default. */
2168 : :
2169 : : spin_lock(&journal->j_state_lock);
2170 [ # # ]: 0 : if (test_opt(sb, BARRIER))
2171 : 0 : journal->j_flags |= JFS_BARRIER;
2172 : : else
2173 : 0 : journal->j_flags &= ~JFS_BARRIER;
2174 [ # # ]: 0 : if (test_opt(sb, DATA_ERR_ABORT))
2175 : 0 : journal->j_flags |= JFS_ABORT_ON_SYNCDATA_ERR;
2176 : : else
2177 : 0 : journal->j_flags &= ~JFS_ABORT_ON_SYNCDATA_ERR;
2178 : : spin_unlock(&journal->j_state_lock);
2179 : 0 : }
2180 : :
2181 : 0 : static journal_t *ext3_get_journal(struct super_block *sb,
2182 : : unsigned int journal_inum)
2183 : : {
2184 : : struct inode *journal_inode;
2185 : : journal_t *journal;
2186 : :
2187 : : /* First, test for the existence of a valid inode on disk. Bad
2188 : : * things happen if we iget() an unused inode, as the subsequent
2189 : : * iput() will try to delete it. */
2190 : :
2191 : 0 : journal_inode = ext3_iget(sb, journal_inum);
2192 [ # # ]: 0 : if (IS_ERR(journal_inode)) {
2193 : 0 : ext3_msg(sb, KERN_ERR, "error: no journal found");
2194 : 0 : return NULL;
2195 : : }
2196 [ # # ]: 0 : if (!journal_inode->i_nlink) {
2197 : 0 : make_bad_inode(journal_inode);
2198 : 0 : iput(journal_inode);
2199 : 0 : ext3_msg(sb, KERN_ERR, "error: journal inode is deleted");
2200 : 0 : return NULL;
2201 : : }
2202 : :
2203 : : jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
2204 : : journal_inode, journal_inode->i_size);
2205 [ # # ]: 0 : if (!S_ISREG(journal_inode->i_mode)) {
2206 : 0 : ext3_msg(sb, KERN_ERR, "error: invalid journal inode");
2207 : 0 : iput(journal_inode);
2208 : 0 : return NULL;
2209 : : }
2210 : :
2211 : 0 : journal = journal_init_inode(journal_inode);
2212 [ # # ]: 0 : if (!journal) {
2213 : 0 : ext3_msg(sb, KERN_ERR, "error: could not load journal inode");
2214 : 0 : iput(journal_inode);
2215 : 0 : return NULL;
2216 : : }
2217 : 0 : journal->j_private = sb;
2218 : 0 : ext3_init_journal_params(sb, journal);
2219 : 0 : return journal;
2220 : : }
2221 : :
2222 : 0 : static journal_t *ext3_get_dev_journal(struct super_block *sb,
2223 : : dev_t j_dev)
2224 : : {
2225 : : struct buffer_head * bh;
2226 : : journal_t *journal;
2227 : : ext3_fsblk_t start;
2228 : : ext3_fsblk_t len;
2229 : : int hblock, blocksize;
2230 : : ext3_fsblk_t sb_block;
2231 : : unsigned long offset;
2232 : : struct ext3_super_block * es;
2233 : : struct block_device *bdev;
2234 : :
2235 : 0 : bdev = ext3_blkdev_get(j_dev, sb);
2236 [ # # ]: 0 : if (bdev == NULL)
2237 : : return NULL;
2238 : :
2239 : 0 : blocksize = sb->s_blocksize;
2240 : 0 : hblock = bdev_logical_block_size(bdev);
2241 [ # # ]: 0 : if (blocksize < hblock) {
2242 : 0 : ext3_msg(sb, KERN_ERR,
2243 : : "error: blocksize too small for journal device");
2244 : 0 : goto out_bdev;
2245 : : }
2246 : :
2247 : 0 : sb_block = EXT3_MIN_BLOCK_SIZE / blocksize;
2248 : 0 : offset = EXT3_MIN_BLOCK_SIZE % blocksize;
2249 : 0 : set_blocksize(bdev, blocksize);
2250 [ # # ]: 0 : if (!(bh = __bread(bdev, sb_block, blocksize))) {
2251 : 0 : ext3_msg(sb, KERN_ERR, "error: couldn't read superblock of "
2252 : : "external journal");
2253 : 0 : goto out_bdev;
2254 : : }
2255 : :
2256 : 0 : es = (struct ext3_super_block *) (bh->b_data + offset);
2257 [ # # ][ # # ]: 0 : if ((le16_to_cpu(es->s_magic) != EXT3_SUPER_MAGIC) ||
2258 : 0 : !(le32_to_cpu(es->s_feature_incompat) &
2259 : : EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
2260 : 0 : ext3_msg(sb, KERN_ERR, "error: external journal has "
2261 : : "bad superblock");
2262 : : brelse(bh);
2263 : : goto out_bdev;
2264 : : }
2265 : :
2266 [ # # ]: 0 : if (memcmp(EXT3_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
2267 : 0 : ext3_msg(sb, KERN_ERR, "error: journal UUID does not match");
2268 : : brelse(bh);
2269 : : goto out_bdev;
2270 : : }
2271 : :
2272 : 0 : len = le32_to_cpu(es->s_blocks_count);
2273 : 0 : start = sb_block + 1;
2274 : : brelse(bh); /* we're done with the superblock */
2275 : :
2276 : 0 : journal = journal_init_dev(bdev, sb->s_bdev,
2277 : : start, len, blocksize);
2278 [ # # ]: 0 : if (!journal) {
2279 : 0 : ext3_msg(sb, KERN_ERR,
2280 : : "error: failed to create device journal");
2281 : 0 : goto out_bdev;
2282 : : }
2283 : 0 : journal->j_private = sb;
2284 [ # # ]: 0 : if (!bh_uptodate_or_lock(journal->j_sb_buffer)) {
2285 [ # # ]: 0 : if (bh_submit_read(journal->j_sb_buffer)) {
2286 : 0 : ext3_msg(sb, KERN_ERR, "I/O error on journal device");
2287 : 0 : goto out_journal;
2288 : : }
2289 : : }
2290 [ # # ][ # # ]: 0 : if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
2291 [ # # ]: 0 : ext3_msg(sb, KERN_ERR,
2292 : : "error: external journal has more than one "
2293 : : "user (unsupported) - %d",
2294 : 0 : be32_to_cpu(journal->j_superblock->s_nr_users));
2295 : 0 : goto out_journal;
2296 : : }
2297 : 0 : EXT3_SB(sb)->journal_bdev = bdev;
2298 : 0 : ext3_init_journal_params(sb, journal);
2299 : 0 : return journal;
2300 : : out_journal:
2301 : 0 : journal_destroy(journal);
2302 : : out_bdev:
2303 : : ext3_blkdev_put(bdev);
2304 : 0 : return NULL;
2305 : : }
2306 : :
2307 : 0 : static int ext3_load_journal(struct super_block *sb,
2308 : : struct ext3_super_block *es,
2309 : : unsigned long journal_devnum)
2310 : : {
2311 : : journal_t *journal;
2312 : 0 : unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
2313 : : dev_t journal_dev;
2314 : : int err = 0;
2315 : : int really_read_only;
2316 : :
2317 [ # # ][ # # ]: 0 : if (journal_devnum &&
2318 : 0 : journal_devnum != le32_to_cpu(es->s_journal_dev)) {
2319 : 0 : ext3_msg(sb, KERN_INFO, "external journal device major/minor "
2320 : : "numbers have changed");
2321 : 0 : journal_dev = new_decode_dev(journal_devnum);
2322 : : } else
2323 : 0 : journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
2324 : :
2325 : 0 : really_read_only = bdev_read_only(sb->s_bdev);
2326 : :
2327 : : /*
2328 : : * Are we loading a blank journal or performing recovery after a
2329 : : * crash? For recovery, we need to check in advance whether we
2330 : : * can get read-write access to the device.
2331 : : */
2332 : :
2333 [ # # ]: 0 : if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER)) {
2334 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY) {
2335 : 0 : ext3_msg(sb, KERN_INFO,
2336 : : "recovery required on readonly filesystem");
2337 [ # # ]: 0 : if (really_read_only) {
2338 : 0 : ext3_msg(sb, KERN_ERR, "error: write access "
2339 : : "unavailable, cannot proceed");
2340 : 0 : return -EROFS;
2341 : : }
2342 : 0 : ext3_msg(sb, KERN_INFO,
2343 : : "write access will be enabled during recovery");
2344 : : }
2345 : : }
2346 : :
2347 [ # # ]: 0 : if (journal_inum && journal_dev) {
2348 : 0 : ext3_msg(sb, KERN_ERR, "error: filesystem has both journal "
2349 : : "and inode journals");
2350 : 0 : return -EINVAL;
2351 : : }
2352 : :
2353 [ # # ]: 0 : if (journal_inum) {
2354 [ # # ]: 0 : if (!(journal = ext3_get_journal(sb, journal_inum)))
2355 : : return -EINVAL;
2356 : : } else {
2357 [ # # ]: 0 : if (!(journal = ext3_get_dev_journal(sb, journal_dev)))
2358 : : return -EINVAL;
2359 : : }
2360 : :
2361 [ # # ]: 0 : if (!(journal->j_flags & JFS_BARRIER))
2362 : 0 : printk(KERN_INFO "EXT3-fs: barriers not enabled\n");
2363 : :
2364 [ # # ][ # # ]: 0 : if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
2365 : 0 : err = journal_update_format(journal);
2366 [ # # ]: 0 : if (err) {
2367 : 0 : ext3_msg(sb, KERN_ERR, "error updating journal");
2368 : 0 : journal_destroy(journal);
2369 : 0 : return err;
2370 : : }
2371 : : }
2372 : :
2373 [ # # ]: 0 : if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER))
2374 : 0 : err = journal_wipe(journal, !really_read_only);
2375 [ # # ]: 0 : if (!err)
2376 : 0 : err = journal_load(journal);
2377 : :
2378 [ # # ]: 0 : if (err) {
2379 : 0 : ext3_msg(sb, KERN_ERR, "error loading journal");
2380 : 0 : journal_destroy(journal);
2381 : 0 : return err;
2382 : : }
2383 : :
2384 : 0 : EXT3_SB(sb)->s_journal = journal;
2385 : 0 : ext3_clear_journal_err(sb, es);
2386 : :
2387 [ # # ][ # # ]: 0 : if (!really_read_only && journal_devnum &&
2388 : 0 : journal_devnum != le32_to_cpu(es->s_journal_dev)) {
2389 : 0 : es->s_journal_dev = cpu_to_le32(journal_devnum);
2390 : :
2391 : : /* Make sure we flush the recovery flag to disk. */
2392 : 0 : ext3_commit_super(sb, es, 1);
2393 : : }
2394 : :
2395 : : return 0;
2396 : : }
2397 : :
2398 : 0 : static int ext3_create_journal(struct super_block *sb,
2399 : : struct ext3_super_block *es,
2400 : : unsigned int journal_inum)
2401 : : {
2402 : : journal_t *journal;
2403 : : int err;
2404 : :
2405 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY) {
2406 : 0 : ext3_msg(sb, KERN_ERR,
2407 : : "error: readonly filesystem when trying to "
2408 : : "create journal");
2409 : 0 : return -EROFS;
2410 : : }
2411 : :
2412 : 0 : journal = ext3_get_journal(sb, journal_inum);
2413 [ # # ]: 0 : if (!journal)
2414 : : return -EINVAL;
2415 : :
2416 : 0 : ext3_msg(sb, KERN_INFO, "creating new journal on inode %u",
2417 : : journal_inum);
2418 : :
2419 : 0 : err = journal_create(journal);
2420 [ # # ]: 0 : if (err) {
2421 : 0 : ext3_msg(sb, KERN_ERR, "error creating journal");
2422 : 0 : journal_destroy(journal);
2423 : 0 : return -EIO;
2424 : : }
2425 : :
2426 : 0 : EXT3_SB(sb)->s_journal = journal;
2427 : :
2428 : 0 : ext3_update_dynamic_rev(sb);
2429 : 0 : EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2430 : 0 : EXT3_SET_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL);
2431 : :
2432 : 0 : es->s_journal_inum = cpu_to_le32(journal_inum);
2433 : :
2434 : : /* Make sure we flush the recovery flag to disk. */
2435 : 0 : ext3_commit_super(sb, es, 1);
2436 : :
2437 : 0 : return 0;
2438 : : }
2439 : :
2440 : 0 : static int ext3_commit_super(struct super_block *sb,
2441 : : struct ext3_super_block *es,
2442 : : int sync)
2443 : : {
2444 : 0 : struct buffer_head *sbh = EXT3_SB(sb)->s_sbh;
2445 : : int error = 0;
2446 : :
2447 [ # # ]: 0 : if (!sbh)
2448 : : return error;
2449 : :
2450 [ # # ]: 0 : if (buffer_write_io_error(sbh)) {
2451 : : /*
2452 : : * Oh, dear. A previous attempt to write the
2453 : : * superblock failed. This could happen because the
2454 : : * USB device was yanked out. Or it could happen to
2455 : : * be a transient write error and maybe the block will
2456 : : * be remapped. Nothing we can do but to retry the
2457 : : * write and hope for the best.
2458 : : */
2459 : 0 : ext3_msg(sb, KERN_ERR, "previous I/O error to "
2460 : : "superblock detected");
2461 : : clear_buffer_write_io_error(sbh);
2462 : : set_buffer_uptodate(sbh);
2463 : : }
2464 : : /*
2465 : : * If the file system is mounted read-only, don't update the
2466 : : * superblock write time. This avoids updating the superblock
2467 : : * write time when we are mounting the root file system
2468 : : * read/only but we need to replay the journal; at that point,
2469 : : * for people who are east of GMT and who make their clock
2470 : : * tick in localtime for Windows bug-for-bug compatibility,
2471 : : * the clock is set in the future, and this will cause e2fsck
2472 : : * to complain and force a full file system check.
2473 : : */
2474 [ # # ]: 0 : if (!(sb->s_flags & MS_RDONLY))
2475 : 0 : es->s_wtime = cpu_to_le32(get_seconds());
2476 : 0 : es->s_free_blocks_count = cpu_to_le32(ext3_count_free_blocks(sb));
2477 : 0 : es->s_free_inodes_count = cpu_to_le32(ext3_count_free_inodes(sb));
2478 : : BUFFER_TRACE(sbh, "marking dirty");
2479 : 0 : mark_buffer_dirty(sbh);
2480 [ # # ]: 0 : if (sync) {
2481 : 0 : error = sync_dirty_buffer(sbh);
2482 [ # # ]: 0 : if (buffer_write_io_error(sbh)) {
2483 : 0 : ext3_msg(sb, KERN_ERR, "I/O error while writing "
2484 : : "superblock");
2485 : : clear_buffer_write_io_error(sbh);
2486 : : set_buffer_uptodate(sbh);
2487 : : }
2488 : : }
2489 : 0 : return error;
2490 : : }
2491 : :
2492 : :
2493 : : /*
2494 : : * Have we just finished recovery? If so, and if we are mounting (or
2495 : : * remounting) the filesystem readonly, then we will end up with a
2496 : : * consistent fs on disk. Record that fact.
2497 : : */
2498 : 0 : static void ext3_mark_recovery_complete(struct super_block * sb,
2499 : : struct ext3_super_block * es)
2500 : : {
2501 : 0 : journal_t *journal = EXT3_SB(sb)->s_journal;
2502 : :
2503 : 0 : journal_lock_updates(journal);
2504 [ # # ]: 0 : if (journal_flush(journal) < 0)
2505 : : goto out;
2506 : :
2507 [ # # ][ # # ]: 0 : if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
2508 : 0 : sb->s_flags & MS_RDONLY) {
2509 : 0 : EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2510 : 0 : ext3_commit_super(sb, es, 1);
2511 : : }
2512 : :
2513 : : out:
2514 : 0 : journal_unlock_updates(journal);
2515 : 0 : }
2516 : :
2517 : : /*
2518 : : * If we are mounting (or read-write remounting) a filesystem whose journal
2519 : : * has recorded an error from a previous lifetime, move that error to the
2520 : : * main filesystem now.
2521 : : */
2522 : 0 : static void ext3_clear_journal_err(struct super_block *sb,
2523 : : struct ext3_super_block *es)
2524 : : {
2525 : : journal_t *journal;
2526 : : int j_errno;
2527 : : const char *errstr;
2528 : :
2529 : 0 : journal = EXT3_SB(sb)->s_journal;
2530 : :
2531 : : /*
2532 : : * Now check for any error status which may have been recorded in the
2533 : : * journal by a prior ext3_error() or ext3_abort()
2534 : : */
2535 : :
2536 : 0 : j_errno = journal_errno(journal);
2537 [ # # ]: 0 : if (j_errno) {
2538 : : char nbuf[16];
2539 : :
2540 : 0 : errstr = ext3_decode_error(sb, j_errno, nbuf);
2541 : 0 : ext3_warning(sb, __func__, "Filesystem error recorded "
2542 : : "from previous mount: %s", errstr);
2543 : 0 : ext3_warning(sb, __func__, "Marking fs in need of "
2544 : : "filesystem check.");
2545 : :
2546 : 0 : EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
2547 : 0 : es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
2548 : 0 : ext3_commit_super (sb, es, 1);
2549 : :
2550 : 0 : journal_clear_err(journal);
2551 : : }
2552 : 0 : }
2553 : :
2554 : : /*
2555 : : * Force the running and committing transactions to commit,
2556 : : * and wait on the commit.
2557 : : */
2558 : 0 : int ext3_force_commit(struct super_block *sb)
2559 : : {
2560 : : journal_t *journal;
2561 : : int ret;
2562 : :
2563 [ # # ]: 0 : if (sb->s_flags & MS_RDONLY)
2564 : : return 0;
2565 : :
2566 : 0 : journal = EXT3_SB(sb)->s_journal;
2567 : : ret = ext3_journal_force_commit(journal);
2568 : 0 : return ret;
2569 : : }
2570 : :
2571 : 0 : static int ext3_sync_fs(struct super_block *sb, int wait)
2572 : : {
2573 : : tid_t target;
2574 : :
2575 : : trace_ext3_sync_fs(sb, wait);
2576 : : /*
2577 : : * Writeback quota in non-journalled quota case - journalled quota has
2578 : : * no dirty dquots
2579 : : */
2580 : 0 : dquot_writeback_dquots(sb, -1);
2581 [ # # ]: 0 : if (journal_start_commit(EXT3_SB(sb)->s_journal, &target)) {
2582 [ # # ]: 0 : if (wait)
2583 : 0 : log_wait_commit(EXT3_SB(sb)->s_journal, target);
2584 : : }
2585 : 0 : return 0;
2586 : : }
2587 : :
2588 : : /*
2589 : : * LVM calls this function before a (read-only) snapshot is created. This
2590 : : * gives us a chance to flush the journal completely and mark the fs clean.
2591 : : */
2592 : 0 : static int ext3_freeze(struct super_block *sb)
2593 : : {
2594 : : int error = 0;
2595 : : journal_t *journal;
2596 : :
2597 [ # # ]: 0 : if (!(sb->s_flags & MS_RDONLY)) {
2598 : 0 : journal = EXT3_SB(sb)->s_journal;
2599 : :
2600 : : /* Now we set up the journal barrier. */
2601 : 0 : journal_lock_updates(journal);
2602 : :
2603 : : /*
2604 : : * We don't want to clear needs_recovery flag when we failed
2605 : : * to flush the journal.
2606 : : */
2607 : 0 : error = journal_flush(journal);
2608 [ # # ]: 0 : if (error < 0)
2609 : : goto out;
2610 : :
2611 : : /* Journal blocked and flushed, clear needs_recovery flag. */
2612 : 0 : EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2613 : 0 : error = ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
2614 [ # # ]: 0 : if (error)
2615 : : goto out;
2616 : : }
2617 : : return 0;
2618 : :
2619 : : out:
2620 : 0 : journal_unlock_updates(journal);
2621 : 0 : return error;
2622 : : }
2623 : :
2624 : : /*
2625 : : * Called by LVM after the snapshot is done. We need to reset the RECOVER
2626 : : * flag here, even though the filesystem is not technically dirty yet.
2627 : : */
2628 : 0 : static int ext3_unfreeze(struct super_block *sb)
2629 : : {
2630 [ # # ]: 0 : if (!(sb->s_flags & MS_RDONLY)) {
2631 : : /* Reser the needs_recovery flag before the fs is unlocked. */
2632 : 0 : EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2633 : 0 : ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
2634 : 0 : journal_unlock_updates(EXT3_SB(sb)->s_journal);
2635 : : }
2636 : 0 : return 0;
2637 : : }
2638 : :
2639 : 0 : static int ext3_remount (struct super_block * sb, int * flags, char * data)
2640 : : {
2641 : : struct ext3_super_block * es;
2642 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
2643 : 0 : ext3_fsblk_t n_blocks_count = 0;
2644 : : unsigned long old_sb_flags;
2645 : : struct ext3_mount_options old_opts;
2646 : : int enable_quota = 0;
2647 : : int err;
2648 : : #ifdef CONFIG_QUOTA
2649 : : int i;
2650 : : #endif
2651 : :
2652 : : /* Store the original options */
2653 : 0 : old_sb_flags = sb->s_flags;
2654 : 0 : old_opts.s_mount_opt = sbi->s_mount_opt;
2655 : 0 : old_opts.s_resuid = sbi->s_resuid;
2656 : 0 : old_opts.s_resgid = sbi->s_resgid;
2657 : 0 : old_opts.s_commit_interval = sbi->s_commit_interval;
2658 : : #ifdef CONFIG_QUOTA
2659 : 0 : old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
2660 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
2661 [ # # ]: 0 : if (sbi->s_qf_names[i]) {
2662 : 0 : old_opts.s_qf_names[i] = kstrdup(sbi->s_qf_names[i],
2663 : : GFP_KERNEL);
2664 [ # # ]: 0 : if (!old_opts.s_qf_names[i]) {
2665 : : int j;
2666 : :
2667 [ # # ]: 0 : for (j = 0; j < i; j++)
2668 : 0 : kfree(old_opts.s_qf_names[j]);
2669 : : return -ENOMEM;
2670 : : }
2671 : : } else
2672 : 0 : old_opts.s_qf_names[i] = NULL;
2673 : : #endif
2674 : :
2675 : : /*
2676 : : * Allow the "check" option to be passed as a remount option.
2677 : : */
2678 [ # # ]: 0 : if (!parse_options(data, sb, NULL, NULL, &n_blocks_count, 1)) {
2679 : : err = -EINVAL;
2680 : : goto restore_opts;
2681 : : }
2682 : :
2683 [ # # ]: 0 : if (test_opt(sb, ABORT))
2684 : 0 : ext3_abort(sb, __func__, "Abort forced by user");
2685 : :
2686 [ # # ]: 0 : sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2687 : 0 : (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
2688 : :
2689 : 0 : es = sbi->s_es;
2690 : :
2691 : 0 : ext3_init_journal_params(sb, sbi->s_journal);
2692 : :
2693 [ # # ][ # # ]: 0 : if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
2694 : 0 : n_blocks_count > le32_to_cpu(es->s_blocks_count)) {
2695 [ # # ]: 0 : if (test_opt(sb, ABORT)) {
2696 : : err = -EROFS;
2697 : : goto restore_opts;
2698 : : }
2699 : :
2700 [ # # ]: 0 : if (*flags & MS_RDONLY) {
2701 : : err = dquot_suspend(sb, -1);
2702 [ # # ]: 0 : if (err < 0)
2703 : : goto restore_opts;
2704 : :
2705 : : /*
2706 : : * First of all, the unconditional stuff we have to do
2707 : : * to disable replay of the journal when we next remount
2708 : : */
2709 : 0 : sb->s_flags |= MS_RDONLY;
2710 : :
2711 : : /*
2712 : : * OK, test if we are remounting a valid rw partition
2713 : : * readonly, and if so set the rdonly flag and then
2714 : : * mark the partition as valid again.
2715 : : */
2716 [ # # ][ # # ]: 0 : if (!(es->s_state & cpu_to_le16(EXT3_VALID_FS)) &&
2717 : 0 : (sbi->s_mount_state & EXT3_VALID_FS))
2718 : 0 : es->s_state = cpu_to_le16(sbi->s_mount_state);
2719 : :
2720 : 0 : ext3_mark_recovery_complete(sb, es);
2721 : : } else {
2722 : : __le32 ret;
2723 [ # # ]: 0 : if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
2724 : : ~EXT3_FEATURE_RO_COMPAT_SUPP))) {
2725 : 0 : ext3_msg(sb, KERN_WARNING,
2726 : : "warning: couldn't remount RDWR "
2727 : : "because of unsupported optional "
2728 : : "features (%x)", le32_to_cpu(ret));
2729 : : err = -EROFS;
2730 : 0 : goto restore_opts;
2731 : : }
2732 : :
2733 : : /*
2734 : : * If we have an unprocessed orphan list hanging
2735 : : * around from a previously readonly bdev mount,
2736 : : * require a full umount & mount for now.
2737 : : */
2738 [ # # ]: 0 : if (es->s_last_orphan) {
2739 : 0 : ext3_msg(sb, KERN_WARNING, "warning: couldn't "
2740 : : "remount RDWR because of unprocessed "
2741 : : "orphan inode list. Please "
2742 : : "umount & mount instead.");
2743 : : err = -EINVAL;
2744 : 0 : goto restore_opts;
2745 : : }
2746 : :
2747 : : /*
2748 : : * Mounting a RDONLY partition read-write, so reread
2749 : : * and store the current valid flag. (It may have
2750 : : * been changed by e2fsck since we originally mounted
2751 : : * the partition.)
2752 : : */
2753 : 0 : ext3_clear_journal_err(sb, es);
2754 : 0 : sbi->s_mount_state = le16_to_cpu(es->s_state);
2755 [ # # ]: 0 : if ((err = ext3_group_extend(sb, es, n_blocks_count)))
2756 : : goto restore_opts;
2757 [ # # ]: 0 : if (!ext3_setup_super (sb, es, 0))
2758 : 0 : sb->s_flags &= ~MS_RDONLY;
2759 : : enable_quota = 1;
2760 : : }
2761 : : }
2762 : : #ifdef CONFIG_QUOTA
2763 : : /* Release old quota file names */
2764 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++)
2765 : 0 : kfree(old_opts.s_qf_names[i]);
2766 : : #endif
2767 [ # # ]: 0 : if (enable_quota)
2768 : 0 : dquot_resume(sb, -1);
2769 : : return 0;
2770 : : restore_opts:
2771 : 0 : sb->s_flags = old_sb_flags;
2772 : 0 : sbi->s_mount_opt = old_opts.s_mount_opt;
2773 : 0 : sbi->s_resuid = old_opts.s_resuid;
2774 : 0 : sbi->s_resgid = old_opts.s_resgid;
2775 : 0 : sbi->s_commit_interval = old_opts.s_commit_interval;
2776 : : #ifdef CONFIG_QUOTA
2777 : 0 : sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
2778 [ # # ]: 0 : for (i = 0; i < MAXQUOTAS; i++) {
2779 : 0 : kfree(sbi->s_qf_names[i]);
2780 : 0 : sbi->s_qf_names[i] = old_opts.s_qf_names[i];
2781 : : }
2782 : : #endif
2783 : : return err;
2784 : : }
2785 : :
2786 : 0 : static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
2787 : : {
2788 : 0 : struct super_block *sb = dentry->d_sb;
2789 : : struct ext3_sb_info *sbi = EXT3_SB(sb);
2790 : 0 : struct ext3_super_block *es = sbi->s_es;
2791 : : u64 fsid;
2792 : :
2793 [ # # ]: 0 : if (test_opt(sb, MINIX_DF)) {
2794 : 0 : sbi->s_overhead_last = 0;
2795 [ # # ]: 0 : } else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
2796 : 0 : unsigned long ngroups = sbi->s_groups_count, i;
2797 : : ext3_fsblk_t overhead = 0;
2798 : 0 : smp_rmb();
2799 : :
2800 : : /*
2801 : : * Compute the overhead (FS structures). This is constant
2802 : : * for a given filesystem unless the number of block groups
2803 : : * changes so we cache the previous value until it does.
2804 : : */
2805 : :
2806 : : /*
2807 : : * All of the blocks before first_data_block are
2808 : : * overhead
2809 : : */
2810 : 0 : overhead = le32_to_cpu(es->s_first_data_block);
2811 : :
2812 : : /*
2813 : : * Add the overhead attributed to the superblock and
2814 : : * block group descriptors. If the sparse superblocks
2815 : : * feature is turned on, then not all groups have this.
2816 : : */
2817 [ # # ]: 0 : for (i = 0; i < ngroups; i++) {
2818 : 0 : overhead += ext3_bg_has_super(sb, i) +
2819 : 0 : ext3_bg_num_gdb(sb, i);
2820 : 0 : cond_resched();
2821 : : }
2822 : :
2823 : : /*
2824 : : * Every block group has an inode bitmap, a block
2825 : : * bitmap, and an inode table.
2826 : : */
2827 : 0 : overhead += ngroups * (2 + sbi->s_itb_per_group);
2828 : :
2829 : : /* Add the journal blocks as well */
2830 : 0 : overhead += sbi->s_journal->j_maxlen;
2831 : :
2832 : 0 : sbi->s_overhead_last = overhead;
2833 : 0 : smp_wmb();
2834 : 0 : sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
2835 : : }
2836 : :
2837 : 0 : buf->f_type = EXT3_SUPER_MAGIC;
2838 : 0 : buf->f_bsize = sb->s_blocksize;
2839 : 0 : buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
2840 : 0 : buf->f_bfree = percpu_counter_sum_positive(&sbi->s_freeblocks_counter);
2841 : 0 : buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
2842 [ # # ]: 0 : if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
2843 : 0 : buf->f_bavail = 0;
2844 : 0 : buf->f_files = le32_to_cpu(es->s_inodes_count);
2845 : 0 : buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
2846 : 0 : buf->f_namelen = EXT3_NAME_LEN;
2847 : 0 : fsid = le64_to_cpup((void *)es->s_uuid) ^
2848 : 0 : le64_to_cpup((void *)es->s_uuid + sizeof(u64));
2849 : 0 : buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
2850 : 0 : buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
2851 : 0 : return 0;
2852 : : }
2853 : :
2854 : : /* Helper function for writing quotas on sync - we need to start transaction before quota file
2855 : : * is locked for write. Otherwise the are possible deadlocks:
2856 : : * Process 1 Process 2
2857 : : * ext3_create() quota_sync()
2858 : : * journal_start() write_dquot()
2859 : : * dquot_initialize() down(dqio_mutex)
2860 : : * down(dqio_mutex) journal_start()
2861 : : *
2862 : : */
2863 : :
2864 : : #ifdef CONFIG_QUOTA
2865 : :
2866 : : static inline struct inode *dquot_to_inode(struct dquot *dquot)
2867 : : {
2868 : 0 : return sb_dqopt(dquot->dq_sb)->files[dquot->dq_id.type];
2869 : : }
2870 : :
2871 : 0 : static int ext3_write_dquot(struct dquot *dquot)
2872 : : {
2873 : : int ret, err;
2874 : : handle_t *handle;
2875 : 0 : struct inode *inode;
2876 : :
2877 : : inode = dquot_to_inode(dquot);
2878 [ # # ]: 0 : handle = ext3_journal_start(inode,
2879 : 0 : EXT3_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
2880 [ # # ]: 0 : if (IS_ERR(handle))
2881 : 0 : return PTR_ERR(handle);
2882 : 0 : ret = dquot_commit(dquot);
2883 : 0 : err = ext3_journal_stop(handle);
2884 [ # # ]: 0 : if (!ret)
2885 : : ret = err;
2886 : 0 : return ret;
2887 : : }
2888 : :
2889 : 0 : static int ext3_acquire_dquot(struct dquot *dquot)
2890 : : {
2891 : : int ret, err;
2892 : : handle_t *handle;
2893 : :
2894 [ # # ]: 0 : handle = ext3_journal_start(dquot_to_inode(dquot),
2895 : 0 : EXT3_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2896 [ # # ]: 0 : if (IS_ERR(handle))
2897 : 0 : return PTR_ERR(handle);
2898 : 0 : ret = dquot_acquire(dquot);
2899 : 0 : err = ext3_journal_stop(handle);
2900 [ # # ]: 0 : if (!ret)
2901 : : ret = err;
2902 : 0 : return ret;
2903 : : }
2904 : :
2905 : 0 : static int ext3_release_dquot(struct dquot *dquot)
2906 : : {
2907 : : int ret, err;
2908 : : handle_t *handle;
2909 : :
2910 [ # # ]: 0 : handle = ext3_journal_start(dquot_to_inode(dquot),
2911 : 0 : EXT3_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2912 [ # # ]: 0 : if (IS_ERR(handle)) {
2913 : : /* Release dquot anyway to avoid endless cycle in dqput() */
2914 : 0 : dquot_release(dquot);
2915 : 0 : return PTR_ERR(handle);
2916 : : }
2917 : 0 : ret = dquot_release(dquot);
2918 : 0 : err = ext3_journal_stop(handle);
2919 [ # # ]: 0 : if (!ret)
2920 : : ret = err;
2921 : 0 : return ret;
2922 : : }
2923 : :
2924 : 0 : static int ext3_mark_dquot_dirty(struct dquot *dquot)
2925 : : {
2926 : : /* Are we journaling quotas? */
2927 [ # # ][ # # ]: 0 : if (EXT3_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2928 : 0 : EXT3_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2929 : 0 : dquot_mark_dquot_dirty(dquot);
2930 : 0 : return ext3_write_dquot(dquot);
2931 : : } else {
2932 : 0 : return dquot_mark_dquot_dirty(dquot);
2933 : : }
2934 : : }
2935 : :
2936 : 0 : static int ext3_write_info(struct super_block *sb, int type)
2937 : : {
2938 : : int ret, err;
2939 : : handle_t *handle;
2940 : :
2941 : : /* Data block + inode block */
2942 : 0 : handle = ext3_journal_start(sb->s_root->d_inode, 2);
2943 [ # # ]: 0 : if (IS_ERR(handle))
2944 : 0 : return PTR_ERR(handle);
2945 : 0 : ret = dquot_commit_info(sb, type);
2946 : 0 : err = ext3_journal_stop(handle);
2947 [ # # ]: 0 : if (!ret)
2948 : : ret = err;
2949 : 0 : return ret;
2950 : : }
2951 : :
2952 : : /*
2953 : : * Turn on quotas during mount time - we need to find
2954 : : * the quota file and such...
2955 : : */
2956 : : static int ext3_quota_on_mount(struct super_block *sb, int type)
2957 : : {
2958 : 0 : return dquot_quota_on_mount(sb, EXT3_SB(sb)->s_qf_names[type],
2959 : : EXT3_SB(sb)->s_jquota_fmt, type);
2960 : : }
2961 : :
2962 : : /*
2963 : : * Standard function to be called on quota_on
2964 : : */
2965 : 0 : static int ext3_quota_on(struct super_block *sb, int type, int format_id,
2966 : : struct path *path)
2967 : : {
2968 : : int err;
2969 : :
2970 [ # # ]: 0 : if (!test_opt(sb, QUOTA))
2971 : : return -EINVAL;
2972 : :
2973 : : /* Quotafile not on the same filesystem? */
2974 [ # # ]: 0 : if (path->dentry->d_sb != sb)
2975 : : return -EXDEV;
2976 : : /* Journaling quota? */
2977 [ # # ]: 0 : if (EXT3_SB(sb)->s_qf_names[type]) {
2978 : : /* Quotafile not of fs root? */
2979 [ # # ]: 0 : if (path->dentry->d_parent != sb->s_root)
2980 : 0 : ext3_msg(sb, KERN_WARNING,
2981 : : "warning: Quota file not on filesystem root. "
2982 : : "Journaled quota will not work.");
2983 : : }
2984 : :
2985 : : /*
2986 : : * When we journal data on quota file, we have to flush journal to see
2987 : : * all updates to the file when we bypass pagecache...
2988 : : */
2989 [ # # ]: 0 : if (ext3_should_journal_data(path->dentry->d_inode)) {
2990 : : /*
2991 : : * We don't need to lock updates but journal_flush() could
2992 : : * otherwise be livelocked...
2993 : : */
2994 : 0 : journal_lock_updates(EXT3_SB(sb)->s_journal);
2995 : 0 : err = journal_flush(EXT3_SB(sb)->s_journal);
2996 : 0 : journal_unlock_updates(EXT3_SB(sb)->s_journal);
2997 [ # # ]: 0 : if (err)
2998 : : return err;
2999 : : }
3000 : :
3001 : 0 : return dquot_quota_on(sb, type, format_id, path);
3002 : : }
3003 : :
3004 : : /* Read data from quotafile - avoid pagecache and such because we cannot afford
3005 : : * acquiring the locks... As quota files are never truncated and quota code
3006 : : * itself serializes the operations (and no one else should touch the files)
3007 : : * we don't have to be afraid of races */
3008 : 0 : static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
3009 : : size_t len, loff_t off)
3010 : : {
3011 : 0 : struct inode *inode = sb_dqopt(sb)->files[type];
3012 : 0 : sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
3013 : 0 : int err = 0;
3014 : 0 : int offset = off & (sb->s_blocksize - 1);
3015 : : int tocopy;
3016 : : size_t toread;
3017 : : struct buffer_head *bh;
3018 : : loff_t i_size = i_size_read(inode);
3019 : :
3020 [ # # ]: 0 : if (off > i_size)
3021 : : return 0;
3022 [ # # ]: 0 : if (off+len > i_size)
3023 : 0 : len = i_size-off;
3024 : : toread = len;
3025 [ # # ]: 0 : while (toread > 0) {
3026 : : tocopy = sb->s_blocksize - offset < toread ?
3027 : 0 : sb->s_blocksize - offset : toread;
3028 : 0 : bh = ext3_bread(NULL, inode, blk, 0, &err);
3029 [ # # ]: 0 : if (err)
3030 : : return err;
3031 [ # # ]: 0 : if (!bh) /* A hole? */
3032 [ # # ]: 0 : memset(data, 0, tocopy);
3033 : : else
3034 : 0 : memcpy(data, bh->b_data+offset, tocopy);
3035 : : brelse(bh);
3036 : : offset = 0;
3037 : 0 : toread -= tocopy;
3038 : 0 : data += tocopy;
3039 : 0 : blk++;
3040 : : }
3041 : 0 : return len;
3042 : : }
3043 : :
3044 : : /* Write to quotafile (we know the transaction is already started and has
3045 : : * enough credits) */
3046 : 0 : static ssize_t ext3_quota_write(struct super_block *sb, int type,
3047 : : const char *data, size_t len, loff_t off)
3048 : : {
3049 : 0 : struct inode *inode = sb_dqopt(sb)->files[type];
3050 : 0 : sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
3051 : 0 : int err = 0;
3052 : 0 : int offset = off & (sb->s_blocksize - 1);
3053 : 0 : int journal_quota = EXT3_SB(sb)->s_qf_names[type] != NULL;
3054 : : struct buffer_head *bh;
3055 : : handle_t *handle = journal_current_handle();
3056 : :
3057 [ # # ]: 0 : if (!handle) {
3058 : 0 : ext3_msg(sb, KERN_WARNING,
3059 : : "warning: quota write (off=%llu, len=%llu)"
3060 : : " cancelled because transaction is not started.",
3061 : : (unsigned long long)off, (unsigned long long)len);
3062 : 0 : return -EIO;
3063 : : }
3064 : :
3065 : : /*
3066 : : * Since we account only one data block in transaction credits,
3067 : : * then it is impossible to cross a block boundary.
3068 : : */
3069 [ # # ]: 0 : if (sb->s_blocksize - offset < len) {
3070 : 0 : ext3_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
3071 : : " cancelled because not block aligned",
3072 : : (unsigned long long)off, (unsigned long long)len);
3073 : 0 : return -EIO;
3074 : : }
3075 : 0 : bh = ext3_bread(handle, inode, blk, 1, &err);
3076 [ # # ]: 0 : if (!bh)
3077 : : goto out;
3078 [ # # ]: 0 : if (journal_quota) {
3079 : 0 : err = ext3_journal_get_write_access(handle, bh);
3080 [ # # ]: 0 : if (err) {
3081 : : brelse(bh);
3082 : : goto out;
3083 : : }
3084 : : }
3085 : : lock_buffer(bh);
3086 : 0 : memcpy(bh->b_data+offset, data, len);
3087 : 0 : flush_dcache_page(bh->b_page);
3088 : 0 : unlock_buffer(bh);
3089 [ # # ]: 0 : if (journal_quota)
3090 : 0 : err = ext3_journal_dirty_metadata(handle, bh);
3091 : : else {
3092 : : /* Always do at least ordered writes for quotas */
3093 : 0 : err = ext3_journal_dirty_data(handle, bh);
3094 : 0 : mark_buffer_dirty(bh);
3095 : : }
3096 : : brelse(bh);
3097 : : out:
3098 [ # # ]: 0 : if (err)
3099 : : return err;
3100 [ # # ]: 0 : if (inode->i_size < off + len) {
3101 : : i_size_write(inode, off + len);
3102 : 0 : EXT3_I(inode)->i_disksize = inode->i_size;
3103 : : }
3104 : 0 : inode->i_version++;
3105 : 0 : inode->i_mtime = inode->i_ctime = CURRENT_TIME;
3106 : 0 : ext3_mark_inode_dirty(handle, inode);
3107 : 0 : return len;
3108 : : }
3109 : :
3110 : : #endif
3111 : :
3112 : 0 : static struct dentry *ext3_mount(struct file_system_type *fs_type,
3113 : : int flags, const char *dev_name, void *data)
3114 : : {
3115 : 0 : return mount_bdev(fs_type, flags, dev_name, data, ext3_fill_super);
3116 : : }
3117 : :
3118 : : static struct file_system_type ext3_fs_type = {
3119 : : .owner = THIS_MODULE,
3120 : : .name = "ext3",
3121 : : .mount = ext3_mount,
3122 : : .kill_sb = kill_block_super,
3123 : : .fs_flags = FS_REQUIRES_DEV,
3124 : : };
3125 : : MODULE_ALIAS_FS("ext3");
3126 : :
3127 : 0 : static int __init init_ext3_fs(void)
3128 : : {
3129 : 0 : int err = init_ext3_xattr();
3130 [ # # ]: 0 : if (err)
3131 : : return err;
3132 : 0 : err = init_inodecache();
3133 [ # # ]: 0 : if (err)
3134 : : goto out1;
3135 : 0 : err = register_filesystem(&ext3_fs_type);
3136 [ # # ]: 0 : if (err)
3137 : : goto out;
3138 : : return 0;
3139 : : out:
3140 : : destroy_inodecache();
3141 : : out1:
3142 : 0 : exit_ext3_xattr();
3143 : 0 : return err;
3144 : : }
3145 : :
3146 : 0 : static void __exit exit_ext3_fs(void)
3147 : : {
3148 : 0 : unregister_filesystem(&ext3_fs_type);
3149 : : destroy_inodecache();
3150 : 0 : exit_ext3_xattr();
3151 : 0 : }
3152 : :
3153 : : MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
3154 : : MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
3155 : : MODULE_LICENSE("GPL");
3156 : : module_init(init_ext3_fs)
3157 : : module_exit(exit_ext3_fs)
|
