fs/freevxfs/vxfs_subr.c

   1 /*
   2  * Copyright (c) 2000-2001 Christoph Hellwig.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification.
  11  * 2. The name of the author may not be used to endorse or promote products
  12  *    derived from this software without specific prior written permission.
  13  *
  14  * Alternatively, this software may be distributed under the terms of the
  15  * GNU General Public License ("GPL").
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ident "$Id: vxfs_subr.c,v 1.8 2001/12/28 20:50:47 hch Exp hch $"
  31
  32 /*
  33  * Veritas filesystem driver - shared subroutines.
  34  */
  35 #include <linux/fs.h>
  36 #include <linux/kernel.h>
  37 #include <linux/slab.h>
  38 #include <linux/pagemap.h>
  39
  40 #include "vxfs_kcompat.h"
  41 #include "vxfs_extern.h"
  42
  43
  44 static int              vxfs_readpage(struct file *, struct page *);
  45 static int              vxfs_bmap(struct address_space *, long);
  46
  47 struct address_space_operations vxfs_aops = {
  48         .readpage =             vxfs_readpage,
  49         .bmap =                 vxfs_bmap,
  50         .sync_page =            block_sync_page,
  51 };
  52
  53 __inline__ void
  54 vxfs_put_page(struct page *pp)
  55 {
  56         kunmap(pp);
  57         page_cache_release(pp);
  58 }
  59
  60 /**
  61  * vxfs_get_page - read a page into memory.
  62  * @ip:         inode to read from
  63  * @n:          page number
  64  *
  65  * Description:
  66  *   vxfs_get_page reads the @n th page of @ip into the pagecache.
  67  *
  68  * Returns:
  69  *   The wanted page on success, else a NULL pointer.
  70  */
  71 struct page *
  72 vxfs_get_page(struct address_space *mapping, u_long n)
  73 {
  74         struct page *                   pp;
  75
  76         pp = read_cache_page(mapping, n,
  77                         (filler_t*)mapping->a_ops->readpage, NULL);
  78
  79         if (!IS_ERR(pp)) {
  80                 wait_on_page(pp);
  81                 kmap(pp);
  82                 if (!Page_Uptodate(pp))
  83                         goto fail;
  84                 /** if (!PageChecked(pp)) **/
  85                         /** vxfs_check_page(pp); **/
  86                 if (PageError(pp))
  87                         goto fail;
  88         }
  89
  90         return (pp);
  91
  92 fail:
  93         vxfs_put_page(pp);
  94         return ERR_PTR(-EIO);
  95 }
  96
  97 /**
  98  * vxfs_bread - read buffer for a give inode,block tuple
  99  * @ip:         inode
 100  * @block:      logical block
 101  *
 102  * Description:
 103  *   The vxfs_bread function reads block no @block  of
 104  *   @ip into the buffercache.
 105  *
 106  * Returns:
 107  *   The resulting &struct buffer_head.
 108  */
 109 struct buffer_head *
 110 vxfs_bread(struct inode *ip, int block)
 111 {
 112         struct buffer_head      *bp;
 113         daddr_t                 pblock;
 114
 115         pblock = vxfs_bmap1(ip, block);
 116         bp = sb_bread(ip->i_sb, pblock);
 117
 118         return (bp);
 119 }
 120
 121 /**
 122  * vxfs_get_block - locate buffer for given inode,block tuple
 123  * @ip:         inode
 124  * @iblock:     logical block
 125  * @bp:         buffer skeleton
 126  * @create:     %TRUE if blocks may be newly allocated.
 127  *
 128  * Description:
 129  *   The vxfs_get_block function fills @bp with the right physical
 130  *   block and device number to perform a lowlevel read/write on
 131  *   it.
 132  *
 133  * Returns:
 134  *   Zero on success, else a negativ error code (-EIO).
 135  */
 136 static int
 137 vxfs_getblk(struct inode *ip, sector_t iblock,
 138             struct buffer_head *bp, int create)
 139 {
 140         daddr_t                 pblock;
 141
 142         pblock = vxfs_bmap1(ip, iblock);
 143         if (pblock != 0) {
 144                 map_bh(bp, ip->i_sb, pblock);
 145                 return 0;
 146         }
 147
 148         return -EIO;
 149 }
 150
 151 /**
 152  * vxfs_readpage - read one page synchronously into the pagecache
 153  * @file:       file context (unused)
 154  * @page:       page frame to fill in.
 155  *
 156  * Description:
 157  *   The vxfs_readpage routine reads @page synchronously into the
 158  *   pagecache.
 159  *
 160  * Returns:
 161  *   Zero on success, else a negative error code.
 162  *
 163  * Locking status:
 164  *   @page is locked and will be unlocked.
 165  */
 166 static int
 167 vxfs_readpage(struct file *file, struct page *page)
 168 {
 169         return block_read_full_page(page, vxfs_getblk);
 170 }
 171
 172 /**
 173  * vxfs_bmap - perform logical to physical block mapping
 174  * @mapping:    logical to physical mapping to use
 175  * @block:      logical block (relative to @mapping).
 176  *
 177  * Description:
 178  *   Vxfs_bmap find out the corresponding phsical block to the
 179  *   @mapping, @block pair.
 180  *
 181  * Returns:
 182  *   Physical block number on success, else Zero.
 183  *
 184  * Locking status:
 185  *   We are under the bkl.
 186  */
 187 static int
 188 vxfs_bmap(struct address_space *mapping, long block)
 189 {
 190         return generic_block_bmap(mapping, block, vxfs_getblk);
 191 }