linux/fs/freevxfs/vxfs_bmap.c
<<
>>
Prefs
   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 - filesystem to disk block mapping.
  32 */
  33#include <linux/fs.h>
  34#include <linux/buffer_head.h>
  35#include <linux/kernel.h>
  36
  37#include "vxfs.h"
  38#include "vxfs_inode.h"
  39#include "vxfs_extern.h"
  40
  41
  42#ifdef DIAGNOSTIC
  43static void
  44vxfs_typdump(struct vxfs_typed *typ)
  45{
  46        printk(KERN_DEBUG "type=%Lu ", typ->vt_hdr >> VXFS_TYPED_TYPESHIFT);
  47        printk("offset=%Lx ", typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
  48        printk("block=%x ", typ->vt_block);
  49        printk("size=%x\n", typ->vt_size);
  50}
  51#endif
  52
  53/**
  54 * vxfs_bmap_ext4 - do bmap for ext4 extents
  55 * @ip:         pointer to the inode we do bmap for
  56 * @iblock:     logical block.
  57 *
  58 * Description:
  59 *   vxfs_bmap_ext4 performs the bmap operation for inodes with
  60 *   ext4-style extents (which are much like the traditional UNIX
  61 *   inode organisation).
  62 *
  63 * Returns:
  64 *   The physical block number on success, else Zero.
  65 */
  66static daddr_t
  67vxfs_bmap_ext4(struct inode *ip, long bn)
  68{
  69        struct super_block *sb = ip->i_sb;
  70        struct vxfs_inode_info *vip = VXFS_INO(ip);
  71        unsigned long bsize = sb->s_blocksize;
  72        u32 indsize = vip->vii_ext4.ve4_indsize;
  73        int i;
  74
  75        if (indsize > sb->s_blocksize)
  76                goto fail_size;
  77
  78        for (i = 0; i < VXFS_NDADDR; i++) {
  79                struct direct *d = vip->vii_ext4.ve4_direct + i;
  80                if (bn >= 0 && bn < d->size)
  81                        return (bn + d->extent);
  82                bn -= d->size;
  83        }
  84
  85        if ((bn / (indsize * indsize * bsize / 4)) == 0) {
  86                struct buffer_head *buf;
  87                daddr_t bno;
  88                u32 *indir;
  89
  90                buf = sb_bread(sb, vip->vii_ext4.ve4_indir[0]);
  91                if (!buf || !buffer_mapped(buf))
  92                        goto fail_buf;
  93
  94                indir = (u32 *)buf->b_data;
  95                bno = indir[(bn/indsize) % (indsize*bn)] + (bn%indsize);
  96
  97                brelse(buf);
  98                return bno;
  99        } else
 100                printk(KERN_WARNING "no matching indir?");
 101
 102        return 0;
 103
 104fail_size:
 105        printk("vxfs: indirect extent too big!\n");
 106fail_buf:
 107        return 0;
 108}
 109
 110/**
 111 * vxfs_bmap_indir - recursion for vxfs_bmap_typed
 112 * @ip:         pointer to the inode we do bmap for
 113 * @indir:      indirect block we start reading at
 114 * @size:       size of the typed area to search
 115 * @block:      partially result from further searches
 116 *
 117 * Description:
 118 *   vxfs_bmap_indir reads a &struct vxfs_typed at @indir
 119 *   and performs the type-defined action.
 120 *
 121 * Return Value:
 122 *   The physical block number on success, else Zero.
 123 *
 124 * Note:
 125 *   Kernelstack is rare.  Unrecurse?
 126 */
 127static daddr_t
 128vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
 129{
 130        struct buffer_head              *bp = NULL;
 131        daddr_t                         pblock = 0;
 132        int                             i;
 133
 134        for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) {
 135                struct vxfs_typed       *typ;
 136                int64_t                 off;
 137
 138                bp = sb_bread(ip->i_sb,
 139                                indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
 140                if (!bp || !buffer_mapped(bp))
 141                        return 0;
 142
 143                typ = ((struct vxfs_typed *)bp->b_data) +
 144                        (i % VXFS_TYPED_PER_BLOCK(ip->i_sb));
 145                off = (typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
 146
 147                if (block < off) {
 148                        brelse(bp);
 149                        continue;
 150                }
 151
 152                switch ((u_int32_t)(typ->vt_hdr >> VXFS_TYPED_TYPESHIFT)) {
 153                case VXFS_TYPED_INDIRECT:
 154                        pblock = vxfs_bmap_indir(ip, typ->vt_block,
 155                                        typ->vt_size, block - off);
 156                        if (pblock == -2)
 157                                break;
 158                        goto out;
 159                case VXFS_TYPED_DATA:
 160                        if ((block - off) >= typ->vt_size)
 161                                break;
 162                        pblock = (typ->vt_block + block - off);
 163                        goto out;
 164                case VXFS_TYPED_INDIRECT_DEV4:
 165                case VXFS_TYPED_DATA_DEV4: {
 166                        struct vxfs_typed_dev4  *typ4 =
 167                                (struct vxfs_typed_dev4 *)typ;
 168
 169                        printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
 170                        printk(KERN_INFO "block: %Lu\tsize: %Ld\tdev: %d\n",
 171                               (unsigned long long) typ4->vd4_block,
 172                               (unsigned long long) typ4->vd4_size,
 173                               typ4->vd4_dev);
 174                        goto fail;
 175                }
 176                default:
 177                        BUG();
 178                }
 179                brelse(bp);
 180        }
 181
 182fail:
 183        pblock = 0;
 184out:
 185        brelse(bp);
 186        return (pblock);
 187}
 188
 189/**
 190 * vxfs_bmap_typed - bmap for typed extents
 191 * @ip:         pointer to the inode we do bmap for
 192 * @iblock:     logical block
 193 *
 194 * Description:
 195 *   Performs the bmap operation for typed extents.
 196 *
 197 * Return Value:
 198 *   The physical block number on success, else Zero.
 199 */
 200static daddr_t
 201vxfs_bmap_typed(struct inode *ip, long iblock)
 202{
 203        struct vxfs_inode_info          *vip = VXFS_INO(ip);
 204        daddr_t                         pblock = 0;
 205        int                             i;
 206
 207        for (i = 0; i < VXFS_NTYPED; i++) {
 208                struct vxfs_typed       *typ = vip->vii_org.typed + i;
 209                int64_t                 off = (typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
 210
 211#ifdef DIAGNOSTIC
 212                vxfs_typdump(typ);
 213#endif
 214                if (iblock < off)
 215                        continue;
 216                switch ((u_int32_t)(typ->vt_hdr >> VXFS_TYPED_TYPESHIFT)) {
 217                case VXFS_TYPED_INDIRECT:
 218                        pblock = vxfs_bmap_indir(ip, typ->vt_block,
 219                                        typ->vt_size, iblock - off);
 220                        if (pblock == -2)
 221                                break;
 222                        return (pblock);
 223                case VXFS_TYPED_DATA:
 224                        if ((iblock - off) < typ->vt_size)
 225                                return (typ->vt_block + iblock - off);
 226                        break;
 227                case VXFS_TYPED_INDIRECT_DEV4:
 228                case VXFS_TYPED_DATA_DEV4: {
 229                        struct vxfs_typed_dev4  *typ4 =
 230                                (struct vxfs_typed_dev4 *)typ;
 231
 232                        printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
 233                        printk(KERN_INFO "block: %Lu\tsize: %Ld\tdev: %d\n",
 234                               (unsigned long long) typ4->vd4_block,
 235                               (unsigned long long) typ4->vd4_size,
 236                               typ4->vd4_dev);
 237                        return 0;
 238                }
 239                default:
 240                        BUG();
 241                }
 242        }
 243
 244        return 0;
 245}
 246
 247/**
 248 * vxfs_bmap1 - vxfs-internal bmap operation
 249 * @ip:                 pointer to the inode we do bmap for
 250 * @iblock:             logical block
 251 *
 252 * Description:
 253 *   vxfs_bmap1 perfoms a logical to physical block mapping
 254 *   for vxfs-internal purposes.
 255 *
 256 * Return Value:
 257 *   The physical block number on success, else Zero.
 258 */
 259daddr_t
 260vxfs_bmap1(struct inode *ip, long iblock)
 261{
 262        struct vxfs_inode_info          *vip = VXFS_INO(ip);
 263
 264        if (VXFS_ISEXT4(vip))
 265                return vxfs_bmap_ext4(ip, iblock);
 266        if (VXFS_ISTYPED(vip))
 267                return vxfs_bmap_typed(ip, iblock);
 268        if (VXFS_ISNONE(vip))
 269                goto unsupp;
 270        if (VXFS_ISIMMED(vip))
 271                goto unsupp;
 272
 273        printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
 274                        ip->i_ino, vip->vii_orgtype);
 275        BUG();
 276
 277unsupp:
 278        printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
 279                        ip->i_ino, vip->vii_orgtype);
 280        return 0;
 281}
 282
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.