LXR linux/fs/freevxfs/vxfs

   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/*
  31 * Veritas filesystem driver - shared subroutines.
  32 */
  33#include <linux/fs.h>
  34#include <linux/buffer_head.h>
  35#include <linux/kernel.h>
  36#include <linux/pagemap.h>
  37
  38#include "vxfs_extern.h"
  39
  40
  41static int              vxfs_readpage(struct file *, struct page *);
  42static sector_t         vxfs_bmap(struct address_space *, sector_t);
  43
  44const struct address_space_operations vxfs_aops = {
  45        .readpage =             vxfs_readpage,
  46        .bmap =                 vxfs_bmap,
  47};
  48
  49inline void
  50vxfs_put_page(struct page *pp)
  51{
  52        kunmap(pp);
  53        put_page(pp);
  54}
  55
  56/**
  57 * vxfs_get_page - read a page into memory.
  58 * @ip:         inode to read from
  59 * @n:          page number
  60 *
  61 * Description:
  62 *   vxfs_get_page reads the @n th page of @ip into the pagecache.
  63 *
  64 * Returns:
  65 *   The wanted page on success, else a NULL pointer.
  66 */
  67struct page *
  68vxfs_get_page(struct address_space *mapping, u_long n)
  69{
  70        struct page *                   pp;
  71
  72        pp = read_mapping_page(mapping, n, NULL);
  73
  74        if (!IS_ERR(pp)) {
  75                kmap(pp);
  76                /** if (!PageChecked(pp)) **/
  77                        /** vxfs_check_page(pp); **/
  78                if (PageError(pp))
  79                        goto fail;
  80        }
  81        
  82        return (pp);
  83                 
  84fail:
  85        vxfs_put_page(pp);
  86        return ERR_PTR(-EIO);
  87}
  88
  89/**
  90 * vxfs_bread - read buffer for a give inode,block tuple
  91 * @ip:         inode
  92 * @block:      logical block
  93 *
  94 * Description:
  95 *   The vxfs_bread function reads block no @block  of
  96 *   @ip into the buffercache.
  97 *
  98 * Returns:
  99 *   The resulting &struct buffer_head.
 100 */
 101struct buffer_head *
 102vxfs_bread(struct inode *ip, int block)
 103{
 104        struct buffer_head      *bp;
 105        daddr_t                 pblock;
 106
 107        pblock = vxfs_bmap1(ip, block);
 108        bp = sb_bread(ip->i_sb, pblock);
 109
 110        return (bp);
 111}
 112
 113/**
 114 * vxfs_get_block - locate buffer for given inode,block tuple 
 115 * @ip:         inode
 116 * @iblock:     logical block
 117 * @bp:         buffer skeleton
 118 * @create:     %TRUE if blocks may be newly allocated.
 119 *
 120 * Description:
 121 *   The vxfs_get_block function fills @bp with the right physical
 122 *   block and device number to perform a lowlevel read/write on
 123 *   it.
 124 *
 125 * Returns:
 126 *   Zero on success, else a negativ error code (-EIO).
 127 */
 128static int
 129vxfs_getblk(struct inode *ip, sector_t iblock,
 130            struct buffer_head *bp, int create)
 131{
 132        daddr_t                 pblock;
 133
 134        pblock = vxfs_bmap1(ip, iblock);
 135        if (pblock != 0) {
 136                map_bh(bp, ip->i_sb, pblock);
 137                return 0;
 138        }
 139
 140        return -EIO;
 141}
 142
 143/**
 144 * vxfs_readpage - read one page synchronously into the pagecache
 145 * @file:       file context (unused)
 146 * @page:       page frame to fill in.
 147 *
 148 * Description:
 149 *   The vxfs_readpage routine reads @page synchronously into the
 150 *   pagecache.
 151 *
 152 * Returns:
 153 *   Zero on success, else a negative error code.
 154 *
 155 * Locking status:
 156 *   @page is locked and will be unlocked.
 157 */
 158static int
 159vxfs_readpage(struct file *file, struct page *page)
 160{
 161        return block_read_full_page(page, vxfs_getblk);
 162}
 163 
 164/**
 165 * vxfs_bmap - perform logical to physical block mapping
 166 * @mapping:    logical to physical mapping to use
 167 * @block:      logical block (relative to @mapping).
 168 *
 169 * Description:
 170 *   Vxfs_bmap find out the corresponding phsical block to the
 171 *   @mapping, @block pair.
 172 *
 173 * Returns:
 174 *   Physical block number on success, else Zero.
 175 *
 176 * Locking status:
 177 *   We are under the bkl.
 178 */
 179static sector_t
 180vxfs_bmap(struct address_space *mapping, sector_t block)
 181{
 182        return generic_block_bmap(mapping, block, vxfs_getblk);
 183}
 184