brintos / linux-shallow public Read only

1/*2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README3 */4 5#include <linux/time.h>6#include <linux/fs.h>7#include "reiserfs.h"8#include "acl.h"9#include "xattr.h"10#include <linux/exportfs.h>11#include <linux/pagemap.h>12#include <linux/highmem.h>13#include <linux/slab.h>14#include <linux/uaccess.h>15#include <linux/unaligned.h>16#include <linux/buffer_head.h>17#include <linux/mpage.h>18#include <linux/writeback.h>19#include <linux/quotaops.h>20#include <linux/swap.h>21#include <linux/uio.h>22#include <linux/bio.h>23 24int reiserfs_commit_write(struct file *f, struct page *page,25			  unsigned from, unsigned to);26 27void reiserfs_evict_inode(struct inode *inode)28{29	/*30	 * We need blocks for transaction + (user+group) quota31	 * update (possibly delete)32	 */33	int jbegin_count =34	    JOURNAL_PER_BALANCE_CNT * 2 +35	    2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb);36	struct reiserfs_transaction_handle th;37	int err;38 39	if (!inode->i_nlink && !is_bad_inode(inode))40		dquot_initialize(inode);41 42	truncate_inode_pages_final(&inode->i_data);43	if (inode->i_nlink)44		goto no_delete;45 46	/*47	 * The = 0 happens when we abort creating a new inode48	 * for some reason like lack of space..49	 * also handles bad_inode case50	 */51	if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) {52 53		reiserfs_delete_xattrs(inode);54 55		reiserfs_write_lock(inode->i_sb);56 57		if (journal_begin(&th, inode->i_sb, jbegin_count))58			goto out;59		reiserfs_update_inode_transaction(inode);60 61		reiserfs_discard_prealloc(&th, inode);62 63		err = reiserfs_delete_object(&th, inode);64 65		/*66		 * Do quota update inside a transaction for journaled quotas.67		 * We must do that after delete_object so that quota updates68		 * go into the same transaction as stat data deletion69		 */70		if (!err) {71			int depth = reiserfs_write_unlock_nested(inode->i_sb);72			dquot_free_inode(inode);73			reiserfs_write_lock_nested(inode->i_sb, depth);74		}75 76		if (journal_end(&th))77			goto out;78 79		/*80		 * check return value from reiserfs_delete_object after81		 * ending the transaction82		 */83		if (err)84		    goto out;85 86		/*87		 * all items of file are deleted, so we can remove88		 * "save" link89		 * we can't do anything about an error here90		 */91		remove_save_link(inode, 0 /* not truncate */);92out:93		reiserfs_write_unlock(inode->i_sb);94	} else {95		/* no object items are in the tree */96		;97	}98 99	/* note this must go after the journal_end to prevent deadlock */100	clear_inode(inode);101 102	dquot_drop(inode);103	inode->i_blocks = 0;104	return;105 106no_delete:107	clear_inode(inode);108	dquot_drop(inode);109}110 111static void _make_cpu_key(struct cpu_key *key, int version, __u32 dirid,112			  __u32 objectid, loff_t offset, int type, int length)113{114	key->version = version;115 116	key->on_disk_key.k_dir_id = dirid;117	key->on_disk_key.k_objectid = objectid;118	set_cpu_key_k_offset(key, offset);119	set_cpu_key_k_type(key, type);120	key->key_length = length;121}122 123/*124 * take base of inode_key (it comes from inode always) (dirid, objectid)125 * and version from an inode, set offset and type of key126 */127void make_cpu_key(struct cpu_key *key, struct inode *inode, loff_t offset,128		  int type, int length)129{130	_make_cpu_key(key, get_inode_item_key_version(inode),131		      le32_to_cpu(INODE_PKEY(inode)->k_dir_id),132		      le32_to_cpu(INODE_PKEY(inode)->k_objectid), offset, type,133		      length);134}135 136/* when key is 0, do not set version and short key */137inline void make_le_item_head(struct item_head *ih, const struct cpu_key *key,138			      int version,139			      loff_t offset, int type, int length,140			      int entry_count /*or ih_free_space */ )141{142	if (key) {143		ih->ih_key.k_dir_id = cpu_to_le32(key->on_disk_key.k_dir_id);144		ih->ih_key.k_objectid =145		    cpu_to_le32(key->on_disk_key.k_objectid);146	}147	put_ih_version(ih, version);148	set_le_ih_k_offset(ih, offset);149	set_le_ih_k_type(ih, type);150	put_ih_item_len(ih, length);151	/*    set_ih_free_space (ih, 0); */152	/*153	 * for directory items it is entry count, for directs and stat154	 * datas - 0xffff, for indirects - 0155	 */156	put_ih_entry_count(ih, entry_count);157}158 159/*160 * FIXME: we might cache recently accessed indirect item161 * Ugh.  Not too eager for that....162 * I cut the code until such time as I see a convincing argument (benchmark).163 * I don't want a bloated inode struct..., and I don't like code complexity....164 */165 166/*167 * cutting the code is fine, since it really isn't in use yet and is easy168 * to add back in.  But, Vladimir has a really good idea here.  Think169 * about what happens for reading a file.  For each page,170 * The VFS layer calls reiserfs_read_folio, who searches the tree to find171 * an indirect item.  This indirect item has X number of pointers, where172 * X is a big number if we've done the block allocation right.  But,173 * we only use one or two of these pointers during each call to read_folio,174 * needlessly researching again later on.175 *176 * The size of the cache could be dynamic based on the size of the file.177 *178 * I'd also like to see us cache the location the stat data item, since179 * we are needlessly researching for that frequently.180 *181 * --chris182 */183 184/*185 * If this page has a file tail in it, and186 * it was read in by get_block_create_0, the page data is valid,187 * but tail is still sitting in a direct item, and we can't write to188 * it.  So, look through this page, and check all the mapped buffers189 * to make sure they have valid block numbers.  Any that don't need190 * to be unmapped, so that __block_write_begin will correctly call191 * reiserfs_get_block to convert the tail into an unformatted node192 */193static inline void fix_tail_page_for_writing(struct page *page)194{195	struct buffer_head *head, *next, *bh;196 197	if (page && page_has_buffers(page)) {198		head = page_buffers(page);199		bh = head;200		do {201			next = bh->b_this_page;202			if (buffer_mapped(bh) && bh->b_blocknr == 0) {203				reiserfs_unmap_buffer(bh);204			}205			bh = next;206		} while (bh != head);207	}208}209 210/*211 * reiserfs_get_block does not need to allocate a block only if it has been212 * done already or non-hole position has been found in the indirect item213 */214static inline int allocation_needed(int retval, b_blocknr_t allocated,215				    struct item_head *ih,216				    __le32 * item, int pos_in_item)217{218	if (allocated)219		return 0;220	if (retval == POSITION_FOUND && is_indirect_le_ih(ih) &&221	    get_block_num(item, pos_in_item))222		return 0;223	return 1;224}225 226static inline int indirect_item_found(int retval, struct item_head *ih)227{228	return (retval == POSITION_FOUND) && is_indirect_le_ih(ih);229}230 231static inline void set_block_dev_mapped(struct buffer_head *bh,232					b_blocknr_t block, struct inode *inode)233{234	map_bh(bh, inode->i_sb, block);235}236 237/*238 * files which were created in the earlier version can not be longer,239 * than 2 gb240 */241static int file_capable(struct inode *inode, sector_t block)242{243	/* it is new file. */244	if (get_inode_item_key_version(inode) != KEY_FORMAT_3_5 ||245	    /* old file, but 'block' is inside of 2gb */246	    block < (1 << (31 - inode->i_sb->s_blocksize_bits)))247		return 1;248 249	return 0;250}251 252static int restart_transaction(struct reiserfs_transaction_handle *th,253			       struct inode *inode, struct treepath *path)254{255	struct super_block *s = th->t_super;256	int err;257 258	BUG_ON(!th->t_trans_id);259	BUG_ON(!th->t_refcount);260 261	pathrelse(path);262 263	/* we cannot restart while nested */264	if (th->t_refcount > 1) {265		return 0;266	}267	reiserfs_update_sd(th, inode);268	err = journal_end(th);269	if (!err) {270		err = journal_begin(th, s, JOURNAL_PER_BALANCE_CNT * 6);271		if (!err)272			reiserfs_update_inode_transaction(inode);273	}274	return err;275}276 277/*278 * it is called by get_block when create == 0. Returns block number279 * for 'block'-th logical block of file. When it hits direct item it280 * returns 0 (being called from bmap) or read direct item into piece281 * of page (bh_result)282 * Please improve the english/clarity in the comment above, as it is283 * hard to understand.284 */285static int _get_block_create_0(struct inode *inode, sector_t block,286			       struct buffer_head *bh_result, int args)287{288	INITIALIZE_PATH(path);289	struct cpu_key key;290	struct buffer_head *bh;291	struct item_head *ih, tmp_ih;292	b_blocknr_t blocknr;293	char *p;294	int chars;295	int ret;296	int result;297	int done = 0;298	unsigned long offset;299 300	/* prepare the key to look for the 'block'-th block of file */301	make_cpu_key(&key, inode,302		     (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY,303		     3);304 305	result = search_for_position_by_key(inode->i_sb, &key, &path);306	if (result != POSITION_FOUND) {307		pathrelse(&path);308		if (result == IO_ERROR)309			return -EIO;310		/*311		 * We do not return -ENOENT if there is a hole but page is312		 * uptodate, because it means that there is some MMAPED data313		 * associated with it that is yet to be written to disk.314		 */315		if ((args & GET_BLOCK_NO_HOLE)316		    && !PageUptodate(bh_result->b_page)) {317			return -ENOENT;318		}319		return 0;320	}321 322	bh = get_last_bh(&path);323	ih = tp_item_head(&path);324	if (is_indirect_le_ih(ih)) {325		__le32 *ind_item = (__le32 *) ih_item_body(bh, ih);326 327		/*328		 * FIXME: here we could cache indirect item or part of it in329		 * the inode to avoid search_by_key in case of subsequent330		 * access to file331		 */332		blocknr = get_block_num(ind_item, path.pos_in_item);333		ret = 0;334		if (blocknr) {335			map_bh(bh_result, inode->i_sb, blocknr);336			if (path.pos_in_item ==337			    ((ih_item_len(ih) / UNFM_P_SIZE) - 1)) {338				set_buffer_boundary(bh_result);339			}340		} else341			/*342			 * We do not return -ENOENT if there is a hole but343			 * page is uptodate, because it means that there is344			 * some MMAPED data associated with it that is345			 * yet to be written to disk.346			 */347		if ((args & GET_BLOCK_NO_HOLE)348			    && !PageUptodate(bh_result->b_page)) {349			ret = -ENOENT;350		}351 352		pathrelse(&path);353		return ret;354	}355	/* requested data are in direct item(s) */356	if (!(args & GET_BLOCK_READ_DIRECT)) {357		/*358		 * we are called by bmap. FIXME: we can not map block of file359		 * when it is stored in direct item(s)360		 */361		pathrelse(&path);362		return -ENOENT;363	}364 365	/*366	 * if we've got a direct item, and the buffer or page was uptodate,367	 * we don't want to pull data off disk again.  skip to the368	 * end, where we map the buffer and return369	 */370	if (buffer_uptodate(bh_result)) {371		goto finished;372	} else373		/*374		 * grab_tail_page can trigger calls to reiserfs_get_block on375		 * up to date pages without any buffers.  If the page is up376		 * to date, we don't want read old data off disk.  Set the up377		 * to date bit on the buffer instead and jump to the end378		 */379	if (!bh_result->b_page || PageUptodate(bh_result->b_page)) {380		set_buffer_uptodate(bh_result);381		goto finished;382	}383	/* read file tail into part of page */384	offset = (cpu_key_k_offset(&key) - 1) & (PAGE_SIZE - 1);385	copy_item_head(&tmp_ih, ih);386 387	/*388	 * we only want to kmap if we are reading the tail into the page.389	 * this is not the common case, so we don't kmap until we are390	 * sure we need to.  But, this means the item might move if391	 * kmap schedules392	 */393	p = (char *)kmap(bh_result->b_page);394	p += offset;395	memset(p, 0, inode->i_sb->s_blocksize);396	do {397		if (!is_direct_le_ih(ih)) {398			BUG();399		}400		/*401		 * make sure we don't read more bytes than actually exist in402		 * the file.  This can happen in odd cases where i_size isn't403		 * correct, and when direct item padding results in a few404		 * extra bytes at the end of the direct item405		 */406		if ((le_ih_k_offset(ih) + path.pos_in_item) > inode->i_size)407			break;408		if ((le_ih_k_offset(ih) - 1 + ih_item_len(ih)) > inode->i_size) {409			chars =410			    inode->i_size - (le_ih_k_offset(ih) - 1) -411			    path.pos_in_item;412			done = 1;413		} else {414			chars = ih_item_len(ih) - path.pos_in_item;415		}416		memcpy(p, ih_item_body(bh, ih) + path.pos_in_item, chars);417 418		if (done)419			break;420 421		p += chars;422 423		/*424		 * we done, if read direct item is not the last item of425		 * node FIXME: we could try to check right delimiting key426		 * to see whether direct item continues in the right427		 * neighbor or rely on i_size428		 */429		if (PATH_LAST_POSITION(&path) != (B_NR_ITEMS(bh) - 1))430			break;431 432		/* update key to look for the next piece */433		set_cpu_key_k_offset(&key, cpu_key_k_offset(&key) + chars);434		result = search_for_position_by_key(inode->i_sb, &key, &path);435		if (result != POSITION_FOUND)436			/* i/o error most likely */437			break;438		bh = get_last_bh(&path);439		ih = tp_item_head(&path);440	} while (1);441 442	flush_dcache_page(bh_result->b_page);443	kunmap(bh_result->b_page);444 445finished:446	pathrelse(&path);447 448	if (result == IO_ERROR)449		return -EIO;450 451	/*452	 * this buffer has valid data, but isn't valid for io.  mapping it to453	 * block #0 tells the rest of reiserfs it just has a tail in it454	 */455	map_bh(bh_result, inode->i_sb, 0);456	set_buffer_uptodate(bh_result);457	return 0;458}459 460/*461 * this is called to create file map. So, _get_block_create_0 will not462 * read direct item463 */464static int reiserfs_bmap(struct inode *inode, sector_t block,465			 struct buffer_head *bh_result, int create)466{467	if (!file_capable(inode, block))468		return -EFBIG;469 470	reiserfs_write_lock(inode->i_sb);471	/* do not read the direct item */472	_get_block_create_0(inode, block, bh_result, 0);473	reiserfs_write_unlock(inode->i_sb);474	return 0;475}476 477/*478 * special version of get_block that is only used by grab_tail_page right479 * now.  It is sent to __block_write_begin, and when you try to get a480 * block past the end of the file (or a block from a hole) it returns481 * -ENOENT instead of a valid buffer.  __block_write_begin expects to482 * be able to do i/o on the buffers returned, unless an error value483 * is also returned.484 *485 * So, this allows __block_write_begin to be used for reading a single block486 * in a page.  Where it does not produce a valid page for holes, or past the487 * end of the file.  This turns out to be exactly what we need for reading488 * tails for conversion.489 *490 * The point of the wrapper is forcing a certain value for create, even491 * though the VFS layer is calling this function with create==1.  If you492 * don't want to send create == GET_BLOCK_NO_HOLE to reiserfs_get_block,493 * don't use this function.494*/495static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,496				       struct buffer_head *bh_result,497				       int create)498{499	return reiserfs_get_block(inode, block, bh_result, GET_BLOCK_NO_HOLE);500}501 502/*503 * This is special helper for reiserfs_get_block in case we are executing504 * direct_IO request.505 */506static int reiserfs_get_blocks_direct_io(struct inode *inode,507					 sector_t iblock,508					 struct buffer_head *bh_result,509					 int create)510{511	int ret;512 513	bh_result->b_page = NULL;514 515	/*516	 * We set the b_size before reiserfs_get_block call since it is517	 * referenced in convert_tail_for_hole() that may be called from518	 * reiserfs_get_block()519	 */520	bh_result->b_size = i_blocksize(inode);521 522	ret = reiserfs_get_block(inode, iblock, bh_result,523				 create | GET_BLOCK_NO_DANGLE);524	if (ret)525		goto out;526 527	/* don't allow direct io onto tail pages */528	if (buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {529		/*530		 * make sure future calls to the direct io funcs for this531		 * offset in the file fail by unmapping the buffer532		 */533		clear_buffer_mapped(bh_result);534		ret = -EINVAL;535	}536 537	/*538	 * Possible unpacked tail. Flush the data before pages have539	 * disappeared540	 */541	if (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) {542		int err;543 544		reiserfs_write_lock(inode->i_sb);545 546		err = reiserfs_commit_for_inode(inode);547		REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;548 549		reiserfs_write_unlock(inode->i_sb);550 551		if (err < 0)552			ret = err;553	}554out:555	return ret;556}557 558/*559 * helper function for when reiserfs_get_block is called for a hole560 * but the file tail is still in a direct item561 * bh_result is the buffer head for the hole562 * tail_offset is the offset of the start of the tail in the file563 *564 * This calls prepare_write, which will start a new transaction565 * you should not be in a transaction, or have any paths held when you566 * call this.567 */568static int convert_tail_for_hole(struct inode *inode,569				 struct buffer_head *bh_result,570				 loff_t tail_offset)571{572	unsigned long index;573	unsigned long tail_end;574	unsigned long tail_start;575	struct page *tail_page;576	struct page *hole_page = bh_result->b_page;577	int retval = 0;578 579	if ((tail_offset & (bh_result->b_size - 1)) != 1)580		return -EIO;581 582	/* always try to read until the end of the block */583	tail_start = tail_offset & (PAGE_SIZE - 1);584	tail_end = (tail_start | (bh_result->b_size - 1)) + 1;585 586	index = tail_offset >> PAGE_SHIFT;587	/*588	 * hole_page can be zero in case of direct_io, we are sure589	 * that we cannot get here if we write with O_DIRECT into tail page590	 */591	if (!hole_page || index != hole_page->index) {592		tail_page = grab_cache_page(inode->i_mapping, index);593		retval = -ENOMEM;594		if (!tail_page) {595			goto out;596		}597	} else {598		tail_page = hole_page;599	}600 601	/*602	 * we don't have to make sure the conversion did not happen while603	 * we were locking the page because anyone that could convert604	 * must first take i_mutex.605	 *606	 * We must fix the tail page for writing because it might have buffers607	 * that are mapped, but have a block number of 0.  This indicates tail608	 * data that has been read directly into the page, and609	 * __block_write_begin won't trigger a get_block in this case.610	 */611	fix_tail_page_for_writing(tail_page);612	retval = __reiserfs_write_begin(tail_page, tail_start,613				      tail_end - tail_start);614	if (retval)615		goto unlock;616 617	/* tail conversion might change the data in the page */618	flush_dcache_page(tail_page);619 620	retval = reiserfs_commit_write(NULL, tail_page, tail_start, tail_end);621 622unlock:623	if (tail_page != hole_page) {624		unlock_page(tail_page);625		put_page(tail_page);626	}627out:628	return retval;629}630 631static inline int _allocate_block(struct reiserfs_transaction_handle *th,632				  sector_t block,633				  struct inode *inode,634				  b_blocknr_t * allocated_block_nr,635				  struct treepath *path, int flags)636{637	BUG_ON(!th->t_trans_id);638 639#ifdef REISERFS_PREALLOCATE640	if (!(flags & GET_BLOCK_NO_IMUX)) {641		return reiserfs_new_unf_blocknrs2(th, inode, allocated_block_nr,642						  path, block);643	}644#endif645	return reiserfs_new_unf_blocknrs(th, inode, allocated_block_nr, path,646					 block);647}648 649int reiserfs_get_block(struct inode *inode, sector_t block,650		       struct buffer_head *bh_result, int create)651{652	int repeat, retval = 0;653	/* b_blocknr_t is (unsigned) 32 bit int*/654	b_blocknr_t allocated_block_nr = 0;655	INITIALIZE_PATH(path);656	int pos_in_item;657	struct cpu_key key;658	struct buffer_head *bh, *unbh = NULL;659	struct item_head *ih, tmp_ih;660	__le32 *item;661	int done;662	int fs_gen;663	struct reiserfs_transaction_handle *th = NULL;664	/*665	 * space reserved in transaction batch:666	 * . 3 balancings in direct->indirect conversion667	 * . 1 block involved into reiserfs_update_sd()668	 * XXX in practically impossible worst case direct2indirect()669	 * can incur (much) more than 3 balancings.670	 * quota update for user, group671	 */672	int jbegin_count =673	    JOURNAL_PER_BALANCE_CNT * 3 + 1 +674	    2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);675	int version;676	int dangle = 1;677	loff_t new_offset =678	    (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1;679 680	reiserfs_write_lock(inode->i_sb);681	version = get_inode_item_key_version(inode);682 683	if (!file_capable(inode, block)) {684		reiserfs_write_unlock(inode->i_sb);685		return -EFBIG;686	}687 688	/*689	 * if !create, we aren't changing the FS, so we don't need to690	 * log anything, so we don't need to start a transaction691	 */692	if (!(create & GET_BLOCK_CREATE)) {693		int ret;694		/* find number of block-th logical block of the file */695		ret = _get_block_create_0(inode, block, bh_result,696					  create | GET_BLOCK_READ_DIRECT);697		reiserfs_write_unlock(inode->i_sb);698		return ret;699	}700 701	/*702	 * if we're already in a transaction, make sure to close703	 * any new transactions we start in this func704	 */705	if ((create & GET_BLOCK_NO_DANGLE) ||706	    reiserfs_transaction_running(inode->i_sb))707		dangle = 0;708 709	/*710	 * If file is of such a size, that it might have a tail and711	 * tails are enabled  we should mark it as possibly needing712	 * tail packing on close713	 */714	if ((have_large_tails(inode->i_sb)715	     && inode->i_size < i_block_size(inode) * 4)716	    || (have_small_tails(inode->i_sb)717		&& inode->i_size < i_block_size(inode)))718		REISERFS_I(inode)->i_flags |= i_pack_on_close_mask;719 720	/* set the key of the first byte in the 'block'-th block of file */721	make_cpu_key(&key, inode, new_offset, TYPE_ANY, 3 /*key length */ );722	if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) {723start_trans:724		th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count);725		if (!th) {726			retval = -ENOMEM;727			goto failure;728		}729		reiserfs_update_inode_transaction(inode);730	}731research:732 733	retval = search_for_position_by_key(inode->i_sb, &key, &path);734	if (retval == IO_ERROR) {735		retval = -EIO;736		goto failure;737	}738 739	bh = get_last_bh(&path);740	ih = tp_item_head(&path);741	item = tp_item_body(&path);742	pos_in_item = path.pos_in_item;743 744	fs_gen = get_generation(inode->i_sb);745	copy_item_head(&tmp_ih, ih);746 747	if (allocation_needed748	    (retval, allocated_block_nr, ih, item, pos_in_item)) {749		/* we have to allocate block for the unformatted node */750		if (!th) {751			pathrelse(&path);752			goto start_trans;753		}754 755		repeat =756		    _allocate_block(th, block, inode, &allocated_block_nr,757				    &path, create);758 759		/*760		 * restart the transaction to give the journal a chance to free761		 * some blocks.  releases the path, so we have to go back to762		 * research if we succeed on the second try763		 */764		if (repeat == NO_DISK_SPACE || repeat == QUOTA_EXCEEDED) {765			SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1;766			retval = restart_transaction(th, inode, &path);767			if (retval)768				goto failure;769			repeat =770			    _allocate_block(th, block, inode,771					    &allocated_block_nr, NULL, create);772 773			if (repeat != NO_DISK_SPACE && repeat != QUOTA_EXCEEDED) {774				goto research;775			}776			if (repeat == QUOTA_EXCEEDED)777				retval = -EDQUOT;778			else779				retval = -ENOSPC;780			goto failure;781		}782 783		if (fs_changed(fs_gen, inode->i_sb)784		    && item_moved(&tmp_ih, &path)) {785			goto research;786		}787	}788 789	if (indirect_item_found(retval, ih)) {790		b_blocknr_t unfm_ptr;791		/*792		 * 'block'-th block is in the file already (there is793		 * corresponding cell in some indirect item). But it may be794		 * zero unformatted node pointer (hole)795		 */796		unfm_ptr = get_block_num(item, pos_in_item);797		if (unfm_ptr == 0) {798			/* use allocated block to plug the hole */799			reiserfs_prepare_for_journal(inode->i_sb, bh, 1);800			if (fs_changed(fs_gen, inode->i_sb)801			    && item_moved(&tmp_ih, &path)) {802				reiserfs_restore_prepared_buffer(inode->i_sb,803								 bh);804				goto research;805			}806			set_buffer_new(bh_result);807			if (buffer_dirty(bh_result)808			    && reiserfs_data_ordered(inode->i_sb))809				reiserfs_add_ordered_list(inode, bh_result);810			put_block_num(item, pos_in_item, allocated_block_nr);811			unfm_ptr = allocated_block_nr;812			journal_mark_dirty(th, bh);813			reiserfs_update_sd(th, inode);814		}815		set_block_dev_mapped(bh_result, unfm_ptr, inode);816		pathrelse(&path);817		retval = 0;818		if (!dangle && th)819			retval = reiserfs_end_persistent_transaction(th);820 821		reiserfs_write_unlock(inode->i_sb);822 823		/*824		 * the item was found, so new blocks were not added to the file825		 * there is no need to make sure the inode is updated with this826		 * transaction827		 */828		return retval;829	}830 831	if (!th) {832		pathrelse(&path);833		goto start_trans;834	}835 836	/*837	 * desired position is not found or is in the direct item. We have838	 * to append file with holes up to 'block'-th block converting839	 * direct items to indirect one if necessary840	 */841	done = 0;842	do {843		if (is_statdata_le_ih(ih)) {844			__le32 unp = 0;845			struct cpu_key tmp_key;846 847			/* indirect item has to be inserted */848			make_le_item_head(&tmp_ih, &key, version, 1,849					  TYPE_INDIRECT, UNFM_P_SIZE,850					  0 /* free_space */ );851 852			/*853			 * we are going to add 'block'-th block to the file.854			 * Use allocated block for that855			 */856			if (cpu_key_k_offset(&key) == 1) {857				unp = cpu_to_le32(allocated_block_nr);858				set_block_dev_mapped(bh_result,859						     allocated_block_nr, inode);860				set_buffer_new(bh_result);861				done = 1;862			}863			tmp_key = key;	/* ;) */864			set_cpu_key_k_offset(&tmp_key, 1);865			PATH_LAST_POSITION(&path)++;866 867			retval =868			    reiserfs_insert_item(th, &path, &tmp_key, &tmp_ih,869						 inode, (char *)&unp);870			if (retval) {871				reiserfs_free_block(th, inode,872						    allocated_block_nr, 1);873				/*874				 * retval == -ENOSPC, -EDQUOT or -EIO875				 * or -EEXIST876				 */877				goto failure;878			}879		} else if (is_direct_le_ih(ih)) {880			/* direct item has to be converted */881			loff_t tail_offset;882 883			tail_offset =884			    ((le_ih_k_offset(ih) -885			      1) & ~(inode->i_sb->s_blocksize - 1)) + 1;886 887			/*888			 * direct item we just found fits into block we have889			 * to map. Convert it into unformatted node: use890			 * bh_result for the conversion891			 */892			if (tail_offset == cpu_key_k_offset(&key)) {893				set_block_dev_mapped(bh_result,894						     allocated_block_nr, inode);895				unbh = bh_result;896				done = 1;897			} else {898				/*899				 * we have to pad file tail stored in direct900				 * item(s) up to block size and convert it901				 * to unformatted node. FIXME: this should902				 * also get into page cache903				 */904 905				pathrelse(&path);906				/*907				 * ugly, but we can only end the transaction if908				 * we aren't nested909				 */910				BUG_ON(!th->t_refcount);911				if (th->t_refcount == 1) {912					retval =913					    reiserfs_end_persistent_transaction914					    (th);915					th = NULL;916					if (retval)917						goto failure;918				}919 920				retval =921				    convert_tail_for_hole(inode, bh_result,922							  tail_offset);923				if (retval) {924					if (retval != -ENOSPC)925						reiserfs_error(inode->i_sb,926							"clm-6004",927							"convert tail failed "928							"inode %lu, error %d",929							inode->i_ino,930							retval);931					if (allocated_block_nr) {932						/*933						 * the bitmap, the super,934						 * and the stat data == 3935						 */936						if (!th)937							th = reiserfs_persistent_transaction(inode->i_sb, 3);938						if (th)939							reiserfs_free_block(th,940									    inode,941									    allocated_block_nr,942									    1);943					}944					goto failure;945				}946				goto research;947			}948			retval =949			    direct2indirect(th, inode, &path, unbh,950					    tail_offset);951			if (retval) {952				reiserfs_unmap_buffer(unbh);953				reiserfs_free_block(th, inode,954						    allocated_block_nr, 1);955				goto failure;956			}957			/*958			 * it is important the set_buffer_uptodate is done959			 * after the direct2indirect.  The buffer might960			 * contain valid data newer than the data on disk961			 * (read by read_folio, changed, and then sent here by962			 * writepage).  direct2indirect needs to know if unbh963			 * was already up to date, so it can decide if the964			 * data in unbh needs to be replaced with data from965			 * the disk966			 */967			set_buffer_uptodate(unbh);968 969			/*970			 * unbh->b_page == NULL in case of DIRECT_IO request,971			 * this means buffer will disappear shortly, so it972			 * should not be added to973			 */974			if (unbh->b_page) {975				/*976				 * we've converted the tail, so we must977				 * flush unbh before the transaction commits978				 */979				reiserfs_add_tail_list(inode, unbh);980 981				/*982				 * mark it dirty now to prevent commit_write983				 * from adding this buffer to the inode's984				 * dirty buffer list985				 */986				/*987				 * AKPM: changed __mark_buffer_dirty to988				 * mark_buffer_dirty().  It's still atomic,989				 * but it sets the page dirty too, which makes990				 * it eligible for writeback at any time by the991				 * VM (which was also the case with992				 * __mark_buffer_dirty())993				 */994				mark_buffer_dirty(unbh);995			}996		} else {997			/*998			 * append indirect item with holes if needed, when999			 * appending pointer to 'block'-th block use block,1000			 * which is already allocated1001			 */1002			struct cpu_key tmp_key;1003			/*1004			 * We use this in case we need to allocate1005			 * only one block which is a fastpath1006			 */1007			unp_t unf_single = 0;1008			unp_t *un;1009			__u64 max_to_insert =1010			    MAX_ITEM_LEN(inode->i_sb->s_blocksize) /1011			    UNFM_P_SIZE;1012			__u64 blocks_needed;1013 1014			RFALSE(pos_in_item != ih_item_len(ih) / UNFM_P_SIZE,1015			       "vs-804: invalid position for append");1016			/*1017			 * indirect item has to be appended,1018			 * set up key of that position1019			 * (key type is unimportant)1020			 */1021			make_cpu_key(&tmp_key, inode,1022				     le_key_k_offset(version,1023						     &ih->ih_key) +1024				     op_bytes_number(ih,1025						     inode->i_sb->s_blocksize),1026				     TYPE_INDIRECT, 3);1027 1028			RFALSE(cpu_key_k_offset(&tmp_key) > cpu_key_k_offset(&key),1029			       "green-805: invalid offset");1030			blocks_needed =1031			    1 +1032			    ((cpu_key_k_offset(&key) -1033			      cpu_key_k_offset(&tmp_key)) >> inode->i_sb->1034			     s_blocksize_bits);1035 1036			if (blocks_needed == 1) {1037				un = &unf_single;1038			} else {1039				un = kcalloc(min(blocks_needed, max_to_insert),1040					     UNFM_P_SIZE, GFP_NOFS);1041				if (!un) {1042					un = &unf_single;1043					blocks_needed = 1;1044					max_to_insert = 0;1045				}1046			}1047			if (blocks_needed <= max_to_insert) {1048				/*1049				 * we are going to add target block to1050				 * the file. Use allocated block for that1051				 */1052				un[blocks_needed - 1] =1053				    cpu_to_le32(allocated_block_nr);1054				set_block_dev_mapped(bh_result,1055						     allocated_block_nr, inode);1056				set_buffer_new(bh_result);1057				done = 1;1058			} else {1059				/* paste hole to the indirect item */1060				/*1061				 * If kcalloc failed, max_to_insert becomes1062				 * zero and it means we only have space for1063				 * one block1064				 */1065				blocks_needed =1066				    max_to_insert ? max_to_insert : 1;1067			}1068			retval =1069			    reiserfs_paste_into_item(th, &path, &tmp_key, inode,1070						     (char *)un,1071						     UNFM_P_SIZE *1072						     blocks_needed);1073 1074			if (blocks_needed != 1)1075				kfree(un);1076 1077			if (retval) {1078				reiserfs_free_block(th, inode,1079						    allocated_block_nr, 1);1080				goto failure;1081			}1082			if (!done) {1083				/*1084				 * We need to mark new file size in case1085				 * this function will be interrupted/aborted1086				 * later on. And we may do this only for1087				 * holes.1088				 */1089				inode->i_size +=1090				    inode->i_sb->s_blocksize * blocks_needed;1091			}1092		}1093 1094		if (done == 1)1095			break;1096 1097		/*1098		 * this loop could log more blocks than we had originally1099		 * asked for.  So, we have to allow the transaction to end1100		 * if it is too big or too full.  Update the inode so things1101		 * are consistent if we crash before the function returns1102		 * release the path so that anybody waiting on the path before1103		 * ending their transaction will be able to continue.1104		 */1105		if (journal_transaction_should_end(th, th->t_blocks_allocated)) {1106			retval = restart_transaction(th, inode, &path);1107			if (retval)1108				goto failure;1109		}1110		/*1111		 * inserting indirect pointers for a hole can take a1112		 * long time.  reschedule if needed and also release the write1113		 * lock for others.1114		 */1115		reiserfs_cond_resched(inode->i_sb);1116 1117		retval = search_for_position_by_key(inode->i_sb, &key, &path);1118		if (retval == IO_ERROR) {1119			retval = -EIO;1120			goto failure;1121		}1122		if (retval == POSITION_FOUND) {1123			reiserfs_warning(inode->i_sb, "vs-825",1124					 "%K should not be found", &key);1125			retval = -EEXIST;1126			if (allocated_block_nr)1127				reiserfs_free_block(th, inode,1128						    allocated_block_nr, 1);1129			pathrelse(&path);1130			goto failure;1131		}1132		bh = get_last_bh(&path);1133		ih = tp_item_head(&path);1134		item = tp_item_body(&path);1135		pos_in_item = path.pos_in_item;1136	} while (1);1137 1138	retval = 0;1139 1140failure:1141	if (th && (!dangle || (retval && !th->t_trans_id))) {1142		int err;1143		if (th->t_trans_id)1144			reiserfs_update_sd(th, inode);1145		err = reiserfs_end_persistent_transaction(th);1146		if (err)1147			retval = err;1148	}1149 1150	reiserfs_write_unlock(inode->i_sb);1151	reiserfs_check_path(&path);1152	return retval;1153}1154 1155static void reiserfs_readahead(struct readahead_control *rac)1156{1157	mpage_readahead(rac, reiserfs_get_block);1158}1159 1160/*1161 * Compute real number of used bytes by file1162 * Following three functions can go away when we'll have enough space in1163 * stat item1164 */1165static int real_space_diff(struct inode *inode, int sd_size)1166{1167	int bytes;1168	loff_t blocksize = inode->i_sb->s_blocksize;1169 1170	if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode))1171		return sd_size;1172 1173	/*1174	 * End of file is also in full block with indirect reference, so round1175	 * up to the next block.1176	 *1177	 * there is just no way to know if the tail is actually packed1178	 * on the file, so we have to assume it isn't.  When we pack the1179	 * tail, we add 4 bytes to pretend there really is an unformatted1180	 * node pointer1181	 */1182	bytes =1183	    ((inode->i_size +1184	      (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE +1185	    sd_size;1186	return bytes;1187}1188 1189static inline loff_t to_real_used_space(struct inode *inode, ulong blocks,1190					int sd_size)1191{1192	if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {1193		return inode->i_size +1194		    (loff_t) (real_space_diff(inode, sd_size));1195	}1196	return ((loff_t) real_space_diff(inode, sd_size)) +1197	    (((loff_t) blocks) << 9);1198}1199 1200/* Compute number of blocks used by file in ReiserFS counting */1201static inline ulong to_fake_used_blocks(struct inode *inode, int sd_size)1202{1203	loff_t bytes = inode_get_bytes(inode);1204	loff_t real_space = real_space_diff(inode, sd_size);1205 1206	/* keeps fsck and non-quota versions of reiserfs happy */1207	if (S_ISLNK(inode->i_mode) || S_ISDIR(inode->i_mode)) {1208		bytes += (loff_t) 511;1209	}1210 1211	/*1212	 * files from before the quota patch might i_blocks such that1213	 * bytes < real_space.  Deal with that here to prevent it from1214	 * going negative.1215	 */1216	if (bytes < real_space)1217		return 0;1218	return (bytes - real_space) >> 9;1219}1220 1221/*1222 * BAD: new directories have stat data of new type and all other items1223 * of old type. Version stored in the inode says about body items, so1224 * in update_stat_data we can not rely on inode, but have to check1225 * item version directly1226 */1227 1228/* called by read_locked_inode */1229static void init_inode(struct inode *inode, struct treepath *path)1230{1231	struct buffer_head *bh;1232	struct item_head *ih;1233	__u32 rdev;1234 1235	bh = PATH_PLAST_BUFFER(path);1236	ih = tp_item_head(path);1237 1238	copy_key(INODE_PKEY(inode), &ih->ih_key);1239 1240	INIT_LIST_HEAD(&REISERFS_I(inode)->i_prealloc_list);1241	REISERFS_I(inode)->i_flags = 0;1242	REISERFS_I(inode)->i_prealloc_block = 0;1243	REISERFS_I(inode)->i_prealloc_count = 0;1244	REISERFS_I(inode)->i_trans_id = 0;1245	REISERFS_I(inode)->i_jl = NULL;1246	reiserfs_init_xattr_rwsem(inode);1247 1248	if (stat_data_v1(ih)) {1249		struct stat_data_v1 *sd =1250		    (struct stat_data_v1 *)ih_item_body(bh, ih);1251		unsigned long blocks;1252 1253		set_inode_item_key_version(inode, KEY_FORMAT_3_5);1254		set_inode_sd_version(inode, STAT_DATA_V1);1255		inode->i_mode = sd_v1_mode(sd);1256		set_nlink(inode, sd_v1_nlink(sd));1257		i_uid_write(inode, sd_v1_uid(sd));1258		i_gid_write(inode, sd_v1_gid(sd));1259		inode->i_size = sd_v1_size(sd);1260		inode_set_atime(inode, sd_v1_atime(sd), 0);1261		inode_set_mtime(inode, sd_v1_mtime(sd), 0);1262		inode_set_ctime(inode, sd_v1_ctime(sd), 0);1263 1264		inode->i_blocks = sd_v1_blocks(sd);1265		inode->i_generation = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);1266		blocks = (inode->i_size + 511) >> 9;1267		blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9);1268 1269		/*1270		 * there was a bug in <=3.5.23 when i_blocks could take1271		 * negative values. Starting from 3.5.17 this value could1272		 * even be stored in stat data. For such files we set1273		 * i_blocks based on file size. Just 2 notes: this can be1274		 * wrong for sparse files. On-disk value will be only1275		 * updated if file's inode will ever change1276		 */1277		if (inode->i_blocks > blocks) {1278			inode->i_blocks = blocks;1279		}1280 1281		rdev = sd_v1_rdev(sd);1282		REISERFS_I(inode)->i_first_direct_byte =1283		    sd_v1_first_direct_byte(sd);1284 1285		/*1286		 * an early bug in the quota code can give us an odd1287		 * number for the block count.  This is incorrect, fix it here.1288		 */1289		if (inode->i_blocks & 1) {1290			inode->i_blocks++;1291		}1292		inode_set_bytes(inode,1293				to_real_used_space(inode, inode->i_blocks,1294						   SD_V1_SIZE));1295		/*1296		 * nopack is initially zero for v1 objects. For v2 objects,1297		 * nopack is initialised from sd_attrs1298		 */1299		REISERFS_I(inode)->i_flags &= ~i_nopack_mask;1300	} else {1301		/*1302		 * new stat data found, but object may have old items1303		 * (directories and symlinks)1304		 */1305		struct stat_data *sd = (struct stat_data *)ih_item_body(bh, ih);1306 1307		inode->i_mode = sd_v2_mode(sd);1308		set_nlink(inode, sd_v2_nlink(sd));1309		i_uid_write(inode, sd_v2_uid(sd));1310		inode->i_size = sd_v2_size(sd);1311		i_gid_write(inode, sd_v2_gid(sd));1312		inode_set_mtime(inode, sd_v2_mtime(sd), 0);1313		inode_set_atime(inode, sd_v2_atime(sd), 0);1314		inode_set_ctime(inode, sd_v2_ctime(sd), 0);1315		inode->i_blocks = sd_v2_blocks(sd);1316		rdev = sd_v2_rdev(sd);1317		if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))1318			inode->i_generation =1319			    le32_to_cpu(INODE_PKEY(inode)->k_dir_id);1320		else1321			inode->i_generation = sd_v2_generation(sd);1322 1323		if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))1324			set_inode_item_key_version(inode, KEY_FORMAT_3_5);1325		else1326			set_inode_item_key_version(inode, KEY_FORMAT_3_6);1327		REISERFS_I(inode)->i_first_direct_byte = 0;1328		set_inode_sd_version(inode, STAT_DATA_V2);1329		inode_set_bytes(inode,1330				to_real_used_space(inode, inode->i_blocks,1331						   SD_V2_SIZE));1332		/*1333		 * read persistent inode attributes from sd and initialise1334		 * generic inode flags from them1335		 */1336		REISERFS_I(inode)->i_attrs = sd_v2_attrs(sd);1337		sd_attrs_to_i_attrs(sd_v2_attrs(sd), inode);1338	}1339 1340	pathrelse(path);1341	if (S_ISREG(inode->i_mode)) {1342		inode->i_op = &reiserfs_file_inode_operations;1343		inode->i_fop = &reiserfs_file_operations;1344		inode->i_mapping->a_ops = &reiserfs_address_space_operations;1345	} else if (S_ISDIR(inode->i_mode)) {1346		inode->i_op = &reiserfs_dir_inode_operations;1347		inode->i_fop = &reiserfs_dir_operations;1348	} else if (S_ISLNK(inode->i_mode)) {1349		inode->i_op = &reiserfs_symlink_inode_operations;1350		inode_nohighmem(inode);1351		inode->i_mapping->a_ops = &reiserfs_address_space_operations;1352	} else {1353		inode->i_blocks = 0;1354		inode->i_op = &reiserfs_special_inode_operations;1355		init_special_inode(inode, inode->i_mode, new_decode_dev(rdev));1356	}1357}1358 1359/* update new stat data with inode fields */1360static void inode2sd(void *sd, struct inode *inode, loff_t size)1361{1362	struct stat_data *sd_v2 = (struct stat_data *)sd;1363 1364	set_sd_v2_mode(sd_v2, inode->i_mode);1365	set_sd_v2_nlink(sd_v2, inode->i_nlink);1366	set_sd_v2_uid(sd_v2, i_uid_read(inode));1367	set_sd_v2_size(sd_v2, size);1368	set_sd_v2_gid(sd_v2, i_gid_read(inode));1369	set_sd_v2_mtime(sd_v2, inode_get_mtime_sec(inode));1370	set_sd_v2_atime(sd_v2, inode_get_atime_sec(inode));1371	set_sd_v2_ctime(sd_v2, inode_get_ctime_sec(inode));1372	set_sd_v2_blocks(sd_v2, to_fake_used_blocks(inode, SD_V2_SIZE));1373	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))1374		set_sd_v2_rdev(sd_v2, new_encode_dev(inode->i_rdev));1375	else1376		set_sd_v2_generation(sd_v2, inode->i_generation);1377	set_sd_v2_attrs(sd_v2, REISERFS_I(inode)->i_attrs);1378}1379 1380/* used to copy inode's fields to old stat data */1381static void inode2sd_v1(void *sd, struct inode *inode, loff_t size)1382{1383	struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;1384 1385	set_sd_v1_mode(sd_v1, inode->i_mode);1386	set_sd_v1_uid(sd_v1, i_uid_read(inode));1387	set_sd_v1_gid(sd_v1, i_gid_read(inode));1388	set_sd_v1_nlink(sd_v1, inode->i_nlink);1389	set_sd_v1_size(sd_v1, size);1390	set_sd_v1_atime(sd_v1, inode_get_atime_sec(inode));1391	set_sd_v1_ctime(sd_v1, inode_get_ctime_sec(inode));1392	set_sd_v1_mtime(sd_v1, inode_get_mtime_sec(inode));1393 1394	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))1395		set_sd_v1_rdev(sd_v1, new_encode_dev(inode->i_rdev));1396	else1397		set_sd_v1_blocks(sd_v1, to_fake_used_blocks(inode, SD_V1_SIZE));1398 1399	/* Sigh. i_first_direct_byte is back */1400	set_sd_v1_first_direct_byte(sd_v1,1401				    REISERFS_I(inode)->i_first_direct_byte);1402}1403 1404/*1405 * NOTE, you must prepare the buffer head before sending it here,1406 * and then log it after the call1407 */1408static void update_stat_data(struct treepath *path, struct inode *inode,1409			     loff_t size)1410{1411	struct buffer_head *bh;1412	struct item_head *ih;1413 1414	bh = PATH_PLAST_BUFFER(path);1415	ih = tp_item_head(path);1416 1417	if (!is_statdata_le_ih(ih))1418		reiserfs_panic(inode->i_sb, "vs-13065", "key %k, found item %h",1419			       INODE_PKEY(inode), ih);1420 1421	/* path points to old stat data */1422	if (stat_data_v1(ih)) {1423		inode2sd_v1(ih_item_body(bh, ih), inode, size);1424	} else {1425		inode2sd(ih_item_body(bh, ih), inode, size);1426	}1427 1428	return;1429}1430 1431void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,1432			     struct inode *inode, loff_t size)1433{1434	struct cpu_key key;1435	INITIALIZE_PATH(path);1436	struct buffer_head *bh;1437	int fs_gen;1438	struct item_head *ih, tmp_ih;1439	int retval;1440 1441	BUG_ON(!th->t_trans_id);1442 1443	/* key type is unimportant */1444	make_cpu_key(&key, inode, SD_OFFSET, TYPE_STAT_DATA, 3);1445 1446	for (;;) {1447		int pos;1448		/* look for the object's stat data */1449		retval = search_item(inode->i_sb, &key, &path);1450		if (retval == IO_ERROR) {1451			reiserfs_error(inode->i_sb, "vs-13050",1452				       "i/o failure occurred trying to "1453				       "update %K stat data", &key);1454			return;1455		}1456		if (retval == ITEM_NOT_FOUND) {1457			pos = PATH_LAST_POSITION(&path);1458			pathrelse(&path);1459			if (inode->i_nlink == 0) {1460				/*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */1461				return;1462			}1463			reiserfs_warning(inode->i_sb, "vs-13060",1464					 "stat data of object %k (nlink == %d) "1465					 "not found (pos %d)",1466					 INODE_PKEY(inode), inode->i_nlink,1467					 pos);1468			reiserfs_check_path(&path);1469			return;1470		}1471 1472		/*1473		 * sigh, prepare_for_journal might schedule.  When it1474		 * schedules the FS might change.  We have to detect that,1475		 * and loop back to the search if the stat data item has moved1476		 */1477		bh = get_last_bh(&path);1478		ih = tp_item_head(&path);1479		copy_item_head(&tmp_ih, ih);1480		fs_gen = get_generation(inode->i_sb);1481		reiserfs_prepare_for_journal(inode->i_sb, bh, 1);1482 1483		/* Stat_data item has been moved after scheduling. */1484		if (fs_changed(fs_gen, inode->i_sb)1485		    && item_moved(&tmp_ih, &path)) {1486			reiserfs_restore_prepared_buffer(inode->i_sb, bh);1487			continue;1488		}1489		break;1490	}1491	update_stat_data(&path, inode, size);1492	journal_mark_dirty(th, bh);1493	pathrelse(&path);1494	return;1495}1496 1497/*1498 * reiserfs_read_locked_inode is called to read the inode off disk, and it1499 * does a make_bad_inode when things go wrong.  But, we need to make sure1500 * and clear the key in the private portion of the inode, otherwise a1501 * corresponding iput might try to delete whatever object the inode last1502 * represented.1503 */1504static void reiserfs_make_bad_inode(struct inode *inode)1505{1506	memset(INODE_PKEY(inode), 0, KEY_SIZE);1507	make_bad_inode(inode);1508}1509 1510/*1511 * initially this function was derived from minix or ext2's analog and1512 * evolved as the prototype did1513 */1514int reiserfs_init_locked_inode(struct inode *inode, void *p)1515{1516	struct reiserfs_iget_args *args = (struct reiserfs_iget_args *)p;1517	inode->i_ino = args->objectid;1518	INODE_PKEY(inode)->k_dir_id = cpu_to_le32(args->dirid);1519	return 0;1520}1521 1522/*1523 * looks for stat data in the tree, and fills up the fields of in-core1524 * inode stat data fields1525 */1526void reiserfs_read_locked_inode(struct inode *inode,1527				struct reiserfs_iget_args *args)1528{1529	INITIALIZE_PATH(path_to_sd);1530	struct cpu_key key;1531	unsigned long dirino;1532	int retval;1533 1534	dirino = args->dirid;1535 1536	/*1537	 * set version 1, version 2 could be used too, because stat data1538	 * key is the same in both versions1539	 */1540	_make_cpu_key(&key, KEY_FORMAT_3_5, dirino, inode->i_ino, 0, 0, 3);1541 1542	/* look for the object's stat data */1543	retval = search_item(inode->i_sb, &key, &path_to_sd);1544	if (retval == IO_ERROR) {1545		reiserfs_error(inode->i_sb, "vs-13070",1546			       "i/o failure occurred trying to find "1547			       "stat data of %K", &key);1548		reiserfs_make_bad_inode(inode);1549		return;1550	}1551 1552	/* a stale NFS handle can trigger this without it being an error */1553	if (retval != ITEM_FOUND) {1554		pathrelse(&path_to_sd);1555		reiserfs_make_bad_inode(inode);1556		clear_nlink(inode);1557		return;1558	}1559 1560	init_inode(inode, &path_to_sd);1561 1562	/*1563	 * It is possible that knfsd is trying to access inode of a file1564	 * that is being removed from the disk by some other thread. As we1565	 * update sd on unlink all that is required is to check for nlink1566	 * here. This bug was first found by Sizif when debugging1567	 * SquidNG/Butterfly, forgotten, and found again after Philippe1568	 * Gramoulle <philippe.gramoulle@mmania.com> reproduced it.1569 1570	 * More logical fix would require changes in fs/inode.c:iput() to1571	 * remove inode from hash-table _after_ fs cleaned disk stuff up and1572	 * in iget() to return NULL if I_FREEING inode is found in1573	 * hash-table.1574	 */1575 1576	/*1577	 * Currently there is one place where it's ok to meet inode with1578	 * nlink==0: processing of open-unlinked and half-truncated files1579	 * during mount (fs/reiserfs/super.c:finish_unfinished()).1580	 */1581	if ((inode->i_nlink == 0) &&1582	    !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) {1583		reiserfs_warning(inode->i_sb, "vs-13075",1584				 "dead inode read from disk %K. "1585				 "This is likely to be race with knfsd. Ignore",1586				 &key);1587		reiserfs_make_bad_inode(inode);1588	}1589 1590	/* init inode should be relsing */1591	reiserfs_check_path(&path_to_sd);1592 1593	/*1594	 * Stat data v1 doesn't support ACLs.1595	 */1596	if (get_inode_sd_version(inode) == STAT_DATA_V1)1597		cache_no_acl(inode);1598}1599 1600/*1601 * reiserfs_find_actor() - "find actor" reiserfs supplies to iget5_locked().1602 *1603 * @inode:    inode from hash table to check1604 * @opaque:   "cookie" passed to iget5_locked(). This is &reiserfs_iget_args.1605 *1606 * This function is called by iget5_locked() to distinguish reiserfs inodes1607 * having the same inode numbers. Such inodes can only exist due to some1608 * error condition. One of them should be bad. Inodes with identical1609 * inode numbers (objectids) are distinguished by parent directory ids.1610 *1611 */1612int reiserfs_find_actor(struct inode *inode, void *opaque)1613{1614	struct reiserfs_iget_args *args;1615 1616	args = opaque;1617	/* args is already in CPU order */1618	return (inode->i_ino == args->objectid) &&1619	    (le32_to_cpu(INODE_PKEY(inode)->k_dir_id) == args->dirid);1620}1621 1622struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key)1623{1624	struct inode *inode;1625	struct reiserfs_iget_args args;1626	int depth;1627 1628	args.objectid = key->on_disk_key.k_objectid;1629	args.dirid = key->on_disk_key.k_dir_id;1630	depth = reiserfs_write_unlock_nested(s);1631	inode = iget5_locked(s, key->on_disk_key.k_objectid,1632			     reiserfs_find_actor, reiserfs_init_locked_inode,1633			     (void *)(&args));1634	reiserfs_write_lock_nested(s, depth);1635	if (!inode)1636		return ERR_PTR(-ENOMEM);1637 1638	if (inode->i_state & I_NEW) {1639		reiserfs_read_locked_inode(inode, &args);1640		unlock_new_inode(inode);1641	}1642 1643	if (comp_short_keys(INODE_PKEY(inode), key) || is_bad_inode(inode)) {1644		/* either due to i/o error or a stale NFS handle */1645		iput(inode);1646		inode = NULL;1647	}1648	return inode;1649}1650 1651static struct dentry *reiserfs_get_dentry(struct super_block *sb,1652	u32 objectid, u32 dir_id, u32 generation)1653 1654{1655	struct cpu_key key;1656	struct inode *inode;1657 1658	key.on_disk_key.k_objectid = objectid;1659	key.on_disk_key.k_dir_id = dir_id;1660	reiserfs_write_lock(sb);1661	inode = reiserfs_iget(sb, &key);1662	if (inode && !IS_ERR(inode) && generation != 0 &&1663	    generation != inode->i_generation) {1664		iput(inode);1665		inode = NULL;1666	}1667	reiserfs_write_unlock(sb);1668 1669	return d_obtain_alias(inode);1670}1671 1672struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,1673		int fh_len, int fh_type)1674{1675	/*1676	 * fhtype happens to reflect the number of u32s encoded.1677	 * due to a bug in earlier code, fhtype might indicate there1678	 * are more u32s then actually fitted.1679	 * so if fhtype seems to be more than len, reduce fhtype.1680	 * Valid types are:1681	 *   2 - objectid + dir_id - legacy support1682	 *   3 - objectid + dir_id + generation1683	 *   4 - objectid + dir_id + objectid and dirid of parent - legacy1684	 *   5 - objectid + dir_id + generation + objectid and dirid of parent1685	 *   6 - as above plus generation of directory1686	 * 6 does not fit in NFSv2 handles1687	 */1688	if (fh_type > fh_len) {1689		if (fh_type != 6 || fh_len != 5)1690			reiserfs_warning(sb, "reiserfs-13077",1691				"nfsd/reiserfs, fhtype=%d, len=%d - odd",1692				fh_type, fh_len);1693		fh_type = fh_len;1694	}1695	if (fh_len < 2)1696		return NULL;1697 1698	return reiserfs_get_dentry(sb, fid->raw[0], fid->raw[1],1699		(fh_type == 3 || fh_type >= 5) ? fid->raw[2] : 0);1700}1701 1702struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,1703		int fh_len, int fh_type)1704{1705	if (fh_type > fh_len)1706		fh_type = fh_len;1707	if (fh_type < 4)1708		return NULL;1709 1710	return reiserfs_get_dentry(sb,1711		(fh_type >= 5) ? fid->raw[3] : fid->raw[2],1712		(fh_type >= 5) ? fid->raw[4] : fid->raw[3],1713		(fh_type == 6) ? fid->raw[5] : 0);1714}1715 1716int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,1717		       struct inode *parent)1718{1719	int maxlen = *lenp;1720 1721	if (parent && (maxlen < 5)) {1722		*lenp = 5;1723		return FILEID_INVALID;1724	} else if (maxlen < 3) {1725		*lenp = 3;1726		return FILEID_INVALID;1727	}1728 1729	data[0] = inode->i_ino;1730	data[1] = le32_to_cpu(INODE_PKEY(inode)->k_dir_id);1731	data[2] = inode->i_generation;1732	*lenp = 3;1733	if (parent) {1734		data[3] = parent->i_ino;1735		data[4] = le32_to_cpu(INODE_PKEY(parent)->k_dir_id);1736		*lenp = 5;1737		if (maxlen >= 6) {1738			data[5] = parent->i_generation;1739			*lenp = 6;1740		}1741	}1742	return *lenp;1743}1744 1745/*1746 * looks for stat data, then copies fields to it, marks the buffer1747 * containing stat data as dirty1748 */1749/*1750 * reiserfs inodes are never really dirty, since the dirty inode call1751 * always logs them.  This call allows the VFS inode marking routines1752 * to properly mark inodes for datasync and such, but only actually1753 * does something when called for a synchronous update.1754 */1755int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc)1756{1757	struct reiserfs_transaction_handle th;1758	int jbegin_count = 1;1759 1760	if (sb_rdonly(inode->i_sb))1761		return -EROFS;1762	/*1763	 * memory pressure can sometimes initiate write_inode calls with1764	 * sync == 1,1765	 * these cases are just when the system needs ram, not when the1766	 * inode needs to reach disk for safety, and they can safely be1767	 * ignored because the altered inode has already been logged.1768	 */1769	if (wbc->sync_mode == WB_SYNC_ALL && !(current->flags & PF_MEMALLOC)) {1770		reiserfs_write_lock(inode->i_sb);1771		if (!journal_begin(&th, inode->i_sb, jbegin_count)) {1772			reiserfs_update_sd(&th, inode);1773			journal_end_sync(&th);1774		}1775		reiserfs_write_unlock(inode->i_sb);1776	}1777	return 0;1778}1779 1780/*1781 * stat data of new object is inserted already, this inserts the item1782 * containing "." and ".." entries1783 */1784static int reiserfs_new_directory(struct reiserfs_transaction_handle *th,1785				  struct inode *inode,1786				  struct item_head *ih, struct treepath *path,1787				  struct inode *dir)1788{1789	struct super_block *sb = th->t_super;1790	char empty_dir[EMPTY_DIR_SIZE];1791	char *body = empty_dir;1792	struct cpu_key key;1793	int retval;1794 1795	BUG_ON(!th->t_trans_id);1796 1797	_make_cpu_key(&key, KEY_FORMAT_3_5, le32_to_cpu(ih->ih_key.k_dir_id),1798		      le32_to_cpu(ih->ih_key.k_objectid), DOT_OFFSET,1799		      TYPE_DIRENTRY, 3 /*key length */ );1800 1801	/*1802	 * compose item head for new item. Directories consist of items of1803	 * old type (ITEM_VERSION_1). Do not set key (second arg is 0), it1804	 * is done by reiserfs_new_inode1805	 */1806	if (old_format_only(sb)) {1807		make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,1808				  TYPE_DIRENTRY, EMPTY_DIR_SIZE_V1, 2);1809 1810		make_empty_dir_item_v1(body, ih->ih_key.k_dir_id,1811				       ih->ih_key.k_objectid,1812				       INODE_PKEY(dir)->k_dir_id,1813				       INODE_PKEY(dir)->k_objectid);1814	} else {1815		make_le_item_head(ih, NULL, KEY_FORMAT_3_5, DOT_OFFSET,1816				  TYPE_DIRENTRY, EMPTY_DIR_SIZE, 2);1817 1818		make_empty_dir_item(body, ih->ih_key.k_dir_id,1819				    ih->ih_key.k_objectid,1820				    INODE_PKEY(dir)->k_dir_id,1821				    INODE_PKEY(dir)->k_objectid);1822	}1823 1824	/* look for place in the tree for new item */1825	retval = search_item(sb, &key, path);1826	if (retval == IO_ERROR) {1827		reiserfs_error(sb, "vs-13080",1828			       "i/o failure occurred creating new directory");1829		return -EIO;1830	}1831	if (retval == ITEM_FOUND) {1832		pathrelse(path);1833		reiserfs_warning(sb, "vs-13070",1834				 "object with this key exists (%k)",1835				 &(ih->ih_key));1836		return -EEXIST;1837	}1838 1839	/* insert item, that is empty directory item */1840	return reiserfs_insert_item(th, path, &key, ih, inode, body);1841}1842 1843/*1844 * stat data of object has been inserted, this inserts the item1845 * containing the body of symlink1846 */1847static int reiserfs_new_symlink(struct reiserfs_transaction_handle *th,1848				struct inode *inode,1849				struct item_head *ih,1850				struct treepath *path, const char *symname,1851				int item_len)1852{1853	struct super_block *sb = th->t_super;1854	struct cpu_key key;1855	int retval;1856 1857	BUG_ON(!th->t_trans_id);1858 1859	_make_cpu_key(&key, KEY_FORMAT_3_5,1860		      le32_to_cpu(ih->ih_key.k_dir_id),1861		      le32_to_cpu(ih->ih_key.k_objectid),1862		      1, TYPE_DIRECT, 3 /*key length */ );1863 1864	make_le_item_head(ih, NULL, KEY_FORMAT_3_5, 1, TYPE_DIRECT, item_len,1865			  0 /*free_space */ );1866 1867	/* look for place in the tree for new item */1868	retval = search_item(sb, &key, path);1869	if (retval == IO_ERROR) {1870		reiserfs_error(sb, "vs-13080",1871			       "i/o failure occurred creating new symlink");1872		return -EIO;1873	}1874	if (retval == ITEM_FOUND) {1875		pathrelse(path);1876		reiserfs_warning(sb, "vs-13080",1877				 "object with this key exists (%k)",1878				 &(ih->ih_key));1879		return -EEXIST;1880	}1881 1882	/* insert item, that is body of symlink */1883	return reiserfs_insert_item(th, path, &key, ih, inode, symname);1884}1885 1886/*1887 * inserts the stat data into the tree, and then calls1888 * reiserfs_new_directory (to insert ".", ".." item if new object is1889 * directory) or reiserfs_new_symlink (to insert symlink body if new1890 * object is symlink) or nothing (if new object is regular file)1891 1892 * NOTE! uid and gid must already be set in the inode.  If we return1893 * non-zero due to an error, we have to drop the quota previously allocated1894 * for the fresh inode.  This can only be done outside a transaction, so1895 * if we return non-zero, we also end the transaction.1896 *1897 * @th: active transaction handle1898 * @dir: parent directory for new inode1899 * @mode: mode of new inode1900 * @symname: symlink contents if inode is symlink1901 * @isize: 0 for regular file, EMPTY_DIR_SIZE for dirs, strlen(symname) for1902 *         symlinks1903 * @inode: inode to be filled1904 * @security: optional security context to associate with this inode1905 */1906int reiserfs_new_inode(struct reiserfs_transaction_handle *th,1907		       struct inode *dir, umode_t mode, const char *symname,1908		       /* 0 for regular, EMTRY_DIR_SIZE for dirs,1909		          strlen (symname) for symlinks) */1910		       loff_t i_size, struct dentry *dentry,1911		       struct inode *inode,1912		       struct reiserfs_security_handle *security)1913{1914	struct super_block *sb = dir->i_sb;1915	struct reiserfs_iget_args args;1916	INITIALIZE_PATH(path_to_key);1917	struct cpu_key key;1918	struct item_head ih;1919	struct stat_data sd;1920	int retval;1921	int err;1922	int depth;1923 1924	BUG_ON(!th->t_trans_id);1925 1926	depth = reiserfs_write_unlock_nested(sb);1927	err = dquot_alloc_inode(inode);1928	reiserfs_write_lock_nested(sb, depth);1929	if (err)1930		goto out_end_trans;1931	if (!dir->i_nlink) {1932		err = -EPERM;1933		goto out_bad_inode;1934	}1935 1936	/* item head of new item */1937	ih.ih_key.k_dir_id = reiserfs_choose_packing(dir);1938	ih.ih_key.k_objectid = cpu_to_le32(reiserfs_get_unused_objectid(th));1939	if (!ih.ih_key.k_objectid) {1940		err = -ENOMEM;1941		goto out_bad_inode;1942	}1943	args.objectid = inode->i_ino = le32_to_cpu(ih.ih_key.k_objectid);1944	if (old_format_only(sb))1945		make_le_item_head(&ih, NULL, KEY_FORMAT_3_5, SD_OFFSET,1946				  TYPE_STAT_DATA, SD_V1_SIZE, MAX_US_INT);1947	else1948		make_le_item_head(&ih, NULL, KEY_FORMAT_3_6, SD_OFFSET,1949				  TYPE_STAT_DATA, SD_SIZE, MAX_US_INT);1950	memcpy(INODE_PKEY(inode), &ih.ih_key, KEY_SIZE);1951	args.dirid = le32_to_cpu(ih.ih_key.k_dir_id);1952 1953	depth = reiserfs_write_unlock_nested(inode->i_sb);1954	err = insert_inode_locked4(inode, args.objectid,1955			     reiserfs_find_actor, &args);1956	reiserfs_write_lock_nested(inode->i_sb, depth);1957	if (err) {1958		err = -EINVAL;1959		goto out_bad_inode;1960	}1961 1962	if (old_format_only(sb))1963		/*1964		 * not a perfect generation count, as object ids can be reused,1965		 * but this is as good as reiserfs can do right now.1966		 * note that the private part of inode isn't filled in yet,1967		 * we have to use the directory.1968		 */1969		inode->i_generation = le32_to_cpu(INODE_PKEY(dir)->k_objectid);1970	else1971#if defined( USE_INODE_GENERATION_COUNTER )1972		inode->i_generation =1973		    le32_to_cpu(REISERFS_SB(sb)->s_rs->s_inode_generation);1974#else1975		inode->i_generation = ++event;1976#endif1977 1978	/* fill stat data */1979	set_nlink(inode, (S_ISDIR(mode) ? 2 : 1));1980 1981	/* uid and gid must already be set by the caller for quota init */1982 1983	simple_inode_init_ts(inode);1984	inode->i_size = i_size;1985	inode->i_blocks = 0;1986	inode->i_bytes = 0;1987	REISERFS_I(inode)->i_first_direct_byte = S_ISLNK(mode) ? 1 :1988	    U32_MAX /*NO_BYTES_IN_DIRECT_ITEM */ ;1989 1990	INIT_LIST_HEAD(&REISERFS_I(inode)->i_prealloc_list);1991	REISERFS_I(inode)->i_flags = 0;1992	REISERFS_I(inode)->i_prealloc_block = 0;1993	REISERFS_I(inode)->i_prealloc_count = 0;1994	REISERFS_I(inode)->i_trans_id = 0;1995	REISERFS_I(inode)->i_jl = NULL;1996	REISERFS_I(inode)->i_attrs =1997	    REISERFS_I(dir)->i_attrs & REISERFS_INHERIT_MASK;1998	sd_attrs_to_i_attrs(REISERFS_I(inode)->i_attrs, inode);1999	reiserfs_init_xattr_rwsem(inode);2000 2001	/* key to search for correct place for new stat data */2002	_make_cpu_key(&key, KEY_FORMAT_3_6, le32_to_cpu(ih.ih_key.k_dir_id),2003		      le32_to_cpu(ih.ih_key.k_objectid), SD_OFFSET,2004		      TYPE_STAT_DATA, 3 /*key length */ );2005 2006	/* find proper place for inserting of stat data */2007	retval = search_item(sb, &key, &path_to_key);2008	if (retval == IO_ERROR) {2009		err = -EIO;2010		goto out_bad_inode;2011	}2012	if (retval == ITEM_FOUND) {2013		pathrelse(&path_to_key);2014		err = -EEXIST;2015		goto out_bad_inode;2016	}2017	if (old_format_only(sb)) {2018		/* i_uid or i_gid is too big to be stored in stat data v3.5 */2019		if (i_uid_read(inode) & ~0xffff || i_gid_read(inode) & ~0xffff) {2020			pathrelse(&path_to_key);2021			err = -EINVAL;2022			goto out_bad_inode;2023		}2024		inode2sd_v1(&sd, inode, inode->i_size);2025	} else {2026		inode2sd(&sd, inode, inode->i_size);2027	}2028	/*2029	 * store in in-core inode the key of stat data and version all2030	 * object items will have (directory items will have old offset2031	 * format, other new objects will consist of new items)2032	 */2033	if (old_format_only(sb) || S_ISDIR(mode) || S_ISLNK(mode))2034		set_inode_item_key_version(inode, KEY_FORMAT_3_5);2035	else2036		set_inode_item_key_version(inode, KEY_FORMAT_3_6);2037	if (old_format_only(sb))2038		set_inode_sd_version(inode, STAT_DATA_V1);2039	else2040		set_inode_sd_version(inode, STAT_DATA_V2);2041 2042	/* insert the stat data into the tree */2043#ifdef DISPLACE_NEW_PACKING_LOCALITIES2044	if (REISERFS_I(dir)->new_packing_locality)2045		th->displace_new_blocks = 1;2046#endif2047	retval =2048	    reiserfs_insert_item(th, &path_to_key, &key, &ih, inode,2049				 (char *)(&sd));2050	if (retval) {2051		err = retval;2052		reiserfs_check_path(&path_to_key);2053		goto out_bad_inode;2054	}2055#ifdef DISPLACE_NEW_PACKING_LOCALITIES2056	if (!th->displace_new_blocks)2057		REISERFS_I(dir)->new_packing_locality = 0;2058#endif2059	if (S_ISDIR(mode)) {2060		/* insert item with "." and ".." */2061		retval =2062		    reiserfs_new_directory(th, inode, &ih, &path_to_key, dir);2063	}2064 2065	if (S_ISLNK(mode)) {2066		/* insert body of symlink */2067		if (!old_format_only(sb))2068			i_size = ROUND_UP(i_size);2069		retval =2070		    reiserfs_new_symlink(th, inode, &ih, &path_to_key, symname,2071					 i_size);2072	}2073	if (retval) {2074		err = retval;2075		reiserfs_check_path(&path_to_key);2076		journal_end(th);2077		goto out_inserted_sd;2078	}2079 2080	/*2081	 * Mark it private if we're creating the privroot2082	 * or something under it.2083	 */2084	if (IS_PRIVATE(dir) || dentry == REISERFS_SB(sb)->priv_root)2085		reiserfs_init_priv_inode(inode);2086 2087	if (reiserfs_posixacl(inode->i_sb)) {2088		reiserfs_write_unlock(inode->i_sb);2089		retval = reiserfs_inherit_default_acl(th, dir, dentry, inode);2090		reiserfs_write_lock(inode->i_sb);2091		if (retval) {2092			err = retval;2093			reiserfs_check_path(&path_to_key);2094			journal_end(th);2095			goto out_inserted_sd;2096		}2097	} else if (inode->i_sb->s_flags & SB_POSIXACL) {2098		reiserfs_warning(inode->i_sb, "jdm-13090",2099				 "ACLs aren't enabled in the fs, "2100				 "but vfs thinks they are!");2101	}2102 2103	if (security->name) {2104		reiserfs_write_unlock(inode->i_sb);2105		retval = reiserfs_security_write(th, inode, security);2106		reiserfs_write_lock(inode->i_sb);2107		if (retval) {2108			err = retval;2109			reiserfs_check_path(&path_to_key);2110			retval = journal_end(th);2111			if (retval)2112				err = retval;2113			goto out_inserted_sd;2114		}2115	}2116 2117	reiserfs_update_sd(th, inode);2118	reiserfs_check_path(&path_to_key);2119 2120	return 0;2121 2122out_bad_inode:2123	/* Invalidate the object, nothing was inserted yet */2124	INODE_PKEY(inode)->k_objectid = 0;2125 2126	/* Quota change must be inside a transaction for journaling */2127	depth = reiserfs_write_unlock_nested(inode->i_sb);2128	dquot_free_inode(inode);2129	reiserfs_write_lock_nested(inode->i_sb, depth);2130 2131out_end_trans:2132	journal_end(th);2133	/*2134	 * Drop can be outside and it needs more credits so it's better2135	 * to have it outside2136	 */2137	depth = reiserfs_write_unlock_nested(inode->i_sb);2138	dquot_drop(inode);2139	reiserfs_write_lock_nested(inode->i_sb, depth);2140	inode->i_flags |= S_NOQUOTA;2141	make_bad_inode(inode);2142 2143out_inserted_sd:2144	clear_nlink(inode);2145	th->t_trans_id = 0;	/* so the caller can't use this handle later */2146	if (inode->i_state & I_NEW)2147		unlock_new_inode(inode);2148	iput(inode);2149	return err;2150}2151 2152/*2153 * finds the tail page in the page cache,2154 * reads the last block in.2155 *2156 * On success, page_result is set to a locked, pinned page, and bh_result2157 * is set to an up to date buffer for the last block in the file.  returns 0.2158 *2159 * tail conversion is not done, so bh_result might not be valid for writing2160 * check buffer_mapped(bh_result) and bh_result->b_blocknr != 0 before2161 * trying to write the block.2162 *2163 * on failure, nonzero is returned, page_result and bh_result are untouched.2164 */2165static int grab_tail_page(struct inode *inode,2166			  struct page **page_result,2167			  struct buffer_head **bh_result)2168{2169 2170	/*2171	 * we want the page with the last byte in the file,2172	 * not the page that will hold the next byte for appending2173	 */2174	unsigned long index = (inode->i_size - 1) >> PAGE_SHIFT;2175	unsigned long pos = 0;2176	unsigned long start = 0;2177	unsigned long blocksize = inode->i_sb->s_blocksize;2178	unsigned long offset = (inode->i_size) & (PAGE_SIZE - 1);2179	struct buffer_head *bh;2180	struct buffer_head *head;2181	struct folio *folio;2182	int error;2183 2184	/*2185	 * we know that we are only called with inode->i_size > 0.2186	 * we also know that a file tail can never be as big as a block2187	 * If i_size % blocksize == 0, our file is currently block aligned2188	 * and it won't need converting or zeroing after a truncate.2189	 */2190	if ((offset & (blocksize - 1)) == 0) {2191		return -ENOENT;2192	}2193	folio = __filemap_get_folio(inode->i_mapping, index,2194			FGP_LOCK | FGP_ACCESSED | FGP_CREAT,2195			mapping_gfp_mask(inode->i_mapping));2196	if (IS_ERR(folio))2197		return PTR_ERR(folio);2198	/* start within the page of the last block in the file */2199	start = (offset / blocksize) * blocksize;2200 2201	error = __block_write_begin(folio, start, offset - start,2202				    reiserfs_get_block_create_0);2203	if (error)2204		goto unlock;2205 2206	head = folio_buffers(folio);2207	bh = head;2208	do {2209		if (pos >= start) {2210			break;2211		}2212		bh = bh->b_this_page;2213		pos += blocksize;2214	} while (bh != head);2215 2216	if (!buffer_uptodate(bh)) {2217		/*2218		 * note, this should never happen, prepare_write should be2219		 * taking care of this for us.  If the buffer isn't up to2220		 * date, I've screwed up the code to find the buffer, or the2221		 * code to call prepare_write2222		 */2223		reiserfs_error(inode->i_sb, "clm-6000",2224			       "error reading block %lu", bh->b_blocknr);2225		error = -EIO;2226		goto unlock;2227	}2228	*bh_result = bh;2229	*page_result = &folio->page;2230 2231	return error;2232 2233unlock:2234	folio_unlock(folio);2235	folio_put(folio);2236	return error;2237}2238 2239/*2240 * vfs version of truncate file.  Must NOT be called with2241 * a transaction already started.2242 *2243 * some code taken from block_truncate_page2244 */2245int reiserfs_truncate_file(struct inode *inode, int update_timestamps)2246{2247	struct reiserfs_transaction_handle th;2248	/* we want the offset for the first byte after the end of the file */2249	unsigned long offset = inode->i_size & (PAGE_SIZE - 1);2250	unsigned blocksize = inode->i_sb->s_blocksize;2251	unsigned length;2252	struct page *page = NULL;2253	int error;2254	struct buffer_head *bh = NULL;2255	int err2;2256 2257	reiserfs_write_lock(inode->i_sb);2258 2259	if (inode->i_size > 0) {2260		error = grab_tail_page(inode, &page, &bh);2261		if (error) {2262			/*2263			 * -ENOENT means we truncated past the end of the2264			 * file, and get_block_create_0 could not find a2265			 * block to read in, which is ok.2266			 */2267			if (error != -ENOENT)2268				reiserfs_error(inode->i_sb, "clm-6001",2269					       "grab_tail_page failed %d",2270					       error);2271			page = NULL;2272			bh = NULL;2273		}2274	}2275 2276	/*2277	 * so, if page != NULL, we have a buffer head for the offset at2278	 * the end of the file. if the bh is mapped, and bh->b_blocknr != 0,2279	 * then we have an unformatted node.  Otherwise, we have a direct item,2280	 * and no zeroing is required on disk.  We zero after the truncate,2281	 * because the truncate might pack the item anyway2282	 * (it will unmap bh if it packs).2283	 *2284	 * it is enough to reserve space in transaction for 2 balancings:2285	 * one for "save" link adding and another for the first2286	 * cut_from_item. 1 is for update_sd2287	 */2288	error = journal_begin(&th, inode->i_sb,2289			      JOURNAL_PER_BALANCE_CNT * 2 + 1);2290	if (error)2291		goto out;2292	reiserfs_update_inode_transaction(inode);2293	if (update_timestamps)2294		/*2295		 * we are doing real truncate: if the system crashes2296		 * before the last transaction of truncating gets committed2297		 * - on reboot the file either appears truncated properly2298		 * or not truncated at all2299		 */2300		add_save_link(&th, inode, 1);2301	err2 = reiserfs_do_truncate(&th, inode, page, update_timestamps);2302	error = journal_end(&th);2303	if (error)2304		goto out;2305 2306	/* check reiserfs_do_truncate after ending the transaction */2307	if (err2) {2308		error = err2;2309  		goto out;2310	}2311	2312	if (update_timestamps) {2313		error = remove_save_link(inode, 1 /* truncate */);2314		if (error)2315			goto out;2316	}2317 2318	if (page) {2319		length = offset & (blocksize - 1);2320		/* if we are not on a block boundary */2321		if (length) {2322			length = blocksize - length;2323			zero_user(page, offset, length);2324			if (buffer_mapped(bh) && bh->b_blocknr != 0) {2325				mark_buffer_dirty(bh);2326			}2327		}2328		unlock_page(page);2329		put_page(page);2330	}2331 2332	reiserfs_write_unlock(inode->i_sb);2333 2334	return 0;2335out:2336	if (page) {2337		unlock_page(page);2338		put_page(page);2339	}2340 2341	reiserfs_write_unlock(inode->i_sb);2342 2343	return error;2344}2345 2346static int map_block_for_writepage(struct inode *inode,2347				   struct buffer_head *bh_result,2348				   unsigned long block)2349{2350	struct reiserfs_transaction_handle th;2351	int fs_gen;2352	struct item_head tmp_ih;2353	struct item_head *ih;2354	struct buffer_head *bh;2355	__le32 *item;2356	struct cpu_key key;2357	INITIALIZE_PATH(path);2358	int pos_in_item;2359	int jbegin_count = JOURNAL_PER_BALANCE_CNT;2360	loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1;2361	int retval;2362	int use_get_block = 0;2363	int bytes_copied = 0;2364	int copy_size;2365	int trans_running = 0;2366 2367	/*2368	 * catch places below that try to log something without2369	 * starting a trans2370	 */2371	th.t_trans_id = 0;2372 2373	if (!buffer_uptodate(bh_result)) {2374		return -EIO;2375	}2376 2377	kmap(bh_result->b_page);2378start_over:2379	reiserfs_write_lock(inode->i_sb);2380	make_cpu_key(&key, inode, byte_offset, TYPE_ANY, 3);2381 2382research:2383	retval = search_for_position_by_key(inode->i_sb, &key, &path);2384	if (retval != POSITION_FOUND) {2385		use_get_block = 1;2386		goto out;2387	}2388 2389	bh = get_last_bh(&path);2390	ih = tp_item_head(&path);2391	item = tp_item_body(&path);2392	pos_in_item = path.pos_in_item;2393 2394	/* we've found an unformatted node */2395	if (indirect_item_found(retval, ih)) {2396		if (bytes_copied > 0) {2397			reiserfs_warning(inode->i_sb, "clm-6002",2398					 "bytes_copied %d", bytes_copied);2399		}2400		if (!get_block_num(item, pos_in_item)) {2401			/* crap, we are writing to a hole */2402			use_get_block = 1;2403			goto out;2404		}2405		set_block_dev_mapped(bh_result,2406				     get_block_num(item, pos_in_item), inode);2407	} else if (is_direct_le_ih(ih)) {2408		char *p;2409		p = page_address(bh_result->b_page);2410		p += (byte_offset - 1) & (PAGE_SIZE - 1);2411		copy_size = ih_item_len(ih) - pos_in_item;2412 2413		fs_gen = get_generation(inode->i_sb);2414		copy_item_head(&tmp_ih, ih);2415 2416		if (!trans_running) {2417			/* vs-3050 is gone, no need to drop the path */2418			retval = journal_begin(&th, inode->i_sb, jbegin_count);2419			if (retval)2420				goto out;2421			reiserfs_update_inode_transaction(inode);2422			trans_running = 1;2423			if (fs_changed(fs_gen, inode->i_sb)2424			    && item_moved(&tmp_ih, &path)) {2425				reiserfs_restore_prepared_buffer(inode->i_sb,2426								 bh);2427				goto research;2428			}2429		}2430 2431		reiserfs_prepare_for_journal(inode->i_sb, bh, 1);2432 2433		if (fs_changed(fs_gen, inode->i_sb)2434		    && item_moved(&tmp_ih, &path)) {2435			reiserfs_restore_prepared_buffer(inode->i_sb, bh);2436			goto research;2437		}2438 2439		memcpy(ih_item_body(bh, ih) + pos_in_item, p + bytes_copied,2440		       copy_size);2441 2442		journal_mark_dirty(&th, bh);2443		bytes_copied += copy_size;2444		set_block_dev_mapped(bh_result, 0, inode);2445 2446		/* are there still bytes left? */2447		if (bytes_copied < bh_result->b_size &&2448		    (byte_offset + bytes_copied) < inode->i_size) {2449			set_cpu_key_k_offset(&key,2450					     cpu_key_k_offset(&key) +2451					     copy_size);2452			goto research;2453		}2454	} else {2455		reiserfs_warning(inode->i_sb, "clm-6003",2456				 "bad item inode %lu", inode->i_ino);2457		retval = -EIO;2458		goto out;2459	}2460	retval = 0;2461 2462out:2463	pathrelse(&path);2464	if (trans_running) {2465		int err = journal_end(&th);2466		if (err)2467			retval = err;2468		trans_running = 0;2469	}2470	reiserfs_write_unlock(inode->i_sb);2471 2472	/* this is where we fill in holes in the file. */2473	if (use_get_block) {2474		retval = reiserfs_get_block(inode, block, bh_result,2475					    GET_BLOCK_CREATE | GET_BLOCK_NO_IMUX2476					    | GET_BLOCK_NO_DANGLE);2477		if (!retval) {2478			if (!buffer_mapped(bh_result)2479			    || bh_result->b_blocknr == 0) {2480				/* get_block failed to find a mapped unformatted node. */2481				use_get_block = 0;2482				goto start_over;2483			}2484		}2485	}2486	kunmap(bh_result->b_page);2487 2488	if (!retval && buffer_mapped(bh_result) && bh_result->b_blocknr == 0) {2489		/*2490		 * we've copied data from the page into the direct item, so the2491		 * buffer in the page is now clean, mark it to reflect that.2492		 */2493		lock_buffer(bh_result);2494		clear_buffer_dirty(bh_result);2495		unlock_buffer(bh_result);2496	}2497	return retval;2498}2499 2500/*2501 * mason@suse.com: updated in 2.5.54 to follow the same general io2502 * start/recovery path as __block_write_full_folio, along with special2503 * code to handle reiserfs tails.2504 */2505static int reiserfs_write_folio(struct folio *folio,2506		struct writeback_control *wbc, void *data)2507{2508	struct inode *inode = folio->mapping->host;2509	unsigned long end_index = inode->i_size >> PAGE_SHIFT;2510	int error = 0;2511	unsigned long block;2512	sector_t last_block;2513	struct buffer_head *head, *bh;2514	int partial = 0;2515	int nr = 0;2516	int checked = folio_test_checked(folio);2517	struct reiserfs_transaction_handle th;2518	struct super_block *s = inode->i_sb;2519	int bh_per_page = PAGE_SIZE / s->s_blocksize;2520	th.t_trans_id = 0;2521 2522	/* no logging allowed when nonblocking or from PF_MEMALLOC */2523	if (checked && (current->flags & PF_MEMALLOC)) {2524		folio_redirty_for_writepage(wbc, folio);2525		folio_unlock(folio);2526		return 0;2527	}2528 2529	/*2530	 * The folio dirty bit is cleared before writepage is called, which2531	 * means we have to tell create_empty_buffers to make dirty buffers2532	 * The folio really should be up to date at this point, so tossing2533	 * in the BH_Uptodate is just a sanity check.2534	 */2535	head = folio_buffers(folio);2536	if (!head)2537		head = create_empty_buffers(folio, s->s_blocksize,2538				     (1 << BH_Dirty) | (1 << BH_Uptodate));2539 2540	/*2541	 * last folio in the file, zero out any contents past the2542	 * last byte in the file2543	 */2544	if (folio->index >= end_index) {2545		unsigned last_offset;2546 2547		last_offset = inode->i_size & (PAGE_SIZE - 1);2548		/* no file contents in this folio */2549		if (folio->index >= end_index + 1 || !last_offset) {2550			folio_unlock(folio);2551			return 0;2552		}2553		folio_zero_segment(folio, last_offset, folio_size(folio));2554	}2555	bh = head;2556	block = folio->index << (PAGE_SHIFT - s->s_blocksize_bits);2557	last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;2558	/* first map all the buffers, logging any direct items we find */2559	do {2560		if (block > last_block) {2561			/*2562			 * This can happen when the block size is less than2563			 * the folio size.  The corresponding bytes in the folio2564			 * were zero filled above2565			 */2566			clear_buffer_dirty(bh);2567			set_buffer_uptodate(bh);2568		} else if ((checked || buffer_dirty(bh)) &&2569			   (!buffer_mapped(bh) || bh->b_blocknr == 0)) {2570			/*2571			 * not mapped yet, or it points to a direct item, search2572			 * the btree for the mapping info, and log any direct2573			 * items found2574			 */2575			if ((error = map_block_for_writepage(inode, bh, block))) {2576				goto fail;2577			}2578		}2579		bh = bh->b_this_page;2580		block++;2581	} while (bh != head);2582 2583	/*2584	 * we start the transaction after map_block_for_writepage,2585	 * because it can create holes in the file (an unbounded operation).2586	 * starting it here, we can make a reliable estimate for how many2587	 * blocks we're going to log2588	 */2589	if (checked) {2590		folio_clear_checked(folio);2591		reiserfs_write_lock(s);2592		error = journal_begin(&th, s, bh_per_page + 1);2593		if (error) {2594			reiserfs_write_unlock(s);2595			goto fail;2596		}2597		reiserfs_update_inode_transaction(inode);2598	}2599	/* now go through and lock any dirty buffers on the folio */2600	do {2601		get_bh(bh);2602		if (!buffer_mapped(bh))2603			continue;2604		if (buffer_mapped(bh) && bh->b_blocknr == 0)2605			continue;2606 2607		if (checked) {2608			reiserfs_prepare_for_journal(s, bh, 1);2609			journal_mark_dirty(&th, bh);2610			continue;2611		}2612		/*2613		 * from this point on, we know the buffer is mapped to a2614		 * real block and not a direct item2615		 */2616		if (wbc->sync_mode != WB_SYNC_NONE) {2617			lock_buffer(bh);2618		} else {2619			if (!trylock_buffer(bh)) {2620				folio_redirty_for_writepage(wbc, folio);2621				continue;2622			}2623		}2624		if (test_clear_buffer_dirty(bh)) {2625			mark_buffer_async_write(bh);2626		} else {2627			unlock_buffer(bh);2628		}2629	} while ((bh = bh->b_this_page) != head);2630 2631	if (checked) {2632		error = journal_end(&th);2633		reiserfs_write_unlock(s);2634		if (error)2635			goto fail;2636	}2637	BUG_ON(folio_test_writeback(folio));2638	folio_start_writeback(folio);2639	folio_unlock(folio);2640 2641	/*2642	 * since any buffer might be the only dirty buffer on the folio,2643	 * the first submit_bh can bring the folio out of writeback.2644	 * be careful with the buffers.2645	 */2646	do {2647		struct buffer_head *next = bh->b_this_page;2648		if (buffer_async_write(bh)) {2649			submit_bh(REQ_OP_WRITE, bh);2650			nr++;2651		}2652		put_bh(bh);2653		bh = next;2654	} while (bh != head);2655 2656	error = 0;2657done:2658	if (nr == 0) {2659		/*2660		 * if this folio only had a direct item, it is very possible for2661		 * no io to be required without there being an error.  Or,2662		 * someone else could have locked them and sent them down the2663		 * pipe without locking the folio2664		 */2665		bh = head;2666		do {2667			if (!buffer_uptodate(bh)) {2668				partial = 1;2669				break;2670			}2671			bh = bh->b_this_page;2672		} while (bh != head);2673		if (!partial)2674			folio_mark_uptodate(folio);2675		folio_end_writeback(folio);2676	}2677	return error;2678 2679fail:2680	/*2681	 * catches various errors, we need to make sure any valid dirty blocks2682	 * get to the media.  The folio is currently locked and not marked for2683	 * writeback2684	 */2685	folio_clear_uptodate(folio);2686	bh = head;2687	do {2688		get_bh(bh);2689		if (buffer_mapped(bh) && buffer_dirty(bh) && bh->b_blocknr) {2690			lock_buffer(bh);2691			mark_buffer_async_write(bh);2692		} else {2693			/*2694			 * clear any dirty bits that might have come from2695			 * getting attached to a dirty folio2696			 */2697			clear_buffer_dirty(bh);2698		}2699		bh = bh->b_this_page;2700	} while (bh != head);2701	BUG_ON(folio_test_writeback(folio));2702	folio_start_writeback(folio);2703	folio_unlock(folio);2704	do {2705		struct buffer_head *next = bh->b_this_page;2706		if (buffer_async_write(bh)) {2707			clear_buffer_dirty(bh);2708			submit_bh(REQ_OP_WRITE, bh);2709			nr++;2710		}2711		put_bh(bh);2712		bh = next;2713	} while (bh != head);2714	goto done;2715}2716 2717static int reiserfs_read_folio(struct file *f, struct folio *folio)2718{2719	return block_read_full_folio(folio, reiserfs_get_block);2720}2721 2722static int reiserfs_writepages(struct address_space *mapping,2723		struct writeback_control *wbc)2724{2725	reiserfs_wait_on_write_block(mapping->host->i_sb);2726	return write_cache_pages(mapping, wbc, reiserfs_write_folio, NULL);2727}2728 2729static void reiserfs_truncate_failed_write(struct inode *inode)2730{2731	truncate_inode_pages(inode->i_mapping, inode->i_size);2732	reiserfs_truncate_file(inode, 0);2733}2734 2735static int reiserfs_write_begin(struct file *file,2736				struct address_space *mapping,2737				loff_t pos, unsigned len,2738				struct folio **foliop, void **fsdata)2739{2740	struct inode *inode;2741	struct folio *folio;2742	pgoff_t index;2743	int ret;2744	int old_ref = 0;2745 2746 	inode = mapping->host;2747	index = pos >> PAGE_SHIFT;2748	folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,2749			mapping_gfp_mask(mapping));2750	if (IS_ERR(folio))2751		return PTR_ERR(folio);2752	*foliop = folio;2753 2754	reiserfs_wait_on_write_block(inode->i_sb);2755	fix_tail_page_for_writing(&folio->page);2756	if (reiserfs_transaction_running(inode->i_sb)) {2757		struct reiserfs_transaction_handle *th;2758		th = (struct reiserfs_transaction_handle *)current->2759		    journal_info;2760		BUG_ON(!th->t_refcount);2761		BUG_ON(!th->t_trans_id);2762		old_ref = th->t_refcount;2763		th->t_refcount++;2764	}2765	ret = __block_write_begin(folio, pos, len, reiserfs_get_block);2766	if (ret && reiserfs_transaction_running(inode->i_sb)) {2767		struct reiserfs_transaction_handle *th = current->journal_info;2768		/*2769		 * this gets a little ugly.  If reiserfs_get_block returned an2770		 * error and left a transacstion running, we've got to close2771		 * it, and we've got to free handle if it was a persistent2772		 * transaction.2773		 *2774		 * But, if we had nested into an existing transaction, we need2775		 * to just drop the ref count on the handle.2776		 *2777		 * If old_ref == 0, the transaction is from reiserfs_get_block,2778		 * and it was a persistent trans.  Otherwise, it was nested2779		 * above.2780		 */2781		if (th->t_refcount > old_ref) {2782			if (old_ref)2783				th->t_refcount--;2784			else {2785				int err;2786				reiserfs_write_lock(inode->i_sb);2787				err = reiserfs_end_persistent_transaction(th);2788				reiserfs_write_unlock(inode->i_sb);2789				if (err)2790					ret = err;2791			}2792		}2793	}2794	if (ret) {2795		folio_unlock(folio);2796		folio_put(folio);2797		/* Truncate allocated blocks */2798		reiserfs_truncate_failed_write(inode);2799	}2800	return ret;2801}2802 2803int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)2804{2805	struct inode *inode = page->mapping->host;2806	int ret;2807	int old_ref = 0;2808	int depth;2809 2810	depth = reiserfs_write_unlock_nested(inode->i_sb);2811	reiserfs_wait_on_write_block(inode->i_sb);2812	reiserfs_write_lock_nested(inode->i_sb, depth);2813 2814	fix_tail_page_for_writing(page);2815	if (reiserfs_transaction_running(inode->i_sb)) {2816		struct reiserfs_transaction_handle *th;2817		th = (struct reiserfs_transaction_handle *)current->2818		    journal_info;2819		BUG_ON(!th->t_refcount);2820		BUG_ON(!th->t_trans_id);2821		old_ref = th->t_refcount;2822		th->t_refcount++;2823	}2824 2825	ret = __block_write_begin(page_folio(page), from, len, reiserfs_get_block);2826	if (ret && reiserfs_transaction_running(inode->i_sb)) {2827		struct reiserfs_transaction_handle *th = current->journal_info;2828		/*2829		 * this gets a little ugly.  If reiserfs_get_block returned an2830		 * error and left a transacstion running, we've got to close2831		 * it, and we've got to free handle if it was a persistent2832		 * transaction.2833		 *2834		 * But, if we had nested into an existing transaction, we need2835		 * to just drop the ref count on the handle.2836		 *2837		 * If old_ref == 0, the transaction is from reiserfs_get_block,2838		 * and it was a persistent trans.  Otherwise, it was nested2839		 * above.2840		 */2841		if (th->t_refcount > old_ref) {2842			if (old_ref)2843				th->t_refcount--;2844			else {2845				int err;2846				reiserfs_write_lock(inode->i_sb);2847				err = reiserfs_end_persistent_transaction(th);2848				reiserfs_write_unlock(inode->i_sb);2849				if (err)2850					ret = err;2851			}2852		}2853	}2854	return ret;2855 2856}2857 2858static sector_t reiserfs_aop_bmap(struct address_space *as, sector_t block)2859{2860	return generic_block_bmap(as, block, reiserfs_bmap);2861}2862 2863static int reiserfs_write_end(struct file *file, struct address_space *mapping,2864			      loff_t pos, unsigned len, unsigned copied,2865			      struct folio *folio, void *fsdata)2866{2867	struct inode *inode = folio->mapping->host;2868	int ret = 0;2869	int update_sd = 0;2870	struct reiserfs_transaction_handle *th;2871	unsigned start;2872	bool locked = false;2873 2874	reiserfs_wait_on_write_block(inode->i_sb);2875	if (reiserfs_transaction_running(inode->i_sb))2876		th = current->journal_info;2877	else2878		th = NULL;2879 2880	start = pos & (PAGE_SIZE - 1);2881	if (unlikely(copied < len)) {2882		if (!folio_test_uptodate(folio))2883			copied = 0;2884 2885		folio_zero_new_buffers(folio, start + copied, start + len);2886	}2887	flush_dcache_folio(folio);2888 2889	reiserfs_commit_page(inode, &folio->page, start, start + copied);2890 2891	/*2892	 * generic_commit_write does this for us, but does not update the2893	 * transaction tracking stuff when the size changes.  So, we have2894	 * to do the i_size updates here.2895	 */2896	if (pos + copied > inode->i_size) {2897		struct reiserfs_transaction_handle myth;2898		reiserfs_write_lock(inode->i_sb);2899		locked = true;2900		/*2901		 * If the file have grown beyond the border where it2902		 * can have a tail, unmark it as needing a tail2903		 * packing2904		 */2905		if ((have_large_tails(inode->i_sb)2906		     && inode->i_size > i_block_size(inode) * 4)2907		    || (have_small_tails(inode->i_sb)2908			&& inode->i_size > i_block_size(inode)))2909			REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;2910 2911		ret = journal_begin(&myth, inode->i_sb, 1);2912		if (ret)2913			goto journal_error;2914 2915		reiserfs_update_inode_transaction(inode);2916		inode->i_size = pos + copied;2917		/*2918		 * this will just nest into our transaction.  It's important2919		 * to use mark_inode_dirty so the inode gets pushed around on2920		 * the dirty lists, and so that O_SYNC works as expected2921		 */2922		mark_inode_dirty(inode);2923		reiserfs_update_sd(&myth, inode);2924		update_sd = 1;2925		ret = journal_end(&myth);2926		if (ret)2927			goto journal_error;2928	}2929	if (th) {2930		if (!locked) {2931			reiserfs_write_lock(inode->i_sb);2932			locked = true;2933		}2934		if (!update_sd)2935			mark_inode_dirty(inode);2936		ret = reiserfs_end_persistent_transaction(th);2937		if (ret)2938			goto out;2939	}2940 2941out:2942	if (locked)2943		reiserfs_write_unlock(inode->i_sb);2944	folio_unlock(folio);2945	folio_put(folio);2946 2947	if (pos + len > inode->i_size)2948		reiserfs_truncate_failed_write(inode);2949 2950	return ret == 0 ? copied : ret;2951 2952journal_error:2953	reiserfs_write_unlock(inode->i_sb);2954	locked = false;2955	if (th) {2956		if (!update_sd)2957			reiserfs_update_sd(th, inode);2958		ret = reiserfs_end_persistent_transaction(th);2959	}2960	goto out;2961}2962 2963int reiserfs_commit_write(struct file *f, struct page *page,2964			  unsigned from, unsigned to)2965{2966	struct inode *inode = page->mapping->host;2967	loff_t pos = ((loff_t) page->index << PAGE_SHIFT) + to;2968	int ret = 0;2969	int update_sd = 0;2970	struct reiserfs_transaction_handle *th = NULL;2971	int depth;2972 2973	depth = reiserfs_write_unlock_nested(inode->i_sb);2974	reiserfs_wait_on_write_block(inode->i_sb);2975	reiserfs_write_lock_nested(inode->i_sb, depth);2976 2977	if (reiserfs_transaction_running(inode->i_sb)) {2978		th = current->journal_info;2979	}2980	reiserfs_commit_page(inode, page, from, to);2981 2982	/*2983	 * generic_commit_write does this for us, but does not update the2984	 * transaction tracking stuff when the size changes.  So, we have2985	 * to do the i_size updates here.2986	 */2987	if (pos > inode->i_size) {2988		struct reiserfs_transaction_handle myth;2989		/*2990		 * If the file have grown beyond the border where it2991		 * can have a tail, unmark it as needing a tail2992		 * packing2993		 */2994		if ((have_large_tails(inode->i_sb)2995		     && inode->i_size > i_block_size(inode) * 4)2996		    || (have_small_tails(inode->i_sb)2997			&& inode->i_size > i_block_size(inode)))2998			REISERFS_I(inode)->i_flags &= ~i_pack_on_close_mask;2999 3000		ret = journal_begin(&myth, inode->i_sb, 1);3001		if (ret)3002			goto journal_error;3003 3004		reiserfs_update_inode_transaction(inode);3005		inode->i_size = pos;3006		/*3007		 * this will just nest into our transaction.  It's important3008		 * to use mark_inode_dirty so the inode gets pushed around3009		 * on the dirty lists, and so that O_SYNC works as expected3010		 */3011		mark_inode_dirty(inode);3012		reiserfs_update_sd(&myth, inode);3013		update_sd = 1;3014		ret = journal_end(&myth);3015		if (ret)3016			goto journal_error;3017	}3018	if (th) {3019		if (!update_sd)3020			mark_inode_dirty(inode);3021		ret = reiserfs_end_persistent_transaction(th);3022		if (ret)3023			goto out;3024	}3025 3026out:3027	return ret;3028 3029journal_error:3030	if (th) {3031		if (!update_sd)3032			reiserfs_update_sd(th, inode);3033		ret = reiserfs_end_persistent_transaction(th);3034	}3035 3036	return ret;3037}3038 3039void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode)3040{3041	if (reiserfs_attrs(inode->i_sb)) {3042		if (sd_attrs & REISERFS_SYNC_FL)3043			inode->i_flags |= S_SYNC;3044		else3045			inode->i_flags &= ~S_SYNC;3046		if (sd_attrs & REISERFS_IMMUTABLE_FL)3047			inode->i_flags |= S_IMMUTABLE;3048		else3049			inode->i_flags &= ~S_IMMUTABLE;3050		if (sd_attrs & REISERFS_APPEND_FL)3051			inode->i_flags |= S_APPEND;3052		else3053			inode->i_flags &= ~S_APPEND;3054		if (sd_attrs & REISERFS_NOATIME_FL)3055			inode->i_flags |= S_NOATIME;3056		else3057			inode->i_flags &= ~S_NOATIME;3058		if (sd_attrs & REISERFS_NOTAIL_FL)3059			REISERFS_I(inode)->i_flags |= i_nopack_mask;3060		else3061			REISERFS_I(inode)->i_flags &= ~i_nopack_mask;3062	}3063}3064 3065/*3066 * decide if this buffer needs to stay around for data logging or ordered3067 * write purposes3068 */3069static int invalidate_folio_can_drop(struct inode *inode, struct buffer_head *bh)3070{3071	int ret = 1;3072	struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);3073 3074	lock_buffer(bh);3075	spin_lock(&j->j_dirty_buffers_lock);3076	if (!buffer_mapped(bh)) {3077		goto free_jh;3078	}3079	/*3080	 * the page is locked, and the only places that log a data buffer3081	 * also lock the page.3082	 */3083	if (reiserfs_file_data_log(inode)) {3084		/*3085		 * very conservative, leave the buffer pinned if3086		 * anyone might need it.3087		 */3088		if (buffer_journaled(bh) || buffer_journal_dirty(bh)) {3089			ret = 0;3090		}3091	} else  if (buffer_dirty(bh)) {3092		struct reiserfs_journal_list *jl;3093		struct reiserfs_jh *jh = bh->b_private;3094 3095		/*3096		 * why is this safe?3097		 * reiserfs_setattr updates i_size in the on disk3098		 * stat data before allowing vmtruncate to be called.3099		 *3100		 * If buffer was put onto the ordered list for this3101		 * transaction, we know for sure either this transaction3102		 * or an older one already has updated i_size on disk,3103		 * and this ordered data won't be referenced in the file3104		 * if we crash.3105		 *3106		 * if the buffer was put onto the ordered list for an older3107		 * transaction, we need to leave it around3108		 */3109		if (jh && (jl = jh->jl)3110		    && jl != SB_JOURNAL(inode->i_sb)->j_current_jl)3111			ret = 0;3112	}3113free_jh:3114	if (ret && bh->b_private) {3115		reiserfs_free_jh(bh);3116	}3117	spin_unlock(&j->j_dirty_buffers_lock);3118	unlock_buffer(bh);3119	return ret;3120}3121 3122/* clm -- taken from fs/buffer.c:block_invalidate_folio */3123static void reiserfs_invalidate_folio(struct folio *folio, size_t offset,3124				    size_t length)3125{3126	struct buffer_head *head, *bh, *next;3127	struct inode *inode = folio->mapping->host;3128	unsigned int curr_off = 0;3129	unsigned int stop = offset + length;3130	int partial_page = (offset || length < folio_size(folio));3131	int ret = 1;3132 3133	BUG_ON(!folio_test_locked(folio));3134 3135	if (!partial_page)3136		folio_clear_checked(folio);3137 3138	head = folio_buffers(folio);3139	if (!head)3140		goto out;3141 3142	bh = head;3143	do {3144		unsigned int next_off = curr_off + bh->b_size;3145		next = bh->b_this_page;3146 3147		if (next_off > stop)3148			goto out;3149 3150		/*3151		 * is this block fully invalidated?3152		 */3153		if (offset <= curr_off) {3154			if (invalidate_folio_can_drop(inode, bh))3155				reiserfs_unmap_buffer(bh);3156			else3157				ret = 0;3158		}3159		curr_off = next_off;3160		bh = next;3161	} while (bh != head);3162 3163	/*3164	 * We release buffers only if the entire page is being invalidated.3165	 * The get_block cached value has been unconditionally invalidated,3166	 * so real IO is not possible anymore.3167	 */3168	if (!partial_page && ret) {3169		ret = filemap_release_folio(folio, 0);3170		/* maybe should BUG_ON(!ret); - neilb */3171	}3172out:3173	return;3174}3175 3176static bool reiserfs_dirty_folio(struct address_space *mapping,3177		struct folio *folio)3178{3179	if (reiserfs_file_data_log(mapping->host)) {3180		folio_set_checked(folio);3181		return filemap_dirty_folio(mapping, folio);3182	}3183	return block_dirty_folio(mapping, folio);3184}3185 3186/*3187 * Returns true if the folio's buffers were dropped.  The folio is locked.3188 *3189 * Takes j_dirty_buffers_lock to protect the b_assoc_buffers list_heads3190 * in the buffers at folio_buffers(folio).3191 *3192 * even in -o notail mode, we can't be sure an old mount without -o notail3193 * didn't create files with tails.3194 */3195static bool reiserfs_release_folio(struct folio *folio, gfp_t unused_gfp_flags)3196{3197	struct inode *inode = folio->mapping->host;3198	struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb);3199	struct buffer_head *head;3200	struct buffer_head *bh;3201	bool ret = true;3202 3203	WARN_ON(folio_test_checked(folio));3204	spin_lock(&j->j_dirty_buffers_lock);3205	head = folio_buffers(folio);3206	bh = head;3207	do {3208		if (bh->b_private) {3209			if (!buffer_dirty(bh) && !buffer_locked(bh)) {3210				reiserfs_free_jh(bh);3211			} else {3212				ret = false;3213				break;3214			}3215		}3216		bh = bh->b_this_page;3217	} while (bh != head);3218	if (ret)3219		ret = try_to_free_buffers(folio);3220	spin_unlock(&j->j_dirty_buffers_lock);3221	return ret;3222}3223 3224/*3225 * We thank Mingming Cao for helping us understand in great detail what3226 * to do in this section of the code.3227 */3228static ssize_t reiserfs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)3229{3230	struct file *file = iocb->ki_filp;3231	struct inode *inode = file->f_mapping->host;3232	size_t count = iov_iter_count(iter);3233	ssize_t ret;3234 3235	ret = blockdev_direct_IO(iocb, inode, iter,3236				 reiserfs_get_blocks_direct_io);3237 3238	/*3239	 * In case of error extending write may have instantiated a few3240	 * blocks outside i_size. Trim these off again.3241	 */3242	if (unlikely(iov_iter_rw(iter) == WRITE && ret < 0)) {3243		loff_t isize = i_size_read(inode);3244		loff_t end = iocb->ki_pos + count;3245 3246		if ((end > isize) && inode_newsize_ok(inode, isize) == 0) {3247			truncate_setsize(inode, isize);3248			reiserfs_vfs_truncate_file(inode);3249		}3250	}3251 3252	return ret;3253}3254 3255int reiserfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,3256		     struct iattr *attr)3257{3258	struct inode *inode = d_inode(dentry);3259	unsigned int ia_valid;3260	int error;3261 3262	error = setattr_prepare(&nop_mnt_idmap, dentry, attr);3263	if (error)3264		return error;3265 3266	/* must be turned off for recursive notify_change calls */3267	ia_valid = attr->ia_valid &= ~(ATTR_KILL_SUID|ATTR_KILL_SGID);3268 3269	if (is_quota_modification(&nop_mnt_idmap, inode, attr)) {3270		error = dquot_initialize(inode);3271		if (error)3272			return error;3273	}3274	reiserfs_write_lock(inode->i_sb);3275	if (attr->ia_valid & ATTR_SIZE) {3276		/*3277		 * version 2 items will be caught by the s_maxbytes check3278		 * done for us in vmtruncate3279		 */3280		if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5 &&3281		    attr->ia_size > MAX_NON_LFS) {3282			reiserfs_write_unlock(inode->i_sb);3283			error = -EFBIG;3284			goto out;3285		}3286 3287		inode_dio_wait(inode);3288 3289		/* fill in hole pointers in the expanding truncate case. */3290		if (attr->ia_size > inode->i_size) {3291			loff_t pos = attr->ia_size;3292 3293			if ((pos & (inode->i_sb->s_blocksize - 1)) == 0)3294				pos++;3295			error = generic_cont_expand_simple(inode, pos);3296			if (REISERFS_I(inode)->i_prealloc_count > 0) {3297				int err;3298				struct reiserfs_transaction_handle th;3299				/* we're changing at most 2 bitmaps, inode + super */3300				err = journal_begin(&th, inode->i_sb, 4);3301				if (!err) {3302					reiserfs_discard_prealloc(&th, inode);3303					err = journal_end(&th);3304				}3305				if (err)3306					error = err;3307			}3308			if (error) {3309				reiserfs_write_unlock(inode->i_sb);3310				goto out;3311			}3312			/*3313			 * file size is changed, ctime and mtime are3314			 * to be updated3315			 */3316			attr->ia_valid |= (ATTR_MTIME | ATTR_CTIME);3317		}3318	}3319	reiserfs_write_unlock(inode->i_sb);3320 3321	if ((((attr->ia_valid & ATTR_UID) && (from_kuid(&init_user_ns, attr->ia_uid) & ~0xffff)) ||3322	     ((attr->ia_valid & ATTR_GID) && (from_kgid(&init_user_ns, attr->ia_gid) & ~0xffff))) &&3323	    (get_inode_sd_version(inode) == STAT_DATA_V1)) {3324		/* stat data of format v3.5 has 16 bit uid and gid */3325		error = -EINVAL;3326		goto out;3327	}3328 3329	if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||3330	    (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {3331		struct reiserfs_transaction_handle th;3332		int jbegin_count =3333		    2 *3334		    (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) +3335		     REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) +3336		    2;3337 3338		error = reiserfs_chown_xattrs(inode, attr);3339 3340		if (error)3341			return error;3342 3343		/*3344		 * (user+group)*(old+new) structure - we count quota3345		 * info and , inode write (sb, inode)3346		 */3347		reiserfs_write_lock(inode->i_sb);3348		error = journal_begin(&th, inode->i_sb, jbegin_count);3349		reiserfs_write_unlock(inode->i_sb);3350		if (error)3351			goto out;3352		error = dquot_transfer(&nop_mnt_idmap, inode, attr);3353		reiserfs_write_lock(inode->i_sb);3354		if (error) {3355			journal_end(&th);3356			reiserfs_write_unlock(inode->i_sb);3357			goto out;3358		}3359 3360		/*3361		 * Update corresponding info in inode so that everything3362		 * is in one transaction3363		 */3364		if (attr->ia_valid & ATTR_UID)3365			inode->i_uid = attr->ia_uid;3366		if (attr->ia_valid & ATTR_GID)3367			inode->i_gid = attr->ia_gid;3368		mark_inode_dirty(inode);3369		error = journal_end(&th);3370		reiserfs_write_unlock(inode->i_sb);3371		if (error)3372			goto out;3373	}3374 3375	if ((attr->ia_valid & ATTR_SIZE) &&3376	    attr->ia_size != i_size_read(inode)) {3377		error = inode_newsize_ok(inode, attr->ia_size);3378		if (!error) {3379			/*3380			 * Could race against reiserfs_file_release3381			 * if called from NFS, so take tailpack mutex.3382			 */3383			mutex_lock(&REISERFS_I(inode)->tailpack);3384			truncate_setsize(inode, attr->ia_size);3385			reiserfs_truncate_file(inode, 1);3386			mutex_unlock(&REISERFS_I(inode)->tailpack);3387		}3388	}3389 3390	if (!error) {3391		setattr_copy(&nop_mnt_idmap, inode, attr);3392		mark_inode_dirty(inode);3393	}3394 3395	if (!error && reiserfs_posixacl(inode->i_sb)) {3396		if (attr->ia_valid & ATTR_MODE)3397			error = reiserfs_acl_chmod(dentry);3398	}3399 3400out:3401	return error;3402}3403 3404const struct address_space_operations reiserfs_address_space_operations = {3405	.writepages = reiserfs_writepages,3406	.read_folio = reiserfs_read_folio,3407	.readahead = reiserfs_readahead,3408	.release_folio = reiserfs_release_folio,3409	.invalidate_folio = reiserfs_invalidate_folio,3410	.write_begin = reiserfs_write_begin,3411	.write_end = reiserfs_write_end,3412	.bmap = reiserfs_aop_bmap,3413	.direct_IO = reiserfs_direct_IO,3414	.dirty_folio = reiserfs_dirty_folio,3415	.migrate_folio = buffer_migrate_folio,3416};3417