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 - 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        struct vxfs_sb_info *sbi = VXFS_SBI(sb);
  72        unsigned long bsize = sb->s_blocksize;
  73        u32 indsize = fs32_to_cpu(sbi, vip->vii_ext4.ve4_indsize);
  74        int i;
  75
  76        if (indsize > sb->s_blocksize)
  77                goto fail_size;
  78
  79        for (i = 0; i < VXFS_NDADDR; i++) {
  80                struct direct *d = vip->vii_ext4.ve4_direct + i;
  81                if (bn >= 0 && bn < fs32_to_cpu(sbi, d->size))
  82                        return (bn + fs32_to_cpu(sbi, d->extent));
  83                bn -= fs32_to_cpu(sbi, d->size);
  84        }
  85
  86        if ((bn / (indsize * indsize * bsize / 4)) == 0) {
  87                struct buffer_head *buf;
  88                daddr_t bno;
  89                __fs32 *indir;
  90
  91                buf = sb_bread(sb,
  92                        fs32_to_cpu(sbi, vip->vii_ext4.ve4_indir[0]));
  93                if (!buf || !buffer_mapped(buf))
  94                        goto fail_buf;
  95
  96                indir = (__fs32 *)buf->b_data;
  97                bno = fs32_to_cpu(sbi, indir[(bn / indsize) % (indsize * bn)]) +
  98                        (bn % indsize);
  99
 100                brelse(buf);
 101                return bno;
 102        } else
 103                printk(KERN_WARNING "no matching indir?");
 104
 105        return 0;
 106
 107fail_size:
 108        printk("vxfs: indirect extent too big!\n");
 109fail_buf:
 110        return 0;
 111}
 112
 113/**
 114 * vxfs_bmap_indir - recursion for vxfs_bmap_typed
 115 * @ip:         pointer to the inode we do bmap for
 116 * @indir:      indirect block we start reading at
 117 * @size:       size of the typed area to search
 118 * @block:      partially result from further searches
 119 *
 120 * Description:
 121 *   vxfs_bmap_indir reads a &struct vxfs_typed at @indir
 122 *   and performs the type-defined action.
 123 *
 124 * Return Value:
 125 *   The physical block number on success, else Zero.
 126 *
 127 * Note:
 128 *   Kernelstack is rare.  Unrecurse?
 129 */
 130static daddr_t
 131vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
 132{
 133        struct vxfs_sb_info             *sbi = VXFS_SBI(ip->i_sb);
 134        struct buffer_head              *bp = NULL;
 135        daddr_t                         pblock = 0;
 136        int                             i;
 137
 138        for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) {
 139                struct vxfs_typed       *typ;
 140                int64_t                 off;
 141
 142                bp = sb_bread(ip->i_sb,
 143                                indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
 144                if (!bp || !buffer_mapped(bp))
 145                        return 0;
 146
 147                typ = ((struct vxfs_typed *)bp->b_data) +
 148                        (i % VXFS_TYPED_PER_BLOCK(ip->i_sb));
 149                off = fs64_to_cpu(sbi, typ->vt_hdr) & VXFS_TYPED_OFFSETMASK;
 150
 151                if (block < off) {
 152                        brelse(bp);
 153                        continue;
 154                }
 155
 156                switch ((u_int32_t)(fs64_to_cpu(sbi, typ->vt_hdr) >>
 157                                VXFS_TYPED_TYPESHIFT)) {
 158                case VXFS_TYPED_INDIRECT:
 159                        pblock = vxfs_bmap_indir(ip,
 160                                        fs32_to_cpu(sbi, typ->vt_block),
 161                                        fs32_to_cpu(sbi, typ->vt_size),
 162                                        block - off);
 163                        if (pblock == -2)
 164                                break;
 165                        goto out;
 166                case VXFS_TYPED_DATA:
 167                        if ((block - off) >= fs32_to_cpu(sbi, typ->vt_size))
 168                                break;
 169                        pblock = fs32_to_cpu(sbi, typ->vt_block) + block - off;
 170                        goto out;
 171                case VXFS_TYPED_INDIRECT_DEV4:
 172                case VXFS_TYPED_DATA_DEV4: {
 173                        struct vxfs_typed_dev4  *typ4 =
 174                                (struct vxfs_typed_dev4 *)typ;
 175
 176                        printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
 177                        printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
 178                               fs64_to_cpu(sbi, typ4->vd4_block),
 179                               fs64_to_cpu(sbi, typ4->vd4_size),
 180                               fs32_to_cpu(sbi, typ4->vd4_dev));
 181                        goto fail;
 182                }
 183                default:
 184                        printk(KERN_ERR "%s:%d vt_hdr %llu\n", __func__,
 185                                __LINE__, fs64_to_cpu(sbi, typ->vt_hdr));
 186                        BUG();
 187                }
 188                brelse(bp);
 189        }
 190
 191fail:
 192        pblock = 0;
 193out:
 194        brelse(bp);
 195        return (pblock);
 196}
 197
 198/**
 199 * vxfs_bmap_typed - bmap for typed extents
 200 * @ip:         pointer to the inode we do bmap for
 201 * @iblock:     logical block
 202 *
 203 * Description:
 204 *   Performs the bmap operation for typed extents.
 205 *
 206 * Return Value:
 207 *   The physical block number on success, else Zero.
 208 */
 209static daddr_t
 210vxfs_bmap_typed(struct inode *ip, long iblock)
 211{
 212        struct vxfs_inode_info          *vip = VXFS_INO(ip);
 213        struct vxfs_sb_info             *sbi = VXFS_SBI(ip->i_sb);
 214        daddr_t                         pblock = 0;
 215        int                             i;
 216
 217        for (i = 0; i < VXFS_NTYPED; i++) {
 218                struct vxfs_typed       *typ = vip->vii_org.typed + i;
 219                u64                     hdr = fs64_to_cpu(sbi, typ->vt_hdr);
 220                int64_t                 off = (hdr & VXFS_TYPED_OFFSETMASK);
 221
 222#ifdef DIAGNOSTIC
 223                vxfs_typdump(typ);
 224#endif
 225                if (iblock < off)
 226                        continue;
 227                switch ((u32)(hdr >> VXFS_TYPED_TYPESHIFT)) {
 228                case VXFS_TYPED_INDIRECT:
 229                        pblock = vxfs_bmap_indir(ip,
 230                                        fs32_to_cpu(sbi, typ->vt_block),
 231                                        fs32_to_cpu(sbi, typ->vt_size),
 232                                        iblock - off);
 233                        if (pblock == -2)
 234                                break;
 235                        return (pblock);
 236                case VXFS_TYPED_DATA:
 237                        if ((iblock - off) < fs32_to_cpu(sbi, typ->vt_size))
 238                                return (fs32_to_cpu(sbi, typ->vt_block) +
 239                                                iblock - off);
 240                        break;
 241                case VXFS_TYPED_INDIRECT_DEV4:
 242                case VXFS_TYPED_DATA_DEV4: {
 243                        struct vxfs_typed_dev4  *typ4 =
 244                                (struct vxfs_typed_dev4 *)typ;
 245
 246                        printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
 247                        printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
 248                               fs64_to_cpu(sbi, typ4->vd4_block),
 249                               fs64_to_cpu(sbi, typ4->vd4_size),
 250                               fs32_to_cpu(sbi, typ4->vd4_dev));
 251                        return 0;
 252                }
 253                default:
 254                        BUG();
 255                }
 256        }
 257
 258        return 0;
 259}
 260
 261/**
 262 * vxfs_bmap1 - vxfs-internal bmap operation
 263 * @ip:                 pointer to the inode we do bmap for
 264 * @iblock:             logical block
 265 *
 266 * Description:
 267 *   vxfs_bmap1 perfoms a logical to physical block mapping
 268 *   for vxfs-internal purposes.
 269 *
 270 * Return Value:
 271 *   The physical block number on success, else Zero.
 272 */
 273daddr_t
 274vxfs_bmap1(struct inode *ip, long iblock)
 275{
 276        struct vxfs_inode_info          *vip = VXFS_INO(ip);
 277
 278        if (VXFS_ISEXT4(vip))
 279                return vxfs_bmap_ext4(ip, iblock);
 280        if (VXFS_ISTYPED(vip))
 281                return vxfs_bmap_typed(ip, iblock);
 282        if (VXFS_ISNONE(vip))
 283                goto unsupp;
 284        if (VXFS_ISIMMED(vip))
 285                goto unsupp;
 286
 287        printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
 288                        ip->i_ino, vip->vii_orgtype);
 289        BUG();
 290
 291unsupp:
 292        printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
 293                        ip->i_ino, vip->vii_orgtype);
 294        return 0;
 295}
 296