1 From: Greg Kroah-Hartman <gregkh@suse.de>
2 Subject: revert ext4 changes in 2.6.27.19 and 2.6.27.20 and 2.6.27.25
5 As we are already taking a different version of ext4, revert the
6 changes that were made to ext4 in 2.6.27.19 and 2.6.27.20 and 2.6.27.25
8 Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
10 --- b/Documentation/filesystems/ext4.txt
11 +++ a/Documentation/filesystems/ext4.txt
13 * extent format more robust in face of on-disk corruption due to magics,
14 * internal redunancy in tree
15 * improved file allocation (multi-block alloc)
16 +* fix 32000 subdirectory limit
17 -* lift 32000 subdirectory limit imposed by i_links_count[1]
18 * nsec timestamps for mtime, atime, ctime, create time
19 * inode version field on disk (NFSv4, Lustre)
20 * reduced e2fsck time via uninit_bg feature
22 * efficent new ordered mode in JBD2 and ext4(avoid using buffer head to force
25 -[1] Filesystems with a block size of 1k may see a limit imposed by the
26 -directory hash tree having a maximum depth of two.
28 2.2 Candidate features for future inclusion
30 * Online defrag (patches available but not well tested)
32 --- b/fs/ext4/balloc.c
33 +++ a/fs/ext4/balloc.c
36 #include "ext4_jbd2.h"
41 * balloc.c contains the blocks allocation and deallocation routines
43 block_group, bitmap_blk);
46 + if (bh_uptodate_or_lock(bh))
48 - if (bitmap_uptodate(bh))
52 - if (bitmap_uptodate(bh)) {
56 spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
57 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
58 ext4_init_block_bitmap(sb, bh, block_group, desc);
59 - set_bitmap_uptodate(bh);
60 set_buffer_uptodate(bh);
62 spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
65 spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
66 - if (buffer_uptodate(bh)) {
68 - * if not uninit if bh is uptodate,
69 - * bitmap is also uptodate
71 - set_bitmap_uptodate(bh);
76 - * submit the buffer_head for read. We can
77 - * safely mark the bitmap as uptodate now.
78 - * We do it here so the bitmap uptodate bit
79 - * get set with buffer lock held.
81 - set_bitmap_uptodate(bh);
82 if (bh_submit_read(bh) < 0) {
84 ext4_error(sb, __func__,
89 - * ext4_add_groupblocks() -- Add given blocks to an existing group
90 - * @handle: handle to this transaction
92 - * @block: start physcial block to add to the block group
93 - * @count: number of blocks to free
95 - * This marks the blocks as free in the bitmap. We ask the
96 - * mballoc to reload the buddy after this by setting group
97 - * EXT4_GROUP_INFO_NEED_INIT_BIT flag
99 -void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
100 - ext4_fsblk_t block, unsigned long count)
102 - struct buffer_head *bitmap_bh = NULL;
103 - struct buffer_head *gd_bh;
104 - ext4_group_t block_group;
107 - struct ext4_group_desc *desc;
108 - struct ext4_super_block *es;
109 - struct ext4_sb_info *sbi;
111 - ext4_grpblk_t blocks_freed;
112 - struct ext4_group_info *grp;
116 - ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);
118 - ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
119 - grp = ext4_get_group_info(sb, block_group);
121 - * Check to see if we are freeing blocks across a group
124 - if (bit + count > EXT4_BLOCKS_PER_GROUP(sb))
127 - bitmap_bh = ext4_read_block_bitmap(sb, block_group);
130 - desc = ext4_get_group_desc(sb, block_group, &gd_bh);
134 - if (in_range(ext4_block_bitmap(sb, desc), block, count) ||
135 - in_range(ext4_inode_bitmap(sb, desc), block, count) ||
136 - in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
137 - in_range(block + count - 1, ext4_inode_table(sb, desc),
138 - sbi->s_itb_per_group)) {
139 - ext4_error(sb, __func__,
140 - "Adding blocks in system zones - "
141 - "Block = %llu, count = %lu",
147 - * We are about to add blocks to the bitmap,
148 - * so we need undo access.
150 - BUFFER_TRACE(bitmap_bh, "getting undo access");
151 - err = ext4_journal_get_undo_access(handle, bitmap_bh);
156 - * We are about to modify some metadata. Call the journal APIs
157 - * to unshare ->b_data if a currently-committing transaction is
160 - BUFFER_TRACE(gd_bh, "get_write_access");
161 - err = ext4_journal_get_write_access(handle, gd_bh);
165 - * make sure we don't allow a parallel init on other groups in the
168 - down_write(&grp->alloc_sem);
169 - for (i = 0, blocks_freed = 0; i < count; i++) {
170 - BUFFER_TRACE(bitmap_bh, "clear bit");
171 - if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
172 - bit + i, bitmap_bh->b_data)) {
173 - ext4_error(sb, __func__,
174 - "bit already cleared for block %llu",
175 - (ext4_fsblk_t)(block + i));
176 - BUFFER_TRACE(bitmap_bh, "bit already cleared");
181 - spin_lock(sb_bgl_lock(sbi, block_group));
182 - le16_add_cpu(&desc->bg_free_blocks_count, blocks_freed);
183 - desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);
184 - spin_unlock(sb_bgl_lock(sbi, block_group));
185 - percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed);
187 - if (sbi->s_log_groups_per_flex) {
188 - ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
189 - spin_lock(sb_bgl_lock(sbi, flex_group));
190 - sbi->s_flex_groups[flex_group].free_blocks += blocks_freed;
191 - spin_unlock(sb_bgl_lock(sbi, flex_group));
194 - * request to reload the buddy with the
195 - * new bitmap information
197 - set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state));
198 - ext4_mb_update_group_info(grp, blocks_freed);
199 - up_write(&grp->alloc_sem);
201 - /* We dirtied the bitmap block */
202 - BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
203 - err = ext4_journal_dirty_metadata(handle, bitmap_bh);
205 - /* And the group descriptor block */
206 - BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
207 - ret = ext4_journal_dirty_metadata(handle, gd_bh);
214 - ext4_std_error(sb, err);
219 * ext4_free_blocks() -- Free given blocks and update quota
220 * @handle: handle for this transaction
226 #include <linux/types.h>
227 #include <linux/blkdev.h>
228 #include <linux/magic.h>
229 -#include <linux/jbd2.h>
234 #define EXT4_FL_USER_VISIBLE 0x000BDFFF /* User visible flags */
235 #define EXT4_FL_USER_MODIFIABLE 0x000380FF /* User modifiable flags */
237 -/* Flags that should be inherited by new inodes from their parent. */
238 -#define EXT4_FL_INHERITED (EXT4_SECRM_FL | EXT4_UNRM_FL | EXT4_COMPR_FL |\
239 - EXT4_SYNC_FL | EXT4_IMMUTABLE_FL | EXT4_APPEND_FL |\
240 - EXT4_NODUMP_FL | EXT4_NOATIME_FL |\
241 - EXT4_NOCOMPR_FL | EXT4_JOURNAL_DATA_FL |\
242 - EXT4_NOTAIL_FL | EXT4_DIRSYNC_FL)
244 -/* Flags that are appropriate for regular files (all but dir-specific ones). */
245 -#define EXT4_REG_FLMASK (~(EXT4_DIRSYNC_FL | EXT4_TOPDIR_FL))
247 -/* Flags that are appropriate for non-directories/regular files. */
248 -#define EXT4_OTHER_FLMASK (EXT4_NODUMP_FL | EXT4_NOATIME_FL)
250 -/* Mask out flags that are inappropriate for the given type of inode. */
251 -static inline __u32 ext4_mask_flags(umode_t mode, __u32 flags)
255 - else if (S_ISREG(mode))
256 - return flags & EXT4_REG_FLMASK;
258 - return flags & EXT4_OTHER_FLMASK;
262 * Inode dynamic state flags
265 #define EXT4_STATE_NEW 0x00000002 /* inode is newly created */
266 #define EXT4_STATE_XATTR 0x00000004 /* has in-inode xattrs */
267 #define EXT4_STATE_NO_EXPAND 0x00000008 /* No space for expansion */
268 -#define EXT4_STATE_DA_ALLOC_CLOSE 0x00000010 /* Alloc DA blks on close */
270 /* Used to pass group descriptor data when online resize is done */
271 struct ext4_new_group_input {
273 #define EXT4_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long)
274 #define EXT4_IOC_GROUP_ADD _IOW('f', 8, struct ext4_new_group_input)
275 #define EXT4_IOC_MIGRATE _IO('f', 9)
276 - /* note ioctl 10 reserved for an early version of the FIEMAP ioctl */
277 /* note ioctl 11 reserved for filesystem-independent FIEMAP ioctl */
278 -#define EXT4_IOC_ALLOC_DA_BLKS _IO('f', 12)
281 * ioctl commands in 32 bit emulation
284 unsigned len = le16_to_cpu(dlen);
286 + if (len == EXT4_MAX_REC_LEN)
287 - if (len == EXT4_MAX_REC_LEN || len == 0)
292 #define DX_HASH_LEGACY 0
293 #define DX_HASH_HALF_MD4 1
294 #define DX_HASH_TEA 2
295 -#define DX_HASH_LEGACY_UNSIGNED 3
296 -#define DX_HASH_HALF_MD4_UNSIGNED 4
297 -#define DX_HASH_TEA_UNSIGNED 5
301 @@ -1019,11 +988,9 @@
302 ext4_fsblk_t nblocks);
303 extern void ext4_free_blocks (handle_t *handle, struct inode *inode,
304 ext4_fsblk_t block, unsigned long count, int metadata);
305 +extern void ext4_free_blocks_sb (handle_t *handle, struct super_block *sb,
306 + ext4_fsblk_t block, unsigned long count,
307 -extern void ext4_free_blocks_sb(handle_t *handle, struct super_block *sb,
308 - ext4_fsblk_t block, unsigned long count,
309 unsigned long *pdquot_freed_blocks);
310 -extern void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
311 - ext4_fsblk_t block, unsigned long count);
312 extern ext4_fsblk_t ext4_count_free_blocks (struct super_block *);
313 extern void ext4_check_blocks_bitmap (struct super_block *);
314 extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
315 @@ -1071,13 +1038,12 @@
316 extern void exit_ext4_mballoc(void);
317 extern void ext4_mb_free_blocks(handle_t *, struct inode *,
318 unsigned long, unsigned long, int, unsigned long *);
319 +extern int ext4_mb_add_more_groupinfo(struct super_block *sb,
320 -extern int ext4_mb_add_groupinfo(struct super_block *sb,
321 ext4_group_t i, struct ext4_group_desc *desc);
322 extern void ext4_mb_update_group_info(struct ext4_group_info *grp,
326 -extern int ext4_mb_get_buddy_cache_lock(struct super_block *, ext4_group_t);
327 -extern void ext4_mb_put_buddy_cache_lock(struct super_block *,
328 - ext4_group_t, int);
330 int ext4_forget(handle_t *handle, int is_metadata, struct inode *inode,
331 struct buffer_head *bh, ext4_fsblk_t blocknr);
332 @@ -1105,14 +1071,13 @@
333 extern void ext4_truncate (struct inode *);
334 extern void ext4_set_inode_flags(struct inode *);
335 extern void ext4_get_inode_flags(struct ext4_inode_info *);
336 -extern int ext4_alloc_da_blocks(struct inode *inode);
337 extern void ext4_set_aops(struct inode *inode);
338 extern int ext4_writepage_trans_blocks(struct inode *);
339 extern int ext4_meta_trans_blocks(struct inode *, int nrblocks, int idxblocks);
340 extern int ext4_chunk_trans_blocks(struct inode *, int nrblocks);
341 extern int ext4_block_truncate_page(handle_t *handle,
342 struct address_space *mapping, loff_t from);
343 +extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page);
344 -extern int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf);
347 extern long ext4_ioctl(struct file *, unsigned int, unsigned long);
348 @@ -1202,11 +1167,8 @@
350 static inline loff_t ext4_isize(struct ext4_inode *raw_inode)
352 + return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
353 + le32_to_cpu(raw_inode->i_size_lo);
354 - if (S_ISREG(le16_to_cpu(raw_inode->i_mode)))
355 - return ((loff_t)le32_to_cpu(raw_inode->i_size_high) << 32) |
356 - le32_to_cpu(raw_inode->i_size_lo);
358 - return (loff_t) le32_to_cpu(raw_inode->i_size_lo);
361 static inline void ext4_isize_set(struct ext4_inode *raw_inode, loff_t i_size)
362 @@ -1282,23 +1244,6 @@
363 sector_t block, unsigned long max_blocks,
364 struct buffer_head *bh, int create,
365 int extend_disksize, int flag);
367 - * Add new method to test wether block and inode bitmaps are properly
368 - * initialized. With uninit_bg reading the block from disk is not enough
369 - * to mark the bitmap uptodate. We need to also zero-out the bitmap
371 -#define BH_BITMAP_UPTODATE BH_JBDPrivateStart
373 -static inline int bitmap_uptodate(struct buffer_head *bh)
375 - return (buffer_uptodate(bh) &&
376 - test_bit(BH_BITMAP_UPTODATE, &(bh)->b_state));
378 -static inline void set_bitmap_uptodate(struct buffer_head *bh)
380 - set_bit(BH_BITMAP_UPTODATE, &(bh)->b_state);
383 #endif /* __KERNEL__ */
387 --- b/fs/ext4/ext4_sb.h
388 +++ a/fs/ext4/ext4_sb.h
390 u32 s_next_generation;
392 int s_def_hash_version;
393 - int s_hash_unsigned; /* 3 if hash should be signed, 0 if not */
394 struct percpu_counter s_freeblocks_counter;
395 struct percpu_counter s_freeinodes_counter;
396 struct percpu_counter s_dirs_counter;
398 struct list_head s_committed_transaction;
399 spinlock_t s_md_lock;
400 tid_t s_last_transaction;
401 + unsigned short *s_mb_offsets, *s_mb_maxs;
402 - unsigned short *s_mb_offsets;
403 - unsigned int *s_mb_maxs;
406 unsigned long s_stripe;
408 --- b/fs/ext4/extents.c
409 +++ a/fs/ext4/extents.c
410 @@ -1118,8 +1118,7 @@
411 struct ext4_extent_idx *ix;
412 struct ext4_extent *ex;
415 - int depth; /* Note, NOT eh_depth; depth from top of tree */
418 BUG_ON(path == NULL);
419 depth = path->p_depth;
420 @@ -1178,8 +1177,7 @@
423 eh = ext_block_hdr(bh);
424 + if (ext4_ext_check_header(inode, eh, depth)) {
425 - /* subtract from p_depth to get proper eh_depth */
426 - if (ext4_ext_check_header(inode, eh, path->p_depth - depth)) {
430 @@ -1633,13 +1631,11 @@
432 struct ext4_ext_cache *cex;
434 - spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
435 cex = &EXT4_I(inode)->i_cached_extent;
437 cex->ec_block = block;
439 cex->ec_start = start;
440 - spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
444 @@ -1696,17 +1692,12 @@
445 struct ext4_extent *ex)
447 struct ext4_ext_cache *cex;
448 - int ret = EXT4_EXT_CACHE_NO;
451 - * We borrow i_block_reservation_lock to protect i_cached_extent
453 - spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
454 cex = &EXT4_I(inode)->i_cached_extent;
456 /* has cache valid data? */
457 if (cex->ec_type == EXT4_EXT_CACHE_NO)
458 + return EXT4_EXT_CACHE_NO;
461 BUG_ON(cex->ec_type != EXT4_EXT_CACHE_GAP &&
462 cex->ec_type != EXT4_EXT_CACHE_EXTENT);
463 @@ -1717,11 +1708,11 @@
464 ext_debug("%u cached by %u:%u:%llu\n",
466 cex->ec_block, cex->ec_len, cex->ec_start);
467 + return cex->ec_type;
468 - ret = cex->ec_type;
472 + return EXT4_EXT_CACHE_NO;
474 - spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
479 @@ -2677,8 +2668,6 @@
480 if (allocated > max_blocks)
481 allocated = max_blocks;
482 set_buffer_unwritten(bh_result);
483 - bh_result->b_bdev = inode->i_sb->s_bdev;
484 - bh_result->b_blocknr = newblock;
493 static int ext4_release_file (struct inode * inode, struct file * filp)
495 - if (EXT4_I(inode)->i_state & EXT4_STATE_DA_ALLOC_CLOSE) {
496 - ext4_alloc_da_blocks(inode);
497 - EXT4_I(inode)->i_state &= ~EXT4_STATE_DA_ALLOC_CLOSE;
499 /* if we are the last writer on the inode, drop the block reservation */
500 if ((filp->f_mode & FMODE_WRITE) &&
501 + (atomic_read(&inode->i_writecount) == 1))
502 - (atomic_read(&inode->i_writecount) == 1) &&
503 - !EXT4_I(inode)->i_reserved_data_blocks)
505 down_write(&EXT4_I(inode)->i_data_sem);
506 ext4_discard_reservation(inode);
513 /* The old legacy hash */
514 +static __u32 dx_hack_hash (const char *name, int len)
515 -static __u32 dx_hack_hash_unsigned(const char *name, int len)
517 + __u32 hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
518 - __u32 hash, hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
519 - const unsigned char *ucp = (const unsigned char *) name;
522 - hash = hash1 + (hash0 ^ (((int) *ucp++) * 7152373));
524 - if (hash & 0x80000000)
525 - hash -= 0x7fffffff;
532 -static __u32 dx_hack_hash_signed(const char *name, int len)
534 - __u32 hash, hash0 = 0x12a3fe2d, hash1 = 0x37abe8f9;
535 - const signed char *scp = (const signed char *) name;
538 + __u32 hash = hash1 + (hash0 ^ (*name++ * 7152373));
539 - hash = hash1 + (hash0 ^ (((int) *scp++) * 7152373));
541 + if (hash & 0x80000000) hash -= 0x7fffffff;
542 - if (hash & 0x80000000)
543 - hash -= 0x7fffffff;
547 + return (hash0 << 1);
551 +static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
552 -static void str2hashbuf_signed(const char *msg, int len, __u32 *buf, int num)
556 - const signed char *scp = (const signed char *) msg;
558 - pad = (__u32)len | ((__u32)len << 8);
564 - for (i = 0; i < len; i++) {
567 - val = ((int) scp[i]) + (val << 8);
568 - if ((i % 4) == 3) {
580 -static void str2hashbuf_unsigned(const char *msg, int len, __u32 *buf, int num)
584 - const unsigned char *ucp = (const unsigned char *) msg;
586 pad = (__u32)len | ((__u32)len << 8);
589 for (i=0; i < len; i++) {
592 + val = msg[i] + (val << 8);
593 - val = ((int) ucp[i]) + (val << 8);
601 - void (*str2hashbuf)(const char *, int, __u32 *, int) =
602 - str2hashbuf_signed;
604 /* Initialize the default seed for the hash checksum functions */
606 @@ -163,18 +113,13 @@
609 switch (hinfo->hash_version) {
610 - case DX_HASH_LEGACY_UNSIGNED:
611 - hash = dx_hack_hash_unsigned(name, len);
614 + hash = dx_hack_hash(name, len);
615 - hash = dx_hack_hash_signed(name, len);
617 - case DX_HASH_HALF_MD4_UNSIGNED:
618 - str2hashbuf = str2hashbuf_unsigned;
619 case DX_HASH_HALF_MD4:
622 + str2hashbuf(p, len, in, 8);
623 - (*str2hashbuf)(p, len, in, 8);
624 half_md4_transform(buf, in);
627 @@ -182,12 +127,10 @@
631 - case DX_HASH_TEA_UNSIGNED:
632 - str2hashbuf = str2hashbuf_unsigned;
636 + str2hashbuf(p, len, in, 4);
637 - (*str2hashbuf)(p, len, in, 4);
638 TEA_transform(buf, in);
642 --- b/fs/ext4/ialloc.c
643 +++ a/fs/ext4/ialloc.c
647 memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
648 + mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), EXT4_BLOCKS_PER_GROUP(sb),
649 - mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
652 return EXT4_INODES_PER_GROUP(sb);
653 @@ -115,40 +115,18 @@
654 block_group, bitmap_blk);
657 + if (bh_uptodate_or_lock(bh))
658 - if (bitmap_uptodate(bh))
662 - if (bitmap_uptodate(bh)) {
666 spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
667 if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
668 ext4_init_inode_bitmap(sb, bh, block_group, desc);
669 - set_bitmap_uptodate(bh);
670 set_buffer_uptodate(bh);
672 spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
675 spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
676 - if (buffer_uptodate(bh)) {
678 - * if not uninit if bh is uptodate,
679 - * bitmap is also uptodate
681 - set_bitmap_uptodate(bh);
686 - * submit the buffer_head for read. We can
687 - * safely mark the bitmap as uptodate now.
688 - * We do it here so the bitmap uptodate bit
689 - * get set with buffer lock held.
691 - set_bitmap_uptodate(bh);
692 if (bh_submit_read(bh) < 0) {
694 ext4_error(sb, __func__,
696 struct ext4_group_desc * gdp;
697 struct ext4_super_block * es;
698 struct ext4_sb_info *sbi;
699 + int fatal = 0, err;
700 - int fatal = 0, err, cleared;
701 ext4_group_t flex_group;
703 if (atomic_read(&inode->i_count) > 1) {
704 @@ -242,12 +220,10 @@
707 /* Ok, now we can actually update the inode bitmaps.. */
708 + if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
709 + bit, bitmap_bh->b_data))
710 + ext4_error (sb, "ext4_free_inode",
711 + "bit already cleared for inode %lu", ino);
712 - spin_lock(sb_bgl_lock(sbi, block_group));
713 - cleared = ext4_clear_bit(bit, bitmap_bh->b_data);
714 - spin_unlock(sb_bgl_lock(sbi, block_group));
716 - ext4_error(sb, "ext4_free_inode",
717 - "bit already cleared for inode %lu", ino);
719 gdp = ext4_get_group_desc (sb, block_group, &bh2);
725 - * claim the inode from the inode bitmap. If the group
726 - * is uninit we need to take the groups's sb_bgl_lock
727 - * and clear the uninit flag. The inode bitmap update
728 - * and group desc uninit flag clear should be done
729 - * after holding sb_bgl_lock so that ext4_read_inode_bitmap
730 - * doesn't race with the ext4_claim_inode
732 -static int ext4_claim_inode(struct super_block *sb,
733 - struct buffer_head *inode_bitmap_bh,
734 - unsigned long ino, ext4_group_t group, int mode)
736 - int free = 0, retval = 0;
737 - struct ext4_sb_info *sbi = EXT4_SB(sb);
738 - struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
740 - spin_lock(sb_bgl_lock(sbi, group));
741 - if (ext4_set_bit(ino, inode_bitmap_bh->b_data)) {
742 - /* not a free inode */
747 - if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
748 - ino > EXT4_INODES_PER_GROUP(sb)) {
749 - spin_unlock(sb_bgl_lock(sbi, group));
750 - ext4_error(sb, __func__,
751 - "reserved inode or inode > inodes count - "
752 - "block_group = %lu, inode=%lu", group,
753 - ino + group * EXT4_INODES_PER_GROUP(sb));
756 - /* If we didn't allocate from within the initialized part of the inode
757 - * table then we need to initialize up to this inode. */
758 - if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
760 - if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
761 - gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
762 - /* When marking the block group with
763 - * ~EXT4_BG_INODE_UNINIT we don't want to depend
764 - * on the value of bg_itable_unused even though
765 - * mke2fs could have initialized the same for us.
766 - * Instead we calculated the value below
771 - free = EXT4_INODES_PER_GROUP(sb) -
772 - le16_to_cpu(gdp->bg_itable_unused);
776 - * Check the relative inode number against the last used
777 - * relative inode number in this group. if it is greater
778 - * we need to update the bg_itable_unused count
782 - gdp->bg_itable_unused =
783 - cpu_to_le16(EXT4_INODES_PER_GROUP(sb) - ino);
785 - le16_add_cpu(&gdp->bg_free_inodes_count, -1);
786 - if (S_ISDIR(mode)) {
787 - le16_add_cpu(&gdp->bg_used_dirs_count, 1);
789 - gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
791 - spin_unlock(sb_bgl_lock(sbi, group));
796 * There are two policies for allocating an inode. If the new inode is
797 * a directory, then a forward search is made for a block group with both
798 * free space and a low directory-to-inode ratio; if that fails, then of
803 - static int once = 1;
804 ext4_group_t flex_group;
806 /* Cannot create files in a deleted directory */
809 if (sbi->s_log_groups_per_flex) {
810 ret2 = find_group_flex(sb, dir, &group);
812 - ret2 = find_group_other(sb, dir, &group);
813 - if (ret2 == 0 && once) {
815 - printk(KERN_NOTICE "ext4: find_group_flex "
816 - "failed, fallback succeeded dir %lu\n",
827 + if (!ext4_set_bit_atomic(sb_bgl_lock(sbi, group),
828 + ino, bitmap_bh->b_data)) {
829 - BUFFER_TRACE(bh2, "get_write_access");
830 - err = ext4_journal_get_write_access(handle, bh2);
833 - if (!ext4_claim_inode(sb, bitmap_bh,
834 - ino, group, mode)) {
836 BUFFER_TRACE(bitmap_bh,
837 "call ext4_journal_dirty_metadata");
838 @@ -767,13 +658,10 @@
842 - /* zero bit is inode number 1*/
847 jbd2_journal_release_buffer(handle, bitmap_bh);
848 - jbd2_journal_release_buffer(handle, bh2);
850 if (++ino < EXT4_INODES_PER_GROUP(sb))
851 goto repeat_in_this_group;
857 + if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
858 + ino > EXT4_INODES_PER_GROUP(sb)) {
859 + ext4_error(sb, __func__,
860 + "reserved inode or inode > inodes count - "
861 + "block_group = %lu, inode=%lu", group,
862 + ino + group * EXT4_INODES_PER_GROUP(sb));
867 + BUFFER_TRACE(bh2, "get_write_access");
868 + err = ext4_journal_get_write_access(handle, bh2);
869 + if (err) goto fail;
871 /* We may have to initialize the block bitmap if it isn't already */
872 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM) &&
873 gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
874 @@ -827,10 +730,47 @@
879 + spin_lock(sb_bgl_lock(sbi, group));
880 + /* If we didn't allocate from within the initialized part of the inode
881 + * table then we need to initialize up to this inode. */
882 + if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
883 + if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
884 + gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
886 + /* When marking the block group with
887 + * ~EXT4_BG_INODE_UNINIT we don't want to depend
888 + * on the value of bg_itable_unused even though
889 + * mke2fs could have initialized the same for us.
890 + * Instead we calculated the value below
895 + free = EXT4_INODES_PER_GROUP(sb) -
896 + le16_to_cpu(gdp->bg_itable_unused);
900 + * Check the relative inode number against the last used
901 + * relative inode number in this group. if it is greater
902 + * we need to update the bg_itable_unused count
906 + gdp->bg_itable_unused =
907 + cpu_to_le16(EXT4_INODES_PER_GROUP(sb) - ino);
910 + le16_add_cpu(&gdp->bg_free_inodes_count, -1);
911 + if (S_ISDIR(mode)) {
912 + le16_add_cpu(&gdp->bg_used_dirs_count, 1);
914 + gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
915 + spin_unlock(sb_bgl_lock(sbi, group));
916 + BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
917 - BUFFER_TRACE(bh2, "call ext4_handle_dirty_metadata");
918 err = ext4_journal_dirty_metadata(handle, bh2);
919 + if (err) goto fail;
923 percpu_counter_dec(&sbi->s_freeinodes_counter);
925 @@ -866,12 +806,16 @@
929 + * Don't inherit extent flag from directory. We set extent flag on
930 + * newly created directory and file only if -o extent mount option is
932 - * Don't inherit extent flag from directory, amongst others. We set
933 - * extent flag on newly created directory and file only if -o extent
934 - * mount option is specified
936 + ei->i_flags = EXT4_I(dir)->i_flags & ~(EXT4_INDEX_FL|EXT4_EXTENTS_FL);
938 + ei->i_flags &= ~(EXT4_IMMUTABLE_FL|EXT4_APPEND_FL);
939 + /* dirsync only applies to directories */
940 + if (!S_ISDIR(mode))
941 + ei->i_flags &= ~EXT4_DIRSYNC_FL;
943 - ext4_mask_flags(mode, EXT4_I(dir)->i_flags & EXT4_FL_INHERITED);
946 ei->i_block_alloc_info = NULL;
948 --- b/fs/ext4/inode.c
949 +++ a/fs/ext4/inode.c
951 static inline int ext4_begin_ordered_truncate(struct inode *inode,
954 + return jbd2_journal_begin_ordered_truncate(&EXT4_I(inode)->jinode,
956 - return jbd2_journal_begin_ordered_truncate(
957 - EXT4_SB(inode->i_sb)->s_journal,
958 - &EXT4_I(inode)->jinode,
962 static void ext4_invalidatepage(struct page *page, unsigned long offset);
966 ext4_warning(inode->i_sb, "ext4_block_to_path",
968 - "block %lu > max in inode %lu",
969 i_block + direct_blocks +
970 + indirect_blocks + double_blocks);
971 - indirect_blocks + double_blocks, inode->i_ino);
974 *boundary = final - 1 - (i_block & (ptrs - 1));
975 @@ -1046,14 +1044,6 @@
976 EXT4_I(inode)->i_reserved_meta_blocks = mdb;
977 EXT4_I(inode)->i_allocated_meta_blocks = 0;
978 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
981 - * If we have done all the pending block allocations and if
982 - * there aren't any writers on the inode, we can discard the
983 - * inode's preallocations.
985 - if (!total && (atomic_read(&inode->i_writecount) == 0))
986 - ext4_discard_reservation(inode);
990 @@ -1085,7 +1075,6 @@
993 clear_buffer_mapped(bh);
994 - clear_buffer_unwritten(bh);
997 * Try to see if we can get the block without requesting
998 @@ -1116,18 +1105,6 @@
1002 - * When we call get_blocks without the create flag, the
1003 - * BH_Unwritten flag could have gotten set if the blocks
1004 - * requested were part of a uninitialized extent. We need to
1005 - * clear this flag now that we are committed to convert all or
1006 - * part of the uninitialized extent to be an initialized
1007 - * extent. This is because we need to avoid the combination
1008 - * of BH_Unwritten and BH_Mapped flags being simultaneously
1009 - * set on the buffer_head.
1011 - clear_buffer_unwritten(bh);
1014 * New blocks allocate and/or writing to uninitialized extent
1015 * will possibly result in updating i_data, so we take
1016 * the write lock of i_data_sem, and call get_blocks()
1017 @@ -1393,10 +1370,6 @@
1021 - /* We cannot recurse into the filesystem as the transaction is already
1023 - flags |= AOP_FLAG_NOFS;
1025 page = grab_cache_page_write_begin(mapping, index, flags);
1027 ext4_journal_stop(handle);
1028 @@ -1406,7 +1379,7 @@
1031 ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
1035 if (!ret && ext4_should_journal_data(inode)) {
1036 ret = walk_page_buffers(handle, page_buffers(page),
1037 @@ -1675,25 +1648,18 @@
1039 static int mpage_da_submit_io(struct mpage_da_data *mpd)
1041 + struct address_space *mapping = mpd->inode->i_mapping;
1042 + int ret = 0, err, nr_pages, i;
1043 + unsigned long index, end;
1044 - long pages_skipped;
1045 struct pagevec pvec;
1046 - unsigned long index, end;
1047 - int ret = 0, err, nr_pages, i;
1048 - struct inode *inode = mpd->inode;
1049 - struct address_space *mapping = inode->i_mapping;
1051 BUG_ON(mpd->next_page <= mpd->first_page);
1052 + pagevec_init(&pvec, 0);
1054 - * We need to start from the first_page to the next_page - 1
1055 - * to make sure we also write the mapped dirty buffer_heads.
1056 - * If we look at mpd->lbh.b_blocknr we would only be looking
1057 - * at the currently mapped buffer_heads.
1059 index = mpd->first_page;
1060 end = mpd->next_page - 1;
1062 - pagevec_init(&pvec, 0);
1063 while (index <= end) {
1064 + /* XXX: optimize tail */
1065 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1068 @@ -1705,10 +1671,6 @@
1072 - BUG_ON(!PageLocked(page));
1073 - BUG_ON(PageWriteback(page));
1075 - pages_skipped = mpd->wbc->pages_skipped;
1076 err = mapping->a_ops->writepage(page, mpd->wbc);
1078 mpd->pages_written++;
1079 @@ -2029,29 +1991,11 @@
1082 BUG_ON(buffer_locked(bh));
1084 - * We need to try to allocate
1085 - * unmapped blocks in the same page.
1086 - * Otherwise we won't make progress
1087 - * with the page in ext4_da_writepage
1089 if (buffer_dirty(bh) &&
1090 (!buffer_mapped(bh) || buffer_delay(bh))) {
1091 mpage_add_bh_to_extent(mpd, logical, bh);
1093 return MPAGE_DA_EXTENT_TAIL;
1094 - } else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
1096 - * mapped dirty buffer. We need to update
1097 - * the b_state because we look at
1098 - * b_state in mpage_da_map_blocks. We don't
1099 - * update b_size because if we find an
1100 - * unmapped buffer_head later we need to
1101 - * use the b_state flag of that buffer_head.
1103 - if (mpd->lbh.b_size == 0)
1104 - mpd->lbh.b_state =
1105 - bh->b_state & BH_FLAGS;
1108 } while ((bh = bh->b_this_page) != head);
1109 @@ -2118,10 +2062,6 @@
1110 struct buffer_head *bh_result, int create)
1113 - sector_t invalid_block = ~((sector_t) 0xffff);
1115 - if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
1116 - invalid_block = ~0;
1118 BUG_ON(create == 0);
1119 BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1120 @@ -2143,18 +2083,11 @@
1121 /* not enough space to reserve */
1124 + map_bh(bh_result, inode->i_sb, 0);
1125 - map_bh(bh_result, inode->i_sb, invalid_block);
1126 set_buffer_new(bh_result);
1127 set_buffer_delay(bh_result);
1128 } else if (ret > 0) {
1129 bh_result->b_size = (ret << inode->i_blkbits);
1131 - * With sub-block writes into unwritten extents
1132 - * we also need to mark the buffer as new so that
1133 - * the unwritten parts of the buffer gets correctly zeroed.
1135 - if (buffer_unwritten(bh_result))
1136 - set_buffer_new(bh_result);
1140 @@ -2365,20 +2298,6 @@
1142 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
1146 - * If the filesystem has aborted, it is read-only, so return
1147 - * right away instead of dumping stack traces later on that
1148 - * will obscure the real source of the problem. We test
1149 - * EXT4_MOUNT_ABORT instead of sb->s_flag's MS_RDONLY because
1150 - * the latter could be true if the filesystem is mounted
1151 - * read-only, and in that case, ext4_da_writepages should
1152 - * *never* be called, so if that ever happens, we would want
1153 - * the stack trace.
1155 - if (unlikely(sbi->s_mount_opt & EXT4_MOUNT_ABORT))
1159 * Make sure nr_to_write is >= sbi->s_mb_stream_request
1160 * This make sure small files blocks are allocated in
1161 @@ -2417,7 +2336,7 @@
1162 handle = ext4_journal_start(inode, needed_blocks);
1163 if (IS_ERR(handle)) {
1164 ret = PTR_ERR(handle);
1165 + printk(KERN_EMERG "%s: jbd2_start: "
1166 - printk(KERN_CRIT "%s: jbd2_start: "
1167 "%ld pages, ino %lu; err %d\n", __func__,
1168 wbc->nr_to_write, inode->i_ino, ret);
1170 @@ -2501,9 +2420,6 @@
1171 ret = PTR_ERR(handle);
1174 - /* We cannot recurse into the filesystem as the transaction is already
1176 - flags |= AOP_FLAG_NOFS;
1178 page = grab_cache_page_write_begin(mapping, index, flags);
1180 @@ -2617,48 +2533,6 @@
1185 - * Force all delayed allocation blocks to be allocated for a given inode.
1187 -int ext4_alloc_da_blocks(struct inode *inode)
1189 - if (!EXT4_I(inode)->i_reserved_data_blocks &&
1190 - !EXT4_I(inode)->i_reserved_meta_blocks)
1194 - * We do something simple for now. The filemap_flush() will
1195 - * also start triggering a write of the data blocks, which is
1196 - * not strictly speaking necessary (and for users of
1197 - * laptop_mode, not even desirable). However, to do otherwise
1198 - * would require replicating code paths in:
1200 - * ext4_da_writepages() ->
1201 - * write_cache_pages() ---> (via passed in callback function)
1202 - * __mpage_da_writepage() -->
1203 - * mpage_add_bh_to_extent()
1204 - * mpage_da_map_blocks()
1206 - * The problem is that write_cache_pages(), located in
1207 - * mm/page-writeback.c, marks pages clean in preparation for
1208 - * doing I/O, which is not desirable if we're not planning on
1209 - * doing I/O at all.
1211 - * We could call write_cache_pages(), and then redirty all of
1212 - * the pages by calling redirty_page_for_writeback() but that
1213 - * would be ugly in the extreme. So instead we would need to
1214 - * replicate parts of the code in the above functions,
1215 - * simplifying them becuase we wouldn't actually intend to
1216 - * write out the pages, but rather only collect contiguous
1217 - * logical block extents, call the multi-block allocator, and
1218 - * then update the buffer heads with the block allocations.
1220 - * For now, though, we'll cheat by calling filemap_flush(),
1221 - * which will map the blocks, and start the I/O, but not
1222 - * actually wait for the I/O to complete.
1224 - return filemap_flush(inode->i_mapping);
1228 * bmap() is special. It gets used by applications such as lilo and by
1229 @@ -3668,9 +3542,6 @@
1230 if (!ext4_can_truncate(inode))
1233 - if (inode->i_size == 0)
1234 - ei->i_state |= EXT4_STATE_DA_ALLOC_CLOSE;
1236 if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
1237 ext4_ext_truncate(inode);
1239 @@ -4088,9 +3959,11 @@
1240 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
1241 inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
1242 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
1243 + if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
1244 + cpu_to_le32(EXT4_OS_HURD)) {
1245 - if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
1247 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
1249 inode->i_size = ext4_isize(raw_inode);
1250 ei->i_disksize = inode->i_size;
1251 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
1252 @@ -4137,18 +4010,6 @@
1253 (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
1256 - if (ei->i_file_acl &&
1257 - ((ei->i_file_acl <
1258 - (le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block) +
1259 - EXT4_SB(sb)->s_gdb_count)) ||
1260 - (ei->i_file_acl >= ext4_blocks_count(EXT4_SB(sb)->s_es)))) {
1261 - ext4_error(sb, __func__,
1262 - "bad extended attribute block %llu in inode #%lu",
1263 - ei->i_file_acl, inode->i_ino);
1268 if (S_ISREG(inode->i_mode)) {
1269 inode->i_op = &ext4_file_inode_operations;
1270 inode->i_fop = &ext4_file_operations;
1271 @@ -4163,8 +4024,7 @@
1272 inode->i_op = &ext4_symlink_inode_operations;
1273 ext4_set_aops(inode);
1276 - } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
1277 - S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
1278 inode->i_op = &ext4_special_inode_operations;
1279 if (raw_inode->i_block[0])
1280 init_special_inode(inode, inode->i_mode,
1281 @@ -4172,13 +4032,6 @@
1283 init_special_inode(inode, inode->i_mode,
1284 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
1288 - ext4_error(inode->i_sb, __func__,
1289 - "bogus i_mode (%o) for inode=%lu",
1290 - inode->i_mode, inode->i_ino);
1294 ext4_set_inode_flags(inode);
1295 @@ -4956,9 +4809,8 @@
1296 return !buffer_mapped(bh);
1299 +int ext4_page_mkwrite(struct vm_area_struct *vma, struct page *page)
1300 -int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
1302 - struct page *page = vmf->page;
1306 @@ -5009,8 +4861,6 @@
1311 - ret = VM_FAULT_SIGBUS;
1312 up_read(&inode->i_alloc_sem);
1316 --- b/fs/ext4/ioctl.c
1317 +++ a/fs/ext4/ioctl.c
1322 + if (!S_ISDIR(inode->i_mode))
1323 + flags &= ~EXT4_DIRSYNC_FL;
1324 - flags = ext4_mask_flags(inode->i_mode, flags);
1327 mutex_lock(&inode->i_mutex);
1328 @@ -287,20 +288,6 @@
1332 - case EXT4_IOC_ALLOC_DA_BLKS:
1335 - if (!is_owner_or_cap(inode))
1338 - err = mnt_want_write(filp->f_path.mnt);
1341 - err = ext4_alloc_da_blocks(inode);
1342 - mnt_drop_write(filp->f_path.mnt);
1350 --- b/fs/ext4/mballoc.c
1351 +++ a/fs/ext4/mballoc.c
1356 + * [ group 0 buddy][ group 0 bitmap] [group 1][ group 1]...
1357 - * [ group 0 bitmap][ group 0 buddy] [group 1][ group 1]...
1360 * one block each for bitmap and buddy information. So for each group we
1361 @@ -330,18 +330,6 @@
1365 -static struct kmem_cache *ext4_pspace_cachep;
1366 -static struct kmem_cache *ext4_ac_cachep;
1367 -static struct kmem_cache *ext4_free_ext_cachep;
1368 -static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
1369 - ext4_group_t group);
1370 -static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
1371 - ext4_group_t group);
1372 -static int ext4_mb_init_per_dev_proc(struct super_block *sb);
1373 -static int ext4_mb_destroy_per_dev_proc(struct super_block *sb);
1374 -static void ext4_mb_free_committed_blocks(struct super_block *);
1375 -static void ext4_mb_poll_new_transaction(struct super_block *sb,
1376 - handle_t *handle);
1378 static inline void *mb_correct_addr_and_bit(int *bit, void *addr)
1381 * stored in the inode as
1384 + * [ group 0 buddy][ group 0 bitmap] [group 1][ group 1]...
1385 - * [ group 0 bitmap][ group 0 buddy] [group 1][ group 1]...
1388 * one block each for bitmap and buddy information.
1389 @@ -796,42 +784,20 @@
1393 + if (bh_uptodate_or_lock(bh[i]))
1394 - if (bitmap_uptodate(bh[i]))
1397 - lock_buffer(bh[i]);
1398 - if (bitmap_uptodate(bh[i])) {
1399 - unlock_buffer(bh[i]);
1402 spin_lock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
1403 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
1404 ext4_init_block_bitmap(sb, bh[i],
1405 first_group + i, desc);
1406 - set_bitmap_uptodate(bh[i]);
1407 set_buffer_uptodate(bh[i]);
1408 unlock_buffer(bh[i]);
1409 spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
1412 spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
1413 - if (buffer_uptodate(bh[i])) {
1415 - * if not uninit if bh is uptodate,
1416 - * bitmap is also uptodate
1418 - set_bitmap_uptodate(bh[i]);
1419 - unlock_buffer(bh[i]);
1424 - * submit the buffer_head for read. We can
1425 - * safely mark the bitmap as uptodate now.
1426 - * We do it here so the bitmap uptodate bit
1427 - * get set with buffer lock held.
1429 - set_bitmap_uptodate(bh[i]);
1430 bh[i]->b_end_io = end_buffer_read_sync;
1431 submit_bh(READ, bh[i]);
1432 mb_debug("read bitmap for group %lu\n", first_group + i);
1436 first_block = page->index * blocks_per_page;
1437 - /* init the page */
1438 - memset(page_address(page), 0xff, PAGE_CACHE_SIZE);
1439 for (i = 0; i < blocks_per_page; i++) {
1441 struct ext4_group_info *grinfo;
1443 BUG_ON(incore == NULL);
1444 mb_debug("put buddy for group %u in page %lu/%x\n",
1445 group, page->index, i * blocksize);
1446 + memset(data, 0xff, blocksize);
1447 grinfo = ext4_get_group_info(sb, group);
1448 grinfo->bb_fragments = 0;
1449 memset(grinfo->bb_counters, 0,
1452 * incore got set to the group block bitmap below
1454 - ext4_lock_group(sb, group);
1455 ext4_mb_generate_buddy(sb, data, incore, group);
1456 - ext4_unlock_group(sb, group);
1459 /* this is block of bitmap */
1462 /* mark all preallocated blks used in in-core bitmap */
1463 ext4_mb_generate_from_pa(sb, data, group);
1464 - ext4_mb_generate_from_freelist(sb, data, group);
1465 ext4_unlock_group(sb, group);
1467 /* set incore so that the buddy information can be
1468 @@ -924,20 +886,18 @@
1469 ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
1470 struct ext4_buddy *e4b)
1472 + struct ext4_sb_info *sbi = EXT4_SB(sb);
1473 + struct inode *inode = sbi->s_buddy_cache;
1474 int blocks_per_page;
1480 - struct ext4_group_info *grp;
1481 - struct ext4_sb_info *sbi = EXT4_SB(sb);
1482 - struct inode *inode = sbi->s_buddy_cache;
1484 mb_debug("load group %lu\n", group);
1486 blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
1487 - grp = ext4_get_group_info(sb, group);
1489 e4b->bd_blkbits = sb->s_blocksize_bits;
1490 e4b->bd_info = ext4_get_group_info(sb, group);
1491 @@ -945,15 +905,6 @@
1492 e4b->bd_group = group;
1493 e4b->bd_buddy_page = NULL;
1494 e4b->bd_bitmap_page = NULL;
1495 - e4b->alloc_semp = &grp->alloc_sem;
1497 - /* Take the read lock on the group alloc
1498 - * sem. This would make sure a parallel
1499 - * ext4_mb_init_group happening on other
1500 - * groups mapped by the page is blocked
1501 - * till we are done with allocation
1503 - down_read(e4b->alloc_semp);
1506 * the buddy cache inode stores the block bitmap
1507 @@ -969,14 +920,6 @@
1508 page = find_get_page(inode->i_mapping, pnum);
1509 if (page == NULL || !PageUptodate(page)) {
1512 - * drop the page reference and try
1513 - * to get the page with lock. If we
1514 - * are not uptodate that implies
1515 - * somebody just created the page but
1516 - * is yet to initialize the same. So
1517 - * wait for it to initialize.
1519 page_cache_release(page);
1520 page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
1522 @@ -1042,9 +985,6 @@
1523 page_cache_release(e4b->bd_buddy_page);
1524 e4b->bd_buddy = NULL;
1525 e4b->bd_bitmap = NULL;
1527 - /* Done with the buddy cache */
1528 - up_read(e4b->alloc_semp);
1532 @@ -1054,9 +994,6 @@
1533 page_cache_release(e4b->bd_bitmap_page);
1534 if (e4b->bd_buddy_page)
1535 page_cache_release(e4b->bd_buddy_page);
1536 - /* Done with the buddy cache */
1537 - if (e4b->alloc_semp)
1538 - up_read(e4b->alloc_semp);
1542 @@ -1094,10 +1031,7 @@
1546 + mb_clear_bit_atomic(lock, cur, bm);
1548 - mb_clear_bit_atomic(lock, cur, bm);
1550 - mb_clear_bit(cur, bm);
1554 @@ -1115,10 +1049,7 @@
1558 + mb_set_bit_atomic(lock, cur, bm);
1560 - mb_set_bit_atomic(lock, cur, bm);
1562 - mb_set_bit(cur, bm);
1566 @@ -1365,20 +1296,13 @@
1567 ac->ac_tail = ret & 0xffff;
1568 ac->ac_buddy = ret >> 16;
1570 + /* XXXXXXX: SUCH A HORRIBLE **CK */
1571 + /*FIXME!! Why ? */
1573 - * take the page reference. We want the page to be pinned
1574 - * so that we don't get a ext4_mb_init_cache_call for this
1575 - * group until we update the bitmap. That would mean we
1576 - * double allocate blocks. The reference is dropped
1577 - * in ext4_mb_release_context
1579 ac->ac_bitmap_page = e4b->bd_bitmap_page;
1580 get_page(ac->ac_bitmap_page);
1581 ac->ac_buddy_page = e4b->bd_buddy_page;
1582 get_page(ac->ac_buddy_page);
1584 - /* on allocation we use ac to track the held semaphore */
1585 - ac->alloc_semp = e4b->alloc_semp;
1586 - e4b->alloc_semp = NULL;
1587 /* store last allocated for subsequent stream allocation */
1588 if ((ac->ac_flags & EXT4_MB_HINT_DATA)) {
1589 spin_lock(&sbi->s_md_lock);
1590 @@ -1402,8 +1326,6 @@
1591 struct ext4_free_extent ex;
1594 - if (ac->ac_status == AC_STATUS_FOUND)
1597 * We don't want to scan for a whole year
1599 @@ -1450,7 +1372,7 @@
1600 struct ext4_free_extent *gex = &ac->ac_g_ex;
1602 BUG_ON(ex->fe_len <= 0);
1603 + BUG_ON(ex->fe_len >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
1604 - BUG_ON(ex->fe_len > EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
1605 BUG_ON(ex->fe_start >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
1606 BUG_ON(ac->ac_status != AC_STATUS_CONTINUE);
1608 @@ -1770,173 +1692,6 @@
1613 - * lock the group_info alloc_sem of all the groups
1614 - * belonging to the same buddy cache page. This
1615 - * make sure other parallel operation on the buddy
1616 - * cache doesn't happen whild holding the buddy cache
1619 -int ext4_mb_get_buddy_cache_lock(struct super_block *sb, ext4_group_t group)
1623 - int blocks_per_page;
1624 - int groups_per_page;
1625 - ext4_group_t first_group;
1626 - struct ext4_group_info *grp;
1628 - blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
1630 - * the buddy cache inode stores the block bitmap
1631 - * and buddy information in consecutive blocks.
1632 - * So for each group we need two blocks.
1634 - block = group * 2;
1635 - pnum = block / blocks_per_page;
1636 - first_group = pnum * blocks_per_page / 2;
1638 - groups_per_page = blocks_per_page >> 1;
1639 - if (groups_per_page == 0)
1640 - groups_per_page = 1;
1641 - /* read all groups the page covers into the cache */
1642 - for (i = 0; i < groups_per_page; i++) {
1644 - if ((first_group + i) >= EXT4_SB(sb)->s_groups_count)
1646 - grp = ext4_get_group_info(sb, first_group + i);
1647 - /* take all groups write allocation
1648 - * semaphore. This make sure there is
1649 - * no block allocation going on in any
1652 - down_write(&grp->alloc_sem);
1657 -void ext4_mb_put_buddy_cache_lock(struct super_block *sb,
1658 - ext4_group_t group, int locked_group)
1662 - int blocks_per_page;
1663 - ext4_group_t first_group;
1664 - struct ext4_group_info *grp;
1666 - blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
1668 - * the buddy cache inode stores the block bitmap
1669 - * and buddy information in consecutive blocks.
1670 - * So for each group we need two blocks.
1672 - block = group * 2;
1673 - pnum = block / blocks_per_page;
1674 - first_group = pnum * blocks_per_page / 2;
1675 - /* release locks on all the groups */
1676 - for (i = 0; i < locked_group; i++) {
1678 - grp = ext4_get_group_info(sb, first_group + i);
1679 - /* take all groups write allocation
1680 - * semaphore. This make sure there is
1681 - * no block allocation going on in any
1684 - up_write(&grp->alloc_sem);
1689 -static int ext4_mb_init_group(struct super_block *sb, ext4_group_t group)
1694 - int blocks_per_page;
1695 - int block, pnum, poff;
1696 - int num_grp_locked = 0;
1697 - struct ext4_group_info *this_grp;
1698 - struct ext4_sb_info *sbi = EXT4_SB(sb);
1699 - struct inode *inode = sbi->s_buddy_cache;
1700 - struct page *page = NULL, *bitmap_page = NULL;
1702 - mb_debug("init group %lu\n", group);
1703 - blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
1704 - this_grp = ext4_get_group_info(sb, group);
1706 - * This ensures we don't add group
1707 - * to this buddy cache via resize
1709 - num_grp_locked = ext4_mb_get_buddy_cache_lock(sb, group);
1710 - if (!EXT4_MB_GRP_NEED_INIT(this_grp)) {
1712 - * somebody initialized the group
1713 - * return without doing anything
1719 - * the buddy cache inode stores the block bitmap
1720 - * and buddy information in consecutive blocks.
1721 - * So for each group we need two blocks.
1723 - block = group * 2;
1724 - pnum = block / blocks_per_page;
1725 - poff = block % blocks_per_page;
1726 - page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
1728 - BUG_ON(page->mapping != inode->i_mapping);
1729 - ret = ext4_mb_init_cache(page, NULL);
1731 - unlock_page(page);
1734 - unlock_page(page);
1736 - if (page == NULL || !PageUptodate(page)) {
1740 - mark_page_accessed(page);
1741 - bitmap_page = page;
1742 - bitmap = page_address(page) + (poff * sb->s_blocksize);
1744 - /* init buddy cache */
1746 - pnum = block / blocks_per_page;
1747 - poff = block % blocks_per_page;
1748 - page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
1749 - if (page == bitmap_page) {
1751 - * If both the bitmap and buddy are in
1752 - * the same page we don't need to force
1755 - unlock_page(page);
1756 - } else if (page) {
1757 - BUG_ON(page->mapping != inode->i_mapping);
1758 - ret = ext4_mb_init_cache(page, bitmap);
1760 - unlock_page(page);
1763 - unlock_page(page);
1765 - if (page == NULL || !PageUptodate(page)) {
1769 - mark_page_accessed(page);
1771 - ext4_mb_put_buddy_cache_lock(sb, group, num_grp_locked);
1773 - page_cache_release(bitmap_page);
1775 - page_cache_release(page);
1779 static noinline_for_stack int
1780 ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
1782 @@ -2020,7 +1775,7 @@
1785 /* quick check to skip empty groups */
1786 + grp = ext4_get_group_info(ac->ac_sb, group);
1787 - grp = ext4_get_group_info(sb, group);
1788 if (grp->bb_free == 0)
1791 @@ -2033,9 +1788,10 @@
1792 * we need full data about the group
1793 * to make a good selection
1795 + err = ext4_mb_load_buddy(sb, group, &e4b);
1796 - err = ext4_mb_init_group(sb, group);
1799 + ext4_mb_release_desc(&e4b);
1803 @@ -2543,8 +2299,6 @@
1806 INIT_LIST_HEAD(&meta_group_info[i]->bb_prealloc_list);
1807 - init_rwsem(&meta_group_info[i]->alloc_sem);
1808 - meta_group_info[i]->bb_free_root.rb_node = NULL;;
1812 @@ -2571,6 +2325,54 @@
1813 } /* ext4_mb_add_groupinfo */
1816 + * Add a group to the existing groups.
1817 + * This function is used for online resize
1819 +int ext4_mb_add_more_groupinfo(struct super_block *sb, ext4_group_t group,
1820 + struct ext4_group_desc *desc)
1822 + struct ext4_sb_info *sbi = EXT4_SB(sb);
1823 + struct inode *inode = sbi->s_buddy_cache;
1824 + int blocks_per_page;
1827 + struct page *page;
1830 + /* Add group based on group descriptor*/
1831 + err = ext4_mb_add_groupinfo(sb, group, desc);
1836 + * Cache pages containing dynamic mb_alloc datas (buddy and bitmap
1837 + * datas) are set not up to date so that they will be re-initilaized
1838 + * during the next call to ext4_mb_load_buddy
1841 + /* Set buddy page as not up to date */
1842 + blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
1843 + block = group * 2;
1844 + pnum = block / blocks_per_page;
1845 + page = find_get_page(inode->i_mapping, pnum);
1846 + if (page != NULL) {
1847 + ClearPageUptodate(page);
1848 + page_cache_release(page);
1851 + /* Set bitmap page as not up to date */
1853 + pnum = block / blocks_per_page;
1854 + page = find_get_page(inode->i_mapping, pnum);
1855 + if (page != NULL) {
1856 + ClearPageUptodate(page);
1857 + page_cache_release(page);
1864 * Update an existing group.
1865 * This function is used for online resize
1867 @@ -2693,12 +2495,10 @@
1868 clear_opt(sbi->s_mount_opt, MBALLOC);
1872 - i = (sb->s_blocksize_bits + 2) * sizeof(unsigned int);
1873 sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL);
1874 if (sbi->s_mb_maxs == NULL) {
1875 clear_opt(sbi->s_mount_opt, MBALLOC);
1876 + kfree(sbi->s_mb_maxs);
1877 - kfree(sbi->s_mb_offsets);
1881 @@ -2858,11 +2658,13 @@
1882 static noinline_for_stack void
1883 ext4_mb_free_committed_blocks(struct super_block *sb)
1885 + struct ext4_sb_info *sbi = EXT4_SB(sb);
1890 + struct ext4_free_metadata *md;
1891 struct ext4_buddy e4b;
1892 - struct ext4_group_info *db;
1893 - struct ext4_sb_info *sbi = EXT4_SB(sb);
1894 - int err, count = 0, count2 = 0;
1895 - struct ext4_free_data *entry;
1897 if (list_empty(&sbi->s_committed_transaction))
1899 @@ -2870,46 +2672,44 @@
1900 /* there is committed blocks to be freed yet */
1902 /* get next array of blocks */
1905 spin_lock(&sbi->s_md_lock);
1906 if (!list_empty(&sbi->s_committed_transaction)) {
1907 + md = list_entry(sbi->s_committed_transaction.next,
1908 + struct ext4_free_metadata, list);
1909 + list_del(&md->list);
1910 - entry = list_entry(sbi->s_committed_transaction.next,
1911 - struct ext4_free_data, list);
1912 - list_del(&entry->list);
1914 spin_unlock(&sbi->s_md_lock);
1917 - if (entry == NULL)
1920 mb_debug("gonna free %u blocks in group %lu (0x%p):",
1921 + md->num, md->group, md);
1922 - entry->count, entry->group, entry);
1924 + err = ext4_mb_load_buddy(sb, md->group, &e4b);
1925 - err = ext4_mb_load_buddy(sb, entry->group, &e4b);
1926 /* we expect to find existing buddy because it's pinned */
1930 /* there are blocks to put in buddy to make them really free */
1932 - count += entry->count;
1934 + ext4_lock_group(sb, md->group);
1935 + for (i = 0; i < md->num; i++) {
1936 + mb_debug(" %u", md->blocks[i]);
1937 + mb_free_blocks(NULL, &e4b, md->blocks[i], 1);
1938 - ext4_lock_group(sb, entry->group);
1939 - /* Take it out of per group rb tree */
1940 - rb_erase(&entry->node, &(db->bb_free_root));
1941 - mb_free_blocks(NULL, &e4b, entry->start_blk, entry->count);
1943 - if (!db->bb_free_root.rb_node) {
1944 - /* No more items in the per group rb tree
1945 - * balance refcounts from ext4_mb_free_metadata()
1947 - page_cache_release(e4b.bd_buddy_page);
1948 - page_cache_release(e4b.bd_bitmap_page);
1951 + ext4_unlock_group(sb, md->group);
1952 - ext4_unlock_group(sb, entry->group);
1954 + /* balance refcounts from ext4_mb_free_metadata() */
1955 + page_cache_release(e4b.bd_buddy_page);
1956 + page_cache_release(e4b.bd_bitmap_page);
1959 - kmem_cache_free(ext4_free_ext_cachep, entry);
1960 ext4_mb_release_desc(&e4b);
1965 mb_debug("freed %u blocks in %u structures\n", count, count2);
1967 @@ -3064,16 +2864,6 @@
1968 kmem_cache_destroy(ext4_pspace_cachep);
1972 - ext4_free_ext_cachep =
1973 - kmem_cache_create("ext4_free_block_extents",
1974 - sizeof(struct ext4_free_data),
1975 - 0, SLAB_RECLAIM_ACCOUNT, NULL);
1976 - if (ext4_free_ext_cachep == NULL) {
1977 - kmem_cache_destroy(ext4_pspace_cachep);
1978 - kmem_cache_destroy(ext4_ac_cachep);
1981 #ifdef CONFIG_PROC_FS
1982 proc_root_ext4 = proc_mkdir("fs/ext4", NULL);
1983 if (proc_root_ext4 == NULL)
1984 @@ -3090,7 +2880,6 @@
1985 #ifdef CONFIG_PROC_FS
1986 remove_proc_entry("fs/ext4", NULL);
1988 - kmem_cache_destroy(ext4_free_ext_cachep);
1992 @@ -3152,8 +2941,8 @@
1993 in_range(block + len - 1, ext4_inode_table(sb, gdp),
1994 EXT4_SB(sb)->s_itb_per_group)) {
1995 ext4_error(sb, __func__,
1996 + "Allocating block in system zone - block = %llu",
1998 - "Allocating block %llu in system zone of %lu group\n",
1999 - block, ac->ac_b_ex.fe_group);
2000 /* File system mounted not to panic on error
2001 * Fix the bitmap and repeat the block allocation
2002 * We leak some of the blocks here.
2003 @@ -3175,9 +2964,10 @@
2007 + mb_set_bits(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group), bitmap_bh->b_data,
2008 + ac->ac_b_ex.fe_start, ac->ac_b_ex.fe_len);
2010 spin_lock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
2011 - mb_set_bits(NULL, bitmap_bh->b_data,
2012 - ac->ac_b_ex.fe_start, ac->ac_b_ex.fe_len);
2013 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
2014 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
2015 gdp->bg_free_blocks_count =
2016 @@ -3400,7 +3190,7 @@
2018 BUG_ON(start + size <= ac->ac_o_ex.fe_logical &&
2019 start > ac->ac_o_ex.fe_logical);
2020 + BUG_ON(size <= 0 || size >= EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
2021 - BUG_ON(size <= 0 || size > EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
2023 /* now prepare goal request */
2025 @@ -3610,37 +3400,10 @@
2026 ac->ac_criteria = 20;
2034 - * the function goes through all block freed in the group
2035 - * but not yet committed and marks them used in in-core bitmap.
2036 - * buddy must be generated from this bitmap
2037 - * Need to be called with ext4 group lock (ext4_lock_group)
2039 -static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
2040 - ext4_group_t group)
2042 - struct rb_node *n;
2043 - struct ext4_group_info *grp;
2044 - struct ext4_free_data *entry;
2046 - grp = ext4_get_group_info(sb, group);
2047 - n = rb_first(&(grp->bb_free_root));
2050 - entry = rb_entry(n, struct ext4_free_data, node);
2051 - mb_set_bits(sb_bgl_lock(EXT4_SB(sb), group),
2052 - bitmap, entry->start_blk,
2060 * the function goes through all preallocation in this group and marks them
2061 * used in in-core bitmap. buddy must be generated from this bitmap
2062 * Need to be called with ext4 group lock (ext4_lock_group)
2063 @@ -3698,7 +3461,6 @@
2064 struct super_block *sb, struct ext4_prealloc_space *pa)
2067 - ext4_fsblk_t grp_blk;
2069 if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0)
2071 @@ -3713,12 +3475,8 @@
2073 spin_unlock(&pa->pa_lock);
2075 + /* -1 is to protect from crossing allocation group */
2076 + ext4_get_group_no_and_offset(sb, pa->pa_pstart - 1, &grp, NULL);
2077 - grp_blk = pa->pa_pstart;
2078 - /* If linear, pa_pstart may be in the next group when pa is used up */
2079 - if (pa->pa_linear)
2082 - ext4_get_group_no_and_offset(sb, grp_blk, &grp, NULL);
2086 @@ -3807,8 +3565,6 @@
2087 pa->pa_free = pa->pa_len;
2088 atomic_set(&pa->pa_count, 1);
2089 spin_lock_init(&pa->pa_lock);
2090 - INIT_LIST_HEAD(&pa->pa_inode_list);
2091 - INIT_LIST_HEAD(&pa->pa_group_list);
2095 @@ -3867,7 +3623,6 @@
2096 atomic_set(&pa->pa_count, 1);
2097 spin_lock_init(&pa->pa_lock);
2098 INIT_LIST_HEAD(&pa->pa_inode_list);
2099 - INIT_LIST_HEAD(&pa->pa_group_list);
2103 @@ -4411,7 +4166,6 @@
2105 ac->ac_bitmap_page = NULL;
2106 ac->ac_buddy_page = NULL;
2107 - ac->alloc_semp = NULL;
2110 /* we have to define context: we'll we work with a file or
2111 @@ -4532,7 +4286,7 @@
2113 spin_lock(&tmp_pa->pa_lock);
2114 if (tmp_pa->pa_deleted) {
2115 + spin_unlock(&pa->pa_lock);
2116 - spin_unlock(&tmp_pa->pa_lock);
2119 if (!added && pa->pa_free < tmp_pa->pa_free) {
2120 @@ -4577,23 +4331,18 @@
2121 pa->pa_free -= ac->ac_b_ex.fe_len;
2122 pa->pa_len -= ac->ac_b_ex.fe_len;
2123 spin_unlock(&pa->pa_lock);
2125 + * We want to add the pa to the right bucket.
2126 + * Remove it from the list and while adding
2127 + * make sure the list to which we are adding
2128 + * doesn't grow big.
2130 + if (likely(pa->pa_free)) {
2131 + spin_lock(pa->pa_obj_lock);
2132 + list_del_rcu(&pa->pa_inode_list);
2133 + spin_unlock(pa->pa_obj_lock);
2134 + ext4_mb_add_n_trim(ac);
2138 - if (ac->alloc_semp)
2139 - up_read(ac->alloc_semp);
2142 - * We want to add the pa to the right bucket.
2143 - * Remove it from the list and while adding
2144 - * make sure the list to which we are adding
2145 - * doesn't grow big. We need to release
2146 - * alloc_semp before calling ext4_mb_add_n_trim()
2148 - if (pa->pa_linear && likely(pa->pa_free)) {
2149 - spin_lock(pa->pa_obj_lock);
2150 - list_del_rcu(&pa->pa_inode_list);
2151 - spin_unlock(pa->pa_obj_lock);
2152 - ext4_mb_add_n_trim(ac);
2154 ext4_mb_put_pa(ac, ac->ac_sb, pa);
2156 @@ -4700,14 +4449,10 @@
2157 ac->ac_o_ex.fe_len < ac->ac_b_ex.fe_len)
2158 ext4_mb_new_preallocation(ac);
2161 if (likely(ac->ac_status == AC_STATUS_FOUND)) {
2162 *errp = ext4_mb_mark_diskspace_used(ac, handle);
2163 if (*errp == -EAGAIN) {
2165 - * drop the reference that we took
2166 - * in ext4_mb_use_best_found
2168 - ext4_mb_release_context(ac);
2169 ac->ac_b_ex.fe_group = 0;
2170 ac->ac_b_ex.fe_start = 0;
2171 ac->ac_b_ex.fe_len = 0;
2172 @@ -4772,97 +4517,65 @@
2173 ext4_mb_free_committed_blocks(sb);
2177 - * We can merge two free data extents only if the physical blocks
2178 - * are contiguous, AND the extents were freed by the same transaction,
2179 - * AND the blocks are associated with the same group.
2181 -static int can_merge(struct ext4_free_data *entry1,
2182 - struct ext4_free_data *entry2)
2184 - if ((entry1->t_tid == entry2->t_tid) &&
2185 - (entry1->group == entry2->group) &&
2186 - ((entry1->start_blk + entry1->count) == entry2->start_blk))
2191 static noinline_for_stack int
2192 ext4_mb_free_metadata(handle_t *handle, struct ext4_buddy *e4b,
2193 + ext4_group_t group, ext4_grpblk_t block, int count)
2194 - struct ext4_free_data *new_entry)
2196 - ext4_grpblk_t block;
2197 - struct ext4_free_data *entry;
2198 struct ext4_group_info *db = e4b->bd_info;
2199 struct super_block *sb = e4b->bd_sb;
2200 struct ext4_sb_info *sbi = EXT4_SB(sb);
2201 + struct ext4_free_metadata *md;
2203 - struct rb_node **n = &db->bb_free_root.rb_node, *node;
2204 - struct rb_node *parent = NULL, *new_node;
2206 BUG_ON(e4b->bd_bitmap_page == NULL);
2207 BUG_ON(e4b->bd_buddy_page == NULL);
2209 + ext4_lock_group(sb, group);
2210 + for (i = 0; i < count; i++) {
2211 + md = db->bb_md_cur;
2212 + if (md && db->bb_tid != handle->h_transaction->t_tid) {
2213 + db->bb_md_cur = NULL;
2215 - new_node = &new_entry->node;
2216 - block = new_entry->start_blk;
2219 - /* first free block exent. We need to
2220 - protect buddy cache from being freed,
2221 - * otherwise we'll refresh it from
2222 - * on-disk bitmap and lose not-yet-available
2224 - page_cache_get(e4b->bd_buddy_page);
2225 - page_cache_get(e4b->bd_bitmap_page);
2229 - entry = rb_entry(parent, struct ext4_free_data, node);
2230 - if (block < entry->start_blk)
2231 - n = &(*n)->rb_left;
2232 - else if (block >= (entry->start_blk + entry->count))
2233 - n = &(*n)->rb_right;
2235 - ext4_error(sb, __func__,
2236 - "Double free of blocks %d (%d %d)\n",
2237 - block, entry->start_blk, entry->count);
2243 + ext4_unlock_group(sb, group);
2244 + md = kmalloc(sizeof(*md), GFP_NOFS);
2248 + md->group = group;
2250 + ext4_lock_group(sb, group);
2251 + if (db->bb_md_cur == NULL) {
2252 + spin_lock(&sbi->s_md_lock);
2253 + list_add(&md->list, &sbi->s_active_transaction);
2254 + spin_unlock(&sbi->s_md_lock);
2255 + /* protect buddy cache from being freed,
2256 + * otherwise we'll refresh it from
2257 + * on-disk bitmap and lose not-yet-available
2259 + page_cache_get(e4b->bd_buddy_page);
2260 + page_cache_get(e4b->bd_bitmap_page);
2261 + db->bb_md_cur = md;
2262 + db->bb_tid = handle->h_transaction->t_tid;
2263 + mb_debug("new md 0x%p for group %lu\n",
2267 + md = db->bb_md_cur;
2269 - rb_link_node(new_node, parent, n);
2270 - rb_insert_color(new_node, &db->bb_free_root);
2272 - /* Now try to see the extent can be merged to left and right */
2273 - node = rb_prev(new_node);
2275 - entry = rb_entry(node, struct ext4_free_data, node);
2276 - if (can_merge(entry, new_entry)) {
2277 - new_entry->start_blk = entry->start_blk;
2278 - new_entry->count += entry->count;
2279 - rb_erase(node, &(db->bb_free_root));
2280 - spin_lock(&sbi->s_md_lock);
2281 - list_del(&entry->list);
2282 - spin_unlock(&sbi->s_md_lock);
2283 - kmem_cache_free(ext4_free_ext_cachep, entry);
2287 + BUG_ON(md->num >= EXT4_BB_MAX_BLOCKS);
2288 + md->blocks[md->num] = block + i;
2290 + if (md->num == EXT4_BB_MAX_BLOCKS) {
2291 + /* no more space, put full container on a sb's list */
2292 + db->bb_md_cur = NULL;
2293 - node = rb_next(new_node);
2295 - entry = rb_entry(node, struct ext4_free_data, node);
2296 - if (can_merge(new_entry, entry)) {
2297 - new_entry->count += entry->count;
2298 - rb_erase(node, &(db->bb_free_root));
2299 - spin_lock(&sbi->s_md_lock);
2300 - list_del(&entry->list);
2301 - spin_unlock(&sbi->s_md_lock);
2302 - kmem_cache_free(ext4_free_ext_cachep, entry);
2305 + ext4_unlock_group(sb, group);
2306 - /* Add the extent to active_transaction list */
2307 - spin_lock(&sbi->s_md_lock);
2308 - list_add(&new_entry->list, &sbi->s_active_transaction);
2309 - spin_unlock(&sbi->s_md_lock);
2313 @@ -4962,6 +4675,11 @@
2314 err = ext4_journal_get_write_access(handle, gd_bh);
2318 + err = ext4_mb_load_buddy(sb, block_group, &e4b);
2320 + goto error_return;
2322 #ifdef AGGRESSIVE_CHECK
2325 @@ -4969,6 +4687,13 @@
2326 BUG_ON(!mb_test_bit(bit + i, bitmap_bh->b_data));
2329 + mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
2332 + /* We dirtied the bitmap block */
2333 + BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
2334 + err = ext4_journal_dirty_metadata(handle, bitmap_bh);
2337 ac->ac_b_ex.fe_group = block_group;
2338 ac->ac_b_ex.fe_start = bit;
2339 @@ -4976,33 +4701,12 @@
2340 ext4_mb_store_history(ac);
2343 - err = ext4_mb_load_buddy(sb, block_group, &e4b);
2345 - goto error_return;
2347 + /* blocks being freed are metadata. these blocks shouldn't
2348 + * be used until this transaction is committed */
2349 + ext4_mb_free_metadata(handle, &e4b, block_group, bit, count);
2350 - struct ext4_free_data *new_entry;
2352 - * blocks being freed are metadata. these blocks shouldn't
2353 - * be used until this transaction is committed
2355 - new_entry = kmem_cache_alloc(ext4_free_ext_cachep, GFP_NOFS);
2356 - new_entry->start_blk = bit;
2357 - new_entry->group = block_group;
2358 - new_entry->count = count;
2359 - new_entry->t_tid = handle->h_transaction->t_tid;
2360 - ext4_lock_group(sb, block_group);
2361 - mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
2363 - ext4_mb_free_metadata(handle, &e4b, new_entry);
2364 - ext4_unlock_group(sb, block_group);
2366 ext4_lock_group(sb, block_group);
2367 - /* need to update group_info->bb_free and bitmap
2368 - * with group lock held. generate_buddy look at
2369 - * them with group lock_held
2371 - mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
2373 mb_free_blocks(inode, &e4b, bit, count);
2374 ext4_mb_return_to_preallocation(inode, &e4b, block, count);
2375 ext4_unlock_group(sb, block_group);
2376 @@ -5025,10 +4729,6 @@
2380 - /* We dirtied the bitmap block */
2381 - BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
2382 - err = ext4_journal_dirty_metadata(handle, bitmap_bh);
2384 /* And the group descriptor block */
2385 BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
2386 ret = ext4_journal_dirty_metadata(handle, gd_bh);
2388 --- b/fs/ext4/mballoc.h
2389 +++ a/fs/ext4/mballoc.h
2391 #include <linux/pagemap.h>
2392 #include <linux/seq_file.h>
2393 #include <linux/version.h>
2394 -#include <linux/mutex.h>
2395 #include "ext4_jbd2.h"
2400 #define MB_DEFAULT_GROUP_PREALLOC 512
2402 +static struct kmem_cache *ext4_pspace_cachep;
2403 +static struct kmem_cache *ext4_ac_cachep;
2404 -struct ext4_free_data {
2405 - /* this links the free block information from group_info */
2406 - struct rb_node node;
2408 +#ifdef EXT4_BB_MAX_BLOCKS
2409 +#undef EXT4_BB_MAX_BLOCKS
2411 +#define EXT4_BB_MAX_BLOCKS 30
2412 - /* this links the free block information from ext4_sb_info */
2413 - struct list_head list;
2415 +struct ext4_free_metadata {
2416 - /* group which free block extent belongs */
2418 + unsigned short num;
2419 + ext4_grpblk_t blocks[EXT4_BB_MAX_BLOCKS];
2420 + struct list_head list;
2422 - /* free block extent */
2423 - ext4_grpblk_t start_blk;
2424 - ext4_grpblk_t count;
2426 - /* transaction which freed this extent */
2430 struct ext4_group_info {
2431 unsigned long bb_state;
2432 + unsigned long bb_tid;
2433 + struct ext4_free_metadata *bb_md_cur;
2434 - struct rb_root bb_free_root;
2435 unsigned short bb_first_free;
2436 unsigned short bb_free;
2437 unsigned short bb_fragments;
2442 - struct rw_semaphore alloc_sem;
2443 unsigned short bb_counters[];
2446 @@ -213,11 +209,6 @@
2447 __u8 ac_op; /* operation, for history only */
2448 struct page *ac_bitmap_page;
2449 struct page *ac_buddy_page;
2451 - * pointer to the held semaphore upon successful
2452 - * block allocation
2454 - struct rw_semaphore *alloc_semp;
2455 struct ext4_prealloc_space *ac_pa;
2456 struct ext4_locality_group *ac_lg;
2459 struct super_block *bd_sb;
2461 ext4_group_t bd_group;
2462 - struct rw_semaphore *alloc_semp;
2464 #define EXT4_MB_BITMAP(e4b) ((e4b)->bd_bitmap)
2465 #define EXT4_MB_BUDDY(e4b) ((e4b)->bd_buddy)
2471 +static void ext4_mb_store_history(struct ext4_allocation_context *ac);
2474 #define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
2475 @@ -268,6 +260,19 @@
2476 static struct proc_dir_entry *proc_root_ext4;
2477 struct buffer_head *read_block_bitmap(struct super_block *, ext4_group_t);
2479 +static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
2480 + ext4_group_t group);
2481 +static void ext4_mb_poll_new_transaction(struct super_block *, handle_t *);
2482 +static void ext4_mb_free_committed_blocks(struct super_block *);
2483 +static void ext4_mb_return_to_preallocation(struct inode *inode,
2484 + struct ext4_buddy *e4b, sector_t block,
2486 +static void ext4_mb_put_pa(struct ext4_allocation_context *,
2487 + struct super_block *, struct ext4_prealloc_space *pa);
2488 +static int ext4_mb_init_per_dev_proc(struct super_block *sb);
2489 +static int ext4_mb_destroy_per_dev_proc(struct super_block *sb);
2492 static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
2494 struct ext4_group_info *grinfo = ext4_get_group_info(sb, group);
2496 &(grinfo->bb_state));
2499 +static ext4_fsblk_t ext4_grp_offs_to_block(struct super_block *sb,
2500 -static inline ext4_fsblk_t ext4_grp_offs_to_block(struct super_block *sb,
2501 struct ext4_free_extent *fex)
2505 --- b/fs/ext4/migrate.c
2506 +++ a/fs/ext4/migrate.c
2509 if (IS_ERR(handle)) {
2510 retval = PTR_ERR(handle);
2514 tmp_inode = ext4_new_inode(handle,
2515 inode->i_sb->s_root->d_inode,
2517 if (IS_ERR(tmp_inode)) {
2519 ext4_journal_stop(handle);
2524 i_size_write(tmp_inode, i_size_read(inode));
2528 ext4_journal_stop(handle);
2537 --- b/fs/ext4/namei.c
2538 +++ a/fs/ext4/namei.c
2542 hinfo->hash_version = root->info.hash_version;
2543 - if (hinfo->hash_version <= DX_HASH_TEA)
2544 - hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2545 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2547 ext4fs_dirhash(dentry->d_name.name, dentry->d_name.len, hinfo);
2549 dir = dir_file->f_path.dentry->d_inode;
2550 if (!(EXT4_I(dir)->i_flags & EXT4_INDEX_FL)) {
2551 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
2552 - if (hinfo.hash_version <= DX_HASH_TEA)
2553 - hinfo.hash_version +=
2554 - EXT4_SB(dir->i_sb)->s_hash_unsigned;
2555 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2556 count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
2557 start_hash, start_minor_hash);
2558 @@ -1055,16 +1050,8 @@
2559 return ERR_PTR(-EIO);
2561 inode = ext4_iget(dir->i_sb, ino);
2562 + if (IS_ERR(inode))
2563 + return ERR_CAST(inode);
2564 - if (unlikely(IS_ERR(inode))) {
2565 - if (PTR_ERR(inode) == -ESTALE) {
2566 - ext4_error(dir->i_sb, __func__,
2567 - "deleted inode referenced: %u",
2569 - return ERR_PTR(-EIO);
2571 - return ERR_CAST(inode);
2575 return d_splice_alias(inode, dentry);
2577 @@ -1390,7 +1377,7 @@
2578 struct fake_dirent *fde;
2580 blocksize = dir->i_sb->s_blocksize;
2581 + dxtrace(printk("Creating index\n"));
2582 - dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2583 retval = ext4_journal_get_write_access(handle, bh);
2585 ext4_std_error(dir->i_sb, retval);
2586 @@ -1399,20 +1386,6 @@
2588 root = (struct dx_root *) bh->b_data;
2590 - /* The 0th block becomes the root, move the dirents out */
2591 - fde = &root->dotdot;
2592 - de = (struct ext4_dir_entry_2 *)((char *)fde +
2593 - ext4_rec_len_from_disk(fde->rec_len));
2594 - if ((char *) de >= (((char *) root) + blocksize)) {
2595 - ext4_error(dir->i_sb, __func__,
2596 - "invalid rec_len for '..' in inode %lu",
2601 - len = ((char *) root) + blocksize - (char *) de;
2603 - /* Allocate new block for the 0th block's dirents */
2604 bh2 = ext4_append (handle, dir, &block, &retval);
2607 @@ -1421,6 +1394,11 @@
2608 EXT4_I(dir)->i_flags |= EXT4_INDEX_FL;
2609 data1 = bh2->b_data;
2611 + /* The 0th block becomes the root, move the dirents out */
2612 + fde = &root->dotdot;
2613 + de = (struct ext4_dir_entry_2 *)((char *)fde +
2614 + ext4_rec_len_from_disk(fde->rec_len));
2615 + len = ((char *) root) + blocksize - (char *) de;
2616 memcpy (data1, de, len);
2617 de = (struct ext4_dir_entry_2 *) data1;
2619 @@ -1440,8 +1418,6 @@
2621 /* Initialize as for dx_probe */
2622 hinfo.hash_version = root->info.hash_version;
2623 - if (hinfo.hash_version <= DX_HASH_TEA)
2624 - hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2625 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2626 ext4fs_dirhash(name, namelen, &hinfo);
2628 @@ -2314,7 +2290,7 @@
2629 struct inode * old_inode, * new_inode;
2630 struct buffer_head * old_bh, * new_bh, * dir_bh;
2631 struct ext4_dir_entry_2 * old_de, * new_de;
2633 - int retval, force_da_alloc = 0;
2635 old_bh = new_bh = dir_bh = NULL;
2637 @@ -2452,7 +2428,6 @@
2638 ext4_mark_inode_dirty(handle, new_inode);
2639 if (!new_inode->i_nlink)
2640 ext4_orphan_add(handle, new_inode);
2641 - force_da_alloc = 1;
2645 @@ -2461,8 +2436,6 @@
2648 ext4_journal_stop(handle);
2649 - if (retval == 0 && force_da_alloc)
2650 - ext4_alloc_da_blocks(old_inode);
2655 --- b/fs/ext4/resize.c
2656 +++ a/fs/ext4/resize.c
2657 @@ -284,9 +284,11 @@
2658 if ((err = extend_or_restart_transaction(handle, 2, bh)))
2661 + mark_bitmap_end(input->blocks_count, EXT4_BLOCKS_PER_GROUP(sb),
2663 - mark_bitmap_end(input->blocks_count, sb->s_blocksize * 8, bh->b_data);
2664 ext4_journal_dirty_metadata(handle, bh);
2667 /* Mark unused entries in inode bitmap used */
2668 ext4_debug("clear inode bitmap %#04llx (+%llu)\n",
2669 input->inode_bitmap, input->inode_bitmap - start);
2674 + mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), EXT4_BLOCKS_PER_GROUP(sb),
2675 - mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
2677 ext4_journal_dirty_metadata(handle, bh);
2680 struct inode *inode = NULL;
2682 int gdb_off, gdb_num;
2683 - int num_grp_locked = 0;
2686 gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb);
2692 if ((err = verify_group_input(sb, input)))
2695 @@ -855,18 +855,15 @@
2696 * using the new disk blocks.
2699 - num_grp_locked = ext4_mb_get_buddy_cache_lock(sb, input->group);
2700 /* Update group descriptor block for new group */
2701 gdp = (struct ext4_group_desc *)((char *)primary->b_data +
2702 gdb_off * EXT4_DESC_SIZE(sb));
2704 - memset(gdp, 0, EXT4_DESC_SIZE(sb));
2705 ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */
2706 ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */
2707 ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */
2708 gdp->bg_free_blocks_count = cpu_to_le16(input->free_blocks_count);
2709 gdp->bg_free_inodes_count = cpu_to_le16(EXT4_INODES_PER_GROUP(sb));
2710 - gdp->bg_flags = cpu_to_le16(EXT4_BG_INODE_ZEROED);
2711 gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp);
2714 @@ -874,11 +871,9 @@
2717 if (test_opt(sb, MBALLOC)) {
2718 + err = ext4_mb_add_more_groupinfo(sb, input->group, gdp);
2720 - err = ext4_mb_add_groupinfo(sb, input->group, gdp);
2722 - ext4_mb_put_buddy_cache_lock(sb, input->group, num_grp_locked);
2727 * Make the new blocks and inodes valid next. We do this before
2730 /* Update the global fs size fields */
2731 sbi->s_groups_count++;
2732 - ext4_mb_put_buddy_cache_lock(sb, input->group, num_grp_locked);
2734 ext4_journal_dirty_metadata(handle, primary);
2737 struct buffer_head * bh;
2740 + unsigned long freed_blocks;
2742 + struct ext4_group_info *grp;
2744 /* We don't need to worry about locking wrt other resizers just
2745 * yet: we're going to revalidate es->s_blocks_count after
2746 @@ -1081,13 +1077,50 @@
2748 ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
2749 o_blocks_count + add);
2750 + ext4_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks);
2751 - /* We add the blocks to the bitmap and set the group need init bit */
2752 - ext4_add_groupblocks(handle, sb, o_blocks_count, add);
2753 ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
2754 o_blocks_count + add);
2755 if ((err = ext4_journal_stop(handle)))
2759 + * Mark mballoc pages as not up to date so that they will be updated
2760 + * next time they are loaded by ext4_mb_load_buddy.
2762 + if (test_opt(sb, MBALLOC)) {
2763 + struct ext4_sb_info *sbi = EXT4_SB(sb);
2764 + struct inode *inode = sbi->s_buddy_cache;
2765 + int blocks_per_page;
2768 + struct page *page;
2770 + /* Set buddy page as not up to date */
2771 + blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
2772 + block = group * 2;
2773 + pnum = block / blocks_per_page;
2774 + page = find_get_page(inode->i_mapping, pnum);
2775 + if (page != NULL) {
2776 + ClearPageUptodate(page);
2777 + page_cache_release(page);
2780 + /* Set bitmap page as not up to date */
2782 + pnum = block / blocks_per_page;
2783 + page = find_get_page(inode->i_mapping, pnum);
2784 + if (page != NULL) {
2785 + ClearPageUptodate(page);
2786 + page_cache_release(page);
2789 + /* Get the info on the last group */
2790 + grp = ext4_get_group_info(sb, group);
2792 + /* Update free blocks in group info */
2793 + ext4_mb_update_group_info(grp, add);
2796 if (test_opt(sb, DEBUG))
2797 printk(KERN_DEBUG "EXT4-fs: extended group to %llu blocks\n",
2798 ext4_blocks_count(es));
2800 --- b/fs/ext4/super.c
2801 +++ a/fs/ext4/super.c
2802 @@ -1493,6 +1493,7 @@
2803 ext4_group_t flex_group_count;
2804 ext4_group_t flex_group;
2805 int groups_per_flex = 0;
2806 + __u64 block_bitmap = 0;
2809 if (!sbi->s_es->s_log_groups_per_flex) {
2810 @@ -1515,6 +1516,9 @@
2814 + gdp = ext4_get_group_desc(sb, 1, &bh);
2815 + block_bitmap = ext4_block_bitmap(sb, gdp) - 1;
2817 for (i = 0; i < sbi->s_groups_count; i++) {
2818 gdp = ext4_get_group_desc(sb, i, &bh);
2820 @@ -1916,8 +1920,8 @@
2826 - unsigned int db_count;
2831 @@ -2168,18 +2172,6 @@
2832 for (i = 0; i < 4; i++)
2833 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
2834 sbi->s_def_hash_version = es->s_def_hash_version;
2835 - i = le32_to_cpu(es->s_flags);
2836 - if (i & EXT2_FLAGS_UNSIGNED_HASH)
2837 - sbi->s_hash_unsigned = 3;
2838 - else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
2839 -#ifdef __CHAR_UNSIGNED__
2840 - es->s_flags |= cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
2841 - sbi->s_hash_unsigned = 3;
2843 - es->s_flags |= cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
2848 if (sbi->s_blocks_per_group > blocksize * 8) {
2850 @@ -2207,30 +2199,20 @@
2851 if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
2854 + /* ensure blocks_count calculation below doesn't sign-extend */
2855 + if (ext4_blocks_count(es) + EXT4_BLOCKS_PER_GROUP(sb) <
2856 + le32_to_cpu(es->s_first_data_block) + 1) {
2857 + printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu, "
2858 + "first data block %u, blocks per group %lu\n",
2859 + ext4_blocks_count(es),
2860 + le32_to_cpu(es->s_first_data_block),
2861 + EXT4_BLOCKS_PER_GROUP(sb));
2863 - * It makes no sense for the first data block to be beyond the end
2864 - * of the filesystem.
2866 - if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
2867 - printk(KERN_WARNING "EXT4-fs: bad geometry: first data"
2868 - "block %u is beyond end of filesystem (%llu)\n",
2869 - le32_to_cpu(es->s_first_data_block),
2870 - ext4_blocks_count(es));
2873 blocks_count = (ext4_blocks_count(es) -
2874 le32_to_cpu(es->s_first_data_block) +
2875 EXT4_BLOCKS_PER_GROUP(sb) - 1);
2876 do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
2877 - if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
2878 - printk(KERN_WARNING "EXT4-fs: groups count too large: %u "
2879 - "(block count %llu, first data block %u, "
2880 - "blocks per group %lu)\n", sbi->s_groups_count,
2881 - ext4_blocks_count(es),
2882 - le32_to_cpu(es->s_first_data_block),
2883 - EXT4_BLOCKS_PER_GROUP(sb));
2884 - goto failed_mount;
2886 sbi->s_groups_count = blocks_count;
2887 db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
2888 EXT4_DESC_PER_BLOCK(sb);
2889 @@ -2950,14 +2932,14 @@
2891 static int ext4_sync_fs(struct super_block *sb, int wait)
2898 + ret = ext4_force_commit(sb);
2900 + jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, NULL);
2902 - if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
2904 - jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
2911 --- b/fs/jbd2/commit.c
2912 +++ a/fs/jbd2/commit.c
2914 #include <linux/crc32.h>
2915 #include <linux/writeback.h>
2916 #include <linux/backing-dev.h>
2917 -#include <linux/bio.h>
2920 * Default IO end handler for temporary BJ_IO buffer_heads.
2921 @@ -171,34 +170,12 @@
2922 * This function along with journal_submit_commit_record
2923 * allows to write the commit record asynchronously.
2925 +static int journal_wait_on_commit_record(struct buffer_head *bh)
2926 -static int journal_wait_on_commit_record(journal_t *journal,
2927 - struct buffer_head *bh)
2932 clear_buffer_dirty(bh);
2934 - if (buffer_eopnotsupp(bh) && (journal->j_flags & JBD2_BARRIER)) {
2935 - printk(KERN_WARNING
2936 - "JBD2: wait_on_commit_record: sync failed on %s - "
2937 - "disabling barriers\n", journal->j_devname);
2938 - spin_lock(&journal->j_state_lock);
2939 - journal->j_flags &= ~JBD2_BARRIER;
2940 - spin_unlock(&journal->j_state_lock);
2943 - clear_buffer_dirty(bh);
2944 - set_buffer_uptodate(bh);
2945 - bh->b_end_io = journal_end_buffer_io_sync;
2947 - ret = submit_bh(WRITE_SYNC, bh);
2949 - unlock_buffer(bh);
2955 if (unlikely(!buffer_uptodate(bh)))
2958 __jbd2_journal_abort_hard(journal);
2960 if (!err && !is_journal_aborted(journal))
2961 + err = journal_wait_on_commit_record(cbh);
2962 - err = journal_wait_on_commit_record(journal, cbh);
2965 jbd2_journal_abort(journal, err);
2967 --- b/fs/jbd2/journal.c
2968 +++ a/fs/jbd2/journal.c
2973 + * Called under j_state_lock. Returns true if a transaction was started.
2974 - * Called under j_state_lock. Returns true if a transaction commit was started.
2976 int __jbd2_log_start_commit(journal_t *journal, tid_t target)
2981 * Start a commit of the current running transaction (if any). Returns true
2982 + * if a transaction was started, and fills its tid in at *ptid
2983 - * if a transaction is going to be committed (or is currently already
2984 - * committing), and fills its tid in at *ptid
2986 int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
2988 @@ -509,19 +508,15 @@
2989 if (journal->j_running_transaction) {
2990 tid_t tid = journal->j_running_transaction->t_tid;
2992 + ret = __jbd2_log_start_commit(journal, tid);
2994 - __jbd2_log_start_commit(journal, tid);
2995 - /* There's a running transaction and we've just made sure
2996 - * it's commit has been scheduled. */
2999 + } else if (journal->j_committing_transaction && ptid) {
3001 - } else if (journal->j_committing_transaction) {
3003 * If ext3_write_super() recently started a commit, then we
3004 * have to wait for completion of that transaction
3006 + *ptid = journal->j_committing_transaction->t_tid;
3008 - *ptid = journal->j_committing_transaction->t_tid;
3011 spin_unlock(&journal->j_state_lock);
3013 --- b/fs/jbd2/revoke.c
3014 +++ a/fs/jbd2/revoke.c
3017 * RevokeValid set, Revoked set:
3018 * buffer has been revoked.
3021 - * We keep two hash tables of revoke records. One hashtable belongs to the
3022 - * running transaction (is pointed to by journal->j_revoke), the other one
3023 - * belongs to the committing transaction. Accesses to the second hash table
3024 - * happen only from the kjournald and no other thread touches this table. Also
3025 - * journal_switch_revoke_table() which switches which hashtable belongs to the
3026 - * running and which to the committing transaction is called only from
3027 - * kjournald. Therefore we need no locks when accessing the hashtable belonging
3028 - * to the committing transaction.
3030 - * All users operating on the hash table belonging to the running transaction
3031 - * have a handle to the transaction. Therefore they are safe from kjournald
3032 - * switching hash tables under them. For operations on the lists of entries in
3033 - * the hash table j_revoke_lock is used.
3035 - * Finally, also replay code uses the hash tables but at this moment noone else
3036 - * can touch them (filesystem isn't mounted yet) and hence no locking is
3042 * the second time we would still have a pending revoke to cancel. So,
3043 * do not trust the Revoked bit on buffers unless RevokeValid is also
3046 + * The caller must have the journal locked.
3048 int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
3050 @@ -497,7 +480,10 @@
3052 * Write revoke records to the journal for all entries in the current
3053 * revoke hash, deleting the entries as we go.
3055 + * Called with the journal lock held.
3058 void jbd2_journal_write_revoke_records(journal_t *journal,
3059 transaction_t *transaction)
3062 --- b/fs/jbd2/transaction.c
3063 +++ a/fs/jbd2/transaction.c
3064 @@ -2049,46 +2049,26 @@
3068 + * This function must be called when inode is journaled in ordered mode
3069 + * before truncation happens. It starts writeout of truncated part in
3070 + * case it is in the committing transaction so that we stand to ordered
3071 + * mode consistency guarantees.
3072 - * File truncate and transaction commit interact with each other in a
3073 - * non-trivial way. If a transaction writing data block A is
3074 - * committing, we cannot discard the data by truncate until we have
3075 - * written them. Otherwise if we crashed after the transaction with
3076 - * write has committed but before the transaction with truncate has
3077 - * committed, we could see stale data in block A. This function is a
3078 - * helper to solve this problem. It starts writeout of the truncated
3079 - * part in case it is in the committing transaction.
3081 - * Filesystem code must call this function when inode is journaled in
3082 - * ordered mode before truncation happens and after the inode has been
3083 - * placed on orphan list with the new inode size. The second condition
3084 - * avoids the race that someone writes new data and we start
3085 - * committing the transaction after this function has been called but
3086 - * before a transaction for truncate is started (and furthermore it
3087 - * allows us to optimize the case where the addition to orphan list
3088 - * happens in the same transaction as write --- we don't have to write
3089 - * any data in such case).
3091 +int jbd2_journal_begin_ordered_truncate(struct jbd2_inode *inode,
3092 -int jbd2_journal_begin_ordered_truncate(journal_t *journal,
3093 - struct jbd2_inode *jinode,
3096 + journal_t *journal;
3097 + transaction_t *commit_trans;
3098 - transaction_t *inode_trans, *commit_trans;
3101 + if (!inode->i_transaction && !inode->i_next_transaction)
3102 - /* This is a quick check to avoid locking if not necessary */
3103 - if (!jinode->i_transaction)
3105 + journal = inode->i_transaction->t_journal;
3106 - /* Locks are here just to force reading of recent values, it is
3107 - * enough that the transaction was not committing before we started
3108 - * a transaction adding the inode to orphan list */
3109 spin_lock(&journal->j_state_lock);
3110 commit_trans = journal->j_committing_transaction;
3111 spin_unlock(&journal->j_state_lock);
3112 + if (inode->i_transaction == commit_trans) {
3113 + ret = filemap_fdatawrite_range(inode->i_vfs_inode->i_mapping,
3114 - spin_lock(&journal->j_list_lock);
3115 - inode_trans = jinode->i_transaction;
3116 - spin_unlock(&journal->j_list_lock);
3117 - if (inode_trans == commit_trans) {
3118 - ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
3119 new_size, LLONG_MAX);
3121 jbd2_journal_abort(journal, ret);
3123 --- b/include/linux/jbd2.h
3124 +++ a/include/linux/jbd2.h
3129 + "EXT3-fs unexpected failure: %s;\n",# expr); \
3130 - "JBD2 unexpected failure: %s: %s;\n", \
3131 - __func__, #expr); \
3132 printk(KERN_ERR why "\n"); \
3136 BH_State, /* Pins most journal_head state */
3137 BH_JournalHead, /* Pins bh->b_private and jh->b_bh */
3138 BH_Unshadow, /* Dummy bit, for BJ_Shadow wakeup filtering */
3139 - BH_JBDPrivateStart, /* First bit available for private use by FS */
3142 BUFFER_FNS(JBD, jbd)
3143 @@ -1075,8 +1073,7 @@
3144 extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
3145 extern int jbd2_journal_force_commit(journal_t *);
3146 extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
3147 +extern int jbd2_journal_begin_ordered_truncate(struct jbd2_inode *inode, loff_t new_size);
3148 -extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
3149 - struct jbd2_inode *inode, loff_t new_size);
3150 extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
3151 extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
projects / people / teissler / ipfire-2.x.git / blob