blob: 26147746c272c2112b7067aa6415800434586b50 [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/super.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *
9 * from
10 *
11 * linux/fs/minix/inode.c
12 *
13 * Copyright (C) 1991, 1992 Linus Torvalds
14 *
15 * Big-endian to little-endian byte-swapping/bitmaps by
16 * David S. Miller (davem@caip.rutgers.edu), 1995
17 */
18
19#include <linux/module.h>
20#include <linux/string.h>
21#include <linux/fs.h>
22#include <linux/time.h>
Theodore Ts'oc5ca7c72009-04-27 22:48:48 -040023#include <linux/vmalloc.h>
Mingming Caodab291a2006-10-11 01:21:01 -070024#include <linux/jbd2.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070025#include <linux/slab.h>
26#include <linux/init.h>
27#include <linux/blkdev.h>
28#include <linux/parser.h>
29#include <linux/smp_lock.h>
30#include <linux/buffer_head.h>
Christoph Hellwiga5694252007-07-17 04:04:28 -070031#include <linux/exportfs.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070032#include <linux/vfs.h>
33#include <linux/random.h>
34#include <linux/mount.h>
35#include <linux/namei.h>
36#include <linux/quotaops.h>
37#include <linux/seq_file.h>
Theodore Ts'o9f6200b2008-09-23 09:18:24 -040038#include <linux/proc_fs.h>
Theodore Ts'o3197ebd2009-03-31 09:10:09 -040039#include <linux/ctype.h>
Vignesh Babu13305932007-07-18 09:11:02 -040040#include <linux/log2.h>
Andreas Dilger717d50e2007-10-16 18:38:25 -040041#include <linux/crc16.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070042#include <asm/uaccess.h>
43
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040044#include "ext4.h"
45#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070046#include "xattr.h"
47#include "acl.h"
Theodore Ts'o3661d282009-09-14 22:59:50 -040048#include "mballoc.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070049
Theodore Ts'o9bffad12009-06-17 11:48:11 -040050#define CREATE_TRACE_POINTS
51#include <trace/events/ext4.h>
52
Theodore Ts'o9f6200b2008-09-23 09:18:24 -040053struct proc_dir_entry *ext4_proc_root;
Theodore Ts'o3197ebd2009-03-31 09:10:09 -040054static struct kset *ext4_kset;
Theodore Ts'o9f6200b2008-09-23 09:18:24 -040055
Mingming Cao617ba132006-10-11 01:20:53 -070056static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070057 unsigned long journal_devnum);
Theodore Ts'oe2d67052009-05-01 00:33:44 -040058static int ext4_commit_super(struct super_block *sb, int sync);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040059static void ext4_mark_recovery_complete(struct super_block *sb,
60 struct ext4_super_block *es);
61static void ext4_clear_journal_err(struct super_block *sb,
62 struct ext4_super_block *es);
Mingming Cao617ba132006-10-11 01:20:53 -070063static int ext4_sync_fs(struct super_block *sb, int wait);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040064static const char *ext4_decode_error(struct super_block *sb, int errno,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070065 char nbuf[16]);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040066static int ext4_remount(struct super_block *sb, int *flags, char *data);
67static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
Takashi Satoc4be0c12009-01-09 16:40:58 -080068static int ext4_unfreeze(struct super_block *sb);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040069static void ext4_write_super(struct super_block *sb);
Takashi Satoc4be0c12009-01-09 16:40:58 -080070static int ext4_freeze(struct super_block *sb);
Jan Karaba69f9a2010-03-24 20:18:37 -040071static int ext4_get_sb(struct file_system_type *fs_type, int flags,
72 const char *dev_name, void *data, struct vfsmount *mnt);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070073
Jan Karaba69f9a2010-03-24 20:18:37 -040074#if !defined(CONFIG_EXT3_FS) && !defined(CONFIG_EXT3_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT23)
75static struct file_system_type ext3_fs_type = {
76 .owner = THIS_MODULE,
77 .name = "ext3",
78 .get_sb = ext4_get_sb,
79 .kill_sb = kill_block_super,
80 .fs_flags = FS_REQUIRES_DEV,
81};
82#define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)
83#else
84#define IS_EXT3_SB(sb) (0)
85#endif
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070086
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070087ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
88 struct ext4_group_desc *bg)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070089{
Aneesh Kumar K.V3a145892007-10-16 18:38:25 -040090 return le32_to_cpu(bg->bg_block_bitmap_lo) |
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070091 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -040092 (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070093}
94
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070095ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
96 struct ext4_group_desc *bg)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070097{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -040098 return le32_to_cpu(bg->bg_inode_bitmap_lo) |
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070099 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400100 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700101}
102
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700103ext4_fsblk_t ext4_inode_table(struct super_block *sb,
104 struct ext4_group_desc *bg)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700105{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -0400106 return le32_to_cpu(bg->bg_inode_table_lo) |
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700107 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400108 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700109}
110
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500111__u32 ext4_free_blks_count(struct super_block *sb,
112 struct ext4_group_desc *bg)
113{
114 return le16_to_cpu(bg->bg_free_blocks_count_lo) |
115 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400116 (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500117}
118
119__u32 ext4_free_inodes_count(struct super_block *sb,
120 struct ext4_group_desc *bg)
121{
122 return le16_to_cpu(bg->bg_free_inodes_count_lo) |
123 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400124 (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500125}
126
127__u32 ext4_used_dirs_count(struct super_block *sb,
128 struct ext4_group_desc *bg)
129{
130 return le16_to_cpu(bg->bg_used_dirs_count_lo) |
131 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400132 (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500133}
134
135__u32 ext4_itable_unused_count(struct super_block *sb,
136 struct ext4_group_desc *bg)
137{
138 return le16_to_cpu(bg->bg_itable_unused_lo) |
139 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400140 (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500141}
142
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700143void ext4_block_bitmap_set(struct super_block *sb,
144 struct ext4_group_desc *bg, ext4_fsblk_t blk)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700145{
Aneesh Kumar K.V3a145892007-10-16 18:38:25 -0400146 bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700147 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
148 bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700149}
150
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700151void ext4_inode_bitmap_set(struct super_block *sb,
152 struct ext4_group_desc *bg, ext4_fsblk_t blk)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700153{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -0400154 bg->bg_inode_bitmap_lo = cpu_to_le32((u32)blk);
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700155 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
156 bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700157}
158
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700159void ext4_inode_table_set(struct super_block *sb,
160 struct ext4_group_desc *bg, ext4_fsblk_t blk)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700161{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -0400162 bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700163 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
164 bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700165}
166
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -0500167void ext4_free_blks_set(struct super_block *sb,
168 struct ext4_group_desc *bg, __u32 count)
169{
170 bg->bg_free_blocks_count_lo = cpu_to_le16((__u16)count);
171 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
172 bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
173}
174
175void ext4_free_inodes_set(struct super_block *sb,
176 struct ext4_group_desc *bg, __u32 count)
177{
178 bg->bg_free_inodes_count_lo = cpu_to_le16((__u16)count);
179 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
180 bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
181}
182
183void ext4_used_dirs_set(struct super_block *sb,
184 struct ext4_group_desc *bg, __u32 count)
185{
186 bg->bg_used_dirs_count_lo = cpu_to_le16((__u16)count);
187 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
188 bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
189}
190
191void ext4_itable_unused_set(struct super_block *sb,
192 struct ext4_group_desc *bg, __u32 count)
193{
194 bg->bg_itable_unused_lo = cpu_to_le16((__u16)count);
195 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
196 bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
197}
198
Curt Wohlgemuthd3d1faf2009-09-29 11:01:03 -0400199
200/* Just increment the non-pointer handle value */
201static handle_t *ext4_get_nojournal(void)
202{
203 handle_t *handle = current->journal_info;
204 unsigned long ref_cnt = (unsigned long)handle;
205
206 BUG_ON(ref_cnt >= EXT4_NOJOURNAL_MAX_REF_COUNT);
207
208 ref_cnt++;
209 handle = (handle_t *)ref_cnt;
210
211 current->journal_info = handle;
212 return handle;
213}
214
215
216/* Decrement the non-pointer handle value */
217static void ext4_put_nojournal(handle_t *handle)
218{
219 unsigned long ref_cnt = (unsigned long)handle;
220
221 BUG_ON(ref_cnt == 0);
222
223 ref_cnt--;
224 handle = (handle_t *)ref_cnt;
225
226 current->journal_info = handle;
227}
228
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700229/*
Mingming Caodab291a2006-10-11 01:21:01 -0700230 * Wrappers for jbd2_journal_start/end.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700231 *
232 * The only special thing we need to do here is to make sure that all
233 * journal_end calls result in the superblock being marked dirty, so
234 * that sync() will call the filesystem's write_super callback if
235 * appropriate.
236 */
Mingming Cao617ba132006-10-11 01:20:53 -0700237handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700238{
239 journal_t *journal;
240
241 if (sb->s_flags & MS_RDONLY)
242 return ERR_PTR(-EROFS);
243
Eric Sandeen437f88c2010-08-01 17:33:29 -0400244 vfs_check_frozen(sb, SB_FREEZE_TRANS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700245 /* Special case here: if the journal has aborted behind our
246 * backs (eg. EIO in the commit thread), then we still need to
247 * take the FS itself readonly cleanly. */
Mingming Cao617ba132006-10-11 01:20:53 -0700248 journal = EXT4_SB(sb)->s_journal;
Frank Mayhar03901312009-01-07 00:06:22 -0500249 if (journal) {
250 if (is_journal_aborted(journal)) {
Theodore Ts'oc67d8592010-06-29 11:07:07 -0400251 ext4_abort(sb, "Detected aborted journal");
Frank Mayhar03901312009-01-07 00:06:22 -0500252 return ERR_PTR(-EROFS);
253 }
254 return jbd2_journal_start(journal, nblocks);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700255 }
Curt Wohlgemuthd3d1faf2009-09-29 11:01:03 -0400256 return ext4_get_nojournal();
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700257}
258
259/*
260 * The only special thing we need to do here is to make sure that all
Mingming Caodab291a2006-10-11 01:21:01 -0700261 * jbd2_journal_stop calls result in the superblock being marked dirty, so
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700262 * that sync() will call the filesystem's write_super callback if
263 * appropriate.
264 */
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400265int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700266{
267 struct super_block *sb;
268 int err;
269 int rc;
270
Frank Mayhar03901312009-01-07 00:06:22 -0500271 if (!ext4_handle_valid(handle)) {
Curt Wohlgemuthd3d1faf2009-09-29 11:01:03 -0400272 ext4_put_nojournal(handle);
Frank Mayhar03901312009-01-07 00:06:22 -0500273 return 0;
274 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700275 sb = handle->h_transaction->t_journal->j_private;
276 err = handle->h_err;
Mingming Caodab291a2006-10-11 01:21:01 -0700277 rc = jbd2_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700278
279 if (!err)
280 err = rc;
281 if (err)
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400282 __ext4_std_error(sb, where, line, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700283 return err;
284}
285
Theodore Ts'o90c72012010-06-29 14:53:24 -0400286void ext4_journal_abort_handle(const char *caller, unsigned int line,
287 const char *err_fn, struct buffer_head *bh,
288 handle_t *handle, int err)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700289{
290 char nbuf[16];
Mingming Cao617ba132006-10-11 01:20:53 -0700291 const char *errstr = ext4_decode_error(NULL, err, nbuf);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700292
Frank Mayhar03901312009-01-07 00:06:22 -0500293 BUG_ON(!ext4_handle_valid(handle));
294
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700295 if (bh)
296 BUFFER_TRACE(bh, "abort");
297
298 if (!handle->h_err)
299 handle->h_err = err;
300
301 if (is_handle_aborted(handle))
302 return;
303
Theodore Ts'o90c72012010-06-29 14:53:24 -0400304 printk(KERN_ERR "%s:%d: aborting transaction: %s in %s\n",
305 caller, line, errstr, err_fn);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700306
Mingming Caodab291a2006-10-11 01:21:01 -0700307 jbd2_journal_abort_handle(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700308}
309
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400310static void __save_error_info(struct super_block *sb, const char *func,
311 unsigned int line)
312{
313 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
314
315 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
316 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
317 es->s_last_error_time = cpu_to_le32(get_seconds());
318 strncpy(es->s_last_error_func, func, sizeof(es->s_last_error_func));
319 es->s_last_error_line = cpu_to_le32(line);
320 if (!es->s_first_error_time) {
321 es->s_first_error_time = es->s_last_error_time;
322 strncpy(es->s_first_error_func, func,
323 sizeof(es->s_first_error_func));
324 es->s_first_error_line = cpu_to_le32(line);
325 es->s_first_error_ino = es->s_last_error_ino;
326 es->s_first_error_block = es->s_last_error_block;
327 }
Theodore Ts'o66e61a92010-07-27 11:56:04 -0400328 /*
329 * Start the daily error reporting function if it hasn't been
330 * started already
331 */
332 if (!es->s_error_count)
333 mod_timer(&EXT4_SB(sb)->s_err_report, jiffies + 24*60*60*HZ);
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400334 es->s_error_count = cpu_to_le32(le32_to_cpu(es->s_error_count) + 1);
335}
336
337static void save_error_info(struct super_block *sb, const char *func,
338 unsigned int line)
339{
340 __save_error_info(sb, func, line);
341 ext4_commit_super(sb, 1);
342}
343
344
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700345/* Deal with the reporting of failure conditions on a filesystem such as
346 * inconsistencies detected or read IO failures.
347 *
348 * On ext2, we can store the error state of the filesystem in the
Mingming Cao617ba132006-10-11 01:20:53 -0700349 * superblock. That is not possible on ext4, because we may have other
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700350 * write ordering constraints on the superblock which prevent us from
351 * writing it out straight away; and given that the journal is about to
352 * be aborted, we can't rely on the current, or future, transactions to
353 * write out the superblock safely.
354 *
Mingming Caodab291a2006-10-11 01:21:01 -0700355 * We'll just use the jbd2_journal_abort() error code to record an error in
Thadeu Lima de Souza Cascardod6b198b2010-01-17 19:10:07 -0200356 * the journal instead. On recovery, the journal will complain about
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700357 * that error until we've noted it down and cleared it.
358 */
359
Mingming Cao617ba132006-10-11 01:20:53 -0700360static void ext4_handle_error(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700361{
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700362 if (sb->s_flags & MS_RDONLY)
363 return;
364
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400365 if (!test_opt(sb, ERRORS_CONT)) {
Mingming Cao617ba132006-10-11 01:20:53 -0700366 journal_t *journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700367
Theodore Ts'o4ab2f152009-06-13 10:09:36 -0400368 EXT4_SB(sb)->s_mount_flags |= EXT4_MF_FS_ABORTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700369 if (journal)
Mingming Caodab291a2006-10-11 01:21:01 -0700370 jbd2_journal_abort(journal, -EIO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700371 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400372 if (test_opt(sb, ERRORS_RO)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -0400373 ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700374 sb->s_flags |= MS_RDONLY;
375 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700376 if (test_opt(sb, ERRORS_PANIC))
Mingming Cao617ba132006-10-11 01:20:53 -0700377 panic("EXT4-fs (device %s): panic forced after error\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700378 sb->s_id);
379}
380
Eric Sandeen12062dd2010-02-15 14:19:27 -0500381void __ext4_error(struct super_block *sb, const char *function,
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400382 unsigned int line, const char *fmt, ...)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700383{
384 va_list args;
385
386 va_start(args, fmt);
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400387 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: comm %s: ",
388 sb->s_id, function, line, current->comm);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700389 vprintk(fmt, args);
390 printk("\n");
391 va_end(args);
392
Mingming Cao617ba132006-10-11 01:20:53 -0700393 ext4_handle_error(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700394}
395
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400396void ext4_error_inode(struct inode *inode, const char *function,
397 unsigned int line, ext4_fsblk_t block,
Frank Mayhar273df552010-03-02 11:46:09 -0500398 const char *fmt, ...)
399{
400 va_list args;
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400401 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
Frank Mayhar273df552010-03-02 11:46:09 -0500402
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400403 es->s_last_error_ino = cpu_to_le32(inode->i_ino);
404 es->s_last_error_block = cpu_to_le64(block);
405 save_error_info(inode->i_sb, function, line);
Frank Mayhar273df552010-03-02 11:46:09 -0500406 va_start(args, fmt);
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400407 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: inode #%lu: ",
408 inode->i_sb->s_id, function, line, inode->i_ino);
409 if (block)
410 printk("block %llu: ", block);
411 printk("comm %s: ", current->comm);
Frank Mayhar273df552010-03-02 11:46:09 -0500412 vprintk(fmt, args);
413 printk("\n");
414 va_end(args);
415
416 ext4_handle_error(inode->i_sb);
417}
418
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400419void ext4_error_file(struct file *file, const char *function,
420 unsigned int line, const char *fmt, ...)
Frank Mayhar273df552010-03-02 11:46:09 -0500421{
422 va_list args;
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400423 struct ext4_super_block *es;
Frank Mayhar273df552010-03-02 11:46:09 -0500424 struct inode *inode = file->f_dentry->d_inode;
425 char pathname[80], *path;
426
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400427 es = EXT4_SB(inode->i_sb)->s_es;
428 es->s_last_error_ino = cpu_to_le32(inode->i_ino);
429 save_error_info(inode->i_sb, function, line);
Frank Mayhar273df552010-03-02 11:46:09 -0500430 va_start(args, fmt);
431 path = d_path(&(file->f_path), pathname, sizeof(pathname));
432 if (!path)
433 path = "(unknown)";
434 printk(KERN_CRIT
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400435 "EXT4-fs error (device %s): %s:%d: inode #%lu "
436 "(comm %s path %s): ",
437 inode->i_sb->s_id, function, line, inode->i_ino,
438 current->comm, path);
Frank Mayhar273df552010-03-02 11:46:09 -0500439 vprintk(fmt, args);
440 printk("\n");
441 va_end(args);
442
443 ext4_handle_error(inode->i_sb);
444}
445
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400446static const char *ext4_decode_error(struct super_block *sb, int errno,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700447 char nbuf[16])
448{
449 char *errstr = NULL;
450
451 switch (errno) {
452 case -EIO:
453 errstr = "IO failure";
454 break;
455 case -ENOMEM:
456 errstr = "Out of memory";
457 break;
458 case -EROFS:
Theodore Ts'o78f1ddb2009-07-27 23:09:47 -0400459 if (!sb || (EXT4_SB(sb)->s_journal &&
460 EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700461 errstr = "Journal has aborted";
462 else
463 errstr = "Readonly filesystem";
464 break;
465 default:
466 /* If the caller passed in an extra buffer for unknown
467 * errors, textualise them now. Else we just return
468 * NULL. */
469 if (nbuf) {
470 /* Check for truncated error codes... */
471 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
472 errstr = nbuf;
473 }
474 break;
475 }
476
477 return errstr;
478}
479
Mingming Cao617ba132006-10-11 01:20:53 -0700480/* __ext4_std_error decodes expected errors from journaling functions
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700481 * automatically and invokes the appropriate error response. */
482
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400483void __ext4_std_error(struct super_block *sb, const char *function,
484 unsigned int line, int errno)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700485{
486 char nbuf[16];
487 const char *errstr;
488
489 /* Special case: if the error is EROFS, and we're not already
490 * inside a transaction, then there's really no point in logging
491 * an error. */
492 if (errno == -EROFS && journal_current_handle() == NULL &&
493 (sb->s_flags & MS_RDONLY))
494 return;
495
Mingming Cao617ba132006-10-11 01:20:53 -0700496 errstr = ext4_decode_error(sb, errno, nbuf);
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400497 printk(KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n",
498 sb->s_id, function, line, errstr);
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400499 save_error_info(sb, function, line);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700500
Mingming Cao617ba132006-10-11 01:20:53 -0700501 ext4_handle_error(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700502}
503
504/*
Mingming Cao617ba132006-10-11 01:20:53 -0700505 * ext4_abort is a much stronger failure handler than ext4_error. The
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700506 * abort function may be used to deal with unrecoverable failures such
507 * as journal IO errors or ENOMEM at a critical moment in log management.
508 *
509 * We unconditionally force the filesystem into an ABORT|READONLY state,
510 * unless the error response on the fs has been set to panic in which
511 * case we take the easy way out and panic immediately.
512 */
513
Theodore Ts'oc67d8592010-06-29 11:07:07 -0400514void __ext4_abort(struct super_block *sb, const char *function,
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400515 unsigned int line, const char *fmt, ...)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700516{
517 va_list args;
518
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400519 save_error_info(sb, function, line);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700520 va_start(args, fmt);
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400521 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: ", sb->s_id,
522 function, line);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700523 vprintk(fmt, args);
524 printk("\n");
525 va_end(args);
526
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400527 if ((sb->s_flags & MS_RDONLY) == 0) {
528 ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
529 sb->s_flags |= MS_RDONLY;
530 EXT4_SB(sb)->s_mount_flags |= EXT4_MF_FS_ABORTED;
531 if (EXT4_SB(sb)->s_journal)
532 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
533 save_error_info(sb, function, line);
534 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700535 if (test_opt(sb, ERRORS_PANIC))
Mingming Cao617ba132006-10-11 01:20:53 -0700536 panic("EXT4-fs panic from previous error\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700537}
538
Eric Sandeenb31e1552009-06-04 17:36:36 -0400539void ext4_msg (struct super_block * sb, const char *prefix,
540 const char *fmt, ...)
541{
542 va_list args;
543
544 va_start(args, fmt);
545 printk("%sEXT4-fs (%s): ", prefix, sb->s_id);
546 vprintk(fmt, args);
547 printk("\n");
548 va_end(args);
549}
550
Eric Sandeen12062dd2010-02-15 14:19:27 -0500551void __ext4_warning(struct super_block *sb, const char *function,
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400552 unsigned int line, const char *fmt, ...)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700553{
554 va_list args;
555
556 va_start(args, fmt);
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400557 printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: ",
558 sb->s_id, function, line);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700559 vprintk(fmt, args);
560 printk("\n");
561 va_end(args);
562}
563
Theodore Ts'oe29136f2010-06-29 12:54:28 -0400564void __ext4_grp_locked_error(const char *function, unsigned int line,
565 struct super_block *sb, ext4_group_t grp,
566 unsigned long ino, ext4_fsblk_t block,
567 const char *fmt, ...)
Aneesh Kumar K.V5d1b1b32009-01-05 22:19:52 -0500568__releases(bitlock)
569__acquires(bitlock)
570{
571 va_list args;
572 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
573
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400574 es->s_last_error_ino = cpu_to_le32(ino);
575 es->s_last_error_block = cpu_to_le64(block);
576 __save_error_info(sb, function, line);
Aneesh Kumar K.V5d1b1b32009-01-05 22:19:52 -0500577 va_start(args, fmt);
Theodore Ts'oe29136f2010-06-29 12:54:28 -0400578 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u",
579 sb->s_id, function, line, grp);
580 if (ino)
581 printk("inode %lu: ", ino);
582 if (block)
583 printk("block %llu:", (unsigned long long) block);
Aneesh Kumar K.V5d1b1b32009-01-05 22:19:52 -0500584 vprintk(fmt, args);
585 printk("\n");
586 va_end(args);
587
588 if (test_opt(sb, ERRORS_CONT)) {
Theodore Ts'oe2d67052009-05-01 00:33:44 -0400589 ext4_commit_super(sb, 0);
Aneesh Kumar K.V5d1b1b32009-01-05 22:19:52 -0500590 return;
591 }
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -0400592
Aneesh Kumar K.V5d1b1b32009-01-05 22:19:52 -0500593 ext4_unlock_group(sb, grp);
594 ext4_handle_error(sb);
595 /*
596 * We only get here in the ERRORS_RO case; relocking the group
597 * may be dangerous, but nothing bad will happen since the
598 * filesystem will have already been marked read/only and the
599 * journal has been aborted. We return 1 as a hint to callers
600 * who might what to use the return value from
601 * ext4_grp_locked_error() to distinguish beween the
602 * ERRORS_CONT and ERRORS_RO case, and perhaps return more
603 * aggressively from the ext4 function in question, with a
604 * more appropriate error code.
605 */
606 ext4_lock_group(sb, grp);
607 return;
608}
609
Mingming Cao617ba132006-10-11 01:20:53 -0700610void ext4_update_dynamic_rev(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700611{
Mingming Cao617ba132006-10-11 01:20:53 -0700612 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700613
Mingming Cao617ba132006-10-11 01:20:53 -0700614 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700615 return;
616
Eric Sandeen12062dd2010-02-15 14:19:27 -0500617 ext4_warning(sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700618 "updating to rev %d because of new feature flag, "
619 "running e2fsck is recommended",
Mingming Cao617ba132006-10-11 01:20:53 -0700620 EXT4_DYNAMIC_REV);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700621
Mingming Cao617ba132006-10-11 01:20:53 -0700622 es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
623 es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
624 es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700625 /* leave es->s_feature_*compat flags alone */
626 /* es->s_uuid will be set by e2fsck if empty */
627
628 /*
629 * The rest of the superblock fields should be zero, and if not it
630 * means they are likely already in use, so leave them alone. We
631 * can leave it up to e2fsck to clean up any inconsistencies there.
632 */
633}
634
635/*
636 * Open the external journal device
637 */
Eric Sandeenb31e1552009-06-04 17:36:36 -0400638static struct block_device *ext4_blkdev_get(dev_t dev, struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700639{
640 struct block_device *bdev;
641 char b[BDEVNAME_SIZE];
642
643 bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
644 if (IS_ERR(bdev))
645 goto fail;
646 return bdev;
647
648fail:
Eric Sandeenb31e1552009-06-04 17:36:36 -0400649 ext4_msg(sb, KERN_ERR, "failed to open journal device %s: %ld",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700650 __bdevname(dev, b), PTR_ERR(bdev));
651 return NULL;
652}
653
654/*
655 * Release the journal device
656 */
Mingming Cao617ba132006-10-11 01:20:53 -0700657static int ext4_blkdev_put(struct block_device *bdev)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700658{
659 bd_release(bdev);
Al Viro9a1c3542008-02-22 20:40:24 -0500660 return blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700661}
662
Mingming Cao617ba132006-10-11 01:20:53 -0700663static int ext4_blkdev_remove(struct ext4_sb_info *sbi)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700664{
665 struct block_device *bdev;
666 int ret = -ENODEV;
667
668 bdev = sbi->journal_bdev;
669 if (bdev) {
Mingming Cao617ba132006-10-11 01:20:53 -0700670 ret = ext4_blkdev_put(bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700671 sbi->journal_bdev = NULL;
672 }
673 return ret;
674}
675
676static inline struct inode *orphan_list_entry(struct list_head *l)
677{
Mingming Cao617ba132006-10-11 01:20:53 -0700678 return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700679}
680
Mingming Cao617ba132006-10-11 01:20:53 -0700681static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700682{
683 struct list_head *l;
684
Eric Sandeenb31e1552009-06-04 17:36:36 -0400685 ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
686 le32_to_cpu(sbi->s_es->s_last_orphan));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700687
688 printk(KERN_ERR "sb_info orphan list:\n");
689 list_for_each(l, &sbi->s_orphan) {
690 struct inode *inode = orphan_list_entry(l);
691 printk(KERN_ERR " "
692 "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
693 inode->i_sb->s_id, inode->i_ino, inode,
694 inode->i_mode, inode->i_nlink,
695 NEXT_ORPHAN(inode));
696 }
697}
698
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400699static void ext4_put_super(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700700{
Mingming Cao617ba132006-10-11 01:20:53 -0700701 struct ext4_sb_info *sbi = EXT4_SB(sb);
702 struct ext4_super_block *es = sbi->s_es;
Hidehiro Kawaief2cabf2008-10-27 22:53:05 -0400703 int i, err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700704
Christoph Hellwige0ccfd92010-05-19 07:16:42 -0400705 dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
706
Mingming Cao4c0425f2009-09-28 15:48:41 -0400707 flush_workqueue(sbi->dio_unwritten_wq);
708 destroy_workqueue(sbi->dio_unwritten_wq);
709
Al Viroa9e220f2009-05-05 22:10:44 -0400710 lock_super(sb);
Christoph Hellwig6cfd0142009-05-05 15:40:36 +0200711 lock_kernel();
Christoph Hellwig8c85e122009-04-28 18:00:26 +0200712 if (sb->s_dirt)
Christoph Hellwigebc1ac12009-05-11 23:35:03 +0200713 ext4_commit_super(sb, 1);
Christoph Hellwig8c85e122009-04-28 18:00:26 +0200714
Frank Mayhar03901312009-01-07 00:06:22 -0500715 if (sbi->s_journal) {
716 err = jbd2_journal_destroy(sbi->s_journal);
717 sbi->s_journal = NULL;
718 if (err < 0)
Theodore Ts'oc67d8592010-06-29 11:07:07 -0400719 ext4_abort(sb, "Couldn't clean up the journal");
Frank Mayhar03901312009-01-07 00:06:22 -0500720 }
Josef Bacikd4edac32009-12-08 21:48:58 -0500721
722 ext4_release_system_zone(sb);
723 ext4_mb_release(sb);
724 ext4_ext_release(sb);
725 ext4_xattr_put_super(sb);
726
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700727 if (!(sb->s_flags & MS_RDONLY)) {
Mingming Cao617ba132006-10-11 01:20:53 -0700728 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700729 es->s_state = cpu_to_le16(sbi->s_mount_state);
Theodore Ts'oe2d67052009-05-01 00:33:44 -0400730 ext4_commit_super(sb, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700731 }
Theodore Ts'o240799c2008-10-09 23:53:47 -0400732 if (sbi->s_proc) {
Theodore Ts'o9f6200b2008-09-23 09:18:24 -0400733 remove_proc_entry(sb->s_id, ext4_proc_root);
Theodore Ts'o240799c2008-10-09 23:53:47 -0400734 }
Theodore Ts'o3197ebd2009-03-31 09:10:09 -0400735 kobject_del(&sbi->s_kobj);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700736
737 for (i = 0; i < sbi->s_gdb_count; i++)
738 brelse(sbi->s_group_desc[i]);
739 kfree(sbi->s_group_desc);
Theodore Ts'oc5ca7c72009-04-27 22:48:48 -0400740 if (is_vmalloc_addr(sbi->s_flex_groups))
741 vfree(sbi->s_flex_groups);
742 else
743 kfree(sbi->s_flex_groups);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700744 percpu_counter_destroy(&sbi->s_freeblocks_counter);
745 percpu_counter_destroy(&sbi->s_freeinodes_counter);
746 percpu_counter_destroy(&sbi->s_dirs_counter);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400747 percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700748 brelse(sbi->s_sbh);
749#ifdef CONFIG_QUOTA
750 for (i = 0; i < MAXQUOTAS; i++)
751 kfree(sbi->s_qf_names[i]);
752#endif
753
754 /* Debugging code just in case the in-memory inode orphan list
755 * isn't empty. The on-disk one can be non-empty if we've
756 * detected an error and taken the fs readonly, but the
757 * in-memory list had better be clean by this point. */
758 if (!list_empty(&sbi->s_orphan))
759 dump_orphan_list(sb, sbi);
760 J_ASSERT(list_empty(&sbi->s_orphan));
761
Peter Zijlstraf98393a2007-05-06 14:49:54 -0700762 invalidate_bdev(sb->s_bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700763 if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
764 /*
765 * Invalidate the journal device's buffers. We don't want them
766 * floating about in memory - the physical journal device may
767 * hotswapped, and it breaks the `ro-after' testing code.
768 */
769 sync_blockdev(sbi->journal_bdev);
Peter Zijlstraf98393a2007-05-06 14:49:54 -0700770 invalidate_bdev(sbi->journal_bdev);
Mingming Cao617ba132006-10-11 01:20:53 -0700771 ext4_blkdev_remove(sbi);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700772 }
773 sb->s_fs_info = NULL;
Theodore Ts'o3197ebd2009-03-31 09:10:09 -0400774 /*
775 * Now that we are completely done shutting down the
776 * superblock, we need to actually destroy the kobject.
777 */
778 unlock_kernel();
779 unlock_super(sb);
780 kobject_put(&sbi->s_kobj);
781 wait_for_completion(&sbi->s_kobj_unregister);
Pekka Enberg705895b2009-02-15 18:07:52 -0500782 kfree(sbi->s_blockgroup_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700783 kfree(sbi);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700784}
785
Christoph Lametere18b8902006-12-06 20:33:20 -0800786static struct kmem_cache *ext4_inode_cachep;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700787
788/*
789 * Called inside transaction, so use GFP_NOFS
790 */
Mingming Cao617ba132006-10-11 01:20:53 -0700791static struct inode *ext4_alloc_inode(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700792{
Mingming Cao617ba132006-10-11 01:20:53 -0700793 struct ext4_inode_info *ei;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700794
Christoph Lametere6b4f8d2006-12-06 20:33:14 -0800795 ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700796 if (!ei)
797 return NULL;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400798
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700799 ei->vfs_inode.i_version = 1;
Aneesh Kumar K.V91246c02008-08-19 21:14:52 -0400800 ei->vfs_inode.i_data.writeback_index = 0;
Alex Tomasa86c6182006-10-11 01:21:03 -0700801 memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
Alex Tomasc9de5602008-01-29 00:19:52 -0500802 INIT_LIST_HEAD(&ei->i_prealloc_list);
803 spin_lock_init(&ei->i_prealloc_lock);
Frank Mayhar03901312009-01-07 00:06:22 -0500804 /*
805 * Note: We can be called before EXT4_SB(sb)->s_journal is set,
806 * therefore it can be null here. Don't check it, just initialize
807 * jinode.
808 */
Jan Kara678aaf42008-07-11 19:27:31 -0400809 jbd2_journal_init_jbd_inode(&ei->jinode, &ei->vfs_inode);
Mingming Caod2a17632008-07-14 17:52:37 -0400810 ei->i_reserved_data_blocks = 0;
811 ei->i_reserved_meta_blocks = 0;
812 ei->i_allocated_meta_blocks = 0;
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500813 ei->i_da_metadata_calc_len = 0;
Mingming Caod2a17632008-07-14 17:52:37 -0400814 ei->i_delalloc_reserved_flag = 0;
815 spin_lock_init(&(ei->i_block_reservation_lock));
Dmitry Monakhova9e7f442009-12-14 15:21:14 +0300816#ifdef CONFIG_QUOTA
817 ei->i_reserved_quota = 0;
818#endif
Jiaying Zhangc7064ef2010-03-02 13:28:44 -0500819 INIT_LIST_HEAD(&ei->i_completed_io_list);
Jiaying Zhang744692d2010-03-04 16:14:02 -0500820 spin_lock_init(&ei->i_completed_io_lock);
Mingming Cao8d5d02e2009-09-28 15:48:29 -0400821 ei->cur_aio_dio = NULL;
Jan Karab436b9b2009-12-08 23:51:10 -0500822 ei->i_sync_tid = 0;
823 ei->i_datasync_tid = 0;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -0400824
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700825 return &ei->vfs_inode;
826}
827
Mingming Cao617ba132006-10-11 01:20:53 -0700828static void ext4_destroy_inode(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700829{
Vasily Averin9f7dd932007-07-15 23:40:45 -0700830 if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
Eric Sandeenb31e1552009-06-04 17:36:36 -0400831 ext4_msg(inode->i_sb, KERN_ERR,
832 "Inode %lu (%p): orphan list check failed!",
833 inode->i_ino, EXT4_I(inode));
Vasily Averin9f7dd932007-07-15 23:40:45 -0700834 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
835 EXT4_I(inode), sizeof(struct ext4_inode_info),
836 true);
837 dump_stack();
838 }
Mingming Cao617ba132006-10-11 01:20:53 -0700839 kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700840}
841
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700842static void init_once(void *foo)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700843{
Mingming Cao617ba132006-10-11 01:20:53 -0700844 struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700845
Christoph Lametera35afb82007-05-16 22:10:57 -0700846 INIT_LIST_HEAD(&ei->i_orphan);
Theodore Ts'o03010a32008-10-10 20:02:48 -0400847#ifdef CONFIG_EXT4_FS_XATTR
Christoph Lametera35afb82007-05-16 22:10:57 -0700848 init_rwsem(&ei->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700849#endif
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500850 init_rwsem(&ei->i_data_sem);
Christoph Lametera35afb82007-05-16 22:10:57 -0700851 inode_init_once(&ei->vfs_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700852}
853
854static int init_inodecache(void)
855{
Mingming Cao617ba132006-10-11 01:20:53 -0700856 ext4_inode_cachep = kmem_cache_create("ext4_inode_cache",
857 sizeof(struct ext4_inode_info),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700858 0, (SLAB_RECLAIM_ACCOUNT|
859 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900860 init_once);
Mingming Cao617ba132006-10-11 01:20:53 -0700861 if (ext4_inode_cachep == NULL)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700862 return -ENOMEM;
863 return 0;
864}
865
866static void destroy_inodecache(void)
867{
Mingming Cao617ba132006-10-11 01:20:53 -0700868 kmem_cache_destroy(ext4_inode_cachep);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700869}
870
Al Viro0930fcc2010-06-07 13:16:22 -0400871void ext4_clear_inode(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700872{
Al Viro0930fcc2010-06-07 13:16:22 -0400873 invalidate_inode_buffers(inode);
874 end_writeback(inode);
Christoph Hellwig9f754752010-03-03 09:05:05 -0500875 dquot_drop(inode);
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400876 ext4_discard_preallocations(inode);
Frank Mayhar03901312009-01-07 00:06:22 -0500877 if (EXT4_JOURNAL(inode))
878 jbd2_journal_release_jbd_inode(EXT4_SB(inode->i_sb)->s_journal,
Jan Kara678aaf42008-07-11 19:27:31 -0400879 &EXT4_I(inode)->jinode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700880}
881
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400882static inline void ext4_show_quota_options(struct seq_file *seq,
883 struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700884{
885#if defined(CONFIG_QUOTA)
Mingming Cao617ba132006-10-11 01:20:53 -0700886 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700887
Jan Kara5a20bdf2009-11-30 23:58:32 +0100888 if (sbi->s_jquota_fmt) {
889 char *fmtname = "";
890
891 switch (sbi->s_jquota_fmt) {
892 case QFMT_VFS_OLD:
893 fmtname = "vfsold";
894 break;
895 case QFMT_VFS_V0:
896 fmtname = "vfsv0";
897 break;
898 case QFMT_VFS_V1:
899 fmtname = "vfsv1";
900 break;
901 }
902 seq_printf(seq, ",jqfmt=%s", fmtname);
903 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700904
905 if (sbi->s_qf_names[USRQUOTA])
906 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
907
908 if (sbi->s_qf_names[GRPQUOTA])
909 seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
910
Dmitry Monakhov482a7422010-02-24 11:35:32 -0500911 if (test_opt(sb, USRQUOTA))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700912 seq_puts(seq, ",usrquota");
913
Dmitry Monakhov482a7422010-02-24 11:35:32 -0500914 if (test_opt(sb, GRPQUOTA))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700915 seq_puts(seq, ",grpquota");
916#endif
917}
918
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700919/*
920 * Show an option if
921 * - it's set to a non-default value OR
922 * - if the per-sb default is different from the global default
923 */
Mingming Cao617ba132006-10-11 01:20:53 -0700924static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700925{
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500926 int def_errors;
927 unsigned long def_mount_opts;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700928 struct super_block *sb = vfs->mnt_sb;
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700929 struct ext4_sb_info *sbi = EXT4_SB(sb);
930 struct ext4_super_block *es = sbi->s_es;
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700931
932 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500933 def_errors = le16_to_cpu(es->s_errors);
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700934
935 if (sbi->s_sb_block != 1)
936 seq_printf(seq, ",sb=%llu", sbi->s_sb_block);
937 if (test_opt(sb, MINIX_DF))
938 seq_puts(seq, ",minixdf");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500939 if (test_opt(sb, GRPID) && !(def_mount_opts & EXT4_DEFM_BSDGROUPS))
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700940 seq_puts(seq, ",grpid");
941 if (!test_opt(sb, GRPID) && (def_mount_opts & EXT4_DEFM_BSDGROUPS))
942 seq_puts(seq, ",nogrpid");
943 if (sbi->s_resuid != EXT4_DEF_RESUID ||
944 le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID) {
945 seq_printf(seq, ",resuid=%u", sbi->s_resuid);
946 }
947 if (sbi->s_resgid != EXT4_DEF_RESGID ||
948 le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID) {
949 seq_printf(seq, ",resgid=%u", sbi->s_resgid);
950 }
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -0500951 if (test_opt(sb, ERRORS_RO)) {
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700952 if (def_errors == EXT4_ERRORS_PANIC ||
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -0500953 def_errors == EXT4_ERRORS_CONTINUE) {
954 seq_puts(seq, ",errors=remount-ro");
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700955 }
956 }
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500957 if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -0500958 seq_puts(seq, ",errors=continue");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500959 if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700960 seq_puts(seq, ",errors=panic");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500961 if (test_opt(sb, NO_UID32) && !(def_mount_opts & EXT4_DEFM_UID16))
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700962 seq_puts(seq, ",nouid32");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500963 if (test_opt(sb, DEBUG) && !(def_mount_opts & EXT4_DEFM_DEBUG))
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700964 seq_puts(seq, ",debug");
965 if (test_opt(sb, OLDALLOC))
966 seq_puts(seq, ",oldalloc");
Theodore Ts'o03010a32008-10-10 20:02:48 -0400967#ifdef CONFIG_EXT4_FS_XATTR
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500968 if (test_opt(sb, XATTR_USER) &&
969 !(def_mount_opts & EXT4_DEFM_XATTR_USER))
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700970 seq_puts(seq, ",user_xattr");
971 if (!test_opt(sb, XATTR_USER) &&
972 (def_mount_opts & EXT4_DEFM_XATTR_USER)) {
973 seq_puts(seq, ",nouser_xattr");
974 }
975#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -0400976#ifdef CONFIG_EXT4_FS_POSIX_ACL
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500977 if (test_opt(sb, POSIX_ACL) && !(def_mount_opts & EXT4_DEFM_ACL))
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700978 seq_puts(seq, ",acl");
979 if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT4_DEFM_ACL))
980 seq_puts(seq, ",noacl");
981#endif
Theodore Ts'o30773842009-01-03 20:27:38 -0500982 if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
Miklos Szeredid9c9bef2007-10-16 23:26:27 -0700983 seq_printf(seq, ",commit=%u",
984 (unsigned) (sbi->s_commit_interval / HZ));
985 }
Theodore Ts'o30773842009-01-03 20:27:38 -0500986 if (sbi->s_min_batch_time != EXT4_DEF_MIN_BATCH_TIME) {
987 seq_printf(seq, ",min_batch_time=%u",
988 (unsigned) sbi->s_min_batch_time);
989 }
990 if (sbi->s_max_batch_time != EXT4_DEF_MAX_BATCH_TIME) {
991 seq_printf(seq, ",max_batch_time=%u",
992 (unsigned) sbi->s_min_batch_time);
993 }
994
Eric Sandeen571640c2008-05-26 12:29:46 -0400995 /*
996 * We're changing the default of barrier mount option, so
997 * let's always display its mount state so it's clear what its
998 * status is.
999 */
1000 seq_puts(seq, ",barrier=");
1001 seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
Theodore Ts'ocd0b6a32008-05-26 10:28:28 -04001002 if (test_opt(sb, JOURNAL_ASYNC_COMMIT))
1003 seq_puts(seq, ",journal_async_commit");
Jan Kara39a4bad2010-05-16 17:00:00 -04001004 else if (test_opt(sb, JOURNAL_CHECKSUM))
1005 seq_puts(seq, ",journal_checksum");
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05001006 if (test_opt(sb, I_VERSION))
1007 seq_puts(seq, ",i_version");
Theodore Ts'o8b67f042010-08-01 23:14:20 -04001008 if (!test_opt(sb, DELALLOC) &&
1009 !(def_mount_opts & EXT4_DEFM_NODELALLOC))
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04001010 seq_puts(seq, ",nodelalloc");
1011
Miklos Szeredicb45bbe2008-01-28 23:58:27 -05001012 if (sbi->s_stripe)
1013 seq_printf(seq, ",stripe=%lu", sbi->s_stripe);
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -05001014 /*
1015 * journal mode get enabled in different ways
1016 * So just print the value even if we didn't specify it
1017 */
Mingming Cao617ba132006-10-11 01:20:53 -07001018 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001019 seq_puts(seq, ",data=journal");
Mingming Cao617ba132006-10-11 01:20:53 -07001020 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001021 seq_puts(seq, ",data=ordered");
Mingming Cao617ba132006-10-11 01:20:53 -07001022 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001023 seq_puts(seq, ",data=writeback");
1024
Theodore Ts'o240799c2008-10-09 23:53:47 -04001025 if (sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
1026 seq_printf(seq, ",inode_readahead_blks=%u",
1027 sbi->s_inode_readahead_blks);
1028
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04001029 if (test_opt(sb, DATA_ERR_ABORT))
1030 seq_puts(seq, ",data_err=abort");
1031
Theodore Ts'oafd46722009-03-16 23:12:23 -04001032 if (test_opt(sb, NO_AUTO_DA_ALLOC))
Theodore Ts'o06705bf2009-03-28 10:59:57 -04001033 seq_puts(seq, ",noauto_da_alloc");
Theodore Ts'oafd46722009-03-16 23:12:23 -04001034
Theodore Ts'o8b67f042010-08-01 23:14:20 -04001035 if (test_opt(sb, DISCARD) && !(def_mount_opts & EXT4_DEFM_DISCARD))
Eric Sandeen5328e632009-11-19 14:25:42 -05001036 seq_puts(seq, ",discard");
1037
Eric Sandeene3bb52a2009-11-19 14:28:50 -05001038 if (test_opt(sb, NOLOAD))
1039 seq_puts(seq, ",norecovery");
1040
Jiaying Zhang744692d2010-03-04 16:14:02 -05001041 if (test_opt(sb, DIOREAD_NOLOCK))
1042 seq_puts(seq, ",dioread_nolock");
1043
Theodore Ts'o8b67f042010-08-01 23:14:20 -04001044 if (test_opt(sb, BLOCK_VALIDITY) &&
1045 !(def_mount_opts & EXT4_DEFM_BLOCK_VALIDITY))
1046 seq_puts(seq, ",block_validity");
1047
Mingming Cao617ba132006-10-11 01:20:53 -07001048 ext4_show_quota_options(seq, sb);
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001049
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001050 return 0;
1051}
1052
Christoph Hellwig1b961ac2007-10-21 16:42:08 -07001053static struct inode *ext4_nfs_get_inode(struct super_block *sb,
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001054 u64 ino, u32 generation)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001055{
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001056 struct inode *inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001057
Mingming Cao617ba132006-10-11 01:20:53 -07001058 if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001059 return ERR_PTR(-ESTALE);
Mingming Cao617ba132006-10-11 01:20:53 -07001060 if (ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001061 return ERR_PTR(-ESTALE);
1062
1063 /* iget isn't really right if the inode is currently unallocated!!
1064 *
Mingming Cao617ba132006-10-11 01:20:53 -07001065 * ext4_read_inode will return a bad_inode if the inode had been
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001066 * deleted, so we should be safe.
1067 *
1068 * Currently we don't know the generation for parent directory, so
1069 * a generation of 0 means "accept any"
1070 */
David Howells1d1fe1e2008-02-07 00:15:37 -08001071 inode = ext4_iget(sb, ino);
1072 if (IS_ERR(inode))
1073 return ERR_CAST(inode);
1074 if (generation && inode->i_generation != generation) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001075 iput(inode);
1076 return ERR_PTR(-ESTALE);
1077 }
Christoph Hellwig1b961ac2007-10-21 16:42:08 -07001078
1079 return inode;
1080}
1081
1082static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001083 int fh_len, int fh_type)
Christoph Hellwig1b961ac2007-10-21 16:42:08 -07001084{
1085 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
1086 ext4_nfs_get_inode);
1087}
1088
1089static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001090 int fh_len, int fh_type)
Christoph Hellwig1b961ac2007-10-21 16:42:08 -07001091{
1092 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
1093 ext4_nfs_get_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001094}
1095
Toshiyuki Okajimac39a7f82009-01-05 22:38:48 -05001096/*
1097 * Try to release metadata pages (indirect blocks, directories) which are
1098 * mapped via the block device. Since these pages could have journal heads
1099 * which would prevent try_to_free_buffers() from freeing them, we must use
1100 * jbd2 layer's try_to_free_buffers() function to release them.
1101 */
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001102static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
1103 gfp_t wait)
Toshiyuki Okajimac39a7f82009-01-05 22:38:48 -05001104{
1105 journal_t *journal = EXT4_SB(sb)->s_journal;
1106
1107 WARN_ON(PageChecked(page));
1108 if (!page_has_buffers(page))
1109 return 0;
1110 if (journal)
1111 return jbd2_journal_try_to_free_buffers(journal, page,
1112 wait & ~__GFP_WAIT);
1113 return try_to_free_buffers(page);
1114}
1115
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001116#ifdef CONFIG_QUOTA
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001117#define QTYPE2NAME(t) ((t) == USRQUOTA ? "user" : "group")
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001118#define QTYPE2MOPT(on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001119
Mingming Cao617ba132006-10-11 01:20:53 -07001120static int ext4_write_dquot(struct dquot *dquot);
1121static int ext4_acquire_dquot(struct dquot *dquot);
1122static int ext4_release_dquot(struct dquot *dquot);
1123static int ext4_mark_dquot_dirty(struct dquot *dquot);
1124static int ext4_write_info(struct super_block *sb, int type);
Jan Kara6f28e082008-04-28 02:14:34 -07001125static int ext4_quota_on(struct super_block *sb, int type, int format_id,
Christoph Hellwig307ae182010-05-19 07:16:43 -04001126 char *path);
Dmitry Monakhovca0e05e2010-08-01 17:48:36 -04001127static int ext4_quota_off(struct super_block *sb, int type);
Mingming Cao617ba132006-10-11 01:20:53 -07001128static int ext4_quota_on_mount(struct super_block *sb, int type);
1129static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001130 size_t len, loff_t off);
Mingming Cao617ba132006-10-11 01:20:53 -07001131static ssize_t ext4_quota_write(struct super_block *sb, int type,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001132 const char *data, size_t len, loff_t off);
1133
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07001134static const struct dquot_operations ext4_quota_operations = {
Dmitry Monakhova9e7f442009-12-14 15:21:14 +03001135#ifdef CONFIG_QUOTA
Mingming Cao60e58e02009-01-22 18:13:05 +01001136 .get_reserved_space = ext4_get_reserved_space,
Dmitry Monakhova9e7f442009-12-14 15:21:14 +03001137#endif
Mingming Cao617ba132006-10-11 01:20:53 -07001138 .write_dquot = ext4_write_dquot,
1139 .acquire_dquot = ext4_acquire_dquot,
1140 .release_dquot = ext4_release_dquot,
1141 .mark_dirty = ext4_mark_dquot_dirty,
Jan Karaa5b5ee32008-11-25 15:31:35 +01001142 .write_info = ext4_write_info,
1143 .alloc_dquot = dquot_alloc,
1144 .destroy_dquot = dquot_destroy,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001145};
1146
Alexey Dobriyan0d54b212009-09-21 17:01:09 -07001147static const struct quotactl_ops ext4_qctl_operations = {
Mingming Cao617ba132006-10-11 01:20:53 -07001148 .quota_on = ext4_quota_on,
Dmitry Monakhovca0e05e2010-08-01 17:48:36 -04001149 .quota_off = ext4_quota_off,
Christoph Hellwig287a8092010-05-19 07:16:45 -04001150 .quota_sync = dquot_quota_sync,
1151 .get_info = dquot_get_dqinfo,
1152 .set_info = dquot_set_dqinfo,
1153 .get_dqblk = dquot_get_dqblk,
1154 .set_dqblk = dquot_set_dqblk
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001155};
1156#endif
1157
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -08001158static const struct super_operations ext4_sops = {
Mingming Cao617ba132006-10-11 01:20:53 -07001159 .alloc_inode = ext4_alloc_inode,
1160 .destroy_inode = ext4_destroy_inode,
Mingming Cao617ba132006-10-11 01:20:53 -07001161 .write_inode = ext4_write_inode,
1162 .dirty_inode = ext4_dirty_inode,
Al Viro0930fcc2010-06-07 13:16:22 -04001163 .evict_inode = ext4_evict_inode,
Mingming Cao617ba132006-10-11 01:20:53 -07001164 .put_super = ext4_put_super,
Mingming Cao617ba132006-10-11 01:20:53 -07001165 .sync_fs = ext4_sync_fs,
Takashi Satoc4be0c12009-01-09 16:40:58 -08001166 .freeze_fs = ext4_freeze,
1167 .unfreeze_fs = ext4_unfreeze,
Mingming Cao617ba132006-10-11 01:20:53 -07001168 .statfs = ext4_statfs,
1169 .remount_fs = ext4_remount,
Mingming Cao617ba132006-10-11 01:20:53 -07001170 .show_options = ext4_show_options,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001171#ifdef CONFIG_QUOTA
Mingming Cao617ba132006-10-11 01:20:53 -07001172 .quota_read = ext4_quota_read,
1173 .quota_write = ext4_quota_write,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001174#endif
Toshiyuki Okajimac39a7f82009-01-05 22:38:48 -05001175 .bdev_try_to_free_page = bdev_try_to_free_page,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001176};
1177
Theodore Ts'o9ca92382009-05-01 12:52:25 -04001178static const struct super_operations ext4_nojournal_sops = {
1179 .alloc_inode = ext4_alloc_inode,
1180 .destroy_inode = ext4_destroy_inode,
1181 .write_inode = ext4_write_inode,
1182 .dirty_inode = ext4_dirty_inode,
Al Viro0930fcc2010-06-07 13:16:22 -04001183 .evict_inode = ext4_evict_inode,
Theodore Ts'o9ca92382009-05-01 12:52:25 -04001184 .write_super = ext4_write_super,
1185 .put_super = ext4_put_super,
1186 .statfs = ext4_statfs,
1187 .remount_fs = ext4_remount,
Theodore Ts'o9ca92382009-05-01 12:52:25 -04001188 .show_options = ext4_show_options,
1189#ifdef CONFIG_QUOTA
1190 .quota_read = ext4_quota_read,
1191 .quota_write = ext4_quota_write,
1192#endif
1193 .bdev_try_to_free_page = bdev_try_to_free_page,
1194};
1195
Christoph Hellwig39655162007-10-21 16:42:17 -07001196static const struct export_operations ext4_export_ops = {
Christoph Hellwig1b961ac2007-10-21 16:42:08 -07001197 .fh_to_dentry = ext4_fh_to_dentry,
1198 .fh_to_parent = ext4_fh_to_parent,
Mingming Cao617ba132006-10-11 01:20:53 -07001199 .get_parent = ext4_get_parent,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001200};
1201
1202enum {
1203 Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
1204 Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
Theodore Ts'o01436ef2008-10-17 07:22:35 -04001205 Opt_nouid32, Opt_debug, Opt_oldalloc, Opt_orlov,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001206 Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
Theodore Ts'o06705bf2009-03-28 10:59:57 -04001207 Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload, Opt_nobh, Opt_bh,
Theodore Ts'o30773842009-01-03 20:27:38 -05001208 Opt_commit, Opt_min_batch_time, Opt_max_batch_time,
Theodore Ts'oc3191062009-01-06 11:14:25 -05001209 Opt_journal_update, Opt_journal_dev,
Girish Shilamkar818d2762008-01-28 23:58:27 -05001210 Opt_journal_checksum, Opt_journal_async_commit,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001211 Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
Theodore Ts'o296c3552009-09-30 00:32:42 -04001212 Opt_data_err_abort, Opt_data_err_ignore,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001213 Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
Jan Kara5a20bdf2009-11-30 23:58:32 +01001214 Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1215 Opt_noquota, Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err,
1216 Opt_resize, Opt_usrquota, Opt_grpquota, Opt_i_version,
Theodore Ts'o01436ef2008-10-17 07:22:35 -04001217 Opt_stripe, Opt_delalloc, Opt_nodelalloc,
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04001218 Opt_block_validity, Opt_noblock_validity,
Eric Sandeen5328e632009-11-19 14:25:42 -05001219 Opt_inode_readahead_blks, Opt_journal_ioprio,
Jiaying Zhang744692d2010-03-04 16:14:02 -05001220 Opt_dioread_nolock, Opt_dioread_lock,
Eric Sandeen5328e632009-11-19 14:25:42 -05001221 Opt_discard, Opt_nodiscard,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001222};
1223
Steven Whitehousea447c092008-10-13 10:46:57 +01001224static const match_table_t tokens = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001225 {Opt_bsd_df, "bsddf"},
1226 {Opt_minix_df, "minixdf"},
1227 {Opt_grpid, "grpid"},
1228 {Opt_grpid, "bsdgroups"},
1229 {Opt_nogrpid, "nogrpid"},
1230 {Opt_nogrpid, "sysvgroups"},
1231 {Opt_resgid, "resgid=%u"},
1232 {Opt_resuid, "resuid=%u"},
1233 {Opt_sb, "sb=%u"},
1234 {Opt_err_cont, "errors=continue"},
1235 {Opt_err_panic, "errors=panic"},
1236 {Opt_err_ro, "errors=remount-ro"},
1237 {Opt_nouid32, "nouid32"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001238 {Opt_debug, "debug"},
1239 {Opt_oldalloc, "oldalloc"},
1240 {Opt_orlov, "orlov"},
1241 {Opt_user_xattr, "user_xattr"},
1242 {Opt_nouser_xattr, "nouser_xattr"},
1243 {Opt_acl, "acl"},
1244 {Opt_noacl, "noacl"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001245 {Opt_noload, "noload"},
Eric Sandeene3bb52a2009-11-19 14:28:50 -05001246 {Opt_noload, "norecovery"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001247 {Opt_nobh, "nobh"},
1248 {Opt_bh, "bh"},
1249 {Opt_commit, "commit=%u"},
Theodore Ts'o30773842009-01-03 20:27:38 -05001250 {Opt_min_batch_time, "min_batch_time=%u"},
1251 {Opt_max_batch_time, "max_batch_time=%u"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001252 {Opt_journal_update, "journal=update"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001253 {Opt_journal_dev, "journal_dev=%u"},
Girish Shilamkar818d2762008-01-28 23:58:27 -05001254 {Opt_journal_checksum, "journal_checksum"},
1255 {Opt_journal_async_commit, "journal_async_commit"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001256 {Opt_abort, "abort"},
1257 {Opt_data_journal, "data=journal"},
1258 {Opt_data_ordered, "data=ordered"},
1259 {Opt_data_writeback, "data=writeback"},
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04001260 {Opt_data_err_abort, "data_err=abort"},
1261 {Opt_data_err_ignore, "data_err=ignore"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001262 {Opt_offusrjquota, "usrjquota="},
1263 {Opt_usrjquota, "usrjquota=%s"},
1264 {Opt_offgrpjquota, "grpjquota="},
1265 {Opt_grpjquota, "grpjquota=%s"},
1266 {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
1267 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
Jan Kara5a20bdf2009-11-30 23:58:32 +01001268 {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001269 {Opt_grpquota, "grpquota"},
1270 {Opt_noquota, "noquota"},
1271 {Opt_quota, "quota"},
1272 {Opt_usrquota, "usrquota"},
1273 {Opt_barrier, "barrier=%u"},
Theodore Ts'o06705bf2009-03-28 10:59:57 -04001274 {Opt_barrier, "barrier"},
1275 {Opt_nobarrier, "nobarrier"},
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05001276 {Opt_i_version, "i_version"},
Alex Tomasc9de5602008-01-29 00:19:52 -05001277 {Opt_stripe, "stripe=%u"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001278 {Opt_resize, "resize"},
Alex Tomas64769242008-07-11 19:27:31 -04001279 {Opt_delalloc, "delalloc"},
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04001280 {Opt_nodelalloc, "nodelalloc"},
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04001281 {Opt_block_validity, "block_validity"},
1282 {Opt_noblock_validity, "noblock_validity"},
Theodore Ts'o240799c2008-10-09 23:53:47 -04001283 {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
Theodore Ts'ob3881f72009-01-05 22:46:26 -05001284 {Opt_journal_ioprio, "journal_ioprio=%u"},
Theodore Ts'oafd46722009-03-16 23:12:23 -04001285 {Opt_auto_da_alloc, "auto_da_alloc=%u"},
Theodore Ts'o06705bf2009-03-28 10:59:57 -04001286 {Opt_auto_da_alloc, "auto_da_alloc"},
1287 {Opt_noauto_da_alloc, "noauto_da_alloc"},
Jiaying Zhang744692d2010-03-04 16:14:02 -05001288 {Opt_dioread_nolock, "dioread_nolock"},
1289 {Opt_dioread_lock, "dioread_lock"},
Eric Sandeen5328e632009-11-19 14:25:42 -05001290 {Opt_discard, "discard"},
1291 {Opt_nodiscard, "nodiscard"},
Josef Bacikf3f12fa2008-04-29 22:05:28 -04001292 {Opt_err, NULL},
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001293};
1294
Mingming Cao617ba132006-10-11 01:20:53 -07001295static ext4_fsblk_t get_sb_block(void **data)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001296{
Mingming Cao617ba132006-10-11 01:20:53 -07001297 ext4_fsblk_t sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001298 char *options = (char *) *data;
1299
1300 if (!options || strncmp(options, "sb=", 3) != 0)
1301 return 1; /* Default location */
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001302
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001303 options += 3;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001304 /* TODO: use simple_strtoll with >32bit ext4 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001305 sb_block = simple_strtoul(options, &options, 0);
1306 if (*options && *options != ',') {
Theodore Ts'o47760042008-09-08 23:00:52 -04001307 printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001308 (char *) *data);
1309 return 1;
1310 }
1311 if (*options == ',')
1312 options++;
1313 *data = (void *) options;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001314
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001315 return sb_block;
1316}
1317
Theodore Ts'ob3881f72009-01-05 22:46:26 -05001318#define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001319static char deprecated_msg[] = "Mount option \"%s\" will be removed by %s\n"
1320 "Contact linux-ext4@vger.kernel.org if you think we should keep it.\n";
Theodore Ts'ob3881f72009-01-05 22:46:26 -05001321
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001322#ifdef CONFIG_QUOTA
1323static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
1324{
1325 struct ext4_sb_info *sbi = EXT4_SB(sb);
1326 char *qname;
1327
1328 if (sb_any_quota_loaded(sb) &&
1329 !sbi->s_qf_names[qtype]) {
1330 ext4_msg(sb, KERN_ERR,
1331 "Cannot change journaled "
1332 "quota options when quota turned on");
1333 return 0;
1334 }
1335 qname = match_strdup(args);
1336 if (!qname) {
1337 ext4_msg(sb, KERN_ERR,
1338 "Not enough memory for storing quotafile name");
1339 return 0;
1340 }
1341 if (sbi->s_qf_names[qtype] &&
1342 strcmp(sbi->s_qf_names[qtype], qname)) {
1343 ext4_msg(sb, KERN_ERR,
1344 "%s quota file already specified", QTYPE2NAME(qtype));
1345 kfree(qname);
1346 return 0;
1347 }
1348 sbi->s_qf_names[qtype] = qname;
1349 if (strchr(sbi->s_qf_names[qtype], '/')) {
1350 ext4_msg(sb, KERN_ERR,
1351 "quotafile must be on filesystem root");
1352 kfree(sbi->s_qf_names[qtype]);
1353 sbi->s_qf_names[qtype] = NULL;
1354 return 0;
1355 }
1356 set_opt(sbi->s_mount_opt, QUOTA);
1357 return 1;
1358}
1359
1360static int clear_qf_name(struct super_block *sb, int qtype)
1361{
1362
1363 struct ext4_sb_info *sbi = EXT4_SB(sb);
1364
1365 if (sb_any_quota_loaded(sb) &&
1366 sbi->s_qf_names[qtype]) {
1367 ext4_msg(sb, KERN_ERR, "Cannot change journaled quota options"
1368 " when quota turned on");
1369 return 0;
1370 }
1371 /*
1372 * The space will be released later when all options are confirmed
1373 * to be correct
1374 */
1375 sbi->s_qf_names[qtype] = NULL;
1376 return 1;
1377}
1378#endif
1379
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001380static int parse_options(char *options, struct super_block *sb,
Theodore Ts'oc3191062009-01-06 11:14:25 -05001381 unsigned long *journal_devnum,
Theodore Ts'ob3881f72009-01-05 22:46:26 -05001382 unsigned int *journal_ioprio,
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001383 ext4_fsblk_t *n_blocks_count, int is_remount)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001384{
Mingming Cao617ba132006-10-11 01:20:53 -07001385 struct ext4_sb_info *sbi = EXT4_SB(sb);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001386 char *p;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001387 substring_t args[MAX_OPT_ARGS];
1388 int data_opt = 0;
1389 int option;
1390#ifdef CONFIG_QUOTA
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001391 int qfmt;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001392#endif
1393
1394 if (!options)
1395 return 1;
1396
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001397 while ((p = strsep(&options, ",")) != NULL) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001398 int token;
1399 if (!*p)
1400 continue;
1401
Eric Sandeen15121c12010-02-15 20:17:55 -05001402 /*
1403 * Initialize args struct so we know whether arg was
1404 * found; some options take optional arguments.
1405 */
1406 args[0].to = args[0].from = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001407 token = match_token(p, tokens, args);
1408 switch (token) {
1409 case Opt_bsd_df:
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001410 ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001411 clear_opt(sbi->s_mount_opt, MINIX_DF);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001412 break;
1413 case Opt_minix_df:
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001414 ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001415 set_opt(sbi->s_mount_opt, MINIX_DF);
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001416
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001417 break;
1418 case Opt_grpid:
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001419 ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001420 set_opt(sbi->s_mount_opt, GRPID);
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001421
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001422 break;
1423 case Opt_nogrpid:
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001424 ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001425 clear_opt(sbi->s_mount_opt, GRPID);
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05001426
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001427 break;
1428 case Opt_resuid:
1429 if (match_int(&args[0], &option))
1430 return 0;
1431 sbi->s_resuid = option;
1432 break;
1433 case Opt_resgid:
1434 if (match_int(&args[0], &option))
1435 return 0;
1436 sbi->s_resgid = option;
1437 break;
1438 case Opt_sb:
1439 /* handled by get_sb_block() instead of here */
1440 /* *sb_block = match_int(&args[0]); */
1441 break;
1442 case Opt_err_panic:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001443 clear_opt(sbi->s_mount_opt, ERRORS_CONT);
1444 clear_opt(sbi->s_mount_opt, ERRORS_RO);
1445 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001446 break;
1447 case Opt_err_ro:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001448 clear_opt(sbi->s_mount_opt, ERRORS_CONT);
1449 clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
1450 set_opt(sbi->s_mount_opt, ERRORS_RO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001451 break;
1452 case Opt_err_cont:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001453 clear_opt(sbi->s_mount_opt, ERRORS_RO);
1454 clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
1455 set_opt(sbi->s_mount_opt, ERRORS_CONT);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001456 break;
1457 case Opt_nouid32:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001458 set_opt(sbi->s_mount_opt, NO_UID32);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001459 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001460 case Opt_debug:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001461 set_opt(sbi->s_mount_opt, DEBUG);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001462 break;
1463 case Opt_oldalloc:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001464 set_opt(sbi->s_mount_opt, OLDALLOC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001465 break;
1466 case Opt_orlov:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001467 clear_opt(sbi->s_mount_opt, OLDALLOC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001468 break;
Theodore Ts'o03010a32008-10-10 20:02:48 -04001469#ifdef CONFIG_EXT4_FS_XATTR
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001470 case Opt_user_xattr:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001471 set_opt(sbi->s_mount_opt, XATTR_USER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001472 break;
1473 case Opt_nouser_xattr:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001474 clear_opt(sbi->s_mount_opt, XATTR_USER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001475 break;
1476#else
1477 case Opt_user_xattr:
1478 case Opt_nouser_xattr:
Eric Sandeenb31e1552009-06-04 17:36:36 -04001479 ext4_msg(sb, KERN_ERR, "(no)user_xattr options not supported");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001480 break;
1481#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -04001482#ifdef CONFIG_EXT4_FS_POSIX_ACL
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001483 case Opt_acl:
1484 set_opt(sbi->s_mount_opt, POSIX_ACL);
1485 break;
1486 case Opt_noacl:
1487 clear_opt(sbi->s_mount_opt, POSIX_ACL);
1488 break;
1489#else
1490 case Opt_acl:
1491 case Opt_noacl:
Eric Sandeenb31e1552009-06-04 17:36:36 -04001492 ext4_msg(sb, KERN_ERR, "(no)acl options not supported");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001493 break;
1494#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001495 case Opt_journal_update:
1496 /* @@@ FIXME */
1497 /* Eventually we will want to be able to create
1498 a journal file here. For now, only allow the
1499 user to specify an existing inode to be the
1500 journal file. */
1501 if (is_remount) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001502 ext4_msg(sb, KERN_ERR,
1503 "Cannot specify journal on remount");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001504 return 0;
1505 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001506 set_opt(sbi->s_mount_opt, UPDATE_JOURNAL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001507 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001508 case Opt_journal_dev:
1509 if (is_remount) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001510 ext4_msg(sb, KERN_ERR,
1511 "Cannot specify journal on remount");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001512 return 0;
1513 }
1514 if (match_int(&args[0], &option))
1515 return 0;
1516 *journal_devnum = option;
1517 break;
Girish Shilamkar818d2762008-01-28 23:58:27 -05001518 case Opt_journal_checksum:
Linus Torvaldsd4da6c92009-11-02 10:15:27 -08001519 set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1520 break;
Girish Shilamkar818d2762008-01-28 23:58:27 -05001521 case Opt_journal_async_commit:
1522 set_opt(sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);
Linus Torvaldsd4da6c92009-11-02 10:15:27 -08001523 set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
Girish Shilamkar818d2762008-01-28 23:58:27 -05001524 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001525 case Opt_noload:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001526 set_opt(sbi->s_mount_opt, NOLOAD);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001527 break;
1528 case Opt_commit:
1529 if (match_int(&args[0], &option))
1530 return 0;
1531 if (option < 0)
1532 return 0;
1533 if (option == 0)
Mingming Caocd02ff02007-10-16 18:38:25 -04001534 option = JBD2_DEFAULT_MAX_COMMIT_AGE;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001535 sbi->s_commit_interval = HZ * option;
1536 break;
Theodore Ts'o30773842009-01-03 20:27:38 -05001537 case Opt_max_batch_time:
1538 if (match_int(&args[0], &option))
1539 return 0;
1540 if (option < 0)
1541 return 0;
1542 if (option == 0)
1543 option = EXT4_DEF_MAX_BATCH_TIME;
1544 sbi->s_max_batch_time = option;
1545 break;
1546 case Opt_min_batch_time:
1547 if (match_int(&args[0], &option))
1548 return 0;
1549 if (option < 0)
1550 return 0;
1551 sbi->s_min_batch_time = option;
1552 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001553 case Opt_data_journal:
Mingming Cao617ba132006-10-11 01:20:53 -07001554 data_opt = EXT4_MOUNT_JOURNAL_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001555 goto datacheck;
1556 case Opt_data_ordered:
Mingming Cao617ba132006-10-11 01:20:53 -07001557 data_opt = EXT4_MOUNT_ORDERED_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001558 goto datacheck;
1559 case Opt_data_writeback:
Mingming Cao617ba132006-10-11 01:20:53 -07001560 data_opt = EXT4_MOUNT_WRITEBACK_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001561 datacheck:
1562 if (is_remount) {
Dmitry Monakhov482a7422010-02-24 11:35:32 -05001563 if (test_opt(sb, DATA_FLAGS) != data_opt) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001564 ext4_msg(sb, KERN_ERR,
1565 "Cannot change data mode on remount");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001566 return 0;
1567 }
1568 } else {
Dmitry Monakhov482a7422010-02-24 11:35:32 -05001569 clear_opt(sbi->s_mount_opt, DATA_FLAGS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001570 sbi->s_mount_opt |= data_opt;
1571 }
1572 break;
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04001573 case Opt_data_err_abort:
1574 set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1575 break;
1576 case Opt_data_err_ignore:
1577 clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1578 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001579#ifdef CONFIG_QUOTA
1580 case Opt_usrjquota:
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001581 if (!set_qf_name(sb, USRQUOTA, &args[0]))
1582 return 0;
1583 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001584 case Opt_grpjquota:
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001585 if (!set_qf_name(sb, GRPQUOTA, &args[0]))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001586 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001587 break;
1588 case Opt_offusrjquota:
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001589 if (!clear_qf_name(sb, USRQUOTA))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001590 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001591 break;
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001592 case Opt_offgrpjquota:
1593 if (!clear_qf_name(sb, GRPQUOTA))
1594 return 0;
1595 break;
1596
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001597 case Opt_jqfmt_vfsold:
Jan Karadfc5d032008-05-13 19:11:51 -04001598 qfmt = QFMT_VFS_OLD;
1599 goto set_qf_format;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001600 case Opt_jqfmt_vfsv0:
Jan Karadfc5d032008-05-13 19:11:51 -04001601 qfmt = QFMT_VFS_V0;
Jan Kara5a20bdf2009-11-30 23:58:32 +01001602 goto set_qf_format;
1603 case Opt_jqfmt_vfsv1:
1604 qfmt = QFMT_VFS_V1;
Jan Karadfc5d032008-05-13 19:11:51 -04001605set_qf_format:
Jan Kara17bd13b2008-08-20 18:14:35 +02001606 if (sb_any_quota_loaded(sb) &&
Jan Karadfc5d032008-05-13 19:11:51 -04001607 sbi->s_jquota_fmt != qfmt) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001608 ext4_msg(sb, KERN_ERR, "Cannot change "
Jan Karadfc5d032008-05-13 19:11:51 -04001609 "journaled quota options when "
Eric Sandeenb31e1552009-06-04 17:36:36 -04001610 "quota turned on");
Jan Karadfc5d032008-05-13 19:11:51 -04001611 return 0;
1612 }
1613 sbi->s_jquota_fmt = qfmt;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001614 break;
1615 case Opt_quota:
1616 case Opt_usrquota:
1617 set_opt(sbi->s_mount_opt, QUOTA);
1618 set_opt(sbi->s_mount_opt, USRQUOTA);
1619 break;
1620 case Opt_grpquota:
1621 set_opt(sbi->s_mount_opt, QUOTA);
1622 set_opt(sbi->s_mount_opt, GRPQUOTA);
1623 break;
1624 case Opt_noquota:
Jan Kara17bd13b2008-08-20 18:14:35 +02001625 if (sb_any_quota_loaded(sb)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001626 ext4_msg(sb, KERN_ERR, "Cannot change quota "
1627 "options when quota turned on");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001628 return 0;
1629 }
1630 clear_opt(sbi->s_mount_opt, QUOTA);
1631 clear_opt(sbi->s_mount_opt, USRQUOTA);
1632 clear_opt(sbi->s_mount_opt, GRPQUOTA);
1633 break;
1634#else
1635 case Opt_quota:
1636 case Opt_usrquota:
1637 case Opt_grpquota:
Eric Sandeenb31e1552009-06-04 17:36:36 -04001638 ext4_msg(sb, KERN_ERR,
1639 "quota options not supported");
Jan Karacd59e7b2008-05-13 19:11:51 -04001640 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001641 case Opt_usrjquota:
1642 case Opt_grpjquota:
1643 case Opt_offusrjquota:
1644 case Opt_offgrpjquota:
1645 case Opt_jqfmt_vfsold:
1646 case Opt_jqfmt_vfsv0:
Jan Kara5a20bdf2009-11-30 23:58:32 +01001647 case Opt_jqfmt_vfsv1:
Eric Sandeenb31e1552009-06-04 17:36:36 -04001648 ext4_msg(sb, KERN_ERR,
1649 "journaled quota options not supported");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001650 break;
1651 case Opt_noquota:
1652 break;
1653#endif
1654 case Opt_abort:
Theodore Ts'o4ab2f152009-06-13 10:09:36 -04001655 sbi->s_mount_flags |= EXT4_MF_FS_ABORTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001656 break;
Theodore Ts'o06705bf2009-03-28 10:59:57 -04001657 case Opt_nobarrier:
1658 clear_opt(sbi->s_mount_opt, BARRIER);
1659 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001660 case Opt_barrier:
Eric Sandeen15121c12010-02-15 20:17:55 -05001661 if (args[0].from) {
1662 if (match_int(&args[0], &option))
1663 return 0;
1664 } else
1665 option = 1; /* No argument, default to 1 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001666 if (option)
1667 set_opt(sbi->s_mount_opt, BARRIER);
1668 else
1669 clear_opt(sbi->s_mount_opt, BARRIER);
1670 break;
1671 case Opt_ignore:
1672 break;
1673 case Opt_resize:
1674 if (!is_remount) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001675 ext4_msg(sb, KERN_ERR,
1676 "resize option only available "
1677 "for remount");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001678 return 0;
1679 }
1680 if (match_int(&args[0], &option) != 0)
1681 return 0;
1682 *n_blocks_count = option;
1683 break;
1684 case Opt_nobh:
Christoph Hellwig206f7ab2010-06-14 14:42:49 -04001685 ext4_msg(sb, KERN_WARNING,
1686 "Ignoring deprecated nobh option");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001687 break;
1688 case Opt_bh:
Christoph Hellwig206f7ab2010-06-14 14:42:49 -04001689 ext4_msg(sb, KERN_WARNING,
1690 "Ignoring deprecated bh option");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001691 break;
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05001692 case Opt_i_version:
1693 set_opt(sbi->s_mount_opt, I_VERSION);
1694 sb->s_flags |= MS_I_VERSION;
1695 break;
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04001696 case Opt_nodelalloc:
1697 clear_opt(sbi->s_mount_opt, DELALLOC);
1698 break;
Alex Tomasc9de5602008-01-29 00:19:52 -05001699 case Opt_stripe:
1700 if (match_int(&args[0], &option))
1701 return 0;
1702 if (option < 0)
1703 return 0;
1704 sbi->s_stripe = option;
1705 break;
Alex Tomas64769242008-07-11 19:27:31 -04001706 case Opt_delalloc:
1707 set_opt(sbi->s_mount_opt, DELALLOC);
1708 break;
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04001709 case Opt_block_validity:
1710 set_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
1711 break;
1712 case Opt_noblock_validity:
1713 clear_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
1714 break;
Theodore Ts'o240799c2008-10-09 23:53:47 -04001715 case Opt_inode_readahead_blks:
1716 if (match_int(&args[0], &option))
1717 return 0;
1718 if (option < 0 || option > (1 << 30))
1719 return 0;
Theodore Ts'of7c43952009-04-24 23:31:59 -04001720 if (!is_power_of_2(option)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001721 ext4_msg(sb, KERN_ERR,
1722 "EXT4-fs: inode_readahead_blks"
1723 " must be a power of 2");
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04001724 return 0;
1725 }
Theodore Ts'o240799c2008-10-09 23:53:47 -04001726 sbi->s_inode_readahead_blks = option;
1727 break;
Theodore Ts'ob3881f72009-01-05 22:46:26 -05001728 case Opt_journal_ioprio:
1729 if (match_int(&args[0], &option))
1730 return 0;
1731 if (option < 0 || option > 7)
1732 break;
1733 *journal_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE,
1734 option);
1735 break;
Theodore Ts'o06705bf2009-03-28 10:59:57 -04001736 case Opt_noauto_da_alloc:
1737 set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
1738 break;
Theodore Ts'oafd46722009-03-16 23:12:23 -04001739 case Opt_auto_da_alloc:
Eric Sandeen15121c12010-02-15 20:17:55 -05001740 if (args[0].from) {
1741 if (match_int(&args[0], &option))
1742 return 0;
1743 } else
1744 option = 1; /* No argument, default to 1 */
Theodore Ts'oafd46722009-03-16 23:12:23 -04001745 if (option)
1746 clear_opt(sbi->s_mount_opt, NO_AUTO_DA_ALLOC);
1747 else
1748 set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
1749 break;
Eric Sandeen5328e632009-11-19 14:25:42 -05001750 case Opt_discard:
1751 set_opt(sbi->s_mount_opt, DISCARD);
1752 break;
1753 case Opt_nodiscard:
1754 clear_opt(sbi->s_mount_opt, DISCARD);
1755 break;
Jiaying Zhang744692d2010-03-04 16:14:02 -05001756 case Opt_dioread_nolock:
1757 set_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
1758 break;
1759 case Opt_dioread_lock:
1760 clear_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
1761 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001762 default:
Eric Sandeenb31e1552009-06-04 17:36:36 -04001763 ext4_msg(sb, KERN_ERR,
1764 "Unrecognized mount option \"%s\" "
1765 "or missing value", p);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001766 return 0;
1767 }
1768 }
1769#ifdef CONFIG_QUOTA
1770 if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
Dmitry Monakhov482a7422010-02-24 11:35:32 -05001771 if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA])
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001772 clear_opt(sbi->s_mount_opt, USRQUOTA);
1773
Dmitry Monakhov482a7422010-02-24 11:35:32 -05001774 if (test_opt(sb, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA])
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001775 clear_opt(sbi->s_mount_opt, GRPQUOTA);
1776
Dmitry Monakhov56c50f12010-03-01 23:28:41 -05001777 if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001778 ext4_msg(sb, KERN_ERR, "old and new quota "
1779 "format mixing");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001780 return 0;
1781 }
1782
1783 if (!sbi->s_jquota_fmt) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001784 ext4_msg(sb, KERN_ERR, "journaled quota format "
1785 "not specified");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001786 return 0;
1787 }
1788 } else {
1789 if (sbi->s_jquota_fmt) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001790 ext4_msg(sb, KERN_ERR, "journaled quota format "
Jan Kara2c8be6b2008-05-13 21:27:55 -04001791 "specified with no journaling "
Eric Sandeenb31e1552009-06-04 17:36:36 -04001792 "enabled");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001793 return 0;
1794 }
1795 }
1796#endif
1797 return 1;
1798}
1799
Mingming Cao617ba132006-10-11 01:20:53 -07001800static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001801 int read_only)
1802{
Mingming Cao617ba132006-10-11 01:20:53 -07001803 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001804 int res = 0;
1805
Mingming Cao617ba132006-10-11 01:20:53 -07001806 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001807 ext4_msg(sb, KERN_ERR, "revision level too high, "
1808 "forcing read-only mode");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001809 res = MS_RDONLY;
1810 }
1811 if (read_only)
1812 return res;
Mingming Cao617ba132006-10-11 01:20:53 -07001813 if (!(sbi->s_mount_state & EXT4_VALID_FS))
Eric Sandeenb31e1552009-06-04 17:36:36 -04001814 ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
1815 "running e2fsck is recommended");
Mingming Cao617ba132006-10-11 01:20:53 -07001816 else if ((sbi->s_mount_state & EXT4_ERROR_FS))
Eric Sandeenb31e1552009-06-04 17:36:36 -04001817 ext4_msg(sb, KERN_WARNING,
1818 "warning: mounting fs with errors, "
1819 "running e2fsck is recommended");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001820 else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
1821 le16_to_cpu(es->s_mnt_count) >=
1822 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
Eric Sandeenb31e1552009-06-04 17:36:36 -04001823 ext4_msg(sb, KERN_WARNING,
1824 "warning: maximal mount count reached, "
1825 "running e2fsck is recommended");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001826 else if (le32_to_cpu(es->s_checkinterval) &&
1827 (le32_to_cpu(es->s_lastcheck) +
1828 le32_to_cpu(es->s_checkinterval) <= get_seconds()))
Eric Sandeenb31e1552009-06-04 17:36:36 -04001829 ext4_msg(sb, KERN_WARNING,
1830 "warning: checktime reached, "
1831 "running e2fsck is recommended");
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04001832 if (!sbi->s_journal)
Frank Mayhar03901312009-01-07 00:06:22 -05001833 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001834 if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
Mingming Cao617ba132006-10-11 01:20:53 -07001835 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
Marcin Slusarze8546d02008-04-17 10:38:59 -04001836 le16_add_cpu(&es->s_mnt_count, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001837 es->s_mtime = cpu_to_le32(get_seconds());
Mingming Cao617ba132006-10-11 01:20:53 -07001838 ext4_update_dynamic_rev(sb);
Frank Mayhar03901312009-01-07 00:06:22 -05001839 if (sbi->s_journal)
1840 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001841
Theodore Ts'oe2d67052009-05-01 00:33:44 -04001842 ext4_commit_super(sb, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001843 if (test_opt(sb, DEBUG))
Theodore Ts'oa9df9a42009-01-05 22:18:16 -05001844 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
Theodore Ts'o7f4520c2009-06-13 10:09:41 -04001845 "bpg=%lu, ipg=%lu, mo=%04x]\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001846 sb->s_blocksize,
1847 sbi->s_groups_count,
Mingming Cao617ba132006-10-11 01:20:53 -07001848 EXT4_BLOCKS_PER_GROUP(sb),
1849 EXT4_INODES_PER_GROUP(sb),
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001850 sbi->s_mount_opt);
1851
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001852 return res;
1853}
1854
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001855static int ext4_fill_flex_info(struct super_block *sb)
1856{
1857 struct ext4_sb_info *sbi = EXT4_SB(sb);
1858 struct ext4_group_desc *gdp = NULL;
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001859 ext4_group_t flex_group_count;
1860 ext4_group_t flex_group;
1861 int groups_per_flex = 0;
Theodore Ts'oc5ca7c72009-04-27 22:48:48 -04001862 size_t size;
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001863 int i;
1864
Theodore Ts'o503358a2009-11-23 07:24:46 -05001865 sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
1866 groups_per_flex = 1 << sbi->s_log_groups_per_flex;
1867
1868 if (groups_per_flex < 2) {
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001869 sbi->s_log_groups_per_flex = 0;
1870 return 1;
1871 }
1872
Frederic Bohec62a11f2008-09-08 10:20:24 -04001873 /* We allocate both existing and potentially added groups */
1874 flex_group_count = ((sbi->s_groups_count + groups_per_flex - 1) +
Aneesh Kumar K.Vd94e99a2008-11-04 09:11:26 -05001875 ((le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) + 1) <<
1876 EXT4_DESC_PER_BLOCK_BITS(sb))) / groups_per_flex;
Theodore Ts'oc5ca7c72009-04-27 22:48:48 -04001877 size = flex_group_count * sizeof(struct flex_groups);
1878 sbi->s_flex_groups = kzalloc(size, GFP_KERNEL);
1879 if (sbi->s_flex_groups == NULL) {
1880 sbi->s_flex_groups = vmalloc(size);
1881 if (sbi->s_flex_groups)
1882 memset(sbi->s_flex_groups, 0, size);
1883 }
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001884 if (sbi->s_flex_groups == NULL) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001885 ext4_msg(sb, KERN_ERR, "not enough memory for "
1886 "%u flex groups", flex_group_count);
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001887 goto failed;
1888 }
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001889
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001890 for (i = 0; i < sbi->s_groups_count; i++) {
Theodore Ts'o88b6edd2009-05-25 11:50:39 -04001891 gdp = ext4_get_group_desc(sb, i, NULL);
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001892
1893 flex_group = ext4_flex_group(sbi, i);
Theodore Ts'o7ad9bb62009-09-11 16:51:28 -04001894 atomic_add(ext4_free_inodes_count(sb, gdp),
1895 &sbi->s_flex_groups[flex_group].free_inodes);
1896 atomic_add(ext4_free_blks_count(sb, gdp),
1897 &sbi->s_flex_groups[flex_group].free_blocks);
1898 atomic_add(ext4_used_dirs_count(sb, gdp),
1899 &sbi->s_flex_groups[flex_group].used_dirs);
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001900 }
1901
1902 return 1;
1903failed:
1904 return 0;
1905}
1906
Andreas Dilger717d50e2007-10-16 18:38:25 -04001907__le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
1908 struct ext4_group_desc *gdp)
1909{
1910 __u16 crc = 0;
1911
1912 if (sbi->s_es->s_feature_ro_compat &
1913 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
1914 int offset = offsetof(struct ext4_group_desc, bg_checksum);
1915 __le32 le_group = cpu_to_le32(block_group);
1916
1917 crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
1918 crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
1919 crc = crc16(crc, (__u8 *)gdp, offset);
1920 offset += sizeof(gdp->bg_checksum); /* skip checksum */
1921 /* for checksum of struct ext4_group_desc do the rest...*/
1922 if ((sbi->s_es->s_feature_incompat &
1923 cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
1924 offset < le16_to_cpu(sbi->s_es->s_desc_size))
1925 crc = crc16(crc, (__u8 *)gdp + offset,
1926 le16_to_cpu(sbi->s_es->s_desc_size) -
1927 offset);
1928 }
1929
1930 return cpu_to_le16(crc);
1931}
1932
1933int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 block_group,
1934 struct ext4_group_desc *gdp)
1935{
1936 if ((sbi->s_es->s_feature_ro_compat &
1937 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) &&
1938 (gdp->bg_checksum != ext4_group_desc_csum(sbi, block_group, gdp)))
1939 return 0;
1940
1941 return 1;
1942}
1943
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001944/* Called at mount-time, super-block is locked */
Akinobu Mita197cd65a2008-02-06 01:40:16 -08001945static int ext4_check_descriptors(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001946{
Mingming Cao617ba132006-10-11 01:20:53 -07001947 struct ext4_sb_info *sbi = EXT4_SB(sb);
1948 ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
1949 ext4_fsblk_t last_block;
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001950 ext4_fsblk_t block_bitmap;
1951 ext4_fsblk_t inode_bitmap;
1952 ext4_fsblk_t inode_table;
Jose R. Santosce421582007-10-16 18:38:25 -04001953 int flexbg_flag = 0;
Avantika Mathurfd2d4292008-01-28 23:58:27 -05001954 ext4_group_t i;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001955
Jose R. Santosce421582007-10-16 18:38:25 -04001956 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
1957 flexbg_flag = 1;
1958
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001959 ext4_debug("Checking group descriptors");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001960
Akinobu Mita197cd65a2008-02-06 01:40:16 -08001961 for (i = 0; i < sbi->s_groups_count; i++) {
1962 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1963
Jose R. Santosce421582007-10-16 18:38:25 -04001964 if (i == sbi->s_groups_count - 1 || flexbg_flag)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001965 last_block = ext4_blocks_count(sbi->s_es) - 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001966 else
1967 last_block = first_block +
Mingming Cao617ba132006-10-11 01:20:53 -07001968 (EXT4_BLOCKS_PER_GROUP(sb) - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001969
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07001970 block_bitmap = ext4_block_bitmap(sb, gdp);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001971 if (block_bitmap < first_block || block_bitmap > last_block) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001972 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -05001973 "Block bitmap for group %u not in group "
Eric Sandeenb31e1552009-06-04 17:36:36 -04001974 "(block %llu)!", i, block_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001975 return 0;
1976 }
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07001977 inode_bitmap = ext4_inode_bitmap(sb, gdp);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001978 if (inode_bitmap < first_block || inode_bitmap > last_block) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001979 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -05001980 "Inode bitmap for group %u not in group "
Eric Sandeenb31e1552009-06-04 17:36:36 -04001981 "(block %llu)!", i, inode_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001982 return 0;
1983 }
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07001984 inode_table = ext4_inode_table(sb, gdp);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001985 if (inode_table < first_block ||
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001986 inode_table + sbi->s_itb_per_group - 1 > last_block) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001987 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
Theodore Ts'oa9df9a42009-01-05 22:18:16 -05001988 "Inode table for group %u not in group "
Eric Sandeenb31e1552009-06-04 17:36:36 -04001989 "(block %llu)!", i, inode_table);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001990 return 0;
1991 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -04001992 ext4_lock_group(sb, i);
Andreas Dilger717d50e2007-10-16 18:38:25 -04001993 if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04001994 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
1995 "Checksum for group %u failed (%u!=%u)",
1996 i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
1997 gdp)), le16_to_cpu(gdp->bg_checksum));
Li Zefan7ee1ec42008-09-08 10:47:19 -04001998 if (!(sb->s_flags & MS_RDONLY)) {
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -04001999 ext4_unlock_group(sb, i);
Theodore Ts'o8a266462008-07-26 14:34:21 -04002000 return 0;
Li Zefan7ee1ec42008-09-08 10:47:19 -04002001 }
Andreas Dilger717d50e2007-10-16 18:38:25 -04002002 }
Aneesh Kumar K.V955ce5f2009-05-02 20:35:09 -04002003 ext4_unlock_group(sb, i);
Jose R. Santosce421582007-10-16 18:38:25 -04002004 if (!flexbg_flag)
2005 first_block += EXT4_BLOCKS_PER_GROUP(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002006 }
2007
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002008 ext4_free_blocks_count_set(sbi->s_es, ext4_count_free_blocks(sb));
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002009 sbi->s_es->s_free_inodes_count =cpu_to_le32(ext4_count_free_inodes(sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002010 return 1;
2011}
2012
Mingming Cao617ba132006-10-11 01:20:53 -07002013/* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002014 * the superblock) which were deleted from all directories, but held open by
2015 * a process at the time of a crash. We walk the list and try to delete these
2016 * inodes at recovery time (only with a read-write filesystem).
2017 *
2018 * In order to keep the orphan inode chain consistent during traversal (in
2019 * case of crash during recovery), we link each inode into the superblock
2020 * orphan list_head and handle it the same way as an inode deletion during
2021 * normal operation (which journals the operations for us).
2022 *
2023 * We only do an iget() and an iput() on each inode, which is very safe if we
2024 * accidentally point at an in-use or already deleted inode. The worst that
2025 * can happen in this case is that we get a "bit already cleared" message from
Mingming Cao617ba132006-10-11 01:20:53 -07002026 * ext4_free_inode(). The only reason we would point at a wrong inode is if
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002027 * e2fsck was run on this filesystem, and it must have already done the orphan
2028 * inode cleanup for us, so we can safely abort without any further action.
2029 */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002030static void ext4_orphan_cleanup(struct super_block *sb,
2031 struct ext4_super_block *es)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002032{
2033 unsigned int s_flags = sb->s_flags;
2034 int nr_orphans = 0, nr_truncates = 0;
2035#ifdef CONFIG_QUOTA
2036 int i;
2037#endif
2038 if (!es->s_last_orphan) {
2039 jbd_debug(4, "no orphan inodes to clean up\n");
2040 return;
2041 }
2042
Eric Sandeena8f48a92006-12-06 20:40:13 -08002043 if (bdev_read_only(sb->s_bdev)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002044 ext4_msg(sb, KERN_ERR, "write access "
2045 "unavailable, skipping orphan cleanup");
Eric Sandeena8f48a92006-12-06 20:40:13 -08002046 return;
2047 }
2048
Mingming Cao617ba132006-10-11 01:20:53 -07002049 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002050 if (es->s_last_orphan)
2051 jbd_debug(1, "Errors on filesystem, "
2052 "clearing orphan list.\n");
2053 es->s_last_orphan = 0;
2054 jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
2055 return;
2056 }
2057
2058 if (s_flags & MS_RDONLY) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002059 ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002060 sb->s_flags &= ~MS_RDONLY;
2061 }
2062#ifdef CONFIG_QUOTA
2063 /* Needed for iput() to work correctly and not trash data */
2064 sb->s_flags |= MS_ACTIVE;
2065 /* Turn on quotas so that they are updated correctly */
2066 for (i = 0; i < MAXQUOTAS; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -07002067 if (EXT4_SB(sb)->s_qf_names[i]) {
2068 int ret = ext4_quota_on_mount(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002069 if (ret < 0)
Eric Sandeenb31e1552009-06-04 17:36:36 -04002070 ext4_msg(sb, KERN_ERR,
2071 "Cannot turn on journaled "
2072 "quota: error %d", ret);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002073 }
2074 }
2075#endif
2076
2077 while (es->s_last_orphan) {
2078 struct inode *inode;
2079
Josef Bacik97bd42b2008-04-29 22:04:56 -04002080 inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
2081 if (IS_ERR(inode)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002082 es->s_last_orphan = 0;
2083 break;
2084 }
2085
Mingming Cao617ba132006-10-11 01:20:53 -07002086 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
Christoph Hellwig871a2932010-03-03 09:05:07 -05002087 dquot_initialize(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002088 if (inode->i_nlink) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002089 ext4_msg(sb, KERN_DEBUG,
2090 "%s: truncating inode %lu to %lld bytes",
Harvey Harrison46e665e2008-04-17 10:38:59 -04002091 __func__, inode->i_ino, inode->i_size);
Theodore Ts'oe5f8eab2008-09-08 22:25:04 -04002092 jbd_debug(2, "truncating inode %lu to %lld bytes\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002093 inode->i_ino, inode->i_size);
Mingming Cao617ba132006-10-11 01:20:53 -07002094 ext4_truncate(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002095 nr_truncates++;
2096 } else {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002097 ext4_msg(sb, KERN_DEBUG,
2098 "%s: deleting unreferenced inode %lu",
Harvey Harrison46e665e2008-04-17 10:38:59 -04002099 __func__, inode->i_ino);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002100 jbd_debug(2, "deleting unreferenced inode %lu\n",
2101 inode->i_ino);
2102 nr_orphans++;
2103 }
2104 iput(inode); /* The delete magic happens here! */
2105 }
2106
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002107#define PLURAL(x) (x), ((x) == 1) ? "" : "s"
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002108
2109 if (nr_orphans)
Eric Sandeenb31e1552009-06-04 17:36:36 -04002110 ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
2111 PLURAL(nr_orphans));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002112 if (nr_truncates)
Eric Sandeenb31e1552009-06-04 17:36:36 -04002113 ext4_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
2114 PLURAL(nr_truncates));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002115#ifdef CONFIG_QUOTA
2116 /* Turn quotas off */
2117 for (i = 0; i < MAXQUOTAS; i++) {
2118 if (sb_dqopt(sb)->files[i])
Christoph Hellwig287a8092010-05-19 07:16:45 -04002119 dquot_quota_off(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002120 }
2121#endif
2122 sb->s_flags = s_flags; /* Restore MS_RDONLY status */
2123}
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002124
Eric Sandeencd2291a2008-01-28 23:58:27 -05002125/*
2126 * Maximal extent format file size.
2127 * Resulting logical blkno at s_maxbytes must fit in our on-disk
2128 * extent format containers, within a sector_t, and within i_blocks
2129 * in the vfs. ext4 inode has 48 bits of i_block in fsblock units,
2130 * so that won't be a limiting factor.
2131 *
2132 * Note, this does *not* consider any metadata overhead for vfs i_blocks.
2133 */
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002134static loff_t ext4_max_size(int blkbits, int has_huge_files)
Eric Sandeencd2291a2008-01-28 23:58:27 -05002135{
2136 loff_t res;
2137 loff_t upper_limit = MAX_LFS_FILESIZE;
2138
2139 /* small i_blocks in vfs inode? */
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002140 if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
Eric Sandeencd2291a2008-01-28 23:58:27 -05002141 /*
Bartlomiej Zolnierkiewicz90c699a2009-06-19 08:08:50 +02002142 * CONFIG_LBDAF is not enabled implies the inode
Eric Sandeencd2291a2008-01-28 23:58:27 -05002143 * i_block represent total blocks in 512 bytes
2144 * 32 == size of vfs inode i_blocks * 8
2145 */
2146 upper_limit = (1LL << 32) - 1;
2147
2148 /* total blocks in file system block size */
2149 upper_limit >>= (blkbits - 9);
2150 upper_limit <<= blkbits;
2151 }
2152
2153 /* 32-bit extent-start container, ee_block */
2154 res = 1LL << 32;
2155 res <<= blkbits;
2156 res -= 1;
2157
2158 /* Sanity check against vm- & vfs- imposed limits */
2159 if (res > upper_limit)
2160 res = upper_limit;
2161
2162 return res;
2163}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002164
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002165/*
Eric Sandeencd2291a2008-01-28 23:58:27 -05002166 * Maximal bitmap file size. There is a direct, and {,double-,triple-}indirect
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002167 * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
2168 * We need to be 1 filesystem block less than the 2^48 sector limit.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002169 */
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002170static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002171{
Mingming Cao617ba132006-10-11 01:20:53 -07002172 loff_t res = EXT4_NDIR_BLOCKS;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002173 int meta_blocks;
2174 loff_t upper_limit;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002175 /* This is calculated to be the largest file size for a dense, block
2176 * mapped file such that the file's total number of 512-byte sectors,
2177 * including data and all indirect blocks, does not exceed (2^48 - 1).
2178 *
2179 * __u32 i_blocks_lo and _u16 i_blocks_high represent the total
2180 * number of 512-byte sectors of the file.
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002181 */
2182
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002183 if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002184 /*
Bartlomiej Zolnierkiewicz90c699a2009-06-19 08:08:50 +02002185 * !has_huge_files or CONFIG_LBDAF not enabled implies that
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002186 * the inode i_block field represents total file blocks in
2187 * 2^32 512-byte sectors == size of vfs inode i_blocks * 8
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002188 */
2189 upper_limit = (1LL << 32) - 1;
2190
2191 /* total blocks in file system block size */
2192 upper_limit >>= (bits - 9);
2193
2194 } else {
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05002195 /*
2196 * We use 48 bit ext4_inode i_blocks
2197 * With EXT4_HUGE_FILE_FL set the i_blocks
2198 * represent total number of blocks in
2199 * file system block size
2200 */
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002201 upper_limit = (1LL << 48) - 1;
2202
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002203 }
2204
2205 /* indirect blocks */
2206 meta_blocks = 1;
2207 /* double indirect blocks */
2208 meta_blocks += 1 + (1LL << (bits-2));
2209 /* tripple indirect blocks */
2210 meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
2211
2212 upper_limit -= meta_blocks;
2213 upper_limit <<= bits;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002214
2215 res += 1LL << (bits-2);
2216 res += 1LL << (2*(bits-2));
2217 res += 1LL << (3*(bits-2));
2218 res <<= bits;
2219 if (res > upper_limit)
2220 res = upper_limit;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002221
2222 if (res > MAX_LFS_FILESIZE)
2223 res = MAX_LFS_FILESIZE;
2224
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002225 return res;
2226}
2227
Mingming Cao617ba132006-10-11 01:20:53 -07002228static ext4_fsblk_t descriptor_loc(struct super_block *sb,
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002229 ext4_fsblk_t logical_sb_block, int nr)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002230{
Mingming Cao617ba132006-10-11 01:20:53 -07002231 struct ext4_sb_info *sbi = EXT4_SB(sb);
Avantika Mathurfd2d4292008-01-28 23:58:27 -05002232 ext4_group_t bg, first_meta_bg;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002233 int has_super = 0;
2234
2235 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
2236
Mingming Cao617ba132006-10-11 01:20:53 -07002237 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002238 nr < first_meta_bg)
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002239 return logical_sb_block + nr + 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002240 bg = sbi->s_desc_per_block * nr;
Mingming Cao617ba132006-10-11 01:20:53 -07002241 if (ext4_bg_has_super(sb, bg))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002242 has_super = 1;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002243
Mingming Cao617ba132006-10-11 01:20:53 -07002244 return (has_super + ext4_group_first_block_no(sb, bg));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002245}
2246
Alex Tomasc9de5602008-01-29 00:19:52 -05002247/**
2248 * ext4_get_stripe_size: Get the stripe size.
2249 * @sbi: In memory super block info
2250 *
2251 * If we have specified it via mount option, then
2252 * use the mount option value. If the value specified at mount time is
2253 * greater than the blocks per group use the super block value.
2254 * If the super block value is greater than blocks per group return 0.
2255 * Allocator needs it be less than blocks per group.
2256 *
2257 */
2258static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
2259{
2260 unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
2261 unsigned long stripe_width =
2262 le32_to_cpu(sbi->s_es->s_raid_stripe_width);
2263
2264 if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
2265 return sbi->s_stripe;
2266
2267 if (stripe_width <= sbi->s_blocks_per_group)
2268 return stripe_width;
2269
2270 if (stride <= sbi->s_blocks_per_group)
2271 return stride;
2272
2273 return 0;
2274}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002275
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002276/* sysfs supprt */
2277
2278struct ext4_attr {
2279 struct attribute attr;
2280 ssize_t (*show)(struct ext4_attr *, struct ext4_sb_info *, char *);
Theodore Ts'o60e66792010-05-17 07:00:00 -04002281 ssize_t (*store)(struct ext4_attr *, struct ext4_sb_info *,
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002282 const char *, size_t);
2283 int offset;
2284};
2285
2286static int parse_strtoul(const char *buf,
2287 unsigned long max, unsigned long *value)
2288{
2289 char *endp;
2290
André Goddard Rosae7d28602009-12-14 18:01:06 -08002291 *value = simple_strtoul(skip_spaces(buf), &endp, 0);
2292 endp = skip_spaces(endp);
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002293 if (*endp || *value > max)
2294 return -EINVAL;
2295
2296 return 0;
2297}
2298
2299static ssize_t delayed_allocation_blocks_show(struct ext4_attr *a,
2300 struct ext4_sb_info *sbi,
2301 char *buf)
2302{
2303 return snprintf(buf, PAGE_SIZE, "%llu\n",
2304 (s64) percpu_counter_sum(&sbi->s_dirtyblocks_counter));
2305}
2306
2307static ssize_t session_write_kbytes_show(struct ext4_attr *a,
2308 struct ext4_sb_info *sbi, char *buf)
2309{
2310 struct super_block *sb = sbi->s_buddy_cache->i_sb;
2311
Theodore Ts'of613dfc2010-07-27 11:56:08 -04002312 if (!sb->s_bdev->bd_part)
2313 return snprintf(buf, PAGE_SIZE, "0\n");
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002314 return snprintf(buf, PAGE_SIZE, "%lu\n",
2315 (part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
2316 sbi->s_sectors_written_start) >> 1);
2317}
2318
2319static ssize_t lifetime_write_kbytes_show(struct ext4_attr *a,
2320 struct ext4_sb_info *sbi, char *buf)
2321{
2322 struct super_block *sb = sbi->s_buddy_cache->i_sb;
2323
Theodore Ts'of613dfc2010-07-27 11:56:08 -04002324 if (!sb->s_bdev->bd_part)
2325 return snprintf(buf, PAGE_SIZE, "0\n");
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002326 return snprintf(buf, PAGE_SIZE, "%llu\n",
Andrew Mortona6b43e32009-12-23 07:48:08 -05002327 (unsigned long long)(sbi->s_kbytes_written +
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002328 ((part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
Andrew Mortona6b43e32009-12-23 07:48:08 -05002329 EXT4_SB(sb)->s_sectors_written_start) >> 1)));
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002330}
2331
2332static ssize_t inode_readahead_blks_store(struct ext4_attr *a,
2333 struct ext4_sb_info *sbi,
2334 const char *buf, size_t count)
2335{
2336 unsigned long t;
2337
2338 if (parse_strtoul(buf, 0x40000000, &t))
2339 return -EINVAL;
2340
Theodore Ts'of7c43952009-04-24 23:31:59 -04002341 if (!is_power_of_2(t))
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002342 return -EINVAL;
2343
2344 sbi->s_inode_readahead_blks = t;
2345 return count;
2346}
2347
2348static ssize_t sbi_ui_show(struct ext4_attr *a,
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002349 struct ext4_sb_info *sbi, char *buf)
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002350{
2351 unsigned int *ui = (unsigned int *) (((char *) sbi) + a->offset);
2352
2353 return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
2354}
2355
2356static ssize_t sbi_ui_store(struct ext4_attr *a,
2357 struct ext4_sb_info *sbi,
2358 const char *buf, size_t count)
2359{
2360 unsigned int *ui = (unsigned int *) (((char *) sbi) + a->offset);
2361 unsigned long t;
2362
2363 if (parse_strtoul(buf, 0xffffffff, &t))
2364 return -EINVAL;
2365 *ui = t;
2366 return count;
2367}
2368
2369#define EXT4_ATTR_OFFSET(_name,_mode,_show,_store,_elname) \
2370static struct ext4_attr ext4_attr_##_name = { \
2371 .attr = {.name = __stringify(_name), .mode = _mode }, \
2372 .show = _show, \
2373 .store = _store, \
2374 .offset = offsetof(struct ext4_sb_info, _elname), \
2375}
2376#define EXT4_ATTR(name, mode, show, store) \
2377static struct ext4_attr ext4_attr_##name = __ATTR(name, mode, show, store)
2378
2379#define EXT4_RO_ATTR(name) EXT4_ATTR(name, 0444, name##_show, NULL)
2380#define EXT4_RW_ATTR(name) EXT4_ATTR(name, 0644, name##_show, name##_store)
2381#define EXT4_RW_ATTR_SBI_UI(name, elname) \
2382 EXT4_ATTR_OFFSET(name, 0644, sbi_ui_show, sbi_ui_store, elname)
2383#define ATTR_LIST(name) &ext4_attr_##name.attr
2384
2385EXT4_RO_ATTR(delayed_allocation_blocks);
2386EXT4_RO_ATTR(session_write_kbytes);
2387EXT4_RO_ATTR(lifetime_write_kbytes);
2388EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, sbi_ui_show,
2389 inode_readahead_blks_store, s_inode_readahead_blks);
Andreas Dilger11013912009-06-13 11:45:35 -04002390EXT4_RW_ATTR_SBI_UI(inode_goal, s_inode_goal);
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002391EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
2392EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
2393EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
2394EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
2395EXT4_RW_ATTR_SBI_UI(mb_stream_req, s_mb_stream_request);
2396EXT4_RW_ATTR_SBI_UI(mb_group_prealloc, s_mb_group_prealloc);
Theodore Ts'o55138e02009-09-29 13:31:31 -04002397EXT4_RW_ATTR_SBI_UI(max_writeback_mb_bump, s_max_writeback_mb_bump);
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002398
2399static struct attribute *ext4_attrs[] = {
2400 ATTR_LIST(delayed_allocation_blocks),
2401 ATTR_LIST(session_write_kbytes),
2402 ATTR_LIST(lifetime_write_kbytes),
2403 ATTR_LIST(inode_readahead_blks),
Andreas Dilger11013912009-06-13 11:45:35 -04002404 ATTR_LIST(inode_goal),
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002405 ATTR_LIST(mb_stats),
2406 ATTR_LIST(mb_max_to_scan),
2407 ATTR_LIST(mb_min_to_scan),
2408 ATTR_LIST(mb_order2_req),
2409 ATTR_LIST(mb_stream_req),
2410 ATTR_LIST(mb_group_prealloc),
Theodore Ts'o55138e02009-09-29 13:31:31 -04002411 ATTR_LIST(max_writeback_mb_bump),
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002412 NULL,
2413};
2414
2415static ssize_t ext4_attr_show(struct kobject *kobj,
2416 struct attribute *attr, char *buf)
2417{
2418 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2419 s_kobj);
2420 struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
2421
2422 return a->show ? a->show(a, sbi, buf) : 0;
2423}
2424
2425static ssize_t ext4_attr_store(struct kobject *kobj,
2426 struct attribute *attr,
2427 const char *buf, size_t len)
2428{
2429 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2430 s_kobj);
2431 struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
2432
2433 return a->store ? a->store(a, sbi, buf, len) : 0;
2434}
2435
2436static void ext4_sb_release(struct kobject *kobj)
2437{
2438 struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2439 s_kobj);
2440 complete(&sbi->s_kobj_unregister);
2441}
2442
2443
Emese Revfy52cf25d2010-01-19 02:58:23 +01002444static const struct sysfs_ops ext4_attr_ops = {
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04002445 .show = ext4_attr_show,
2446 .store = ext4_attr_store,
2447};
2448
2449static struct kobj_type ext4_ktype = {
2450 .default_attrs = ext4_attrs,
2451 .sysfs_ops = &ext4_attr_ops,
2452 .release = ext4_sb_release,
2453};
2454
Eric Sandeena13fb1a2009-08-18 00:20:23 -04002455/*
2456 * Check whether this filesystem can be mounted based on
2457 * the features present and the RDONLY/RDWR mount requested.
2458 * Returns 1 if this filesystem can be mounted as requested,
2459 * 0 if it cannot be.
2460 */
2461static int ext4_feature_set_ok(struct super_block *sb, int readonly)
2462{
2463 if (EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP)) {
2464 ext4_msg(sb, KERN_ERR,
2465 "Couldn't mount because of "
2466 "unsupported optional features (%x)",
2467 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
2468 ~EXT4_FEATURE_INCOMPAT_SUPP));
2469 return 0;
2470 }
2471
2472 if (readonly)
2473 return 1;
2474
2475 /* Check that feature set is OK for a read-write mount */
2476 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP)) {
2477 ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of "
2478 "unsupported optional features (%x)",
2479 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
2480 ~EXT4_FEATURE_RO_COMPAT_SUPP));
2481 return 0;
2482 }
2483 /*
2484 * Large file size enabled file system can only be mounted
2485 * read-write on 32-bit systems if kernel is built with CONFIG_LBDAF
2486 */
2487 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
2488 if (sizeof(blkcnt_t) < sizeof(u64)) {
2489 ext4_msg(sb, KERN_ERR, "Filesystem with huge files "
2490 "cannot be mounted RDWR without "
2491 "CONFIG_LBDAF");
2492 return 0;
2493 }
2494 }
2495 return 1;
2496}
2497
Theodore Ts'o66e61a92010-07-27 11:56:04 -04002498/*
2499 * This function is called once a day if we have errors logged
2500 * on the file system
2501 */
2502static void print_daily_error_info(unsigned long arg)
2503{
2504 struct super_block *sb = (struct super_block *) arg;
2505 struct ext4_sb_info *sbi;
2506 struct ext4_super_block *es;
2507
2508 sbi = EXT4_SB(sb);
2509 es = sbi->s_es;
2510
2511 if (es->s_error_count)
2512 ext4_msg(sb, KERN_NOTICE, "error count: %u",
2513 le32_to_cpu(es->s_error_count));
2514 if (es->s_first_error_time) {
2515 printk(KERN_NOTICE "EXT4-fs (%s): initial error at %u: %.*s:%d",
2516 sb->s_id, le32_to_cpu(es->s_first_error_time),
2517 (int) sizeof(es->s_first_error_func),
2518 es->s_first_error_func,
2519 le32_to_cpu(es->s_first_error_line));
2520 if (es->s_first_error_ino)
2521 printk(": inode %u",
2522 le32_to_cpu(es->s_first_error_ino));
2523 if (es->s_first_error_block)
2524 printk(": block %llu", (unsigned long long)
2525 le64_to_cpu(es->s_first_error_block));
2526 printk("\n");
2527 }
2528 if (es->s_last_error_time) {
2529 printk(KERN_NOTICE "EXT4-fs (%s): last error at %u: %.*s:%d",
2530 sb->s_id, le32_to_cpu(es->s_last_error_time),
2531 (int) sizeof(es->s_last_error_func),
2532 es->s_last_error_func,
2533 le32_to_cpu(es->s_last_error_line));
2534 if (es->s_last_error_ino)
2535 printk(": inode %u",
2536 le32_to_cpu(es->s_last_error_ino));
2537 if (es->s_last_error_block)
2538 printk(": block %llu", (unsigned long long)
2539 le64_to_cpu(es->s_last_error_block));
2540 printk("\n");
2541 }
2542 mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ); /* Once a day */
2543}
2544
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002545static int ext4_fill_super(struct super_block *sb, void *data, int silent)
Aneesh Kumar K.V74778272008-07-11 19:27:31 -04002546 __releases(kernel_lock)
2547 __acquires(kernel_lock)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002548{
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04002549 char *orig_data = kstrdup(data, GFP_KERNEL);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002550 struct buffer_head *bh;
Mingming Cao617ba132006-10-11 01:20:53 -07002551 struct ext4_super_block *es = NULL;
2552 struct ext4_sb_info *sbi;
2553 ext4_fsblk_t block;
2554 ext4_fsblk_t sb_block = get_sb_block(&data);
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002555 ext4_fsblk_t logical_sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002556 unsigned long offset = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002557 unsigned long journal_devnum = 0;
2558 unsigned long def_mount_opts;
2559 struct inode *root;
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04002560 char *cp;
Frank Mayhar03901312009-01-07 00:06:22 -05002561 const char *descr;
Cyrill Gorcunovdcc7dae2010-07-27 11:56:07 -04002562 int ret = -ENOMEM;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002563 int blocksize;
Theodore Ts'o4ec11022009-01-06 14:53:26 -05002564 unsigned int db_count;
2565 unsigned int i;
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002566 int needs_recovery, has_huge_files;
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002567 __u64 blocks_count;
Peter Zijlstra833f4072007-10-16 23:25:45 -07002568 int err;
Theodore Ts'ob3881f72009-01-05 22:46:26 -05002569 unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002570
2571 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
2572 if (!sbi)
Cyrill Gorcunovdcc7dae2010-07-27 11:56:07 -04002573 goto out_free_orig;
Pekka Enberg705895b2009-02-15 18:07:52 -05002574
2575 sbi->s_blockgroup_lock =
2576 kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
2577 if (!sbi->s_blockgroup_lock) {
2578 kfree(sbi);
Cyrill Gorcunovdcc7dae2010-07-27 11:56:07 -04002579 goto out_free_orig;
Pekka Enberg705895b2009-02-15 18:07:52 -05002580 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002581 sb->s_fs_info = sbi;
2582 sbi->s_mount_opt = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07002583 sbi->s_resuid = EXT4_DEF_RESUID;
2584 sbi->s_resgid = EXT4_DEF_RESGID;
Theodore Ts'o240799c2008-10-09 23:53:47 -04002585 sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
Miklos Szeredid9c9bef2007-10-16 23:26:27 -07002586 sbi->s_sb_block = sb_block;
Theodore Ts'of613dfc2010-07-27 11:56:08 -04002587 if (sb->s_bdev->bd_part)
2588 sbi->s_sectors_written_start =
2589 part_stat_read(sb->s_bdev->bd_part, sectors[1]);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002590
2591 unlock_kernel();
2592
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04002593 /* Cleanup superblock name */
2594 for (cp = sb->s_id; (cp = strchr(cp, '/'));)
2595 *cp = '!';
2596
Cyrill Gorcunovdcc7dae2010-07-27 11:56:07 -04002597 ret = -EINVAL;
Mingming Cao617ba132006-10-11 01:20:53 -07002598 blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002599 if (!blocksize) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002600 ext4_msg(sb, KERN_ERR, "unable to set blocksize");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002601 goto out_fail;
2602 }
2603
2604 /*
Mingming Cao617ba132006-10-11 01:20:53 -07002605 * The ext4 superblock will not be buffer aligned for other than 1kB
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002606 * block sizes. We need to calculate the offset from buffer start.
2607 */
Mingming Cao617ba132006-10-11 01:20:53 -07002608 if (blocksize != EXT4_MIN_BLOCK_SIZE) {
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002609 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
2610 offset = do_div(logical_sb_block, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002611 } else {
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002612 logical_sb_block = sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002613 }
2614
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002615 if (!(bh = sb_bread(sb, logical_sb_block))) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002616 ext4_msg(sb, KERN_ERR, "unable to read superblock");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002617 goto out_fail;
2618 }
2619 /*
2620 * Note: s_es must be initialized as soon as possible because
Mingming Cao617ba132006-10-11 01:20:53 -07002621 * some ext4 macro-instructions depend on its value
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002622 */
Mingming Cao617ba132006-10-11 01:20:53 -07002623 es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002624 sbi->s_es = es;
2625 sb->s_magic = le16_to_cpu(es->s_magic);
Mingming Cao617ba132006-10-11 01:20:53 -07002626 if (sb->s_magic != EXT4_SUPER_MAGIC)
2627 goto cantfind_ext4;
Theodore Ts'oafc32f72009-02-28 19:39:58 -05002628 sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002629
2630 /* Set defaults before we parse the mount options */
2631 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
Mingming Cao617ba132006-10-11 01:20:53 -07002632 if (def_mount_opts & EXT4_DEFM_DEBUG)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002633 set_opt(sbi->s_mount_opt, DEBUG);
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05002634 if (def_mount_opts & EXT4_DEFM_BSDGROUPS) {
2635 ext4_msg(sb, KERN_WARNING, deprecated_msg, "bsdgroups",
2636 "2.6.38");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002637 set_opt(sbi->s_mount_opt, GRPID);
Dmitry Monakhov437ca0f2010-03-01 22:29:21 -05002638 }
Mingming Cao617ba132006-10-11 01:20:53 -07002639 if (def_mount_opts & EXT4_DEFM_UID16)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002640 set_opt(sbi->s_mount_opt, NO_UID32);
Theodore Ts'o03010a32008-10-10 20:02:48 -04002641#ifdef CONFIG_EXT4_FS_XATTR
Mingming Cao617ba132006-10-11 01:20:53 -07002642 if (def_mount_opts & EXT4_DEFM_XATTR_USER)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002643 set_opt(sbi->s_mount_opt, XATTR_USER);
Hugh Dickins2e7842b2007-02-10 01:46:13 -08002644#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -04002645#ifdef CONFIG_EXT4_FS_POSIX_ACL
Mingming Cao617ba132006-10-11 01:20:53 -07002646 if (def_mount_opts & EXT4_DEFM_ACL)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002647 set_opt(sbi->s_mount_opt, POSIX_ACL);
Hugh Dickins2e7842b2007-02-10 01:46:13 -08002648#endif
Mingming Cao617ba132006-10-11 01:20:53 -07002649 if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
Dmitry Monakhov482a7422010-02-24 11:35:32 -05002650 set_opt(sbi->s_mount_opt, JOURNAL_DATA);
Mingming Cao617ba132006-10-11 01:20:53 -07002651 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
Dmitry Monakhov482a7422010-02-24 11:35:32 -05002652 set_opt(sbi->s_mount_opt, ORDERED_DATA);
Mingming Cao617ba132006-10-11 01:20:53 -07002653 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
Dmitry Monakhov482a7422010-02-24 11:35:32 -05002654 set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002655
Mingming Cao617ba132006-10-11 01:20:53 -07002656 if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002657 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -05002658 else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
Dmitry Mishinceea16b2006-10-11 01:21:21 -07002659 set_opt(sbi->s_mount_opt, ERRORS_CONT);
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -05002660 else
2661 set_opt(sbi->s_mount_opt, ERRORS_RO);
Theodore Ts'o8b67f042010-08-01 23:14:20 -04002662 if (def_mount_opts & EXT4_DEFM_BLOCK_VALIDITY)
2663 set_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
2664 if (def_mount_opts & EXT4_DEFM_DISCARD)
2665 set_opt(sbi->s_mount_opt, DISCARD);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002666
2667 sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
2668 sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
Theodore Ts'o30773842009-01-03 20:27:38 -05002669 sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
2670 sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
2671 sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002672
Theodore Ts'o8b67f042010-08-01 23:14:20 -04002673 if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
2674 set_opt(sbi->s_mount_opt, BARRIER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002675
Mingming Cao1e2462f2007-07-18 09:00:55 -04002676 /*
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04002677 * enable delayed allocation by default
2678 * Use -o nodelalloc to turn it off
2679 */
Theodore Ts'o8b67f042010-08-01 23:14:20 -04002680 if (!IS_EXT3_SB(sb) &&
2681 ((def_mount_opts & EXT4_DEFM_NODELALLOC) == 0))
Jan Karaba69f9a2010-03-24 20:18:37 -04002682 set_opt(sbi->s_mount_opt, DELALLOC);
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04002683
Theodore Ts'o8b67f042010-08-01 23:14:20 -04002684 if (!parse_options((char *) sbi->s_es->s_mount_opts, sb,
2685 &journal_devnum, &journal_ioprio, NULL, 0)) {
2686 ext4_msg(sb, KERN_WARNING,
2687 "failed to parse options in superblock: %s",
2688 sbi->s_es->s_mount_opts);
2689 }
Theodore Ts'ob3881f72009-01-05 22:46:26 -05002690 if (!parse_options((char *) data, sb, &journal_devnum,
2691 &journal_ioprio, NULL, 0))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002692 goto failed_mount;
2693
2694 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
Dmitry Monakhov482a7422010-02-24 11:35:32 -05002695 (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002696
Mingming Cao617ba132006-10-11 01:20:53 -07002697 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
2698 (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) ||
2699 EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
2700 EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U)))
Eric Sandeenb31e1552009-06-04 17:36:36 -04002701 ext4_msg(sb, KERN_WARNING,
2702 "feature flags set on rev 0 fs, "
2703 "running e2fsck is recommended");
Theodore Tso469108f2008-02-10 01:11:44 -05002704
2705 /*
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002706 * Check feature flags regardless of the revision level, since we
2707 * previously didn't change the revision level when setting the flags,
2708 * so there is a chance incompat flags are set on a rev 0 filesystem.
2709 */
Eric Sandeena13fb1a2009-08-18 00:20:23 -04002710 if (!ext4_feature_set_ok(sb, (sb->s_flags & MS_RDONLY)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002711 goto failed_mount;
Eric Sandeena13fb1a2009-08-18 00:20:23 -04002712
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002713 blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
2714
Mingming Cao617ba132006-10-11 01:20:53 -07002715 if (blocksize < EXT4_MIN_BLOCK_SIZE ||
2716 blocksize > EXT4_MAX_BLOCK_SIZE) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002717 ext4_msg(sb, KERN_ERR,
2718 "Unsupported filesystem blocksize %d", blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002719 goto failed_mount;
2720 }
2721
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002722 if (sb->s_blocksize != blocksize) {
Aneesh Kumar K.Vce407332008-01-28 23:58:27 -05002723 /* Validate the filesystem blocksize */
2724 if (!sb_set_blocksize(sb, blocksize)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002725 ext4_msg(sb, KERN_ERR, "bad block size %d",
Aneesh Kumar K.Vce407332008-01-28 23:58:27 -05002726 blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002727 goto failed_mount;
2728 }
2729
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002730 brelse(bh);
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002731 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
2732 offset = do_div(logical_sb_block, blocksize);
2733 bh = sb_bread(sb, logical_sb_block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002734 if (!bh) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002735 ext4_msg(sb, KERN_ERR,
2736 "Can't read superblock on 2nd try");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002737 goto failed_mount;
2738 }
Mingming Cao617ba132006-10-11 01:20:53 -07002739 es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002740 sbi->s_es = es;
Mingming Cao617ba132006-10-11 01:20:53 -07002741 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002742 ext4_msg(sb, KERN_ERR,
2743 "Magic mismatch, very weird!");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002744 goto failed_mount;
2745 }
2746 }
2747
Eric Sandeena13fb1a2009-08-18 00:20:23 -04002748 has_huge_files = EXT4_HAS_RO_COMPAT_FEATURE(sb,
2749 EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002750 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
2751 has_huge_files);
2752 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002753
Mingming Cao617ba132006-10-11 01:20:53 -07002754 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
2755 sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
2756 sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002757 } else {
2758 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
2759 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
Mingming Cao617ba132006-10-11 01:20:53 -07002760 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
Vignesh Babu13305932007-07-18 09:11:02 -04002761 (!is_power_of_2(sbi->s_inode_size)) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002762 (sbi->s_inode_size > blocksize)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002763 ext4_msg(sb, KERN_ERR,
2764 "unsupported inode size: %d",
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002765 sbi->s_inode_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002766 goto failed_mount;
2767 }
Kalpak Shahef7f3832007-07-18 09:15:20 -04002768 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
2769 sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002770 }
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002771
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002772 sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
2773 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) {
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07002774 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002775 sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
vignesh babud8ea6cf2007-10-16 23:27:14 -07002776 !is_power_of_2(sbi->s_desc_size)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002777 ext4_msg(sb, KERN_ERR,
2778 "unsupported descriptor size %lu",
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002779 sbi->s_desc_size);
2780 goto failed_mount;
2781 }
2782 } else
2783 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002784
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002785 sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002786 sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
Andries E. Brouwerb47b6f32007-12-17 16:19:55 -08002787 if (EXT4_INODE_SIZE(sb) == 0 || EXT4_INODES_PER_GROUP(sb) == 0)
Mingming Cao617ba132006-10-11 01:20:53 -07002788 goto cantfind_ext4;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002789
Mingming Cao617ba132006-10-11 01:20:53 -07002790 sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002791 if (sbi->s_inodes_per_block == 0)
Mingming Cao617ba132006-10-11 01:20:53 -07002792 goto cantfind_ext4;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002793 sbi->s_itb_per_group = sbi->s_inodes_per_group /
2794 sbi->s_inodes_per_block;
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002795 sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002796 sbi->s_sbh = bh;
2797 sbi->s_mount_state = le16_to_cpu(es->s_state);
Fengguang Wue57aa832007-10-16 23:26:25 -07002798 sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
2799 sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002800
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002801 for (i = 0; i < 4; i++)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002802 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
2803 sbi->s_def_hash_version = es->s_def_hash_version;
Theodore Ts'of99b2582008-10-28 13:21:44 -04002804 i = le32_to_cpu(es->s_flags);
2805 if (i & EXT2_FLAGS_UNSIGNED_HASH)
2806 sbi->s_hash_unsigned = 3;
2807 else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
2808#ifdef __CHAR_UNSIGNED__
2809 es->s_flags |= cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
2810 sbi->s_hash_unsigned = 3;
2811#else
2812 es->s_flags |= cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
2813#endif
2814 sb->s_dirt = 1;
2815 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002816
2817 if (sbi->s_blocks_per_group > blocksize * 8) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002818 ext4_msg(sb, KERN_ERR,
2819 "#blocks per group too big: %lu",
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002820 sbi->s_blocks_per_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002821 goto failed_mount;
2822 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002823 if (sbi->s_inodes_per_group > blocksize * 8) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002824 ext4_msg(sb, KERN_ERR,
2825 "#inodes per group too big: %lu",
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002826 sbi->s_inodes_per_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002827 goto failed_mount;
2828 }
2829
Eric Sandeenbf43d842009-08-17 23:48:51 -04002830 /*
2831 * Test whether we have more sectors than will fit in sector_t,
2832 * and whether the max offset is addressable by the page cache.
2833 */
2834 if ((ext4_blocks_count(es) >
2835 (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) ||
2836 (ext4_blocks_count(es) >
2837 (pgoff_t)(~0ULL) >> (PAGE_CACHE_SHIFT - sb->s_blocksize_bits))) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002838 ext4_msg(sb, KERN_ERR, "filesystem"
Eric Sandeenbf43d842009-08-17 23:48:51 -04002839 " too large to mount safely on this system");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002840 if (sizeof(sector_t) < 8)
Bartlomiej Zolnierkiewicz90c699a2009-06-19 08:08:50 +02002841 ext4_msg(sb, KERN_WARNING, "CONFIG_LBDAF not enabled");
Eric Sandeenbf43d842009-08-17 23:48:51 -04002842 ret = -EFBIG;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002843 goto failed_mount;
2844 }
2845
Mingming Cao617ba132006-10-11 01:20:53 -07002846 if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
2847 goto cantfind_ext4;
Eric Sandeene7c95592008-01-28 23:58:27 -05002848
From: Thiemo Nagel0f2ddca2009-04-07 14:07:47 -04002849 /* check blocks count against device size */
2850 blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
2851 if (blocks_count && ext4_blocks_count(es) > blocks_count) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002852 ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
2853 "exceeds size of device (%llu blocks)",
From: Thiemo Nagel0f2ddca2009-04-07 14:07:47 -04002854 ext4_blocks_count(es), blocks_count);
2855 goto failed_mount;
2856 }
2857
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04002858 /*
2859 * It makes no sense for the first data block to be beyond the end
2860 * of the filesystem.
2861 */
2862 if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002863 ext4_msg(sb, KERN_WARNING, "bad geometry: first data"
2864 "block %u is beyond end of filesystem (%llu)",
2865 le32_to_cpu(es->s_first_data_block),
2866 ext4_blocks_count(es));
Eric Sandeene7c95592008-01-28 23:58:27 -05002867 goto failed_mount;
2868 }
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002869 blocks_count = (ext4_blocks_count(es) -
2870 le32_to_cpu(es->s_first_data_block) +
2871 EXT4_BLOCKS_PER_GROUP(sb) - 1);
2872 do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
Theodore Ts'o4ec11022009-01-06 14:53:26 -05002873 if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002874 ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
Theodore Ts'o4ec11022009-01-06 14:53:26 -05002875 "(block count %llu, first data block %u, "
Eric Sandeenb31e1552009-06-04 17:36:36 -04002876 "blocks per group %lu)", sbi->s_groups_count,
Theodore Ts'o4ec11022009-01-06 14:53:26 -05002877 ext4_blocks_count(es),
2878 le32_to_cpu(es->s_first_data_block),
2879 EXT4_BLOCKS_PER_GROUP(sb));
2880 goto failed_mount;
2881 }
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002882 sbi->s_groups_count = blocks_count;
Eric Sandeenfb0a3872009-09-16 14:45:10 -04002883 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
2884 (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
Mingming Cao617ba132006-10-11 01:20:53 -07002885 db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
2886 EXT4_DESC_PER_BLOCK(sb);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002887 sbi->s_group_desc = kmalloc(db_count * sizeof(struct buffer_head *),
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002888 GFP_KERNEL);
2889 if (sbi->s_group_desc == NULL) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002890 ext4_msg(sb, KERN_ERR, "not enough memory");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002891 goto failed_mount;
2892 }
2893
Alexander Beregalov3244fcb2008-10-12 17:27:49 -04002894#ifdef CONFIG_PROC_FS
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04002895 if (ext4_proc_root)
2896 sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root);
Alexander Beregalov3244fcb2008-10-12 17:27:49 -04002897#endif
Theodore Ts'o240799c2008-10-09 23:53:47 -04002898
Pekka Enberg705895b2009-02-15 18:07:52 -05002899 bgl_lock_init(sbi->s_blockgroup_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002900
2901 for (i = 0; i < db_count; i++) {
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002902 block = descriptor_loc(sb, logical_sb_block, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002903 sbi->s_group_desc[i] = sb_bread(sb, block);
2904 if (!sbi->s_group_desc[i]) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002905 ext4_msg(sb, KERN_ERR,
2906 "can't read group descriptor %d", i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002907 db_count = i;
2908 goto failed_mount2;
2909 }
2910 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002911 if (!ext4_check_descriptors(sb)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002912 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002913 goto failed_mount2;
2914 }
Jose R. Santos772cb7c2008-07-11 19:27:31 -04002915 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
2916 if (!ext4_fill_flex_info(sb)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002917 ext4_msg(sb, KERN_ERR,
2918 "unable to initialize "
2919 "flex_bg meta info!");
Jose R. Santos772cb7c2008-07-11 19:27:31 -04002920 goto failed_mount2;
2921 }
2922
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002923 sbi->s_gdb_count = db_count;
2924 get_random_bytes(&sbi->s_next_generation, sizeof(u32));
2925 spin_lock_init(&sbi->s_next_gen_lock);
2926
Alex Tomasc9de5602008-01-29 00:19:52 -05002927 sbi->s_stripe = ext4_get_stripe_size(sbi);
Theodore Ts'o55138e02009-09-29 13:31:31 -04002928 sbi->s_max_writeback_mb_bump = 128;
Alex Tomasc9de5602008-01-29 00:19:52 -05002929
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002930 /*
2931 * set up enough so that it can read an inode
2932 */
Theodore Ts'o9ca92382009-05-01 12:52:25 -04002933 if (!test_opt(sb, NOLOAD) &&
2934 EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL))
2935 sb->s_op = &ext4_sops;
2936 else
2937 sb->s_op = &ext4_nojournal_sops;
Mingming Cao617ba132006-10-11 01:20:53 -07002938 sb->s_export_op = &ext4_export_ops;
2939 sb->s_xattr = ext4_xattr_handlers;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002940#ifdef CONFIG_QUOTA
Mingming Cao617ba132006-10-11 01:20:53 -07002941 sb->s_qcop = &ext4_qctl_operations;
2942 sb->dq_op = &ext4_quota_operations;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002943#endif
2944 INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
Theodore Ts'o3b9d4ed2009-04-25 22:54:04 -04002945 mutex_init(&sbi->s_orphan_lock);
Theodore Ts'o32ed5052009-04-25 22:53:39 -04002946 mutex_init(&sbi->s_resize_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002947
2948 sb->s_root = NULL;
2949
2950 needs_recovery = (es->s_last_orphan != 0 ||
Mingming Cao617ba132006-10-11 01:20:53 -07002951 EXT4_HAS_INCOMPAT_FEATURE(sb,
2952 EXT4_FEATURE_INCOMPAT_RECOVER));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002953
2954 /*
2955 * The first inode we look at is the journal inode. Don't try
2956 * root first: it may be modified in the journal!
2957 */
2958 if (!test_opt(sb, NOLOAD) &&
Mingming Cao617ba132006-10-11 01:20:53 -07002959 EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
2960 if (ext4_load_journal(sb, es, journal_devnum))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002961 goto failed_mount3;
Frank Mayhar03901312009-01-07 00:06:22 -05002962 } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
2963 EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002964 ext4_msg(sb, KERN_ERR, "required journal recovery "
2965 "suppressed and not mounted read-only");
Jiaying Zhang744692d2010-03-04 16:14:02 -05002966 goto failed_mount_wq;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002967 } else {
Frank Mayhar03901312009-01-07 00:06:22 -05002968 clear_opt(sbi->s_mount_opt, DATA_FLAGS);
2969 set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
2970 sbi->s_journal = NULL;
2971 needs_recovery = 0;
2972 goto no_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002973 }
2974
Jose R. Santoseb40a092007-07-18 08:37:25 -04002975 if (ext4_blocks_count(es) > 0xffffffffULL &&
2976 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
2977 JBD2_FEATURE_INCOMPAT_64BIT)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04002978 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
Jiaying Zhang744692d2010-03-04 16:14:02 -05002979 goto failed_mount_wq;
Jose R. Santoseb40a092007-07-18 08:37:25 -04002980 }
2981
Linus Torvaldsd4da6c92009-11-02 10:15:27 -08002982 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
2983 jbd2_journal_set_features(sbi->s_journal,
2984 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
Girish Shilamkar818d2762008-01-28 23:58:27 -05002985 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
Linus Torvaldsd4da6c92009-11-02 10:15:27 -08002986 } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
2987 jbd2_journal_set_features(sbi->s_journal,
2988 JBD2_FEATURE_COMPAT_CHECKSUM, 0, 0);
Girish Shilamkar818d2762008-01-28 23:58:27 -05002989 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
2990 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
Linus Torvaldsd4da6c92009-11-02 10:15:27 -08002991 } else {
2992 jbd2_journal_clear_features(sbi->s_journal,
2993 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2994 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2995 }
Girish Shilamkar818d2762008-01-28 23:58:27 -05002996
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002997 /* We have now updated the journal if required, so we can
2998 * validate the data journaling mode. */
2999 switch (test_opt(sb, DATA_FLAGS)) {
3000 case 0:
3001 /* No mode set, assume a default based on the journal
Andrew Morton63f57932006-10-11 01:21:24 -07003002 * capabilities: ORDERED_DATA if the journal can
3003 * cope, else JOURNAL_DATA
3004 */
Mingming Caodab291a2006-10-11 01:21:01 -07003005 if (jbd2_journal_check_available_features
3006 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003007 set_opt(sbi->s_mount_opt, ORDERED_DATA);
3008 else
3009 set_opt(sbi->s_mount_opt, JOURNAL_DATA);
3010 break;
3011
Mingming Cao617ba132006-10-11 01:20:53 -07003012 case EXT4_MOUNT_ORDERED_DATA:
3013 case EXT4_MOUNT_WRITEBACK_DATA:
Mingming Caodab291a2006-10-11 01:21:01 -07003014 if (!jbd2_journal_check_available_features
3015 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003016 ext4_msg(sb, KERN_ERR, "Journal does not support "
3017 "requested data journaling mode");
Jiaying Zhang744692d2010-03-04 16:14:02 -05003018 goto failed_mount_wq;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003019 }
3020 default:
3021 break;
3022 }
Theodore Ts'ob3881f72009-01-05 22:46:26 -05003023 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003024
Frank Mayhar03901312009-01-07 00:06:22 -05003025no_journal:
Dmitry Monakhov84061e02010-05-16 08:00:00 -04003026 err = percpu_counter_init(&sbi->s_freeblocks_counter,
3027 ext4_count_free_blocks(sb));
3028 if (!err)
3029 err = percpu_counter_init(&sbi->s_freeinodes_counter,
3030 ext4_count_free_inodes(sb));
3031 if (!err)
3032 err = percpu_counter_init(&sbi->s_dirs_counter,
3033 ext4_count_dirs(sb));
3034 if (!err)
3035 err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
3036 if (err) {
3037 ext4_msg(sb, KERN_ERR, "insufficient memory");
3038 goto failed_mount_wq;
3039 }
Christoph Hellwig206f7ab2010-06-14 14:42:49 -04003040
Mingming Cao4c0425f2009-09-28 15:48:41 -04003041 EXT4_SB(sb)->dio_unwritten_wq = create_workqueue("ext4-dio-unwritten");
3042 if (!EXT4_SB(sb)->dio_unwritten_wq) {
3043 printk(KERN_ERR "EXT4-fs: failed to create DIO workqueue\n");
3044 goto failed_mount_wq;
3045 }
3046
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003047 /*
Mingming Caodab291a2006-10-11 01:21:01 -07003048 * The jbd2_journal_load will have done any necessary log recovery,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003049 * so we can safely mount the rest of the filesystem now.
3050 */
3051
David Howells1d1fe1e2008-02-07 00:15:37 -08003052 root = ext4_iget(sb, EXT4_ROOT_INO);
3053 if (IS_ERR(root)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003054 ext4_msg(sb, KERN_ERR, "get root inode failed");
David Howells1d1fe1e2008-02-07 00:15:37 -08003055 ret = PTR_ERR(root);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003056 goto failed_mount4;
3057 }
3058 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
David Howells1d1fe1e2008-02-07 00:15:37 -08003059 iput(root);
Eric Sandeenb31e1552009-06-04 17:36:36 -04003060 ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003061 goto failed_mount4;
3062 }
David Howells1d1fe1e2008-02-07 00:15:37 -08003063 sb->s_root = d_alloc_root(root);
3064 if (!sb->s_root) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003065 ext4_msg(sb, KERN_ERR, "get root dentry failed");
David Howells1d1fe1e2008-02-07 00:15:37 -08003066 iput(root);
3067 ret = -ENOMEM;
3068 goto failed_mount4;
3069 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003070
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003071 ext4_setup_super(sb, es, sb->s_flags & MS_RDONLY);
Kalpak Shahef7f3832007-07-18 09:15:20 -04003072
3073 /* determine the minimum size of new large inodes, if present */
3074 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
3075 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
3076 EXT4_GOOD_OLD_INODE_SIZE;
3077 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
3078 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
3079 if (sbi->s_want_extra_isize <
3080 le16_to_cpu(es->s_want_extra_isize))
3081 sbi->s_want_extra_isize =
3082 le16_to_cpu(es->s_want_extra_isize);
3083 if (sbi->s_want_extra_isize <
3084 le16_to_cpu(es->s_min_extra_isize))
3085 sbi->s_want_extra_isize =
3086 le16_to_cpu(es->s_min_extra_isize);
3087 }
3088 }
3089 /* Check if enough inode space is available */
3090 if (EXT4_GOOD_OLD_INODE_SIZE + sbi->s_want_extra_isize >
3091 sbi->s_inode_size) {
3092 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
3093 EXT4_GOOD_OLD_INODE_SIZE;
Eric Sandeenb31e1552009-06-04 17:36:36 -04003094 ext4_msg(sb, KERN_INFO, "required extra inode space not"
3095 "available");
Kalpak Shahef7f3832007-07-18 09:15:20 -04003096 }
3097
Theodore Ts'o90576c02009-09-29 15:51:30 -04003098 if (test_opt(sb, DELALLOC) &&
3099 (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003100 ext4_msg(sb, KERN_WARNING, "Ignoring delalloc option - "
3101 "requested data journaling mode");
Aneesh Kumar K.Vc2774d82008-10-10 20:07:20 -04003102 clear_opt(sbi->s_mount_opt, DELALLOC);
Theodore Ts'o90576c02009-09-29 15:51:30 -04003103 }
Jiaying Zhang744692d2010-03-04 16:14:02 -05003104 if (test_opt(sb, DIOREAD_NOLOCK)) {
3105 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
3106 ext4_msg(sb, KERN_WARNING, "Ignoring dioread_nolock "
3107 "option - requested data journaling mode");
3108 clear_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
3109 }
3110 if (sb->s_blocksize < PAGE_SIZE) {
3111 ext4_msg(sb, KERN_WARNING, "Ignoring dioread_nolock "
3112 "option - block size is too small");
3113 clear_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
3114 }
3115 }
Aneesh Kumar K.Vc2774d82008-10-10 20:07:20 -04003116
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04003117 err = ext4_setup_system_zone(sb);
3118 if (err) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003119 ext4_msg(sb, KERN_ERR, "failed to initialize system "
Curt Wohlgemuthfbe845d2010-05-16 13:00:00 -04003120 "zone (%d)", err);
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04003121 goto failed_mount4;
3122 }
3123
Aneesh Kumar K.Vc2774d82008-10-10 20:07:20 -04003124 ext4_ext_init(sb);
3125 err = ext4_mb_init(sb, needs_recovery);
3126 if (err) {
Uwe Kleine-König421f91d2010-06-11 12:17:00 +02003127 ext4_msg(sb, KERN_ERR, "failed to initialize mballoc (%d)",
Eric Sandeenb31e1552009-06-04 17:36:36 -04003128 err);
Aneesh Kumar K.Vc2774d82008-10-10 20:07:20 -04003129 goto failed_mount4;
3130 }
3131
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04003132 sbi->s_kobj.kset = ext4_kset;
3133 init_completion(&sbi->s_kobj_unregister);
3134 err = kobject_init_and_add(&sbi->s_kobj, &ext4_ktype, NULL,
3135 "%s", sb->s_id);
3136 if (err) {
3137 ext4_mb_release(sb);
3138 ext4_ext_release(sb);
3139 goto failed_mount4;
3140 };
3141
Mingming Cao617ba132006-10-11 01:20:53 -07003142 EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
3143 ext4_orphan_cleanup(sb, es);
3144 EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
Frank Mayhar03901312009-01-07 00:06:22 -05003145 if (needs_recovery) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003146 ext4_msg(sb, KERN_INFO, "recovery complete");
Frank Mayhar03901312009-01-07 00:06:22 -05003147 ext4_mark_recovery_complete(sb, es);
3148 }
3149 if (EXT4_SB(sb)->s_journal) {
3150 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
3151 descr = " journalled data mode";
3152 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
3153 descr = " ordered data mode";
3154 else
3155 descr = " writeback data mode";
3156 } else
3157 descr = "out journal";
3158
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04003159 ext4_msg(sb, KERN_INFO, "mounted filesystem with%s. "
Theodore Ts'o8b67f042010-08-01 23:14:20 -04003160 "Opts: %s%s%s", descr, sbi->s_es->s_mount_opts,
3161 *sbi->s_es->s_mount_opts ? "; " : "", orig_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003162
Theodore Ts'o66e61a92010-07-27 11:56:04 -04003163 init_timer(&sbi->s_err_report);
3164 sbi->s_err_report.function = print_daily_error_info;
3165 sbi->s_err_report.data = (unsigned long) sb;
3166 if (es->s_error_count)
3167 mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003168
3169 lock_kernel();
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04003170 kfree(orig_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003171 return 0;
3172
Mingming Cao617ba132006-10-11 01:20:53 -07003173cantfind_ext4:
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003174 if (!silent)
Eric Sandeenb31e1552009-06-04 17:36:36 -04003175 ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003176 goto failed_mount;
3177
3178failed_mount4:
Eric Sandeenb31e1552009-06-04 17:36:36 -04003179 ext4_msg(sb, KERN_ERR, "mount failed");
Mingming Cao4c0425f2009-09-28 15:48:41 -04003180 destroy_workqueue(EXT4_SB(sb)->dio_unwritten_wq);
3181failed_mount_wq:
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04003182 ext4_release_system_zone(sb);
Frank Mayhar03901312009-01-07 00:06:22 -05003183 if (sbi->s_journal) {
3184 jbd2_journal_destroy(sbi->s_journal);
3185 sbi->s_journal = NULL;
3186 }
Dmitry Monakhov84061e02010-05-16 08:00:00 -04003187 percpu_counter_destroy(&sbi->s_freeblocks_counter);
3188 percpu_counter_destroy(&sbi->s_freeinodes_counter);
3189 percpu_counter_destroy(&sbi->s_dirs_counter);
3190 percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003191failed_mount3:
Theodore Ts'oc5ca7c72009-04-27 22:48:48 -04003192 if (sbi->s_flex_groups) {
3193 if (is_vmalloc_addr(sbi->s_flex_groups))
3194 vfree(sbi->s_flex_groups);
3195 else
3196 kfree(sbi->s_flex_groups);
3197 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003198failed_mount2:
3199 for (i = 0; i < db_count; i++)
3200 brelse(sbi->s_group_desc[i]);
3201 kfree(sbi->s_group_desc);
3202failed_mount:
Theodore Ts'o240799c2008-10-09 23:53:47 -04003203 if (sbi->s_proc) {
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04003204 remove_proc_entry(sb->s_id, ext4_proc_root);
Theodore Ts'o240799c2008-10-09 23:53:47 -04003205 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003206#ifdef CONFIG_QUOTA
3207 for (i = 0; i < MAXQUOTAS; i++)
3208 kfree(sbi->s_qf_names[i]);
3209#endif
Mingming Cao617ba132006-10-11 01:20:53 -07003210 ext4_blkdev_remove(sbi);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003211 brelse(bh);
3212out_fail:
3213 sb->s_fs_info = NULL;
Manish Katiyarf6830162009-05-17 23:52:44 -04003214 kfree(sbi->s_blockgroup_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003215 kfree(sbi);
3216 lock_kernel();
Cyrill Gorcunovdcc7dae2010-07-27 11:56:07 -04003217out_free_orig:
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04003218 kfree(orig_data);
David Howells1d1fe1e2008-02-07 00:15:37 -08003219 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003220}
3221
3222/*
3223 * Setup any per-fs journal parameters now. We'll do this both on
3224 * initial mount, once the journal has been initialised but before we've
3225 * done any recovery; and again on any subsequent remount.
3226 */
Mingming Cao617ba132006-10-11 01:20:53 -07003227static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003228{
Mingming Cao617ba132006-10-11 01:20:53 -07003229 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003230
Theodore Ts'o30773842009-01-03 20:27:38 -05003231 journal->j_commit_interval = sbi->s_commit_interval;
3232 journal->j_min_batch_time = sbi->s_min_batch_time;
3233 journal->j_max_batch_time = sbi->s_max_batch_time;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003234
Theodore Ts'oa931da62010-08-03 21:35:12 -04003235 write_lock(&journal->j_state_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003236 if (test_opt(sb, BARRIER))
Mingming Caodab291a2006-10-11 01:21:01 -07003237 journal->j_flags |= JBD2_BARRIER;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003238 else
Mingming Caodab291a2006-10-11 01:21:01 -07003239 journal->j_flags &= ~JBD2_BARRIER;
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04003240 if (test_opt(sb, DATA_ERR_ABORT))
3241 journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
3242 else
3243 journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
Theodore Ts'oa931da62010-08-03 21:35:12 -04003244 write_unlock(&journal->j_state_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003245}
3246
Mingming Cao617ba132006-10-11 01:20:53 -07003247static journal_t *ext4_get_journal(struct super_block *sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003248 unsigned int journal_inum)
3249{
3250 struct inode *journal_inode;
3251 journal_t *journal;
3252
Frank Mayhar03901312009-01-07 00:06:22 -05003253 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
3254
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003255 /* First, test for the existence of a valid inode on disk. Bad
3256 * things happen if we iget() an unused inode, as the subsequent
3257 * iput() will try to delete it. */
3258
David Howells1d1fe1e2008-02-07 00:15:37 -08003259 journal_inode = ext4_iget(sb, journal_inum);
3260 if (IS_ERR(journal_inode)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003261 ext4_msg(sb, KERN_ERR, "no journal found");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003262 return NULL;
3263 }
3264 if (!journal_inode->i_nlink) {
3265 make_bad_inode(journal_inode);
3266 iput(journal_inode);
Eric Sandeenb31e1552009-06-04 17:36:36 -04003267 ext4_msg(sb, KERN_ERR, "journal inode is deleted");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003268 return NULL;
3269 }
3270
Theodore Ts'oe5f8eab2008-09-08 22:25:04 -04003271 jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003272 journal_inode, journal_inode->i_size);
David Howells1d1fe1e2008-02-07 00:15:37 -08003273 if (!S_ISREG(journal_inode->i_mode)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003274 ext4_msg(sb, KERN_ERR, "invalid journal inode");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003275 iput(journal_inode);
3276 return NULL;
3277 }
3278
Mingming Caodab291a2006-10-11 01:21:01 -07003279 journal = jbd2_journal_init_inode(journal_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003280 if (!journal) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003281 ext4_msg(sb, KERN_ERR, "Could not load journal inode");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003282 iput(journal_inode);
3283 return NULL;
3284 }
3285 journal->j_private = sb;
Mingming Cao617ba132006-10-11 01:20:53 -07003286 ext4_init_journal_params(sb, journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003287 return journal;
3288}
3289
Mingming Cao617ba132006-10-11 01:20:53 -07003290static journal_t *ext4_get_dev_journal(struct super_block *sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003291 dev_t j_dev)
3292{
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003293 struct buffer_head *bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003294 journal_t *journal;
Mingming Cao617ba132006-10-11 01:20:53 -07003295 ext4_fsblk_t start;
3296 ext4_fsblk_t len;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003297 int hblock, blocksize;
Mingming Cao617ba132006-10-11 01:20:53 -07003298 ext4_fsblk_t sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003299 unsigned long offset;
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003300 struct ext4_super_block *es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003301 struct block_device *bdev;
3302
Frank Mayhar03901312009-01-07 00:06:22 -05003303 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
3304
Eric Sandeenb31e1552009-06-04 17:36:36 -04003305 bdev = ext4_blkdev_get(j_dev, sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003306 if (bdev == NULL)
3307 return NULL;
3308
3309 if (bd_claim(bdev, sb)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003310 ext4_msg(sb, KERN_ERR,
3311 "failed to claim external journal device");
Al Viro9a1c3542008-02-22 20:40:24 -05003312 blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003313 return NULL;
3314 }
3315
3316 blocksize = sb->s_blocksize;
Martin K. Petersene1defc42009-05-22 17:17:49 -04003317 hblock = bdev_logical_block_size(bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003318 if (blocksize < hblock) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003319 ext4_msg(sb, KERN_ERR,
3320 "blocksize too small for journal device");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003321 goto out_bdev;
3322 }
3323
Mingming Cao617ba132006-10-11 01:20:53 -07003324 sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
3325 offset = EXT4_MIN_BLOCK_SIZE % blocksize;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003326 set_blocksize(bdev, blocksize);
3327 if (!(bh = __bread(bdev, sb_block, blocksize))) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003328 ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
3329 "external journal");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003330 goto out_bdev;
3331 }
3332
Mingming Cao617ba132006-10-11 01:20:53 -07003333 es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
3334 if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003335 !(le32_to_cpu(es->s_feature_incompat) &
Mingming Cao617ba132006-10-11 01:20:53 -07003336 EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003337 ext4_msg(sb, KERN_ERR, "external journal has "
3338 "bad superblock");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003339 brelse(bh);
3340 goto out_bdev;
3341 }
3342
Mingming Cao617ba132006-10-11 01:20:53 -07003343 if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003344 ext4_msg(sb, KERN_ERR, "journal UUID does not match");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003345 brelse(bh);
3346 goto out_bdev;
3347 }
3348
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07003349 len = ext4_blocks_count(es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003350 start = sb_block + 1;
3351 brelse(bh); /* we're done with the superblock */
3352
Mingming Caodab291a2006-10-11 01:21:01 -07003353 journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003354 start, len, blocksize);
3355 if (!journal) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003356 ext4_msg(sb, KERN_ERR, "failed to create device journal");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003357 goto out_bdev;
3358 }
3359 journal->j_private = sb;
3360 ll_rw_block(READ, 1, &journal->j_sb_buffer);
3361 wait_on_buffer(journal->j_sb_buffer);
3362 if (!buffer_uptodate(journal->j_sb_buffer)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003363 ext4_msg(sb, KERN_ERR, "I/O error on journal device");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003364 goto out_journal;
3365 }
3366 if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003367 ext4_msg(sb, KERN_ERR, "External journal has more than one "
3368 "user (unsupported) - %d",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003369 be32_to_cpu(journal->j_superblock->s_nr_users));
3370 goto out_journal;
3371 }
Mingming Cao617ba132006-10-11 01:20:53 -07003372 EXT4_SB(sb)->journal_bdev = bdev;
3373 ext4_init_journal_params(sb, journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003374 return journal;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003375
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003376out_journal:
Mingming Caodab291a2006-10-11 01:21:01 -07003377 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003378out_bdev:
Mingming Cao617ba132006-10-11 01:20:53 -07003379 ext4_blkdev_put(bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003380 return NULL;
3381}
3382
Mingming Cao617ba132006-10-11 01:20:53 -07003383static int ext4_load_journal(struct super_block *sb,
3384 struct ext4_super_block *es,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003385 unsigned long journal_devnum)
3386{
3387 journal_t *journal;
3388 unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
3389 dev_t journal_dev;
3390 int err = 0;
3391 int really_read_only;
3392
Frank Mayhar03901312009-01-07 00:06:22 -05003393 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
3394
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003395 if (journal_devnum &&
3396 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003397 ext4_msg(sb, KERN_INFO, "external journal device major/minor "
3398 "numbers have changed");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003399 journal_dev = new_decode_dev(journal_devnum);
3400 } else
3401 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
3402
3403 really_read_only = bdev_read_only(sb->s_bdev);
3404
3405 /*
3406 * Are we loading a blank journal or performing recovery after a
3407 * crash? For recovery, we need to check in advance whether we
3408 * can get read-write access to the device.
3409 */
Mingming Cao617ba132006-10-11 01:20:53 -07003410 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003411 if (sb->s_flags & MS_RDONLY) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003412 ext4_msg(sb, KERN_INFO, "INFO: recovery "
3413 "required on readonly filesystem");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003414 if (really_read_only) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003415 ext4_msg(sb, KERN_ERR, "write access "
3416 "unavailable, cannot proceed");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003417 return -EROFS;
3418 }
Eric Sandeenb31e1552009-06-04 17:36:36 -04003419 ext4_msg(sb, KERN_INFO, "write access will "
3420 "be enabled during recovery");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003421 }
3422 }
3423
3424 if (journal_inum && journal_dev) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003425 ext4_msg(sb, KERN_ERR, "filesystem has both journal "
3426 "and inode journals!");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003427 return -EINVAL;
3428 }
3429
3430 if (journal_inum) {
Mingming Cao617ba132006-10-11 01:20:53 -07003431 if (!(journal = ext4_get_journal(sb, journal_inum)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003432 return -EINVAL;
3433 } else {
Mingming Cao617ba132006-10-11 01:20:53 -07003434 if (!(journal = ext4_get_dev_journal(sb, journal_dev)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003435 return -EINVAL;
3436 }
3437
Theodore Ts'o90576c02009-09-29 15:51:30 -04003438 if (!(journal->j_flags & JBD2_BARRIER))
Eric Sandeenb31e1552009-06-04 17:36:36 -04003439 ext4_msg(sb, KERN_INFO, "barriers disabled");
Theodore Ts'o47760042008-09-08 23:00:52 -04003440
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003441 if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
Mingming Caodab291a2006-10-11 01:21:01 -07003442 err = jbd2_journal_update_format(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003443 if (err) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003444 ext4_msg(sb, KERN_ERR, "error updating journal");
Mingming Caodab291a2006-10-11 01:21:01 -07003445 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003446 return err;
3447 }
3448 }
3449
Mingming Cao617ba132006-10-11 01:20:53 -07003450 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER))
Mingming Caodab291a2006-10-11 01:21:01 -07003451 err = jbd2_journal_wipe(journal, !really_read_only);
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -04003452 if (!err) {
3453 char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
3454 if (save)
3455 memcpy(save, ((char *) es) +
3456 EXT4_S_ERR_START, EXT4_S_ERR_LEN);
Mingming Caodab291a2006-10-11 01:21:01 -07003457 err = jbd2_journal_load(journal);
Theodore Ts'o1c13d5c2010-07-27 11:56:03 -04003458 if (save)
3459 memcpy(((char *) es) + EXT4_S_ERR_START,
3460 save, EXT4_S_ERR_LEN);
3461 kfree(save);
3462 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003463
3464 if (err) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003465 ext4_msg(sb, KERN_ERR, "error loading journal");
Mingming Caodab291a2006-10-11 01:21:01 -07003466 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003467 return err;
3468 }
3469
Mingming Cao617ba132006-10-11 01:20:53 -07003470 EXT4_SB(sb)->s_journal = journal;
3471 ext4_clear_journal_err(sb, es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003472
3473 if (journal_devnum &&
3474 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
3475 es->s_journal_dev = cpu_to_le32(journal_devnum);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003476
3477 /* Make sure we flush the recovery flag to disk. */
Theodore Ts'oe2d67052009-05-01 00:33:44 -04003478 ext4_commit_super(sb, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003479 }
3480
3481 return 0;
3482}
3483
Theodore Ts'oe2d67052009-05-01 00:33:44 -04003484static int ext4_commit_super(struct super_block *sb, int sync)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003485{
Theodore Ts'oe2d67052009-05-01 00:33:44 -04003486 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Mingming Cao617ba132006-10-11 01:20:53 -07003487 struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
Takashi Satoc4be0c12009-01-09 16:40:58 -08003488 int error = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003489
3490 if (!sbh)
Takashi Satoc4be0c12009-01-09 16:40:58 -08003491 return error;
Theodore Ts'o914258b2008-10-06 21:35:40 -04003492 if (buffer_write_io_error(sbh)) {
3493 /*
3494 * Oh, dear. A previous attempt to write the
3495 * superblock failed. This could happen because the
3496 * USB device was yanked out. Or it could happen to
3497 * be a transient write error and maybe the block will
3498 * be remapped. Nothing we can do but to retry the
3499 * write and hope for the best.
3500 */
Eric Sandeenb31e1552009-06-04 17:36:36 -04003501 ext4_msg(sb, KERN_ERR, "previous I/O error to "
3502 "superblock detected");
Theodore Ts'o914258b2008-10-06 21:35:40 -04003503 clear_buffer_write_io_error(sbh);
3504 set_buffer_uptodate(sbh);
3505 }
Theodore Ts'o71290b32009-09-10 17:31:04 -04003506 /*
3507 * If the file system is mounted read-only, don't update the
3508 * superblock write time. This avoids updating the superblock
3509 * write time when we are mounting the root file system
3510 * read/only but we need to replay the journal; at that point,
3511 * for people who are east of GMT and who make their clock
3512 * tick in localtime for Windows bug-for-bug compatibility,
3513 * the clock is set in the future, and this will cause e2fsck
3514 * to complain and force a full file system check.
3515 */
3516 if (!(sb->s_flags & MS_RDONLY))
3517 es->s_wtime = cpu_to_le32(get_seconds());
Theodore Ts'of613dfc2010-07-27 11:56:08 -04003518 if (sb->s_bdev->bd_part)
3519 es->s_kbytes_written =
3520 cpu_to_le64(EXT4_SB(sb)->s_kbytes_written +
Theodore Ts'oafc32f72009-02-28 19:39:58 -05003521 ((part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
3522 EXT4_SB(sb)->s_sectors_written_start) >> 1));
Theodore Ts'of613dfc2010-07-27 11:56:08 -04003523 else
3524 es->s_kbytes_written =
3525 cpu_to_le64(EXT4_SB(sb)->s_kbytes_written);
Aneesh Kumar K.V5d1b1b32009-01-05 22:19:52 -05003526 ext4_free_blocks_count_set(es, percpu_counter_sum_positive(
3527 &EXT4_SB(sb)->s_freeblocks_counter));
3528 es->s_free_inodes_count = cpu_to_le32(percpu_counter_sum_positive(
3529 &EXT4_SB(sb)->s_freeinodes_counter));
Theodore Ts'o7234ab22009-04-30 21:24:04 -04003530 sb->s_dirt = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003531 BUFFER_TRACE(sbh, "marking dirty");
3532 mark_buffer_dirty(sbh);
Theodore Ts'o914258b2008-10-06 21:35:40 -04003533 if (sync) {
Takashi Satoc4be0c12009-01-09 16:40:58 -08003534 error = sync_dirty_buffer(sbh);
3535 if (error)
3536 return error;
3537
3538 error = buffer_write_io_error(sbh);
3539 if (error) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003540 ext4_msg(sb, KERN_ERR, "I/O error while writing "
3541 "superblock");
Theodore Ts'o914258b2008-10-06 21:35:40 -04003542 clear_buffer_write_io_error(sbh);
3543 set_buffer_uptodate(sbh);
3544 }
3545 }
Takashi Satoc4be0c12009-01-09 16:40:58 -08003546 return error;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003547}
3548
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003549/*
3550 * Have we just finished recovery? If so, and if we are mounting (or
3551 * remounting) the filesystem readonly, then we will end up with a
3552 * consistent fs on disk. Record that fact.
3553 */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003554static void ext4_mark_recovery_complete(struct super_block *sb,
3555 struct ext4_super_block *es)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003556{
Mingming Cao617ba132006-10-11 01:20:53 -07003557 journal_t *journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003558
Frank Mayhar03901312009-01-07 00:06:22 -05003559 if (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
3560 BUG_ON(journal != NULL);
3561 return;
3562 }
Mingming Caodab291a2006-10-11 01:21:01 -07003563 jbd2_journal_lock_updates(journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04003564 if (jbd2_journal_flush(journal) < 0)
3565 goto out;
3566
Mingming Cao617ba132006-10-11 01:20:53 -07003567 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003568 sb->s_flags & MS_RDONLY) {
Mingming Cao617ba132006-10-11 01:20:53 -07003569 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
Theodore Ts'oe2d67052009-05-01 00:33:44 -04003570 ext4_commit_super(sb, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003571 }
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04003572
3573out:
Mingming Caodab291a2006-10-11 01:21:01 -07003574 jbd2_journal_unlock_updates(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003575}
3576
3577/*
3578 * If we are mounting (or read-write remounting) a filesystem whose journal
3579 * has recorded an error from a previous lifetime, move that error to the
3580 * main filesystem now.
3581 */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003582static void ext4_clear_journal_err(struct super_block *sb,
3583 struct ext4_super_block *es)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003584{
3585 journal_t *journal;
3586 int j_errno;
3587 const char *errstr;
3588
Frank Mayhar03901312009-01-07 00:06:22 -05003589 BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
3590
Mingming Cao617ba132006-10-11 01:20:53 -07003591 journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003592
3593 /*
3594 * Now check for any error status which may have been recorded in the
Mingming Cao617ba132006-10-11 01:20:53 -07003595 * journal by a prior ext4_error() or ext4_abort()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003596 */
3597
Mingming Caodab291a2006-10-11 01:21:01 -07003598 j_errno = jbd2_journal_errno(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003599 if (j_errno) {
3600 char nbuf[16];
3601
Mingming Cao617ba132006-10-11 01:20:53 -07003602 errstr = ext4_decode_error(sb, j_errno, nbuf);
Eric Sandeen12062dd2010-02-15 14:19:27 -05003603 ext4_warning(sb, "Filesystem error recorded "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003604 "from previous mount: %s", errstr);
Eric Sandeen12062dd2010-02-15 14:19:27 -05003605 ext4_warning(sb, "Marking fs in need of filesystem check.");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003606
Mingming Cao617ba132006-10-11 01:20:53 -07003607 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
3608 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
Theodore Ts'oe2d67052009-05-01 00:33:44 -04003609 ext4_commit_super(sb, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003610
Mingming Caodab291a2006-10-11 01:21:01 -07003611 jbd2_journal_clear_err(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003612 }
3613}
3614
3615/*
3616 * Force the running and committing transactions to commit,
3617 * and wait on the commit.
3618 */
Mingming Cao617ba132006-10-11 01:20:53 -07003619int ext4_force_commit(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003620{
3621 journal_t *journal;
Frank Mayhar03901312009-01-07 00:06:22 -05003622 int ret = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003623
3624 if (sb->s_flags & MS_RDONLY)
3625 return 0;
3626
Mingming Cao617ba132006-10-11 01:20:53 -07003627 journal = EXT4_SB(sb)->s_journal;
Eric Sandeen6b0310f2010-05-16 02:00:00 -04003628 if (journal) {
Eric Sandeen437f88c2010-08-01 17:33:29 -04003629 vfs_check_frozen(sb, SB_FREEZE_TRANS);
Frank Mayhar03901312009-01-07 00:06:22 -05003630 ret = ext4_journal_force_commit(journal);
Eric Sandeen6b0310f2010-05-16 02:00:00 -04003631 }
Frank Mayhar03901312009-01-07 00:06:22 -05003632
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003633 return ret;
3634}
3635
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003636static void ext4_write_super(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003637{
Christoph Hellwigebc1ac12009-05-11 23:35:03 +02003638 lock_super(sb);
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003639 ext4_commit_super(sb, 1);
Christoph Hellwigebc1ac12009-05-11 23:35:03 +02003640 unlock_super(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003641}
3642
Mingming Cao617ba132006-10-11 01:20:53 -07003643static int ext4_sync_fs(struct super_block *sb, int wait)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003644{
Theodore Ts'o14ce0cb2008-11-03 18:10:55 -05003645 int ret = 0;
Jan Kara9eddacf2009-02-10 06:46:05 -05003646 tid_t target;
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003647 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003648
Theodore Ts'o9bffad12009-06-17 11:48:11 -04003649 trace_ext4_sync_fs(sb, wait);
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003650 flush_workqueue(sbi->dio_unwritten_wq);
3651 if (jbd2_journal_start_commit(sbi->s_journal, &target)) {
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003652 if (wait)
Mingming Cao8d5d02e2009-09-28 15:48:29 -04003653 jbd2_log_wait_commit(sbi->s_journal, target);
Frank Mayhar03901312009-01-07 00:06:22 -05003654 }
Theodore Ts'o14ce0cb2008-11-03 18:10:55 -05003655 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003656}
3657
3658/*
3659 * LVM calls this function before a (read-only) snapshot is created. This
3660 * gives us a chance to flush the journal completely and mark the fs clean.
3661 */
Takashi Satoc4be0c12009-01-09 16:40:58 -08003662static int ext4_freeze(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003663{
Takashi Satoc4be0c12009-01-09 16:40:58 -08003664 int error = 0;
3665 journal_t *journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003666
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003667 if (sb->s_flags & MS_RDONLY)
3668 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003669
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003670 journal = EXT4_SB(sb)->s_journal;
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04003671
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003672 /* Now we set up the journal barrier. */
3673 jbd2_journal_lock_updates(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003674
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003675 /*
3676 * Don't clear the needs_recovery flag if we failed to flush
3677 * the journal.
3678 */
3679 error = jbd2_journal_flush(journal);
Eric Sandeen6b0310f2010-05-16 02:00:00 -04003680 if (error < 0)
3681 goto out;
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003682
3683 /* Journal blocked and flushed, clear needs_recovery flag. */
3684 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
3685 error = ext4_commit_super(sb, 1);
Eric Sandeen6b0310f2010-05-16 02:00:00 -04003686out:
3687 /* we rely on s_frozen to stop further updates */
3688 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
3689 return error;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003690}
3691
3692/*
3693 * Called by LVM after the snapshot is done. We need to reset the RECOVER
3694 * flag here, even though the filesystem is not technically dirty yet.
3695 */
Takashi Satoc4be0c12009-01-09 16:40:58 -08003696static int ext4_unfreeze(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003697{
Theodore Ts'o9ca92382009-05-01 12:52:25 -04003698 if (sb->s_flags & MS_RDONLY)
3699 return 0;
3700
3701 lock_super(sb);
3702 /* Reset the needs_recovery flag before the fs is unlocked. */
3703 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
3704 ext4_commit_super(sb, 1);
3705 unlock_super(sb);
Takashi Satoc4be0c12009-01-09 16:40:58 -08003706 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003707}
3708
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003709static int ext4_remount(struct super_block *sb, int *flags, char *data)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003710{
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003711 struct ext4_super_block *es;
Mingming Cao617ba132006-10-11 01:20:53 -07003712 struct ext4_sb_info *sbi = EXT4_SB(sb);
3713 ext4_fsblk_t n_blocks_count = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003714 unsigned long old_sb_flags;
Mingming Cao617ba132006-10-11 01:20:53 -07003715 struct ext4_mount_options old_opts;
Christoph Hellwigc79d9672010-05-19 07:16:40 -04003716 int enable_quota = 0;
Theodore Ts'o8a266462008-07-26 14:34:21 -04003717 ext4_group_t g;
Theodore Ts'ob3881f72009-01-05 22:46:26 -05003718 unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003719 int err;
3720#ifdef CONFIG_QUOTA
3721 int i;
3722#endif
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04003723 char *orig_data = kstrdup(data, GFP_KERNEL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003724
Alessio Igor Bogani337eb002009-05-12 15:10:54 +02003725 lock_kernel();
3726
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003727 /* Store the original options */
Al Virobbd68512009-05-06 10:43:07 -04003728 lock_super(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003729 old_sb_flags = sb->s_flags;
3730 old_opts.s_mount_opt = sbi->s_mount_opt;
3731 old_opts.s_resuid = sbi->s_resuid;
3732 old_opts.s_resgid = sbi->s_resgid;
3733 old_opts.s_commit_interval = sbi->s_commit_interval;
Theodore Ts'o30773842009-01-03 20:27:38 -05003734 old_opts.s_min_batch_time = sbi->s_min_batch_time;
3735 old_opts.s_max_batch_time = sbi->s_max_batch_time;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003736#ifdef CONFIG_QUOTA
3737 old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
3738 for (i = 0; i < MAXQUOTAS; i++)
3739 old_opts.s_qf_names[i] = sbi->s_qf_names[i];
3740#endif
Theodore Ts'ob3881f72009-01-05 22:46:26 -05003741 if (sbi->s_journal && sbi->s_journal->j_task->io_context)
3742 journal_ioprio = sbi->s_journal->j_task->io_context->ioprio;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003743
3744 /*
3745 * Allow the "check" option to be passed as a remount option.
3746 */
Theodore Ts'ob3881f72009-01-05 22:46:26 -05003747 if (!parse_options(data, sb, NULL, &journal_ioprio,
3748 &n_blocks_count, 1)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003749 err = -EINVAL;
3750 goto restore_opts;
3751 }
3752
Theodore Ts'o4ab2f152009-06-13 10:09:36 -04003753 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED)
Theodore Ts'oc67d8592010-06-29 11:07:07 -04003754 ext4_abort(sb, "Abort forced by user");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003755
3756 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
Dmitry Monakhov482a7422010-02-24 11:35:32 -05003757 (test_opt(sb, POSIX_ACL) ? MS_POSIXACL : 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003758
3759 es = sbi->s_es;
3760
Theodore Ts'ob3881f72009-01-05 22:46:26 -05003761 if (sbi->s_journal) {
Frank Mayhar03901312009-01-07 00:06:22 -05003762 ext4_init_journal_params(sb, sbi->s_journal);
Theodore Ts'ob3881f72009-01-05 22:46:26 -05003763 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
3764 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003765
3766 if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07003767 n_blocks_count > ext4_blocks_count(es)) {
Theodore Ts'o4ab2f152009-06-13 10:09:36 -04003768 if (sbi->s_mount_flags & EXT4_MF_FS_ABORTED) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003769 err = -EROFS;
3770 goto restore_opts;
3771 }
3772
3773 if (*flags & MS_RDONLY) {
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04003774 err = dquot_suspend(sb, -1);
3775 if (err < 0)
Christoph Hellwigc79d9672010-05-19 07:16:40 -04003776 goto restore_opts;
Christoph Hellwigc79d9672010-05-19 07:16:40 -04003777
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003778 /*
3779 * First of all, the unconditional stuff we have to do
3780 * to disable replay of the journal when we next remount
3781 */
3782 sb->s_flags |= MS_RDONLY;
3783
3784 /*
3785 * OK, test if we are remounting a valid rw partition
3786 * readonly, and if so set the rdonly flag and then
3787 * mark the partition as valid again.
3788 */
Mingming Cao617ba132006-10-11 01:20:53 -07003789 if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
3790 (sbi->s_mount_state & EXT4_VALID_FS))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003791 es->s_state = cpu_to_le16(sbi->s_mount_state);
3792
Theodore Ts'oa63c9eb2009-05-01 01:59:42 -04003793 if (sbi->s_journal)
Frank Mayhar03901312009-01-07 00:06:22 -05003794 ext4_mark_recovery_complete(sb, es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003795 } else {
Eric Sandeena13fb1a2009-08-18 00:20:23 -04003796 /* Make sure we can mount this feature set readwrite */
3797 if (!ext4_feature_set_ok(sb, 0)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003798 err = -EROFS;
3799 goto restore_opts;
3800 }
Eric Sandeenead65962007-02-10 01:46:08 -08003801 /*
Theodore Ts'o8a266462008-07-26 14:34:21 -04003802 * Make sure the group descriptor checksums
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003803 * are sane. If they aren't, refuse to remount r/w.
Theodore Ts'o8a266462008-07-26 14:34:21 -04003804 */
3805 for (g = 0; g < sbi->s_groups_count; g++) {
3806 struct ext4_group_desc *gdp =
3807 ext4_get_group_desc(sb, g, NULL);
3808
3809 if (!ext4_group_desc_csum_verify(sbi, g, gdp)) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003810 ext4_msg(sb, KERN_ERR,
3811 "ext4_remount: Checksum for group %u failed (%u!=%u)",
Theodore Ts'o8a266462008-07-26 14:34:21 -04003812 g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)),
3813 le16_to_cpu(gdp->bg_checksum));
3814 err = -EINVAL;
3815 goto restore_opts;
3816 }
3817 }
3818
3819 /*
Eric Sandeenead65962007-02-10 01:46:08 -08003820 * If we have an unprocessed orphan list hanging
3821 * around from a previously readonly bdev mount,
3822 * require a full umount/remount for now.
3823 */
3824 if (es->s_last_orphan) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04003825 ext4_msg(sb, KERN_WARNING, "Couldn't "
Eric Sandeenead65962007-02-10 01:46:08 -08003826 "remount RDWR because of unprocessed "
3827 "orphan inode list. Please "
Eric Sandeenb31e1552009-06-04 17:36:36 -04003828 "umount/remount instead");
Eric Sandeenead65962007-02-10 01:46:08 -08003829 err = -EINVAL;
3830 goto restore_opts;
3831 }
3832
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003833 /*
3834 * Mounting a RDONLY partition read-write, so reread
3835 * and store the current valid flag. (It may have
3836 * been changed by e2fsck since we originally mounted
3837 * the partition.)
3838 */
Frank Mayhar03901312009-01-07 00:06:22 -05003839 if (sbi->s_journal)
3840 ext4_clear_journal_err(sb, es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003841 sbi->s_mount_state = le16_to_cpu(es->s_state);
Mingming Cao617ba132006-10-11 01:20:53 -07003842 if ((err = ext4_group_extend(sb, es, n_blocks_count)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003843 goto restore_opts;
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003844 if (!ext4_setup_super(sb, es, 0))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003845 sb->s_flags &= ~MS_RDONLY;
Christoph Hellwigc79d9672010-05-19 07:16:40 -04003846 enable_quota = 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003847 }
3848 }
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04003849 ext4_setup_system_zone(sb);
Frank Mayhar03901312009-01-07 00:06:22 -05003850 if (sbi->s_journal == NULL)
Theodore Ts'oe2d67052009-05-01 00:33:44 -04003851 ext4_commit_super(sb, 1);
Frank Mayhar03901312009-01-07 00:06:22 -05003852
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003853#ifdef CONFIG_QUOTA
3854 /* Release old quota file names */
3855 for (i = 0; i < MAXQUOTAS; i++)
3856 if (old_opts.s_qf_names[i] &&
3857 old_opts.s_qf_names[i] != sbi->s_qf_names[i])
3858 kfree(old_opts.s_qf_names[i]);
3859#endif
Al Virobbd68512009-05-06 10:43:07 -04003860 unlock_super(sb);
Alessio Igor Bogani337eb002009-05-12 15:10:54 +02003861 unlock_kernel();
Christoph Hellwigc79d9672010-05-19 07:16:40 -04003862 if (enable_quota)
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04003863 dquot_resume(sb, -1);
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04003864
3865 ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);
3866 kfree(orig_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003867 return 0;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003868
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003869restore_opts:
3870 sb->s_flags = old_sb_flags;
3871 sbi->s_mount_opt = old_opts.s_mount_opt;
3872 sbi->s_resuid = old_opts.s_resuid;
3873 sbi->s_resgid = old_opts.s_resgid;
3874 sbi->s_commit_interval = old_opts.s_commit_interval;
Theodore Ts'o30773842009-01-03 20:27:38 -05003875 sbi->s_min_batch_time = old_opts.s_min_batch_time;
3876 sbi->s_max_batch_time = old_opts.s_max_batch_time;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003877#ifdef CONFIG_QUOTA
3878 sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
3879 for (i = 0; i < MAXQUOTAS; i++) {
3880 if (sbi->s_qf_names[i] &&
3881 old_opts.s_qf_names[i] != sbi->s_qf_names[i])
3882 kfree(sbi->s_qf_names[i]);
3883 sbi->s_qf_names[i] = old_opts.s_qf_names[i];
3884 }
3885#endif
Al Virobbd68512009-05-06 10:43:07 -04003886 unlock_super(sb);
Alessio Igor Bogani337eb002009-05-12 15:10:54 +02003887 unlock_kernel();
Curt Wohlgemuthd4c402d2010-05-16 12:00:00 -04003888 kfree(orig_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003889 return err;
3890}
3891
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003892static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003893{
3894 struct super_block *sb = dentry->d_sb;
Mingming Cao617ba132006-10-11 01:20:53 -07003895 struct ext4_sb_info *sbi = EXT4_SB(sb);
3896 struct ext4_super_block *es = sbi->s_es;
Pekka Enberg960cc392006-12-06 20:35:29 -08003897 u64 fsid;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003898
Badari Pulavarty5e700302007-07-15 23:42:00 -07003899 if (test_opt(sb, MINIX_DF)) {
3900 sbi->s_overhead_last = 0;
Aneesh Kumar K.V6bc9fef2007-10-16 18:38:25 -04003901 } else if (sbi->s_blocks_last != ext4_blocks_count(es)) {
Theodore Ts'o8df96752009-05-01 08:50:38 -04003902 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
Badari Pulavarty5e700302007-07-15 23:42:00 -07003903 ext4_fsblk_t overhead = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003904
3905 /*
Badari Pulavarty5e700302007-07-15 23:42:00 -07003906 * Compute the overhead (FS structures). This is constant
3907 * for a given filesystem unless the number of block groups
3908 * changes so we cache the previous value until it does.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003909 */
3910
3911 /*
3912 * All of the blocks before first_data_block are
3913 * overhead
3914 */
3915 overhead = le32_to_cpu(es->s_first_data_block);
3916
3917 /*
3918 * Add the overhead attributed to the superblock and
3919 * block group descriptors. If the sparse superblocks
3920 * feature is turned on, then not all groups have this.
3921 */
3922 for (i = 0; i < ngroups; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -07003923 overhead += ext4_bg_has_super(sb, i) +
3924 ext4_bg_num_gdb(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003925 cond_resched();
3926 }
3927
3928 /*
3929 * Every block group has an inode bitmap, a block
3930 * bitmap, and an inode table.
3931 */
Badari Pulavarty5e700302007-07-15 23:42:00 -07003932 overhead += ngroups * (2 + sbi->s_itb_per_group);
3933 sbi->s_overhead_last = overhead;
3934 smp_wmb();
Aneesh Kumar K.V6bc9fef2007-10-16 18:38:25 -04003935 sbi->s_blocks_last = ext4_blocks_count(es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003936 }
3937
Mingming Cao617ba132006-10-11 01:20:53 -07003938 buf->f_type = EXT4_SUPER_MAGIC;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003939 buf->f_bsize = sb->s_blocksize;
Badari Pulavarty5e700302007-07-15 23:42:00 -07003940 buf->f_blocks = ext4_blocks_count(es) - sbi->s_overhead_last;
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -04003941 buf->f_bfree = percpu_counter_sum_positive(&sbi->s_freeblocks_counter) -
3942 percpu_counter_sum_positive(&sbi->s_dirtyblocks_counter);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07003943 buf->f_bavail = buf->f_bfree - ext4_r_blocks_count(es);
3944 if (buf->f_bfree < ext4_r_blocks_count(es))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003945 buf->f_bavail = 0;
3946 buf->f_files = le32_to_cpu(es->s_inodes_count);
Peter Zijlstra52d9f3b2007-10-16 23:25:44 -07003947 buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
Mingming Cao617ba132006-10-11 01:20:53 -07003948 buf->f_namelen = EXT4_NAME_LEN;
Pekka Enberg960cc392006-12-06 20:35:29 -08003949 fsid = le64_to_cpup((void *)es->s_uuid) ^
3950 le64_to_cpup((void *)es->s_uuid + sizeof(u64));
3951 buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
3952 buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003953
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003954 return 0;
3955}
3956
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003957/* Helper function for writing quotas on sync - we need to start transaction
3958 * before quota file is locked for write. Otherwise the are possible deadlocks:
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003959 * Process 1 Process 2
Mingming Cao617ba132006-10-11 01:20:53 -07003960 * ext4_create() quota_sync()
Jan Karaa269eb12009-01-26 17:04:39 +01003961 * jbd2_journal_start() write_dquot()
Christoph Hellwig871a2932010-03-03 09:05:07 -05003962 * dquot_initialize() down(dqio_mutex)
Mingming Caodab291a2006-10-11 01:21:01 -07003963 * down(dqio_mutex) jbd2_journal_start()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003964 *
3965 */
3966
3967#ifdef CONFIG_QUOTA
3968
3969static inline struct inode *dquot_to_inode(struct dquot *dquot)
3970{
3971 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
3972}
3973
Mingming Cao617ba132006-10-11 01:20:53 -07003974static int ext4_write_dquot(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003975{
3976 int ret, err;
3977 handle_t *handle;
3978 struct inode *inode;
3979
3980 inode = dquot_to_inode(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003981 handle = ext4_journal_start(inode,
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003982 EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003983 if (IS_ERR(handle))
3984 return PTR_ERR(handle);
3985 ret = dquot_commit(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003986 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003987 if (!ret)
3988 ret = err;
3989 return ret;
3990}
3991
Mingming Cao617ba132006-10-11 01:20:53 -07003992static int ext4_acquire_dquot(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003993{
3994 int ret, err;
3995 handle_t *handle;
3996
Mingming Cao617ba132006-10-11 01:20:53 -07003997 handle = ext4_journal_start(dquot_to_inode(dquot),
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04003998 EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003999 if (IS_ERR(handle))
4000 return PTR_ERR(handle);
4001 ret = dquot_acquire(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07004002 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004003 if (!ret)
4004 ret = err;
4005 return ret;
4006}
4007
Mingming Cao617ba132006-10-11 01:20:53 -07004008static int ext4_release_dquot(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004009{
4010 int ret, err;
4011 handle_t *handle;
4012
Mingming Cao617ba132006-10-11 01:20:53 -07004013 handle = ext4_journal_start(dquot_to_inode(dquot),
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04004014 EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
Jan Kara9c3013e2007-09-11 15:23:29 -07004015 if (IS_ERR(handle)) {
4016 /* Release dquot anyway to avoid endless cycle in dqput() */
4017 dquot_release(dquot);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004018 return PTR_ERR(handle);
Jan Kara9c3013e2007-09-11 15:23:29 -07004019 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004020 ret = dquot_release(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07004021 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004022 if (!ret)
4023 ret = err;
4024 return ret;
4025}
4026
Mingming Cao617ba132006-10-11 01:20:53 -07004027static int ext4_mark_dquot_dirty(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004028{
Jan Kara2c8be6b2008-05-13 21:27:55 -04004029 /* Are we journaling quotas? */
Mingming Cao617ba132006-10-11 01:20:53 -07004030 if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
4031 EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004032 dquot_mark_dquot_dirty(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07004033 return ext4_write_dquot(dquot);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004034 } else {
4035 return dquot_mark_dquot_dirty(dquot);
4036 }
4037}
4038
Mingming Cao617ba132006-10-11 01:20:53 -07004039static int ext4_write_info(struct super_block *sb, int type)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004040{
4041 int ret, err;
4042 handle_t *handle;
4043
4044 /* Data block + inode block */
Mingming Cao617ba132006-10-11 01:20:53 -07004045 handle = ext4_journal_start(sb->s_root->d_inode, 2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004046 if (IS_ERR(handle))
4047 return PTR_ERR(handle);
4048 ret = dquot_commit_info(sb, type);
Mingming Cao617ba132006-10-11 01:20:53 -07004049 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004050 if (!ret)
4051 ret = err;
4052 return ret;
4053}
4054
4055/*
4056 * Turn on quotas during mount time - we need to find
4057 * the quota file and such...
4058 */
Mingming Cao617ba132006-10-11 01:20:53 -07004059static int ext4_quota_on_mount(struct super_block *sb, int type)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004060{
Christoph Hellwig287a8092010-05-19 07:16:45 -04004061 return dquot_quota_on_mount(sb, EXT4_SB(sb)->s_qf_names[type],
4062 EXT4_SB(sb)->s_jquota_fmt, type);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004063}
4064
4065/*
4066 * Standard function to be called on quota_on
4067 */
Mingming Cao617ba132006-10-11 01:20:53 -07004068static int ext4_quota_on(struct super_block *sb, int type, int format_id,
Christoph Hellwig307ae182010-05-19 07:16:43 -04004069 char *name)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004070{
4071 int err;
Al Viro82646132008-08-02 00:57:06 -04004072 struct path path;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004073
4074 if (!test_opt(sb, QUOTA))
4075 return -EINVAL;
Jan Kara06235432008-05-13 19:11:51 -04004076
Al Viro82646132008-08-02 00:57:06 -04004077 err = kern_path(name, LOOKUP_FOLLOW, &path);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004078 if (err)
4079 return err;
Jan Kara06235432008-05-13 19:11:51 -04004080
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004081 /* Quotafile not on the same filesystem? */
Al Viro82646132008-08-02 00:57:06 -04004082 if (path.mnt->mnt_sb != sb) {
4083 path_put(&path);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004084 return -EXDEV;
4085 }
Jan Kara06235432008-05-13 19:11:51 -04004086 /* Journaling quota? */
4087 if (EXT4_SB(sb)->s_qf_names[type]) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04004088 /* Quotafile not in fs root? */
Al Viro82646132008-08-02 00:57:06 -04004089 if (path.dentry->d_parent != sb->s_root)
Eric Sandeenb31e1552009-06-04 17:36:36 -04004090 ext4_msg(sb, KERN_WARNING,
4091 "Quota file not on filesystem root. "
4092 "Journaled quota will not work");
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04004093 }
Jan Kara06235432008-05-13 19:11:51 -04004094
4095 /*
4096 * When we journal data on quota file, we have to flush journal to see
4097 * all updates to the file when we bypass pagecache...
4098 */
Frank Mayhar03901312009-01-07 00:06:22 -05004099 if (EXT4_SB(sb)->s_journal &&
4100 ext4_should_journal_data(path.dentry->d_inode)) {
Jan Kara06235432008-05-13 19:11:51 -04004101 /*
4102 * We don't need to lock updates but journal_flush() could
4103 * otherwise be livelocked...
4104 */
4105 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04004106 err = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
Jan Kara06235432008-05-13 19:11:51 -04004107 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04004108 if (err) {
Al Viro82646132008-08-02 00:57:06 -04004109 path_put(&path);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04004110 return err;
4111 }
Jan Kara06235432008-05-13 19:11:51 -04004112 }
4113
Christoph Hellwig287a8092010-05-19 07:16:45 -04004114 err = dquot_quota_on_path(sb, type, format_id, &path);
Al Viro82646132008-08-02 00:57:06 -04004115 path_put(&path);
Al Viro77e69da2008-08-01 04:29:18 -04004116 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004117}
4118
Dmitry Monakhovca0e05e2010-08-01 17:48:36 -04004119static int ext4_quota_off(struct super_block *sb, int type)
4120{
4121 /* Force all delayed allocation blocks to be allocated */
4122 if (test_opt(sb, DELALLOC)) {
4123 down_read(&sb->s_umount);
4124 sync_filesystem(sb);
4125 up_read(&sb->s_umount);
4126 }
4127
4128 return dquot_quota_off(sb, type);
4129}
4130
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004131/* Read data from quotafile - avoid pagecache and such because we cannot afford
4132 * acquiring the locks... As quota files are never truncated and quota code
4133 * itself serializes the operations (and noone else should touch the files)
4134 * we don't have to be afraid of races */
Mingming Cao617ba132006-10-11 01:20:53 -07004135static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004136 size_t len, loff_t off)
4137{
4138 struct inode *inode = sb_dqopt(sb)->files[type];
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05004139 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004140 int err = 0;
4141 int offset = off & (sb->s_blocksize - 1);
4142 int tocopy;
4143 size_t toread;
4144 struct buffer_head *bh;
4145 loff_t i_size = i_size_read(inode);
4146
4147 if (off > i_size)
4148 return 0;
4149 if (off+len > i_size)
4150 len = i_size-off;
4151 toread = len;
4152 while (toread > 0) {
4153 tocopy = sb->s_blocksize - offset < toread ?
4154 sb->s_blocksize - offset : toread;
Mingming Cao617ba132006-10-11 01:20:53 -07004155 bh = ext4_bread(NULL, inode, blk, 0, &err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004156 if (err)
4157 return err;
4158 if (!bh) /* A hole? */
4159 memset(data, 0, tocopy);
4160 else
4161 memcpy(data, bh->b_data+offset, tocopy);
4162 brelse(bh);
4163 offset = 0;
4164 toread -= tocopy;
4165 data += tocopy;
4166 blk++;
4167 }
4168 return len;
4169}
4170
4171/* Write to quotafile (we know the transaction is already started and has
4172 * enough credits) */
Mingming Cao617ba132006-10-11 01:20:53 -07004173static ssize_t ext4_quota_write(struct super_block *sb, int type,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004174 const char *data, size_t len, loff_t off)
4175{
4176 struct inode *inode = sb_dqopt(sb)->files[type];
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05004177 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004178 int err = 0;
4179 int offset = off & (sb->s_blocksize - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004180 struct buffer_head *bh;
4181 handle_t *handle = journal_current_handle();
4182
Frank Mayhar03901312009-01-07 00:06:22 -05004183 if (EXT4_SB(sb)->s_journal && !handle) {
Eric Sandeenb31e1552009-06-04 17:36:36 -04004184 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
4185 " cancelled because transaction is not started",
Jan Kara9c3013e2007-09-11 15:23:29 -07004186 (unsigned long long)off, (unsigned long long)len);
4187 return -EIO;
4188 }
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004189 /*
4190 * Since we account only one data block in transaction credits,
4191 * then it is impossible to cross a block boundary.
4192 */
4193 if (sb->s_blocksize - offset < len) {
4194 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
4195 " cancelled because not block aligned",
4196 (unsigned long long)off, (unsigned long long)len);
4197 return -EIO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004198 }
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004199
4200 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
4201 bh = ext4_bread(handle, inode, blk, 1, &err);
4202 if (!bh)
4203 goto out;
Jan Kara62d2b5f2010-07-27 11:56:07 -04004204 err = ext4_journal_get_write_access(handle, bh);
4205 if (err) {
4206 brelse(bh);
4207 goto out;
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004208 }
4209 lock_buffer(bh);
4210 memcpy(bh->b_data+offset, data, len);
4211 flush_dcache_page(bh->b_page);
4212 unlock_buffer(bh);
Jan Kara62d2b5f2010-07-27 11:56:07 -04004213 err = ext4_handle_dirty_metadata(handle, NULL, bh);
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004214 brelse(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004215out:
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004216 if (err) {
Jan Kara4d04e4f2008-07-04 09:59:34 -07004217 mutex_unlock(&inode->i_mutex);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004218 return err;
Jan Kara4d04e4f2008-07-04 09:59:34 -07004219 }
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004220 if (inode->i_size < off + len) {
4221 i_size_write(inode, off + len);
Mingming Cao617ba132006-10-11 01:20:53 -07004222 EXT4_I(inode)->i_disksize = inode->i_size;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004223 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004224 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Mingming Cao617ba132006-10-11 01:20:53 -07004225 ext4_mark_inode_dirty(handle, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004226 mutex_unlock(&inode->i_mutex);
Dmitry Monakhov67eeb562010-03-02 08:08:51 -05004227 return len;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004228}
4229
4230#endif
4231
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04004232static int ext4_get_sb(struct file_system_type *fs_type, int flags,
4233 const char *dev_name, void *data, struct vfsmount *mnt)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004234{
Andreas Dilger0b8e58a2009-06-03 17:59:28 -04004235 return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super,mnt);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004236}
4237
Theodore Ts'o37f328e2010-03-24 20:06:41 -04004238#if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT23)
Theodore Ts'o24b58422009-12-07 14:08:51 -05004239static struct file_system_type ext2_fs_type = {
4240 .owner = THIS_MODULE,
4241 .name = "ext2",
4242 .get_sb = ext4_get_sb,
4243 .kill_sb = kill_block_super,
4244 .fs_flags = FS_REQUIRES_DEV,
4245};
4246
4247static inline void register_as_ext2(void)
4248{
4249 int err = register_filesystem(&ext2_fs_type);
4250 if (err)
4251 printk(KERN_WARNING
4252 "EXT4-fs: Unable to register as ext2 (%d)\n", err);
4253}
4254
4255static inline void unregister_as_ext2(void)
4256{
4257 unregister_filesystem(&ext2_fs_type);
4258}
Theodore Ts'o51b7e3c2009-12-21 10:56:09 -05004259MODULE_ALIAS("ext2");
Theodore Ts'o24b58422009-12-07 14:08:51 -05004260#else
4261static inline void register_as_ext2(void) { }
4262static inline void unregister_as_ext2(void) { }
4263#endif
4264
Theodore Ts'o37f328e2010-03-24 20:06:41 -04004265#if !defined(CONFIG_EXT3_FS) && !defined(CONFIG_EXT3_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT23)
Theodore Ts'o24b58422009-12-07 14:08:51 -05004266static inline void register_as_ext3(void)
4267{
4268 int err = register_filesystem(&ext3_fs_type);
4269 if (err)
4270 printk(KERN_WARNING
4271 "EXT4-fs: Unable to register as ext3 (%d)\n", err);
4272}
4273
4274static inline void unregister_as_ext3(void)
4275{
4276 unregister_filesystem(&ext3_fs_type);
4277}
Theodore Ts'o51b7e3c2009-12-21 10:56:09 -05004278MODULE_ALIAS("ext3");
Theodore Ts'o24b58422009-12-07 14:08:51 -05004279#else
4280static inline void register_as_ext3(void) { }
4281static inline void unregister_as_ext3(void) { }
4282#endif
4283
Theodore Ts'o03010a32008-10-10 20:02:48 -04004284static struct file_system_type ext4_fs_type = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004285 .owner = THIS_MODULE,
Theodore Ts'o03010a32008-10-10 20:02:48 -04004286 .name = "ext4",
Mingming Cao617ba132006-10-11 01:20:53 -07004287 .get_sb = ext4_get_sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004288 .kill_sb = kill_block_super,
4289 .fs_flags = FS_REQUIRES_DEV,
4290};
4291
Mingming Cao617ba132006-10-11 01:20:53 -07004292static int __init init_ext4_fs(void)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004293{
Alex Tomasc9de5602008-01-29 00:19:52 -05004294 int err;
4295
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04004296 ext4_check_flag_values();
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04004297 err = init_ext4_system_zone();
4298 if (err)
4299 return err;
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04004300 ext4_kset = kset_create_and_add("ext4", NULL, fs_kobj);
4301 if (!ext4_kset)
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04004302 goto out4;
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04004303 ext4_proc_root = proc_mkdir("fs/ext4", NULL);
Alex Tomasc9de5602008-01-29 00:19:52 -05004304 err = init_ext4_mballoc();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004305 if (err)
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04004306 goto out3;
Alex Tomasc9de5602008-01-29 00:19:52 -05004307
4308 err = init_ext4_xattr();
4309 if (err)
4310 goto out2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004311 err = init_inodecache();
4312 if (err)
4313 goto out1;
Theodore Ts'o24b58422009-12-07 14:08:51 -05004314 register_as_ext2();
4315 register_as_ext3();
Theodore Ts'o03010a32008-10-10 20:02:48 -04004316 err = register_filesystem(&ext4_fs_type);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004317 if (err)
4318 goto out;
4319 return 0;
4320out:
Theodore Ts'o24b58422009-12-07 14:08:51 -05004321 unregister_as_ext2();
4322 unregister_as_ext3();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004323 destroy_inodecache();
4324out1:
Mingming Cao617ba132006-10-11 01:20:53 -07004325 exit_ext4_xattr();
Alex Tomasc9de5602008-01-29 00:19:52 -05004326out2:
4327 exit_ext4_mballoc();
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04004328out3:
4329 remove_proc_entry("fs/ext4", NULL);
4330 kset_unregister(ext4_kset);
4331out4:
4332 exit_ext4_system_zone();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004333 return err;
4334}
4335
Mingming Cao617ba132006-10-11 01:20:53 -07004336static void __exit exit_ext4_fs(void)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004337{
Theodore Ts'o24b58422009-12-07 14:08:51 -05004338 unregister_as_ext2();
4339 unregister_as_ext3();
Theodore Ts'o03010a32008-10-10 20:02:48 -04004340 unregister_filesystem(&ext4_fs_type);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004341 destroy_inodecache();
Mingming Cao617ba132006-10-11 01:20:53 -07004342 exit_ext4_xattr();
Alex Tomasc9de5602008-01-29 00:19:52 -05004343 exit_ext4_mballoc();
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04004344 remove_proc_entry("fs/ext4", NULL);
Theodore Ts'o3197ebd2009-03-31 09:10:09 -04004345 kset_unregister(ext4_kset);
Theodore Ts'o6fd058f2009-05-17 15:38:01 -04004346 exit_ext4_system_zone();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004347}
4348
4349MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
Theodore Ts'o83982b62009-01-06 14:53:16 -05004350MODULE_DESCRIPTION("Fourth Extended Filesystem");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004351MODULE_LICENSE("GPL");
Mingming Cao617ba132006-10-11 01:20:53 -07004352module_init(init_ext4_fs)
4353module_exit(exit_ext4_fs)