[net-next-2.6.git] / fs / reiserfs / tail_conversion.c

/*
 * Copyright 1999 Hans Reiser, see reiserfs/README for licensing and copyright details
 */

#include <linux/time.h>
#include <linux/pagemap.h>
#include <linux/buffer_head.h>
#include <linux/reiserfs_fs.h>

/* access to tail : when one is going to read tail it must make sure, that is not running.
 direct2indirect and indirect2direct can not run concurrently */

/* Converts direct items to an unformatted node. Panics if file has no
   tail. -ENOSPC if no disk space for conversion */
/* path points to first direct item of the file regarless of how many of
   them are there */
int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
		    struct treepath *path, struct buffer_head *unbh,
		    loff_t tail_offset)
{
	struct super_block *sb = inode->i_sb;
	struct buffer_head *up_to_date_bh;
	struct item_head *p_le_ih = PATH_PITEM_HEAD(path);
	unsigned long total_tail = 0;
	struct cpu_key end_key;	/* Key to search for the last byte of the
				   converted item. */
	struct item_head ind_ih;	/* new indirect item to be inserted or
					   key of unfm pointer to be pasted */
	int blk_size, retval;	/* returned value for reiserfs_insert_item and clones */
	unp_t unfm_ptr;		/* Handle on an unformatted node
				   that will be inserted in the
				   tree. */

	BUG_ON(!th->t_trans_id);

	REISERFS_SB(sb)->s_direct2indirect++;

	blk_size = sb->s_blocksize;

	/* and key to search for append or insert pointer to the new
	   unformatted node. */
	copy_item_head(&ind_ih, p_le_ih);
	set_le_ih_k_offset(&ind_ih, tail_offset);
	set_le_ih_k_type(&ind_ih, TYPE_INDIRECT);

	/* Set the key to search for the place for new unfm pointer */
	make_cpu_key(&end_key, inode, tail_offset, TYPE_INDIRECT, 4);

	/* FIXME: we could avoid this */
	if (search_for_position_by_key(sb, &end_key, path) == POSITION_FOUND) {
		reiserfs_error(sb, "PAP-14030",
			       "pasted or inserted byte exists in "
			       "the tree %K. Use fsck to repair.", &end_key);
		pathrelse(path);
		return -EIO;
	}

	p_le_ih = PATH_PITEM_HEAD(path);

	unfm_ptr = cpu_to_le32(unbh->b_blocknr);

	if (is_statdata_le_ih(p_le_ih)) {
		/* Insert new indirect item. */
		set_ih_free_space(&ind_ih, 0);	/* delete at nearest future */
		put_ih_item_len(&ind_ih, UNFM_P_SIZE);
		PATH_LAST_POSITION(path)++;
		retval =
		    reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
					 (char *)&unfm_ptr);
	} else {
		/* Paste into last indirect item of an object. */
		retval = reiserfs_paste_into_item(th, path, &end_key, inode,
						    (char *)&unfm_ptr,
						    UNFM_P_SIZE);
	}
	if (retval) {
		return retval;
	}
	// note: from here there are two keys which have matching first
	// three key components. They only differ by the fourth one.

	/* Set the key to search for the direct items of the file */
	make_cpu_key(&end_key, inode, max_reiserfs_offset(inode), TYPE_DIRECT,
		     4);

	/* Move bytes from the direct items to the new unformatted node
	   and delete them. */
	while (1) {
		int tail_size;

		/* end_key.k_offset is set so, that we will always have found
		   last item of the file */
		if (search_for_position_by_key(sb, &end_key, path) ==
		    POSITION_FOUND)
			reiserfs_panic(sb, "PAP-14050",
				       "direct item (%K) not found", &end_key);
		p_le_ih = PATH_PITEM_HEAD(path);
		RFALSE(!is_direct_le_ih(p_le_ih),
		       "vs-14055: direct item expected(%K), found %h",
		       &end_key, p_le_ih);
		tail_size = (le_ih_k_offset(p_le_ih) & (blk_size - 1))
		    + ih_item_len(p_le_ih) - 1;

		/* we only send the unbh pointer if the buffer is not up to date.
		 ** this avoids overwriting good data from writepage() with old data
		 ** from the disk or buffer cache
		 ** Special case: unbh->b_page will be NULL if we are coming through
		 ** DIRECT_IO handler here.
		 */
		if (!unbh->b_page || buffer_uptodate(unbh)
		    || PageUptodate(unbh->b_page)) {
			up_to_date_bh = NULL;
		} else {
			up_to_date_bh = unbh;
		}
		retval = reiserfs_delete_item(th, path, &end_key, inode,
						up_to_date_bh);

		total_tail += retval;
		if (tail_size == retval)
			// done: file does not have direct items anymore
			break;

	}
	/* if we've copied bytes from disk into the page, we need to zero
	 ** out the unused part of the block (it was not up to date before)
	 */
	if (up_to_date_bh) {
		unsigned pgoff =
		    (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
		char *kaddr = kmap_atomic(up_to_date_bh->b_page, KM_USER0);
		memset(kaddr + pgoff, 0, blk_size - total_tail);
		kunmap_atomic(kaddr, KM_USER0);
	}

	REISERFS_I(inode)->i_first_direct_byte = U32_MAX;

	return 0;
}

/* stolen from fs/buffer.c */
void reiserfs_unmap_buffer(struct buffer_head *bh)
{
	lock_buffer(bh);
	if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {
		BUG();
	}
	clear_buffer_dirty(bh);
	/* Remove the buffer from whatever list it belongs to. We are mostly
	   interested in removing it from per-sb j_dirty_buffers list, to avoid
	   BUG() on attempt to write not mapped buffer */
	if ((!list_empty(&bh->b_assoc_buffers) || bh->b_private) && bh->b_page) {
		struct inode *inode = bh->b_page->mapping->host;
		struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
		spin_lock(&j->j_dirty_buffers_lock);
		list_del_init(&bh->b_assoc_buffers);
		reiserfs_free_jh(bh);
		spin_unlock(&j->j_dirty_buffers_lock);
	}
	clear_buffer_mapped(bh);
	clear_buffer_req(bh);
	clear_buffer_new(bh);
	bh->b_bdev = NULL;
	unlock_buffer(bh);
}

/* this first locks inode (neither reads nor sync are permitted),
   reads tail through page cache, insert direct item. When direct item
   inserted successfully inode is left locked. Return value is always
   what we expect from it (number of cut bytes). But when tail remains
   in the unformatted node, we set mode to SKIP_BALANCING and unlock
   inode */
int indirect2direct(struct reiserfs_transaction_handle *th,
		    struct inode *inode, struct page *page,
		    struct treepath *path,	/* path to the indirect item. */
		    const struct cpu_key *item_key,	/* Key to look for
							 * unformatted node
							 * pointer to be cut. */
		    loff_t n_new_file_size,	/* New file size. */
		    char *mode)
{
	struct super_block *sb = inode->i_sb;
	struct item_head s_ih;
	unsigned long block_size = sb->s_blocksize;
	char *tail;
	int tail_len, round_tail_len;
	loff_t pos, pos1;	/* position of first byte of the tail */
	struct cpu_key key;

	BUG_ON(!th->t_trans_id);

	REISERFS_SB(sb)->s_indirect2direct++;

	*mode = M_SKIP_BALANCING;

	/* store item head path points to. */
	copy_item_head(&s_ih, PATH_PITEM_HEAD(path));

	tail_len = (n_new_file_size & (block_size - 1));
	if (get_inode_sd_version(inode) == STAT_DATA_V2)
		round_tail_len = ROUND_UP(tail_len);
	else
		round_tail_len = tail_len;

	pos =
	    le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
					 1) * sb->s_blocksize;
	pos1 = pos;

	// we are protected by i_mutex. The tail can not disapper, not
	// append can be done either
	// we are in truncate or packing tail in file_release

	tail = (char *)kmap(page);	/* this can schedule */

	if (path_changed(&s_ih, path)) {
		/* re-search indirect item */
		if (search_for_position_by_key(sb, item_key, path)
		    == POSITION_NOT_FOUND)
			reiserfs_panic(sb, "PAP-5520",
				       "item to be converted %K does not exist",
				       item_key);
		copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
#ifdef CONFIG_REISERFS_CHECK
		pos = le_ih_k_offset(&s_ih) - 1 +
		    (ih_item_len(&s_ih) / UNFM_P_SIZE -
		     1) * sb->s_blocksize;
		if (pos != pos1)
			reiserfs_panic(sb, "vs-5530", "tail position "
				       "changed while we were reading it");
#endif
	}

	/* Set direct item header to insert. */
	make_le_item_head(&s_ih, NULL, get_inode_item_key_version(inode),
			  pos1 + 1, TYPE_DIRECT, round_tail_len,
			  0xffff /*ih_free_space */ );

	/* we want a pointer to the first byte of the tail in the page.
	 ** the page was locked and this part of the page was up to date when
	 ** indirect2direct was called, so we know the bytes are still valid
	 */
	tail = tail + (pos & (PAGE_CACHE_SIZE - 1));

	PATH_LAST_POSITION(path)++;

	key = *item_key;
	set_cpu_key_k_type(&key, TYPE_DIRECT);
	key.key_length = 4;
	/* Insert tail as new direct item in the tree */
	if (reiserfs_insert_item(th, path, &key, &s_ih, inode,
				 tail ? tail : NULL) < 0) {
		/* No disk memory. So we can not convert last unformatted node
		   to the direct item.  In this case we used to adjust
		   indirect items's ih_free_space. Now ih_free_space is not
		   used, it would be ideal to write zeros to corresponding
		   unformatted node. For now i_size is considered as guard for
		   going out of file size */
		kunmap(page);
		return block_size - round_tail_len;
	}
	kunmap(page);

	/* make sure to get the i_blocks changes from reiserfs_insert_item */
	reiserfs_update_sd(th, inode);

	// note: we have now the same as in above direct2indirect
	// conversion: there are two keys which have matching first three
	// key components. They only differ by the fouhth one.

	/* We have inserted new direct item and must remove last
	   unformatted node. */
	*mode = M_CUT;

	/* we store position of first direct item in the in-core inode */
	/* mark_file_with_tail (inode, pos1 + 1); */
	REISERFS_I(inode)->i_first_direct_byte = pos1 + 1;

	return block_size - round_tail_len;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright 1999 Hans Reiser, see reiserfs/README for licensing and copyright details
	3	*/
	4
1da177e4 LT	5	#include <linux/time.h>
	6	#include <linux/pagemap.h>
	7	#include <linux/buffer_head.h>
	8	#include <linux/reiserfs_fs.h>
	9
	10	/* access to tail : when one is going to read tail it must make sure, that is not running.
	11	direct2indirect and indirect2direct can not run concurrently */
	12
1da177e4 LT	13	/* Converts direct items to an unformatted node. Panics if file has no
	14	tail. -ENOSPC if no disk space for conversion */
	15	/* path points to first direct item of the file regarless of how many of
	16	them are there */
bd4c625c	17	int direct2indirect(struct reiserfs_transaction_handle th, struct inode inode,
fec6d055	18	struct treepath path, struct buffer_head unbh,
bd4c625c	19	loff_t tail_offset)
1da177e4	20	{
bd4c625c LT	21	struct super_block *sb = inode->i_sb;
	22	struct buffer_head *up_to_date_bh;
	23	struct item_head *p_le_ih = PATH_PITEM_HEAD(path);
	24	unsigned long total_tail = 0;
	25	struct cpu_key end_key; /* Key to search for the last byte of the
	26	converted item. */
	27	struct item_head ind_ih; /* new indirect item to be inserted or
	28	key of unfm pointer to be pasted */
ee93961b	29	int blk_size, retval; /* returned value for reiserfs_insert_item and clones */
bd4c625c LT	30	unp_t unfm_ptr; /* Handle on an unformatted node
	31	that will be inserted in the
	32	tree. */
	33
	34	BUG_ON(!th->t_trans_id);
	35
	36	REISERFS_SB(sb)->s_direct2indirect++;
	37
ee93961b	38	blk_size = sb->s_blocksize;
bd4c625c LT	39
	40	/* and key to search for append or insert pointer to the new
	41	unformatted node. */
	42	copy_item_head(&ind_ih, p_le_ih);
	43	set_le_ih_k_offset(&ind_ih, tail_offset);
	44	set_le_ih_k_type(&ind_ih, TYPE_INDIRECT);
	45
	46	/* Set the key to search for the place for new unfm pointer */
	47	make_cpu_key(&end_key, inode, tail_offset, TYPE_INDIRECT, 4);
	48
0222e657	49	/* FIXME: we could avoid this */
bd4c625c	50	if (search_for_position_by_key(sb, &end_key, path) == POSITION_FOUND) {
0030b645 JM	51	reiserfs_error(sb, "PAP-14030",
	52	"pasted or inserted byte exists in "
	53	"the tree %K. Use fsck to repair.", &end_key);
bd4c625c LT	54	pathrelse(path);
	55	return -EIO;
	56	}
	57
	58	p_le_ih = PATH_PITEM_HEAD(path);
	59
	60	unfm_ptr = cpu_to_le32(unbh->b_blocknr);
	61
	62	if (is_statdata_le_ih(p_le_ih)) {
	63	/* Insert new indirect item. */
	64	set_ih_free_space(&ind_ih, 0); /* delete at nearest future */
	65	put_ih_item_len(&ind_ih, UNFM_P_SIZE);
	66	PATH_LAST_POSITION(path)++;
ee93961b	67	retval =
bd4c625c	68	reiserfs_insert_item(th, path, &end_key, &ind_ih, inode,
1da177e4	69	(char *)&unfm_ptr);
1da177e4	70	} else {
bd4c625c	71	/* Paste into last indirect item of an object. */
ee93961b	72	retval = reiserfs_paste_into_item(th, path, &end_key, inode,
bd4c625c LT	73	(char *)&unfm_ptr,
bd4c625c LT	74	UNFM_P_SIZE);
1da177e4	75	}
ee93961b JM	76	if (retval) {
ee93961b JM	77	return retval;
bd4c625c LT	78	}
	79	// note: from here there are two keys which have matching first
	80	// three key components. They only differ by the fourth one.
	81
	82	/* Set the key to search for the direct items of the file */
	83	make_cpu_key(&end_key, inode, max_reiserfs_offset(inode), TYPE_DIRECT,
	84	4);
	85
	86	/* Move bytes from the direct items to the new unformatted node
	87	and delete them. */
	88	while (1) {
	89	int tail_size;
	90
	91	/* end_key.k_offset is set so, that we will always have found
	92	last item of the file */
	93	if (search_for_position_by_key(sb, &end_key, path) ==
	94	POSITION_FOUND)
c3a9c210	95	reiserfs_panic(sb, "PAP-14050",
bd4c625c LT	96	"direct item (%K) not found", &end_key);
	97	p_le_ih = PATH_PITEM_HEAD(path);
	98	RFALSE(!is_direct_le_ih(p_le_ih),
	99	"vs-14055: direct item expected(%K), found %h",
	100	&end_key, p_le_ih);
ee93961b	101	tail_size = (le_ih_k_offset(p_le_ih) & (blk_size - 1))
bd4c625c LT	102	+ ih_item_len(p_le_ih) - 1;
	103
	104	/* we only send the unbh pointer if the buffer is not up to date.
	105	** this avoids overwriting good data from writepage() with old data
	106	** from the disk or buffer cache
	107	** Special case: unbh->b_page will be NULL if we are coming through
	108	** DIRECT_IO handler here.
	109	*/
	110	if (!unbh->b_page \|\| buffer_uptodate(unbh)
	111	\|\| PageUptodate(unbh->b_page)) {
	112	up_to_date_bh = NULL;
	113	} else {
	114	up_to_date_bh = unbh;
	115	}
ee93961b	116	retval = reiserfs_delete_item(th, path, &end_key, inode,
bd4c625c LT	117	up_to_date_bh);
bd4c625c LT	118
ee93961b JM	119	total_tail += retval;
ee93961b JM	120	if (tail_size == retval)
bd4c625c LT	121	// done: file does not have direct items anymore
bd4c625c LT	122	break;
1da177e4	123
bd4c625c LT	124	}
	125	/* if we've copied bytes from disk into the page, we need to zero
	126	** out the unused part of the block (it was not up to date before)
	127	*/
	128	if (up_to_date_bh) {
	129	unsigned pgoff =
	130	(tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1);
	131	char *kaddr = kmap_atomic(up_to_date_bh->b_page, KM_USER0);
ee93961b	132	memset(kaddr + pgoff, 0, blk_size - total_tail);
bd4c625c LT	133	kunmap_atomic(kaddr, KM_USER0);
	134	}
	135
	136	REISERFS_I(inode)->i_first_direct_byte = U32_MAX;
	137
	138	return 0;
	139	}
1da177e4 LT	140
1da177e4 LT	141	/* stolen from fs/buffer.c */
bd4c625c LT	142	void reiserfs_unmap_buffer(struct buffer_head *bh)
	143	{
	144	lock_buffer(bh);
	145	if (buffer_journaled(bh) \|\| buffer_journal_dirty(bh)) {
	146	BUG();
	147	}
	148	clear_buffer_dirty(bh);
	149	/* Remove the buffer from whatever list it belongs to. We are mostly
	150	interested in removing it from per-sb j_dirty_buffers list, to avoid
	151	BUG() on attempt to write not mapped buffer */
	152	if ((!list_empty(&bh->b_assoc_buffers) \|\| bh->b_private) && bh->b_page) {
	153	struct inode *inode = bh->b_page->mapping->host;
	154	struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);
	155	spin_lock(&j->j_dirty_buffers_lock);
	156	list_del_init(&bh->b_assoc_buffers);
	157	reiserfs_free_jh(bh);
	158	spin_unlock(&j->j_dirty_buffers_lock);
	159	}
	160	clear_buffer_mapped(bh);
	161	clear_buffer_req(bh);
	162	clear_buffer_new(bh);
	163	bh->b_bdev = NULL;
	164	unlock_buffer(bh);
1da177e4 LT	165	}
	166
	167	/* this first locks inode (neither reads nor sync are permitted),
	168	reads tail through page cache, insert direct item. When direct item
	169	inserted successfully inode is left locked. Return value is always
	170	what we expect from it (number of cut bytes). But when tail remains
	171	in the unformatted node, we set mode to SKIP_BALANCING and unlock
	172	inode */
995c762e JM	173	int indirect2direct(struct reiserfs_transaction_handle *th,
995c762e JM	174	struct inode inode, struct page page,
d68caa95 JM	175	struct treepath path, / path to the indirect item. */
	176	const struct cpu_key item_key, / Key to look for
	177	* unformatted node
	178	* pointer to be cut. */
bd4c625c	179	loff_t n_new_file_size, /* New file size. */
d68caa95	180	char *mode)
1da177e4	181	{
995c762e	182	struct super_block *sb = inode->i_sb;
bd4c625c	183	struct item_head s_ih;
ee93961b	184	unsigned long block_size = sb->s_blocksize;
bd4c625c LT	185	char *tail;
	186	int tail_len, round_tail_len;
	187	loff_t pos, pos1; /* position of first byte of the tail */
	188	struct cpu_key key;
1da177e4	189
bd4c625c	190	BUG_ON(!th->t_trans_id);
1da177e4	191
a9dd3643	192	REISERFS_SB(sb)->s_indirect2direct++;
1da177e4	193
d68caa95	194	*mode = M_SKIP_BALANCING;
1da177e4	195
bd4c625c	196	/* store item head path points to. */
d68caa95	197	copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
bd4c625c	198
ee93961b	199	tail_len = (n_new_file_size & (block_size - 1));
995c762e	200	if (get_inode_sd_version(inode) == STAT_DATA_V2)
bd4c625c LT	201	round_tail_len = ROUND_UP(tail_len);
	202	else
	203	round_tail_len = tail_len;
	204
	205	pos =
	206	le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
a9dd3643	207	1) * sb->s_blocksize;
bd4c625c LT	208	pos1 = pos;
bd4c625c LT	209
1b1dcc1b	210	// we are protected by i_mutex. The tail can not disapper, not
bd4c625c LT	211	// append can be done either
	212	// we are in truncate or packing tail in file_release
	213
	214	tail = (char )kmap(page); / this can schedule */
	215
d68caa95	216	if (path_changed(&s_ih, path)) {
bd4c625c	217	/* re-search indirect item */
d68caa95	218	if (search_for_position_by_key(sb, item_key, path)
bd4c625c	219	== POSITION_NOT_FOUND)
a9dd3643	220	reiserfs_panic(sb, "PAP-5520",
bd4c625c	221	"item to be converted %K does not exist",
d68caa95 JM	222	item_key);
d68caa95 JM	223	copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
1da177e4	224	#ifdef CONFIG_REISERFS_CHECK
bd4c625c LT	225	pos = le_ih_k_offset(&s_ih) - 1 +
bd4c625c LT	226	(ih_item_len(&s_ih) / UNFM_P_SIZE -
a9dd3643	227	1) * sb->s_blocksize;
bd4c625c	228	if (pos != pos1)
a9dd3643	229	reiserfs_panic(sb, "vs-5530", "tail position "
c3a9c210	230	"changed while we were reading it");
1da177e4	231	#endif
bd4c625c	232	}
1da177e4	233
bd4c625c	234	/* Set direct item header to insert. */
995c762e	235	make_le_item_head(&s_ih, NULL, get_inode_item_key_version(inode),
bd4c625c LT	236	pos1 + 1, TYPE_DIRECT, round_tail_len,
	237	0xffff /ih_free_space / );
	238
	239	/* we want a pointer to the first byte of the tail in the page.
	240	** the page was locked and this part of the page was up to date when
	241	** indirect2direct was called, so we know the bytes are still valid
	242	*/
	243	tail = tail + (pos & (PAGE_CACHE_SIZE - 1));
	244
d68caa95	245	PATH_LAST_POSITION(path)++;
bd4c625c	246
d68caa95	247	key = *item_key;
bd4c625c LT	248	set_cpu_key_k_type(&key, TYPE_DIRECT);
	249	key.key_length = 4;
	250	/* Insert tail as new direct item in the tree */
d68caa95	251	if (reiserfs_insert_item(th, path, &key, &s_ih, inode,
bd4c625c LT	252	tail ? tail : NULL) < 0) {
	253	/* No disk memory. So we can not convert last unformatted node
	254	to the direct item. In this case we used to adjust
	255	indirect items's ih_free_space. Now ih_free_space is not
	256	used, it would be ideal to write zeros to corresponding
	257	unformatted node. For now i_size is considered as guard for
	258	going out of file size */
	259	kunmap(page);
ee93961b	260	return block_size - round_tail_len;
bd4c625c LT	261	}
bd4c625c LT	262	kunmap(page);
1da177e4	263
bd4c625c	264	/* make sure to get the i_blocks changes from reiserfs_insert_item */
995c762e	265	reiserfs_update_sd(th, inode);
1da177e4	266
bd4c625c LT	267	// note: we have now the same as in above direct2indirect
	268	// conversion: there are two keys which have matching first three
	269	// key components. They only differ by the fouhth one.
1da177e4	270
bd4c625c LT	271	/* We have inserted new direct item and must remove last
bd4c625c LT	272	unformatted node. */
d68caa95	273	*mode = M_CUT;
1da177e4	274
bd4c625c	275	/* we store position of first direct item in the in-core inode */
995c762e JM	276	/* mark_file_with_tail (inode, pos1 + 1); */
995c762e JM	277	REISERFS_I(inode)->i_first_direct_byte = pos1 + 1;
1da177e4	278
ee93961b	279	return block_size - round_tail_len;
bd4c625c	280	}