From 81dd5772b8fb665e33b62b190337d6de6603facb Mon Sep 17 00:00:00 2001 From: Christoph Lameter Date: Wed, 25 Jul 2007 22:25:04 -0700 Subject: [PATCH] Use page_cache_xxx in fs/reiserfs Use page_cache_xxx in fs/reiserfs Signed-off-by: Christoph Lameter --- fs/reiserfs/file.c | 83 ++++++++++++++++++++++------------------- fs/reiserfs/inode.c | 33 ++++++++++------ fs/reiserfs/ioctl.c | 2 +- fs/reiserfs/stree.c | 8 ++- fs/reiserfs/tail_conversion.c | 5 +- fs/reiserfs/xattr.c | 19 +++++---- 6 files changed, 84 insertions(+), 66 deletions(-) Index: linux-2.6/fs/reiserfs/file.c =================================================================== --- linux-2.6.orig/fs/reiserfs/file.c 2007-08-27 21:22:40.000000000 -0700 +++ linux-2.6/fs/reiserfs/file.c 2007-08-27 21:50:01.000000000 -0700 @@ -187,9 +187,11 @@ static int reiserfs_allocate_blocks_for_ int curr_block; // current block used to keep track of unmapped blocks. int i; // loop counter int itempos; // position in item - unsigned int from = (pos & (PAGE_CACHE_SIZE - 1)); // writing position in + struct address_space *mapping = prepared_pages[0]->mapping; + unsigned int from = page_cache_offset(mapping, pos); // writing position in // first page - unsigned int to = ((pos + write_bytes - 1) & (PAGE_CACHE_SIZE - 1)) + 1; /* last modified byte offset in last page */ + unsigned int to = page_cache_offset(mapping, pos + write_bytes - 1) + 1; + /* last modified byte offset in last page */ __u64 hole_size; // amount of blocks for a file hole, if it needed to be created. int modifying_this_item = 0; // Flag for items traversal code to keep track // of the fact that we already prepared @@ -731,19 +733,22 @@ static int reiserfs_copy_from_user_to_fi long page_fault = 0; // status of copy_from_user. int i; // loop counter. int offset; // offset in page + struct address_space *mapping = prepared_pages[0]->mapping; - for (i = 0, offset = (pos & (PAGE_CACHE_SIZE - 1)); i < num_pages; + for (i = 0, offset = page_cache_offset(mapping, pos); i < num_pages; i++, offset = 0) { - size_t count = min_t(size_t, PAGE_CACHE_SIZE - offset, write_bytes); // How much of bytes to write to this page + size_t count = min_t(size_t, page_cache_size(mapping) - offset, + write_bytes); // How much of bytes to write to this page struct page *page = prepared_pages[i]; // Current page we process. fault_in_pages_readable(buf, count); /* Copy data from userspace to the current page */ kmap(page); - page_fault = __copy_from_user(page_address(page) + offset, buf, count); // Copy the data. + page_fault = __copy_from_user(page_address(page) + offset, buf, count); + // Copy the data. /* Flush processor's dcache for this page */ - flush_dcache_page(page); + flush_mapping_page(page); kunmap(page); buf += count; write_bytes -= count; @@ -763,11 +768,12 @@ int reiserfs_commit_page(struct inode *i int partial = 0; unsigned blocksize; struct buffer_head *bh, *head; - unsigned long i_size_index = inode->i_size >> PAGE_CACHE_SHIFT; + unsigned long i_size_index = + page_cache_offset(inode->i_mapping, inode->i_size); int new; int logit = reiserfs_file_data_log(inode); struct super_block *s = inode->i_sb; - int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize; + int bh_per_page = page_cache_size(inode->i_mapping) / s->s_blocksize; struct reiserfs_transaction_handle th; int ret = 0; @@ -839,10 +845,11 @@ static int reiserfs_submit_file_region_f int offset; // Writing offset in page. int orig_write_bytes = write_bytes; int sd_update = 0; + struct address_space *mapping = inode->i_mapping; - for (i = 0, offset = (pos & (PAGE_CACHE_SIZE - 1)); i < num_pages; + for (i = 0, offset = page_cache_offset(mapping, pos); i < num_pages; i++, offset = 0) { - int count = min_t(int, PAGE_CACHE_SIZE - offset, write_bytes); // How much of bytes to write to this page + int count = min_t(int, page_cache_size(mapping) - offset, write_bytes); // How much of bytes to write to this page struct page *page = prepared_pages[i]; // Current page we process. status = @@ -985,12 +992,12 @@ static int reiserfs_prepare_file_region_ ) { int res = 0; // Return values of different functions we call. - unsigned long index = pos >> PAGE_CACHE_SHIFT; // Offset in file in pages. - int from = (pos & (PAGE_CACHE_SIZE - 1)); // Writing offset in first page - int to = ((pos + write_bytes - 1) & (PAGE_CACHE_SIZE - 1)) + 1; + struct address_space *mapping = inode->i_mapping; // Pages are mapped here. + unsigned long index = page_cache_index(mapping, pos); // Offset in file in pages. + int from = page_cache_offset(mapping, pos); // Writing offset in first page + int to = page_cache_offset(mapping, pos + write_bytes - 1) + 1; /* offset of last modified byte in last page */ - struct address_space *mapping = inode->i_mapping; // Pages are mapped here. int i; // Simple counter int blocks = 0; /* Return value (blocks that should be allocated) */ struct buffer_head *bh, *head; // Current bufferhead and first bufferhead @@ -1041,30 +1048,31 @@ static int reiserfs_prepare_file_region_ /* These are full-overwritten pages so we count all the blocks in these pages are counted as needed to be allocated */ blocks = - (num_pages - 2) << (PAGE_CACHE_SHIFT - inode->i_blkbits); + (num_pages - 2) << (page_cache_shift(mapping) - inode->i_blkbits); /* count blocks needed for first page (possibly partially written) */ - blocks += ((PAGE_CACHE_SIZE - from) >> inode->i_blkbits) + !!(from & (inode->i_sb->s_blocksize - 1)); /* roundup */ + blocks += ((page_cache_size(mapping) - from) >> inode->i_blkbits) + + !!(from & (inode->i_sb->s_blocksize - 1)); /* roundup */ /* Now we account for last page. If last page == first page (we overwrite only one page), we substract all the blocks past the last writing position in a page out of already calculated number of blocks */ - blocks += ((num_pages > 1) << (PAGE_CACHE_SHIFT - inode->i_blkbits)) - - ((PAGE_CACHE_SIZE - to) >> inode->i_blkbits); + blocks += ((num_pages > 1) << (page_cache_shift(mapping) - inode->i_blkbits)) - + ((page_cache_size(mapping) - to) >> inode->i_blkbits); /* Note how we do not roundup here since partial blocks still should be allocated */ /* Now if all the write area lies past the file end, no point in maping blocks, since there is none, so we just zero out remaining parts of first and last pages in write area (if needed) */ - if ((pos & ~((loff_t) PAGE_CACHE_SIZE - 1)) > inode->i_size) { + if (page_cache_offset(mapping, pos) > inode->i_size) { if (from != 0) /* First page needs to be partially zeroed */ zero_user(prepared_pages[0], 0, from); - if (to != PAGE_CACHE_SIZE) /* Last page needs to be partially zeroed */ + if (to != page_cache_size(mapping)) /* Last page needs to be partially zeroed */ zero_user_segment(prepared_pages[num_pages-1], to, - PAGE_CACHE_SIZE); + page_cache_size(mapping)); /* Since all blocks are new - use already calculated value */ return blocks; @@ -1201,8 +1209,8 @@ static int reiserfs_prepare_file_region_ /* Last page, see if it is not uptodate, or if the last page is past the end of the file. */ if (!PageUptodate(prepared_pages[num_pages - 1]) || - ((pos + write_bytes) >> PAGE_CACHE_SHIFT) > - (inode->i_size >> PAGE_CACHE_SHIFT)) { + page_cache_index(mapping, pos + write_bytes) > + page_cache_index(mapping, inode->i_size)) { head = page_buffers(prepared_pages[num_pages - 1]); /* for each buffer in page */ @@ -1292,6 +1300,7 @@ static ssize_t reiserfs_file_write(struc locked pages in array for now */ struct page *prepared_pages[REISERFS_WRITE_PAGES_AT_A_TIME]; struct reiserfs_transaction_handle th; + struct address_space *mapping = inode->i_mapping; th.t_trans_id = 0; /* If a filesystem is converted from 3.5 to 3.6, we'll have v3.5 items @@ -1358,10 +1367,10 @@ static ssize_t reiserfs_file_write(struc size_t blocks_to_allocate; /* how much blocks we need to allocate for this iteration */ /* (pos & (PAGE_CACHE_SIZE-1)) is an idiom for offset into a page of pos */ - num_pages = !!((pos + count) & (PAGE_CACHE_SIZE - 1)) + /* round up partial + num_pages = !!(page_cache_offset(mapping, pos + count)) + /* round up partial pages */ ((count + - (pos & (PAGE_CACHE_SIZE - 1))) >> PAGE_CACHE_SHIFT); + (pos & (page_cache_size(mapping) - 1))) >> page_cache_shift(mapping)); /* convert size to amount of pages */ reiserfs_write_lock(inode->i_sb); @@ -1374,8 +1383,8 @@ static ssize_t reiserfs_file_write(struc min_t(size_t, REISERFS_WRITE_PAGES_AT_A_TIME, reiserfs_can_fit_pages(inode->i_sb)); /* Also we should not forget to set size in bytes accordingly */ - write_bytes = (num_pages << PAGE_CACHE_SHIFT) - - (pos & (PAGE_CACHE_SIZE - 1)); + write_bytes = (num_pages << page_cache_shift(mapping)) - + page_cache_offset(mapping, pos); /* If position is not on the start of the page, we need to substract the offset @@ -1387,7 +1396,7 @@ static ssize_t reiserfs_file_write(struc we still have the space to write the blocks to */ reiserfs_claim_blocks_to_be_allocated(inode->i_sb, num_pages << - (PAGE_CACHE_SHIFT - + (page_cache_shift(mapping) - inode->i_blkbits)); reiserfs_write_unlock(inode->i_sb); @@ -1412,7 +1421,7 @@ static ssize_t reiserfs_file_write(struc // No blocks were claimed before, so do it now. reiserfs_claim_blocks_to_be_allocated(inode->i_sb, 1 << - (PAGE_CACHE_SHIFT + (page_cache_shift(mapping) - inode-> i_blkbits)); @@ -1429,7 +1438,7 @@ static ssize_t reiserfs_file_write(struc if (res < 0) { reiserfs_release_claimed_blocks(inode->i_sb, num_pages << - (PAGE_CACHE_SHIFT - + (page_cache_shift(mapping) - inode->i_blkbits)); break; } @@ -1439,7 +1448,7 @@ static ssize_t reiserfs_file_write(struc /* First we correct our estimate of how many blocks we need */ reiserfs_release_claimed_blocks(inode->i_sb, (num_pages << - (PAGE_CACHE_SHIFT - + (page_cache_shift(mapping) - inode->i_sb-> s_blocksize_bits)) - blocks_to_allocate); Index: linux-2.6/fs/reiserfs/inode.c =================================================================== --- linux-2.6.orig/fs/reiserfs/inode.c 2007-08-27 21:22:40.000000000 -0700 +++ linux-2.6/fs/reiserfs/inode.c 2007-08-27 21:22:40.000000000 -0700 @@ -336,7 +336,8 @@ static int _get_block_create_0(struct in goto finished; } // read file tail into part of page - offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1); + offset = page_cache_offset(inode->i_mapping, + cpu_key_k_offset(&key) - 1); fs_gen = get_generation(inode->i_sb); copy_item_head(&tmp_ih, ih); @@ -522,10 +523,10 @@ static int convert_tail_for_hole(struct return -EIO; /* always try to read until the end of the block */ - tail_start = tail_offset & (PAGE_CACHE_SIZE - 1); + tail_start = page_cache_offset(inode->i_mapping, tail_offset); tail_end = (tail_start | (bh_result->b_size - 1)) + 1; - index = tail_offset >> PAGE_CACHE_SHIFT; + index = page_cache_index(inode->i_mapping, tail_offset); /* hole_page can be zero in case of direct_io, we are sure that we cannot get here if we write with O_DIRECT into tail page */ @@ -2007,11 +2008,13 @@ static int grab_tail_page(struct inode * /* we want the page with the last byte in the file, ** not the page that will hold the next byte for appending */ - unsigned long index = (p_s_inode->i_size - 1) >> PAGE_CACHE_SHIFT; + unsigned long index = page_cache_index(p_s_inode->i_mapping, + p_s_inode->i_size - 1); unsigned long pos = 0; unsigned long start = 0; unsigned long blocksize = p_s_inode->i_sb->s_blocksize; - unsigned long offset = (p_s_inode->i_size) & (PAGE_CACHE_SIZE - 1); + unsigned long offset = page_cache_index(p_s_inode->i_mapping, + p_s_inode->i_size); struct buffer_head *bh; struct buffer_head *head; struct page *page; @@ -2083,7 +2086,8 @@ int reiserfs_truncate_file(struct inode { struct reiserfs_transaction_handle th; /* we want the offset for the first byte after the end of the file */ - unsigned long offset = p_s_inode->i_size & (PAGE_CACHE_SIZE - 1); + unsigned long offset = page_cache_offset(p_s_inode->i_mapping, + p_s_inode->i_size); unsigned blocksize = p_s_inode->i_sb->s_blocksize; unsigned length; struct page *page = NULL; @@ -2232,7 +2236,7 @@ static int map_block_for_writepage(struc } else if (is_direct_le_ih(ih)) { char *p; p = page_address(bh_result->b_page); - p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1); + p += page_cache_offset(inode->i_mapping, byte_offset - 1); copy_size = ih_item_len(ih) - pos_in_item; fs_gen = get_generation(inode->i_sb); @@ -2331,7 +2335,8 @@ static int reiserfs_write_full_page(stru struct writeback_control *wbc) { struct inode *inode = page->mapping->host; - unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT; + unsigned long end_index = page_cache_index(inode->i_mapping, + inode->i_size); int error = 0; unsigned long block; sector_t last_block; @@ -2341,7 +2346,7 @@ static int reiserfs_write_full_page(stru int checked = PageChecked(page); struct reiserfs_transaction_handle th; struct super_block *s = inode->i_sb; - int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize; + int bh_per_page = page_cache_size(inode->i_mapping) / s->s_blocksize; th.t_trans_id = 0; /* no logging allowed when nonblocking or from PF_MEMALLOC */ @@ -2368,16 +2373,18 @@ static int reiserfs_write_full_page(stru if (page->index >= end_index) { unsigned last_offset; - last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1); + last_offset = page_cache_offset(inode->i_mapping, inode->i_size); /* no file contents in this page */ if (page->index >= end_index + 1 || !last_offset) { unlock_page(page); return 0; } - zero_user_segment(page, last_offset, PAGE_CACHE_SIZE); + zero_user_segment(page, last_offset, + page_cache_size(inode->i_mapping)); } bh = head; - block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits); + block = page->index << (page_cache_shift(inode->i_mapping) + - s->s_blocksize_bits); last_block = (i_size_read(inode) - 1) >> inode->i_blkbits; /* first map all the buffers, logging any direct items we find */ do { @@ -2608,7 +2615,7 @@ static int reiserfs_commit_write(struct unsigned from, unsigned to) { struct inode *inode = page->mapping->host; - loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to; + loff_t pos = page_cache_pos(page->mapping, page->index, to); int ret = 0; int update_sd = 0; struct reiserfs_transaction_handle *th = NULL; Index: linux-2.6/fs/reiserfs/ioctl.c =================================================================== --- linux-2.6.orig/fs/reiserfs/ioctl.c 2007-08-27 21:22:36.000000000 -0700 +++ linux-2.6/fs/reiserfs/ioctl.c 2007-08-27 21:22:40.000000000 -0700 @@ -168,8 +168,8 @@ static int reiserfs_unpack(struct inode ** reiserfs_prepare_write on that page. This will force a ** reiserfs_get_block to unpack the tail for us. */ - index = inode->i_size >> PAGE_CACHE_SHIFT; mapping = inode->i_mapping; + index = page_cache_index(mapping, inode->i_size); page = grab_cache_page(mapping, index); retval = -ENOMEM; if (!page) { Index: linux-2.6/fs/reiserfs/stree.c =================================================================== --- linux-2.6.orig/fs/reiserfs/stree.c 2007-08-27 21:22:36.000000000 -0700 +++ linux-2.6/fs/reiserfs/stree.c 2007-08-27 21:22:40.000000000 -0700 @@ -1283,7 +1283,8 @@ int reiserfs_delete_item(struct reiserfs */ data = kmap_atomic(p_s_un_bh->b_page, KM_USER0); - off = ((le_ih_k_offset(&s_ih) - 1) & (PAGE_CACHE_SIZE - 1)); + off = page_cache_offset(p_s_inode->i_mapping, + le_ih_k_offset(&s_ih) - 1); memcpy(data + off, B_I_PITEM(PATH_PLAST_BUFFER(p_s_path), &s_ih), n_ret_value); @@ -1439,7 +1440,7 @@ static void unmap_buffers(struct page *p if (page) { if (page_has_buffers(page)) { - tail_index = pos & (PAGE_CACHE_SIZE - 1); + tail_index = page_cache_offset(page_mapping(page), pos); cur_index = 0; head = page_buffers(page); bh = head; @@ -1459,7 +1460,8 @@ static void unmap_buffers(struct page *p bh = next; } while (bh != head); if (PAGE_SIZE == bh->b_size) { - cancel_dirty_page(page, PAGE_CACHE_SIZE); + cancel_dirty_page(page, + page_cache_size(page_mapping(page))); } } } Index: linux-2.6/fs/reiserfs/tail_conversion.c =================================================================== --- linux-2.6.orig/fs/reiserfs/tail_conversion.c 2007-08-27 21:22:36.000000000 -0700 +++ linux-2.6/fs/reiserfs/tail_conversion.c 2007-08-27 21:22:40.000000000 -0700 @@ -128,7 +128,8 @@ int direct2indirect(struct reiserfs_tran */ if (up_to_date_bh) { unsigned pgoff = - (tail_offset + total_tail - 1) & (PAGE_CACHE_SIZE - 1); + page_cache_offset(inode->i_mapping, + tail_offset + total_tail - 1); char *kaddr = kmap_atomic(up_to_date_bh->b_page, KM_USER0); memset(kaddr + pgoff, 0, n_blk_size - total_tail); kunmap_atomic(kaddr, KM_USER0); @@ -238,7 +239,7 @@ int indirect2direct(struct reiserfs_tran ** the page was locked and this part of the page was up to date when ** indirect2direct was called, so we know the bytes are still valid */ - tail = tail + (pos & (PAGE_CACHE_SIZE - 1)); + tail = tail + page_cache_offset(p_s_inode->i_mapping, pos); PATH_LAST_POSITION(p_s_path)++; Index: linux-2.6/fs/reiserfs/xattr.c =================================================================== --- linux-2.6.orig/fs/reiserfs/xattr.c 2007-08-27 21:22:36.000000000 -0700 +++ linux-2.6/fs/reiserfs/xattr.c 2007-08-27 21:56:54.000000000 -0700 @@ -487,13 +487,13 @@ reiserfs_xattr_set(struct inode *inode, while (buffer_pos < buffer_size || buffer_pos == 0) { size_t chunk; size_t skip = 0; - size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1)); - if (buffer_size - buffer_pos > PAGE_CACHE_SIZE) - chunk = PAGE_CACHE_SIZE; + size_t page_offset = page_cache_offset(mapping, file_pos); + if (buffer_size - buffer_pos > page_cache_size(mapping)) + chunk = page_cache_size(mapping); else chunk = buffer_size - buffer_pos; - page = reiserfs_get_page(xinode, file_pos >> PAGE_CACHE_SHIFT); + page = reiserfs_get_page(xinode, page_cache_index(mapping, file_pos)); if (IS_ERR(page)) { err = PTR_ERR(page); goto out_filp; @@ -505,8 +505,8 @@ reiserfs_xattr_set(struct inode *inode, if (file_pos == 0) { struct reiserfs_xattr_header *rxh; skip = file_pos = sizeof(struct reiserfs_xattr_header); - if (chunk + skip > PAGE_CACHE_SIZE) - chunk = PAGE_CACHE_SIZE - skip; + if (chunk + skip > page_cache_size(mapping)) + chunk = page_cache_size(mapping) - skip; rxh = (struct reiserfs_xattr_header *)data; rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC); rxh->h_hash = cpu_to_le32(xahash); @@ -597,12 +597,13 @@ reiserfs_xattr_get(const struct inode *i size_t chunk; char *data; size_t skip = 0; - if (isize - file_pos > PAGE_CACHE_SIZE) - chunk = PAGE_CACHE_SIZE; + if (isize - file_pos > page_cache_size(xinode->i_mapping)) + chunk = page_cache_size(xinode->i_mapping); else chunk = isize - file_pos; - page = reiserfs_get_page(xinode, file_pos >> PAGE_CACHE_SHIFT); + page = reiserfs_get_page(xinode, + page_cache_index(xinode->i_mapping, file_pos)); if (IS_ERR(page)) { err = PTR_ERR(page); goto out_dput;