bsd/ufs/ffs/ffs_subr.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  23 /*
  24  * Copyright (c) 1982, 1986, 1989, 1993
  25  *      The Regents of the University of California.  All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. All advertising materials mentioning features or use of this software
  36  *    must display the following acknowledgement:
  37  *      This product includes software developed by the University of
  38  *      California, Berkeley and its contributors.
  39  * 4. Neither the name of the University nor the names of its contributors
  40  *    may be used to endorse or promote products derived from this software
  41  *    without specific prior written permission.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  *
  55  *      @(#)ffs_subr.c  8.5 (Berkeley) 3/21/95
  56  */
  57
  58 #include <rev_endian_fs.h>
  59 #include <sys/param.h>
  60 #if REV_ENDIAN_FS
  61 #include <sys/mount.h>
  62 #endif /* REV_ENDIAN_FS */
  63
  64 #ifndef KERNEL
  65 #include <ufs/ufs/dinode.h>
  66 #include <ufs/ffs/fs.h>
  67 #else
  68
  69 #include <sys/systm.h>
  70 #include <sys/vnode.h>
  71 #include <sys/buf.h>
  72 #include <sys/quota.h>
  73 #include <ufs/ufs/quota.h>
  74 #include <ufs/ufs/inode.h>
  75 #include <ufs/ffs/fs.h>
  76 #include <ufs/ffs/ffs_extern.h>
  77 #if REV_ENDIAN_FS
  78 #include <ufs/ufs/ufs_byte_order.h>
  79 #include <architecture/byte_order.h>
  80 #endif /* REV_ENDIAN_FS */
  81
  82 /*
  83  * Return buffer with the contents of block "offset" from the beginning of
  84  * directory "ip".  If "res" is non-zero, fill it in with a pointer to the
  85  * remaining space in the directory.
  86  */
  87 int
  88 ffs_blkatoff(ap)
  89         struct vop_blkatoff_args /* {
  90                 struct vnode *a_vp;
  91                 off_t a_offset;
  92                 char **a_res;
  93                 struct buf **a_bpp;
  94         } */ *ap;
  95 {
  96         struct inode *ip;
  97         register struct fs *fs;
  98         struct buf *bp;
  99         ufs_daddr_t lbn;
 100         int bsize, error;
 101 #if REV_ENDIAN_FS
 102         struct mount *mp=(ap->a_vp)->v_mount;
 103         int rev_endian=(mp->mnt_flag & MNT_REVEND);
 104 #endif /* REV_ENDIAN_FS */
 105
 106         ip = VTOI(ap->a_vp);
 107         fs = ip->i_fs;
 108         lbn = lblkno(fs, ap->a_offset);
 109         bsize = blksize(fs, ip, lbn);
 110
 111         *ap->a_bpp = NULL;
 112         if (error = bread(ap->a_vp, lbn, bsize, NOCRED, &bp)) {
 113                 brelse(bp);
 114                 return (error);
 115         }
 116 #if     REV_ENDIAN_FS
 117         if (rev_endian)
 118                 byte_swap_dir_block_in(bp->b_data, bp->b_bcount);
 119 #endif  /* REV_ENDIAN_FS */
 120
 121         if (ap->a_res)
 122                 *ap->a_res = (char *)bp->b_data + blkoff(fs, ap->a_offset);
 123         *ap->a_bpp = bp;
 124         return (0);
 125 }
 126 #endif
 127
 128 /*
 129  * Update the frsum fields to reflect addition or deletion
 130  * of some frags.
 131  */
 132 void
 133 ffs_fragacct(fs, fragmap, fraglist, cnt)
 134         struct fs *fs;
 135         int fragmap;
 136         int32_t fraglist[];
 137         int cnt;
 138 {
 139         int inblk;
 140         register int field, subfield;
 141         register int siz, pos;
 142
 143         inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;
 144         fragmap <<= 1;
 145         for (siz = 1; siz < fs->fs_frag; siz++) {
 146                 if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
 147                         continue;
 148                 field = around[siz];
 149                 subfield = inside[siz];
 150                 for (pos = siz; pos <= fs->fs_frag; pos++) {
 151                         if ((fragmap & field) == subfield) {
 152                                 fraglist[siz] += cnt;
 153                                 pos += siz;
 154                                 field <<= siz;
 155                                 subfield <<= siz;
 156                         }
 157                         field <<= 1;
 158                         subfield <<= 1;
 159                 }
 160         }
 161 }
 162
 163 #if defined(KERNEL) && DIAGNOSTIC
 164 void
 165 ffs_checkoverlap(bp, ip)
 166         struct buf *bp;
 167         struct inode *ip;
 168 {
 169         register struct buf *ebp, *ep;
 170         register ufs_daddr_t start, last;
 171         struct vnode *vp;
 172 #ifdef NeXT
 173         int devBlockSize=0;
 174 #endif /* NeXT */
 175
 176         ebp = &buf[nbuf];
 177         start = bp->b_blkno;
 178 #ifdef NeXT
 179         VOP_DEVBLOCKSIZE(ip->i_devvp,&devBlockSize);
 180         last = start + btodb(bp->b_bcount, devBlockSize) - 1;
 181 #else
 182         last = start + btodb(bp->b_bcount) - 1;
 183 #endif /* NeXT */
 184         for (ep = buf; ep < ebp; ep++) {
 185                 if (ep == bp || (ep->b_flags & B_INVAL) ||
 186                     ep->b_vp == NULLVP)
 187                         continue;
 188                 if (VOP_BMAP(ep->b_vp, (ufs_daddr_t)0, &vp, (ufs_daddr_t)0,
 189                     NULL))
 190                         continue;
 191                 if (vp != ip->i_devvp)
 192                         continue;
 193                 /* look for overlap */
 194 #ifdef NeXT
 195                 if (ep->b_bcount == 0 || ep->b_blkno > last ||
 196                     ep->b_blkno + btodb(ep->b_bcount, devBlockSize) <= start)
 197                         continue;
 198                 vprint("Disk overlap", vp);
 199                 (void)printf("\tstart %d, end %d overlap start %d, end %d\n",
 200                         start, last, ep->b_blkno,
 201                         ep->b_blkno + btodb(ep->b_bcount, devBlockSize) - 1);
 202 #else
 203                 if (ep->b_bcount == 0 || ep->b_blkno > last ||
 204                     ep->b_blkno + btodb(ep->b_bcount) <= start)
 205                         continue;
 206                 vprint("Disk overlap", vp);
 207                 (void)printf("\tstart %d, end %d overlap start %d, end %d\n",
 208                         start, last, ep->b_blkno,
 209                         ep->b_blkno + btodb(ep->b_bcount) - 1);
 210 #endif /* NeXT */
 211                 panic("Disk buffer overlap");
 212         }
 213 }
 214 #endif /* DIAGNOSTIC */
 215
 216 /*
 217  * block operations
 218  *
 219  * check if a block is available
 220  */
 221 int
 222 ffs_isblock(fs, cp, h)
 223         struct fs *fs;
 224         unsigned char *cp;
 225         ufs_daddr_t h;
 226 {
 227         unsigned char mask;
 228
 229         switch ((int)fs->fs_frag) {
 230         case 8:
 231                 return (cp[h] == 0xff);
 232         case 4:
 233                 mask = 0x0f << ((h & 0x1) << 2);
 234                 return ((cp[h >> 1] & mask) == mask);
 235         case 2:
 236                 mask = 0x03 << ((h & 0x3) << 1);
 237                 return ((cp[h >> 2] & mask) == mask);
 238         case 1:
 239                 mask = 0x01 << (h & 0x7);
 240                 return ((cp[h >> 3] & mask) == mask);
 241         default:
 242                 panic("ffs_isblock");
 243         }
 244 }
 245
 246 /*
 247  * take a block out of the map
 248  */
 249 void
 250 ffs_clrblock(fs, cp, h)
 251         struct fs *fs;
 252         u_char *cp;
 253         ufs_daddr_t h;
 254 {
 255
 256         switch ((int)fs->fs_frag) {
 257         case 8:
 258                 cp[h] = 0;
 259                 return;
 260         case 4:
 261                 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
 262                 return;
 263         case 2:
 264                 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
 265                 return;
 266         case 1:
 267                 cp[h >> 3] &= ~(0x01 << (h & 0x7));
 268                 return;
 269         default:
 270                 panic("ffs_clrblock");
 271         }
 272 }
 273
 274 /*
 275  * put a block into the map
 276  */
 277 void
 278 ffs_setblock(fs, cp, h)
 279         struct fs *fs;
 280         unsigned char *cp;
 281         ufs_daddr_t h;
 282 {
 283
 284         switch ((int)fs->fs_frag) {
 285
 286         case 8:
 287                 cp[h] = 0xff;
 288                 return;
 289         case 4:
 290                 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
 291                 return;
 292         case 2:
 293                 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
 294                 return;
 295         case 1:
 296                 cp[h >> 3] |= (0x01 << (h & 0x7));
 297                 return;
 298         default:
 299                 panic("ffs_setblock");
 300         }
 301 }