mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros

[linux-block.git] / fs / isofs / compress.c

diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index f311bf084015fd1450a859ebb31e0200ccd20ff3..2e4e834d1a9871377137a1735f7f28548b965304 100644 (file)
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -26,7 +26,7 @@
 #include "zisofs.h"
 
 /* This should probably be global. */
-static char zisofs_sink_page[PAGE_CACHE_SIZE];
+static char zisofs_sink_page[PAGE_SIZE];
 
 /*
  * This contains the zlib memory allocation and the mutex for the
@@ -70,11 +70,11 @@ static loff_t zisofs_uncompress_block(struct inode *inode, loff_t block_start,
                for ( i = 0 ; i < pcount ; i++ ) {
                        if (!pages[i])
                                continue;
-                       memset(page_address(pages[i]), 0, PAGE_CACHE_SIZE);
+                       memset(page_address(pages[i]), 0, PAGE_SIZE);
                        flush_dcache_page(pages[i]);
                        SetPageUptodate(pages[i]);
                }
-               return ((loff_t)pcount) << PAGE_CACHE_SHIFT;
+               return ((loff_t)pcount) << PAGE_SHIFT;
        }
 
        /* Because zlib is not thread-safe, do all the I/O at the top. */
@@ -121,11 +121,11 @@ static loff_t zisofs_uncompress_block(struct inode *inode, loff_t block_start,
                        if (pages[curpage]) {
                                stream.next_out = page_address(pages[curpage])
                                                + poffset;
-                               stream.avail_out = PAGE_CACHE_SIZE - poffset;
+                               stream.avail_out = PAGE_SIZE - poffset;
                                poffset = 0;
                        } else {
                                stream.next_out = (void *)&zisofs_sink_page;
-                               stream.avail_out = PAGE_CACHE_SIZE;
+                               stream.avail_out = PAGE_SIZE;
                        }
                }
                if (!stream.avail_in) {
@@ -220,14 +220,14 @@ static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
         * pages with the data we have anyway...
         */
        start_off = page_offset(pages[full_page]);
-       end_off = min_t(loff_t, start_off + PAGE_CACHE_SIZE, inode->i_size);
+       end_off = min_t(loff_t, start_off + PAGE_SIZE, inode->i_size);
 
        cstart_block = start_off >> zisofs_block_shift;
        cend_block = (end_off + (1 << zisofs_block_shift) - 1)
                        >> zisofs_block_shift;
 
-       WARN_ON(start_off - (full_page << PAGE_CACHE_SHIFT) !=
-               ((cstart_block << zisofs_block_shift) & PAGE_CACHE_MASK));
+       WARN_ON(start_off - (full_page << PAGE_SHIFT) !=
+               ((cstart_block << zisofs_block_shift) & PAGE_MASK));
 
        /* Find the pointer to this specific chunk */
        /* Note: we're not using isonum_731() here because the data is known aligned */
@@ -260,10 +260,10 @@ static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
                ret = zisofs_uncompress_block(inode, block_start, block_end,
                                              pcount, pages, poffset, &err);
                poffset += ret;
-               pages += poffset >> PAGE_CACHE_SHIFT;
-               pcount -= poffset >> PAGE_CACHE_SHIFT;
-               full_page -= poffset >> PAGE_CACHE_SHIFT;
-               poffset &= ~PAGE_CACHE_MASK;
+               pages += poffset >> PAGE_SHIFT;
+               pcount -= poffset >> PAGE_SHIFT;
+               full_page -= poffset >> PAGE_SHIFT;
+               poffset &= ~PAGE_MASK;
 
                if (err) {
                        brelse(bh);
@@ -282,7 +282,7 @@ static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
 
        if (poffset && *pages) {
                memset(page_address(*pages) + poffset, 0,
-                      PAGE_CACHE_SIZE - poffset);
+                      PAGE_SIZE - poffset);
                flush_dcache_page(*pages);
                SetPageUptodate(*pages);
        }
@@ -302,12 +302,12 @@ static int zisofs_readpage(struct file *file, struct page *page)
        int i, pcount, full_page;
        unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
        unsigned int zisofs_pages_per_cblock =
-               PAGE_CACHE_SHIFT <= zisofs_block_shift ?
-               (1 << (zisofs_block_shift - PAGE_CACHE_SHIFT)) : 0;
+               PAGE_SHIFT <= zisofs_block_shift ?
+               (1 << (zisofs_block_shift - PAGE_SHIFT)) : 0;
        struct page *pages[max_t(unsigned, zisofs_pages_per_cblock, 1)];
        pgoff_t index = page->index, end_index;
 
-       end_index = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+       end_index = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
        /*
         * If this page is wholly outside i_size we just return zero;
         * do_generic_file_read() will handle this for us
@@ -318,7 +318,7 @@ static int zisofs_readpage(struct file *file, struct page *page)
                return 0;
        }
 
-       if (PAGE_CACHE_SHIFT <= zisofs_block_shift) {
+       if (PAGE_SHIFT <= zisofs_block_shift) {
                /* We have already been given one page, this is the one
                   we must do. */
                full_page = index & (zisofs_pages_per_cblock - 1);
@@ -351,7 +351,7 @@ static int zisofs_readpage(struct file *file, struct page *page)
                        kunmap(pages[i]);
                        unlock_page(pages[i]);
                        if (i != full_page)
-                               page_cache_release(pages[i]);
+                               put_page(pages[i]);
                }
        }