lael-labs/linux

fs/buffer.c+5−12

 }
 EXPORT_SYMBOL(page_zero_new_buffers);
-int block_prepare_write(struct page *page, unsigned from, unsigned to,
+int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 		get_block_t *get_block)
 {
+	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+	unsigned to = from + len;
 	struct inode *inode = page->mapping->host;
 	unsigned block_start, block_end;
 	sector_t block;
 	}
 	return err;
 }
-EXPORT_SYMBOL(block_prepare_write);
+EXPORT_SYMBOL(__block_write_begin);
 static int __block_commit_write(struct inode *inode, struct page *page,
 		unsigned from, unsigned to)
 	return 0;
 }
-int __block_write_begin(struct page *page, loff_t pos, unsigned len,
-		get_block_t *get_block)
-{
-	unsigned start = pos & (PAGE_CACHE_SIZE - 1);
-	return block_prepare_write(page, start, start + len, get_block);
-}
-EXPORT_SYMBOL(__block_write_begin);
 /*
  * block_write_begin takes care of the basic task of block allocation and
  * bringing partial write blocks uptodate first.
 	else
 		end = PAGE_CACHE_SIZE;
-	ret = block_prepare_write(page, 0, end, get_block);
+	ret = __block_write_begin(page, 0, end, get_block);
 	if (!ret)
 		ret = block_commit_write(page, 0, end);

fs/ext3/inode.c+2−2

@@ -1696,8 +1696,8 @@ static int ext3_journalled_writepage(struct page *page, · 1695 unmodified lines
1696	* doesn't seem much point in redirtying the page here.	1696	* doesn't seem much point in redirtying the page here.
1697	*/	1697	*/
1698	ClearPageChecked(page);	1698	ClearPageChecked(page);
1699	ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,	1699	ret = __block_write_begin(page, 0, PAGE_CACHE_SIZE,
1700	ext3_get_block);	1700	ext3_get_block);
1701	if (ret != 0) {	1701	if (ret != 0) {
1702	ext3_journal_stop(handle);	1702	ext3_journal_stop(handle);
1703	goto out_unlock;	1703	goto out_unlock;

fs/ext4/inode.c+5−6

 	if (!buffer_mapped(bh) || buffer_freed(bh))
 		return 0;
 	/*
-	 * __block_prepare_write() could have dirtied some buffers. Clean
+	 * __block_write_begin() could have dirtied some buffers. Clean
 	 * the dirty bit as jbd2_journal_get_write_access() could complain
 	 * otherwise about fs integrity issues. Setting of the dirty bit
-	 * by __block_prepare_write() isn't a real problem here as we clear
+	 * by __block_write_begin() isn't a real problem here as we clear
 	 * the bit before releasing a page lock and thus writeback cannot
 	 * ever write the buffer.
 	 */
 		if (buffer_delay(bh))
 			return 0; /* Not sure this could or should happen */
 		/*
-		 * XXX: __block_prepare_write() unmaps passed block,
+		 * XXX: __block_write_begin() unmaps passed block, is it OK?
-		 * is it OK?
 		 */
 		ret = ext4_da_reserve_space(inode, iblock);
 		if (ret)
 /*
  * This function is used as a standard get_block_t calback function
  * when there is no desire to allocate any blocks.  It is used as a
- * callback function for block_prepare_write() and block_write_full_page().
+ * callback function for block_write_begin() and block_write_full_page().
  * These functions should only try to map a single block at a time.
  *
  * Since this function doesn't do block allocations even if the caller
 		 * all are mapped and non delay. We don't want to
 		 * do block allocation here.
 		 */
-		ret = block_prepare_write(page, 0, len,
+		ret = __block_write_begin(page, 0, len,
 					  noalloc_get_block_write);
 		if (!ret) {
 			page_bufs = page_buffers(page);

fs/gfs2/aops.c+1−2

 	struct gfs2_alloc *al = NULL;
 	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
-	unsigned to = from + len;
 	struct page *page;
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
 	}
 prepare_write:
-	error = block_prepare_write(page, from, to, gfs2_block_map);
+	error = __block_write_begin(page, from, len, gfs2_block_map);
 out:
 	if (error == 0)
 		return 0;

fs/gfs2/ops_inode.c+3−3

@@ -1294,7 +1294,7 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to) · 1293 unmodified lines
1294	int error;	1294	int error;
1295		1295
1296	if (!page_has_buffers(page)) {	1296	if (!page_has_buffers(page)) {
1297	error = block_prepare_write(page, from, to, gfs2_block_map);	1297	error = __block_write_begin(page, from, to - from, gfs2_block_map);
1298	if (unlikely(error))	1298	if (unlikely(error))
1299	return error;	1299	return error;
1300		1300
@@ -1313,7 +1313,7 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to) · 12 unmodified lines
1313	next += bh->b_size;	1313	next += bh->b_size;
1314	if (buffer_mapped(bh)) {	1314	if (buffer_mapped(bh)) {
1315	if (end) {	1315	if (end) {
1316	error = block_prepare_write(page, start, end,	1316	error = __block_write_begin(page, start, end - start,
1317	gfs2_block_map);	1317	gfs2_block_map);
1318	if (unlikely(error))	1318	if (unlikely(error))
1319	return error;	1319	return error;
@@ -1328,7 +1328,7 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to) · 8 unmodified lines
1328	} while (next < to);	1328	} while (next < to);
1329		1329
1330	if (end) {	1330	if (end) {
1331	error = block_prepare_write(page, start, end, gfs2_block_map);	1331	error = __block_write_begin(page, start, end - start, gfs2_block_map);
1332	if (unlikely(error))	1332	if (unlikely(error))
1333	return error;	1333	return error;
1334	empty_write_end(page, start, end);	1334	empty_write_end(page, start, end);

fs/ocfs2/aops.c+2−17

 	 * ocfs2 never allocates in this function - the only time we
 	 * need to use BH_New is when we're extending i_size on a file
 	 * system which doesn't support holes, in which case BH_New
-	 * allows block_prepare_write() to zero.
+	 * allows __block_write_begin() to zero.
 	 *
 	 * If we see this on a sparse file system, then a truncate has
 	 * raced us and removed the cluster. In this case, we clear
 	return ret;
 }
-/*
- * This is called from ocfs2_write_zero_page() which has handled it's
- * own cluster locking and has ensured allocation exists for those
- * blocks to be written.
- */
-int ocfs2_prepare_write_nolock(struct inode *inode, struct page *page,
-			       unsigned from, unsigned to)
-{
-	int ret;
-	ret = block_prepare_write(page, from, to, ocfs2_get_block);
-	return ret;
-}
 /* Taken from ext3. We don't necessarily need the full blown
  * functionality yet, but IMHO it's better to cut and paste the whole
  * thing so we can avoid introducing our own bugs (and easily pick up
 }
 /*
- * Some of this taken from block_prepare_write(). We already have our
+ * Some of this taken from __block_write_begin(). We already have our
  * mapping by now though, and the entire write will be allocating or
  * it won't, so not much need to use BH_New.
  *

fs/ocfs2/aops.h+0−3

@@ -22,9 +22,6 @@ · 21 unmodified lines
22	#ifndef OCFS2_AOPS_H	22	#ifndef OCFS2_AOPS_H
23	#define OCFS2_AOPS_H	23	#define OCFS2_AOPS_H
24		24
25	int ocfs2_prepare_write_nolock(struct inode inode, struct page page,
26	unsigned from, unsigned to);
27
28	handle_t ocfs2_start_walk_page_trans(struct inode inode,	25	handle_t ocfs2_start_walk_page_trans(struct inode inode,
29	struct page *page,	26	struct page *page,
30	unsigned from,	27	unsigned from,

fs/ocfs2/file.c+4−5

 		block_end = block_start + (1 << inode->i_blkbits);
 		/*
-		 * block_start is block-aligned.  Bump it by one to
+		 * block_start is block-aligned.  Bump it by one to force
-		 * force ocfs2_{prepare,commit}_write() to zero the
+		 * __block_write_begin and block_commit_write to zero the
 		 * whole block.
 		 */
-		ret = ocfs2_prepare_write_nolock(inode, page,
+		ret = __block_write_begin(page, block_start + 1, 0,
-						 block_start + 1,
+					  ocfs2_get_block);
-						 block_start + 1);
 		if (ret < 0) {
 			mlog_errno(ret);
 			goto out_unlock;

fs/reiserfs/inode.c+11−13

 int reiserfs_commit_write(struct file *f, struct page *page,
 			  unsigned from, unsigned to);
-int reiserfs_prepare_write(struct file *f, struct page *page,
-			   unsigned from, unsigned to);
 void reiserfs_evict_inode(struct inode *inode)
 {
 ** but tail is still sitting in a direct item, and we can't write to
 ** it.  So, look through this page, and check all the mapped buffers
 ** to make sure they have valid block numbers.  Any that don't need
-** to be unmapped, so that block_prepare_write will correctly call
+** to be unmapped, so that __block_write_begin will correctly call
 ** reiserfs_get_block to convert the tail into an unformatted node
 */
 static inline void fix_tail_page_for_writing(struct page *page)
 }
 /* special version of get_block that is only used by grab_tail_page right
-** now.  It is sent to block_prepare_write, and when you try to get a
+** now.  It is sent to __block_write_begin, and when you try to get a
 ** block past the end of the file (or a block from a hole) it returns
-** -ENOENT instead of a valid buffer.  block_prepare_write expects to
+** -ENOENT instead of a valid buffer.  __block_write_begin expects to
 ** be able to do i/o on the buffers returned, unless an error value
 ** is also returned.
 **
-** So, this allows block_prepare_write to be used for reading a single block
+** So, this allows __block_write_begin to be used for reading a single block
 ** in a page.  Where it does not produce a valid page for holes, or past the
 ** end of the file.  This turns out to be exactly what we need for reading
 ** tails for conversion.
 	 **
 	 ** We must fix the tail page for writing because it might have buffers
 	 ** that are mapped, but have a block number of 0.  This indicates tail
-	 ** data that has been read directly into the page, and block_prepare_write
+	 ** data that has been read directly into the page, and
-	 ** won't trigger a get_block in this case.
+	 ** __block_write_begin won't trigger a get_block in this case.
 	 */
 	fix_tail_page_for_writing(tail_page);
-	retval = reiserfs_prepare_write(NULL, tail_page, tail_start, tail_end);
+	retval = __reiserfs_write_begin(tail_page, tail_start,
+				      tail_end - tail_start);
 	if (retval)
 		goto unlock;
 	/* start within the page of the last block in the file */
 	start = (offset / blocksize) * blocksize;
-	error = block_prepare_write(page, start, offset,
+	error = __block_write_begin(page, start, offset - start,
 				    reiserfs_get_block_create_0);
 	if (error)
 		goto unlock;
 	return ret;
 }
-int reiserfs_prepare_write(struct file *f, struct page *page,
+int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len)
-			   unsigned from, unsigned to)
 {
 	struct inode *inode = page->mapping->host;
 	int ret;
 		th->t_refcount++;
 	}
-	ret = block_prepare_write(page, from, to, reiserfs_get_block);
+	ret = __block_write_begin(page, from, len, reiserfs_get_block);
 	if (ret && reiserfs_transaction_running(inode->i_sb)) {
 		struct reiserfs_transaction_handle *th = current->journal_info;
 		/* this gets a little ugly.  If reiserfs_get_block returned an

fs/reiserfs/ioctl.c+2−4

 int reiserfs_commit_write(struct file *f, struct page *page,
 			  unsigned from, unsigned to);
-int reiserfs_prepare_write(struct file *f, struct page *page,
-			   unsigned from, unsigned to);
 /*
 ** reiserfs_unpack
 ** Function try to convert tail from direct item into indirect.
 	}
 	/* we unpack by finding the page with the tail, and calling
-	 ** reiserfs_prepare_write on that page.  This will force a
+	 ** __reiserfs_write_begin on that page.  This will force a
 	 ** reiserfs_get_block to unpack the tail for us.
 	 */
 	index = inode->i_size >> PAGE_CACHE_SHIFT;
 	if (!page) {
 		goto out;
 	}
-	retval = reiserfs_prepare_write(NULL, page, write_from, write_from);
+	retval = __reiserfs_write_begin(page, write_from, 0);
 	if (retval)
 		goto out_unlock;

fs/reiserfs/xattr.c+1−4

 int reiserfs_commit_write(struct file *f, struct page *page,
 			  unsigned from, unsigned to);
-int reiserfs_prepare_write(struct file *f, struct page *page,
-			   unsigned from, unsigned to);
 static void update_ctime(struct inode *inode)
 {
 			rxh->h_hash = cpu_to_le32(xahash);
 		}
-		err = reiserfs_prepare_write(NULL, page, page_offset,
+		err = __reiserfs_write_begin(page, page_offset, chunk + skip);
-					    page_offset + chunk + skip);
 		if (!err) {
 			if (buffer)
 				memcpy(data + skip, buffer + buffer_pos, chunk);

fs/xfs/linux-2.6/xfs_super.c+1−1

@@ -576,7 +576,7 @@ xfs_max_file_offset( · 575 unmodified lines
576		576
577	/* Figure out maximum filesize, on Linux this can depend on	577	/* Figure out maximum filesize, on Linux this can depend on
578	* the filesystem blocksize (on 32 bit platforms).	578	* the filesystem blocksize (on 32 bit platforms).
579	* __block_prepare_write does this in an [unsigned] long...	579	* __block_write_begin does this in an [unsigned] long...
580	* page->index << (PAGE_CACHE_SHIFT - bbits)	580	* page->index << (PAGE_CACHE_SHIFT - bbits)
581	* So, for page sized blocks (4K on 32 bit platforms),	581	* So, for page sized blocks (4K on 32 bit platforms),
582	* this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is	582	* this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is

include/linux/buffer_head.h+0−1

@@ -212,7 +212,6 @@ int generic_write_end(struct file , struct address_space , · 211 unmodified lines
212	loff_t, unsigned, unsigned,	212	loff_t, unsigned, unsigned,
213	struct page , void );	213	struct page , void );
214	void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);	214	void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
215	int block_prepare_write(struct page, unsigned, unsigned, get_block_t);
216	int cont_write_begin(struct file , struct address_space , loff_t,	215	int cont_write_begin(struct file , struct address_space , loff_t,
217	unsigned, unsigned, struct page , void ,	216	unsigned, unsigned, struct page , void ,
218	get_block_t , loff_t );	217	get_block_t , loff_t );

include/linux/reiserfs_fs.h+2−0

@@ -2072,6 +2072,8 @@ void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode); · 2071 unmodified lines
2072	void i_attrs_to_sd_attrs(struct inode inode, __u16 sd_attrs);	2072	void i_attrs_to_sd_attrs(struct inode inode, __u16 sd_attrs);
2073	int reiserfs_setattr(struct dentry dentry, struct iattr attr);	2073	int reiserfs_setattr(struct dentry dentry, struct iattr attr);
2074		2074
		2075	int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len);
		2076
2075	/* namei.c */	2077	/* namei.c */
2076	void set_de_name_and_namelen(struct reiserfs_dir_entry *de);	2078	void set_de_name_and_namelen(struct reiserfs_dir_entry *de);
2077	int search_by_entry_key(struct super_block sb, const struct cpu_key key,	2079	int search_by_entry_key(struct super_block sb, const struct cpu_key key,