FreeBSD/Linux Kernel Cross Reference
sys/fs/freevxfs/vxfs_subr.c

     /*
      * Copyright (c) 2000-2001 Christoph Hellwig.
      * All rights reserved.
      *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions
      * are met:
      * 1. Redistributions of source code must retain the above copyright
      *    notice, this list of conditions, and the following disclaimer,
     *    without modification.
     * 2. The name of the author may not be used to endorse or promote products
     *    derived from this software without specific prior written permission.
     *
     * Alternatively, this software may be distributed under the terms of the
     * GNU General Public License ("GPL").
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
     * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     * SUCH DAMAGE.
     */
    
    #ident "$Id: vxfs_subr.c,v 1.8 2001/12/28 20:50:47 hch Exp hch $"
    
    /*
     * Veritas filesystem driver - shared subroutines.
     */
    #include <linux/fs.h>
    #include <linux/kernel.h>
    #include <linux/slab.h>
    #include <linux/pagemap.h>
    
    #include "vxfs_kcompat.h"
    #include "vxfs_extern.h"
    
    
    static int              vxfs_readpage(struct file *, struct page *);
    static int              vxfs_bmap(struct address_space *, long);
    
    struct address_space_operations vxfs_aops = {
            .readpage =             vxfs_readpage,
            .bmap =                 vxfs_bmap,
            .sync_page =            block_sync_page,
    };
    
    
    /**
     * vxfs_get_page - read a page into memory.
     * @ip:         inode to read from
     * @n:          page number
     *
     * Description:
     *   vxfs_get_page reads the @n th page of @ip into the pagecache.
     *
     * Returns:
     *   The wanted page on success, else a NULL pointer.
     */
    struct page *
    vxfs_get_page(struct address_space *mapping, u_long n)
    {
            struct page *                   pp;
    
            pp = read_cache_page(mapping, n,
                            (filler_t*)mapping->a_ops->readpage, NULL);
    
            if (!IS_ERR(pp)) {
                    wait_on_page(pp);
                    kmap(pp);
                    if (!Page_Uptodate(pp))
                            goto fail;
                    /** if (!PageChecked(pp)) **/
                            /** vxfs_check_page(pp); **/
                    if (PageError(pp))
                            goto fail;
            }
            
            return (pp);
                     
    fail:
            vxfs_put_page(pp);
            return ERR_PTR(-EIO);
    }
    
    __inline__ void
    vxfs_put_page(struct page *pp)
    {
            kunmap(pp);
            page_cache_release(pp);
    }
    
    /**
     * vxfs_bread - read buffer for a give inode,block tuple
    * @ip:         inode
    * @block:      logical block
    *
    * Description:
    *   The vxfs_bread function reads block no @block  of
    *   @ip into the buffercache.
    *
    * Returns:
    *   The resulting &struct buffer_head.
    */
   struct buffer_head *
   vxfs_bread(struct inode *ip, int block)
   {
           struct buffer_head      *bp;
           daddr_t                 pblock;
   
           pblock = vxfs_bmap1(ip, block);
           bp = sb_bread(ip->i_sb, pblock);
   
           return (bp);
   }
   
   /**
    * vxfs_get_block - locate buffer for given inode,block tuple 
    * @ip:         inode
    * @iblock:     logical block
    * @bp:         buffer skeleton
    * @create:     %TRUE if blocks may be newly allocated.
    *
    * Description:
    *   The vxfs_get_block function fills @bp with the right physical
    *   block and device number to perform a lowlevel read/write on
    *   it.
    *
    * Returns:
    *   Zero on success, else a negativ error code (-EIO).
    */
   static int
   vxfs_getblk(struct inode *ip, sector_t iblock,
               struct buffer_head *bp, int create)
   {
           daddr_t                 pblock;
   
           pblock = vxfs_bmap1(ip, iblock);
           if (pblock != 0) {
                   map_bh(bp, ip->i_sb, pblock);
                   return 0;
           }
   
           return -EIO;
   }
   
   /**
    * vxfs_readpage - read one page synchronously into the pagecache
    * @file:       file context (unused)
    * @page:       page frame to fill in.
    *
    * Description:
    *   The vxfs_readpage routine reads @page synchronously into the
    *   pagecache.
    *
    * Returns:
    *   Zero on success, else a negative error code.
    *
    * Locking status:
    *   @page is locked and will be unlocked.
    */
   static int
   vxfs_readpage(struct file *file, struct page *page)
   {
           return block_read_full_page(page, vxfs_getblk);
   }
    
   /**
    * vxfs_bmap - perform logical to physical block mapping
    * @mapping:    logical to physical mapping to use
    * @block:      logical block (relative to @mapping).
    *
    * Description:
    *   Vxfs_bmap find out the corresponding phsical block to the
    *   @mapping, @block pair.
    *
    * Returns:
    *   Physical block number on success, else Zero.
    *
    * Locking status:
    *   We are under the bkl.
    */
   static int
   vxfs_bmap(struct address_space *mapping, long block)
   {
           return generic_block_bmap(mapping, block, vxfs_getblk);
   }

Cache object: 8487bdc09e16109d98a13d481479612a