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_internal.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_internal.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 __private_extern__
  88 int
  89 ffs_blkatoff(vnode_t vp, off_t offset, char **res, buf_t *bpp)
  90 {
  91         struct inode *ip;
  92         register struct fs *fs;
  93         struct buf *bp;
  94         ufs_daddr_t lbn;
  95         int bsize, error;
  96 #if REV_ENDIAN_FS
  97         struct mount *mp = vnode_mount(vp);
  98         int rev_endian=(mp->mnt_flag & MNT_REVEND);
  99 #endif /* REV_ENDIAN_FS */
 100
 101         ip = VTOI(vp);
 102         fs = ip->i_fs;
 103         lbn = lblkno(fs, offset);
 104         bsize = blksize(fs, ip, lbn);
 105
 106         *bpp = NULL;
 107         if (error = (int)buf_bread(vp, (daddr64_t)((unsigned)lbn), bsize, NOCRED, &bp)) {
 108                 buf_brelse(bp);
 109                 return (error);
 110         }
 111 #if     REV_ENDIAN_FS
 112         if (rev_endian)
 113                 byte_swap_dir_block_in((char *)buf_dataptr(bp), buf_count(bp));
 114 #endif  /* REV_ENDIAN_FS */
 115
 116         if (res)
 117                 *res = (char *)buf_dataptr(bp) + blkoff(fs, offset);
 118         *bpp = bp;
 119         return (0);
 120 }
 121 #endif
 122
 123 /*
 124  * Update the frsum fields to reflect addition or deletion
 125  * of some frags.
 126  */
 127 void
 128 ffs_fragacct(fs, fragmap, fraglist, cnt)
 129         struct fs *fs;
 130         int fragmap;
 131         int32_t fraglist[];
 132         int cnt;
 133 {
 134         int inblk;
 135         register int field, subfield;
 136         register int siz, pos;
 137
 138         inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;
 139         fragmap <<= 1;
 140         for (siz = 1; siz < fs->fs_frag; siz++) {
 141                 if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
 142                         continue;
 143                 field = around[siz];
 144                 subfield = inside[siz];
 145                 for (pos = siz; pos <= fs->fs_frag; pos++) {
 146                         if ((fragmap & field) == subfield) {
 147                                 fraglist[siz] += cnt;
 148                                 pos += siz;
 149                                 field <<= siz;
 150                                 subfield <<= siz;
 151                         }
 152                         field <<= 1;
 153                         subfield <<= 1;
 154                 }
 155         }
 156 }
 157
 158 /*
 159  * block operations
 160  *
 161  * check if a block is available
 162  */
 163 int
 164 ffs_isblock(fs, cp, h)
 165         struct fs *fs;
 166         unsigned char *cp;
 167         ufs_daddr_t h;
 168 {
 169         unsigned char mask;
 170
 171         switch ((int)fs->fs_frag) {
 172         case 8:
 173                 return (cp[h] == 0xff);
 174         case 4:
 175                 mask = 0x0f << ((h & 0x1) << 2);
 176                 return ((cp[h >> 1] & mask) == mask);
 177         case 2:
 178                 mask = 0x03 << ((h & 0x3) << 1);
 179                 return ((cp[h >> 2] & mask) == mask);
 180         case 1:
 181                 mask = 0x01 << (h & 0x7);
 182                 return ((cp[h >> 3] & mask) == mask);
 183         default:
 184                 panic("ffs_isblock");
 185         }
 186         /* NOTREACHED */
 187         return 0;
 188 }
 189
 190 /*
 191  * take a block out of the map
 192  */
 193 void
 194 ffs_clrblock(fs, cp, h)
 195         struct fs *fs;
 196         u_char *cp;
 197         ufs_daddr_t h;
 198 {
 199
 200         switch ((int)fs->fs_frag) {
 201         case 8:
 202                 cp[h] = 0;
 203                 return;
 204         case 4:
 205                 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
 206                 return;
 207         case 2:
 208                 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
 209                 return;
 210         case 1:
 211                 cp[h >> 3] &= ~(0x01 << (h & 0x7));
 212                 return;
 213         default:
 214                 panic("ffs_clrblock");
 215         }
 216 }
 217
 218 /*
 219  * put a block into the map
 220  */
 221 void
 222 ffs_setblock(fs, cp, h)
 223         struct fs *fs;
 224         unsigned char *cp;
 225         ufs_daddr_t h;
 226 {
 227
 228         switch ((int)fs->fs_frag) {
 229
 230         case 8:
 231                 cp[h] = 0xff;
 232                 return;
 233         case 4:
 234                 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
 235                 return;
 236         case 2:
 237                 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
 238                 return;
 239         case 1:
 240                 cp[h >> 3] |= (0x01 << (h & 0x7));
 241                 return;
 242         default:
 243                 panic("ffs_setblock");
 244         }
 245 }