litmus-rt-edfsc.git - LITMUS^RT with the EDF-SC plugin for Real-Time Systems journal paper

diff options

author	Artem Bityutskiy <Artem.Bityutskiy@nokia.com>	2009-03-20 13:11:12 -0400
committer	Artem Bityutskiy <Artem.Bityutskiy@nokia.com>	2009-03-20 13:11:12 -0400
commit	7d4e9ccb435e51e013e63abd340b4f496428139c (patch)
tree	c61d7f4b984cf67de137f8a8f821e1dc4da3fa50
parent	fb1cd01a33ecb8a49d590c034ba146dff80c5597 (diff)

UBIFS: fix commentaries

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>

-rw-r--r--

-rw-r--r--

-rw-r--r--

-rw-r--r--

-rw-r--r--

-rw-r--r--

fs/ubifs/lpt_commit.c

-rw-r--r--

fs/ubifs/replay.c

-rw-r--r--

fs/ubifs/tnc.c

8 files changed, 9 insertions, 9 deletions


diff --git a/fs/ubifs/budget.c b/fs/ubifs/budget.c index 8cd425b628ee..af1914462f02 100644 --- a/fs/ubifs/budget.c +++ b/fs/ubifs/budget.c
@@ -322,8 +322,8 @@ static int can_use_rp(struct ubifs_info *c)
322	* be large, because UBIFS does not do any index consolidation as long as	322	* be large, because UBIFS does not do any index consolidation as long as
323	* there is free space. IOW, the index may take a lot of LEBs, but the LEBs	323	* there is free space. IOW, the index may take a lot of LEBs, but the LEBs
324	* will contain a lot of dirt.	324	* will contain a lot of dirt.
325	* o @c->min_idx_lebs is the the index presumably takes. IOW, the index may be	325	* o @c->min_idx_lebs is the number of LEBS the index presumably takes. IOW,
326	* consolidated to take up to @c->min_idx_lebs LEBs.	326	* the index may be consolidated to take up to @c->min_idx_lebs LEBs.
327	*	327	*
328	* This function returns zero in case of success, and %-ENOSPC in case of	328	* This function returns zero in case of success, and %-ENOSPC in case of
329	* failure.	329	* failure.


diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c index 93f6532eff00..ce2cd8343618 100644 --- a/fs/ubifs/debug.c +++ b/fs/ubifs/debug.c
@@ -1214,7 +1214,7 @@ static int dbg_check_znode(struct ubifs_info c, struct ubifs_zbranch zbr)
1214		1214
1215	/*	1215	/*
1216	* Make sure the last key in our znode is less or	1216	* Make sure the last key in our znode is less or
1217	* equivalent than the the key in zbranch which goes	1217	* equivalent than the key in the zbranch which goes
1218	* after our pointing zbranch.	1218	* after our pointing zbranch.
1219	*/	1219	*/
1220	cmp = keys_cmp(c, max,	1220	cmp = keys_cmp(c, max,


diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c index 4e7f0aca9ebc..4e256b8f56b2 100644 --- a/fs/ubifs/file.c +++ b/fs/ubifs/file.c
@@ -959,7 +959,7 @@ static int do_writepage(struct page *page, int len)
959	* whole index and correct all inode sizes, which is long an unacceptable.	959	* whole index and correct all inode sizes, which is long an unacceptable.
960	*	960	*
961	* To prevent situations like this, UBIFS writes pages back only if they are	961	* To prevent situations like this, UBIFS writes pages back only if they are
962	* within last synchronized inode size, i.e. the the size which has been	962	* within the last synchronized inode size, i.e. the size which has been
963	* written to the flash media last time. Otherwise, UBIFS forces inode	963	* written to the flash media last time. Otherwise, UBIFS forces inode
964	* write-back, thus making sure the on-flash inode contains current inode size,	964	* write-back, thus making sure the on-flash inode contains current inode size,
965	* and then keeps writing pages back.	965	* and then keeps writing pages back.


diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c index a2d334eccbca..64b5f3a309f5 100644 --- a/fs/ubifs/journal.c +++ b/fs/ubifs/journal.c
@@ -1365,7 +1365,7 @@ out_ro:
1365	* @host: host inode	1365	* @host: host inode
1366	*	1366	*
1367	* This function writes the updated version of an extended attribute inode and	1367	* This function writes the updated version of an extended attribute inode and
1368	* the host inode tho the journal (to the base head). The host inode is written	1368	* the host inode to the journal (to the base head). The host inode is written
1369	* after the extended attribute inode in order to guarantee that the extended	1369	* after the extended attribute inode in order to guarantee that the extended
1370	* attribute will be flushed when the inode is synchronized by 'fsync()' and	1370	* attribute will be flushed when the inode is synchronized by 'fsync()' and
1371	* consequently, the write-buffer is synchronized. This function returns zero	1371	* consequently, the write-buffer is synchronized. This function returns zero


diff --git a/fs/ubifs/log.c b/fs/ubifs/log.c index 1004261dc864..56e33772a1ee 100644 --- a/fs/ubifs/log.c +++ b/fs/ubifs/log.c
@@ -239,7 +239,7 @@ int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs)
239	}	239	}
240		240
241	/*	241	/*
242	* Make sure the the amount of space in buds will not exceed	242	* Make sure the amount of space in buds will not exceed the
243	* 'c->max_bud_bytes' limit, because we want to guarantee mount time	243	* 'c->max_bud_bytes' limit, because we want to guarantee mount time
244	* limits.	244	* limits.
245	*	245	*


diff --git a/fs/ubifs/lpt_commit.c b/fs/ubifs/lpt_commit.c index 9d77f68b2f8e..8cbfb8248025 100644 --- a/fs/ubifs/lpt_commit.c +++ b/fs/ubifs/lpt_commit.c
@@ -1,4 +1,4 @@
1	/*	1	/*
2	* This file is part of UBIFS.	2	* This file is part of UBIFS.
3	*	3	*
4	* Copyright (C) 2006-2008 Nokia Corporation.	4	* Copyright (C) 2006-2008 Nokia Corporation.


diff --git a/fs/ubifs/replay.c b/fs/ubifs/replay.c index ce42a7b0ca5a..11cc80125a49 100644 --- a/fs/ubifs/replay.c +++ b/fs/ubifs/replay.c
@@ -143,7 +143,7 @@ static int set_bud_lprops(struct ubifs_info c, struct replay_entry r)
143	dirty -= c->leb_size - lp->free;	143	dirty -= c->leb_size - lp->free;
144	/*	144	/*
145	* If the replay order was perfect the dirty space would now be	145	* If the replay order was perfect the dirty space would now be
146	* zero. The order is not perfect because the the journal heads	146	* zero. The order is not perfect because the journal heads
147	* race with each other. This is not a problem but is does mean	147	* race with each other. This is not a problem but is does mean
148	* that the dirty space may temporarily exceed c->leb_size	148	* that the dirty space may temporarily exceed c->leb_size
149	* during the replay.	149	* during the replay.


diff --git a/fs/ubifs/tnc.c b/fs/ubifs/tnc.c index fa28a84c6a1b..f249f7b0d656 100644 --- a/fs/ubifs/tnc.c +++ b/fs/ubifs/tnc.c
@@ -1252,7 +1252,7 @@ int ubifs_lookup_level0(struct ubifs_info c, const union ubifs_key key,
1252	* splitting in the middle of the colliding sequence. Also, when	1252	* splitting in the middle of the colliding sequence. Also, when
1253	* removing the leftmost key, we would have to correct the key of the	1253	* removing the leftmost key, we would have to correct the key of the
1254	* parent node, which would introduce additional complications. Namely,	1254	* parent node, which would introduce additional complications. Namely,
1255	* if we changed the the leftmost key of the parent znode, the garbage	1255	* if we changed the leftmost key of the parent znode, the garbage
1256	* collector would be unable to find it (GC is doing this when GC'ing	1256	* collector would be unable to find it (GC is doing this when GC'ing
1257	* indexing LEBs). Although we already have an additional RB-tree where	1257	* indexing LEBs). Although we already have an additional RB-tree where
1258	* we save such changed znodes (see 'ins_clr_old_idx_znode()') until	1258	* we save such changed znodes (see 'ins_clr_old_idx_znode()') until

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425

554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618

/* * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README */ #include <linux/time.h> #include <linux/reiserfs_fs.h> #include <linux/reiserfs_acl.h> #include <linux/reiserfs_xattr.h> #include <asm/uaccess.h> #include <linux/pagemap.h> #include <linux/swap.h> #include <linux/writeback.h> #include <linux/blkdev.h> #include <linux/buffer_head.h> #include <linux/quotaops.h> /* ** We pack the tails of files on file close, not at the time they are written. ** This implies an unnecessary copy of the tail and an unnecessary indirect item ** insertion/balancing, for files that are written in one write. ** It avoids unnecessary tail packings (balances) for files that are written in ** multiple writes and are small enough to have tails. ** ** file_release is called by the VFS layer when the file is closed. If ** this is the last open file descriptor, and the file ** small enough to have a tail, and the tail is currently in an ** unformatted node, the tail is converted back into a direct item. ** ** We use reiserfs_truncate_file to pack the tail, since it already has ** all the conditions coded. */ static int reiserfs_file_release(struct inode *inode, struct file *filp) { struct reiserfs_transaction_handle th; int err; int jbegin_failure = 0; BUG_ON(!S_ISREG(inode->i_mode)); /* fast out for when nothing needs to be done */ if ((atomic_read(&inode->i_count) > 1 || !(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) || !tail_has_to_be_packed(inode)) && REISERFS_I(inode)->i_prealloc_count <= 0) { return 0; } mutex_lock(&inode->i_mutex); mutex_lock(&(REISERFS_I(inode)->i_mmap)); if (REISERFS_I(inode)->i_flags & i_ever_mapped) REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask; reiserfs_write_lock(inode->i_sb); /* freeing preallocation only involves relogging blocks that * are already in the current transaction. preallocation gets * freed at the end of each transaction, so it is impossible for * us to log any additional blocks (including quota blocks) */ err = journal_begin(&th, inode->i_sb, 1); if (err) { /* uh oh, we can't allow the inode to go away while there * is still preallocation blocks pending. Try to join the * aborted transaction */ jbegin_failure = err; err = journal_join_abort(&th, inode->i_sb, 1); if (err) { /* hmpf, our choices here aren't good. We can pin the inode * which will disallow unmount from every happening, we can * do nothing, which will corrupt random memory on unmount, * or we can forcibly remove the file from the preallocation * list, which will leak blocks on disk. Lets pin the inode * and let the admin know what is going on. */ igrab(inode); reiserfs_warning(inode->i_sb, "pinning inode %lu because the " "preallocation can't be freed", inode->i_ino); goto out; } } reiserfs_update_inode_transaction(inode); #ifdef REISERFS_PREALLOCATE reiserfs_discard_prealloc(&th, inode); #endif err = journal_end(&th, inode->i_sb, 1); /* copy back the error code from journal_begin */ if (!err) err = jbegin_failure; if (!err && atomic_read(&inode->i_count) <= 1 && (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) && tail_has_to_be_packed(inode)) { /* if regular file is released by last holder and it has been appended (we append by unformatted node only) or its direct item(s) had to be converted, then it may have to be indirect2direct converted */ err = reiserfs_truncate_file(inode, 0); } out: mutex_unlock(&(REISERFS_I(inode)->i_mmap)); mutex_unlock(&inode->i_mutex); reiserfs_write_unlock(inode->i_sb); return err; } static int reiserfs_file_mmap(struct file *file, struct vm_area_struct *vma) { struct inode *inode; inode = file->f_path.dentry->d_inode; mutex_lock(&(REISERFS_I(inode)->i_mmap)); REISERFS_I(inode)->i_flags |= i_ever_mapped; mutex_unlock(&(REISERFS_I(inode)->i_mmap)); return generic_file_mmap(file, vma); } static void reiserfs_vfs_truncate_file(struct inode *inode) { reiserfs_truncate_file(inode, 1); } /* Sync a reiserfs file. */ /* * FIXME: sync_mapping_buffers() never has anything to sync. Can * be removed... */ static int reiserfs_sync_file(struct file *p_s_filp, struct dentry *p_s_dentry, int datasync) { struct inode *p_s_inode = p_s_dentry->d_inode; int n_err; int barrier_done; BUG_ON(!S_ISREG(p_s_inode->i_mode)); n_err = sync_mapping_buffers(p_s_inode->i_mapping); reiserfs_write_lock(p_s_inode->i_sb); barrier_done = reiserfs_commit_for_inode(p_s_inode); reiserfs_write_unlock(p_s_inode->i_sb); if (barrier_done != 1 && reiserfs_barrier_flush(p_s_inode->i_sb)) blkdev_issue_flush(p_s_inode->i_sb->s_bdev, NULL); if (barrier_done < 0) return barrier_done; return (n_err < 0) ? -EIO : 0; } /* I really do not want to play with memory shortage right now, so to simplify the code, we are not going to write more than this much pages at a time. This still should considerably improve performance compared to 4k at a time case. This is 32 pages of 4k size. */ #define REISERFS_WRITE_PAGES_AT_A_TIME (128 * 1024) / PAGE_CACHE_SIZE /* Allocates blocks for a file to fulfil write request. Maps all unmapped but prepared pages from the list. Updates metadata with newly allocated blocknumbers as needed */ static int reiserfs_allocate_blocks_for_region(struct reiserfs_transaction_handle *th, struct inode *inode, /* Inode we work with */ loff_t pos, /* Writing position */ int num_pages, /* number of pages write going to touch */ int write_bytes, /* amount of bytes to write */ struct page **prepared_pages, /* array of prepared pages */ int blocks_to_allocate /* Amount of blocks we need to allocate to fit the data into file */ ) { struct cpu_key key; // cpu key of item that we are going to deal with struct item_head *ih; // pointer to item head that we are going to deal with struct buffer_head *bh; // Buffer head that contains items that we are going to deal with __le32 *item; // pointer to item we are going to deal with INITIALIZE_PATH(path); // path to item, that we are going to deal with. b_blocknr_t *allocated_blocks; // Pointer to a place where allocated blocknumbers would be stored. reiserfs_blocknr_hint_t hint; // hint structure for block allocator. size_t res; // return value of various functions that we call. int curr_block; // current block used to keep track of unmapped blocks. int i; // loop counter int itempos; // position in item unsigned int from = (pos & (PAGE_CACHE_SIZE - 1)); // writing position in // first page unsigned int to = ((pos + write_bytes - 1) & (PAGE_CACHE_SIZE - 1)) + 1; /* last modified byte offset in last page */ __u64 hole_size; // amount of blocks for a file hole, if it needed to be created. int modifying_this_item = 0; // Flag for items traversal code to keep track // of the fact that we already prepared // current block for journal int will_prealloc = 0; RFALSE(!blocks_to_allocate, "green-9004: tried to allocate zero blocks?"); /* only preallocate if this is a small write */ if (REISERFS_I(inode)->i_prealloc_count || (!(write_bytes & (inode->i_sb->s_blocksize - 1)) && blocks_to_allocate < REISERFS_SB(inode->i_sb)->s_alloc_options.preallocsize)) will_prealloc = REISERFS_SB(inode->i_sb)->s_alloc_options.preallocsize; allocated_blocks = kmalloc((blocks_to_allocate + will_prealloc) * sizeof(b_blocknr_t), GFP_NOFS); if (!allocated_blocks) return -ENOMEM; /* First we compose a key to point at the writing position, we want to do that outside of any locking region. */ make_cpu_key(&key, inode, pos + 1, TYPE_ANY, 3 /*key length */ ); /* If we came here, it means we absolutely need to open a transaction, since we need to allocate some blocks */ reiserfs_write_lock(inode->i_sb); // Journaling stuff and we need that. res = journal_begin(th, inode->i_sb, JOURNAL_PER_BALANCE_CNT * 3 + 1 + 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb)); // Wish I know if this number enough if (res) goto error_exit; reiserfs_update_inode_transaction(inode); /* Look for the in-tree position of our write, need path for block allocator */ res = search_for_position_by_key(inode->i_sb, &key, &path); if (res == IO_ERROR) { res = -EIO; goto error_exit; } /* Allocate blocks */ /* First fill in "hint" structure for block allocator */ hint.th = th; // transaction handle. hint.path = &path; // Path, so that block allocator can determine packing locality or whatever it needs to determine. hint.inode = inode; // Inode is needed by block allocator too. hint.search_start = 0; // We have no hint on where to search free blocks for block allocator. hint.key = key.on_disk_key; // on disk key of file. hint.block = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); // Number of disk blocks this file occupies already. hint.formatted_node = 0; // We are allocating blocks for unformatted node. hint.preallocate = will_prealloc; /* Call block allocator to allocate blocks */ res = reiserfs_allocate_blocknrs(&hint, allocated_blocks, blocks_to_allocate, blocks_to_allocate); if (res != CARRY_ON) { if (res == NO_DISK_SPACE) { /* We flush the transaction in case of no space. This way some blocks might become free */ SB_JOURNAL(inode->i_sb)->j_must_wait = 1; res = restart_transaction(th, inode, &path); if (res) goto error_exit; /* We might have scheduled, so search again */ res = search_for_position_by_key(inode->i_sb, &key, &path); if (res == IO_ERROR) { res = -EIO; goto error_exit; } /* update changed info for hint structure. */ res = reiserfs_allocate_blocknrs(&hint, allocated_blocks, blocks_to_allocate, blocks_to_allocate); if (res != CARRY_ON) { res = res == QUOTA_EXCEEDED ? -EDQUOT : -ENOSPC; pathrelse(&path); goto error_exit; } } else { res = res == QUOTA_EXCEEDED ? -EDQUOT : -ENOSPC; pathrelse(&path); goto error_exit; } } #ifdef __BIG_ENDIAN // Too bad, I have not found any way to convert a given region from // cpu format to little endian format { int i; for (i = 0; i < blocks_to_allocate; i++) allocated_blocks[i] = cpu_to_le32(allocated_blocks[i]); } #endif /* Blocks allocating well might have scheduled and tree might have changed, let's search the tree again */ /* find where in the tree our write should go */ res = search_for_position_by_key(inode->i_sb, &key, &path); if (res == IO_ERROR) { res = -EIO; goto error_exit_free_blocks; } bh = get_last_bh(&path); // Get a bufferhead for last element in path. ih = get_ih(&path); // Get a pointer to last item head in path. item = get_item(&path); // Get a pointer to last item in path /* Let's see what we have found */ if (res != POSITION_FOUND) { /* position not found, this means that we might need to append file with holes first */ // Since we are writing past the file's end, we need to find out if // there is a hole that needs to be inserted before our writing // position, and how many blocks it is going to cover (we need to // populate pointers to file blocks representing the hole with zeros) { int item_offset = 1; /* * if ih is stat data, its offset is 0 and we don't want to * add 1 to pos in the hole_size calculation */ if (is_statdata_le_ih(ih)) item_offset = 0; hole_size = (pos + item_offset - (le_key_k_offset (get_inode_item_key_version(inode), &(ih->ih_key)) + op_bytes_number(ih, inode-> i_sb-> s_blocksize))) >> inode->i_sb->s_blocksize_bits; } if (hole_size > 0) { int to_paste = min_t(__u64, hole_size, MAX_ITEM_LEN(inode->i_sb->s_blocksize) / UNFM_P_SIZE); // How much data to insert first time. /* area filled with zeroes, to supply as list of zero blocknumbers We allocate it outside of loop just in case loop would spin for several iterations. */ char *zeros = kzalloc(to_paste * UNFM_P_SIZE, GFP_ATOMIC); // We cannot insert more than MAX_ITEM_LEN bytes anyway. if (!zeros) { res = -ENOMEM; goto error_exit_free_blocks; } do { to_paste = min_t(__u64, hole_size, MAX_ITEM_LEN(inode->i_sb-> s_blocksize) / UNFM_P_SIZE); if (is_indirect_le_ih(ih)) { /* Ok, there is existing indirect item already. Need to append it */ /* Calculate position past inserted item */ make_cpu_key(&key, inode, le_key_k_offset (get_inode_item_key_version (inode), &(ih->ih_key)) + op_bytes_number(ih, inode-> i_sb-> s_blocksize), TYPE_INDIRECT, 3); res = reiserfs_paste_into_item(th, &path, &key, inode, (char *) zeros, UNFM_P_SIZE * to_paste); if (res) { kfree(zeros); goto error_exit_free_blocks; } } else if (is_statdata_le_ih(ih)) { /* No existing item, create it */ /* item head for new item */ struct item_head ins_ih; /* create a key for our new item */ make_cpu_key(&key, inode, 1, TYPE_INDIRECT, 3); /* Create new item head for our new item */ make_le_item_head(&ins_ih, &key, key.version, 1, TYPE_INDIRECT, to_paste * UNFM_P_SIZE, 0 /* free space */ ); /* Find where such item should live in the tree */ res = search_item(inode->i_sb, &key, &path); if (res != ITEM_NOT_FOUND) { /* item should not exist, otherwise we have error */ if (res != -ENOSPC) { reiserfs_warning(inode-> i_sb, "green-9008: search_by_key (%K) returned %d", &key, res); } res = -EIO; kfree(zeros); goto error_exit_free_blocks; } res = reiserfs_insert_item(th, &path, &key, &ins_ih, inode, (char *)zeros); } else { reiserfs_panic(inode->i_sb, "green-9011: Unexpected key type %K\n", &key); } if (res) { kfree(zeros); goto error_exit_free_blocks; } /* Now we want to check if transaction is too full, and if it is we restart it. This will also free the path. */ if (journal_transaction_should_end (th, th->t_blocks_allocated)) { inode->i_size = cpu_key_k_offset(&key) + (to_paste << inode->i_blkbits); res = restart_transaction(th, inode, &path); if (res) { pathrelse(&path); kfree(zeros); goto error_exit; } } /* Well, need to recalculate path and stuff */ set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + (to_paste << inode-> i_blkbits)); res = search_for_position_by_key(inode->i_sb, &key, &path); if (res == IO_ERROR) { res = -EIO; kfree(zeros); goto error_exit_free_blocks; } bh = get_last_bh(&path); ih = get_ih(&path); item = get_item(&path); hole_size -= to_paste; } while (hole_size); kfree(zeros); } } // Go through existing indirect items first // replace all zeroes with blocknumbers from list // Note that if no corresponding item was found, by previous search, // it means there are no existing in-tree representation for file area // we are going to overwrite, so there is nothing to scan through for holes. for (curr_block = 0, itempos = path.pos_in_item; curr_block < blocks_to_allocate && res == POSITION_FOUND;) { retry: if (itempos >= ih_item_len(ih) / UNFM_P_SIZE) { /* We run out of data in this indirect item, let's look for another one. */ /* First if we are already modifying current item, log it */ if (modifying_this_item) { journal_mark_dirty(th, inode->i_sb, bh); modifying_this_item = 0; } /* Then set the key to look for a new indirect item (offset of old item is added to old item length */ set_cpu_key_k_offset(&key, le_key_k_offset (get_inode_item_key_version(inode), &(ih->ih_key)) + op_bytes_number(ih, inode->i_sb-> s_blocksize)); /* Search ofor position of new key in the tree. */ res = search_for_position_by_key(inode->i_sb, &key, &path); if (res == IO_ERROR) { res = -EIO; goto error_exit_free_blocks; } bh = get_last_bh(&path); ih = get_ih(&path); item = get_item(&path); itempos = path.pos_in_item; continue; // loop to check all kinds of conditions and so on. } /* Ok, we have correct position in item now, so let's see if it is representing file hole (blocknumber is zero) and fill it if needed */ if (!item[itempos]) { /* Ok, a hole. Now we need to check if we already prepared this block to be journaled */ while (!modifying_this_item) { // loop until succeed /* Well, this item is not journaled yet, so we must prepare it for journal first, before we can change it */ struct item_head tmp_ih; // We copy item head of found item, // here to detect if fs changed under // us while we were preparing for // journal. int fs_gen; // We store fs generation here to find if someone // changes fs under our feet copy_item_head(&tmp_ih, ih); // Remember itemhead fs_gen = get_generation(inode->i_sb); // remember fs generation reiserfs_prepare_for_journal(inode->i_sb, bh, 1); // Prepare a buffer within which indirect item is stored for changing. if (fs_changed(fs_gen, inode->i_sb) && item_moved(&tmp_ih, &path)) { // Sigh, fs was changed under us, we need to look for new // location of item we are working with /* unmark prepaerd area as journaled and search for it's new position */ reiserfs_restore_prepared_buffer(inode-> i_sb, bh); res = search_for_position_by_key(inode-> i_sb, &key, &path); if (res == IO_ERROR) { res = -EIO; goto error_exit_free_blocks; } bh = get_last_bh(&path); ih = get_ih(&path); item = get_item(&path); itempos = path.pos_in_item; goto retry; } modifying_this_item = 1; } item[itempos] = allocated_blocks[curr_block]; // Assign new block curr_block++; } itempos++; } if (modifying_this_item) { // We need to log last-accessed block, if it // was modified, but not logged yet. journal_mark_dirty(th, inode->i_sb, bh); } if (curr_block < blocks_to_allocate) { // Oh, well need to append to indirect item, or to create indirect item // if there weren't any if (is_indirect_le_ih(ih)) { // Existing indirect item - append. First calculate key for append // position. We do not need to recalculate path as it should // already point to correct place. make_cpu_key(&key, inode, le_key_k_offset(get_inode_item_key_version (inode), &(ih->ih_key)) + op_bytes_number(ih, inode->i_sb->s_blocksize), TYPE_INDIRECT, 3); res = reiserfs_paste_into_item(th, &path, &key, inode, (char *)(allocated_blocks + curr_block), UNFM_P_SIZE * (blocks_to_allocate - curr_block)); if (res) { goto error_exit_free_blocks; } } else if (is_statdata_le_ih(ih)) { // Last found item was statdata. That means we need to create indirect item. struct item_head ins_ih; /* itemhead for new item */ /* create a key for our new item */ make_cpu_key(&key, inode, 1, TYPE_INDIRECT, 3); // Position one, // because that's // where first // indirect item


context:
space:
mode: