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