On Fri, 2006-03-24 at 06:05 -0800, Valerie Henson wrote:
> The fs-wide dirty bit patch is now functional - crashing the system
> while the file system is marked clean results in a clean fsck. This
> is mostly the result of porting Mingming's reservations and multiple
> block allocation patches to ext2. Changes since last patch:
>
> * Remove old preallocation code, replace with reservations
> * ext2 port of multiple block allocations
It seems that you will need to port back part of ext3_get_blocks() back
to ext2, to make use of the ext2_new_blocks() you just ported below, for
multiple block allocation. And also probably check ext2/3_direct_IO()
code, as it is the user of ext2/3 multiple block allocations.
> You probably also need to port
> * Use kthread API, fsync_super() (thanks, Andrew!)
> * Coding style fixes
> * Actual working-ness
>
> Next on my plate:
>
> * Finish OLS paper :)
> * Test on non-UML
> * Performance tests
> * Fix at least two known unlocked regions
> * Various patch monkey type items
> * Pay Arjan $10
>
> Thanks to everyone who reviewed and commented.
>
> Patch is still against 2.6.16-rc5-mm3.
>
> -VAL
>
> diff -x '*~' -uNr vanilla-linux/fs/ext2/balloc.c uml-clean/fs/ext2/balloc.c
> --- vanilla-linux/fs/ext2/balloc.c 2006-03-24 01:47:33.000000000 -0800
> +++ uml-clean/fs/ext2/balloc.c 2006-03-24 05:23:17.000000000 -0800
> @@ -95,41 +95,6 @@
> return bh;
> }
>
> -/*
> - * Set sb->s_dirt here because the superblock was "logically" altered. We
> - * need to recalculate its free blocks count and flush it out.
> - */
> -static int reserve_blocks(struct super_block *sb, int count)
> -{
> - struct ext2_sb_info *sbi = EXT2_SB(sb);
> - struct ext2_super_block *es = sbi->s_es;
> - unsigned free_blocks;
> - unsigned root_blocks;
> -
> - free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
> - root_blocks = le32_to_cpu(es->s_r_blocks_count);
> -
> - if (free_blocks < count)
> - count = free_blocks;
> -
> - if (free_blocks < root_blocks + count && !capable(CAP_SYS_RESOURCE) &&
> - sbi->s_resuid != current->fsuid &&
> - (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
> - /*
> - * We are too close to reserve and we are not privileged.
> - * Can we allocate anything at all?
> - */
> - if (free_blocks > root_blocks)
> - count = free_blocks - root_blocks;
> - else
> - return 0;
> - }
> -
> - percpu_counter_mod(&sbi->s_freeblocks_counter, -count);
> - sb->s_dirt = 1;
> - return count;
> -}
> -
> static void release_blocks(struct super_block *sb, int count)
> {
> if (count) {
> @@ -140,24 +105,6 @@
> }
> }
>
> -static int group_reserve_blocks(struct ext2_sb_info *sbi, int group_no,
> - struct ext2_group_desc *desc, struct buffer_head *bh, int count)
> -{
> - unsigned free_blocks;
> -
> - if (!desc->bg_free_blocks_count)
> - return 0;
> -
> - spin_lock(sb_bgl_lock(sbi, group_no));
> - free_blocks = le16_to_cpu(desc->bg_free_blocks_count);
> - if (free_blocks < count)
> - count = free_blocks;
> - desc->bg_free_blocks_count = cpu_to_le16(free_blocks - count);
> - spin_unlock(sb_bgl_lock(sbi, group_no));
> - mark_buffer_dirty(bh);
> - return count;
> -}
> -
> static void group_release_blocks(struct super_block *sb, int group_no,
> struct ext2_group_desc *desc, struct buffer_head *bh, int count)
> {
> @@ -170,10 +117,222 @@
> desc->bg_free_blocks_count = cpu_to_le16(free_blocks + count);
> spin_unlock(sb_bgl_lock(sbi, group_no));
> sb->s_dirt = 1;
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bh);
> }
> }
>
> +/*
> + * The reservation window structure operations
> + * --------------------------------------------
> + * Operations include:
> + * dump, find, add, remove, is_empty, find_next_reservable_window, etc.
> + *
> + * We use sorted double linked list for the per-filesystem reservation
> + * window list. (like in vm_region).
> + *
> + * Initially, we keep those small operations in the abstract functions,
> + * so later if we need a better searching tree than double linked-list,
> + * we could easily switch to that without changing too much
> + * code.
> + */
> +#if 0
> +static void __rsv_window_dump(struct rb_root *root, int verbose,
> + const char *fn)
> +{
> + struct rb_node *n;
> + struct ext2_reserve_window_node *rsv, *prev;
> + int bad;
> +
> +restart:
> + n = rb_first(root);
> + bad = 0;
> + prev = NULL;
> +
> + printk("Block Allocation Reservation Windows Map (%s):\n", fn);
> + while (n) {
> + rsv = list_entry(n, struct ext2_reserve_window_node, rsv_node);
> + if (verbose)
> + printk("reservation window 0x%p "
> + "start: %d, end: %d\n",
> + rsv, rsv->rsv_start, rsv->rsv_end);
> + if (rsv->rsv_start && rsv->rsv_start >= rsv->rsv_end) {
> + printk("Bad reservation %p (start >= end)\n",
> + rsv);
> + bad = 1;
> + }
> + if (prev && prev->rsv_end >= rsv->rsv_start) {
> + printk("Bad reservation %p (prev->end >= start)\n",
> + rsv);
> + bad = 1;
> + }
> + if (bad) {
> + if (!verbose) {
> + printk("Restarting reservation walk in verbose mode\n");
> + verbose = 1;
> + goto restart;
> + }
> + }
> + n = rb_next(n);
> + prev = rsv;
> + }
> + printk("Window map complete.\n");
> + if (bad)
> + BUG();
> +}
> +#define rsv_window_dump(root, verbose) \
> + __rsv_window_dump((root), (verbose), __FUNCTION__)
> +#else
> +#define rsv_window_dump(root, verbose) do {} while (0)
> +#endif
> +
> +static int
> +goal_in_my_reservation(struct ext2_reserve_window *rsv, int goal,
> + unsigned int group, struct super_block * sb)
> +{
> + unsigned long group_first_block, group_last_block;
> +
> + group_first_block = le32_to_cpu(EXT2_SB(sb)->s_es->s_first_data_block) +
> + group * EXT2_BLOCKS_PER_GROUP(sb);
> + group_last_block = group_first_block + EXT2_BLOCKS_PER_GROUP(sb) - 1;
> +
> + if ((rsv->_rsv_start > group_last_block) ||
> + (rsv->_rsv_end < group_first_block))
> + return 0;
> + if ((goal >= 0) && ((goal + group_first_block < rsv->_rsv_start)
> + || (goal + group_first_block > rsv->_rsv_end)))
> + return 0;
> + return 1;
> +}
> +
> +/*
> + * Find the reserved window which includes the goal, or the previous one
> + * if the goal is not in any window.
> + * Returns NULL if there are no windows or if all windows start after the goal.
> + */
> +static struct ext2_reserve_window_node *
> +search_reserve_window(struct rb_root *root, unsigned long goal)
> +{
> + struct rb_node *n = root->rb_node;
> + struct ext2_reserve_window_node *rsv;
> +
> + if (!n)
> + return NULL;
> +
> + do {
> + rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
> +
> + if (goal < rsv->rsv_start)
> + n = n->rb_left;
> + else if (goal > rsv->rsv_end)
> + n = n->rb_right;
> + else
> + return rsv;
> + } while (n);
> + /*
> + * We've fallen off the end of the tree: the goal wasn't inside
> + * any particular node. OK, the previous node must be to one
> + * side of the interval containing the goal. If it's the RHS,
> + * we need to back up one.
> + */
> + if (rsv->rsv_start > goal) {
> + n = rb_prev(&rsv->rsv_node);
> + rsv = rb_entry(n, struct ext2_reserve_window_node, rsv_node);
> + }
> + return rsv;
> +}
> +
> +void ext2_rsv_window_add(struct super_block *sb,
> + struct ext2_reserve_window_node *rsv)
> +{
> + struct rb_root *root = &EXT2_SB(sb)->s_rsv_window_root;
> + struct rb_node *node = &rsv->rsv_node;
> + unsigned int start = rsv->rsv_start;
> +
> + struct rb_node ** p = &root->rb_node;
> + struct rb_node * parent = NULL;
> + struct ext2_reserve_window_node *this;
> +
> + while (*p)
> + {
> + parent = *p;
> + this = rb_entry(parent, struct ext2_reserve_window_node, rsv_node);
> +
> + if (start < this->rsv_start)
> + p = &(*p)->rb_left;
> + else if (start > this->rsv_end)
> + p = &(*p)->rb_right;
> + else
> + BUG();
> + }
> +
> + rb_link_node(node, parent, p);
> + rb_insert_color(node, root);
> +}
> +
> +static void rsv_window_remove(struct super_block *sb,
> + struct ext2_reserve_window_node *rsv)
> +{
> + rsv->rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
> + rsv->rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
> + rsv->rsv_alloc_hit = 0;
> + rb_erase(&rsv->rsv_node, &EXT2_SB(sb)->s_rsv_window_root);
> +}
> +
> +static inline int rsv_is_empty(struct ext2_reserve_window *rsv)
> +{
> + /* a valid reservation end block could not be 0 */
> + return (rsv->_rsv_end == EXT2_RESERVE_WINDOW_NOT_ALLOCATED);
> +}
> +
> +void ext2_init_block_alloc_info(struct inode *inode)
> +{
> + struct ext2_inode_info *ei = EXT2_I(inode);
> + struct ext2_block_alloc_info *block_i = ei->i_block_alloc_info;
> + struct super_block *sb = inode->i_sb;
> +
> + block_i = kmalloc(sizeof(*block_i), GFP_NOFS);
> + if (block_i) {
> + struct ext2_reserve_window_node *rsv = &block_i->rsv_window_node;
> +
> + rsv->rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
> + rsv->rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
> +
> + /*
> + * if filesystem is mounted with NORESERVATION, the goal
> + * reservation window size is set to zero to indicate
> + * block reservation is off
> + */
> + if (!test_opt(sb, RESERVATION))
> + rsv->rsv_goal_size = 0;
> + else
> + rsv->rsv_goal_size = EXT2_DEFAULT_RESERVE_BLOCKS;
> + rsv->rsv_alloc_hit = 0;
> + block_i->last_alloc_logical_block = 0;
> + block_i->last_alloc_physical_block = 0;
> + }
> + ei->i_block_alloc_info = block_i;
> +}
> +
> +void ext2_discard_reservation(struct inode *inode)
> +{
> + struct ext2_inode_info *ei = EXT2_I(inode);
> + struct ext2_block_alloc_info *block_i = ei->i_block_alloc_info;
> + struct ext2_reserve_window_node *rsv;
> + spinlock_t *rsv_lock = &EXT2_SB(inode->i_sb)->s_rsv_window_lock;
> +
> + if (!block_i)
> + return;
> +
> + rsv = &block_i->rsv_window_node;
> + if (!rsv_is_empty(&rsv->rsv_window)) {
> + spin_lock(rsv_lock);
> + if (!rsv_is_empty(&rsv->rsv_window))
> + rsv_window_remove(inode->i_sb, rsv);
> + spin_unlock(rsv_lock);
> + }
> +}
> +
> /* Free given blocks, update quota and i_blocks field */
> void ext2_free_blocks (struct inode * inode, unsigned long block,
> unsigned long count)
> @@ -245,6 +404,7 @@
> }
> }
>
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bitmap_bh);
> if (sb->s_flags & MS_SYNCHRONOUS)
> sync_dirty_buffer(bitmap_bh);
> @@ -263,16 +423,31 @@
> DQUOT_FREE_BLOCK(inode, freed);
> }
>
> -static int grab_block(spinlock_t *lock, char *map, unsigned size, int goal)
> +static int
> +bitmap_search_next_usable_block(int start, struct buffer_head *bh,
> + int maxblocks)
> {
> - int k;
> - char *p, *r;
> + int next;
>
> - if (!ext2_test_bit(goal, map))
> - goto got_it;
> + next = ext2_find_next_zero_bit(bh->b_data, maxblocks, start);
> + if (next >= maxblocks)
> + return -1;
> + return next;
> +}
>
> -repeat:
> - if (goal) {
> +/*
> + * Find an allocatable block in a bitmap. We perform the "most
> + * appropriate allocation" algorithm of looking for a free block near
> + * the initial goal; then for a free byte somewhere in the bitmap;
> + * then for any free bit in the bitmap.
> + */
> +static int
> +find_next_usable_block(int start, struct buffer_head *bh, int maxblocks)
> +{
> + int here, next;
> + char *p, *r;
> +
> + if (start > 0) {
> /*
> * The goal was occupied; search forward for a free
> * block within the next XX blocks.
> @@ -281,244 +456,746 @@
> * less than EXT2_BLOCKS_PER_GROUP. Aligning up to the
> * next 64-bit boundary is simple..
> */
> - k = (goal + 63) & ~63;
> - goal = ext2_find_next_zero_bit(map, k, goal);
> - if (goal < k)
> - goto got_it;
> + int end_goal = (start + 63) & ~63;
> + if (end_goal > maxblocks)
> + end_goal = maxblocks;
> + here = ext2_find_next_zero_bit(bh->b_data, end_goal, start);
> + if (here < end_goal)
> + return here;
> + ext2_debug("Bit not found near goal\n");
> + }
> +
> + here = start;
> + if (here < 0)
> + here = 0;
> +
> + p = ((char *)bh->b_data) + (here >> 3);
> + r = memscan(p, 0, (maxblocks - here + 7) >> 3);
> + next = (r - ((char *)bh->b_data)) << 3;
> +
> + if (next < maxblocks && next >= here)
> + return next;
> +
> + here = bitmap_search_next_usable_block(here, bh, maxblocks);
> + return here;
> +}
> +
> +/*
> + * If we failed to allocate the desired block then we may end up crossing to a
> + * new bitmap.
> + */
> +static int
> +ext2_try_to_allocate(struct super_block *sb, int group,
> + struct buffer_head *bitmap_bh, int goal,
> + unsigned long *count, struct ext2_reserve_window *my_rsv)
> +{
> + int group_first_block, start, end;
> + unsigned long num = 0;
> +
> + /* we do allocation within the reservation window if we have a window */
> + if (my_rsv) {
> + group_first_block =
> + le32_to_cpu(EXT2_SB(sb)->s_es->s_first_data_block) +
> + group * EXT2_BLOCKS_PER_GROUP(sb);
> + if (my_rsv->_rsv_start >= group_first_block)
> + start = my_rsv->_rsv_start - group_first_block;
> + else
> + /* reservation window cross group boundary */
> + start = 0;
> + end = my_rsv->_rsv_end - group_first_block + 1;
> + if (end > EXT2_BLOCKS_PER_GROUP(sb))
> + /* reservation window crosses group boundary */
> + end = EXT2_BLOCKS_PER_GROUP(sb);
> + if ((start <= goal) && (goal < end))
> + start = goal;
> + else
> + goal = -1;
> + } else {
> + if (goal > 0)
> + start = goal;
> + else
> + start = 0;
> + end = EXT2_BLOCKS_PER_GROUP(sb);
> + }
> +
> + BUG_ON(start > EXT2_BLOCKS_PER_GROUP(sb));
> +
> +repeat:
> + if (goal < 0) {
> + goal = find_next_usable_block(start, bitmap_bh, end);
> + if (goal < 0)
> + goto fail_access;
> + if (!my_rsv) {
> + int i;
> +
> + for (i = 0; i < 7 && goal > start &&
> + !ext2_test_bit(goal - 1, bitmap_bh->b_data);
> + i++, goal--)
> + ;
> + }
> + }
> + start = goal;
> +
> + if (ext2_set_bit_atomic(sb_bgl_lock(EXT2_SB(sb), group), goal, bitmap_bh->b_data)) {
> + /*
> + * The block was allocated by another thread, or it was
> + * allocated and then freed by another thread
> + */
> + start++;
> + goal++;
> + if (start >= end)
> + goto fail_access;
> + goto repeat;
> + }
> + num++;
> + goal++;
> + while (num < *count && goal < end
> + && !ext2_set_bit_atomic(sb_bgl_lock(EXT2_SB(sb), group), goal, bitmap_bh->b_data)) {
> + num++;
> + goal++;
> + }
> + *count = num;
> + return goal - num;
> +fail_access:
> + *count = num;
> + return -1;
> +}
> +
> +/**
> + * find_next_reservable_window():
> + * find a reservable space within the given range.
> + * It does not allocate the reservation window for now:
> + * alloc_new_reservation() will do the work later.
> + *
> + * @search_head: the head of the searching list;
> + * This is not necessarily the list head of the whole filesystem
> + *
> + * We have both head and start_block to assist the search
> + * for the reservable space. The list starts from head,
> + * but we will shift to the place where start_block is,
> + * then start from there, when looking for a reservable space.
> + *
> + * @size: the target new reservation window size
> + *
> + * @group_first_block: the first block we consider to start
> + * the real search from
> + *
> + * @last_block:
> + * the maximum block number that our goal reservable space
> + * could start from. This is normally the last block in this
> + * group. The search will end when we found the start of next
> + * possible reservable space is out of this boundary.
> + * This could handle the cross boundary reservation window
> + * request.
> + *
> + * basically we search from the given range, rather than the whole
> + * reservation double linked list, (start_block, last_block)
> + * to find a free region that is of my size and has not
> + * been reserved.
> + *
> + */
> +static int find_next_reservable_window(
> + struct ext2_reserve_window_node *search_head,
> + struct ext2_reserve_window_node *my_rsv,
> + struct super_block * sb, int start_block,
> + int last_block)
> +{
> + struct rb_node *next;
> + struct ext2_reserve_window_node *rsv, *prev;
> + int cur;
> + int size = my_rsv->rsv_goal_size;
> +
> + /* TODO: make the start of the reservation window byte-aligned */
> + /* cur = *start_block & ~7;*/
> + cur = start_block;
> + rsv = search_head;
> + if (!rsv)
> + return -1;
> +
> + while (1) {
> + if (cur <= rsv->rsv_end)
> + cur = rsv->rsv_end + 1;
> +
> + /* TODO?
> + * in the case we could not find a reservable space
> + * that is what is expected, during the re-search, we could
> + * remember what's the largest reservable space we could have
> + * and return that one.
> + *
> + * For now it will fail if we could not find the reservable
> + * space with expected-size (or more)...
> + */
> + if (cur > last_block)
> + return -1; /* fail */
> +
> + prev = rsv;
> + next = rb_next(&rsv->rsv_node);
> + rsv = list_entry(next,struct ext2_reserve_window_node,rsv_node);
> +
> + /*
> + * Reached the last reservation, we can just append to the
> + * previous one.
> + */
> + if (!next)
> + break;
> +
> + if (cur + size <= rsv->rsv_start) {
> + /*
> + * Found a reserveable space big enough. We could
> + * have a reservation across the group boundary here
> + */
> + break;
> + }
> + }
> + /*
> + * we come here either :
> + * when we reach the end of the whole list,
> + * and there is empty reservable space after last entry in the list.
> + * append it to the end of the list.
> + *
> + * or we found one reservable space in the middle of the list,
> + * return the reservation window that we could append to.
> + * succeed.
> + */
> +
> + if ((prev != my_rsv) && (!rsv_is_empty(&my_rsv->rsv_window)))
> + rsv_window_remove(sb, my_rsv);
> +
> + /*
> + * Let's book the whole avaliable window for now. We will check the
> + * disk bitmap later and then, if there are free blocks then we adjust
> + * the window size if it's larger than requested.
> + * Otherwise, we will remove this node from the tree next time
> + * call find_next_reservable_window.
> + */
> + my_rsv->rsv_start = cur;
> + my_rsv->rsv_end = cur + size - 1;
> + my_rsv->rsv_alloc_hit = 0;
> +
> + if (prev != my_rsv)
> + ext2_rsv_window_add(sb, my_rsv);
> +
> + return 0;
> +}
> +
> +/**
> + * alloc_new_reservation()--allocate a new reservation window
> + *
> + * To make a new reservation, we search part of the filesystem
> + * reservation list (the list that inside the group). We try to
> + * allocate a new reservation window near the allocation goal,
> + * or the beginning of the group, if there is no goal.
> + *
> + * We first find a reservable space after the goal, then from
> + * there, we check the bitmap for the first free block after
> + * it. If there is no free block until the end of group, then the
> + * whole group is full, we failed. Otherwise, check if the free
> + * block is inside the expected reservable space, if so, we
> + * succeed.
> + * If the first free block is outside the reservable space, then
> + * start from the first free block, we search for next available
> + * space, and go on.
> + *
> + * on succeed, a new reservation will be found and inserted into the list
> + * It contains at least one free block, and it does not overlap with other
> + * reservation windows.
> + *
> + * failed: we failed to find a reservation window in this group
> + *
> + * @rsv: the reservation
> + *
> + * @goal: The goal (group-relative). It is where the search for a
> + * free reservable space should start from.
> + * if we have a goal(goal >0 ), then start from there,
> + * no goal(goal = -1), we start from the first block
> + * of the group.
> + *
> + * @sb: the super block
> + * @group: the group we are trying to allocate in
> + * @bitmap_bh: the block group block bitmap
> + *
> + */
> +static int alloc_new_reservation(struct ext2_reserve_window_node *my_rsv,
> + int goal, struct super_block *sb,
> + unsigned int group, struct buffer_head *bitmap_bh)
> +{
> + struct ext2_reserve_window_node *search_head;
> + int group_first_block, group_end_block, start_block;
> + int first_free_block;
> + struct rb_root *fs_rsv_root = &EXT2_SB(sb)->s_rsv_window_root;
> + unsigned long size;
> + int ret;
> + spinlock_t *rsv_lock = &EXT2_SB(sb)->s_rsv_window_lock;
> +
> + group_first_block = le32_to_cpu(EXT2_SB(sb)->s_es->s_first_data_block) +
> + group * EXT2_BLOCKS_PER_GROUP(sb);
> + group_end_block = group_first_block + EXT2_BLOCKS_PER_GROUP(sb) - 1;
> +
> + if (goal < 0)
> + start_block = group_first_block;
> + else
> + start_block = goal + group_first_block;
> +
> + size = my_rsv->rsv_goal_size;
> +
> + if (!rsv_is_empty(&my_rsv->rsv_window)) {
> /*
> - * Search in the remainder of the current group.
> + * if the old reservation is cross group boundary
> + * and if the goal is inside the old reservation window,
> + * we will come here when we just failed to allocate from
> + * the first part of the window. We still have another part
> + * that belongs to the next group. In this case, there is no
> + * point to discard our window and try to allocate a new one
> + * in this group(which will fail). we should
> + * keep the reservation window, just simply move on.
> + *
> + * Maybe we could shift the start block of the reservation
> + * window to the first block of next group.
> */
> +
> + if ((my_rsv->rsv_start <= group_end_block) &&
> + (my_rsv->rsv_end > group_end_block) &&
> + (start_block >= my_rsv->rsv_start))
> + return -1;
> +
> + if ((my_rsv->rsv_alloc_hit >
> + (my_rsv->rsv_end - my_rsv->rsv_start + 1) / 2)) {
> + /*
> + * if we previously allocation hit ration is greater than half
> + * we double the size of reservation window next time
> + * otherwise keep the same
> + */
> + size = size * 2;
> + if (size > EXT2_MAX_RESERVE_BLOCKS)
> + size = EXT2_MAX_RESERVE_BLOCKS;
> + my_rsv->rsv_goal_size= size;
> + }
> + }
> +
> + spin_lock(rsv_lock);
> + /*
> + * shift the search start to the window near the goal block
> + */
> + search_head = search_reserve_window(fs_rsv_root, start_block);
> +
> + /*
> + * find_next_reservable_window() simply finds a reservable window
> + * inside the given range(start_block, group_end_block).
> + *
> + * To make sure the reservation window has a free bit inside it, we
> + * need to check the bitmap after we found a reservable window.
> + */
> +retry:
> + ret = find_next_reservable_window(search_head, my_rsv, sb,
> + start_block, group_end_block);
> +
> + if (ret == -1) {
> + if (!rsv_is_empty(&my_rsv->rsv_window))
> + rsv_window_remove(sb, my_rsv);
> + spin_unlock(rsv_lock);
> + return -1;
> }
>
> - p = map + (goal >> 3);
> - r = memscan(p, 0, (size - goal + 7) >> 3);
> - k = (r - map) << 3;
> - if (k < size) {
> - /*
> - * We have succeeded in finding a free byte in the block
> - * bitmap. Now search backwards to find the start of this
> - * group of free blocks - won't take more than 7 iterations.
> + /*
> + * On success, find_next_reservable_window() returns the
> + * reservation window where there is a reservable space after it.
> + * Before we reserve this reservable space, we need
> + * to make sure there is at least a free block inside this region.
> + *
> + * searching the first free bit on the block bitmap and copy of
> + * last committed bitmap alternatively, until we found a allocatable
> + * block. Search start from the start block of the reservable space
> + * we just found.
> + */
> + spin_unlock(rsv_lock);
> + first_free_block = bitmap_search_next_usable_block(
> + my_rsv->rsv_start - group_first_block,
> + bitmap_bh, group_end_block - group_first_block + 1);
> +
> + if (first_free_block < 0) {
> + /*
> + * no free block left on the bitmap, no point
> + * to reserve the space. return failed.
> */
> - for (goal = k; goal && !ext2_test_bit (goal - 1, map); goal--)
> - ;
> - goto got_it;
> + spin_lock(rsv_lock);
> + if (!rsv_is_empty(&my_rsv->rsv_window))
> + rsv_window_remove(sb, my_rsv);
> + spin_unlock(rsv_lock);
> + return -1; /* failed */
> }
>
> - k = ext2_find_next_zero_bit ((u32 *)map, size, goal);
> - if (k < size) {
> - goal = k;
> - goto got_it;
> + start_block = first_free_block + group_first_block;
> + /*
> + * check if the first free block is within the
> + * free space we just reserved
> + */
> + if (start_block >= my_rsv->rsv_start && start_block < my_rsv->rsv_end)
> + return 0; /* success */
> + /*
> + * if the first free bit we found is out of the reservable space
> + * continue search for next reservable space,
> + * start from where the free block is,
> + * we also shift the list head to where we stopped last time
> + */
> + search_head = my_rsv;
> + spin_lock(rsv_lock);
> + goto retry;
> +}
> +
> +static void try_to_extend_reservation(struct ext2_reserve_window_node *my_rsv,
> + struct super_block *sb, int size)
> +{
> + struct ext2_reserve_window_node *next_rsv;
> + struct rb_node *next;
> + spinlock_t *rsv_lock = &EXT2_SB(sb)->s_rsv_window_lock;
> +
> + printk("req. rsv size %d\n", size);
> +
> + if (!spin_trylock(rsv_lock))
> + return;
> +
> + next = rb_next(&my_rsv->rsv_node);
> +
> + if (!next)
> + my_rsv->rsv_end += size;
> + else {
> + next_rsv = list_entry(next, struct ext2_reserve_window_node, rsv_node);
> +
> + if ((next_rsv->rsv_start - my_rsv->rsv_end - 1) >= size)
> + my_rsv->rsv_end += size;
> + else
> + my_rsv->rsv_end = next_rsv->rsv_start - 1;
> }
> - return -1;
> -got_it:
> - if (ext2_set_bit_atomic(lock, goal, (void *) map))
> - goto repeat;
> - return goal;
> + spin_unlock(rsv_lock);
> }
>
> /*
> - * ext2_new_block uses a goal block to assist allocation. If the goal is
> + * This is the main function used to allocate a new block and its reservation
> + * window.
> + *
> + * Each time when a new block allocation is need, first try to allocate from
> + * its own reservation. If it does not have a reservation window, instead of
> + * looking for a free bit on bitmap first, then look up the reservation list to
> + * see if it is inside somebody else's reservation window, we try to allocate a
> + * reservation window for it starting from the goal first. Then do the block
> + * allocation within the reservation window.
> + *
> + * This will avoid keeping on searching the reservation list again and
> + * again when somebody is looking for a free block (without
> + * reservation), and there are lots of free blocks, but they are all
> + * being reserved.
> + *
> + * We use a sorted double linked list for the per-filesystem reservation list.
> + * The insert, remove and find a free space(non-reserved) operations for the
> + * sorted double linked list should be fast.
> + *
> + */
> +static int
> +ext2_try_to_allocate_with_rsv(struct super_block *sb,
> + unsigned int group, struct buffer_head *bitmap_bh,
> + int goal, struct ext2_reserve_window_node * my_rsv,
> + unsigned long *count)
> +{
> + unsigned long group_first_block;
> + int ret = 0;
> + unsigned long num = *count;
> +
> + /*
> + * we don't deal with reservation when
> + * filesystem is mounted without reservation
> + * or the file is not a regular file
> + * or last attempt to allocate a block with reservation turned on failed
> + */
> + if (my_rsv == NULL ) {
> + return ext2_try_to_allocate(sb, group, bitmap_bh,
> + goal, count, NULL);
> + }
> + /*
> + * goal is a group relative block number (if there is a goal)
> + * 0 < goal < EXT2_BLOCKS_PER_GROUP(sb)
> + * first block is a filesystem wide block number
> + * first block is the block number of the first block in this group
> + */
> + group_first_block = le32_to_cpu(EXT2_SB(sb)->s_es->s_first_data_block) +
> + group * EXT2_BLOCKS_PER_GROUP(sb);
> +
> + /*
> + * Basically we will allocate a new block from inode's reservation
> + * window.
> + *
> + * We need to allocate a new reservation window, if:
> + * a) inode does not have a reservation window; or
> + * b) last attempt to allocate a block from existing reservation
> + * failed; or
> + * c) we come here with a goal and with a reservation window
> + *
> + * We do not need to allocate a new reservation window if we come here
> + * at the beginning with a goal and the goal is inside the window, or
> + * we don't have a goal but already have a reservation window.
> + * then we could go to allocate from the reservation window directly.
> + */
> + while (1) {
> + if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
> + !goal_in_my_reservation(&my_rsv->rsv_window, goal, group, sb)) {
> + if (my_rsv->rsv_goal_size < *count)
> + my_rsv->rsv_goal_size = *count;
> + ret = alloc_new_reservation(my_rsv, goal, sb,
> + group, bitmap_bh);
> + if (ret < 0)
> + break; /* failed */
> +
> + if (!goal_in_my_reservation(&my_rsv->rsv_window, goal, group, sb))
> + goal = -1;
> + } else if (goal > 0 && (my_rsv->rsv_end-goal+1) < *count)
> + try_to_extend_reservation(my_rsv, sb,
> + *count-my_rsv->rsv_end + goal - 1);
> +
> + if ((my_rsv->rsv_start >= group_first_block + EXT2_BLOCKS_PER_GROUP(sb))
> + || (my_rsv->rsv_end < group_first_block))
> + BUG();
> + ret = ext2_try_to_allocate(sb, group, bitmap_bh, goal,
> + &num, &my_rsv->rsv_window);
> + if (ret >= 0) {
> + my_rsv->rsv_alloc_hit += num;
> + *count = num;
> + break; /* succeed */
> + }
> + num = *count;
> + }
> + return ret;
> +}
> +
> +static int ext2_has_free_blocks(struct ext2_sb_info *sbi)
> +{
> + int free_blocks, root_blocks;
> +
> + free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
> + root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
> + if (free_blocks < root_blocks + 1 && !capable(CAP_SYS_RESOURCE) &&
> + sbi->s_resuid != current->fsuid &&
> + (sbi->s_resgid == 0 || !in_group_p (sbi->s_resgid))) {
> + return 0;
> + }
> + return 1;
> +}
> +
> +/*
> + * ext2_new_blocks uses a goal block to assist allocation. If the goal is
> * free, or there is a free block within 32 blocks of the goal, that block
> * is allocated. Otherwise a forward search is made for a free block; within
> * each block group the search first looks for an entire free byte in the block
> * bitmap, and then for any free bit if that fails.
> * This function also updates quota and i_blocks field.
> */
> -int ext2_new_block(struct inode *inode, unsigned long goal,
> - u32 *prealloc_count, u32 *prealloc_block, int *err)
> +int ext2_new_blocks(struct inode *inode, unsigned long goal,
> + unsigned long *count, int *errp)
> {
> struct buffer_head *bitmap_bh = NULL;
> - struct buffer_head *gdp_bh; /* bh2 */
> - struct ext2_group_desc *desc;
> - int group_no; /* i */
> - int ret_block; /* j */
> - int group_idx; /* k */
> - int target_block; /* tmp */
> - int block = 0;
> - struct super_block *sb = inode->i_sb;
> - struct ext2_sb_info *sbi = EXT2_SB(sb);
> - struct ext2_super_block *es = sbi->s_es;
> - unsigned group_size = EXT2_BLOCKS_PER_GROUP(sb);
> - unsigned prealloc_goal = es->s_prealloc_blocks;
> - unsigned group_alloc = 0, es_alloc, dq_alloc;
> - int nr_scanned_groups;
> -
> - if (!prealloc_goal--)
> - prealloc_goal = EXT2_DEFAULT_PREALLOC_BLOCKS - 1;
> - if (!prealloc_count || *prealloc_count)
> - prealloc_goal = 0;
> -
> - if (DQUOT_ALLOC_BLOCK(inode, 1)) {
> - *err = -EDQUOT;
> - goto out;
> + struct buffer_head *gdp_bh;
> + int group_no;
> + int goal_group;
> + int ret_block;
> + int bgi; /* blockgroup iteration index */
> + int target_block;
> + int performed_allocation = 0;
> + int free_blocks;
> + struct super_block *sb;
> + struct ext2_group_desc *gdp;
> + struct ext2_super_block *es;
> + struct ext2_sb_info *sbi;
> + struct ext2_reserve_window_node *my_rsv = NULL;
> + struct ext2_block_alloc_info *block_i;
> + unsigned short windowsz = 0;
> + unsigned long ngroups;
> + unsigned long num = *count;
> +
> + *errp = -ENOSPC;
> + sb = inode->i_sb;
> + if (!sb) {
> + printk("ext2_new_blocks: nonexistent device");
> + return 0;
> }
>
> - while (prealloc_goal && DQUOT_PREALLOC_BLOCK(inode, prealloc_goal))
> - prealloc_goal--;
> + /*
> + * Check quota for allocation of this block.
> + */
> + if (DQUOT_ALLOC_BLOCK(inode, num)) {
> + *errp = -EDQUOT;
> + return 0;
> + }
>
> - dq_alloc = prealloc_goal + 1;
> - es_alloc = reserve_blocks(sb, dq_alloc);
> - if (!es_alloc) {
> - *err = -ENOSPC;
> - goto out_dquot;
> + sbi = EXT2_SB(sb);
> + es = EXT2_SB(sb)->s_es;
> + ext2_debug("goal=%lu.\n", goal);
> + /*
> + * Allocate a block from reservation only when
> + * filesystem is mounted with reservation(default,-o reservation), and
> + * it's a regular file, and
> + * the desired window size is greater than 0 (One could use ioctl
> + * command EXT2_IOC_SETRSVSZ to set the window size to 0 to turn off
> + * reservation on that particular file)
> + */
> + block_i = EXT2_I(inode)->i_block_alloc_info;
> + if (block_i && ((windowsz = block_i->rsv_window_node.rsv_goal_size) > 0)) {
> + my_rsv = &block_i->rsv_window_node;
> }
>
> - ext2_debug ("goal=%lu.\n", goal);
> + if (!ext2_has_free_blocks(sbi)) {
> + *errp = -ENOSPC;
> + goto out;
> + }
>
> + /*
> + * First, test whether the goal block is free.
> + */
> if (goal < le32_to_cpu(es->s_first_data_block) ||
> goal >= le32_to_cpu(es->s_blocks_count))
> goal = le32_to_cpu(es->s_first_data_block);
> - group_no = (goal - le32_to_cpu(es->s_first_data_block)) / group_size;
> - desc = ext2_get_group_desc (sb, group_no, &gdp_bh);
> - if (!desc) {
> - /*
> - * gdp_bh may still be uninitialised. But group_release_blocks
> - * will not touch it because group_alloc is zero.
> - */
> + group_no = (goal - le32_to_cpu(es->s_first_data_block)) /
> + EXT2_BLOCKS_PER_GROUP(sb);
> + gdp = ext2_get_group_desc(sb, group_no, &gdp_bh);
> + if (!gdp)
> goto io_error;
> - }
>
> - group_alloc = group_reserve_blocks(sbi, group_no, desc,
> - gdp_bh, es_alloc);
> - if (group_alloc) {
> + goal_group = group_no;
> +retry:
> + free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
> + /*
> + * if there is not enough free blocks to make a new resevation
> + * turn off reservation for this allocation
> + */
> + if (my_rsv && (free_blocks < windowsz)
> + && (rsv_is_empty(&my_rsv->rsv_window)))
> + my_rsv = NULL;
> +
> + if (free_blocks > 0) {
> ret_block = ((goal - le32_to_cpu(es->s_first_data_block)) %
> - group_size);
> - brelse(bitmap_bh);
> + EXT2_BLOCKS_PER_GROUP(sb));
> bitmap_bh = read_block_bitmap(sb, group_no);
> if (!bitmap_bh)
> goto io_error;
> -
> - ext2_debug("goal is at %d:%d.\n", group_no, ret_block);
> -
> - ret_block = grab_block(sb_bgl_lock(sbi, group_no),
> - bitmap_bh->b_data, group_size, ret_block);
> + ret_block = ext2_try_to_allocate_with_rsv(sb, group_no,
> + bitmap_bh, ret_block, my_rsv, &num);
> if (ret_block >= 0)
> - goto got_block;
> - group_release_blocks(sb, group_no, desc, gdp_bh, group_alloc);
> - group_alloc = 0;
> + goto allocated;
> }
>
> - ext2_debug ("Bit not found in block group %d.\n", group_no);
> + ngroups = EXT2_SB(sb)->s_groups_count;
> + smp_rmb();
>
> /*
> * Now search the rest of the groups. We assume that
> - * i and desc correctly point to the last group visited.
> + * i and gdp correctly point to the last group visited.
> */
> - nr_scanned_groups = 0;
> -retry:
> - for (group_idx = 0; !group_alloc &&
> - group_idx < sbi->s_groups_count; group_idx++) {
> + for (bgi = 0; bgi < ngroups; bgi++) {
> group_no++;
> - if (group_no >= sbi->s_groups_count)
> + if (group_no >= ngroups)
> group_no = 0;
> - desc = ext2_get_group_desc(sb, group_no, &gdp_bh);
> - if (!desc)
> - goto io_error;
> - group_alloc = group_reserve_blocks(sbi, group_no, desc,
> - gdp_bh, es_alloc);
> - }
> - if (!group_alloc) {
> - *err = -ENOSPC;
> - goto out_release;
> - }
> - brelse(bitmap_bh);
> - bitmap_bh = read_block_bitmap(sb, group_no);
> - if (!bitmap_bh)
> - goto io_error;
> -
> - ret_block = grab_block(sb_bgl_lock(sbi, group_no), bitmap_bh->b_data,
> - group_size, 0);
> - if (ret_block < 0) {
> - /*
> - * If a free block counter is corrupted we can loop inifintely.
> - * Detect that here.
> - */
> - nr_scanned_groups++;
> - if (nr_scanned_groups > 2 * sbi->s_groups_count) {
> - ext2_error(sb, "ext2_new_block",
> - "corrupted free blocks counters");
> - goto io_error;
> + gdp = ext2_get_group_desc(sb, group_no, &gdp_bh);
> + if (!gdp) {
> + *errp = -EIO;
> + goto out;
> }
> + free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
> /*
> - * Someone else grabbed the last free block in this blockgroup
> - * before us. Retry the scan.
> + * skip this group if the number of
> + * free blocks is less than half of the reservation
> + * window size.
> */
> - group_release_blocks(sb, group_no, desc, gdp_bh, group_alloc);
> - group_alloc = 0;
> + if (free_blocks <= (windowsz/2))
> + continue;
> +
> + brelse(bitmap_bh);
> + bitmap_bh = read_block_bitmap(sb, group_no);
> + if (!bitmap_bh)
> + goto io_error;
> + ret_block = ext2_try_to_allocate_with_rsv(sb, group_no,
> + bitmap_bh, -1, my_rsv, &num);
> + if (ret_block >= 0)
> + goto allocated;
> + }
> + /*
> + * We may end up a bogus ealier ENOSPC error due to
> + * filesystem is "full" of reservations, but
> + * there maybe indeed free blocks avaliable on disk
> + * In this case, we just forget about the reservations
> + * just do block allocation as without reservations.
> + */
> + if (my_rsv) {
> + my_rsv = NULL;
> + group_no = goal_group;
> goto retry;
> }
> + /* No space left on the device */
> + *errp = -ENOSPC;
> + goto out;
> +
> +allocated:
>
> -got_block:
> ext2_debug("using block group %d(%d)\n",
> - group_no, desc->bg_free_blocks_count);
> + group_no, gdp->bg_free_blocks_count);
>
> - target_block = ret_block + group_no * group_size +
> - le32_to_cpu(es->s_first_data_block);
> + target_block = ret_block + group_no * EXT2_BLOCKS_PER_GROUP(sb)
> + + le32_to_cpu(es->s_first_data_block);
>
> - if (target_block == le32_to_cpu(desc->bg_block_bitmap) ||
> - target_block == le32_to_cpu(desc->bg_inode_bitmap) ||
> - in_range(target_block, le32_to_cpu(desc->bg_inode_table),
> - sbi->s_itb_per_group))
> - ext2_error (sb, "ext2_new_block",
> + if (in_range(le32_to_cpu(gdp->bg_block_bitmap), target_block, num) ||
> + in_range(le32_to_cpu(gdp->bg_inode_bitmap), target_block, num) ||
> + in_range(target_block, le32_to_cpu(gdp->bg_inode_table),
> + EXT2_SB(sb)->s_itb_per_group) ||
> + in_range(target_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
> + EXT2_SB(sb)->s_itb_per_group))
> + ext2_error(sb, "ext2_new_blocks",
> "Allocating block in system zone - "
> - "block = %u", target_block);
> + "blocks from %u, length %lu", target_block, num);
> +
> + performed_allocation = 1;
>
> - if (target_block >= le32_to_cpu(es->s_blocks_count)) {
> - ext2_error (sb, "ext2_new_block",
> +
> + /* ret_block was blockgroup-relative. Now it becomes fs-relative */
> + ret_block = target_block;
> +
> + if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
> + ext2_error(sb, "ext2_new_blocks",
> "block(%d) >= blocks count(%d) - "
> "block_group = %d, es == %p ", ret_block,
> le32_to_cpu(es->s_blocks_count), group_no, es);
> - goto io_error;
> + goto out;
> }
> - block = target_block;
>
> - /* OK, we _had_ allocated something */
> - ext2_debug("found bit %d\n", ret_block);
> -
> - dq_alloc--;
> - es_alloc--;
> - group_alloc--;
> -
> - /*
> - * Do block preallocation now if required.
> - */
> - write_lock(&EXT2_I(inode)->i_meta_lock);
> - if (group_alloc && !*prealloc_count) {
> - unsigned n;
> -
> - for (n = 0; n < group_alloc && ++ret_block < group_size; n++) {
> - if (ext2_set_bit_atomic(sb_bgl_lock(sbi, group_no),
> - ret_block,
> - (void*) bitmap_bh->b_data))
> - break;
> - }
> - *prealloc_block = block + 1;
> - *prealloc_count = n;
> - es_alloc -= n;
> - dq_alloc -= n;
> - group_alloc -= n;
> - }
> - write_unlock(&EXT2_I(inode)->i_meta_lock);
> + spin_lock(sb_bgl_lock(sbi, group_no));
> + gdp->bg_free_blocks_count =
> + cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count) - num);
> + spin_unlock(sb_bgl_lock(sbi, group_no));
> + percpu_counter_mod(&sbi->s_freeblocks_counter, -num);
>
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bitmap_bh);
> if (sb->s_flags & MS_SYNCHRONOUS)
> sync_dirty_buffer(bitmap_bh);
>
> - ext2_debug ("allocating block %d. ", block);
> + *errp = 0;
> + brelse(bitmap_bh);
> + DQUOT_FREE_BLOCK(inode, *count-num);
> + *count = num;
> + return ret_block;
>
> - *err = 0;
> -out_release:
> - group_release_blocks(sb, group_no, desc, gdp_bh, group_alloc);
> - release_blocks(sb, es_alloc);
> -out_dquot:
> - DQUOT_FREE_BLOCK(inode, dq_alloc);
> +io_error:
> + *errp = -EIO;
> out:
> + /*
> + * Undo the block allocation
> + */
> + if (!performed_allocation)
> + DQUOT_FREE_BLOCK(inode, *count);
> brelse(bitmap_bh);
> - return block;
> + return 0;
> +}
>
> -io_error:
> - *err = -EIO;
> - goto out_release;
> +int ext2_new_block(struct inode *inode, unsigned long goal, int *errp)
> +{
> + unsigned long count = 1;
> +
> + return ext2_new_blocks(inode, goal, &count, errp);
> }
>
> unsigned long ext2_count_free_blocks (struct super_block * sb)
> diff -x '*~' -uNr vanilla-linux/fs/ext2/dir.c uml-clean/fs/ext2/dir.c
> --- vanilla-linux/fs/ext2/dir.c 2006-03-24 01:48:18.000000000 -0800
> +++ uml-clean/fs/ext2/dir.c 2006-03-08 16:21:30.000000000 -0800
> @@ -67,6 +67,7 @@
> struct inode *dir = page->mapping->host;
> int err = 0;
> dir->i_version++;
> + ext2_mark_fs_dirty(dir->i_sb);
> page->mapping->a_ops->commit_write(NULL, page, from, to);
> if (IS_DIRSYNC(dir))
> err = write_one_page(page, 1);
> diff -x '*~' -uNr vanilla-linux/fs/ext2/ext2.h uml-clean/fs/ext2/ext2.h
> --- vanilla-linux/fs/ext2/ext2.h 2006-03-24 01:48:18.000000000 -0800
> +++ uml-clean/fs/ext2/ext2.h 2006-03-24 04:06:12.000000000 -0800
> @@ -33,22 +33,9 @@
> */
> __u32 i_block_group;
>
> - /*
> - * i_next_alloc_block is the logical (file-relative) number of the
> - * most-recently-allocated block in this file. Yes, it is misnamed.
> - * We use this for detecting linearly ascending allocation requests.
> - */
> - __u32 i_next_alloc_block;
> + /* block reservation info */
> + struct ext2_block_alloc_info *i_block_alloc_info;
>
> - /*
> - * i_next_alloc_goal is the *physical* companion to i_next_alloc_block.
> - * it the the physical block number of the block which was most-recently
> - * allocated to this file. This give us the goal (target) for the next
> - * allocation when we detect linearly ascending requests.
> - */
> - __u32 i_next_alloc_goal;
> - __u32 i_prealloc_block;
> - __u32 i_prealloc_count;
> __u32 i_dir_start_lookup;
> #ifdef CONFIG_EXT2_FS_XATTR
> /*
> @@ -66,6 +53,7 @@
> #endif
> rwlock_t i_meta_lock;
> struct inode vfs_inode;
> + struct list_head i_orphan; /* unlinked but open inodes */
> };
>
> /*
> @@ -91,8 +79,8 @@
> /* balloc.c */
> extern int ext2_bg_has_super(struct super_block *sb, int group);
> extern unsigned long ext2_bg_num_gdb(struct super_block *sb, int group);
> -extern int ext2_new_block (struct inode *, unsigned long,
> - __u32 *, __u32 *, int *);
> +extern int ext2_new_block (struct inode *, unsigned long, int *);
> +extern int ext2_new_blocks (struct inode *, unsigned long, unsigned long *, int *);
> extern void ext2_free_blocks (struct inode *, unsigned long,
> unsigned long);
> extern unsigned long ext2_count_free_blocks (struct super_block *);
> @@ -101,6 +89,10 @@
> extern struct ext2_group_desc * ext2_get_group_desc(struct super_block * sb,
> unsigned int block_group,
> struct buffer_head ** bh);
> +extern void ext2_discard_reservation (struct inode *);
> +extern int ext2_should_retry_alloc(struct super_block *sb, int *retries);
> +extern void ext2_init_block_alloc_info(struct inode *);
> +extern void ext2_rsv_window_add(struct super_block *sb, struct ext2_reserve_window_node *rsv);
>
> /* dir.c */
> extern int ext2_add_link (struct dentry *, struct inode *);
> @@ -128,7 +120,6 @@
> extern void ext2_put_inode (struct inode *);
> extern void ext2_delete_inode (struct inode *);
> extern int ext2_sync_inode (struct inode *);
> -extern void ext2_discard_prealloc (struct inode *);
> extern int ext2_get_block(struct inode *, sector_t, struct buffer_head *, int);
> extern void ext2_truncate (struct inode *);
> extern int ext2_setattr (struct dentry *, struct iattr *);
> @@ -148,6 +139,14 @@
> __attribute__ ((format (printf, 3, 4)));
> extern void ext2_update_dynamic_rev (struct super_block *sb);
> extern void ext2_write_super (struct super_block *);
> +extern void ext2_prepare_super (struct super_block *);
> +extern void __ext2_mark_fs_clean (struct super_block *);
> +extern void ext2_mark_fs_dirty (struct super_block *);
> +extern void ext2_mark_inode_dirty (struct inode *);
> +extern void ext2_orphan_add(struct inode *);
> +extern void ext2_orphan_del(struct inode *);
> +/* XXX Gross */
> +#define mark_inode_dirty(x) ext2_mark_inode_dirty(x)
>
> /*
> * Inodes and files operations
> @@ -173,3 +172,6 @@
> /* symlink.c */
> extern struct inode_operations ext2_fast_symlink_inode_operations;
> extern struct inode_operations ext2_symlink_inode_operations;
> +
> +/* state.c */
> +extern int ext2_dirtyd(void *);
> diff -x '*~' -uNr vanilla-linux/fs/ext2/file.c uml-clean/fs/ext2/file.c
> --- vanilla-linux/fs/ext2/file.c 2006-03-24 01:48:18.000000000 -0800
> +++ uml-clean/fs/ext2/file.c 2006-03-22 01:44:56.000000000 -0800
> @@ -31,7 +31,7 @@
> static int ext2_release_file (struct inode * inode, struct file * filp)
> {
> if (filp->f_mode & FMODE_WRITE)
> - ext2_discard_prealloc (inode);
> + ext2_discard_reservation (inode);
> return 0;
> }
>
> diff -x '*~' -uNr vanilla-linux/fs/ext2/ialloc.c uml-clean/fs/ext2/ialloc.c
> --- vanilla-linux/fs/ext2/ialloc.c 2006-03-24 01:47:33.000000000 -0800
> +++ uml-clean/fs/ext2/ialloc.c 2006-03-24 04:45:43.000000000 -0800
> @@ -85,6 +85,7 @@
> if (dir)
> percpu_counter_dec(&EXT2_SB(sb)->s_dirs_counter);
> sb->s_dirt = 1;
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bh);
> }
>
> @@ -154,6 +155,7 @@
> "bit already cleared for inode %lu", ino);
> else
> ext2_release_inode(sb, block_group, is_directory);
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bitmap_bh);
> if (sb->s_flags & MS_SYNCHRONOUS)
> sync_dirty_buffer(bitmap_bh);
> @@ -528,6 +530,7 @@
> err = -ENOSPC;
> goto fail;
> got:
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bitmap_bh);
> if (sb->s_flags & MS_SYNCHRONOUS)
> sync_dirty_buffer(bitmap_bh);
> @@ -562,6 +565,7 @@
> spin_unlock(sb_bgl_lock(sbi, group));
>
> sb->s_dirt = 1;
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(bh2);
> inode->i_uid = current->fsuid;
> if (test_opt (sb, GRPID))
> @@ -591,11 +595,8 @@
> ei->i_file_acl = 0;
> ei->i_dir_acl = 0;
> ei->i_dtime = 0;
> + ei->i_block_alloc_info = NULL;
> ei->i_block_group = group;
> - ei->i_next_alloc_block = 0;
> - ei->i_next_alloc_goal = 0;
> - ei->i_prealloc_block = 0;
> - ei->i_prealloc_count = 0;
> ei->i_dir_start_lookup = 0;
> ei->i_state = EXT2_STATE_NEW;
> ext2_set_inode_flags(inode);
> diff -x '*~' -uNr vanilla-linux/fs/ext2/inode.c uml-clean/fs/ext2/inode.c
> --- vanilla-linux/fs/ext2/inode.c 2006-03-24 01:48:18.000000000 -0800
> +++ uml-clean/fs/ext2/inode.c 2006-03-24 04:47:34.000000000 -0800
> @@ -54,19 +54,6 @@
> }
>
> /*
> - * Called at each iput().
> - *
> - * The inode may be "bad" if ext2_read_inode() saw an error from
> - * ext2_get_inode(), so we need to check that to avoid freeing random disk
> - * blocks.
> - */
> -void ext2_put_inode(struct inode *inode)
> -{
> - if (!is_bad_inode(inode))
> - ext2_discard_prealloc(inode);
> -}
> -
> -/*
> * Called at the last iput() if i_nlink is zero.
> */
> void ext2_delete_inode (struct inode * inode)
> @@ -75,6 +62,7 @@
>
> if (is_bad_inode(inode))
> goto no_delete;
> + ext2_orphan_del(inode);
> EXT2_I(inode)->i_dtime = get_seconds();
> mark_inode_dirty(inode);
> ext2_update_inode(inode, inode_needs_sync(inode));
> @@ -89,61 +77,6 @@
> clear_inode(inode); /* We must guarantee clearing of inode... */
> }
>
> -void ext2_discard_prealloc (struct inode * inode)
> -{
> -#ifdef EXT2_PREALLOCATE
> - struct ext2_inode_info *ei = EXT2_I(inode);
> - write_lock(&ei->i_meta_lock);
> - if (ei->i_prealloc_count) {
> - unsigned short total = ei->i_prealloc_count;
> - unsigned long block = ei->i_prealloc_block;
> - ei->i_prealloc_count = 0;
> - ei->i_prealloc_block = 0;
> - write_unlock(&ei->i_meta_lock);
> - ext2_free_blocks (inode, block, total);
> - return;
> - } else
> - write_unlock(&ei->i_meta_lock);
> -#endif
> -}
> -
> -static int ext2_alloc_block (struct inode * inode, unsigned long goal, int *err)
> -{
> -#ifdef EXT2FS_DEBUG
> - static unsigned long alloc_hits, alloc_attempts;
> -#endif
> - unsigned long result;
> -
> -
> -#ifdef EXT2_PREALLOCATE
> - struct ext2_inode_info *ei = EXT2_I(inode);
> - write_lock(&ei->i_meta_lock);
> - if (ei->i_prealloc_count &&
> - (goal == ei->i_prealloc_block || goal + 1 == ei->i_prealloc_block))
> - {
> - result = ei->i_prealloc_block++;
> - ei->i_prealloc_count--;
> - write_unlock(&ei->i_meta_lock);
> - ext2_debug ("preallocation hit (%lu/%lu).\n",
> - ++alloc_hits, ++alloc_attempts);
> - } else {
> - write_unlock(&ei->i_meta_lock);
> - ext2_discard_prealloc (inode);
> - ext2_debug ("preallocation miss (%lu/%lu).\n",
> - alloc_hits, ++alloc_attempts);
> - if (S_ISREG(inode->i_mode))
> - result = ext2_new_block (inode, goal,
> - &ei->i_prealloc_count,
> - &ei->i_prealloc_block, err);
> - else
> - result = ext2_new_block(inode, goal, NULL, NULL, err);
> - }
> -#else
> - result = ext2_new_block (inode, goal, 0, 0, err);
> -#endif
> - return result;
> -}
> -
> typedef struct {
> __le32 *p;
> __le32 key;
> @@ -228,7 +161,8 @@
> ext2_warning (inode->i_sb, "ext2_block_to_path", "block > big");
> }
> if (boundary)
> - *boundary = (i_block & (ptrs - 1)) == (final - 1);
> + *boundary = final - 1 - (i_block & (ptrs - 1));
> +
> return n;
> }
>
> @@ -355,39 +289,129 @@
> * @block: block we want
> * @chain: chain of indirect blocks
> * @partial: pointer to the last triple within a chain
> - * @goal: place to store the result.
> *
> - * Normally this function find the prefered place for block allocation,
> - * stores it in *@goal and returns zero. If the branch had been changed
> - * under us we return -EAGAIN.
> + * Returns preferred place for a block (the goal).
> */
>
> static inline int ext2_find_goal(struct inode *inode,
> long block,
> Indirect chain[4],
> - Indirect *partial,
> - unsigned long *goal)
> + Indirect *partial)
> {
> - struct ext2_inode_info *ei = EXT2_I(inode);
> - write_lock(&ei->i_meta_lock);
> - if ((block == ei->i_next_alloc_block + 1) && ei->i_next_alloc_goal) {
> - ei->i_next_alloc_block++;
> - ei->i_next_alloc_goal++;
> - }
> - if (verify_chain(chain, partial)) {
> - /*
> - * try the heuristic for sequential allocation,
> - * failing that at least try to get decent locality.
> - */
> - if (block == ei->i_next_alloc_block)
> - *goal = ei->i_next_alloc_goal;
> - if (!*goal)
> - *goal = ext2_find_near(inode, partial);
> - write_unlock(&ei->i_meta_lock);
> - return 0;
> + struct ext2_block_alloc_info *block_i;
> +
> + block_i = EXT2_I(inode)->i_block_alloc_info;
> +
> + /*
> + * try the heuristic for sequential allocation,
> + * failing that at least try to get decent locality.
> + */
> + if (block_i && (block == block_i->last_alloc_logical_block + 1)
> + && (block_i->last_alloc_physical_block != 0)) {
> + return block_i->last_alloc_physical_block + 1;
> + }
> +
> + return ext2_find_near(inode, partial);
> +}
> +
> +/**
> + * ext2_blks_to_allocate: Look up the block map and count the number
> + * of direct blocks need to be allocated for the given branch.
> + *
> + * @branch: chain of indirect blocks
> + * @k: number of blocks need for indirect blocks
> + * @blks: number of data blocks to be mapped.
> + * @blocks_to_boundary: the offset in the indirect block
> + *
> + * return the total number of blocks to be allocate, including the
> + * direct and indirect blocks.
> + */
> +static int
> +ext2_blks_to_allocate(Indirect * branch, int k, unsigned long blks,
> + int blocks_to_boundary)
> +{
> + unsigned long count = 0;
> +
> + /*
> + * Simple case, [t,d]Indirect block(s) has not allocated yet
> + * then it's clear blocks on that path have not allocated
> + */
> + if (k > 0) {
> + /* right now don't hanel cross boundary allocation */
> + if (blks < blocks_to_boundary + 1)
> + count += blks;
> + else
> + count += blocks_to_boundary + 1;
> + return count;
> + }
> +
> + count++;
> + while (count < blks && count <= blocks_to_boundary
> + && le32_to_cpu(*(branch[0].p + count)) == 0) {
> + count++;
> + }
> + return count;
> +}
> +
> +/**
> + * ext2_alloc_blocks: multiple allocate blocks needed for a branch
> + * @indirect_blks: the number of blocks need to allocate for indirect
> + * blocks
> + *
> + * @new_blocks: on return it will store the new block numbers for
> + * the indirect blocks(if needed) and the first direct block,
> + * @blks: on return it will store the total number of allocated
> + * direct blocks
> + */
> +static int ext2_alloc_blocks(struct inode *inode,
> + unsigned long goal, int indirect_blks, int blks,
> + unsigned long long new_blocks[4], int *err)
> +{
> + int target, i;
> + unsigned long count = 0;
> + int index = 0;
> + unsigned long current_block = 0;
> + int ret = 0;
> +
> + /*
> + * Here we try to allocate the requested multiple blocks at once,
> + * on a best-effort basis.
> + * To build a branch, we should allocate blocks for
> + * the indirect blocks(if not allocated yet), and at least
> + * the first direct block of this branch. That's the
> + * minimum number of blocks need to allocate(required)
> + */
> + target = blks + indirect_blks;
> +
> + while (1) {
> + count = target;
> + /* allocating blocks for indirect blocks and direct blocks */
> + current_block = ext2_new_blocks(inode,goal,&count,err);
> + if (*err)
> + goto failed_out;
> +
> + target -= count;
> + /* allocate blocks for indirect blocks */
> + while (index < indirect_blks && count) {
> + new_blocks[index++] = current_block++;
> + count--;
> + }
> +
> + if (count > 0)
> + break;
> }
> - write_unlock(&ei->i_meta_lock);
> - return -EAGAIN;
> +
> + /* save the new block number for the first direct block */
> + new_blocks[index] = current_block;
> +
> + /* total number of blocks allocated for direct blocks */
> + ret = count;
> + *err = 0;
> + return ret;
> +failed_out:
> + for (i = 0; i <index; i++)
> + ext2_free_blocks(inode, new_blocks[i], 1);
> + return ret;
> }
>
> /**
> @@ -416,41 +440,52 @@
> */
>
> static int ext2_alloc_branch(struct inode *inode,
> - int num,
> - unsigned long goal,
> - int *offsets,
> - Indirect *branch)
> + int indirect_blks, int *blks, unsigned long goal,
> + int *offsets, Indirect *branch)
> {
> int blocksize = inode->i_sb->s_blocksize;
> - int n = 0;
> - int err;
> - int i;
> - int parent = ext2_alloc_block(inode, goal, &err);
> + int i, n = 0;
> + int err = 0;
> + struct buffer_head *bh;
> + int num;
> + unsigned long long new_blocks[4];
> + unsigned long long current_block;
>
> - branch[0].key = cpu_to_le32(parent);
> - if (parent) for (n = 1; n < num; n++) {
> - struct buffer_head *bh;
> - /* Allocate the next block */
> - int nr = ext2_alloc_block(inode, parent, &err);
> - if (!nr)
> - break;
> - branch[n].key = cpu_to_le32(nr);
> + num = ext2_alloc_blocks(inode, goal, indirect_blks,
> + *blks, new_blocks, &err);
> + if (err)
> + return err;
> +
> + branch[0].key = cpu_to_le32(new_blocks[0]);
> + /*
> + * metadata blocks and data blocks are allocated.
> + */
> + for (n = 1; n <= indirect_blks; n++) {
> /*
> - * Get buffer_head for parent block, zero it out and set
> - * the pointer to new one, then send parent to disk.
> + * Get buffer_head for parent block, zero it out
> + * and set the pointer to new one, then send
> + * parent to disk.
> */
> - bh = sb_getblk(inode->i_sb, parent);
> - if (!bh) {
> - err = -EIO;
> - break;
> - }
> + bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
> + branch[n].bh = bh;
> lock_buffer(bh);
> memset(bh->b_data, 0, blocksize);
> - branch[n].bh = bh;
> branch[n].p = (__le32 *) bh->b_data + offsets[n];
> + branch[n].key = cpu_to_le32(new_blocks[n]);
> *branch[n].p = branch[n].key;
> + if ( n == indirect_blks) {
> + current_block = new_blocks[n];
> + /*
> + * End of chain, update the last new metablock of
> + * the chain to point to the new allocated
> + * data blocks numbers
> + */
> + for (i=1; i < num; i++)
> + *(branch[n].p + i) = cpu_to_le32(++current_block);
> + }
> set_buffer_uptodate(bh);
> unlock_buffer(bh);
> + ext2_mark_fs_dirty(inode->i_sb);
> mark_buffer_dirty_inode(bh, inode);
> /* We used to sync bh here if IS_SYNC(inode).
> * But we now rely upon generic_osync_inode()
> @@ -458,77 +493,68 @@
> */
> if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
> sync_dirty_buffer(bh);
> - parent = nr;
> }
> - if (n == num)
> - return 0;
> -
> - /* Allocation failed, free what we already allocated */
> - for (i = 1; i < n; i++)
> - bforget(branch[i].bh);
> - for (i = 0; i < n; i++)
> - ext2_free_blocks(inode, le32_to_cpu(branch[i].key), 1);
> + *blks = num;
> return err;
> }
>
> /**
> - * ext2_splice_branch - splice the allocated branch onto inode.
> - * @inode: owner
> - * @block: (logical) number of block we are adding
> - * @chain: chain of indirect blocks (with a missing link - see
> - * ext2_alloc_branch)
> - * @where: location of missing link
> - * @num: number of blocks we are adding
> - *
> - * This function verifies that chain (up to the missing link) had not
> - * changed, fills the missing link and does all housekeeping needed in
> - * inode (->i_blocks, etc.). In case of success we end up with the full
> - * chain to new block and return 0. Otherwise (== chain had been changed)
> - * we free the new blocks (forgetting their buffer_heads, indeed) and
> - * return -EAGAIN.
> + * ext2_splice_branch - splice the allocated branch onto inode.
> + * @inode: owner
> + * @block: (logical) number of block we are adding
> + * @chain: chain of indirect blocks (with a missing link - see
> + * ext2_alloc_branch)
> + * @where: location of missing link
> + * @num: number of indirect blocks we are adding
> + * @blks: number of direct blocks we are adding
> + *
> + * This function fills the missing link and does all housekeeping needed in
> + * inode (->i_blocks, etc.). In case of success we end up with the full
> + * chain to new block and return 0.
> */
> -
> -static inline int ext2_splice_branch(struct inode *inode,
> - long block,
> - Indirect chain[4],
> - Indirect *where,
> - int num)
> +static void ext2_splice_branch(struct inode *inode,
> + long block, Indirect *where, int num, int blks)
> {
> - struct ext2_inode_info *ei = EXT2_I(inode);
> int i;
> + struct ext2_block_alloc_info *block_i;
> + unsigned long current_block;
>
> - /* Verify that place we are splicing to is still there and vacant */
> -
> - write_lock(&ei->i_meta_lock);
> - if (!verify_chain(chain, where-1) || *where->p)
> - goto changed;
> + block_i = EXT2_I(inode)->i_block_alloc_info;
>
> + /* XXX LOCKING probably should have i_meta_lock ?*/
> /* That's it */
>
> *where->p = where->key;
> - ei->i_next_alloc_block = block;
> - ei->i_next_alloc_goal = le32_to_cpu(where[num-1].key);
>
> - write_unlock(&ei->i_meta_lock);
> + /*
> + * Update the host buffer_head or inode to point to more just allocated
> + * direct blocks blocks
> + */
> + if (num == 0 && blks > 1) {
> + current_block = le32_to_cpu(where->key + 1);
> + for (i = 1; i < blks; i++)
> + *(where->p + i ) = cpu_to_le32(current_block++);
> + }
> +
> + /*
> + * update the most recently allocated logical & physical block
> + * in i_block_alloc_info, to assist find the proper goal block for next
> + * allocation
> + */
> + if (block_i) {
> + block_i->last_alloc_logical_block = block + blks - 1;
> + block_i->last_alloc_physical_block =
> + le32_to_cpu(where[num].key + blks - 1);
> + }
>
> /* We are done with atomic stuff, now do the rest of housekeeping */
>
> - inode->i_ctime = CURRENT_TIME_SEC;
> -
> /* had we spliced it onto indirect block? */
> if (where->bh)
> mark_buffer_dirty_inode(where->bh, inode);
>
> + inode->i_ctime = CURRENT_TIME_SEC;
> mark_inode_dirty(inode);
> - return 0;
> -
> -changed:
> - write_unlock(&ei->i_meta_lock);
> - for (i = 1; i < num; i++)
> - bforget(where[i].bh);
> - for (i = 0; i < num; i++)
> - ext2_free_blocks(inode, le32_to_cpu(where[i].key), 1);
> - return -EAGAIN;
> }
>
> /*
> @@ -542,62 +568,91 @@
> * That has a nice additional property: no special recovery from the failed
> * allocations is needed - we simply release blocks and do not touch anything
> * reachable from inode.
> + *
> + * `handle' can be NULL if create == 0.
> + *
> + * The BKL may not be held on entry here. Be sure to take it early.
> + * return > 0, # of blocks mapped or allocated.
> + * return = 0, if plain lookup failed.
> + * return < 0, error case.
> */
> -
> -int ext2_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
> +int ext2_get_blocks(struct inode *inode,
> + sector_t iblock, unsigned long maxblocks,
> + struct buffer_head *bh_result,
> + int create)
> {
> int err = -EIO;
> int offsets[4];
> Indirect chain[4];
> Indirect *partial;
> unsigned long goal;
> - int left;
> - int boundary = 0;
> - int depth = ext2_block_to_path(inode, iblock, offsets, &boundary);
> + int indirect_blks;
> + int blocks_to_boundary = 0;
> + int depth;
> + struct ext2_inode_info *ei = EXT2_I(inode);
> + int count = 0;
> + unsigned long first_block = 0;
>
> - if (depth == 0)
> - goto out;
> + depth = ext2_block_to_path(inode,iblock,offsets,&blocks_to_boundary);
>
> + if (depth == 0)
> + return (err);
> reread:
> partial = ext2_get_branch(inode, depth, offsets, chain, &err);
>
> /* Simplest case - block found, no allocation needed */
> if (!partial) {
> -got_it:
> - map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
> - if (boundary)
> - set_buffer_boundary(bh_result);
> - /* Clean up and exit */
> - partial = chain+depth-1; /* the whole chain */
> - goto cleanup;
> + first_block = chain[depth - 1].key;
> + clear_buffer_new(bh_result); /* What's this do? */
> + count++;
> + /*map more blocks*/
> + while (count < maxblocks && count <= blocks_to_boundary) {
> + if (!verify_chain(chain, partial)) {
> + /*
> + * Indirect block might be removed by
> + * truncate while we were reading it.
> + * Handling of that case: forget what we've
> + * got now, go to reread.
> + */
> + count = 0;
> + goto changed;
> + }
> + if (le32_to_cpu(*(chain[depth-1].p+count) ==
> + (first_block + count)))
> + count++;
> + else
> + break;
> + }
> + goto got_it;
> }
>
> /* Next simple case - plain lookup or failed read of indirect block */
> - if (!create || err == -EIO) {
> -cleanup:
> - while (partial > chain) {
> - brelse(partial->bh);
> - partial--;
> - }
> -out:
> - return err;
> - }
> + if (!create || err == -EIO)
> + goto cleanup;
>
> /*
> - * Indirect block might be removed by truncate while we were
> - * reading it. Handling of that case (forget what we've got and
> - * reread) is taken out of the main path.
> + * Okay, we need to do block allocation. Lazily initialize the block
> + * allocation info here if necessary
> + */
> + if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
> + ext2_init_block_alloc_info(inode);
> +
> + goal = ext2_find_goal(inode, iblock, chain, partial);
> +
> + /* the number of blocks need to allocate for [d,t]indirect blocks */
> + indirect_blks = (chain + depth) - partial - 1;
> + /*
> + * Next look up the indirect map to count the totoal number of
> + * direct blocks to allocate for this branch.
> */
> - if (err == -EAGAIN)
> - goto changed;
> + count = ext2_blks_to_allocate(partial, indirect_blks,
> + maxblocks, blocks_to_boundary);
> + /*
> + * XXX ???? Block out ext2_truncate while we alter the tree
> + */
> + err = ext2_alloc_branch(inode, indirect_blks, &count, goal,
> + offsets + (partial - chain), partial);
>
> - goal = 0;
> - if (ext2_find_goal(inode, iblock, chain, partial, &goal) < 0)
> - goto changed;
> -
> - left = (chain + depth) - partial;
> - err = ext2_alloc_branch(inode, left, goal,
> - offsets+(partial-chain), partial);
> if (err)
> goto cleanup;
>
> @@ -611,12 +666,22 @@
> goto cleanup;
> }
>
> - if (ext2_splice_branch(inode, iblock, chain, partial, left) < 0)
> - goto changed;
> + ext2_splice_branch(inode, iblock, partial, indirect_blks, count);
>
> set_buffer_new(bh_result);
> - goto got_it;
> -
> +got_it:
> + map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key));
> + if (blocks_to_boundary == 0)
> + set_buffer_boundary(bh_result);
> + err = count;
> + /* Clean up and exit */
> + partial = chain + depth - 1; /* the whole chain */
> +cleanup:
> + while (partial > chain) {
> + brelse(partial->bh);
> + partial--;
> + }
> + return err;
> changed:
> while (partial > chain) {
> brelse(partial->bh);
> @@ -625,6 +690,19 @@
> goto reread;
> }
>
> +int ext2_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
> +{
> + unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
> + int ret = ext2_get_blocks(inode, iblock, max_blocks,
> + bh_result, create);
> + if (ret > 0) {
> + bh_result->b_size = (ret << inode->i_blkbits);
> + ret = 0;
> + }
> + return ret;
> +
> +}
> +
> static int ext2_writepage(struct page *page, struct writeback_control *wbc)
> {
> return block_write_full_page(page, ext2_get_block, wbc);
> @@ -916,8 +994,6 @@
> if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
> return;
>
> - ext2_discard_prealloc(inode);
> -
> blocksize = inode->i_sb->s_blocksize;
> iblock = (inode->i_size + blocksize-1)
> >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
> @@ -943,10 +1019,12 @@
> partial = ext2_find_shared(inode, n, offsets, chain, &nr);
> /* Kill the top of shared branch (already detached) */
> if (nr) {
> - if (partial == chain)
> + if (partial == chain) {
> mark_inode_dirty(inode);
> - else
> + } else {
> + ext2_mark_fs_dirty(inode->i_sb);
> mark_buffer_dirty_inode(partial->bh, inode);
> + }
> ext2_free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);
> }
> /* Clear the ends of indirect blocks on the shared branch */
> @@ -955,6 +1033,7 @@
> partial->p + 1,
> (__le32*)partial->bh->b_data+addr_per_block,
> (chain+n-1) - partial);
> + ext2_mark_fs_dirty(inode->i_sb);
> mark_buffer_dirty_inode(partial->bh, inode);
> brelse (partial->bh);
> partial--;
> @@ -986,9 +1065,13 @@
> case EXT2_TIND_BLOCK:
> ;
> }
> +
> + ext2_discard_reservation(inode);
> +
> inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
> if (inode_needs_sync(inode)) {
> sync_mapping_buffers(inode->i_mapping);
> + ext2_mark_fs_dirty(inode->i_sb);
> ext2_sync_inode (inode);
> } else {
> mark_inode_dirty(inode);
> @@ -1067,6 +1150,8 @@
> ei->i_acl = EXT2_ACL_NOT_CACHED;
> ei->i_default_acl = EXT2_ACL_NOT_CACHED;
> #endif
> + ei->i_block_alloc_info = NULL;
> +
> if (IS_ERR(raw_inode))
> goto bad_inode;
>
> @@ -1109,9 +1194,6 @@
> ei->i_dtime = 0;
> inode->i_generation = le32_to_cpu(raw_inode->i_generation);
> ei->i_state = 0;
> - ei->i_next_alloc_block = 0;
> - ei->i_next_alloc_goal = 0;
> - ei->i_prealloc_count = 0;
> ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
> ei->i_dir_start_lookup = 0;
>
> @@ -1121,6 +1203,7 @@
> */
> for (n = 0; n < EXT2_N_BLOCKS; n++)
> ei->i_data[n] = raw_inode->i_block[n];
> + INIT_LIST_HEAD(&ei->i_orphan);
>
> if (S_ISREG(inode->i_mode)) {
> inode->i_op = &ext2_file_inode_operations;
> diff -x '*~' -uNr vanilla-linux/fs/ext2/ioctl.c uml-clean/fs/ext2/ioctl.c
> --- vanilla-linux/fs/ext2/ioctl.c 2006-03-24 01:47:33.000000000 -0800
> +++ uml-clean/fs/ext2/ioctl.c 2006-03-22 17:49:49.000000000 -0800
> @@ -20,6 +20,7 @@
> {
> struct ext2_inode_info *ei = EXT2_I(inode);
> unsigned int flags;
> + unsigned short rsv_window_size;
>
> ext2_debug ("cmd = %u, arg = %lu\n", cmd, arg);
>
> @@ -76,6 +77,48 @@
> inode->i_ctime = CURRENT_TIME_SEC;
> mark_inode_dirty(inode);
> return 0;
> + case EXT2_IOC_GETRSVSZ:
> + if (test_opt(inode->i_sb, RESERVATION)
> + && S_ISREG(inode->i_mode)
> + && ei->i_block_alloc_info) {
> + rsv_window_size = ei->i_block_alloc_info->rsv_window_node.rsv_goal_size;
> + return put_user(rsv_window_size, (int __user *)arg);
> + }
> + return -ENOTTY;
> + case EXT2_IOC_SETRSVSZ: {
> +
> + if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode))
> + return -ENOTTY;
> +
> + if (IS_RDONLY(inode))
> + return -EROFS;
> +
> + if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER))
> + return -EACCES;
> +
> + if (get_user(rsv_window_size, (int __user *)arg))
> + return -EFAULT;
> +
> + if (rsv_window_size > EXT2_MAX_RESERVE_BLOCKS)
> + rsv_window_size = EXT2_MAX_RESERVE_BLOCKS;
> +
> + /*
> + * need to allocate reservation structure for this inode
> + * before set the window size
> + */
> + /*
> + * XXX What lock should protect the rsv_goal_size?
> + * Accessed in ext2_get_block only. ext3 uses i_truncate.
> + */
> + if (!ei->i_block_alloc_info)
> + ext2_init_block_alloc_info(inode);
> +
> + if (ei->i_block_alloc_info){
> + struct ext2_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node;
> + rsv->rsv_goal_size = rsv_window_size;
> + }
> + return 0;
> + }
> default:
> return -ENOTTY;
> }
> diff -x '*~' -uNr vanilla-linux/fs/ext2/Makefile uml-clean/fs/ext2/Makefile
> --- vanilla-linux/fs/ext2/Makefile 2006-01-02 19:21:10.000000000 -0800
> +++ uml-clean/fs/ext2/Makefile 2006-03-16 22:16:47.000000000 -0800
> @@ -5,7 +5,7 @@
> obj-$(CONFIG_EXT2_FS) += ext2.o
>
> ext2-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
> - ioctl.o namei.o super.o symlink.o
> + ioctl.o namei.o super.o symlink.o state.o
>
> ext2-$(CONFIG_EXT2_FS_XATTR) += xattr.o xattr_user.o xattr_trusted.o
> ext2-$(CONFIG_EXT2_FS_POSIX_ACL) += acl.o
> diff -x '*~' -uNr vanilla-linux/fs/ext2/namei.c uml-clean/fs/ext2/namei.c
> --- vanilla-linux/fs/ext2/namei.c 2006-03-24 01:48:18.000000000 -0800
> +++ uml-clean/fs/ext2/namei.c 2006-03-10 01:23:52.000000000 -0800
> @@ -267,6 +267,8 @@
>
> inode->i_ctime = dir->i_ctime;
> inode_dec_link_count(inode);
> + if (!inode->i_nlink)
> + ext2_orphan_add(inode);
> err = 0;
> out:
> return err;
> @@ -328,6 +330,8 @@
> if (dir_de)
> new_inode->i_nlink--;
> inode_dec_link_count(new_inode);
> + if (!new_inode->i_nlink)
> + ext2_orphan_add(new_inode);
> } else {
> if (dir_de) {
> err = -EMLINK;
> diff -x '*~' -uNr vanilla-linux/fs/ext2/state.c uml-clean/fs/ext2/state.c
> --- vanilla-linux/fs/ext2/state.c 1969-12-31 16:00:00.000000000 -0800
> +++ uml-clean/fs/ext2/state.c 2006-03-24 04:36:00.000000000 -0800
> @@ -0,0 +1,109 @@
> +/*
> + * Kernel thread to keep track of clean/dirty state of ext2 file system
> + */
> +#include <linux/buffer_head.h>
> +#include <linux/kthread.h>
> +#include "ext2.h"
> +
> +#define EXT2_DIRTY_TIMEOUT 1 /* Time in secs to check for dirty */
> +#define EXT2_DIRTY_JIFFIES (EXT2_DIRTY_TIMEOUT * HZ)
> +
> +/*
> + * ext2_update_state runs periodically to check to see if the file
> + * system has any ongoing write traffic. If no one has written to the
> + * file system recently, then we sync the file system and check if any
> + * metadata writes occurred while we were doing the sync. If no
> + * writes occurred, we go ahead and mark the file system clean. Any
> + * operation that changes the metadata must first mark the file system
> + * dirty (via ext2_mark_fs_dirty()) before any other writes hit disk.
> + *
> + * For debugging and measurement, we are keeping some statistics on
> + * how often the file system is dirty/clean in any given period in the
> + * superblock. They will go away if this hits production.
> + *
> + */
> +
> +static void ext2_update_state(struct super_block *sb)
> +{
> + struct ext2_sb_info *sbi = EXT2_SB(sb);
> + struct ext2_super_block *es = EXT2_SB(sb)->s_es;
> +
> + lock_super(sb);
> + sb->s_dirt = 1;
> + if (sbi->s_dirty_lately == EXT2_FS_DIRTY) {
> + es->s_dirty_count =
> + cpu_to_le32(le32_to_cpu(es->s_dirty_count) + 1);
> + /* Reset our dirty flag for the next interval */
> + sbi->s_dirty_lately = EXT2_FS_CLEAN;
> + } else {
> + es->s_clean_count =
> + cpu_to_le32(le32_to_cpu(es->s_clean_count) + 1);
> + /*
> + * This fs has not been written to recently. If it is
> + * currently marked dirty, sync all outstanding writes
> + * and see if we are still clean. If so, mark the fs
> + * clean.
> + */
> + if (es->s_fs_dirty != EXT2_FS_CLEAN) {
> + unlock_super(sb);
> + /* Sync all outstanding writes to file system */
> + /* XXX need to export below for moduleness */
> + fsync_super(sb);
> + lock_super(sb);
> + /* New writes may have occurred during the
> + * sync, recheck */
> + if (sbi->s_dirty_lately == EXT2_FS_CLEAN)
> + __ext2_mark_fs_clean(sb);
> + else
> + printk(KERN_DEBUG "fs dirtied during sync\n");
> + }
> + /*
> + * We don't flush the superblock if the file system
> + * was already marked clean. Otherwise we'll be
> + * writing to the disk continuously while the file
> + * system is idle. This means the stats won't
> + * necessarily get written to disk until the fs is
> + * unmounted.
> + */
> + }
> + unlock_super(sb);
> +}
> +
> +static void ext2_print_stats(struct super_block *sb)
> +{
> + struct ext2_super_block *es = EXT2_SB(sb)->s_es;
> + unsigned int clean, dirty, total, percent;
> +
> + clean = le32_to_cpu(es->s_clean_count);
> + dirty = le32_to_cpu(es->s_dirty_count);
> + total = dirty + clean;
> +
> + if (total == 0)
> + percent = 0;
> + else
> + percent = (clean * 100) / total;
> + /* XXX add fs mount point */
> + printk(KERN_DEBUG "ext2: dirty:%u clean:%u total:%u percent clean: %u\n",
> + dirty, clean, total, percent);
> +}
> +
> +int ext2_dirtyd(void *arg)
> +{
> + struct super_block *sb = (struct super_block *) arg;
> +
> + printk(KERN_INFO "ext2_dirtyd starting, interval %d seconds\n",
> + EXT2_DIRTY_TIMEOUT);
> + ext2_print_stats(sb);
> +
> + while (1) {
> + schedule_timeout_interruptible(EXT2_DIRTY_JIFFIES);
> + if (kthread_should_stop())
> + break;
> + if (freezing(current))
> + refrigerator();
> + ext2_update_state(sb);
> + }
> +
> + ext2_print_stats(sb);
> + return 0;
> +}
> diff -x '*~' -uNr vanilla-linux/fs/ext2/super.c uml-clean/fs/ext2/super.c
> --- vanilla-linux/fs/ext2/super.c 2006-03-24 01:48:18.000000000 -0800
> +++ uml-clean/fs/ext2/super.c 2006-03-24 05:20:08.000000000 -0800
> @@ -30,6 +30,7 @@
> #include <linux/vfs.h>
> #include <linux/seq_file.h>
> #include <linux/mount.h>
> +#include <linux/kthread.h>
> #include <asm/uaccess.h>
> #include "ext2.h"
> #include "xattr.h"
> @@ -113,6 +114,7 @@
> int i;
> struct ext2_sb_info *sbi = EXT2_SB(sb);
>
> + kthread_stop(sbi->s_dirtyd);
> ext2_xattr_put_super(sb);
> if (!(sb->s_flags & MS_RDONLY)) {
> struct ext2_super_block *es = sbi->s_es;
> @@ -129,6 +131,7 @@
> percpu_counter_destroy(&sbi->s_freeblocks_counter);
> percpu_counter_destroy(&sbi->s_freeinodes_counter);
> percpu_counter_destroy(&sbi->s_dirs_counter);
> + kfree(sbi->s_esp);
> brelse (sbi->s_sbh);
> sb->s_fs_info = NULL;
> kfree(sbi);
> @@ -164,6 +167,7 @@
> if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
> SLAB_CTOR_CONSTRUCTOR) {
> rwlock_init(&ei->i_meta_lock);
> + INIT_LIST_HEAD(&ei->i_orphan);
> #ifdef CONFIG_EXT2_FS_XATTR
> init_rwsem(&ei->xattr_sem);
> #endif
> @@ -191,6 +195,7 @@
>
> static void ext2_clear_inode(struct inode *inode)
> {
> + struct ext2_block_alloc_info *rsv = EXT2_I(inode)->i_block_alloc_info;
> #ifdef CONFIG_EXT2_FS_POSIX_ACL
> struct ext2_inode_info *ei = EXT2_I(inode);
>
> @@ -203,6 +208,9 @@
> ei->i_default_acl = EXT2_ACL_NOT_CACHED;
> }
> #endif
> + ext2_discard_reservation(inode);
> + EXT2_I(inode)->i_block_alloc_info = NULL;
> + kfree(rsv);
> }
>
> static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
> @@ -240,7 +248,6 @@
> .destroy_inode = ext2_destroy_inode,
> .read_inode = ext2_read_inode,
> .write_inode = ext2_write_inode,
> - .put_inode = ext2_put_inode,
> .delete_inode = ext2_delete_inode,
> .put_super = ext2_put_super,
> .write_super = ext2_write_super,
> @@ -289,7 +296,7 @@
> Opt_err_ro, Opt_nouid32, Opt_nocheck, Opt_debug,
> Opt_oldalloc, Opt_orlov, Opt_nobh, Opt_user_xattr, Opt_nouser_xattr,
> Opt_acl, Opt_noacl, Opt_xip, Opt_ignore, Opt_err, Opt_quota,
> - Opt_usrquota, Opt_grpquota
> + Opt_usrquota, Opt_grpquota, Opt_reservation, Opt_noreservation
> };
>
> static match_table_t tokens = {
> @@ -321,6 +328,8 @@
> {Opt_ignore, "noquota"},
> {Opt_quota, "quota"},
> {Opt_usrquota, "usrquota"},
> + {Opt_reservation, "reservation"},
> + {Opt_noreservation, "noreservation"},
> {Opt_err, NULL}
> };
>
> @@ -448,6 +457,14 @@
> break;
> #endif
>
> + case Opt_reservation:
> + set_opt(sbi->s_mount_opt, RESERVATION);
> + printk("reservations ON\n");
> + break;
> + case Opt_noreservation:
> + clear_opt(sbi->s_mount_opt, RESERVATION);
> + printk("reservations OFF\n");
> + break;
> case Opt_ignore:
> break;
> default:
> @@ -649,9 +666,23 @@
> /*
> * Note: s_es must be initialized as soon as possible because
> * some ext2 macro-instructions depend on its value
> + *
> + * We used to operate on the on-disk superblock directly
> + * inside the buffer in the superblock bh. However, now that
> + * we need to do an asynchronous write of the superblock, we
> + * have to allocate a separate in-memory buffer for the
> + * superblock. For simplicity, we allocate a buffer that is
> + * as large as device block size and then set the sbi->s_es
> + * pointer to the beginning of the superblock inside the
> + * buffer. -VAL
> */
> - es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
> - sbi->s_es = es;
> + sbi->s_esp = kmalloc(bh->b_size, GFP_KERNEL);
> + if (!sbi->s_esp)
> + goto failed_sbi;
> + memcpy(sbi->s_esp, bh->b_data, bh->b_size);
> + sbi->s_es = (struct ext2_super_block *) sbi->s_esp + offset;
> + es = sbi->s_es;
> +
> sb->s_magic = le16_to_cpu(es->s_magic);
>
> if (sb->s_magic != EXT2_SUPER_MAGIC)
> @@ -678,6 +709,8 @@
> sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
> sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
>
> + set_opt(sbi->s_mount_opt, RESERVATION);
> +
> if (!parse_options ((char *) data, sbi))
> goto failed_mount;
>
> @@ -726,6 +759,7 @@
> /* If the blocksize doesn't match, re-read the thing.. */
> if (sb->s_blocksize != blocksize) {
> brelse(bh);
> + kfree(sbi->s_esp);
>
> if (!sb_set_blocksize(sb, blocksize)) {
> printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");
> @@ -740,8 +774,13 @@
> "2nd try.\n");
> goto failed_sbi;
> }
> - es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
> - sbi->s_es = es;
> + sbi->s_esp = kmalloc(bh->b_size, GFP_KERNEL);
> + if (!sbi->s_esp)
> + goto failed_sbi;
> + memcpy(sbi->s_esp, bh->b_data, bh->b_size);
> + sbi->s_es = (struct ext2_super_block *) sbi->s_esp + offset;
> + es = sbi->s_es;
> +
> if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
> printk ("EXT2-fs: Magic mismatch, very weird !\n");
> goto failed_mount;
> @@ -865,6 +904,19 @@
> sbi->s_gdb_count = db_count;
> get_random_bytes(&sbi->s_next_generation, sizeof(u32));
> spin_lock_init(&sbi->s_next_gen_lock);
> + /* per fileystem reservation list head & lock */
> + spin_lock_init(&sbi->s_rsv_window_lock);
> + sbi->s_rsv_window_root = RB_ROOT;
> + /* Add a single, static dummy reservation to the start of the
> + * reservation window list --- it gives us a placeholder for
> + * append-at-start-of-list which makes the allocation logic
> + * _much_ simpler. */
> + sbi->s_rsv_window_head.rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
> + sbi->s_rsv_window_head.rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
> + sbi->s_rsv_window_head.rsv_alloc_hit = 0;
> + sbi->s_rsv_window_head.rsv_goal_size = 0;
> + ext2_rsv_window_add(sb, &sbi->s_rsv_window_head);
> +
> /*
> * set up enough so that it can read an inode
> */
> @@ -894,6 +946,9 @@
> ext2_count_free_inodes(sb));
> percpu_counter_mod(&sbi->s_dirs_counter,
> ext2_count_dirs(sb));
> + INIT_LIST_HEAD(&sbi->s_orphan);
> + /* XXX be smarter about starting/stopping */
> + sbi->s_dirtyd = kthread_run(ext2_dirtyd, sb, "ext2dirtyd");
> return 0;
>
> cantfind_ext2:
> @@ -910,27 +965,79 @@
> kfree(sbi->s_debts);
> failed_mount:
> brelse(bh);
> + kfree(sbi->s_esp);
> failed_sbi:
> sb->s_fs_info = NULL;
> kfree(sbi);
> return -EINVAL;
> }
>
> +/*
> + * Helper function to copy the in-memory superblock into the buffer
> + * used to write it to disk.
> + */
> +
> +void ext2_prepare_super(struct super_block * sb)
> +{
> + struct buffer_head *bh = EXT2_SB(sb)->s_sbh;
> + char *esp = EXT2_SB(sb)->s_esp;
> +
> + lock_buffer(bh);
> + memcpy(bh->b_data, esp, bh->b_size);
> + unlock_buffer(bh);
> +}
> +
> static void ext2_commit_super (struct super_block * sb,
> struct ext2_super_block * es)
> {
> + struct buffer_head *bh = EXT2_SB(sb)->s_sbh;
> +
> es->s_wtime = cpu_to_le32(get_seconds());
> - mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
> + ext2_prepare_super(sb);
> + mark_buffer_dirty(bh);
> sb->s_dirt = 0;
> }
>
> +static void ext2_end_async_io(struct buffer_head *bh, int uptodate)
> +{
> + /* XXX Deal with failed write of dirty fs bit? */
> + if (uptodate)
> + set_buffer_uptodate(bh);
> + else
> + clear_buffer_uptodate(bh);
> + unlock_buffer(bh);
> +}
> +
> +/*
> + * Submit the superblock for writing, but don't wait - we only need a
> + * write barrier here (has to hit disk after previous writes and
> + * before any subsequent writes).
> + */
> +static
> +void ext2_write_super_async(struct super_block *sb, struct ext2_super_block *es)
> +{
> + struct buffer_head *bh = EXT2_SB(sb)->s_sbh;
> + char *esp = EXT2_SB(sb)->s_esp;
> +
> + lock_buffer(bh);
> + bh->b_end_io = ext2_end_async_io;
> + clear_buffer_dirty(bh);
> + memcpy(bh->b_data, esp, bh->b_size);
> + submit_bh(WRITE_BARRIER, bh);
> + sb->s_dirt = 0;
> + /* bh unlocked in end io function */
> +}
> +
> static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
> {
> + struct buffer_head *bh = EXT2_SB(sb)->s_sbh;
> +
> es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
> es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
> es->s_wtime = cpu_to_le32(get_seconds());
> - mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
> - sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
> + ext2_prepare_super(sb);
> + mark_buffer_dirty(bh);
> + sync_dirty_buffer(bh);
> sb->s_dirt = 0;
> }
>
> @@ -943,12 +1050,19 @@
> * flags to 0. We need to set this flag to 0 since the fs
> * may have been checked while mounted and e2fsck may have
> * set s_state to EXT2_VALID_FS after some corrections.
> + *
> + * Now we are keeping a copy of the superblock elsewhere in memory
> + * (pointed to by sbi->s_es, and copying it into the buffer on need
> + * (see ext2_prepare_super()). This is so we can use the superblock
> + * to contain the fs-wide dirty bit. We need to be able to submit an
> + * asynchronous I/O to update this bit without having the superblock
> + * information change while it is in flight. -VAL
> */
>
> void ext2_write_super (struct super_block * sb)
> {
> struct ext2_super_block * es;
> - lock_kernel();
> + lock_kernel(); /* XXX Need to lock_kernel() when writing sb?? */
> if (!(sb->s_flags & MS_RDONLY)) {
> es = EXT2_SB(sb)->s_es;
>
> @@ -956,8 +1070,10 @@
> ext2_debug ("setting valid to 0\n");
> es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) &
> ~EXT2_VALID_FS);
> - es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
> - es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
> + es->s_free_blocks_count =
> + cpu_to_le32(ext2_count_free_blocks(sb));
> + es->s_free_inodes_count =
> + cpu_to_le32(ext2_count_free_inodes(sb));
> es->s_mtime = cpu_to_le32(get_seconds());
> ext2_sync_super(sb, es);
> } else
> @@ -967,6 +1083,183 @@
> unlock_kernel();
> }
>
> +/*
> + * Functions for marking fs as dirty or clean with respect to ongoing
> + * write activity. Note this is different from the fs valid bit,
> + * which determines whether the fs has been cleanly unmounted.
> + *
> + * sb->s_lock MUST be held while calling this function.
> + */
> +
> +static void __ext2_mark_super(struct super_block *sb, int state)
> +{
> + struct ext2_sb_info *sbi = EXT2_SB(sb);
> + struct ext2_super_block *es = sbi->s_es;
> +
> + if (sb->s_flags & MS_RDONLY)
> + return;
> + if (es->s_fs_dirty == state)
> + return;
> +
> + es->s_fs_dirty = state;
> + es->s_wtime = cpu_to_le32(get_seconds());
> + /*
> + * If it's dirty, don't update free block/inode counts -
> + * that's expensive, and we have to rebuild them anyway.
> + *
> + * If it's clean, update the free block/inode counts, they
> + * have to be correct now.
> + */
> + if (state == EXT2_FS_DIRTY) {
> + printk(KERN_DEBUG "marking fs dirty\n");
> + sbi->s_dirty_lately = EXT2_FS_DIRTY;
> + } else {
> + printk(KERN_DEBUG "marking fs clean\n");
> + es->s_free_blocks_count =
> + cpu_to_le32(ext2_count_free_blocks(sb));
> + es->s_free_inodes_count =
> + cpu_to_le32(ext2_count_free_inodes(sb));
> + /* We only reset the dirty_lately flag in ext2_update_state */
> + }
> + ext2_write_super_async(sb, es);
> +}
> +
> +static void __ext2_mark_fs_dirty(struct super_block *sb)
> +{
> + __ext2_mark_super(sb, EXT2_FS_DIRTY);
> +}
> +
> +void __ext2_mark_fs_clean(struct super_block *sb)
> +{
> + __ext2_mark_super(sb, EXT2_FS_CLEAN);
> +}
> +
> +/*
> + * This function must be called every time we modify file system
> + * metadata, and must be called BEFORE any write I/O is scheduled.
> + */
> +
> +void ext2_mark_fs_dirty(struct super_block *sb)
> +{
> + /* XXX get around locking super every write ? */
> + lock_super(sb);
> + __ext2_mark_super(sb, EXT2_FS_DIRTY);
> + unlock_super(sb);
> +}
> +
> +/*
> + * Whenever we mark an inode dirty, we must also mark the file system
> + * dirty.
> + *
> + * XXX Currently mark_inode_dirty() is #defined as
> + * ext2_mark_inode_dirty(), hence the bogus use of
> + * __mark_inode_dirty(). I don't want to replace all instances of
> + * mark_inode_dirty until I'm sure this is what I want to do.
> + */
> +
> +static void __ext2_mark_inode_dirty(struct inode *inode)
> +{
> + __ext2_mark_fs_dirty(inode->i_sb);
> + __mark_inode_dirty(inode, I_DIRTY);
> +}
> +
> +void ext2_mark_inode_dirty(struct inode *inode)
> +{
> + ext2_mark_fs_dirty(inode->i_sb);
> + __mark_inode_dirty(inode, I_DIRTY);
> +}
> +
> +/*
> + * orphan inode stuff, stolen from ext3
> + *
> + */
> +
> +#ifdef EXT2FS_DEBUG
> +static inline struct inode *orphan_list_entry(struct list_head *l)
> +{
> + return &list_entry(l, struct ext2_inode_info, i_orphan)->vfs_inode;
> +}
> +
> +static void dump_orphan_list(struct super_block *sb, struct ext2_sb_info *sbi)
> +{
> + struct list_head *l;
> + printk(KERN_DEBUG "sb_info orphan list:\n");
> + list_for_each(l, &sbi->s_orphan) {
> + struct inode *inode = orphan_list_entry(l);
> + printk(KERN_DEBUG " "
> + "inode %s:%ld at %p: mode %o, nlink %d, next %d\n",
> + inode->i_sb->s_id, inode->i_ino, inode,
> + inode->i_mode, inode->i_nlink,
> + NEXT_ORPHAN(inode));
> + }
> +}
> +#endif
> +/*
> + * ext2_orphan_add() links an unlinked inode into a list of such
> + * inodes, starting at the superblock, in case we crash before the
> + * file is closed and deleted.
> + *
> + * We depend on the ext3 orphan recovery code in fsck to clean up.
> + */
> +void ext2_orphan_add(struct inode *inode)
> +{
> + struct super_block *sb = inode->i_sb;
> + struct ext2_sb_info *sbi = EXT2_SB(sb);
> + struct ext2_super_block *es = sbi->s_es;
> +
> + lock_super(sb);
> + if (!list_empty(&EXT2_I(inode)->i_orphan)) {
> + unlock_super(sb);
> + return;
> + }
> + /* Insert this inode at the head of the on-disk orphan list... */
> + NEXT_ORPHAN(inode) = le32_to_cpu(es->s_last_orphan);
> + es->s_last_orphan = cpu_to_le32(inode->i_ino);
> + /* Add to in-memory list */
> + list_add(&EXT2_I(inode)->i_orphan, &EXT2_SB(sb)->s_orphan);
> + __ext2_mark_inode_dirty(inode);
> + unlock_super(sb);
> + return;
> +}
> +
> +/*
> + * ext2_orphan_del() removes an unlinked inode from the list of such
> + * inodes stored on disk, because it is finally being cleaned up.
> + */
> +void ext2_orphan_del(struct inode *inode)
> +{
> + struct list_head *prev;
> + struct super_block *sb = inode->i_sb;
> + struct ext2_inode_info *ei = EXT2_I(inode);
> + struct ext2_sb_info *sbi;
> + unsigned long ino_next;
> +
> + lock_super(sb);
> + if (list_empty(&ei->i_orphan)) {
> + unlock_super(sb);
> + return;
> + }
> +
> + ino_next = NEXT_ORPHAN(inode);
> + prev = ei->i_orphan.prev;
> + sbi = EXT2_SB(sb);
> +
> + list_del_init(&ei->i_orphan);
> +
> + if (prev == &sbi->s_orphan) {
> + sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
> + } else {
> + struct inode *i_prev =
> + &list_entry(prev, struct ext2_inode_info,
> + i_orphan)->vfs_inode;
> + NEXT_ORPHAN(i_prev) = ino_next;
> + __ext2_mark_inode_dirty(i_prev);
> + }
> + __ext2_mark_inode_dirty(inode);
> + unlock_super(sb);
> + return;
> +}
> +
> static int ext2_remount (struct super_block * sb, int * flags, char * data)
> {
> struct ext2_sb_info * sbi = EXT2_SB(sb);
> @@ -993,6 +1286,10 @@
> sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
> ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
>
> + /* Superblock may have changed on disk, reread into memory copy */
> +
> + memcpy(sbi->s_esp, sbi->s_sbh->b_data, sbi->s_sbh->b_size);
> +
> es = sbi->s_es;
> if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=
> (old_mount_opt & EXT2_MOUNT_XIP)) &&
> @@ -1125,7 +1422,7 @@
>
> tmp_bh.b_state = 0;
> err = ext2_get_block(inode, blk, &tmp_bh, 0);
> - if (err)
> + if (err < 0)
> return err;
> if (!buffer_mapped(&tmp_bh)) /* A hole? */
> memset(data, 0, tocopy);
> @@ -1164,7 +1461,7 @@
>
> tmp_bh.b_state = 0;
> err = ext2_get_block(inode, blk, &tmp_bh, 1);
> - if (err)
> + if (err < 0)
> goto out;
> if (offset || tocopy != EXT2_BLOCK_SIZE(sb))
> bh = sb_bread(sb, tmp_bh.b_blocknr);
> diff -x '*~' -uNr vanilla-linux/fs/ext2/xattr.c uml-clean/fs/ext2/xattr.c
> --- vanilla-linux/fs/ext2/xattr.c 2006-03-24 01:47:33.000000000 -0800
> +++ uml-clean/fs/ext2/xattr.c 2006-03-24 03:01:33.000000000 -0800
> @@ -345,6 +345,7 @@
> lock_super(sb);
> EXT2_SB(sb)->s_es->s_feature_compat |=
> cpu_to_le32(EXT2_FEATURE_COMPAT_EXT_ATTR);
> + ext2_prepare_super(sb);
> sb->s_dirt = 1;
> mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
> unlock_super(sb);
> @@ -688,6 +689,7 @@
>
> ext2_xattr_update_super_block(sb);
> }
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(new_bh);
> if (IS_SYNC(inode)) {
> sync_dirty_buffer(new_bh);
> @@ -741,6 +743,7 @@
> if (ce)
> mb_cache_entry_release(ce);
> DQUOT_FREE_BLOCK(inode, 1);
> + ext2_mark_fs_dirty(sb);
> mark_buffer_dirty(old_bh);
> ea_bdebug(old_bh, "refcount now=%d",
> le32_to_cpu(HDR(old_bh)->h_refcount));
> @@ -801,6 +804,7 @@
> ea_bdebug(bh, "refcount now=%d",
> le32_to_cpu(HDR(bh)->h_refcount));
> unlock_buffer(bh);
> + ext2_mark_fs_dirty(inode->i_sb);
> mark_buffer_dirty(bh);
> if (IS_SYNC(inode))
> sync_dirty_buffer(bh);
> diff -x '*~' -uNr vanilla-linux/include/linux/ext2_fs.h uml-clean/include/linux/ext2_fs.h
> --- vanilla-linux/include/linux/ext2_fs.h 2006-01-02 19:21:10.000000000 -0800
> +++ uml-clean/include/linux/ext2_fs.h 2006-03-24 04:34:00.000000000 -0800
> @@ -29,11 +29,12 @@
> #undef EXT2FS_DEBUG
>
> /*
> - * Define EXT2_PREALLOCATE to preallocate data blocks for expanding files
> + * Define EXT2_RESERVATION to reserve data blocks for expanding files
> */
> -#define EXT2_PREALLOCATE
> -#define EXT2_DEFAULT_PREALLOC_BLOCKS 8
> -
> +#define EXT2_DEFAULT_RESERVE_BLOCKS 8
> +/*max window size: 1024(direct blocks) + 3([t,d]indirect blocks) */
> +#define EXT2_MAX_RESERVE_BLOCKS 1027
> +#define EXT2_RESERVE_WINDOW_NOT_ALLOCATED 0
> /*
> * The second extended file system version
> */
> @@ -117,6 +118,12 @@
> #endif
>
> /*
> + * Macro for dealing with orphan inode list
> + */
> +
> +#define NEXT_ORPHAN(inode) EXT2_I(inode)->i_dtime
> +
> +/*
> * Macro-instructions used to manage fragments
> */
> #define EXT2_MIN_FRAG_SIZE 1024
> @@ -204,6 +211,8 @@
> #define EXT2_IOC_SETFLAGS _IOW('f', 2, long)
> #define EXT2_IOC_GETVERSION _IOR('v', 1, long)
> #define EXT2_IOC_SETVERSION _IOW('v', 2, long)
> +#define EXT2_IOC_GETRSVSZ _IOR('f', 5, long)
> +#define EXT2_IOC_SETRSVSZ _IOW('f', 6, long)
>
> /*
> * Structure of an inode on the disk
> @@ -296,6 +305,15 @@
> */
> #define EXT2_VALID_FS 0x0001 /* Unmounted cleanly */
> #define EXT2_ERROR_FS 0x0002 /* Errors detected */
> +/*
> + * Bits defining whether the file system is currently clean or not.
> + * Note that in file systems created by old code, the bit would be set
> + * to 0. To be safe, we must define 0 as dirty and 1 as clean.
> + *
> + * XXX Should convert to state bits, but need to fix fsck first.
> + */
> +#define EXT2_FS_CLEAN 1
> +#define EXT2_FS_DIRTY 0
>
> /*
> * Mount flags
> @@ -313,8 +331,9 @@
> #define EXT2_MOUNT_XATTR_USER 0x004000 /* Extended user attributes */
> #define EXT2_MOUNT_POSIX_ACL 0x008000 /* POSIX Access Control Lists */
> #define EXT2_MOUNT_XIP 0x010000 /* Execute in place */
> -#define EXT2_MOUNT_USRQUOTA 0x020000 /* user quota */
> -#define EXT2_MOUNT_GRPQUOTA 0x040000 /* group quota */
> +#define EXT2_MOUNT_USRQUOTA 0x020000 /* user quota */
> +#define EXT2_MOUNT_GRPQUOTA 0x040000 /* group quota */
> +#define EXT2_MOUNT_RESERVATION 0x080000 /* Preallocation */
>
>
> #define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt
> @@ -407,7 +426,12 @@
> __u16 s_reserved_word_pad;
> __le32 s_default_mount_opts;
> __le32 s_first_meta_bg; /* First metablock block group */
> - __u32 s_reserved[190]; /* Padding to the end of the block */
> + __u32 s_journal_reserved[18]; /* Used by ext3 journaling */
> + __u8 s_fs_dirty; /* Fs-wide dirty bit */
> + __u8 s_bytes_reserved[3]; /* Padding */
> + __u32 s_clean_count; /* Intervals in which fs was clean */
> + __u32 s_dirty_count; /* Intervals in which fs was dirty */
> + __u32 s_reserved[169]; /* Padding to the end of the block */
> };
>
> /*
> diff -x '*~' -uNr vanilla-linux/include/linux/ext2_fs_sb.h uml-clean/include/linux/ext2_fs_sb.h
> --- vanilla-linux/include/linux/ext2_fs_sb.h 2006-01-02 19:21:10.000000000 -0800
> +++ uml-clean/include/linux/ext2_fs_sb.h 2006-03-24 04:00:53.000000000 -0800
> @@ -18,6 +18,44 @@
>
> #include <linux/blockgroup_lock.h>
> #include <linux/percpu_counter.h>
> +#include <linux/rbtree.h>
> +
> +/* XXX Here for now... not interested in restructing headers JUST now */
> +
> +struct ext2_reserve_window {
> + __u32 _rsv_start; /* First byte reserved */
> + __u32 _rsv_end; /* Last byte reserved or 0 */
> +};
> +
> +struct ext2_reserve_window_node {
> + struct rb_node rsv_node;
> + __u32 rsv_goal_size;
> + __u32 rsv_alloc_hit;
> + struct ext2_reserve_window rsv_window;
> +};
> +
> +struct ext2_block_alloc_info {
> + /* information about reservation window */
> + struct ext2_reserve_window_node rsv_window_node;
> + /*
> + * was i_next_alloc_block in ext2_inode_info
> + * is the logical (file-relative) number of the
> + * most-recently-allocated block in this file.
> + * We use this for detecting linearly ascending allocation requests.
> + */
> + __u32 last_alloc_logical_block;
> + /*
> + * Was i_next_alloc_goal in ext2_inode_info
> + * is the *physical* companion to i_next_alloc_block.
> + * it the the physical block number of the block which was most-recentl
> + * allocated to this file. This give us the goal (target) for the next
> + * allocation when we detect linearly ascending requests.
> + */
> + __u32 last_alloc_physical_block;
> +};
> +
> +#define rsv_start rsv_window._rsv_start
> +#define rsv_end rsv_window._rsv_end
>
> /*
> * second extended-fs super-block data in memory
> @@ -34,7 +72,11 @@
> unsigned long s_desc_per_block; /* Number of group descriptors per block */
> unsigned long s_groups_count; /* Number of groups in the fs */
> struct buffer_head * s_sbh; /* Buffer containing the super block */
> - struct ext2_super_block * s_es; /* Pointer to the super block in the buffer */
> + struct ext2_super_block * s_es; /* Pointer to the in memory super block */
> + char * s_esp; /* Pointer to kmalloc'd memory
> + * containing ext2_super_block
> + * - might be offset inside
> + * buffer */
> struct buffer_head ** s_group_desc;
> unsigned long s_mount_opt;
> uid_t s_resuid;
> @@ -53,6 +95,15 @@
> struct percpu_counter s_freeinodes_counter;
> struct percpu_counter s_dirs_counter;
> struct blockgroup_lock s_blockgroup_lock;
> + /* root of the per fs reservation window tree */
> + spinlock_t s_rsv_window_lock;
> + struct rb_root s_rsv_window_root;
> + struct ext2_reserve_window_node s_rsv_window_head;
> +
> + wait_queue_head_t s_wait;
> + struct list_head s_orphan; /* For quick access to orphan inodes */
> + int s_dirty_lately;
> + struct task_struct *s_dirtyd; /* task pointer for dirty thread */
> };
>
> #endif /* _LINUX_EXT2_FS_SB */
>
>
> -------------------------------------------------------
> This SF.Net email is sponsored by xPML, a groundbreaking scripting language
> that extends applications into web and mobile media. Attend the live webcast
> and join the prime developer group breaking into this new coding territory!
> http://sel.as-us.falkag.net/sel?cmd=lnk&kid=110944&bid=241720&dat=121642
> _______________________________________________
> Ext2-devel mailing list
> [email protected]
> https://lists.sourceforge.net/lists/listinfo/ext2-devel
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
[Index of Archives]
[Kernel Newbies]
[Netfilter]
[Bugtraq]
[Photo]
[Stuff]
[Gimp]
[Yosemite News]
[MIPS Linux]
[ARM Linux]
[Linux Security]
[Linux RAID]
[Video 4 Linux]
[Linux for the blind]
[Linux Resources]
