blob: bdddea14e782f041381837d1488506fd951cbc99 [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>
Mingming Caodab291a2006-10-11 01:21:01 -070023#include <linux/jbd2.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070024#include <linux/slab.h>
25#include <linux/init.h>
26#include <linux/blkdev.h>
27#include <linux/parser.h>
28#include <linux/smp_lock.h>
29#include <linux/buffer_head.h>
Christoph Hellwiga5694252007-07-17 04:04:28 -070030#include <linux/exportfs.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070031#include <linux/vfs.h>
32#include <linux/random.h>
33#include <linux/mount.h>
34#include <linux/namei.h>
35#include <linux/quotaops.h>
36#include <linux/seq_file.h>
Theodore Ts'o9f6200b2008-09-23 09:18:24 -040037#include <linux/proc_fs.h>
Theodore Ts'oede86cc2008-10-05 20:50:06 -040038#include <linux/marker.h>
Vignesh Babu13305932007-07-18 09:11:02 -040039#include <linux/log2.h>
Andreas Dilger717d50e2007-10-16 18:38:25 -040040#include <linux/crc16.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070041#include <asm/uaccess.h>
42
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040043#include "ext4.h"
44#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070045#include "xattr.h"
46#include "acl.h"
47#include "namei.h"
Andreas Dilger717d50e2007-10-16 18:38:25 -040048#include "group.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070049
Theodore Ts'o9f6200b2008-09-23 09:18:24 -040050struct proc_dir_entry *ext4_proc_root;
51
Mingming Cao617ba132006-10-11 01:20:53 -070052static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070053 unsigned long journal_devnum);
Mingming Cao617ba132006-10-11 01:20:53 -070054static int ext4_create_journal(struct super_block *, struct ext4_super_block *,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070055 unsigned int);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040056static void ext4_commit_super(struct super_block *sb,
57 struct ext4_super_block *es, int sync);
58static void ext4_mark_recovery_complete(struct super_block *sb,
59 struct ext4_super_block *es);
60static void ext4_clear_journal_err(struct super_block *sb,
61 struct ext4_super_block *es);
Mingming Cao617ba132006-10-11 01:20:53 -070062static int ext4_sync_fs(struct super_block *sb, int wait);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040063static const char *ext4_decode_error(struct super_block *sb, int errno,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070064 char nbuf[16]);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040065static int ext4_remount(struct super_block *sb, int *flags, char *data);
66static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
Mingming Cao617ba132006-10-11 01:20:53 -070067static void ext4_unlockfs(struct super_block *sb);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -040068static void ext4_write_super(struct super_block *sb);
Mingming Cao617ba132006-10-11 01:20:53 -070069static void ext4_write_super_lockfs(struct super_block *sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -070070
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070071
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070072ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
73 struct ext4_group_desc *bg)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070074{
Aneesh Kumar K.V3a145892007-10-16 18:38:25 -040075 return le32_to_cpu(bg->bg_block_bitmap_lo) |
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070076 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Aneesh Kumar K.V3a145892007-10-16 18:38:25 -040077 (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070078}
79
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070080ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
81 struct ext4_group_desc *bg)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070082{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -040083 return le32_to_cpu(bg->bg_inode_bitmap_lo) |
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070084 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -040085 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070086}
87
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070088ext4_fsblk_t ext4_inode_table(struct super_block *sb,
89 struct ext4_group_desc *bg)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070090{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -040091 return le32_to_cpu(bg->bg_inode_table_lo) |
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070092 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -040093 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070094}
95
Alexandre Ratchov8fadc142006-10-11 01:21:15 -070096void ext4_block_bitmap_set(struct super_block *sb,
97 struct ext4_group_desc *bg, ext4_fsblk_t blk)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -070098{
Aneesh Kumar K.V3a145892007-10-16 18:38:25 -040099 bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700100 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
101 bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700102}
103
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700104void ext4_inode_bitmap_set(struct super_block *sb,
105 struct ext4_group_desc *bg, ext4_fsblk_t blk)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700106{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -0400107 bg->bg_inode_bitmap_lo = cpu_to_le32((u32)blk);
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700108 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
109 bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700110}
111
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700112void ext4_inode_table_set(struct super_block *sb,
113 struct ext4_group_desc *bg, ext4_fsblk_t blk)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700114{
Aneesh Kumar K.V5272f832007-10-16 18:38:25 -0400115 bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
Alexandre Ratchov8fadc142006-10-11 01:21:15 -0700116 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
117 bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -0700118}
119
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700120/*
Mingming Caodab291a2006-10-11 01:21:01 -0700121 * Wrappers for jbd2_journal_start/end.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700122 *
123 * The only special thing we need to do here is to make sure that all
124 * journal_end calls result in the superblock being marked dirty, so
125 * that sync() will call the filesystem's write_super callback if
126 * appropriate.
127 */
Mingming Cao617ba132006-10-11 01:20:53 -0700128handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700129{
130 journal_t *journal;
131
132 if (sb->s_flags & MS_RDONLY)
133 return ERR_PTR(-EROFS);
134
135 /* Special case here: if the journal has aborted behind our
136 * backs (eg. EIO in the commit thread), then we still need to
137 * take the FS itself readonly cleanly. */
Mingming Cao617ba132006-10-11 01:20:53 -0700138 journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700139 if (is_journal_aborted(journal)) {
Harvey Harrison46e665e2008-04-17 10:38:59 -0400140 ext4_abort(sb, __func__,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700141 "Detected aborted journal");
142 return ERR_PTR(-EROFS);
143 }
144
Mingming Caodab291a2006-10-11 01:21:01 -0700145 return jbd2_journal_start(journal, nblocks);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700146}
147
148/*
149 * The only special thing we need to do here is to make sure that all
Mingming Caodab291a2006-10-11 01:21:01 -0700150 * jbd2_journal_stop calls result in the superblock being marked dirty, so
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700151 * that sync() will call the filesystem's write_super callback if
152 * appropriate.
153 */
Mingming Cao617ba132006-10-11 01:20:53 -0700154int __ext4_journal_stop(const char *where, handle_t *handle)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700155{
156 struct super_block *sb;
157 int err;
158 int rc;
159
160 sb = handle->h_transaction->t_journal->j_private;
161 err = handle->h_err;
Mingming Caodab291a2006-10-11 01:21:01 -0700162 rc = jbd2_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700163
164 if (!err)
165 err = rc;
166 if (err)
Mingming Cao617ba132006-10-11 01:20:53 -0700167 __ext4_std_error(sb, where, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700168 return err;
169}
170
Mingming Cao617ba132006-10-11 01:20:53 -0700171void ext4_journal_abort_handle(const char *caller, const char *err_fn,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700172 struct buffer_head *bh, handle_t *handle, int err)
173{
174 char nbuf[16];
Mingming Cao617ba132006-10-11 01:20:53 -0700175 const char *errstr = ext4_decode_error(NULL, err, nbuf);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700176
177 if (bh)
178 BUFFER_TRACE(bh, "abort");
179
180 if (!handle->h_err)
181 handle->h_err = err;
182
183 if (is_handle_aborted(handle))
184 return;
185
186 printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
187 caller, errstr, err_fn);
188
Mingming Caodab291a2006-10-11 01:21:01 -0700189 jbd2_journal_abort_handle(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700190}
191
192/* Deal with the reporting of failure conditions on a filesystem such as
193 * inconsistencies detected or read IO failures.
194 *
195 * On ext2, we can store the error state of the filesystem in the
Mingming Cao617ba132006-10-11 01:20:53 -0700196 * superblock. That is not possible on ext4, because we may have other
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700197 * write ordering constraints on the superblock which prevent us from
198 * writing it out straight away; and given that the journal is about to
199 * be aborted, we can't rely on the current, or future, transactions to
200 * write out the superblock safely.
201 *
Mingming Caodab291a2006-10-11 01:21:01 -0700202 * We'll just use the jbd2_journal_abort() error code to record an error in
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700203 * the journal instead. On recovery, the journal will compain about
204 * that error until we've noted it down and cleared it.
205 */
206
Mingming Cao617ba132006-10-11 01:20:53 -0700207static void ext4_handle_error(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700208{
Mingming Cao617ba132006-10-11 01:20:53 -0700209 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700210
Mingming Cao617ba132006-10-11 01:20:53 -0700211 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
212 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700213
214 if (sb->s_flags & MS_RDONLY)
215 return;
216
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400217 if (!test_opt(sb, ERRORS_CONT)) {
Mingming Cao617ba132006-10-11 01:20:53 -0700218 journal_t *journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700219
Mingming Cao617ba132006-10-11 01:20:53 -0700220 EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700221 if (journal)
Mingming Caodab291a2006-10-11 01:21:01 -0700222 jbd2_journal_abort(journal, -EIO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700223 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400224 if (test_opt(sb, ERRORS_RO)) {
225 printk(KERN_CRIT "Remounting filesystem read-only\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700226 sb->s_flags |= MS_RDONLY;
227 }
Mingming Cao617ba132006-10-11 01:20:53 -0700228 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700229 if (test_opt(sb, ERRORS_PANIC))
Mingming Cao617ba132006-10-11 01:20:53 -0700230 panic("EXT4-fs (device %s): panic forced after error\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700231 sb->s_id);
232}
233
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400234void ext4_error(struct super_block *sb, const char *function,
235 const char *fmt, ...)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700236{
237 va_list args;
238
239 va_start(args, fmt);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400240 printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700241 vprintk(fmt, args);
242 printk("\n");
243 va_end(args);
244
Mingming Cao617ba132006-10-11 01:20:53 -0700245 ext4_handle_error(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700246}
247
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400248static const char *ext4_decode_error(struct super_block *sb, int errno,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700249 char nbuf[16])
250{
251 char *errstr = NULL;
252
253 switch (errno) {
254 case -EIO:
255 errstr = "IO failure";
256 break;
257 case -ENOMEM:
258 errstr = "Out of memory";
259 break;
260 case -EROFS:
Mingming Caodab291a2006-10-11 01:21:01 -0700261 if (!sb || EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700262 errstr = "Journal has aborted";
263 else
264 errstr = "Readonly filesystem";
265 break;
266 default:
267 /* If the caller passed in an extra buffer for unknown
268 * errors, textualise them now. Else we just return
269 * NULL. */
270 if (nbuf) {
271 /* Check for truncated error codes... */
272 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
273 errstr = nbuf;
274 }
275 break;
276 }
277
278 return errstr;
279}
280
Mingming Cao617ba132006-10-11 01:20:53 -0700281/* __ext4_std_error decodes expected errors from journaling functions
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700282 * automatically and invokes the appropriate error response. */
283
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400284void __ext4_std_error(struct super_block *sb, const char *function, int errno)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700285{
286 char nbuf[16];
287 const char *errstr;
288
289 /* Special case: if the error is EROFS, and we're not already
290 * inside a transaction, then there's really no point in logging
291 * an error. */
292 if (errno == -EROFS && journal_current_handle() == NULL &&
293 (sb->s_flags & MS_RDONLY))
294 return;
295
Mingming Cao617ba132006-10-11 01:20:53 -0700296 errstr = ext4_decode_error(sb, errno, nbuf);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400297 printk(KERN_CRIT "EXT4-fs error (device %s) in %s: %s\n",
298 sb->s_id, function, errstr);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700299
Mingming Cao617ba132006-10-11 01:20:53 -0700300 ext4_handle_error(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700301}
302
303/*
Mingming Cao617ba132006-10-11 01:20:53 -0700304 * ext4_abort is a much stronger failure handler than ext4_error. The
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700305 * abort function may be used to deal with unrecoverable failures such
306 * as journal IO errors or ENOMEM at a critical moment in log management.
307 *
308 * We unconditionally force the filesystem into an ABORT|READONLY state,
309 * unless the error response on the fs has been set to panic in which
310 * case we take the easy way out and panic immediately.
311 */
312
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400313void ext4_abort(struct super_block *sb, const char *function,
314 const char *fmt, ...)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700315{
316 va_list args;
317
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400318 printk(KERN_CRIT "ext4_abort called.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700319
320 va_start(args, fmt);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400321 printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700322 vprintk(fmt, args);
323 printk("\n");
324 va_end(args);
325
326 if (test_opt(sb, ERRORS_PANIC))
Mingming Cao617ba132006-10-11 01:20:53 -0700327 panic("EXT4-fs panic from previous error\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700328
329 if (sb->s_flags & MS_RDONLY)
330 return;
331
332 printk(KERN_CRIT "Remounting filesystem read-only\n");
Mingming Cao617ba132006-10-11 01:20:53 -0700333 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700334 sb->s_flags |= MS_RDONLY;
Mingming Cao617ba132006-10-11 01:20:53 -0700335 EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
Mingming Caodab291a2006-10-11 01:21:01 -0700336 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700337}
338
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400339void ext4_warning(struct super_block *sb, const char *function,
340 const char *fmt, ...)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700341{
342 va_list args;
343
344 va_start(args, fmt);
Mingming Cao617ba132006-10-11 01:20:53 -0700345 printk(KERN_WARNING "EXT4-fs warning (device %s): %s: ",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700346 sb->s_id, function);
347 vprintk(fmt, args);
348 printk("\n");
349 va_end(args);
350}
351
Mingming Cao617ba132006-10-11 01:20:53 -0700352void ext4_update_dynamic_rev(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700353{
Mingming Cao617ba132006-10-11 01:20:53 -0700354 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700355
Mingming Cao617ba132006-10-11 01:20:53 -0700356 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700357 return;
358
Harvey Harrison46e665e2008-04-17 10:38:59 -0400359 ext4_warning(sb, __func__,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700360 "updating to rev %d because of new feature flag, "
361 "running e2fsck is recommended",
Mingming Cao617ba132006-10-11 01:20:53 -0700362 EXT4_DYNAMIC_REV);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700363
Mingming Cao617ba132006-10-11 01:20:53 -0700364 es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
365 es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
366 es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700367 /* leave es->s_feature_*compat flags alone */
368 /* es->s_uuid will be set by e2fsck if empty */
369
370 /*
371 * The rest of the superblock fields should be zero, and if not it
372 * means they are likely already in use, so leave them alone. We
373 * can leave it up to e2fsck to clean up any inconsistencies there.
374 */
375}
376
377/*
378 * Open the external journal device
379 */
Mingming Cao617ba132006-10-11 01:20:53 -0700380static struct block_device *ext4_blkdev_get(dev_t dev)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700381{
382 struct block_device *bdev;
383 char b[BDEVNAME_SIZE];
384
385 bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
386 if (IS_ERR(bdev))
387 goto fail;
388 return bdev;
389
390fail:
Mingming Cao617ba132006-10-11 01:20:53 -0700391 printk(KERN_ERR "EXT4: failed to open journal device %s: %ld\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700392 __bdevname(dev, b), PTR_ERR(bdev));
393 return NULL;
394}
395
396/*
397 * Release the journal device
398 */
Mingming Cao617ba132006-10-11 01:20:53 -0700399static int ext4_blkdev_put(struct block_device *bdev)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700400{
401 bd_release(bdev);
Al Viro9a1c3542008-02-22 20:40:24 -0500402 return blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700403}
404
Mingming Cao617ba132006-10-11 01:20:53 -0700405static int ext4_blkdev_remove(struct ext4_sb_info *sbi)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700406{
407 struct block_device *bdev;
408 int ret = -ENODEV;
409
410 bdev = sbi->journal_bdev;
411 if (bdev) {
Mingming Cao617ba132006-10-11 01:20:53 -0700412 ret = ext4_blkdev_put(bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700413 sbi->journal_bdev = NULL;
414 }
415 return ret;
416}
417
418static inline struct inode *orphan_list_entry(struct list_head *l)
419{
Mingming Cao617ba132006-10-11 01:20:53 -0700420 return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700421}
422
Mingming Cao617ba132006-10-11 01:20:53 -0700423static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700424{
425 struct list_head *l;
426
427 printk(KERN_ERR "sb orphan head is %d\n",
428 le32_to_cpu(sbi->s_es->s_last_orphan));
429
430 printk(KERN_ERR "sb_info orphan list:\n");
431 list_for_each(l, &sbi->s_orphan) {
432 struct inode *inode = orphan_list_entry(l);
433 printk(KERN_ERR " "
434 "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
435 inode->i_sb->s_id, inode->i_ino, inode,
436 inode->i_mode, inode->i_nlink,
437 NEXT_ORPHAN(inode));
438 }
439}
440
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400441static void ext4_put_super(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700442{
Mingming Cao617ba132006-10-11 01:20:53 -0700443 struct ext4_sb_info *sbi = EXT4_SB(sb);
444 struct ext4_super_block *es = sbi->s_es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700445 int i;
446
Alex Tomasc9de5602008-01-29 00:19:52 -0500447 ext4_mb_release(sb);
Alex Tomasa86c6182006-10-11 01:21:03 -0700448 ext4_ext_release(sb);
Mingming Cao617ba132006-10-11 01:20:53 -0700449 ext4_xattr_put_super(sb);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -0400450 if (jbd2_journal_destroy(sbi->s_journal) < 0)
451 ext4_abort(sb, __func__, "Couldn't clean up the journal");
Jan Kara47b4a502008-07-11 19:27:31 -0400452 sbi->s_journal = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700453 if (!(sb->s_flags & MS_RDONLY)) {
Mingming Cao617ba132006-10-11 01:20:53 -0700454 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700455 es->s_state = cpu_to_le16(sbi->s_mount_state);
Mingming Cao617ba132006-10-11 01:20:53 -0700456 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700457 }
Theodore Ts'o240799c2008-10-09 23:53:47 -0400458 if (sbi->s_proc) {
459 remove_proc_entry("inode_readahead_blks", sbi->s_proc);
Theodore Ts'o9f6200b2008-09-23 09:18:24 -0400460 remove_proc_entry(sb->s_id, ext4_proc_root);
Theodore Ts'o240799c2008-10-09 23:53:47 -0400461 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700462
463 for (i = 0; i < sbi->s_gdb_count; i++)
464 brelse(sbi->s_group_desc[i]);
465 kfree(sbi->s_group_desc);
Jose R. Santos772cb7c2008-07-11 19:27:31 -0400466 kfree(sbi->s_flex_groups);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700467 percpu_counter_destroy(&sbi->s_freeblocks_counter);
468 percpu_counter_destroy(&sbi->s_freeinodes_counter);
469 percpu_counter_destroy(&sbi->s_dirs_counter);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400470 percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700471 brelse(sbi->s_sbh);
472#ifdef CONFIG_QUOTA
473 for (i = 0; i < MAXQUOTAS; i++)
474 kfree(sbi->s_qf_names[i]);
475#endif
476
477 /* Debugging code just in case the in-memory inode orphan list
478 * isn't empty. The on-disk one can be non-empty if we've
479 * detected an error and taken the fs readonly, but the
480 * in-memory list had better be clean by this point. */
481 if (!list_empty(&sbi->s_orphan))
482 dump_orphan_list(sb, sbi);
483 J_ASSERT(list_empty(&sbi->s_orphan));
484
Peter Zijlstraf98393a2007-05-06 14:49:54 -0700485 invalidate_bdev(sb->s_bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700486 if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
487 /*
488 * Invalidate the journal device's buffers. We don't want them
489 * floating about in memory - the physical journal device may
490 * hotswapped, and it breaks the `ro-after' testing code.
491 */
492 sync_blockdev(sbi->journal_bdev);
Peter Zijlstraf98393a2007-05-06 14:49:54 -0700493 invalidate_bdev(sbi->journal_bdev);
Mingming Cao617ba132006-10-11 01:20:53 -0700494 ext4_blkdev_remove(sbi);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700495 }
496 sb->s_fs_info = NULL;
497 kfree(sbi);
498 return;
499}
500
Christoph Lametere18b8902006-12-06 20:33:20 -0800501static struct kmem_cache *ext4_inode_cachep;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700502
503/*
504 * Called inside transaction, so use GFP_NOFS
505 */
Mingming Cao617ba132006-10-11 01:20:53 -0700506static struct inode *ext4_alloc_inode(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700507{
Mingming Cao617ba132006-10-11 01:20:53 -0700508 struct ext4_inode_info *ei;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700509
Christoph Lametere6b4f8d2006-12-06 20:33:14 -0800510 ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700511 if (!ei)
512 return NULL;
Theodore Ts'o03010a32008-10-10 20:02:48 -0400513#ifdef CONFIG_EXT4_FS_POSIX_ACL
Mingming Cao617ba132006-10-11 01:20:53 -0700514 ei->i_acl = EXT4_ACL_NOT_CACHED;
515 ei->i_default_acl = EXT4_ACL_NOT_CACHED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700516#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700517 ei->vfs_inode.i_version = 1;
Aneesh Kumar K.V91246c02008-08-19 21:14:52 -0400518 ei->vfs_inode.i_data.writeback_index = 0;
Alex Tomasa86c6182006-10-11 01:21:03 -0700519 memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
Alex Tomasc9de5602008-01-29 00:19:52 -0500520 INIT_LIST_HEAD(&ei->i_prealloc_list);
521 spin_lock_init(&ei->i_prealloc_lock);
Jan Kara678aaf42008-07-11 19:27:31 -0400522 jbd2_journal_init_jbd_inode(&ei->jinode, &ei->vfs_inode);
Mingming Caod2a17632008-07-14 17:52:37 -0400523 ei->i_reserved_data_blocks = 0;
524 ei->i_reserved_meta_blocks = 0;
525 ei->i_allocated_meta_blocks = 0;
526 ei->i_delalloc_reserved_flag = 0;
527 spin_lock_init(&(ei->i_block_reservation_lock));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700528 return &ei->vfs_inode;
529}
530
Mingming Cao617ba132006-10-11 01:20:53 -0700531static void ext4_destroy_inode(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700532{
Vasily Averin9f7dd932007-07-15 23:40:45 -0700533 if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
534 printk("EXT4 Inode %p: orphan list check failed!\n",
535 EXT4_I(inode));
536 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
537 EXT4_I(inode), sizeof(struct ext4_inode_info),
538 true);
539 dump_stack();
540 }
Mingming Cao617ba132006-10-11 01:20:53 -0700541 kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700542}
543
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700544static void init_once(void *foo)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700545{
Mingming Cao617ba132006-10-11 01:20:53 -0700546 struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700547
Christoph Lametera35afb82007-05-16 22:10:57 -0700548 INIT_LIST_HEAD(&ei->i_orphan);
Theodore Ts'o03010a32008-10-10 20:02:48 -0400549#ifdef CONFIG_EXT4_FS_XATTR
Christoph Lametera35afb82007-05-16 22:10:57 -0700550 init_rwsem(&ei->xattr_sem);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700551#endif
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500552 init_rwsem(&ei->i_data_sem);
Christoph Lametera35afb82007-05-16 22:10:57 -0700553 inode_init_once(&ei->vfs_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700554}
555
556static int init_inodecache(void)
557{
Mingming Cao617ba132006-10-11 01:20:53 -0700558 ext4_inode_cachep = kmem_cache_create("ext4_inode_cache",
559 sizeof(struct ext4_inode_info),
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700560 0, (SLAB_RECLAIM_ACCOUNT|
561 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900562 init_once);
Mingming Cao617ba132006-10-11 01:20:53 -0700563 if (ext4_inode_cachep == NULL)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700564 return -ENOMEM;
565 return 0;
566}
567
568static void destroy_inodecache(void)
569{
Mingming Cao617ba132006-10-11 01:20:53 -0700570 kmem_cache_destroy(ext4_inode_cachep);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700571}
572
Mingming Cao617ba132006-10-11 01:20:53 -0700573static void ext4_clear_inode(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700574{
Theodore Ts'o03010a32008-10-10 20:02:48 -0400575#ifdef CONFIG_EXT4_FS_POSIX_ACL
Mingming Cao617ba132006-10-11 01:20:53 -0700576 if (EXT4_I(inode)->i_acl &&
577 EXT4_I(inode)->i_acl != EXT4_ACL_NOT_CACHED) {
578 posix_acl_release(EXT4_I(inode)->i_acl);
579 EXT4_I(inode)->i_acl = EXT4_ACL_NOT_CACHED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700580 }
Mingming Cao617ba132006-10-11 01:20:53 -0700581 if (EXT4_I(inode)->i_default_acl &&
582 EXT4_I(inode)->i_default_acl != EXT4_ACL_NOT_CACHED) {
583 posix_acl_release(EXT4_I(inode)->i_default_acl);
584 EXT4_I(inode)->i_default_acl = EXT4_ACL_NOT_CACHED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700585 }
586#endif
Theodore Ts'oc2ea3fd2008-10-10 09:40:52 -0400587 ext4_discard_preallocations(inode);
Jan Kara678aaf42008-07-11 19:27:31 -0400588 jbd2_journal_release_jbd_inode(EXT4_SB(inode->i_sb)->s_journal,
589 &EXT4_I(inode)->jinode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700590}
591
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400592static inline void ext4_show_quota_options(struct seq_file *seq,
593 struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700594{
595#if defined(CONFIG_QUOTA)
Mingming Cao617ba132006-10-11 01:20:53 -0700596 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700597
598 if (sbi->s_jquota_fmt)
599 seq_printf(seq, ",jqfmt=%s",
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400600 (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold" : "vfsv0");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700601
602 if (sbi->s_qf_names[USRQUOTA])
603 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
604
605 if (sbi->s_qf_names[GRPQUOTA])
606 seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
607
Mingming Cao617ba132006-10-11 01:20:53 -0700608 if (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700609 seq_puts(seq, ",usrquota");
610
Mingming Cao617ba132006-10-11 01:20:53 -0700611 if (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700612 seq_puts(seq, ",grpquota");
613#endif
614}
615
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700616/*
617 * Show an option if
618 * - it's set to a non-default value OR
619 * - if the per-sb default is different from the global default
620 */
Mingming Cao617ba132006-10-11 01:20:53 -0700621static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700622{
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500623 int def_errors;
624 unsigned long def_mount_opts;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700625 struct super_block *sb = vfs->mnt_sb;
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700626 struct ext4_sb_info *sbi = EXT4_SB(sb);
627 struct ext4_super_block *es = sbi->s_es;
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700628
629 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500630 def_errors = le16_to_cpu(es->s_errors);
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700631
632 if (sbi->s_sb_block != 1)
633 seq_printf(seq, ",sb=%llu", sbi->s_sb_block);
634 if (test_opt(sb, MINIX_DF))
635 seq_puts(seq, ",minixdf");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500636 if (test_opt(sb, GRPID) && !(def_mount_opts & EXT4_DEFM_BSDGROUPS))
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700637 seq_puts(seq, ",grpid");
638 if (!test_opt(sb, GRPID) && (def_mount_opts & EXT4_DEFM_BSDGROUPS))
639 seq_puts(seq, ",nogrpid");
640 if (sbi->s_resuid != EXT4_DEF_RESUID ||
641 le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID) {
642 seq_printf(seq, ",resuid=%u", sbi->s_resuid);
643 }
644 if (sbi->s_resgid != EXT4_DEF_RESGID ||
645 le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID) {
646 seq_printf(seq, ",resgid=%u", sbi->s_resgid);
647 }
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -0500648 if (test_opt(sb, ERRORS_RO)) {
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700649 if (def_errors == EXT4_ERRORS_PANIC ||
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -0500650 def_errors == EXT4_ERRORS_CONTINUE) {
651 seq_puts(seq, ",errors=remount-ro");
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700652 }
653 }
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500654 if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -0500655 seq_puts(seq, ",errors=continue");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500656 if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700657 seq_puts(seq, ",errors=panic");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500658 if (test_opt(sb, NO_UID32) && !(def_mount_opts & EXT4_DEFM_UID16))
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700659 seq_puts(seq, ",nouid32");
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500660 if (test_opt(sb, DEBUG) && !(def_mount_opts & EXT4_DEFM_DEBUG))
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700661 seq_puts(seq, ",debug");
662 if (test_opt(sb, OLDALLOC))
663 seq_puts(seq, ",oldalloc");
Theodore Ts'o03010a32008-10-10 20:02:48 -0400664#ifdef CONFIG_EXT4_FS_XATTR
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500665 if (test_opt(sb, XATTR_USER) &&
666 !(def_mount_opts & EXT4_DEFM_XATTR_USER))
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700667 seq_puts(seq, ",user_xattr");
668 if (!test_opt(sb, XATTR_USER) &&
669 (def_mount_opts & EXT4_DEFM_XATTR_USER)) {
670 seq_puts(seq, ",nouser_xattr");
671 }
672#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -0400673#ifdef CONFIG_EXT4_FS_POSIX_ACL
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500674 if (test_opt(sb, POSIX_ACL) && !(def_mount_opts & EXT4_DEFM_ACL))
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700675 seq_puts(seq, ",acl");
676 if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT4_DEFM_ACL))
677 seq_puts(seq, ",noacl");
678#endif
679 if (!test_opt(sb, RESERVATION))
680 seq_puts(seq, ",noreservation");
681 if (sbi->s_commit_interval) {
682 seq_printf(seq, ",commit=%u",
683 (unsigned) (sbi->s_commit_interval / HZ));
684 }
Eric Sandeen571640c2008-05-26 12:29:46 -0400685 /*
686 * We're changing the default of barrier mount option, so
687 * let's always display its mount state so it's clear what its
688 * status is.
689 */
690 seq_puts(seq, ",barrier=");
691 seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
Theodore Ts'ocd0b6a32008-05-26 10:28:28 -0400692 if (test_opt(sb, JOURNAL_ASYNC_COMMIT))
693 seq_puts(seq, ",journal_async_commit");
Miklos Szeredid9c9bef12007-10-16 23:26:27 -0700694 if (test_opt(sb, NOBH))
695 seq_puts(seq, ",nobh");
696 if (!test_opt(sb, EXTENTS))
697 seq_puts(seq, ",noextents");
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -0500698 if (test_opt(sb, I_VERSION))
699 seq_puts(seq, ",i_version");
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -0400700 if (!test_opt(sb, DELALLOC))
701 seq_puts(seq, ",nodelalloc");
702
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700703
Miklos Szeredicb45bbe2008-01-28 23:58:27 -0500704 if (sbi->s_stripe)
705 seq_printf(seq, ",stripe=%lu", sbi->s_stripe);
Aneesh Kumar K.Vaa22df22008-01-28 23:58:27 -0500706 /*
707 * journal mode get enabled in different ways
708 * So just print the value even if we didn't specify it
709 */
Mingming Cao617ba132006-10-11 01:20:53 -0700710 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700711 seq_puts(seq, ",data=journal");
Mingming Cao617ba132006-10-11 01:20:53 -0700712 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700713 seq_puts(seq, ",data=ordered");
Mingming Cao617ba132006-10-11 01:20:53 -0700714 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700715 seq_puts(seq, ",data=writeback");
716
Theodore Ts'o240799c2008-10-09 23:53:47 -0400717 if (sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
718 seq_printf(seq, ",inode_readahead_blks=%u",
719 sbi->s_inode_readahead_blks);
720
Hidehiro Kawai5bf56832008-10-10 22:12:43 -0400721 if (test_opt(sb, DATA_ERR_ABORT))
722 seq_puts(seq, ",data_err=abort");
723
Mingming Cao617ba132006-10-11 01:20:53 -0700724 ext4_show_quota_options(seq, sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700725 return 0;
726}
727
728
Christoph Hellwig1b961ac2007-10-21 16:42:08 -0700729static struct inode *ext4_nfs_get_inode(struct super_block *sb,
730 u64 ino, u32 generation)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700731{
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700732 struct inode *inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700733
Mingming Cao617ba132006-10-11 01:20:53 -0700734 if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700735 return ERR_PTR(-ESTALE);
Mingming Cao617ba132006-10-11 01:20:53 -0700736 if (ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700737 return ERR_PTR(-ESTALE);
738
739 /* iget isn't really right if the inode is currently unallocated!!
740 *
Mingming Cao617ba132006-10-11 01:20:53 -0700741 * ext4_read_inode will return a bad_inode if the inode had been
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700742 * deleted, so we should be safe.
743 *
744 * Currently we don't know the generation for parent directory, so
745 * a generation of 0 means "accept any"
746 */
David Howells1d1fe1e2008-02-07 00:15:37 -0800747 inode = ext4_iget(sb, ino);
748 if (IS_ERR(inode))
749 return ERR_CAST(inode);
750 if (generation && inode->i_generation != generation) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700751 iput(inode);
752 return ERR_PTR(-ESTALE);
753 }
Christoph Hellwig1b961ac2007-10-21 16:42:08 -0700754
755 return inode;
756}
757
758static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
759 int fh_len, int fh_type)
760{
761 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
762 ext4_nfs_get_inode);
763}
764
765static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
766 int fh_len, int fh_type)
767{
768 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
769 ext4_nfs_get_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700770}
771
772#ifdef CONFIG_QUOTA
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400773#define QTYPE2NAME(t) ((t) == USRQUOTA ? "user" : "group")
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400774#define QTYPE2MOPT(on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700775
Mingming Cao617ba132006-10-11 01:20:53 -0700776static int ext4_dquot_initialize(struct inode *inode, int type);
777static int ext4_dquot_drop(struct inode *inode);
778static int ext4_write_dquot(struct dquot *dquot);
779static int ext4_acquire_dquot(struct dquot *dquot);
780static int ext4_release_dquot(struct dquot *dquot);
781static int ext4_mark_dquot_dirty(struct dquot *dquot);
782static int ext4_write_info(struct super_block *sb, int type);
Jan Kara6f28e082008-04-28 02:14:34 -0700783static int ext4_quota_on(struct super_block *sb, int type, int format_id,
784 char *path, int remount);
Mingming Cao617ba132006-10-11 01:20:53 -0700785static int ext4_quota_on_mount(struct super_block *sb, int type);
786static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700787 size_t len, loff_t off);
Mingming Cao617ba132006-10-11 01:20:53 -0700788static ssize_t ext4_quota_write(struct super_block *sb, int type,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700789 const char *data, size_t len, loff_t off);
790
Mingming Cao617ba132006-10-11 01:20:53 -0700791static struct dquot_operations ext4_quota_operations = {
792 .initialize = ext4_dquot_initialize,
793 .drop = ext4_dquot_drop,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700794 .alloc_space = dquot_alloc_space,
795 .alloc_inode = dquot_alloc_inode,
796 .free_space = dquot_free_space,
797 .free_inode = dquot_free_inode,
798 .transfer = dquot_transfer,
Mingming Cao617ba132006-10-11 01:20:53 -0700799 .write_dquot = ext4_write_dquot,
800 .acquire_dquot = ext4_acquire_dquot,
801 .release_dquot = ext4_release_dquot,
802 .mark_dirty = ext4_mark_dquot_dirty,
803 .write_info = ext4_write_info
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700804};
805
Mingming Cao617ba132006-10-11 01:20:53 -0700806static struct quotactl_ops ext4_qctl_operations = {
807 .quota_on = ext4_quota_on,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700808 .quota_off = vfs_quota_off,
809 .quota_sync = vfs_quota_sync,
810 .get_info = vfs_get_dqinfo,
811 .set_info = vfs_set_dqinfo,
812 .get_dqblk = vfs_get_dqblk,
813 .set_dqblk = vfs_set_dqblk
814};
815#endif
816
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800817static const struct super_operations ext4_sops = {
Mingming Cao617ba132006-10-11 01:20:53 -0700818 .alloc_inode = ext4_alloc_inode,
819 .destroy_inode = ext4_destroy_inode,
Mingming Cao617ba132006-10-11 01:20:53 -0700820 .write_inode = ext4_write_inode,
821 .dirty_inode = ext4_dirty_inode,
822 .delete_inode = ext4_delete_inode,
823 .put_super = ext4_put_super,
824 .write_super = ext4_write_super,
825 .sync_fs = ext4_sync_fs,
826 .write_super_lockfs = ext4_write_super_lockfs,
827 .unlockfs = ext4_unlockfs,
828 .statfs = ext4_statfs,
829 .remount_fs = ext4_remount,
830 .clear_inode = ext4_clear_inode,
831 .show_options = ext4_show_options,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700832#ifdef CONFIG_QUOTA
Mingming Cao617ba132006-10-11 01:20:53 -0700833 .quota_read = ext4_quota_read,
834 .quota_write = ext4_quota_write,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700835#endif
836};
837
Christoph Hellwig39655162007-10-21 16:42:17 -0700838static const struct export_operations ext4_export_ops = {
Christoph Hellwig1b961ac2007-10-21 16:42:08 -0700839 .fh_to_dentry = ext4_fh_to_dentry,
840 .fh_to_parent = ext4_fh_to_parent,
Mingming Cao617ba132006-10-11 01:20:53 -0700841 .get_parent = ext4_get_parent,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700842};
843
844enum {
845 Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
846 Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
Theodore Ts'o01436ef2008-10-17 07:22:35 -0400847 Opt_nouid32, Opt_debug, Opt_oldalloc, Opt_orlov,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700848 Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
849 Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
850 Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
Girish Shilamkar818d2762008-01-28 23:58:27 -0500851 Opt_journal_checksum, Opt_journal_async_commit,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700852 Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
Hidehiro Kawai5bf56832008-10-10 22:12:43 -0400853 Opt_data_err_abort, Opt_data_err_ignore,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700854 Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
855 Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
856 Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -0500857 Opt_grpquota, Opt_extents, Opt_noextents, Opt_i_version,
Theodore Ts'o01436ef2008-10-17 07:22:35 -0400858 Opt_stripe, Opt_delalloc, Opt_nodelalloc,
Theodore Ts'o240799c2008-10-09 23:53:47 -0400859 Opt_inode_readahead_blks
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700860};
861
Steven Whitehousea447c092008-10-13 10:46:57 +0100862static const match_table_t tokens = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700863 {Opt_bsd_df, "bsddf"},
864 {Opt_minix_df, "minixdf"},
865 {Opt_grpid, "grpid"},
866 {Opt_grpid, "bsdgroups"},
867 {Opt_nogrpid, "nogrpid"},
868 {Opt_nogrpid, "sysvgroups"},
869 {Opt_resgid, "resgid=%u"},
870 {Opt_resuid, "resuid=%u"},
871 {Opt_sb, "sb=%u"},
872 {Opt_err_cont, "errors=continue"},
873 {Opt_err_panic, "errors=panic"},
874 {Opt_err_ro, "errors=remount-ro"},
875 {Opt_nouid32, "nouid32"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700876 {Opt_debug, "debug"},
877 {Opt_oldalloc, "oldalloc"},
878 {Opt_orlov, "orlov"},
879 {Opt_user_xattr, "user_xattr"},
880 {Opt_nouser_xattr, "nouser_xattr"},
881 {Opt_acl, "acl"},
882 {Opt_noacl, "noacl"},
883 {Opt_reservation, "reservation"},
884 {Opt_noreservation, "noreservation"},
885 {Opt_noload, "noload"},
886 {Opt_nobh, "nobh"},
887 {Opt_bh, "bh"},
888 {Opt_commit, "commit=%u"},
889 {Opt_journal_update, "journal=update"},
890 {Opt_journal_inum, "journal=%u"},
891 {Opt_journal_dev, "journal_dev=%u"},
Girish Shilamkar818d2762008-01-28 23:58:27 -0500892 {Opt_journal_checksum, "journal_checksum"},
893 {Opt_journal_async_commit, "journal_async_commit"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700894 {Opt_abort, "abort"},
895 {Opt_data_journal, "data=journal"},
896 {Opt_data_ordered, "data=ordered"},
897 {Opt_data_writeback, "data=writeback"},
Hidehiro Kawai5bf56832008-10-10 22:12:43 -0400898 {Opt_data_err_abort, "data_err=abort"},
899 {Opt_data_err_ignore, "data_err=ignore"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700900 {Opt_offusrjquota, "usrjquota="},
901 {Opt_usrjquota, "usrjquota=%s"},
902 {Opt_offgrpjquota, "grpjquota="},
903 {Opt_grpjquota, "grpjquota=%s"},
904 {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
905 {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
906 {Opt_grpquota, "grpquota"},
907 {Opt_noquota, "noquota"},
908 {Opt_quota, "quota"},
909 {Opt_usrquota, "usrquota"},
910 {Opt_barrier, "barrier=%u"},
Alex Tomasa86c6182006-10-11 01:21:03 -0700911 {Opt_extents, "extents"},
Mingming Cao1e2462f2007-07-18 09:00:55 -0400912 {Opt_noextents, "noextents"},
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -0500913 {Opt_i_version, "i_version"},
Alex Tomasc9de5602008-01-29 00:19:52 -0500914 {Opt_stripe, "stripe=%u"},
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700915 {Opt_resize, "resize"},
Alex Tomas64769242008-07-11 19:27:31 -0400916 {Opt_delalloc, "delalloc"},
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -0400917 {Opt_nodelalloc, "nodelalloc"},
Theodore Ts'o240799c2008-10-09 23:53:47 -0400918 {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
Josef Bacikf3f12fa2008-04-29 22:05:28 -0400919 {Opt_err, NULL},
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700920};
921
Mingming Cao617ba132006-10-11 01:20:53 -0700922static ext4_fsblk_t get_sb_block(void **data)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700923{
Mingming Cao617ba132006-10-11 01:20:53 -0700924 ext4_fsblk_t sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700925 char *options = (char *) *data;
926
927 if (!options || strncmp(options, "sb=", 3) != 0)
928 return 1; /* Default location */
929 options += 3;
Mingming Cao617ba132006-10-11 01:20:53 -0700930 /*todo: use simple_strtoll with >32bit ext4 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700931 sb_block = simple_strtoul(options, &options, 0);
932 if (*options && *options != ',') {
Theodore Ts'o4776004f2008-09-08 23:00:52 -0400933 printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700934 (char *) *data);
935 return 1;
936 }
937 if (*options == ',')
938 options++;
939 *data = (void *) options;
940 return sb_block;
941}
942
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400943static int parse_options(char *options, struct super_block *sb,
944 unsigned int *inum, unsigned long *journal_devnum,
945 ext4_fsblk_t *n_blocks_count, int is_remount)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700946{
Mingming Cao617ba132006-10-11 01:20:53 -0700947 struct ext4_sb_info *sbi = EXT4_SB(sb);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400948 char *p;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700949 substring_t args[MAX_OPT_ARGS];
950 int data_opt = 0;
951 int option;
952#ifdef CONFIG_QUOTA
Jan Karadfc5d032008-05-13 19:11:51 -0400953 int qtype, qfmt;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700954 char *qname;
955#endif
Aneesh Kumar K.Vc07651b2008-07-11 19:27:31 -0400956 ext4_fsblk_t last_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700957
958 if (!options)
959 return 1;
960
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400961 while ((p = strsep(&options, ",")) != NULL) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700962 int token;
963 if (!*p)
964 continue;
965
966 token = match_token(p, tokens, args);
967 switch (token) {
968 case Opt_bsd_df:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400969 clear_opt(sbi->s_mount_opt, MINIX_DF);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700970 break;
971 case Opt_minix_df:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400972 set_opt(sbi->s_mount_opt, MINIX_DF);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700973 break;
974 case Opt_grpid:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400975 set_opt(sbi->s_mount_opt, GRPID);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700976 break;
977 case Opt_nogrpid:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400978 clear_opt(sbi->s_mount_opt, GRPID);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700979 break;
980 case Opt_resuid:
981 if (match_int(&args[0], &option))
982 return 0;
983 sbi->s_resuid = option;
984 break;
985 case Opt_resgid:
986 if (match_int(&args[0], &option))
987 return 0;
988 sbi->s_resgid = option;
989 break;
990 case Opt_sb:
991 /* handled by get_sb_block() instead of here */
992 /* *sb_block = match_int(&args[0]); */
993 break;
994 case Opt_err_panic:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400995 clear_opt(sbi->s_mount_opt, ERRORS_CONT);
996 clear_opt(sbi->s_mount_opt, ERRORS_RO);
997 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700998 break;
999 case Opt_err_ro:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001000 clear_opt(sbi->s_mount_opt, ERRORS_CONT);
1001 clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
1002 set_opt(sbi->s_mount_opt, ERRORS_RO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001003 break;
1004 case Opt_err_cont:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001005 clear_opt(sbi->s_mount_opt, ERRORS_RO);
1006 clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
1007 set_opt(sbi->s_mount_opt, ERRORS_CONT);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001008 break;
1009 case Opt_nouid32:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001010 set_opt(sbi->s_mount_opt, NO_UID32);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001011 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001012 case Opt_debug:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001013 set_opt(sbi->s_mount_opt, DEBUG);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001014 break;
1015 case Opt_oldalloc:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001016 set_opt(sbi->s_mount_opt, OLDALLOC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001017 break;
1018 case Opt_orlov:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001019 clear_opt(sbi->s_mount_opt, OLDALLOC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001020 break;
Theodore Ts'o03010a32008-10-10 20:02:48 -04001021#ifdef CONFIG_EXT4_FS_XATTR
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001022 case Opt_user_xattr:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001023 set_opt(sbi->s_mount_opt, XATTR_USER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001024 break;
1025 case Opt_nouser_xattr:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001026 clear_opt(sbi->s_mount_opt, XATTR_USER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001027 break;
1028#else
1029 case Opt_user_xattr:
1030 case Opt_nouser_xattr:
Theodore Ts'o4776004f2008-09-08 23:00:52 -04001031 printk(KERN_ERR "EXT4 (no)user_xattr options "
1032 "not supported\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001033 break;
1034#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -04001035#ifdef CONFIG_EXT4_FS_POSIX_ACL
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001036 case Opt_acl:
1037 set_opt(sbi->s_mount_opt, POSIX_ACL);
1038 break;
1039 case Opt_noacl:
1040 clear_opt(sbi->s_mount_opt, POSIX_ACL);
1041 break;
1042#else
1043 case Opt_acl:
1044 case Opt_noacl:
Theodore Ts'o4776004f2008-09-08 23:00:52 -04001045 printk(KERN_ERR "EXT4 (no)acl options "
1046 "not supported\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001047 break;
1048#endif
1049 case Opt_reservation:
1050 set_opt(sbi->s_mount_opt, RESERVATION);
1051 break;
1052 case Opt_noreservation:
1053 clear_opt(sbi->s_mount_opt, RESERVATION);
1054 break;
1055 case Opt_journal_update:
1056 /* @@@ FIXME */
1057 /* Eventually we will want to be able to create
1058 a journal file here. For now, only allow the
1059 user to specify an existing inode to be the
1060 journal file. */
1061 if (is_remount) {
Mingming Cao617ba132006-10-11 01:20:53 -07001062 printk(KERN_ERR "EXT4-fs: cannot specify "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001063 "journal on remount\n");
1064 return 0;
1065 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001066 set_opt(sbi->s_mount_opt, UPDATE_JOURNAL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001067 break;
1068 case Opt_journal_inum:
1069 if (is_remount) {
Mingming Cao617ba132006-10-11 01:20:53 -07001070 printk(KERN_ERR "EXT4-fs: cannot specify "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001071 "journal on remount\n");
1072 return 0;
1073 }
1074 if (match_int(&args[0], &option))
1075 return 0;
1076 *inum = option;
1077 break;
1078 case Opt_journal_dev:
1079 if (is_remount) {
Mingming Cao617ba132006-10-11 01:20:53 -07001080 printk(KERN_ERR "EXT4-fs: cannot specify "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001081 "journal on remount\n");
1082 return 0;
1083 }
1084 if (match_int(&args[0], &option))
1085 return 0;
1086 *journal_devnum = option;
1087 break;
Girish Shilamkar818d2762008-01-28 23:58:27 -05001088 case Opt_journal_checksum:
1089 set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1090 break;
1091 case Opt_journal_async_commit:
1092 set_opt(sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);
1093 set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1094 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001095 case Opt_noload:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001096 set_opt(sbi->s_mount_opt, NOLOAD);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001097 break;
1098 case Opt_commit:
1099 if (match_int(&args[0], &option))
1100 return 0;
1101 if (option < 0)
1102 return 0;
1103 if (option == 0)
Mingming Caocd02ff02007-10-16 18:38:25 -04001104 option = JBD2_DEFAULT_MAX_COMMIT_AGE;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001105 sbi->s_commit_interval = HZ * option;
1106 break;
1107 case Opt_data_journal:
Mingming Cao617ba132006-10-11 01:20:53 -07001108 data_opt = EXT4_MOUNT_JOURNAL_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001109 goto datacheck;
1110 case Opt_data_ordered:
Mingming Cao617ba132006-10-11 01:20:53 -07001111 data_opt = EXT4_MOUNT_ORDERED_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001112 goto datacheck;
1113 case Opt_data_writeback:
Mingming Cao617ba132006-10-11 01:20:53 -07001114 data_opt = EXT4_MOUNT_WRITEBACK_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001115 datacheck:
1116 if (is_remount) {
Mingming Cao617ba132006-10-11 01:20:53 -07001117 if ((sbi->s_mount_opt & EXT4_MOUNT_DATA_FLAGS)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001118 != data_opt) {
1119 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07001120 "EXT4-fs: cannot change data "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001121 "mode on remount\n");
1122 return 0;
1123 }
1124 } else {
Mingming Cao617ba132006-10-11 01:20:53 -07001125 sbi->s_mount_opt &= ~EXT4_MOUNT_DATA_FLAGS;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001126 sbi->s_mount_opt |= data_opt;
1127 }
1128 break;
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04001129 case Opt_data_err_abort:
1130 set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1131 break;
1132 case Opt_data_err_ignore:
1133 clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1134 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001135#ifdef CONFIG_QUOTA
1136 case Opt_usrjquota:
1137 qtype = USRQUOTA;
1138 goto set_qf_name;
1139 case Opt_grpjquota:
1140 qtype = GRPQUOTA;
1141set_qf_name:
Jan Karadfc5d032008-05-13 19:11:51 -04001142 if ((sb_any_quota_enabled(sb) ||
1143 sb_any_quota_suspended(sb)) &&
1144 !sbi->s_qf_names[qtype]) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001145 printk(KERN_ERR
Theodore Ts'o4776004f2008-09-08 23:00:52 -04001146 "EXT4-fs: Cannot change journaled "
1147 "quota options when quota turned on.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001148 return 0;
1149 }
1150 qname = match_strdup(&args[0]);
1151 if (!qname) {
1152 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07001153 "EXT4-fs: not enough memory for "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001154 "storing quotafile name.\n");
1155 return 0;
1156 }
1157 if (sbi->s_qf_names[qtype] &&
1158 strcmp(sbi->s_qf_names[qtype], qname)) {
1159 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07001160 "EXT4-fs: %s quota file already "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001161 "specified.\n", QTYPE2NAME(qtype));
1162 kfree(qname);
1163 return 0;
1164 }
1165 sbi->s_qf_names[qtype] = qname;
1166 if (strchr(sbi->s_qf_names[qtype], '/')) {
1167 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07001168 "EXT4-fs: quotafile must be on "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001169 "filesystem root.\n");
1170 kfree(sbi->s_qf_names[qtype]);
1171 sbi->s_qf_names[qtype] = NULL;
1172 return 0;
1173 }
1174 set_opt(sbi->s_mount_opt, QUOTA);
1175 break;
1176 case Opt_offusrjquota:
1177 qtype = USRQUOTA;
1178 goto clear_qf_name;
1179 case Opt_offgrpjquota:
1180 qtype = GRPQUOTA;
1181clear_qf_name:
Jan Karadfc5d032008-05-13 19:11:51 -04001182 if ((sb_any_quota_enabled(sb) ||
1183 sb_any_quota_suspended(sb)) &&
1184 sbi->s_qf_names[qtype]) {
Mingming Cao617ba132006-10-11 01:20:53 -07001185 printk(KERN_ERR "EXT4-fs: Cannot change "
Jan Kara2c8be6b2008-05-13 21:27:55 -04001186 "journaled quota options when "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001187 "quota turned on.\n");
1188 return 0;
1189 }
1190 /*
1191 * The space will be released later when all options
1192 * are confirmed to be correct
1193 */
1194 sbi->s_qf_names[qtype] = NULL;
1195 break;
1196 case Opt_jqfmt_vfsold:
Jan Karadfc5d032008-05-13 19:11:51 -04001197 qfmt = QFMT_VFS_OLD;
1198 goto set_qf_format;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001199 case Opt_jqfmt_vfsv0:
Jan Karadfc5d032008-05-13 19:11:51 -04001200 qfmt = QFMT_VFS_V0;
1201set_qf_format:
1202 if ((sb_any_quota_enabled(sb) ||
1203 sb_any_quota_suspended(sb)) &&
1204 sbi->s_jquota_fmt != qfmt) {
1205 printk(KERN_ERR "EXT4-fs: Cannot change "
1206 "journaled quota options when "
1207 "quota turned on.\n");
1208 return 0;
1209 }
1210 sbi->s_jquota_fmt = qfmt;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001211 break;
1212 case Opt_quota:
1213 case Opt_usrquota:
1214 set_opt(sbi->s_mount_opt, QUOTA);
1215 set_opt(sbi->s_mount_opt, USRQUOTA);
1216 break;
1217 case Opt_grpquota:
1218 set_opt(sbi->s_mount_opt, QUOTA);
1219 set_opt(sbi->s_mount_opt, GRPQUOTA);
1220 break;
1221 case Opt_noquota:
1222 if (sb_any_quota_enabled(sb)) {
Mingming Cao617ba132006-10-11 01:20:53 -07001223 printk(KERN_ERR "EXT4-fs: Cannot change quota "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001224 "options when quota turned on.\n");
1225 return 0;
1226 }
1227 clear_opt(sbi->s_mount_opt, QUOTA);
1228 clear_opt(sbi->s_mount_opt, USRQUOTA);
1229 clear_opt(sbi->s_mount_opt, GRPQUOTA);
1230 break;
1231#else
1232 case Opt_quota:
1233 case Opt_usrquota:
1234 case Opt_grpquota:
Jan Karacd59e7b2008-05-13 19:11:51 -04001235 printk(KERN_ERR
1236 "EXT4-fs: quota options not supported.\n");
1237 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001238 case Opt_usrjquota:
1239 case Opt_grpjquota:
1240 case Opt_offusrjquota:
1241 case Opt_offgrpjquota:
1242 case Opt_jqfmt_vfsold:
1243 case Opt_jqfmt_vfsv0:
1244 printk(KERN_ERR
Jan Karacd59e7b2008-05-13 19:11:51 -04001245 "EXT4-fs: journaled quota options not "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001246 "supported.\n");
1247 break;
1248 case Opt_noquota:
1249 break;
1250#endif
1251 case Opt_abort:
1252 set_opt(sbi->s_mount_opt, ABORT);
1253 break;
1254 case Opt_barrier:
1255 if (match_int(&args[0], &option))
1256 return 0;
1257 if (option)
1258 set_opt(sbi->s_mount_opt, BARRIER);
1259 else
1260 clear_opt(sbi->s_mount_opt, BARRIER);
1261 break;
1262 case Opt_ignore:
1263 break;
1264 case Opt_resize:
1265 if (!is_remount) {
Mingming Cao617ba132006-10-11 01:20:53 -07001266 printk("EXT4-fs: resize option only available "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001267 "for remount\n");
1268 return 0;
1269 }
1270 if (match_int(&args[0], &option) != 0)
1271 return 0;
1272 *n_blocks_count = option;
1273 break;
1274 case Opt_nobh:
1275 set_opt(sbi->s_mount_opt, NOBH);
1276 break;
1277 case Opt_bh:
1278 clear_opt(sbi->s_mount_opt, NOBH);
1279 break;
Alex Tomasa86c6182006-10-11 01:21:03 -07001280 case Opt_extents:
Eric Sandeene4079a12008-07-11 19:27:31 -04001281 if (!EXT4_HAS_INCOMPAT_FEATURE(sb,
1282 EXT4_FEATURE_INCOMPAT_EXTENTS)) {
1283 ext4_warning(sb, __func__,
1284 "extents feature not enabled "
1285 "on this filesystem, use tune2fs\n");
1286 return 0;
1287 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001288 set_opt(sbi->s_mount_opt, EXTENTS);
Alex Tomasa86c6182006-10-11 01:21:03 -07001289 break;
Mingming Cao1e2462f2007-07-18 09:00:55 -04001290 case Opt_noextents:
Aneesh Kumar K.Vc07651b2008-07-11 19:27:31 -04001291 /*
1292 * When e2fsprogs support resizing an already existing
1293 * ext3 file system to greater than 2**32 we need to
1294 * add support to block allocator to handle growing
1295 * already existing block mapped inode so that blocks
1296 * allocated for them fall within 2**32
1297 */
1298 last_block = ext4_blocks_count(sbi->s_es) - 1;
1299 if (last_block > 0xffffffffULL) {
1300 printk(KERN_ERR "EXT4-fs: Filesystem too "
1301 "large to mount with "
1302 "-o noextents options\n");
1303 return 0;
1304 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001305 clear_opt(sbi->s_mount_opt, EXTENTS);
Mingming Cao1e2462f2007-07-18 09:00:55 -04001306 break;
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05001307 case Opt_i_version:
1308 set_opt(sbi->s_mount_opt, I_VERSION);
1309 sb->s_flags |= MS_I_VERSION;
1310 break;
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04001311 case Opt_nodelalloc:
1312 clear_opt(sbi->s_mount_opt, DELALLOC);
1313 break;
Alex Tomasc9de5602008-01-29 00:19:52 -05001314 case Opt_stripe:
1315 if (match_int(&args[0], &option))
1316 return 0;
1317 if (option < 0)
1318 return 0;
1319 sbi->s_stripe = option;
1320 break;
Alex Tomas64769242008-07-11 19:27:31 -04001321 case Opt_delalloc:
1322 set_opt(sbi->s_mount_opt, DELALLOC);
1323 break;
Theodore Ts'o240799c2008-10-09 23:53:47 -04001324 case Opt_inode_readahead_blks:
1325 if (match_int(&args[0], &option))
1326 return 0;
1327 if (option < 0 || option > (1 << 30))
1328 return 0;
1329 sbi->s_inode_readahead_blks = option;
1330 break;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001331 default:
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001332 printk(KERN_ERR
1333 "EXT4-fs: Unrecognized mount option \"%s\" "
1334 "or missing value\n", p);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001335 return 0;
1336 }
1337 }
1338#ifdef CONFIG_QUOTA
1339 if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
Mingming Cao617ba132006-10-11 01:20:53 -07001340 if ((sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA) &&
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001341 sbi->s_qf_names[USRQUOTA])
1342 clear_opt(sbi->s_mount_opt, USRQUOTA);
1343
Mingming Cao617ba132006-10-11 01:20:53 -07001344 if ((sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA) &&
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001345 sbi->s_qf_names[GRPQUOTA])
1346 clear_opt(sbi->s_mount_opt, GRPQUOTA);
1347
1348 if ((sbi->s_qf_names[USRQUOTA] &&
Mingming Cao617ba132006-10-11 01:20:53 -07001349 (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001350 (sbi->s_qf_names[GRPQUOTA] &&
Mingming Cao617ba132006-10-11 01:20:53 -07001351 (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA))) {
1352 printk(KERN_ERR "EXT4-fs: old and new quota "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001353 "format mixing.\n");
1354 return 0;
1355 }
1356
1357 if (!sbi->s_jquota_fmt) {
Jan Kara2c8be6b2008-05-13 21:27:55 -04001358 printk(KERN_ERR "EXT4-fs: journaled quota format "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001359 "not specified.\n");
1360 return 0;
1361 }
1362 } else {
1363 if (sbi->s_jquota_fmt) {
Jan Kara2c8be6b2008-05-13 21:27:55 -04001364 printk(KERN_ERR "EXT4-fs: journaled quota format "
1365 "specified with no journaling "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001366 "enabled.\n");
1367 return 0;
1368 }
1369 }
1370#endif
1371 return 1;
1372}
1373
Mingming Cao617ba132006-10-11 01:20:53 -07001374static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001375 int read_only)
1376{
Mingming Cao617ba132006-10-11 01:20:53 -07001377 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001378 int res = 0;
1379
Mingming Cao617ba132006-10-11 01:20:53 -07001380 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001381 printk(KERN_ERR "EXT4-fs warning: revision level too high, "
1382 "forcing read-only mode\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001383 res = MS_RDONLY;
1384 }
1385 if (read_only)
1386 return res;
Mingming Cao617ba132006-10-11 01:20:53 -07001387 if (!(sbi->s_mount_state & EXT4_VALID_FS))
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001388 printk(KERN_WARNING "EXT4-fs warning: mounting unchecked fs, "
1389 "running e2fsck is recommended\n");
Mingming Cao617ba132006-10-11 01:20:53 -07001390 else if ((sbi->s_mount_state & EXT4_ERROR_FS))
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001391 printk(KERN_WARNING
1392 "EXT4-fs warning: mounting fs with errors, "
1393 "running e2fsck is recommended\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001394 else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
1395 le16_to_cpu(es->s_mnt_count) >=
1396 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001397 printk(KERN_WARNING
1398 "EXT4-fs warning: maximal mount count reached, "
1399 "running e2fsck is recommended\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001400 else if (le32_to_cpu(es->s_checkinterval) &&
1401 (le32_to_cpu(es->s_lastcheck) +
1402 le32_to_cpu(es->s_checkinterval) <= get_seconds()))
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001403 printk(KERN_WARNING
1404 "EXT4-fs warning: checktime reached, "
1405 "running e2fsck is recommended\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001406#if 0
1407 /* @@@ We _will_ want to clear the valid bit if we find
Andrew Morton63f57932006-10-11 01:21:24 -07001408 * inconsistencies, to force a fsck at reboot. But for
1409 * a plain journaled filesystem we can keep it set as
1410 * valid forever! :)
1411 */
Marcin Slusarz216c34b2008-04-17 10:38:59 -04001412 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001413#endif
1414 if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
Mingming Cao617ba132006-10-11 01:20:53 -07001415 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
Marcin Slusarze8546d02008-04-17 10:38:59 -04001416 le16_add_cpu(&es->s_mnt_count, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001417 es->s_mtime = cpu_to_le32(get_seconds());
Mingming Cao617ba132006-10-11 01:20:53 -07001418 ext4_update_dynamic_rev(sb);
1419 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001420
Mingming Cao617ba132006-10-11 01:20:53 -07001421 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001422 if (test_opt(sb, DEBUG))
Mingming Cao617ba132006-10-11 01:20:53 -07001423 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%lu, "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001424 "bpg=%lu, ipg=%lu, mo=%04lx]\n",
1425 sb->s_blocksize,
1426 sbi->s_groups_count,
Mingming Cao617ba132006-10-11 01:20:53 -07001427 EXT4_BLOCKS_PER_GROUP(sb),
1428 EXT4_INODES_PER_GROUP(sb),
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001429 sbi->s_mount_opt);
1430
Theodore Ts'o05496762008-09-16 14:36:17 -04001431 printk(KERN_INFO "EXT4 FS on %s, %s journal on %s\n",
1432 sb->s_id, EXT4_SB(sb)->s_journal->j_inode ? "internal" :
1433 "external", EXT4_SB(sb)->s_journal->j_devname);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001434 return res;
1435}
1436
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001437static int ext4_fill_flex_info(struct super_block *sb)
1438{
1439 struct ext4_sb_info *sbi = EXT4_SB(sb);
1440 struct ext4_group_desc *gdp = NULL;
1441 struct buffer_head *bh;
1442 ext4_group_t flex_group_count;
1443 ext4_group_t flex_group;
1444 int groups_per_flex = 0;
1445 __u64 block_bitmap = 0;
1446 int i;
1447
1448 if (!sbi->s_es->s_log_groups_per_flex) {
1449 sbi->s_log_groups_per_flex = 0;
1450 return 1;
1451 }
1452
1453 sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
1454 groups_per_flex = 1 << sbi->s_log_groups_per_flex;
1455
Frederic Bohec62a11f2008-09-08 10:20:24 -04001456 /* We allocate both existing and potentially added groups */
1457 flex_group_count = ((sbi->s_groups_count + groups_per_flex - 1) +
1458 ((sbi->s_es->s_reserved_gdt_blocks +1 ) <<
1459 EXT4_DESC_PER_BLOCK_BITS(sb))) /
1460 groups_per_flex;
Li Zefanec05e862008-07-24 12:49:59 -04001461 sbi->s_flex_groups = kzalloc(flex_group_count *
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001462 sizeof(struct flex_groups), GFP_KERNEL);
1463 if (sbi->s_flex_groups == NULL) {
Li Zefanec05e862008-07-24 12:49:59 -04001464 printk(KERN_ERR "EXT4-fs: not enough memory for "
1465 "%lu flex groups\n", flex_group_count);
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001466 goto failed;
1467 }
Jose R. Santos772cb7c2008-07-11 19:27:31 -04001468
1469 gdp = ext4_get_group_desc(sb, 1, &bh);
1470 block_bitmap = ext4_block_bitmap(sb, gdp) - 1;
1471
1472 for (i = 0; i < sbi->s_groups_count; i++) {
1473 gdp = ext4_get_group_desc(sb, i, &bh);
1474
1475 flex_group = ext4_flex_group(sbi, i);
1476 sbi->s_flex_groups[flex_group].free_inodes +=
1477 le16_to_cpu(gdp->bg_free_inodes_count);
1478 sbi->s_flex_groups[flex_group].free_blocks +=
1479 le16_to_cpu(gdp->bg_free_blocks_count);
1480 }
1481
1482 return 1;
1483failed:
1484 return 0;
1485}
1486
Andreas Dilger717d50e2007-10-16 18:38:25 -04001487__le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
1488 struct ext4_group_desc *gdp)
1489{
1490 __u16 crc = 0;
1491
1492 if (sbi->s_es->s_feature_ro_compat &
1493 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
1494 int offset = offsetof(struct ext4_group_desc, bg_checksum);
1495 __le32 le_group = cpu_to_le32(block_group);
1496
1497 crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
1498 crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
1499 crc = crc16(crc, (__u8 *)gdp, offset);
1500 offset += sizeof(gdp->bg_checksum); /* skip checksum */
1501 /* for checksum of struct ext4_group_desc do the rest...*/
1502 if ((sbi->s_es->s_feature_incompat &
1503 cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
1504 offset < le16_to_cpu(sbi->s_es->s_desc_size))
1505 crc = crc16(crc, (__u8 *)gdp + offset,
1506 le16_to_cpu(sbi->s_es->s_desc_size) -
1507 offset);
1508 }
1509
1510 return cpu_to_le16(crc);
1511}
1512
1513int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 block_group,
1514 struct ext4_group_desc *gdp)
1515{
1516 if ((sbi->s_es->s_feature_ro_compat &
1517 cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) &&
1518 (gdp->bg_checksum != ext4_group_desc_csum(sbi, block_group, gdp)))
1519 return 0;
1520
1521 return 1;
1522}
1523
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001524/* Called at mount-time, super-block is locked */
Akinobu Mita197cd65a2008-02-06 01:40:16 -08001525static int ext4_check_descriptors(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001526{
Mingming Cao617ba132006-10-11 01:20:53 -07001527 struct ext4_sb_info *sbi = EXT4_SB(sb);
1528 ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
1529 ext4_fsblk_t last_block;
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001530 ext4_fsblk_t block_bitmap;
1531 ext4_fsblk_t inode_bitmap;
1532 ext4_fsblk_t inode_table;
Jose R. Santosce421582007-10-16 18:38:25 -04001533 int flexbg_flag = 0;
Avantika Mathurfd2d4292008-01-28 23:58:27 -05001534 ext4_group_t i;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001535
Jose R. Santosce421582007-10-16 18:38:25 -04001536 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
1537 flexbg_flag = 1;
1538
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001539 ext4_debug("Checking group descriptors");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001540
Akinobu Mita197cd65a2008-02-06 01:40:16 -08001541 for (i = 0; i < sbi->s_groups_count; i++) {
1542 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1543
Jose R. Santosce421582007-10-16 18:38:25 -04001544 if (i == sbi->s_groups_count - 1 || flexbg_flag)
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001545 last_block = ext4_blocks_count(sbi->s_es) - 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001546 else
1547 last_block = first_block +
Mingming Cao617ba132006-10-11 01:20:53 -07001548 (EXT4_BLOCKS_PER_GROUP(sb) - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001549
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07001550 block_bitmap = ext4_block_bitmap(sb, gdp);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001551 if (block_bitmap < first_block || block_bitmap > last_block) {
Josef Bacikc19204b2008-04-29 22:00:28 -04001552 printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1553 "Block bitmap for group %lu not in group "
Eric Sesterhenn51282732008-10-17 09:16:19 -04001554 "(block %llu)!\n", i, block_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001555 return 0;
1556 }
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07001557 inode_bitmap = ext4_inode_bitmap(sb, gdp);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001558 if (inode_bitmap < first_block || inode_bitmap > last_block) {
Josef Bacikc19204b2008-04-29 22:00:28 -04001559 printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1560 "Inode bitmap for group %lu not in group "
Eric Sesterhenn51282732008-10-17 09:16:19 -04001561 "(block %llu)!\n", i, inode_bitmap);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001562 return 0;
1563 }
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07001564 inode_table = ext4_inode_table(sb, gdp);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001565 if (inode_table < first_block ||
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001566 inode_table + sbi->s_itb_per_group - 1 > last_block) {
Josef Bacikc19204b2008-04-29 22:00:28 -04001567 printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1568 "Inode table for group %lu not in group "
Eric Sesterhenn51282732008-10-17 09:16:19 -04001569 "(block %llu)!\n", i, inode_table);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001570 return 0;
1571 }
Eric Sandeenb5f10ee2008-08-02 21:21:08 -04001572 spin_lock(sb_bgl_lock(sbi, i));
Andreas Dilger717d50e2007-10-16 18:38:25 -04001573 if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
Josef Bacikc19204b2008-04-29 22:00:28 -04001574 printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1575 "Checksum for group %lu failed (%u!=%u)\n",
1576 i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
1577 gdp)), le16_to_cpu(gdp->bg_checksum));
Li Zefan7ee1ec42008-09-08 10:47:19 -04001578 if (!(sb->s_flags & MS_RDONLY)) {
1579 spin_unlock(sb_bgl_lock(sbi, i));
Theodore Ts'o8a266462008-07-26 14:34:21 -04001580 return 0;
Li Zefan7ee1ec42008-09-08 10:47:19 -04001581 }
Andreas Dilger717d50e2007-10-16 18:38:25 -04001582 }
Eric Sandeenb5f10ee2008-08-02 21:21:08 -04001583 spin_unlock(sb_bgl_lock(sbi, i));
Jose R. Santosce421582007-10-16 18:38:25 -04001584 if (!flexbg_flag)
1585 first_block += EXT4_BLOCKS_PER_GROUP(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001586 }
1587
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001588 ext4_free_blocks_count_set(sbi->s_es, ext4_count_free_blocks(sb));
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001589 sbi->s_es->s_free_inodes_count = cpu_to_le32(ext4_count_free_inodes(sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001590 return 1;
1591}
1592
Mingming Cao617ba132006-10-11 01:20:53 -07001593/* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001594 * the superblock) which were deleted from all directories, but held open by
1595 * a process at the time of a crash. We walk the list and try to delete these
1596 * inodes at recovery time (only with a read-write filesystem).
1597 *
1598 * In order to keep the orphan inode chain consistent during traversal (in
1599 * case of crash during recovery), we link each inode into the superblock
1600 * orphan list_head and handle it the same way as an inode deletion during
1601 * normal operation (which journals the operations for us).
1602 *
1603 * We only do an iget() and an iput() on each inode, which is very safe if we
1604 * accidentally point at an in-use or already deleted inode. The worst that
1605 * can happen in this case is that we get a "bit already cleared" message from
Mingming Cao617ba132006-10-11 01:20:53 -07001606 * ext4_free_inode(). The only reason we would point at a wrong inode is if
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001607 * e2fsck was run on this filesystem, and it must have already done the orphan
1608 * inode cleanup for us, so we can safely abort without any further action.
1609 */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001610static void ext4_orphan_cleanup(struct super_block *sb,
1611 struct ext4_super_block *es)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001612{
1613 unsigned int s_flags = sb->s_flags;
1614 int nr_orphans = 0, nr_truncates = 0;
1615#ifdef CONFIG_QUOTA
1616 int i;
1617#endif
1618 if (!es->s_last_orphan) {
1619 jbd_debug(4, "no orphan inodes to clean up\n");
1620 return;
1621 }
1622
Eric Sandeena8f48a92006-12-06 20:40:13 -08001623 if (bdev_read_only(sb->s_bdev)) {
1624 printk(KERN_ERR "EXT4-fs: write access "
1625 "unavailable, skipping orphan cleanup.\n");
1626 return;
1627 }
1628
Mingming Cao617ba132006-10-11 01:20:53 -07001629 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001630 if (es->s_last_orphan)
1631 jbd_debug(1, "Errors on filesystem, "
1632 "clearing orphan list.\n");
1633 es->s_last_orphan = 0;
1634 jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
1635 return;
1636 }
1637
1638 if (s_flags & MS_RDONLY) {
Mingming Cao617ba132006-10-11 01:20:53 -07001639 printk(KERN_INFO "EXT4-fs: %s: orphan cleanup on readonly fs\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001640 sb->s_id);
1641 sb->s_flags &= ~MS_RDONLY;
1642 }
1643#ifdef CONFIG_QUOTA
1644 /* Needed for iput() to work correctly and not trash data */
1645 sb->s_flags |= MS_ACTIVE;
1646 /* Turn on quotas so that they are updated correctly */
1647 for (i = 0; i < MAXQUOTAS; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -07001648 if (EXT4_SB(sb)->s_qf_names[i]) {
1649 int ret = ext4_quota_on_mount(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001650 if (ret < 0)
1651 printk(KERN_ERR
Jan Kara2c8be6b2008-05-13 21:27:55 -04001652 "EXT4-fs: Cannot turn on journaled "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001653 "quota: error %d\n", ret);
1654 }
1655 }
1656#endif
1657
1658 while (es->s_last_orphan) {
1659 struct inode *inode;
1660
Josef Bacik97bd42b2008-04-29 22:04:56 -04001661 inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
1662 if (IS_ERR(inode)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001663 es->s_last_orphan = 0;
1664 break;
1665 }
1666
Mingming Cao617ba132006-10-11 01:20:53 -07001667 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001668 DQUOT_INIT(inode);
1669 if (inode->i_nlink) {
1670 printk(KERN_DEBUG
Theodore Ts'oe5f8eab82008-09-08 22:25:04 -04001671 "%s: truncating inode %lu to %lld bytes\n",
Harvey Harrison46e665e2008-04-17 10:38:59 -04001672 __func__, inode->i_ino, inode->i_size);
Theodore Ts'oe5f8eab82008-09-08 22:25:04 -04001673 jbd_debug(2, "truncating inode %lu to %lld bytes\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001674 inode->i_ino, inode->i_size);
Mingming Cao617ba132006-10-11 01:20:53 -07001675 ext4_truncate(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001676 nr_truncates++;
1677 } else {
1678 printk(KERN_DEBUG
1679 "%s: deleting unreferenced inode %lu\n",
Harvey Harrison46e665e2008-04-17 10:38:59 -04001680 __func__, inode->i_ino);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001681 jbd_debug(2, "deleting unreferenced inode %lu\n",
1682 inode->i_ino);
1683 nr_orphans++;
1684 }
1685 iput(inode); /* The delete magic happens here! */
1686 }
1687
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001688#define PLURAL(x) (x), ((x) == 1) ? "" : "s"
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001689
1690 if (nr_orphans)
Mingming Cao617ba132006-10-11 01:20:53 -07001691 printk(KERN_INFO "EXT4-fs: %s: %d orphan inode%s deleted\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001692 sb->s_id, PLURAL(nr_orphans));
1693 if (nr_truncates)
Mingming Cao617ba132006-10-11 01:20:53 -07001694 printk(KERN_INFO "EXT4-fs: %s: %d truncate%s cleaned up\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001695 sb->s_id, PLURAL(nr_truncates));
1696#ifdef CONFIG_QUOTA
1697 /* Turn quotas off */
1698 for (i = 0; i < MAXQUOTAS; i++) {
1699 if (sb_dqopt(sb)->files[i])
Jan Kara6f28e082008-04-28 02:14:34 -07001700 vfs_quota_off(sb, i, 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001701 }
1702#endif
1703 sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1704}
Eric Sandeencd2291a2008-01-28 23:58:27 -05001705/*
1706 * Maximal extent format file size.
1707 * Resulting logical blkno at s_maxbytes must fit in our on-disk
1708 * extent format containers, within a sector_t, and within i_blocks
1709 * in the vfs. ext4 inode has 48 bits of i_block in fsblock units,
1710 * so that won't be a limiting factor.
1711 *
1712 * Note, this does *not* consider any metadata overhead for vfs i_blocks.
1713 */
Theodore Ts'of287a1a2008-10-16 22:50:48 -04001714static loff_t ext4_max_size(int blkbits, int has_huge_files)
Eric Sandeencd2291a2008-01-28 23:58:27 -05001715{
1716 loff_t res;
1717 loff_t upper_limit = MAX_LFS_FILESIZE;
1718
1719 /* small i_blocks in vfs inode? */
Theodore Ts'of287a1a2008-10-16 22:50:48 -04001720 if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
Eric Sandeencd2291a2008-01-28 23:58:27 -05001721 /*
1722 * CONFIG_LSF is not enabled implies the inode
1723 * i_block represent total blocks in 512 bytes
1724 * 32 == size of vfs inode i_blocks * 8
1725 */
1726 upper_limit = (1LL << 32) - 1;
1727
1728 /* total blocks in file system block size */
1729 upper_limit >>= (blkbits - 9);
1730 upper_limit <<= blkbits;
1731 }
1732
1733 /* 32-bit extent-start container, ee_block */
1734 res = 1LL << 32;
1735 res <<= blkbits;
1736 res -= 1;
1737
1738 /* Sanity check against vm- & vfs- imposed limits */
1739 if (res > upper_limit)
1740 res = upper_limit;
1741
1742 return res;
1743}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001744
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001745/*
Eric Sandeencd2291a2008-01-28 23:58:27 -05001746 * Maximal bitmap file size. There is a direct, and {,double-,triple-}indirect
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001747 * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
1748 * We need to be 1 filesystem block less than the 2^48 sector limit.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001749 */
Theodore Ts'of287a1a2008-10-16 22:50:48 -04001750static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001751{
Mingming Cao617ba132006-10-11 01:20:53 -07001752 loff_t res = EXT4_NDIR_BLOCKS;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001753 int meta_blocks;
1754 loff_t upper_limit;
1755 /* This is calculated to be the largest file size for a
Eric Sandeencd2291a2008-01-28 23:58:27 -05001756 * dense, bitmapped file such that the total number of
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001757 * sectors in the file, including data and all indirect blocks,
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001758 * does not exceed 2^48 -1
1759 * __u32 i_blocks_lo and _u16 i_blocks_high representing the
1760 * total number of 512 bytes blocks of the file
1761 */
1762
Theodore Ts'of287a1a2008-10-16 22:50:48 -04001763 if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001764 /*
Theodore Ts'of287a1a2008-10-16 22:50:48 -04001765 * !has_huge_files or CONFIG_LSF is not enabled
1766 * implies the inode i_block represent total blocks in
1767 * 512 bytes 32 == size of vfs inode i_blocks * 8
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001768 */
1769 upper_limit = (1LL << 32) - 1;
1770
1771 /* total blocks in file system block size */
1772 upper_limit >>= (bits - 9);
1773
1774 } else {
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05001775 /*
1776 * We use 48 bit ext4_inode i_blocks
1777 * With EXT4_HUGE_FILE_FL set the i_blocks
1778 * represent total number of blocks in
1779 * file system block size
1780 */
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001781 upper_limit = (1LL << 48) - 1;
1782
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001783 }
1784
1785 /* indirect blocks */
1786 meta_blocks = 1;
1787 /* double indirect blocks */
1788 meta_blocks += 1 + (1LL << (bits-2));
1789 /* tripple indirect blocks */
1790 meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
1791
1792 upper_limit -= meta_blocks;
1793 upper_limit <<= bits;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001794
1795 res += 1LL << (bits-2);
1796 res += 1LL << (2*(bits-2));
1797 res += 1LL << (3*(bits-2));
1798 res <<= bits;
1799 if (res > upper_limit)
1800 res = upper_limit;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05001801
1802 if (res > MAX_LFS_FILESIZE)
1803 res = MAX_LFS_FILESIZE;
1804
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001805 return res;
1806}
1807
Mingming Cao617ba132006-10-11 01:20:53 -07001808static ext4_fsblk_t descriptor_loc(struct super_block *sb,
Andrew Morton70bbb3e2006-10-11 01:21:20 -07001809 ext4_fsblk_t logical_sb_block, int nr)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001810{
Mingming Cao617ba132006-10-11 01:20:53 -07001811 struct ext4_sb_info *sbi = EXT4_SB(sb);
Avantika Mathurfd2d4292008-01-28 23:58:27 -05001812 ext4_group_t bg, first_meta_bg;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001813 int has_super = 0;
1814
1815 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
1816
Mingming Cao617ba132006-10-11 01:20:53 -07001817 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001818 nr < first_meta_bg)
Andrew Morton70bbb3e2006-10-11 01:21:20 -07001819 return logical_sb_block + nr + 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001820 bg = sbi->s_desc_per_block * nr;
Mingming Cao617ba132006-10-11 01:20:53 -07001821 if (ext4_bg_has_super(sb, bg))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001822 has_super = 1;
Mingming Cao617ba132006-10-11 01:20:53 -07001823 return (has_super + ext4_group_first_block_no(sb, bg));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001824}
1825
Alex Tomasc9de5602008-01-29 00:19:52 -05001826/**
1827 * ext4_get_stripe_size: Get the stripe size.
1828 * @sbi: In memory super block info
1829 *
1830 * If we have specified it via mount option, then
1831 * use the mount option value. If the value specified at mount time is
1832 * greater than the blocks per group use the super block value.
1833 * If the super block value is greater than blocks per group return 0.
1834 * Allocator needs it be less than blocks per group.
1835 *
1836 */
1837static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
1838{
1839 unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
1840 unsigned long stripe_width =
1841 le32_to_cpu(sbi->s_es->s_raid_stripe_width);
1842
1843 if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
1844 return sbi->s_stripe;
1845
1846 if (stripe_width <= sbi->s_blocks_per_group)
1847 return stripe_width;
1848
1849 if (stride <= sbi->s_blocks_per_group)
1850 return stride;
1851
1852 return 0;
1853}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001854
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001855static int ext4_fill_super(struct super_block *sb, void *data, int silent)
Aneesh Kumar K.V74778272008-07-11 19:27:31 -04001856 __releases(kernel_lock)
1857 __acquires(kernel_lock)
Aneesh Kumar K.V1d03ec92008-01-28 23:58:27 -05001858
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001859{
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001860 struct buffer_head *bh;
Mingming Cao617ba132006-10-11 01:20:53 -07001861 struct ext4_super_block *es = NULL;
1862 struct ext4_sb_info *sbi;
1863 ext4_fsblk_t block;
1864 ext4_fsblk_t sb_block = get_sb_block(&data);
Andrew Morton70bbb3e2006-10-11 01:21:20 -07001865 ext4_fsblk_t logical_sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001866 unsigned long offset = 0;
1867 unsigned int journal_inum = 0;
1868 unsigned long journal_devnum = 0;
1869 unsigned long def_mount_opts;
1870 struct inode *root;
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04001871 char *cp;
David Howells1d1fe1e2008-02-07 00:15:37 -08001872 int ret = -EINVAL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001873 int blocksize;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001874 int db_count;
1875 int i;
Theodore Ts'of287a1a2008-10-16 22:50:48 -04001876 int needs_recovery, has_huge_files;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001877 __le32 features;
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07001878 __u64 blocks_count;
Peter Zijlstra833f4072007-10-16 23:25:45 -07001879 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001880
1881 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
1882 if (!sbi)
1883 return -ENOMEM;
1884 sb->s_fs_info = sbi;
1885 sbi->s_mount_opt = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07001886 sbi->s_resuid = EXT4_DEF_RESUID;
1887 sbi->s_resgid = EXT4_DEF_RESGID;
Theodore Ts'o240799c2008-10-09 23:53:47 -04001888 sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
Miklos Szeredid9c9bef12007-10-16 23:26:27 -07001889 sbi->s_sb_block = sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001890
1891 unlock_kernel();
1892
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04001893 /* Cleanup superblock name */
1894 for (cp = sb->s_id; (cp = strchr(cp, '/'));)
1895 *cp = '!';
1896
Mingming Cao617ba132006-10-11 01:20:53 -07001897 blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001898 if (!blocksize) {
Mingming Cao617ba132006-10-11 01:20:53 -07001899 printk(KERN_ERR "EXT4-fs: unable to set blocksize\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001900 goto out_fail;
1901 }
1902
1903 /*
Mingming Cao617ba132006-10-11 01:20:53 -07001904 * The ext4 superblock will not be buffer aligned for other than 1kB
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001905 * block sizes. We need to calculate the offset from buffer start.
1906 */
Mingming Cao617ba132006-10-11 01:20:53 -07001907 if (blocksize != EXT4_MIN_BLOCK_SIZE) {
Andrew Morton70bbb3e2006-10-11 01:21:20 -07001908 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
1909 offset = do_div(logical_sb_block, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001910 } else {
Andrew Morton70bbb3e2006-10-11 01:21:20 -07001911 logical_sb_block = sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001912 }
1913
Andrew Morton70bbb3e2006-10-11 01:21:20 -07001914 if (!(bh = sb_bread(sb, logical_sb_block))) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001915 printk(KERN_ERR "EXT4-fs: unable to read superblock\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001916 goto out_fail;
1917 }
1918 /*
1919 * Note: s_es must be initialized as soon as possible because
Mingming Cao617ba132006-10-11 01:20:53 -07001920 * some ext4 macro-instructions depend on its value
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001921 */
Mingming Cao617ba132006-10-11 01:20:53 -07001922 es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001923 sbi->s_es = es;
1924 sb->s_magic = le16_to_cpu(es->s_magic);
Mingming Cao617ba132006-10-11 01:20:53 -07001925 if (sb->s_magic != EXT4_SUPER_MAGIC)
1926 goto cantfind_ext4;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001927
1928 /* Set defaults before we parse the mount options */
1929 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
Mingming Cao617ba132006-10-11 01:20:53 -07001930 if (def_mount_opts & EXT4_DEFM_DEBUG)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001931 set_opt(sbi->s_mount_opt, DEBUG);
Mingming Cao617ba132006-10-11 01:20:53 -07001932 if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001933 set_opt(sbi->s_mount_opt, GRPID);
Mingming Cao617ba132006-10-11 01:20:53 -07001934 if (def_mount_opts & EXT4_DEFM_UID16)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001935 set_opt(sbi->s_mount_opt, NO_UID32);
Theodore Ts'o03010a32008-10-10 20:02:48 -04001936#ifdef CONFIG_EXT4_FS_XATTR
Mingming Cao617ba132006-10-11 01:20:53 -07001937 if (def_mount_opts & EXT4_DEFM_XATTR_USER)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001938 set_opt(sbi->s_mount_opt, XATTR_USER);
Hugh Dickins2e7842b2007-02-10 01:46:13 -08001939#endif
Theodore Ts'o03010a32008-10-10 20:02:48 -04001940#ifdef CONFIG_EXT4_FS_POSIX_ACL
Mingming Cao617ba132006-10-11 01:20:53 -07001941 if (def_mount_opts & EXT4_DEFM_ACL)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001942 set_opt(sbi->s_mount_opt, POSIX_ACL);
Hugh Dickins2e7842b2007-02-10 01:46:13 -08001943#endif
Mingming Cao617ba132006-10-11 01:20:53 -07001944 if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
1945 sbi->s_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
1946 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
1947 sbi->s_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
1948 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
1949 sbi->s_mount_opt |= EXT4_MOUNT_WRITEBACK_DATA;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001950
Mingming Cao617ba132006-10-11 01:20:53 -07001951 if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001952 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -05001953 else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
Dmitry Mishinceea16b2006-10-11 01:21:21 -07001954 set_opt(sbi->s_mount_opt, ERRORS_CONT);
Aneesh Kumar K.Vbb4f3972008-01-28 23:58:26 -05001955 else
1956 set_opt(sbi->s_mount_opt, ERRORS_RO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001957
1958 sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
1959 sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
1960
1961 set_opt(sbi->s_mount_opt, RESERVATION);
Eric Sandeen571640c2008-05-26 12:29:46 -04001962 set_opt(sbi->s_mount_opt, BARRIER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001963
Mingming Cao1e2462f2007-07-18 09:00:55 -04001964 /*
1965 * turn on extents feature by default in ext4 filesystem
Eric Sandeene4079a12008-07-11 19:27:31 -04001966 * only if feature flag already set by mkfs or tune2fs.
1967 * Use -o noextents to turn it off
Mingming Cao1e2462f2007-07-18 09:00:55 -04001968 */
Eric Sandeene4079a12008-07-11 19:27:31 -04001969 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_EXTENTS))
1970 set_opt(sbi->s_mount_opt, EXTENTS);
1971 else
1972 ext4_warning(sb, __func__,
1973 "extents feature not enabled on this filesystem, "
1974 "use tune2fs.\n");
Mingming Cao1e2462f2007-07-18 09:00:55 -04001975
Aneesh Kumar K.Vdd919b92008-07-11 19:27:31 -04001976 /*
1977 * enable delayed allocation by default
1978 * Use -o nodelalloc to turn it off
1979 */
1980 set_opt(sbi->s_mount_opt, DELALLOC);
1981
1982
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04001983 if (!parse_options((char *) data, sb, &journal_inum, &journal_devnum,
1984 NULL, 0))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001985 goto failed_mount;
1986
1987 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
Mingming Cao617ba132006-10-11 01:20:53 -07001988 ((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001989
Mingming Cao617ba132006-10-11 01:20:53 -07001990 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
1991 (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) ||
1992 EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
1993 EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001994 printk(KERN_WARNING
Mingming Cao617ba132006-10-11 01:20:53 -07001995 "EXT4-fs warning: feature flags set on rev 0 fs, "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001996 "running e2fsck is recommended\n");
Theodore Tso469108f2008-02-10 01:11:44 -05001997
1998 /*
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001999 * Check feature flags regardless of the revision level, since we
2000 * previously didn't change the revision level when setting the flags,
2001 * so there is a chance incompat flags are set on a rev 0 filesystem.
2002 */
Mingming Cao617ba132006-10-11 01:20:53 -07002003 features = EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002004 if (features) {
Mingming Cao617ba132006-10-11 01:20:53 -07002005 printk(KERN_ERR "EXT4-fs: %s: couldn't mount because of "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002006 "unsupported optional features (%x).\n",
2007 sb->s_id, le32_to_cpu(features));
2008 goto failed_mount;
2009 }
Mingming Cao617ba132006-10-11 01:20:53 -07002010 features = EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002011 if (!(sb->s_flags & MS_RDONLY) && features) {
Mingming Cao617ba132006-10-11 01:20:53 -07002012 printk(KERN_ERR "EXT4-fs: %s: couldn't mount RDWR because of "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002013 "unsupported optional features (%x).\n",
2014 sb->s_id, le32_to_cpu(features));
2015 goto failed_mount;
2016 }
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002017 has_huge_files = EXT4_HAS_RO_COMPAT_FEATURE(sb,
2018 EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
2019 if (has_huge_files) {
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05002020 /*
2021 * Large file size enabled file system can only be
2022 * mount if kernel is build with CONFIG_LSF
2023 */
2024 if (sizeof(root->i_blocks) < sizeof(u64) &&
2025 !(sb->s_flags & MS_RDONLY)) {
2026 printk(KERN_ERR "EXT4-fs: %s: Filesystem with huge "
2027 "files cannot be mounted read-write "
2028 "without CONFIG_LSF.\n", sb->s_id);
2029 goto failed_mount;
2030 }
2031 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002032 blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
2033
Mingming Cao617ba132006-10-11 01:20:53 -07002034 if (blocksize < EXT4_MIN_BLOCK_SIZE ||
2035 blocksize > EXT4_MAX_BLOCK_SIZE) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002036 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07002037 "EXT4-fs: Unsupported filesystem blocksize %d on %s.\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002038 blocksize, sb->s_id);
2039 goto failed_mount;
2040 }
2041
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002042 if (sb->s_blocksize != blocksize) {
Aneesh Kumar K.Vce407332008-01-28 23:58:27 -05002043
2044 /* Validate the filesystem blocksize */
2045 if (!sb_set_blocksize(sb, blocksize)) {
2046 printk(KERN_ERR "EXT4-fs: bad block size %d.\n",
2047 blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002048 goto failed_mount;
2049 }
2050
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002051 brelse(bh);
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002052 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
2053 offset = do_div(logical_sb_block, blocksize);
2054 bh = sb_bread(sb, logical_sb_block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002055 if (!bh) {
2056 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07002057 "EXT4-fs: Can't read superblock on 2nd try.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002058 goto failed_mount;
2059 }
Mingming Cao617ba132006-10-11 01:20:53 -07002060 es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002061 sbi->s_es = es;
Mingming Cao617ba132006-10-11 01:20:53 -07002062 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002063 printk(KERN_ERR
2064 "EXT4-fs: Magic mismatch, very weird !\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002065 goto failed_mount;
2066 }
2067 }
2068
Theodore Ts'of287a1a2008-10-16 22:50:48 -04002069 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
2070 has_huge_files);
2071 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002072
Mingming Cao617ba132006-10-11 01:20:53 -07002073 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
2074 sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
2075 sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002076 } else {
2077 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
2078 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
Mingming Cao617ba132006-10-11 01:20:53 -07002079 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
Vignesh Babu13305932007-07-18 09:11:02 -04002080 (!is_power_of_2(sbi->s_inode_size)) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002081 (sbi->s_inode_size > blocksize)) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002082 printk(KERN_ERR
2083 "EXT4-fs: unsupported inode size: %d\n",
2084 sbi->s_inode_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002085 goto failed_mount;
2086 }
Kalpak Shahef7f3832007-07-18 09:15:20 -04002087 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
2088 sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002089 }
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002090 sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
2091 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) {
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07002092 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002093 sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
vignesh babud8ea6cf2007-10-16 23:27:14 -07002094 !is_power_of_2(sbi->s_desc_size)) {
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002095 printk(KERN_ERR
Alexandre Ratchov8fadc142006-10-11 01:21:15 -07002096 "EXT4-fs: unsupported descriptor size %lu\n",
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002097 sbi->s_desc_size);
2098 goto failed_mount;
2099 }
2100 } else
2101 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002102 sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002103 sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
Andries E. Brouwerb47b6f32007-12-17 16:19:55 -08002104 if (EXT4_INODE_SIZE(sb) == 0 || EXT4_INODES_PER_GROUP(sb) == 0)
Mingming Cao617ba132006-10-11 01:20:53 -07002105 goto cantfind_ext4;
2106 sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002107 if (sbi->s_inodes_per_block == 0)
Mingming Cao617ba132006-10-11 01:20:53 -07002108 goto cantfind_ext4;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002109 sbi->s_itb_per_group = sbi->s_inodes_per_group /
2110 sbi->s_inodes_per_block;
Alexandre Ratchov0d1ee422006-10-11 01:21:14 -07002111 sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002112 sbi->s_sbh = bh;
2113 sbi->s_mount_state = le16_to_cpu(es->s_state);
Fengguang Wue57aa832007-10-16 23:26:25 -07002114 sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
2115 sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002116 for (i = 0; i < 4; i++)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002117 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
2118 sbi->s_def_hash_version = es->s_def_hash_version;
2119
2120 if (sbi->s_blocks_per_group > blocksize * 8) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002121 printk(KERN_ERR
2122 "EXT4-fs: #blocks per group too big: %lu\n",
2123 sbi->s_blocks_per_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002124 goto failed_mount;
2125 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002126 if (sbi->s_inodes_per_group > blocksize * 8) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002127 printk(KERN_ERR
2128 "EXT4-fs: #inodes per group too big: %lu\n",
2129 sbi->s_inodes_per_group);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002130 goto failed_mount;
2131 }
2132
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002133 if (ext4_blocks_count(es) >
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002134 (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002135 printk(KERN_ERR "EXT4-fs: filesystem on %s:"
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002136 " too large to mount safely\n", sb->s_id);
2137 if (sizeof(sector_t) < 8)
Mingming Cao617ba132006-10-11 01:20:53 -07002138 printk(KERN_WARNING "EXT4-fs: CONFIG_LBD not "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002139 "enabled\n");
2140 goto failed_mount;
2141 }
2142
Mingming Cao617ba132006-10-11 01:20:53 -07002143 if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
2144 goto cantfind_ext4;
Eric Sandeene7c95592008-01-28 23:58:27 -05002145
2146 /* ensure blocks_count calculation below doesn't sign-extend */
2147 if (ext4_blocks_count(es) + EXT4_BLOCKS_PER_GROUP(sb) <
2148 le32_to_cpu(es->s_first_data_block) + 1) {
2149 printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu, "
2150 "first data block %u, blocks per group %lu\n",
2151 ext4_blocks_count(es),
2152 le32_to_cpu(es->s_first_data_block),
2153 EXT4_BLOCKS_PER_GROUP(sb));
2154 goto failed_mount;
2155 }
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002156 blocks_count = (ext4_blocks_count(es) -
2157 le32_to_cpu(es->s_first_data_block) +
2158 EXT4_BLOCKS_PER_GROUP(sb) - 1);
2159 do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
2160 sbi->s_groups_count = blocks_count;
Mingming Cao617ba132006-10-11 01:20:53 -07002161 db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
2162 EXT4_DESC_PER_BLOCK(sb);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002163 sbi->s_group_desc = kmalloc(db_count * sizeof(struct buffer_head *),
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002164 GFP_KERNEL);
2165 if (sbi->s_group_desc == NULL) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002166 printk(KERN_ERR "EXT4-fs: not enough memory\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002167 goto failed_mount;
2168 }
2169
Alexander Beregalov3244fcb2008-10-12 17:27:49 -04002170#ifdef CONFIG_PROC_FS
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04002171 if (ext4_proc_root)
2172 sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root);
2173
Theodore Ts'o240799c2008-10-09 23:53:47 -04002174 if (sbi->s_proc)
2175 proc_create_data("inode_readahead_blks", 0644, sbi->s_proc,
2176 &ext4_ui_proc_fops,
2177 &sbi->s_inode_readahead_blks);
Alexander Beregalov3244fcb2008-10-12 17:27:49 -04002178#endif
Theodore Ts'o240799c2008-10-09 23:53:47 -04002179
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002180 bgl_lock_init(&sbi->s_blockgroup_lock);
2181
2182 for (i = 0; i < db_count; i++) {
Andrew Morton70bbb3e2006-10-11 01:21:20 -07002183 block = descriptor_loc(sb, logical_sb_block, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002184 sbi->s_group_desc[i] = sb_bread(sb, block);
2185 if (!sbi->s_group_desc[i]) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002186 printk(KERN_ERR "EXT4-fs: "
2187 "can't read group descriptor %d\n", i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002188 db_count = i;
2189 goto failed_mount2;
2190 }
2191 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002192 if (!ext4_check_descriptors(sb)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002193 printk(KERN_ERR "EXT4-fs: group descriptors corrupted!\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002194 goto failed_mount2;
2195 }
Jose R. Santos772cb7c2008-07-11 19:27:31 -04002196 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
2197 if (!ext4_fill_flex_info(sb)) {
2198 printk(KERN_ERR
2199 "EXT4-fs: unable to initialize "
2200 "flex_bg meta info!\n");
2201 goto failed_mount2;
2202 }
2203
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002204 sbi->s_gdb_count = db_count;
2205 get_random_bytes(&sbi->s_next_generation, sizeof(u32));
2206 spin_lock_init(&sbi->s_next_gen_lock);
2207
Peter Zijlstra833f4072007-10-16 23:25:45 -07002208 err = percpu_counter_init(&sbi->s_freeblocks_counter,
2209 ext4_count_free_blocks(sb));
2210 if (!err) {
2211 err = percpu_counter_init(&sbi->s_freeinodes_counter,
2212 ext4_count_free_inodes(sb));
2213 }
2214 if (!err) {
2215 err = percpu_counter_init(&sbi->s_dirs_counter,
2216 ext4_count_dirs(sb));
2217 }
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -04002218 if (!err) {
2219 err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
2220 }
Peter Zijlstra833f4072007-10-16 23:25:45 -07002221 if (err) {
2222 printk(KERN_ERR "EXT4-fs: insufficient memory\n");
2223 goto failed_mount3;
2224 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002225
Alex Tomasc9de5602008-01-29 00:19:52 -05002226 sbi->s_stripe = ext4_get_stripe_size(sbi);
2227
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002228 /*
2229 * set up enough so that it can read an inode
2230 */
Mingming Cao617ba132006-10-11 01:20:53 -07002231 sb->s_op = &ext4_sops;
2232 sb->s_export_op = &ext4_export_ops;
2233 sb->s_xattr = ext4_xattr_handlers;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002234#ifdef CONFIG_QUOTA
Mingming Cao617ba132006-10-11 01:20:53 -07002235 sb->s_qcop = &ext4_qctl_operations;
2236 sb->dq_op = &ext4_quota_operations;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002237#endif
2238 INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
2239
2240 sb->s_root = NULL;
2241
2242 needs_recovery = (es->s_last_orphan != 0 ||
Mingming Cao617ba132006-10-11 01:20:53 -07002243 EXT4_HAS_INCOMPAT_FEATURE(sb,
2244 EXT4_FEATURE_INCOMPAT_RECOVER));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002245
2246 /*
2247 * The first inode we look at is the journal inode. Don't try
2248 * root first: it may be modified in the journal!
2249 */
2250 if (!test_opt(sb, NOLOAD) &&
Mingming Cao617ba132006-10-11 01:20:53 -07002251 EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
2252 if (ext4_load_journal(sb, es, journal_devnum))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002253 goto failed_mount3;
Theodore Ts'o624080e2008-06-06 17:50:40 -04002254 if (!(sb->s_flags & MS_RDONLY) &&
2255 EXT4_SB(sb)->s_journal->j_failed_commit) {
2256 printk(KERN_CRIT "EXT4-fs error (device %s): "
2257 "ext4_fill_super: Journal transaction "
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002258 "%u is corrupt\n", sb->s_id,
Theodore Ts'o624080e2008-06-06 17:50:40 -04002259 EXT4_SB(sb)->s_journal->j_failed_commit);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002260 if (test_opt(sb, ERRORS_RO)) {
2261 printk(KERN_CRIT
2262 "Mounting filesystem read-only\n");
Theodore Ts'o624080e2008-06-06 17:50:40 -04002263 sb->s_flags |= MS_RDONLY;
2264 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
2265 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
2266 }
2267 if (test_opt(sb, ERRORS_PANIC)) {
2268 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
2269 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
2270 ext4_commit_super(sb, es, 1);
2271 printk(KERN_CRIT
2272 "EXT4-fs (device %s): mount failed\n",
2273 sb->s_id);
2274 goto failed_mount4;
2275 }
2276 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002277 } else if (journal_inum) {
Mingming Cao617ba132006-10-11 01:20:53 -07002278 if (ext4_create_journal(sb, es, journal_inum))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002279 goto failed_mount3;
2280 } else {
2281 if (!silent)
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002282 printk(KERN_ERR
2283 "ext4: No journal on filesystem on %s\n",
2284 sb->s_id);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002285 goto failed_mount3;
2286 }
2287
Jose R. Santoseb40a092007-07-18 08:37:25 -04002288 if (ext4_blocks_count(es) > 0xffffffffULL &&
2289 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
2290 JBD2_FEATURE_INCOMPAT_64BIT)) {
2291 printk(KERN_ERR "ext4: Failed to set 64-bit journal feature\n");
2292 goto failed_mount4;
2293 }
2294
Girish Shilamkar818d2762008-01-28 23:58:27 -05002295 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
2296 jbd2_journal_set_features(sbi->s_journal,
2297 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2298 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2299 } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
2300 jbd2_journal_set_features(sbi->s_journal,
2301 JBD2_FEATURE_COMPAT_CHECKSUM, 0, 0);
2302 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
2303 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2304 } else {
2305 jbd2_journal_clear_features(sbi->s_journal,
2306 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2307 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2308 }
2309
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002310 /* We have now updated the journal if required, so we can
2311 * validate the data journaling mode. */
2312 switch (test_opt(sb, DATA_FLAGS)) {
2313 case 0:
2314 /* No mode set, assume a default based on the journal
Andrew Morton63f57932006-10-11 01:21:24 -07002315 * capabilities: ORDERED_DATA if the journal can
2316 * cope, else JOURNAL_DATA
2317 */
Mingming Caodab291a2006-10-11 01:21:01 -07002318 if (jbd2_journal_check_available_features
2319 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002320 set_opt(sbi->s_mount_opt, ORDERED_DATA);
2321 else
2322 set_opt(sbi->s_mount_opt, JOURNAL_DATA);
2323 break;
2324
Mingming Cao617ba132006-10-11 01:20:53 -07002325 case EXT4_MOUNT_ORDERED_DATA:
2326 case EXT4_MOUNT_WRITEBACK_DATA:
Mingming Caodab291a2006-10-11 01:21:01 -07002327 if (!jbd2_journal_check_available_features
2328 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002329 printk(KERN_ERR "EXT4-fs: Journal does not support "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002330 "requested data journaling mode\n");
2331 goto failed_mount4;
2332 }
2333 default:
2334 break;
2335 }
2336
2337 if (test_opt(sb, NOBH)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002338 if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
2339 printk(KERN_WARNING "EXT4-fs: Ignoring nobh option - "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002340 "its supported only with writeback mode\n");
2341 clear_opt(sbi->s_mount_opt, NOBH);
2342 }
2343 }
2344 /*
Mingming Caodab291a2006-10-11 01:21:01 -07002345 * The jbd2_journal_load will have done any necessary log recovery,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002346 * so we can safely mount the rest of the filesystem now.
2347 */
2348
David Howells1d1fe1e2008-02-07 00:15:37 -08002349 root = ext4_iget(sb, EXT4_ROOT_INO);
2350 if (IS_ERR(root)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002351 printk(KERN_ERR "EXT4-fs: get root inode failed\n");
David Howells1d1fe1e2008-02-07 00:15:37 -08002352 ret = PTR_ERR(root);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002353 goto failed_mount4;
2354 }
2355 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
David Howells1d1fe1e2008-02-07 00:15:37 -08002356 iput(root);
Mingming Cao617ba132006-10-11 01:20:53 -07002357 printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002358 goto failed_mount4;
2359 }
David Howells1d1fe1e2008-02-07 00:15:37 -08002360 sb->s_root = d_alloc_root(root);
2361 if (!sb->s_root) {
2362 printk(KERN_ERR "EXT4-fs: get root dentry failed\n");
2363 iput(root);
2364 ret = -ENOMEM;
2365 goto failed_mount4;
2366 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002367
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002368 ext4_setup_super(sb, es, sb->s_flags & MS_RDONLY);
Kalpak Shahef7f3832007-07-18 09:15:20 -04002369
2370 /* determine the minimum size of new large inodes, if present */
2371 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
2372 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
2373 EXT4_GOOD_OLD_INODE_SIZE;
2374 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
2375 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
2376 if (sbi->s_want_extra_isize <
2377 le16_to_cpu(es->s_want_extra_isize))
2378 sbi->s_want_extra_isize =
2379 le16_to_cpu(es->s_want_extra_isize);
2380 if (sbi->s_want_extra_isize <
2381 le16_to_cpu(es->s_min_extra_isize))
2382 sbi->s_want_extra_isize =
2383 le16_to_cpu(es->s_min_extra_isize);
2384 }
2385 }
2386 /* Check if enough inode space is available */
2387 if (EXT4_GOOD_OLD_INODE_SIZE + sbi->s_want_extra_isize >
2388 sbi->s_inode_size) {
2389 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
2390 EXT4_GOOD_OLD_INODE_SIZE;
2391 printk(KERN_INFO "EXT4-fs: required extra inode space not"
2392 "available.\n");
2393 }
2394
Aneesh Kumar K.Vc2774d82008-10-10 20:07:20 -04002395 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
2396 printk(KERN_WARNING "EXT4-fs: Ignoring delalloc option - "
2397 "requested data journaling mode\n");
2398 clear_opt(sbi->s_mount_opt, DELALLOC);
2399 } else if (test_opt(sb, DELALLOC))
2400 printk(KERN_INFO "EXT4-fs: delayed allocation enabled\n");
2401
2402 ext4_ext_init(sb);
2403 err = ext4_mb_init(sb, needs_recovery);
2404 if (err) {
2405 printk(KERN_ERR "EXT4-fs: failed to initalize mballoc (%d)\n",
2406 err);
2407 goto failed_mount4;
2408 }
2409
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002410 /*
2411 * akpm: core read_super() calls in here with the superblock locked.
2412 * That deadlocks, because orphan cleanup needs to lock the superblock
2413 * in numerous places. Here we just pop the lock - it's relatively
2414 * harmless, because we are now ready to accept write_super() requests,
2415 * and aviro says that's the only reason for hanging onto the
2416 * superblock lock.
2417 */
Mingming Cao617ba132006-10-11 01:20:53 -07002418 EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
2419 ext4_orphan_cleanup(sb, es);
2420 EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002421 if (needs_recovery)
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002422 printk(KERN_INFO "EXT4-fs: recovery complete.\n");
Mingming Cao617ba132006-10-11 01:20:53 -07002423 ext4_mark_recovery_complete(sb, es);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002424 printk(KERN_INFO "EXT4-fs: mounted filesystem with %s data mode.\n",
2425 test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ? "journal":
2426 test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA ? "ordered":
2427 "writeback");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002428
2429 lock_kernel();
2430 return 0;
2431
Mingming Cao617ba132006-10-11 01:20:53 -07002432cantfind_ext4:
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002433 if (!silent)
Mingming Cao617ba132006-10-11 01:20:53 -07002434 printk(KERN_ERR "VFS: Can't find ext4 filesystem on dev %s.\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002435 sb->s_id);
2436 goto failed_mount;
2437
2438failed_mount4:
Mingming Caodab291a2006-10-11 01:21:01 -07002439 jbd2_journal_destroy(sbi->s_journal);
Jan Kara47b4a502008-07-11 19:27:31 -04002440 sbi->s_journal = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002441failed_mount3:
2442 percpu_counter_destroy(&sbi->s_freeblocks_counter);
2443 percpu_counter_destroy(&sbi->s_freeinodes_counter);
2444 percpu_counter_destroy(&sbi->s_dirs_counter);
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -04002445 percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002446failed_mount2:
2447 for (i = 0; i < db_count; i++)
2448 brelse(sbi->s_group_desc[i]);
2449 kfree(sbi->s_group_desc);
2450failed_mount:
Theodore Ts'o240799c2008-10-09 23:53:47 -04002451 if (sbi->s_proc) {
2452 remove_proc_entry("inode_readahead_blks", sbi->s_proc);
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04002453 remove_proc_entry(sb->s_id, ext4_proc_root);
Theodore Ts'o240799c2008-10-09 23:53:47 -04002454 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002455#ifdef CONFIG_QUOTA
2456 for (i = 0; i < MAXQUOTAS; i++)
2457 kfree(sbi->s_qf_names[i]);
2458#endif
Mingming Cao617ba132006-10-11 01:20:53 -07002459 ext4_blkdev_remove(sbi);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002460 brelse(bh);
2461out_fail:
2462 sb->s_fs_info = NULL;
2463 kfree(sbi);
2464 lock_kernel();
David Howells1d1fe1e2008-02-07 00:15:37 -08002465 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002466}
2467
2468/*
2469 * Setup any per-fs journal parameters now. We'll do this both on
2470 * initial mount, once the journal has been initialised but before we've
2471 * done any recovery; and again on any subsequent remount.
2472 */
Mingming Cao617ba132006-10-11 01:20:53 -07002473static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002474{
Mingming Cao617ba132006-10-11 01:20:53 -07002475 struct ext4_sb_info *sbi = EXT4_SB(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002476
2477 if (sbi->s_commit_interval)
2478 journal->j_commit_interval = sbi->s_commit_interval;
Mingming Cao617ba132006-10-11 01:20:53 -07002479 /* We could also set up an ext4-specific default for the commit
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002480 * interval here, but for now we'll just fall back to the jbd
2481 * default. */
2482
2483 spin_lock(&journal->j_state_lock);
2484 if (test_opt(sb, BARRIER))
Mingming Caodab291a2006-10-11 01:21:01 -07002485 journal->j_flags |= JBD2_BARRIER;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002486 else
Mingming Caodab291a2006-10-11 01:21:01 -07002487 journal->j_flags &= ~JBD2_BARRIER;
Hidehiro Kawai5bf56832008-10-10 22:12:43 -04002488 if (test_opt(sb, DATA_ERR_ABORT))
2489 journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
2490 else
2491 journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002492 spin_unlock(&journal->j_state_lock);
2493}
2494
Mingming Cao617ba132006-10-11 01:20:53 -07002495static journal_t *ext4_get_journal(struct super_block *sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002496 unsigned int journal_inum)
2497{
2498 struct inode *journal_inode;
2499 journal_t *journal;
2500
2501 /* First, test for the existence of a valid inode on disk. Bad
2502 * things happen if we iget() an unused inode, as the subsequent
2503 * iput() will try to delete it. */
2504
David Howells1d1fe1e2008-02-07 00:15:37 -08002505 journal_inode = ext4_iget(sb, journal_inum);
2506 if (IS_ERR(journal_inode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002507 printk(KERN_ERR "EXT4-fs: no journal found.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002508 return NULL;
2509 }
2510 if (!journal_inode->i_nlink) {
2511 make_bad_inode(journal_inode);
2512 iput(journal_inode);
Mingming Cao617ba132006-10-11 01:20:53 -07002513 printk(KERN_ERR "EXT4-fs: journal inode is deleted.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002514 return NULL;
2515 }
2516
Theodore Ts'oe5f8eab82008-09-08 22:25:04 -04002517 jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002518 journal_inode, journal_inode->i_size);
David Howells1d1fe1e2008-02-07 00:15:37 -08002519 if (!S_ISREG(journal_inode->i_mode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002520 printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002521 iput(journal_inode);
2522 return NULL;
2523 }
2524
Mingming Caodab291a2006-10-11 01:21:01 -07002525 journal = jbd2_journal_init_inode(journal_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002526 if (!journal) {
Mingming Cao617ba132006-10-11 01:20:53 -07002527 printk(KERN_ERR "EXT4-fs: Could not load journal inode\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002528 iput(journal_inode);
2529 return NULL;
2530 }
2531 journal->j_private = sb;
Mingming Cao617ba132006-10-11 01:20:53 -07002532 ext4_init_journal_params(sb, journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002533 return journal;
2534}
2535
Mingming Cao617ba132006-10-11 01:20:53 -07002536static journal_t *ext4_get_dev_journal(struct super_block *sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002537 dev_t j_dev)
2538{
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002539 struct buffer_head *bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002540 journal_t *journal;
Mingming Cao617ba132006-10-11 01:20:53 -07002541 ext4_fsblk_t start;
2542 ext4_fsblk_t len;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002543 int hblock, blocksize;
Mingming Cao617ba132006-10-11 01:20:53 -07002544 ext4_fsblk_t sb_block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002545 unsigned long offset;
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002546 struct ext4_super_block *es;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002547 struct block_device *bdev;
2548
Mingming Cao617ba132006-10-11 01:20:53 -07002549 bdev = ext4_blkdev_get(j_dev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002550 if (bdev == NULL)
2551 return NULL;
2552
2553 if (bd_claim(bdev, sb)) {
2554 printk(KERN_ERR
Dave Kleikamp8c55e202007-05-24 13:04:54 -04002555 "EXT4: failed to claim external journal device.\n");
Al Viro9a1c3542008-02-22 20:40:24 -05002556 blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002557 return NULL;
2558 }
2559
2560 blocksize = sb->s_blocksize;
2561 hblock = bdev_hardsect_size(bdev);
2562 if (blocksize < hblock) {
2563 printk(KERN_ERR
Mingming Cao617ba132006-10-11 01:20:53 -07002564 "EXT4-fs: blocksize too small for journal device.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002565 goto out_bdev;
2566 }
2567
Mingming Cao617ba132006-10-11 01:20:53 -07002568 sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
2569 offset = EXT4_MIN_BLOCK_SIZE % blocksize;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002570 set_blocksize(bdev, blocksize);
2571 if (!(bh = __bread(bdev, sb_block, blocksize))) {
Mingming Cao617ba132006-10-11 01:20:53 -07002572 printk(KERN_ERR "EXT4-fs: couldn't read superblock of "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002573 "external journal\n");
2574 goto out_bdev;
2575 }
2576
Mingming Cao617ba132006-10-11 01:20:53 -07002577 es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
2578 if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002579 !(le32_to_cpu(es->s_feature_incompat) &
Mingming Cao617ba132006-10-11 01:20:53 -07002580 EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
2581 printk(KERN_ERR "EXT4-fs: external journal has "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002582 "bad superblock\n");
2583 brelse(bh);
2584 goto out_bdev;
2585 }
2586
Mingming Cao617ba132006-10-11 01:20:53 -07002587 if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
2588 printk(KERN_ERR "EXT4-fs: journal UUID does not match\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002589 brelse(bh);
2590 goto out_bdev;
2591 }
2592
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002593 len = ext4_blocks_count(es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002594 start = sb_block + 1;
2595 brelse(bh); /* we're done with the superblock */
2596
Mingming Caodab291a2006-10-11 01:21:01 -07002597 journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002598 start, len, blocksize);
2599 if (!journal) {
Mingming Cao617ba132006-10-11 01:20:53 -07002600 printk(KERN_ERR "EXT4-fs: failed to create device journal\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002601 goto out_bdev;
2602 }
2603 journal->j_private = sb;
2604 ll_rw_block(READ, 1, &journal->j_sb_buffer);
2605 wait_on_buffer(journal->j_sb_buffer);
2606 if (!buffer_uptodate(journal->j_sb_buffer)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002607 printk(KERN_ERR "EXT4-fs: I/O error on journal device\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002608 goto out_journal;
2609 }
2610 if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
Mingming Cao617ba132006-10-11 01:20:53 -07002611 printk(KERN_ERR "EXT4-fs: External journal has more than one "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002612 "user (unsupported) - %d\n",
2613 be32_to_cpu(journal->j_superblock->s_nr_users));
2614 goto out_journal;
2615 }
Mingming Cao617ba132006-10-11 01:20:53 -07002616 EXT4_SB(sb)->journal_bdev = bdev;
2617 ext4_init_journal_params(sb, journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002618 return journal;
2619out_journal:
Mingming Caodab291a2006-10-11 01:21:01 -07002620 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002621out_bdev:
Mingming Cao617ba132006-10-11 01:20:53 -07002622 ext4_blkdev_put(bdev);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002623 return NULL;
2624}
2625
Mingming Cao617ba132006-10-11 01:20:53 -07002626static int ext4_load_journal(struct super_block *sb,
2627 struct ext4_super_block *es,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002628 unsigned long journal_devnum)
2629{
2630 journal_t *journal;
2631 unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
2632 dev_t journal_dev;
2633 int err = 0;
2634 int really_read_only;
2635
2636 if (journal_devnum &&
2637 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002638 printk(KERN_INFO "EXT4-fs: external journal device major/minor "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002639 "numbers have changed\n");
2640 journal_dev = new_decode_dev(journal_devnum);
2641 } else
2642 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
2643
2644 really_read_only = bdev_read_only(sb->s_bdev);
2645
2646 /*
2647 * Are we loading a blank journal or performing recovery after a
2648 * crash? For recovery, we need to check in advance whether we
2649 * can get read-write access to the device.
2650 */
2651
Mingming Cao617ba132006-10-11 01:20:53 -07002652 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002653 if (sb->s_flags & MS_RDONLY) {
Mingming Cao617ba132006-10-11 01:20:53 -07002654 printk(KERN_INFO "EXT4-fs: INFO: recovery "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002655 "required on readonly filesystem.\n");
2656 if (really_read_only) {
Mingming Cao617ba132006-10-11 01:20:53 -07002657 printk(KERN_ERR "EXT4-fs: write access "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002658 "unavailable, cannot proceed.\n");
2659 return -EROFS;
2660 }
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002661 printk(KERN_INFO "EXT4-fs: write access will "
2662 "be enabled during recovery.\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002663 }
2664 }
2665
2666 if (journal_inum && journal_dev) {
Mingming Cao617ba132006-10-11 01:20:53 -07002667 printk(KERN_ERR "EXT4-fs: filesystem has both journal "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002668 "and inode journals!\n");
2669 return -EINVAL;
2670 }
2671
2672 if (journal_inum) {
Mingming Cao617ba132006-10-11 01:20:53 -07002673 if (!(journal = ext4_get_journal(sb, journal_inum)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002674 return -EINVAL;
2675 } else {
Mingming Cao617ba132006-10-11 01:20:53 -07002676 if (!(journal = ext4_get_dev_journal(sb, journal_dev)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002677 return -EINVAL;
2678 }
2679
Theodore Ts'o4776004f2008-09-08 23:00:52 -04002680 if (journal->j_flags & JBD2_BARRIER)
2681 printk(KERN_INFO "EXT4-fs: barriers enabled\n");
2682 else
2683 printk(KERN_INFO "EXT4-fs: barriers disabled\n");
2684
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002685 if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
Mingming Caodab291a2006-10-11 01:21:01 -07002686 err = jbd2_journal_update_format(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002687 if (err) {
Mingming Cao617ba132006-10-11 01:20:53 -07002688 printk(KERN_ERR "EXT4-fs: error updating journal.\n");
Mingming Caodab291a2006-10-11 01:21:01 -07002689 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002690 return err;
2691 }
2692 }
2693
Mingming Cao617ba132006-10-11 01:20:53 -07002694 if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER))
Mingming Caodab291a2006-10-11 01:21:01 -07002695 err = jbd2_journal_wipe(journal, !really_read_only);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002696 if (!err)
Mingming Caodab291a2006-10-11 01:21:01 -07002697 err = jbd2_journal_load(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002698
2699 if (err) {
Mingming Cao617ba132006-10-11 01:20:53 -07002700 printk(KERN_ERR "EXT4-fs: error loading journal.\n");
Mingming Caodab291a2006-10-11 01:21:01 -07002701 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002702 return err;
2703 }
2704
Mingming Cao617ba132006-10-11 01:20:53 -07002705 EXT4_SB(sb)->s_journal = journal;
2706 ext4_clear_journal_err(sb, es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002707
2708 if (journal_devnum &&
2709 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
2710 es->s_journal_dev = cpu_to_le32(journal_devnum);
2711 sb->s_dirt = 1;
2712
2713 /* Make sure we flush the recovery flag to disk. */
Mingming Cao617ba132006-10-11 01:20:53 -07002714 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002715 }
2716
2717 return 0;
2718}
2719
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002720static int ext4_create_journal(struct super_block *sb,
2721 struct ext4_super_block *es,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002722 unsigned int journal_inum)
2723{
2724 journal_t *journal;
Borislav Petkov6c675bd2007-07-15 23:41:45 -07002725 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002726
2727 if (sb->s_flags & MS_RDONLY) {
Mingming Cao617ba132006-10-11 01:20:53 -07002728 printk(KERN_ERR "EXT4-fs: readonly filesystem when trying to "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002729 "create journal.\n");
2730 return -EROFS;
2731 }
2732
Borislav Petkov6c675bd2007-07-15 23:41:45 -07002733 journal = ext4_get_journal(sb, journal_inum);
2734 if (!journal)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002735 return -EINVAL;
2736
Mingming Cao617ba132006-10-11 01:20:53 -07002737 printk(KERN_INFO "EXT4-fs: creating new journal on inode %u\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002738 journal_inum);
2739
Borislav Petkov6c675bd2007-07-15 23:41:45 -07002740 err = jbd2_journal_create(journal);
2741 if (err) {
Mingming Cao617ba132006-10-11 01:20:53 -07002742 printk(KERN_ERR "EXT4-fs: error creating journal.\n");
Mingming Caodab291a2006-10-11 01:21:01 -07002743 jbd2_journal_destroy(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002744 return -EIO;
2745 }
2746
Mingming Cao617ba132006-10-11 01:20:53 -07002747 EXT4_SB(sb)->s_journal = journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002748
Mingming Cao617ba132006-10-11 01:20:53 -07002749 ext4_update_dynamic_rev(sb);
2750 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2751 EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002752
2753 es->s_journal_inum = cpu_to_le32(journal_inum);
2754 sb->s_dirt = 1;
2755
2756 /* Make sure we flush the recovery flag to disk. */
Mingming Cao617ba132006-10-11 01:20:53 -07002757 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002758
2759 return 0;
2760}
2761
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002762static void ext4_commit_super(struct super_block *sb,
2763 struct ext4_super_block *es, int sync)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002764{
Mingming Cao617ba132006-10-11 01:20:53 -07002765 struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002766
2767 if (!sbh)
2768 return;
Theodore Ts'o914258b2008-10-06 21:35:40 -04002769 if (buffer_write_io_error(sbh)) {
2770 /*
2771 * Oh, dear. A previous attempt to write the
2772 * superblock failed. This could happen because the
2773 * USB device was yanked out. Or it could happen to
2774 * be a transient write error and maybe the block will
2775 * be remapped. Nothing we can do but to retry the
2776 * write and hope for the best.
2777 */
2778 printk(KERN_ERR "ext4: previous I/O error to "
2779 "superblock detected for %s.\n", sb->s_id);
2780 clear_buffer_write_io_error(sbh);
2781 set_buffer_uptodate(sbh);
2782 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002783 es->s_wtime = cpu_to_le32(get_seconds());
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002784 ext4_free_blocks_count_set(es, ext4_count_free_blocks(sb));
Mingming Cao617ba132006-10-11 01:20:53 -07002785 es->s_free_inodes_count = cpu_to_le32(ext4_count_free_inodes(sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002786 BUFFER_TRACE(sbh, "marking dirty");
2787 mark_buffer_dirty(sbh);
Theodore Ts'o914258b2008-10-06 21:35:40 -04002788 if (sync) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002789 sync_dirty_buffer(sbh);
Theodore Ts'o914258b2008-10-06 21:35:40 -04002790 if (buffer_write_io_error(sbh)) {
2791 printk(KERN_ERR "ext4: I/O error while writing "
2792 "superblock for %s.\n", sb->s_id);
2793 clear_buffer_write_io_error(sbh);
2794 set_buffer_uptodate(sbh);
2795 }
2796 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002797}
2798
2799
2800/*
2801 * Have we just finished recovery? If so, and if we are mounting (or
2802 * remounting) the filesystem readonly, then we will end up with a
2803 * consistent fs on disk. Record that fact.
2804 */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002805static void ext4_mark_recovery_complete(struct super_block *sb,
2806 struct ext4_super_block *es)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002807{
Mingming Cao617ba132006-10-11 01:20:53 -07002808 journal_t *journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002809
Mingming Caodab291a2006-10-11 01:21:01 -07002810 jbd2_journal_lock_updates(journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04002811 if (jbd2_journal_flush(journal) < 0)
2812 goto out;
2813
Jan Kara32c37732007-07-15 23:41:09 -07002814 lock_super(sb);
Mingming Cao617ba132006-10-11 01:20:53 -07002815 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002816 sb->s_flags & MS_RDONLY) {
Mingming Cao617ba132006-10-11 01:20:53 -07002817 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002818 sb->s_dirt = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07002819 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002820 }
Jan Kara32c37732007-07-15 23:41:09 -07002821 unlock_super(sb);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04002822
2823out:
Mingming Caodab291a2006-10-11 01:21:01 -07002824 jbd2_journal_unlock_updates(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002825}
2826
2827/*
2828 * If we are mounting (or read-write remounting) a filesystem whose journal
2829 * has recorded an error from a previous lifetime, move that error to the
2830 * main filesystem now.
2831 */
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002832static void ext4_clear_journal_err(struct super_block *sb,
2833 struct ext4_super_block *es)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002834{
2835 journal_t *journal;
2836 int j_errno;
2837 const char *errstr;
2838
Mingming Cao617ba132006-10-11 01:20:53 -07002839 journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002840
2841 /*
2842 * Now check for any error status which may have been recorded in the
Mingming Cao617ba132006-10-11 01:20:53 -07002843 * journal by a prior ext4_error() or ext4_abort()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002844 */
2845
Mingming Caodab291a2006-10-11 01:21:01 -07002846 j_errno = jbd2_journal_errno(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002847 if (j_errno) {
2848 char nbuf[16];
2849
Mingming Cao617ba132006-10-11 01:20:53 -07002850 errstr = ext4_decode_error(sb, j_errno, nbuf);
Harvey Harrison46e665e2008-04-17 10:38:59 -04002851 ext4_warning(sb, __func__, "Filesystem error recorded "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002852 "from previous mount: %s", errstr);
Harvey Harrison46e665e2008-04-17 10:38:59 -04002853 ext4_warning(sb, __func__, "Marking fs in need of "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002854 "filesystem check.");
2855
Mingming Cao617ba132006-10-11 01:20:53 -07002856 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
2857 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002858 ext4_commit_super(sb, es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002859
Mingming Caodab291a2006-10-11 01:21:01 -07002860 jbd2_journal_clear_err(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002861 }
2862}
2863
2864/*
2865 * Force the running and committing transactions to commit,
2866 * and wait on the commit.
2867 */
Mingming Cao617ba132006-10-11 01:20:53 -07002868int ext4_force_commit(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002869{
2870 journal_t *journal;
2871 int ret;
2872
2873 if (sb->s_flags & MS_RDONLY)
2874 return 0;
2875
Mingming Cao617ba132006-10-11 01:20:53 -07002876 journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002877 sb->s_dirt = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07002878 ret = ext4_journal_force_commit(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002879 return ret;
2880}
2881
2882/*
Mingming Cao617ba132006-10-11 01:20:53 -07002883 * Ext4 always journals updates to the superblock itself, so we don't
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002884 * have to propagate any other updates to the superblock on disk at this
2885 * point. Just start an async writeback to get the buffers on their way
2886 * to the disk.
2887 *
2888 * This implicitly triggers the writebehind on sync().
2889 */
2890
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002891static void ext4_write_super(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002892{
2893 if (mutex_trylock(&sb->s_lock) != 0)
2894 BUG();
2895 sb->s_dirt = 0;
2896}
2897
Mingming Cao617ba132006-10-11 01:20:53 -07002898static int ext4_sync_fs(struct super_block *sb, int wait)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002899{
2900 tid_t target;
2901
Theodore Ts'oede86cc2008-10-05 20:50:06 -04002902 trace_mark(ext4_sync_fs, "dev %s wait %d", sb->s_id, wait);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002903 sb->s_dirt = 0;
Mingming Caodab291a2006-10-11 01:21:01 -07002904 if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002905 if (wait)
Mingming Caodab291a2006-10-11 01:21:01 -07002906 jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002907 }
2908 return 0;
2909}
2910
2911/*
2912 * LVM calls this function before a (read-only) snapshot is created. This
2913 * gives us a chance to flush the journal completely and mark the fs clean.
2914 */
Mingming Cao617ba132006-10-11 01:20:53 -07002915static void ext4_write_super_lockfs(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002916{
2917 sb->s_dirt = 0;
2918
2919 if (!(sb->s_flags & MS_RDONLY)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002920 journal_t *journal = EXT4_SB(sb)->s_journal;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002921
2922 /* Now we set up the journal barrier. */
Mingming Caodab291a2006-10-11 01:21:01 -07002923 jbd2_journal_lock_updates(journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04002924
2925 /*
2926 * We don't want to clear needs_recovery flag when we failed
2927 * to flush the journal.
2928 */
2929 if (jbd2_journal_flush(journal) < 0)
2930 return;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002931
2932 /* Journal blocked and flushed, clear needs_recovery flag. */
Mingming Cao617ba132006-10-11 01:20:53 -07002933 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2934 ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002935 }
2936}
2937
2938/*
2939 * Called by LVM after the snapshot is done. We need to reset the RECOVER
2940 * flag here, even though the filesystem is not technically dirty yet.
2941 */
Mingming Cao617ba132006-10-11 01:20:53 -07002942static void ext4_unlockfs(struct super_block *sb)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002943{
2944 if (!(sb->s_flags & MS_RDONLY)) {
2945 lock_super(sb);
2946 /* Reser the needs_recovery flag before the fs is unlocked. */
Mingming Cao617ba132006-10-11 01:20:53 -07002947 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2948 ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002949 unlock_super(sb);
Mingming Caodab291a2006-10-11 01:21:01 -07002950 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002951 }
2952}
2953
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002954static int ext4_remount(struct super_block *sb, int *flags, char *data)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002955{
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04002956 struct ext4_super_block *es;
Mingming Cao617ba132006-10-11 01:20:53 -07002957 struct ext4_sb_info *sbi = EXT4_SB(sb);
2958 ext4_fsblk_t n_blocks_count = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002959 unsigned long old_sb_flags;
Mingming Cao617ba132006-10-11 01:20:53 -07002960 struct ext4_mount_options old_opts;
Theodore Ts'o8a266462008-07-26 14:34:21 -04002961 ext4_group_t g;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002962 int err;
2963#ifdef CONFIG_QUOTA
2964 int i;
2965#endif
2966
2967 /* Store the original options */
2968 old_sb_flags = sb->s_flags;
2969 old_opts.s_mount_opt = sbi->s_mount_opt;
2970 old_opts.s_resuid = sbi->s_resuid;
2971 old_opts.s_resgid = sbi->s_resgid;
2972 old_opts.s_commit_interval = sbi->s_commit_interval;
2973#ifdef CONFIG_QUOTA
2974 old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
2975 for (i = 0; i < MAXQUOTAS; i++)
2976 old_opts.s_qf_names[i] = sbi->s_qf_names[i];
2977#endif
2978
2979 /*
2980 * Allow the "check" option to be passed as a remount option.
2981 */
2982 if (!parse_options(data, sb, NULL, NULL, &n_blocks_count, 1)) {
2983 err = -EINVAL;
2984 goto restore_opts;
2985 }
2986
Mingming Cao617ba132006-10-11 01:20:53 -07002987 if (sbi->s_mount_opt & EXT4_MOUNT_ABORT)
Harvey Harrison46e665e2008-04-17 10:38:59 -04002988 ext4_abort(sb, __func__, "Abort forced by user");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002989
2990 sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
Mingming Cao617ba132006-10-11 01:20:53 -07002991 ((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002992
2993 es = sbi->s_es;
2994
Mingming Cao617ba132006-10-11 01:20:53 -07002995 ext4_init_journal_params(sb, sbi->s_journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002996
2997 if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07002998 n_blocks_count > ext4_blocks_count(es)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002999 if (sbi->s_mount_opt & EXT4_MOUNT_ABORT) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003000 err = -EROFS;
3001 goto restore_opts;
3002 }
3003
3004 if (*flags & MS_RDONLY) {
3005 /*
3006 * First of all, the unconditional stuff we have to do
3007 * to disable replay of the journal when we next remount
3008 */
3009 sb->s_flags |= MS_RDONLY;
3010
3011 /*
3012 * OK, test if we are remounting a valid rw partition
3013 * readonly, and if so set the rdonly flag and then
3014 * mark the partition as valid again.
3015 */
Mingming Cao617ba132006-10-11 01:20:53 -07003016 if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
3017 (sbi->s_mount_state & EXT4_VALID_FS))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003018 es->s_state = cpu_to_le16(sbi->s_mount_state);
3019
Jan Kara32c37732007-07-15 23:41:09 -07003020 /*
3021 * We have to unlock super so that we can wait for
3022 * transactions.
3023 */
3024 unlock_super(sb);
Mingming Cao617ba132006-10-11 01:20:53 -07003025 ext4_mark_recovery_complete(sb, es);
Jan Kara32c37732007-07-15 23:41:09 -07003026 lock_super(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003027 } else {
3028 __le32 ret;
Mingming Cao617ba132006-10-11 01:20:53 -07003029 if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
3030 ~EXT4_FEATURE_RO_COMPAT_SUPP))) {
3031 printk(KERN_WARNING "EXT4-fs: %s: couldn't "
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003032 "remount RDWR because of unsupported "
3033 "optional features (%x).\n",
3034 sb->s_id, le32_to_cpu(ret));
3035 err = -EROFS;
3036 goto restore_opts;
3037 }
Eric Sandeenead65962007-02-10 01:46:08 -08003038
3039 /*
Theodore Ts'o8a266462008-07-26 14:34:21 -04003040 * Make sure the group descriptor checksums
3041 * are sane. If they aren't, refuse to
3042 * remount r/w.
3043 */
3044 for (g = 0; g < sbi->s_groups_count; g++) {
3045 struct ext4_group_desc *gdp =
3046 ext4_get_group_desc(sb, g, NULL);
3047
3048 if (!ext4_group_desc_csum_verify(sbi, g, gdp)) {
3049 printk(KERN_ERR
3050 "EXT4-fs: ext4_remount: "
3051 "Checksum for group %lu failed (%u!=%u)\n",
3052 g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)),
3053 le16_to_cpu(gdp->bg_checksum));
3054 err = -EINVAL;
3055 goto restore_opts;
3056 }
3057 }
3058
3059 /*
Eric Sandeenead65962007-02-10 01:46:08 -08003060 * If we have an unprocessed orphan list hanging
3061 * around from a previously readonly bdev mount,
3062 * require a full umount/remount for now.
3063 */
3064 if (es->s_last_orphan) {
3065 printk(KERN_WARNING "EXT4-fs: %s: couldn't "
3066 "remount RDWR because of unprocessed "
3067 "orphan inode list. Please "
3068 "umount/remount instead.\n",
3069 sb->s_id);
3070 err = -EINVAL;
3071 goto restore_opts;
3072 }
3073
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003074 /*
3075 * Mounting a RDONLY partition read-write, so reread
3076 * and store the current valid flag. (It may have
3077 * been changed by e2fsck since we originally mounted
3078 * the partition.)
3079 */
Mingming Cao617ba132006-10-11 01:20:53 -07003080 ext4_clear_journal_err(sb, es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003081 sbi->s_mount_state = le16_to_cpu(es->s_state);
Mingming Cao617ba132006-10-11 01:20:53 -07003082 if ((err = ext4_group_extend(sb, es, n_blocks_count)))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003083 goto restore_opts;
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003084 if (!ext4_setup_super(sb, es, 0))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003085 sb->s_flags &= ~MS_RDONLY;
3086 }
3087 }
3088#ifdef CONFIG_QUOTA
3089 /* Release old quota file names */
3090 for (i = 0; i < MAXQUOTAS; i++)
3091 if (old_opts.s_qf_names[i] &&
3092 old_opts.s_qf_names[i] != sbi->s_qf_names[i])
3093 kfree(old_opts.s_qf_names[i]);
3094#endif
3095 return 0;
3096restore_opts:
3097 sb->s_flags = old_sb_flags;
3098 sbi->s_mount_opt = old_opts.s_mount_opt;
3099 sbi->s_resuid = old_opts.s_resuid;
3100 sbi->s_resgid = old_opts.s_resgid;
3101 sbi->s_commit_interval = old_opts.s_commit_interval;
3102#ifdef CONFIG_QUOTA
3103 sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
3104 for (i = 0; i < MAXQUOTAS; i++) {
3105 if (sbi->s_qf_names[i] &&
3106 old_opts.s_qf_names[i] != sbi->s_qf_names[i])
3107 kfree(sbi->s_qf_names[i]);
3108 sbi->s_qf_names[i] = old_opts.s_qf_names[i];
3109 }
3110#endif
3111 return err;
3112}
3113
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003114static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003115{
3116 struct super_block *sb = dentry->d_sb;
Mingming Cao617ba132006-10-11 01:20:53 -07003117 struct ext4_sb_info *sbi = EXT4_SB(sb);
3118 struct ext4_super_block *es = sbi->s_es;
Pekka Enberg960cc392006-12-06 20:35:29 -08003119 u64 fsid;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003120
Badari Pulavarty5e700302007-07-15 23:42:00 -07003121 if (test_opt(sb, MINIX_DF)) {
3122 sbi->s_overhead_last = 0;
Aneesh Kumar K.V6bc9fef2007-10-16 18:38:25 -04003123 } else if (sbi->s_blocks_last != ext4_blocks_count(es)) {
Avantika Mathurfd2d4292008-01-28 23:58:27 -05003124 ext4_group_t ngroups = sbi->s_groups_count, i;
Badari Pulavarty5e700302007-07-15 23:42:00 -07003125 ext4_fsblk_t overhead = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003126 smp_rmb();
3127
3128 /*
Badari Pulavarty5e700302007-07-15 23:42:00 -07003129 * Compute the overhead (FS structures). This is constant
3130 * for a given filesystem unless the number of block groups
3131 * changes so we cache the previous value until it does.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003132 */
3133
3134 /*
3135 * All of the blocks before first_data_block are
3136 * overhead
3137 */
3138 overhead = le32_to_cpu(es->s_first_data_block);
3139
3140 /*
3141 * Add the overhead attributed to the superblock and
3142 * block group descriptors. If the sparse superblocks
3143 * feature is turned on, then not all groups have this.
3144 */
3145 for (i = 0; i < ngroups; i++) {
Mingming Cao617ba132006-10-11 01:20:53 -07003146 overhead += ext4_bg_has_super(sb, i) +
3147 ext4_bg_num_gdb(sb, i);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003148 cond_resched();
3149 }
3150
3151 /*
3152 * Every block group has an inode bitmap, a block
3153 * bitmap, and an inode table.
3154 */
Badari Pulavarty5e700302007-07-15 23:42:00 -07003155 overhead += ngroups * (2 + sbi->s_itb_per_group);
3156 sbi->s_overhead_last = overhead;
3157 smp_wmb();
Aneesh Kumar K.V6bc9fef2007-10-16 18:38:25 -04003158 sbi->s_blocks_last = ext4_blocks_count(es);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003159 }
3160
Mingming Cao617ba132006-10-11 01:20:53 -07003161 buf->f_type = EXT4_SUPER_MAGIC;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003162 buf->f_bsize = sb->s_blocksize;
Badari Pulavarty5e700302007-07-15 23:42:00 -07003163 buf->f_blocks = ext4_blocks_count(es) - sbi->s_overhead_last;
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -04003164 buf->f_bfree = percpu_counter_sum_positive(&sbi->s_freeblocks_counter) -
3165 percpu_counter_sum_positive(&sbi->s_dirtyblocks_counter);
Aneesh Kumar K.V308ba3e2007-10-16 18:38:25 -04003166 ext4_free_blocks_count_set(es, buf->f_bfree);
Laurent Vivierbd81d8e2006-10-11 01:21:10 -07003167 buf->f_bavail = buf->f_bfree - ext4_r_blocks_count(es);
3168 if (buf->f_bfree < ext4_r_blocks_count(es))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003169 buf->f_bavail = 0;
3170 buf->f_files = le32_to_cpu(es->s_inodes_count);
Peter Zijlstra52d9f3b2007-10-16 23:25:44 -07003171 buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
Badari Pulavarty5e700302007-07-15 23:42:00 -07003172 es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
Mingming Cao617ba132006-10-11 01:20:53 -07003173 buf->f_namelen = EXT4_NAME_LEN;
Pekka Enberg960cc392006-12-06 20:35:29 -08003174 fsid = le64_to_cpup((void *)es->s_uuid) ^
3175 le64_to_cpup((void *)es->s_uuid + sizeof(u64));
3176 buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
3177 buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003178 return 0;
3179}
3180
3181/* Helper function for writing quotas on sync - we need to start transaction before quota file
3182 * is locked for write. Otherwise the are possible deadlocks:
3183 * Process 1 Process 2
Mingming Cao617ba132006-10-11 01:20:53 -07003184 * ext4_create() quota_sync()
Mingming Caodab291a2006-10-11 01:21:01 -07003185 * jbd2_journal_start() write_dquot()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003186 * DQUOT_INIT() down(dqio_mutex)
Mingming Caodab291a2006-10-11 01:21:01 -07003187 * down(dqio_mutex) jbd2_journal_start()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003188 *
3189 */
3190
3191#ifdef CONFIG_QUOTA
3192
3193static inline struct inode *dquot_to_inode(struct dquot *dquot)
3194{
3195 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
3196}
3197
Mingming Cao617ba132006-10-11 01:20:53 -07003198static int ext4_dquot_initialize(struct inode *inode, int type)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003199{
3200 handle_t *handle;
3201 int ret, err;
3202
3203 /* We may create quota structure so we need to reserve enough blocks */
Mingming Cao617ba132006-10-11 01:20:53 -07003204 handle = ext4_journal_start(inode, 2*EXT4_QUOTA_INIT_BLOCKS(inode->i_sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003205 if (IS_ERR(handle))
3206 return PTR_ERR(handle);
3207 ret = dquot_initialize(inode, type);
Mingming Cao617ba132006-10-11 01:20:53 -07003208 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003209 if (!ret)
3210 ret = err;
3211 return ret;
3212}
3213
Mingming Cao617ba132006-10-11 01:20:53 -07003214static int ext4_dquot_drop(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003215{
3216 handle_t *handle;
3217 int ret, err;
3218
3219 /* We may delete quota structure so we need to reserve enough blocks */
Mingming Cao617ba132006-10-11 01:20:53 -07003220 handle = ext4_journal_start(inode, 2*EXT4_QUOTA_DEL_BLOCKS(inode->i_sb));
Jan Kara2887df12008-04-29 22:02:07 -04003221 if (IS_ERR(handle)) {
3222 /*
3223 * We call dquot_drop() anyway to at least release references
3224 * to quota structures so that umount does not hang.
3225 */
3226 dquot_drop(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003227 return PTR_ERR(handle);
Jan Kara2887df12008-04-29 22:02:07 -04003228 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003229 ret = dquot_drop(inode);
Mingming Cao617ba132006-10-11 01:20:53 -07003230 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003231 if (!ret)
3232 ret = err;
3233 return ret;
3234}
3235
Mingming Cao617ba132006-10-11 01:20:53 -07003236static int ext4_write_dquot(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003237{
3238 int ret, err;
3239 handle_t *handle;
3240 struct inode *inode;
3241
3242 inode = dquot_to_inode(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003243 handle = ext4_journal_start(inode,
3244 EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003245 if (IS_ERR(handle))
3246 return PTR_ERR(handle);
3247 ret = dquot_commit(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003248 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003249 if (!ret)
3250 ret = err;
3251 return ret;
3252}
3253
Mingming Cao617ba132006-10-11 01:20:53 -07003254static int ext4_acquire_dquot(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003255{
3256 int ret, err;
3257 handle_t *handle;
3258
Mingming Cao617ba132006-10-11 01:20:53 -07003259 handle = ext4_journal_start(dquot_to_inode(dquot),
3260 EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003261 if (IS_ERR(handle))
3262 return PTR_ERR(handle);
3263 ret = dquot_acquire(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003264 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003265 if (!ret)
3266 ret = err;
3267 return ret;
3268}
3269
Mingming Cao617ba132006-10-11 01:20:53 -07003270static int ext4_release_dquot(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003271{
3272 int ret, err;
3273 handle_t *handle;
3274
Mingming Cao617ba132006-10-11 01:20:53 -07003275 handle = ext4_journal_start(dquot_to_inode(dquot),
3276 EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
Jan Kara9c3013e2007-09-11 15:23:29 -07003277 if (IS_ERR(handle)) {
3278 /* Release dquot anyway to avoid endless cycle in dqput() */
3279 dquot_release(dquot);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003280 return PTR_ERR(handle);
Jan Kara9c3013e2007-09-11 15:23:29 -07003281 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003282 ret = dquot_release(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003283 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003284 if (!ret)
3285 ret = err;
3286 return ret;
3287}
3288
Mingming Cao617ba132006-10-11 01:20:53 -07003289static int ext4_mark_dquot_dirty(struct dquot *dquot)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003290{
Jan Kara2c8be6b2008-05-13 21:27:55 -04003291 /* Are we journaling quotas? */
Mingming Cao617ba132006-10-11 01:20:53 -07003292 if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
3293 EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003294 dquot_mark_dquot_dirty(dquot);
Mingming Cao617ba132006-10-11 01:20:53 -07003295 return ext4_write_dquot(dquot);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003296 } else {
3297 return dquot_mark_dquot_dirty(dquot);
3298 }
3299}
3300
Mingming Cao617ba132006-10-11 01:20:53 -07003301static int ext4_write_info(struct super_block *sb, int type)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003302{
3303 int ret, err;
3304 handle_t *handle;
3305
3306 /* Data block + inode block */
Mingming Cao617ba132006-10-11 01:20:53 -07003307 handle = ext4_journal_start(sb->s_root->d_inode, 2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003308 if (IS_ERR(handle))
3309 return PTR_ERR(handle);
3310 ret = dquot_commit_info(sb, type);
Mingming Cao617ba132006-10-11 01:20:53 -07003311 err = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003312 if (!ret)
3313 ret = err;
3314 return ret;
3315}
3316
3317/*
3318 * Turn on quotas during mount time - we need to find
3319 * the quota file and such...
3320 */
Mingming Cao617ba132006-10-11 01:20:53 -07003321static int ext4_quota_on_mount(struct super_block *sb, int type)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003322{
Mingming Cao617ba132006-10-11 01:20:53 -07003323 return vfs_quota_on_mount(sb, EXT4_SB(sb)->s_qf_names[type],
3324 EXT4_SB(sb)->s_jquota_fmt, type);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003325}
3326
3327/*
3328 * Standard function to be called on quota_on
3329 */
Mingming Cao617ba132006-10-11 01:20:53 -07003330static int ext4_quota_on(struct super_block *sb, int type, int format_id,
Al Viro82646132008-08-02 00:57:06 -04003331 char *name, int remount)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003332{
3333 int err;
Al Viro82646132008-08-02 00:57:06 -04003334 struct path path;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003335
3336 if (!test_opt(sb, QUOTA))
3337 return -EINVAL;
Al Viro82646132008-08-02 00:57:06 -04003338 /* When remounting, no checks are needed and in fact, name is NULL */
Jan Kara06235432008-05-13 19:11:51 -04003339 if (remount)
Al Viro82646132008-08-02 00:57:06 -04003340 return vfs_quota_on(sb, type, format_id, name, remount);
Jan Kara06235432008-05-13 19:11:51 -04003341
Al Viro82646132008-08-02 00:57:06 -04003342 err = kern_path(name, LOOKUP_FOLLOW, &path);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003343 if (err)
3344 return err;
Jan Kara06235432008-05-13 19:11:51 -04003345
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003346 /* Quotafile not on the same filesystem? */
Al Viro82646132008-08-02 00:57:06 -04003347 if (path.mnt->mnt_sb != sb) {
3348 path_put(&path);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003349 return -EXDEV;
3350 }
Jan Kara06235432008-05-13 19:11:51 -04003351 /* Journaling quota? */
3352 if (EXT4_SB(sb)->s_qf_names[type]) {
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003353 /* Quotafile not in fs root? */
Al Viro82646132008-08-02 00:57:06 -04003354 if (path.dentry->d_parent != sb->s_root)
Jan Kara06235432008-05-13 19:11:51 -04003355 printk(KERN_WARNING
3356 "EXT4-fs: Quota file not on filesystem root. "
3357 "Journaled quota will not work.\n");
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -04003358 }
Jan Kara06235432008-05-13 19:11:51 -04003359
3360 /*
3361 * When we journal data on quota file, we have to flush journal to see
3362 * all updates to the file when we bypass pagecache...
3363 */
Al Viro82646132008-08-02 00:57:06 -04003364 if (ext4_should_journal_data(path.dentry->d_inode)) {
Jan Kara06235432008-05-13 19:11:51 -04003365 /*
3366 * We don't need to lock updates but journal_flush() could
3367 * otherwise be livelocked...
3368 */
3369 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04003370 err = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
Jan Kara06235432008-05-13 19:11:51 -04003371 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04003372 if (err) {
Al Viro82646132008-08-02 00:57:06 -04003373 path_put(&path);
Hidehiro Kawai7ffe1ea2008-10-10 20:29:21 -04003374 return err;
3375 }
Jan Kara06235432008-05-13 19:11:51 -04003376 }
3377
Al Viro82646132008-08-02 00:57:06 -04003378 err = vfs_quota_on_path(sb, type, format_id, &path);
3379 path_put(&path);
Al Viro77e69da2008-08-01 04:29:18 -04003380 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003381}
3382
3383/* Read data from quotafile - avoid pagecache and such because we cannot afford
3384 * acquiring the locks... As quota files are never truncated and quota code
3385 * itself serializes the operations (and noone else should touch the files)
3386 * we don't have to be afraid of races */
Mingming Cao617ba132006-10-11 01:20:53 -07003387static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003388 size_t len, loff_t off)
3389{
3390 struct inode *inode = sb_dqopt(sb)->files[type];
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05003391 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003392 int err = 0;
3393 int offset = off & (sb->s_blocksize - 1);
3394 int tocopy;
3395 size_t toread;
3396 struct buffer_head *bh;
3397 loff_t i_size = i_size_read(inode);
3398
3399 if (off > i_size)
3400 return 0;
3401 if (off+len > i_size)
3402 len = i_size-off;
3403 toread = len;
3404 while (toread > 0) {
3405 tocopy = sb->s_blocksize - offset < toread ?
3406 sb->s_blocksize - offset : toread;
Mingming Cao617ba132006-10-11 01:20:53 -07003407 bh = ext4_bread(NULL, inode, blk, 0, &err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003408 if (err)
3409 return err;
3410 if (!bh) /* A hole? */
3411 memset(data, 0, tocopy);
3412 else
3413 memcpy(data, bh->b_data+offset, tocopy);
3414 brelse(bh);
3415 offset = 0;
3416 toread -= tocopy;
3417 data += tocopy;
3418 blk++;
3419 }
3420 return len;
3421}
3422
3423/* Write to quotafile (we know the transaction is already started and has
3424 * enough credits) */
Mingming Cao617ba132006-10-11 01:20:53 -07003425static ssize_t ext4_quota_write(struct super_block *sb, int type,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003426 const char *data, size_t len, loff_t off)
3427{
3428 struct inode *inode = sb_dqopt(sb)->files[type];
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05003429 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003430 int err = 0;
3431 int offset = off & (sb->s_blocksize - 1);
3432 int tocopy;
Mingming Cao617ba132006-10-11 01:20:53 -07003433 int journal_quota = EXT4_SB(sb)->s_qf_names[type] != NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003434 size_t towrite = len;
3435 struct buffer_head *bh;
3436 handle_t *handle = journal_current_handle();
3437
Jan Kara9c3013e2007-09-11 15:23:29 -07003438 if (!handle) {
Theodore Ts'oe5f8eab82008-09-08 22:25:04 -04003439 printk(KERN_WARNING "EXT4-fs: Quota write (off=%llu, len=%llu)"
Jan Kara9c3013e2007-09-11 15:23:29 -07003440 " cancelled because transaction is not started.\n",
3441 (unsigned long long)off, (unsigned long long)len);
3442 return -EIO;
3443 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003444 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
3445 while (towrite > 0) {
3446 tocopy = sb->s_blocksize - offset < towrite ?
3447 sb->s_blocksize - offset : towrite;
Mingming Cao617ba132006-10-11 01:20:53 -07003448 bh = ext4_bread(handle, inode, blk, 1, &err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003449 if (!bh)
3450 goto out;
3451 if (journal_quota) {
Mingming Cao617ba132006-10-11 01:20:53 -07003452 err = ext4_journal_get_write_access(handle, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003453 if (err) {
3454 brelse(bh);
3455 goto out;
3456 }
3457 }
3458 lock_buffer(bh);
3459 memcpy(bh->b_data+offset, data, tocopy);
3460 flush_dcache_page(bh->b_page);
3461 unlock_buffer(bh);
3462 if (journal_quota)
Mingming Cao617ba132006-10-11 01:20:53 -07003463 err = ext4_journal_dirty_metadata(handle, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003464 else {
3465 /* Always do at least ordered writes for quotas */
Jan Kara678aaf42008-07-11 19:27:31 -04003466 err = ext4_jbd2_file_inode(handle, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003467 mark_buffer_dirty(bh);
3468 }
3469 brelse(bh);
3470 if (err)
3471 goto out;
3472 offset = 0;
3473 towrite -= tocopy;
3474 data += tocopy;
3475 blk++;
3476 }
3477out:
Jan Kara4d04e4f2008-07-04 09:59:34 -07003478 if (len == towrite) {
3479 mutex_unlock(&inode->i_mutex);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003480 return err;
Jan Kara4d04e4f2008-07-04 09:59:34 -07003481 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003482 if (inode->i_size < off+len-towrite) {
3483 i_size_write(inode, off+len-towrite);
Mingming Cao617ba132006-10-11 01:20:53 -07003484 EXT4_I(inode)->i_disksize = inode->i_size;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003485 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003486 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Mingming Cao617ba132006-10-11 01:20:53 -07003487 ext4_mark_inode_dirty(handle, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003488 mutex_unlock(&inode->i_mutex);
3489 return len - towrite;
3490}
3491
3492#endif
3493
Mingming Cao617ba132006-10-11 01:20:53 -07003494static int ext4_get_sb(struct file_system_type *fs_type,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003495 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
3496{
Mingming Cao617ba132006-10-11 01:20:53 -07003497 return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003498}
3499
Theodore Ts'o5e8814f2008-09-23 18:07:35 -04003500#ifdef CONFIG_PROC_FS
3501static int ext4_ui_proc_show(struct seq_file *m, void *v)
3502{
3503 unsigned int *p = m->private;
3504
3505 seq_printf(m, "%u\n", *p);
3506 return 0;
3507}
3508
3509static int ext4_ui_proc_open(struct inode *inode, struct file *file)
3510{
3511 return single_open(file, ext4_ui_proc_show, PDE(inode)->data);
3512}
3513
3514static ssize_t ext4_ui_proc_write(struct file *file, const char __user *buf,
3515 size_t cnt, loff_t *ppos)
3516{
3517 unsigned int *p = PDE(file->f_path.dentry->d_inode)->data;
3518 char str[32];
3519 unsigned long value;
3520
3521 if (cnt >= sizeof(str))
3522 return -EINVAL;
3523 if (copy_from_user(str, buf, cnt))
3524 return -EFAULT;
3525 value = simple_strtol(str, NULL, 0);
3526 if (value < 0)
3527 return -ERANGE;
3528 *p = value;
3529 return cnt;
3530}
3531
3532const struct file_operations ext4_ui_proc_fops = {
3533 .owner = THIS_MODULE,
3534 .open = ext4_ui_proc_open,
3535 .read = seq_read,
3536 .llseek = seq_lseek,
3537 .release = single_release,
3538 .write = ext4_ui_proc_write,
3539};
3540#endif
3541
Theodore Ts'o03010a32008-10-10 20:02:48 -04003542static struct file_system_type ext4_fs_type = {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003543 .owner = THIS_MODULE,
Theodore Ts'o03010a32008-10-10 20:02:48 -04003544 .name = "ext4",
Mingming Cao617ba132006-10-11 01:20:53 -07003545 .get_sb = ext4_get_sb,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003546 .kill_sb = kill_block_super,
3547 .fs_flags = FS_REQUIRES_DEV,
3548};
3549
Theodore Ts'o03010a32008-10-10 20:02:48 -04003550#ifdef CONFIG_EXT4DEV_COMPAT
3551static int ext4dev_get_sb(struct file_system_type *fs_type,
3552 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
3553{
3554 printk(KERN_WARNING "EXT4-fs: Update your userspace programs "
3555 "to mount using ext4\n");
3556 printk(KERN_WARNING "EXT4-fs: ext4dev backwards compatibility "
3557 "will go away by 2.6.31\n");
3558 return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
3559}
3560
3561static struct file_system_type ext4dev_fs_type = {
3562 .owner = THIS_MODULE,
3563 .name = "ext4dev",
3564 .get_sb = ext4dev_get_sb,
3565 .kill_sb = kill_block_super,
3566 .fs_flags = FS_REQUIRES_DEV,
3567};
3568MODULE_ALIAS("ext4dev");
3569#endif
3570
Mingming Cao617ba132006-10-11 01:20:53 -07003571static int __init init_ext4_fs(void)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003572{
Alex Tomasc9de5602008-01-29 00:19:52 -05003573 int err;
3574
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04003575 ext4_proc_root = proc_mkdir("fs/ext4", NULL);
Alex Tomasc9de5602008-01-29 00:19:52 -05003576 err = init_ext4_mballoc();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003577 if (err)
3578 return err;
Alex Tomasc9de5602008-01-29 00:19:52 -05003579
3580 err = init_ext4_xattr();
3581 if (err)
3582 goto out2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003583 err = init_inodecache();
3584 if (err)
3585 goto out1;
Theodore Ts'o03010a32008-10-10 20:02:48 -04003586 err = register_filesystem(&ext4_fs_type);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003587 if (err)
3588 goto out;
Theodore Ts'o03010a32008-10-10 20:02:48 -04003589#ifdef CONFIG_EXT4DEV_COMPAT
3590 err = register_filesystem(&ext4dev_fs_type);
3591 if (err) {
3592 unregister_filesystem(&ext4_fs_type);
3593 goto out;
3594 }
3595#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003596 return 0;
3597out:
3598 destroy_inodecache();
3599out1:
Mingming Cao617ba132006-10-11 01:20:53 -07003600 exit_ext4_xattr();
Alex Tomasc9de5602008-01-29 00:19:52 -05003601out2:
3602 exit_ext4_mballoc();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003603 return err;
3604}
3605
Mingming Cao617ba132006-10-11 01:20:53 -07003606static void __exit exit_ext4_fs(void)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003607{
Theodore Ts'o03010a32008-10-10 20:02:48 -04003608 unregister_filesystem(&ext4_fs_type);
3609#ifdef CONFIG_EXT4DEV_COMPAT
Mingming Cao617ba132006-10-11 01:20:53 -07003610 unregister_filesystem(&ext4dev_fs_type);
Theodore Ts'o03010a32008-10-10 20:02:48 -04003611#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003612 destroy_inodecache();
Mingming Cao617ba132006-10-11 01:20:53 -07003613 exit_ext4_xattr();
Alex Tomasc9de5602008-01-29 00:19:52 -05003614 exit_ext4_mballoc();
Theodore Ts'o9f6200b2008-09-23 09:18:24 -04003615 remove_proc_entry("fs/ext4", NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003616}
3617
3618MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
Mingming Cao617ba132006-10-11 01:20:53 -07003619MODULE_DESCRIPTION("Fourth Extended Filesystem with extents");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003620MODULE_LICENSE("GPL");
Mingming Cao617ba132006-10-11 01:20:53 -07003621module_init(init_ext4_fs)
3622module_exit(exit_ext4_fs)