ffs_subr.c revision 1.46
1 /* $NetBSD: ffs_subr.c,v 1.46 2011/03/06 17:08:38 bouyer Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)ffs_subr.c 8.5 (Berkeley) 3/21/95 32 */ 33 34 #if HAVE_NBTOOL_CONFIG_H 35 #include "nbtool_config.h" 36 #endif 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: ffs_subr.c,v 1.46 2011/03/06 17:08:38 bouyer Exp $"); 40 41 #include <sys/param.h> 42 43 /* in ffs_tables.c */ 44 extern const int inside[], around[]; 45 extern const u_char * const fragtbl[]; 46 47 #ifndef _KERNEL 48 #define FFS_EI /* always include byteswapped filesystems support */ 49 #endif 50 #include <ufs/ffs/fs.h> 51 #include <ufs/ffs/ffs_extern.h> 52 #include <ufs/ufs/ufs_bswap.h> 53 54 #ifndef _KERNEL 55 #include <ufs/ufs/dinode.h> 56 void panic(const char *, ...) 57 __attribute__((__noreturn__,__format__(__printf__,1,2))); 58 59 #else /* _KERNEL */ 60 #include <sys/systm.h> 61 #include <sys/vnode.h> 62 #include <sys/mount.h> 63 #include <sys/buf.h> 64 #include <sys/inttypes.h> 65 #include <sys/pool.h> 66 #include <sys/fstrans.h> 67 #include <ufs/ufs/inode.h> 68 #include <ufs/ufs/ufsmount.h> 69 #include <ufs/ufs/ufs_extern.h> 70 71 /* 72 * Load up the contents of an inode and copy the appropriate pieces 73 * to the incore copy. 74 */ 75 void 76 ffs_load_inode(struct buf *bp, struct inode *ip, struct fs *fs, ino_t ino) 77 { 78 struct ufs1_dinode *dp1; 79 struct ufs2_dinode *dp2; 80 81 if (ip->i_ump->um_fstype == UFS1) { 82 dp1 = (struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ino); 83 #ifdef FFS_EI 84 if (UFS_FSNEEDSWAP(fs)) 85 ffs_dinode1_swap(dp1, ip->i_din.ffs1_din); 86 else 87 #endif 88 *ip->i_din.ffs1_din = *dp1; 89 90 ip->i_mode = ip->i_ffs1_mode; 91 ip->i_nlink = ip->i_ffs1_nlink; 92 ip->i_size = ip->i_ffs1_size; 93 ip->i_flags = ip->i_ffs1_flags; 94 ip->i_gen = ip->i_ffs1_gen; 95 ip->i_uid = ip->i_ffs1_uid; 96 ip->i_gid = ip->i_ffs1_gid; 97 } else { 98 dp2 = (struct ufs2_dinode *)bp->b_data + ino_to_fsbo(fs, ino); 99 #ifdef FFS_EI 100 if (UFS_FSNEEDSWAP(fs)) 101 ffs_dinode2_swap(dp2, ip->i_din.ffs2_din); 102 else 103 #endif 104 *ip->i_din.ffs2_din = *dp2; 105 106 ip->i_mode = ip->i_ffs2_mode; 107 ip->i_nlink = ip->i_ffs2_nlink; 108 ip->i_size = ip->i_ffs2_size; 109 ip->i_flags = ip->i_ffs2_flags; 110 ip->i_gen = ip->i_ffs2_gen; 111 ip->i_uid = ip->i_ffs2_uid; 112 ip->i_gid = ip->i_ffs2_gid; 113 } 114 } 115 116 int 117 ffs_getblk(struct vnode *vp, daddr_t lblkno, daddr_t blkno, int size, 118 bool clearbuf, buf_t **bpp) 119 { 120 int error = 0; 121 122 KASSERT(blkno >= 0 || blkno == FFS_NOBLK); 123 124 if ((*bpp = getblk(vp, lblkno, size, 0, 0)) == NULL) 125 return ENOMEM; 126 if (blkno != FFS_NOBLK) 127 (*bpp)->b_blkno = blkno; 128 if (clearbuf) 129 clrbuf(*bpp); 130 if ((*bpp)->b_blkno >= 0 && (error = fscow_run(*bpp, false)) != 0) 131 brelse(*bpp, BC_INVAL); 132 return error; 133 } 134 135 #endif /* _KERNEL */ 136 137 /* 138 * Update the frsum fields to reflect addition or deletion 139 * of some frags. 140 */ 141 void 142 ffs_fragacct(struct fs *fs, int fragmap, int32_t fraglist[], int cnt, 143 int needswap) 144 { 145 int inblk; 146 int field, subfield; 147 int siz, pos; 148 149 inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1; 150 fragmap <<= 1; 151 for (siz = 1; siz < fs->fs_frag; siz++) { 152 if ((inblk & (1 << (siz + (fs->fs_frag & (NBBY - 1))))) == 0) 153 continue; 154 field = around[siz]; 155 subfield = inside[siz]; 156 for (pos = siz; pos <= fs->fs_frag; pos++) { 157 if ((fragmap & field) == subfield) { 158 fraglist[siz] = ufs_rw32( 159 ufs_rw32(fraglist[siz], needswap) + cnt, 160 needswap); 161 pos += siz; 162 field <<= siz; 163 subfield <<= siz; 164 } 165 field <<= 1; 166 subfield <<= 1; 167 } 168 } 169 } 170 171 /* 172 * block operations 173 * 174 * check if a block is available 175 * returns true if all the correponding bits in the free map are 1 176 * returns false if any corresponding bit in the free map is 0 177 */ 178 int 179 ffs_isblock(struct fs *fs, u_char *cp, int32_t h) 180 { 181 u_char mask; 182 183 switch ((int)fs->fs_fragshift) { 184 case 3: 185 return (cp[h] == 0xff); 186 case 2: 187 mask = 0x0f << ((h & 0x1) << 2); 188 return ((cp[h >> 1] & mask) == mask); 189 case 1: 190 mask = 0x03 << ((h & 0x3) << 1); 191 return ((cp[h >> 2] & mask) == mask); 192 case 0: 193 mask = 0x01 << (h & 0x7); 194 return ((cp[h >> 3] & mask) == mask); 195 default: 196 panic("ffs_isblock: unknown fs_fragshift %d", 197 (int)fs->fs_fragshift); 198 } 199 } 200 201 /* 202 * check if a block is completely allocated 203 * returns true if all the corresponding bits in the free map are 0 204 * returns false if any corresponding bit in the free map is 1 205 */ 206 int 207 ffs_isfreeblock(struct fs *fs, u_char *cp, int32_t h) 208 { 209 210 switch ((int)fs->fs_fragshift) { 211 case 3: 212 return (cp[h] == 0); 213 case 2: 214 return ((cp[h >> 1] & (0x0f << ((h & 0x1) << 2))) == 0); 215 case 1: 216 return ((cp[h >> 2] & (0x03 << ((h & 0x3) << 1))) == 0); 217 case 0: 218 return ((cp[h >> 3] & (0x01 << (h & 0x7))) == 0); 219 default: 220 panic("ffs_isfreeblock: unknown fs_fragshift %d", 221 (int)fs->fs_fragshift); 222 } 223 } 224 225 /* 226 * take a block out of the map 227 */ 228 void 229 ffs_clrblock(struct fs *fs, u_char *cp, int32_t h) 230 { 231 232 switch ((int)fs->fs_fragshift) { 233 case 3: 234 cp[h] = 0; 235 return; 236 case 2: 237 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); 238 return; 239 case 1: 240 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); 241 return; 242 case 0: 243 cp[h >> 3] &= ~(0x01 << (h & 0x7)); 244 return; 245 default: 246 panic("ffs_clrblock: unknown fs_fragshift %d", 247 (int)fs->fs_fragshift); 248 } 249 } 250 251 /* 252 * put a block into the map 253 */ 254 void 255 ffs_setblock(struct fs *fs, u_char *cp, int32_t h) 256 { 257 258 switch ((int)fs->fs_fragshift) { 259 case 3: 260 cp[h] = 0xff; 261 return; 262 case 2: 263 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); 264 return; 265 case 1: 266 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); 267 return; 268 case 0: 269 cp[h >> 3] |= (0x01 << (h & 0x7)); 270 return; 271 default: 272 panic("ffs_setblock: unknown fs_fragshift %d", 273 (int)fs->fs_fragshift); 274 } 275 } 276 277 /* 278 * Update the cluster map because of an allocation or free. 279 * 280 * Cnt == 1 means free; cnt == -1 means allocating. 281 */ 282 void 283 ffs_clusteracct(struct fs *fs, struct cg *cgp, int32_t blkno, int cnt) 284 { 285 int32_t *sump; 286 int32_t *lp; 287 u_char *freemapp, *mapp; 288 int i, start, end, forw, back, map, bit; 289 #ifdef FFS_EI 290 const int needswap = UFS_FSNEEDSWAP(fs); 291 #endif 292 293 /* KASSERT(mutex_owned(&ump->um_lock)); */ 294 295 if (fs->fs_contigsumsize <= 0) 296 return; 297 freemapp = cg_clustersfree(cgp, needswap); 298 sump = cg_clustersum(cgp, needswap); 299 /* 300 * Allocate or clear the actual block. 301 */ 302 if (cnt > 0) 303 setbit(freemapp, blkno); 304 else 305 clrbit(freemapp, blkno); 306 /* 307 * Find the size of the cluster going forward. 308 */ 309 start = blkno + 1; 310 end = start + fs->fs_contigsumsize; 311 if (end >= ufs_rw32(cgp->cg_nclusterblks, needswap)) 312 end = ufs_rw32(cgp->cg_nclusterblks, needswap); 313 mapp = &freemapp[start / NBBY]; 314 map = *mapp++; 315 bit = 1 << (start % NBBY); 316 for (i = start; i < end; i++) { 317 if ((map & bit) == 0) 318 break; 319 if ((i & (NBBY - 1)) != (NBBY - 1)) { 320 bit <<= 1; 321 } else { 322 map = *mapp++; 323 bit = 1; 324 } 325 } 326 forw = i - start; 327 /* 328 * Find the size of the cluster going backward. 329 */ 330 start = blkno - 1; 331 end = start - fs->fs_contigsumsize; 332 if (end < 0) 333 end = -1; 334 mapp = &freemapp[start / NBBY]; 335 map = *mapp--; 336 bit = 1 << (start % NBBY); 337 for (i = start; i > end; i--) { 338 if ((map & bit) == 0) 339 break; 340 if ((i & (NBBY - 1)) != 0) { 341 bit >>= 1; 342 } else { 343 map = *mapp--; 344 bit = 1 << (NBBY - 1); 345 } 346 } 347 back = start - i; 348 /* 349 * Account for old cluster and the possibly new forward and 350 * back clusters. 351 */ 352 i = back + forw + 1; 353 if (i > fs->fs_contigsumsize) 354 i = fs->fs_contigsumsize; 355 ufs_add32(sump[i], cnt, needswap); 356 if (back > 0) 357 ufs_add32(sump[back], -cnt, needswap); 358 if (forw > 0) 359 ufs_add32(sump[forw], -cnt, needswap); 360 361 /* 362 * Update cluster summary information. 363 */ 364 lp = &sump[fs->fs_contigsumsize]; 365 for (i = fs->fs_contigsumsize; i > 0; i--) 366 if (ufs_rw32(*lp--, needswap) > 0) 367 break; 368 #if defined(_KERNEL) 369 fs->fs_maxcluster[ufs_rw32(cgp->cg_cgx, needswap)] = i; 370 #endif 371 } 372
Indexes created Tue Sep 30 17:09:57 GMT 2025