1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 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 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 #include <sys/param.h> 38 39 #ifndef _KERNEL 40 #include <stdio.h> 41 #include <string.h> 42 #include <stdlib.h> 43 #include <time.h> 44 #include <sys/errno.h> 45 #include <ufs/ufs/dinode.h> 46 #include <ufs/ffs/fs.h> 47 48 struct malloc_type; 49 #define UFS_MALLOC(size, type, flags) malloc(size) 50 #define UFS_FREE(ptr, type) free(ptr) 51 #define UFS_TIME time(NULL) 52 53 #else /* _KERNEL */ 54 #include <sys/systm.h> 55 #include <sys/lock.h> 56 #include <sys/malloc.h> 57 #include <sys/mount.h> 58 #include <sys/vnode.h> 59 #include <sys/bio.h> 60 #include <sys/buf.h> 61 #include <sys/ucred.h> 62 63 #include <ufs/ufs/quota.h> 64 #include <ufs/ufs/inode.h> 65 #include <ufs/ufs/extattr.h> 66 #include <ufs/ufs/ufsmount.h> 67 #include <ufs/ufs/ufs_extern.h> 68 #include <ufs/ffs/ffs_extern.h> 69 #include <ufs/ffs/fs.h> 70 71 #define UFS_MALLOC(size, type, flags) malloc(size, type, flags) 72 #define UFS_FREE(ptr, type) free(ptr, type) 73 #define UFS_TIME time_second 74 75 /* 76 * Return buffer with the contents of block "offset" from the beginning of 77 * directory "ip". If "res" is non-zero, fill it in with a pointer to the 78 * remaining space in the directory. 79 */ 80 int 81 ffs_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp) 82 { 83 struct inode *ip; 84 struct fs *fs; 85 struct buf *bp; 86 ufs_lbn_t lbn; 87 int bsize, error; 88 89 ip = VTOI(vp); 90 fs = ITOFS(ip); 91 lbn = lblkno(fs, offset); 92 bsize = blksize(fs, ip, lbn); 93 94 *bpp = NULL; 95 error = bread(vp, lbn, bsize, NOCRED, &bp); 96 if (error) { 97 brelse(bp); 98 return (error); 99 } 100 if (res) 101 *res = (char *)bp->b_data + blkoff(fs, offset); 102 *bpp = bp; 103 return (0); 104 } 105 106 /* 107 * Load up the contents of an inode and copy the appropriate pieces 108 * to the incore copy. 109 */ 110 void 111 ffs_load_inode(struct buf *bp, struct inode *ip, struct fs *fs, ino_t ino) 112 { 113 114 if (I_IS_UFS1(ip)) { 115 *ip->i_din1 = 116 *((struct ufs1_dinode *)bp->b_data + ino_to_fsbo(fs, ino)); 117 ip->i_mode = ip->i_din1->di_mode; 118 ip->i_nlink = ip->i_din1->di_nlink; 119 ip->i_size = ip->i_din1->di_size; 120 ip->i_flags = ip->i_din1->di_flags; 121 ip->i_gen = ip->i_din1->di_gen; 122 ip->i_uid = ip->i_din1->di_uid; 123 ip->i_gid = ip->i_din1->di_gid; 124 } else { 125 *ip->i_din2 = 126 *((struct ufs2_dinode *)bp->b_data + ino_to_fsbo(fs, ino)); 127 ip->i_mode = ip->i_din2->di_mode; 128 ip->i_nlink = ip->i_din2->di_nlink; 129 ip->i_size = ip->i_din2->di_size; 130 ip->i_flags = ip->i_din2->di_flags; 131 ip->i_gen = ip->i_din2->di_gen; 132 ip->i_uid = ip->i_din2->di_uid; 133 ip->i_gid = ip->i_din2->di_gid; 134 } 135 } 136 #endif /* KERNEL */ 137 138 /* 139 * These are the low-level functions that actually read and write 140 * the superblock and its associated data. 141 */ 142 static off_t sblock_try[] = SBLOCKSEARCH; 143 static int readsuper(void *, struct fs **, off_t, 144 int (*)(void *, off_t, void **, int)); 145 146 /* 147 * Read a superblock from the devfd device. 148 * 149 * If an alternate superblock is specified, it is read. Otherwise the 150 * set of locations given in the SBLOCKSEARCH list is searched for a 151 * superblock. Memory is allocated for the superblock by the readfunc and 152 * is returned. If filltype is non-NULL, additional memory is allocated 153 * of type filltype and filled in with the superblock summary information. 154 * 155 * If a superblock is found, zero is returned. Otherwise one of the 156 * following error values is returned: 157 * EIO: non-existent or truncated superblock. 158 * EIO: error reading summary information. 159 * ENOENT: no usable known superblock found. 160 * ENOSPC: failed to allocate space for the superblock. 161 * EINVAL: The previous newfs operation on this volume did not complete. 162 * The administrator must complete newfs before using this volume. 163 */ 164 int 165 ffs_sbget(void *devfd, struct fs **fsp, off_t altsuperblock, 166 struct malloc_type *filltype, 167 int (*readfunc)(void *devfd, off_t loc, void **bufp, int size)) 168 { 169 struct fs *fs; 170 int i, ret, size, blks; 171 uint8_t *space; 172 int32_t *lp; 173 char *buf; 174 175 if (altsuperblock != -1) { 176 if ((ret = readsuper(devfd, fsp, altsuperblock, readfunc)) != 0) 177 return (ret); 178 } else { 179 for (i = 0; sblock_try[i] != -1; i++) { 180 if ((ret = readsuper(devfd, fsp, sblock_try[i], 181 readfunc)) == 0) 182 break; 183 if (ret == ENOENT) 184 continue; 185 return (ret); 186 } 187 if (sblock_try[i] == -1) 188 return (ENOENT); 189 } 190 /* 191 * If not filling in summary information, NULL out fs_csp and return. 192 */ 193 fs = *fsp; 194 if (filltype == NULL) { 195 fs->fs_csp = NULL; 196 return (0); 197 } 198 /* 199 * Read in the superblock summary information. 200 */ 201 size = fs->fs_cssize; 202 blks = howmany(size, fs->fs_fsize); 203 if (fs->fs_contigsumsize > 0) 204 size += fs->fs_ncg * sizeof(int32_t); 205 size += fs->fs_ncg * sizeof(u_int8_t); 206 space = UFS_MALLOC(size, filltype, M_WAITOK); 207 fs->fs_csp = (struct csum *)space; 208 for (i = 0; i < blks; i += fs->fs_frag) { 209 size = fs->fs_bsize; 210 if (i + fs->fs_frag > blks) 211 size = (blks - i) * fs->fs_fsize; 212 ret = (*readfunc)(devfd, 213 dbtob(fsbtodb(fs, fs->fs_csaddr + i)), (void **)&buf, size); 214 if (ret) { 215 UFS_FREE(fs->fs_csp, filltype); 216 fs->fs_csp = NULL; 217 return (ret); 218 } 219 memcpy(space, buf, size); 220 UFS_FREE(buf, filltype); 221 space += size; 222 } 223 if (fs->fs_contigsumsize > 0) { 224 fs->fs_maxcluster = lp = (int32_t *)space; 225 for (i = 0; i < fs->fs_ncg; i++) 226 *lp++ = fs->fs_contigsumsize; 227 space = (uint8_t *)lp; 228 } 229 size = fs->fs_ncg * sizeof(u_int8_t); 230 fs->fs_contigdirs = (u_int8_t *)space; 231 bzero(fs->fs_contigdirs, size); 232 return (0); 233 } 234 235 /* 236 * Try to read a superblock from the location specified by sblockloc. 237 * Return zero on success or an errno on failure. 238 */ 239 static int 240 readsuper(void *devfd, struct fs **fsp, off_t sblockloc, 241 int (*readfunc)(void *devfd, off_t loc, void **bufp, int size)) 242 { 243 struct fs *fs; 244 int error; 245 246 error = (*readfunc)(devfd, sblockloc, (void **)fsp, SBLOCKSIZE); 247 if (error != 0) 248 return (error); 249 fs = *fsp; 250 if (fs->fs_magic == FS_BAD_MAGIC) 251 return (EINVAL); 252 if (((fs->fs_magic == FS_UFS1_MAGIC && sblockloc <= SBLOCK_UFS1) || 253 (fs->fs_magic == FS_UFS2_MAGIC && 254 sblockloc == fs->fs_sblockloc)) && 255 fs->fs_ncg >= 1 && 256 fs->fs_bsize >= MINBSIZE && 257 fs->fs_bsize <= MAXBSIZE && 258 fs->fs_bsize >= roundup(sizeof(struct fs), DEV_BSIZE)) { 259 /* Have to set for old filesystems that predate this field */ 260 fs->fs_sblockactualloc = sblockloc; 261 return (0); 262 } 263 return (ENOENT); 264 } 265 266 /* 267 * Write a superblock to the devfd device from the memory pointed to by fs. 268 * Write out the superblock summary information if it is present. 269 * 270 * If the write is successful, zero is returned. Otherwise one of the 271 * following error values is returned: 272 * EIO: failed to write superblock. 273 * EIO: failed to write superblock summary information. 274 */ 275 int 276 ffs_sbput(void *devfd, struct fs *fs, off_t loc, 277 int (*writefunc)(void *devfd, off_t loc, void *buf, int size)) 278 { 279 int i, error, blks, size; 280 uint8_t *space; 281 282 /* 283 * If there is summary information, write it first, so if there 284 * is an error, the superblock will not be marked as clean. 285 */ 286 if (fs->fs_csp != NULL) { 287 blks = howmany(fs->fs_cssize, fs->fs_fsize); 288 space = (uint8_t *)fs->fs_csp; 289 for (i = 0; i < blks; i += fs->fs_frag) { 290 size = fs->fs_bsize; 291 if (i + fs->fs_frag > blks) 292 size = (blks - i) * fs->fs_fsize; 293 if ((error = (*writefunc)(devfd, 294 dbtob(fsbtodb(fs, fs->fs_csaddr + i)), 295 space, size)) != 0) 296 return (error); 297 space += size; 298 } 299 } 300 fs->fs_fmod = 0; 301 fs->fs_time = UFS_TIME; 302 if ((error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize)) != 0) 303 return (error); 304 return (0); 305 } 306 307 /* 308 * Update the frsum fields to reflect addition or deletion 309 * of some frags. 310 */ 311 void 312 ffs_fragacct(struct fs *fs, int fragmap, int32_t fraglist[], int cnt) 313 { 314 int inblk; 315 int field, subfield; 316 int siz, pos; 317 318 inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1; 319 fragmap <<= 1; 320 for (siz = 1; siz < fs->fs_frag; siz++) { 321 if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0) 322 continue; 323 field = around[siz]; 324 subfield = inside[siz]; 325 for (pos = siz; pos <= fs->fs_frag; pos++) { 326 if ((fragmap & field) == subfield) { 327 fraglist[siz] += cnt; 328 pos += siz; 329 field <<= siz; 330 subfield <<= siz; 331 } 332 field <<= 1; 333 subfield <<= 1; 334 } 335 } 336 } 337 338 /* 339 * block operations 340 * 341 * check if a block is available 342 */ 343 int 344 ffs_isblock(struct fs *fs, unsigned char *cp, ufs1_daddr_t h) 345 { 346 unsigned char mask; 347 348 switch ((int)fs->fs_frag) { 349 case 8: 350 return (cp[h] == 0xff); 351 case 4: 352 mask = 0x0f << ((h & 0x1) << 2); 353 return ((cp[h >> 1] & mask) == mask); 354 case 2: 355 mask = 0x03 << ((h & 0x3) << 1); 356 return ((cp[h >> 2] & mask) == mask); 357 case 1: 358 mask = 0x01 << (h & 0x7); 359 return ((cp[h >> 3] & mask) == mask); 360 default: 361 #ifdef _KERNEL 362 panic("ffs_isblock"); 363 #endif 364 break; 365 } 366 return (0); 367 } 368 369 /* 370 * check if a block is free 371 */ 372 int 373 ffs_isfreeblock(struct fs *fs, u_char *cp, ufs1_daddr_t h) 374 { 375 376 switch ((int)fs->fs_frag) { 377 case 8: 378 return (cp[h] == 0); 379 case 4: 380 return ((cp[h >> 1] & (0x0f << ((h & 0x1) << 2))) == 0); 381 case 2: 382 return ((cp[h >> 2] & (0x03 << ((h & 0x3) << 1))) == 0); 383 case 1: 384 return ((cp[h >> 3] & (0x01 << (h & 0x7))) == 0); 385 default: 386 #ifdef _KERNEL 387 panic("ffs_isfreeblock"); 388 #endif 389 break; 390 } 391 return (0); 392 } 393 394 /* 395 * take a block out of the map 396 */ 397 void 398 ffs_clrblock(struct fs *fs, u_char *cp, ufs1_daddr_t h) 399 { 400 401 switch ((int)fs->fs_frag) { 402 case 8: 403 cp[h] = 0; 404 return; 405 case 4: 406 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); 407 return; 408 case 2: 409 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); 410 return; 411 case 1: 412 cp[h >> 3] &= ~(0x01 << (h & 0x7)); 413 return; 414 default: 415 #ifdef _KERNEL 416 panic("ffs_clrblock"); 417 #endif 418 break; 419 } 420 } 421 422 /* 423 * put a block into the map 424 */ 425 void 426 ffs_setblock(struct fs *fs, unsigned char *cp, ufs1_daddr_t h) 427 { 428 429 switch ((int)fs->fs_frag) { 430 431 case 8: 432 cp[h] = 0xff; 433 return; 434 case 4: 435 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); 436 return; 437 case 2: 438 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); 439 return; 440 case 1: 441 cp[h >> 3] |= (0x01 << (h & 0x7)); 442 return; 443 default: 444 #ifdef _KERNEL 445 panic("ffs_setblock"); 446 #endif 447 break; 448 } 449 } 450 451 /* 452 * Update the cluster map because of an allocation or free. 453 * 454 * Cnt == 1 means free; cnt == -1 means allocating. 455 */ 456 void 457 ffs_clusteracct(struct fs *fs, struct cg *cgp, ufs1_daddr_t blkno, int cnt) 458 { 459 int32_t *sump; 460 int32_t *lp; 461 u_char *freemapp, *mapp; 462 int i, start, end, forw, back, map, bit; 463 464 if (fs->fs_contigsumsize <= 0) 465 return; 466 freemapp = cg_clustersfree(cgp); 467 sump = cg_clustersum(cgp); 468 /* 469 * Allocate or clear the actual block. 470 */ 471 if (cnt > 0) 472 setbit(freemapp, blkno); 473 else 474 clrbit(freemapp, blkno); 475 /* 476 * Find the size of the cluster going forward. 477 */ 478 start = blkno + 1; 479 end = start + fs->fs_contigsumsize; 480 if (end >= cgp->cg_nclusterblks) 481 end = cgp->cg_nclusterblks; 482 mapp = &freemapp[start / NBBY]; 483 map = *mapp++; 484 bit = 1 << (start % NBBY); 485 for (i = start; i < end; i++) { 486 if ((map & bit) == 0) 487 break; 488 if ((i & (NBBY - 1)) != (NBBY - 1)) { 489 bit <<= 1; 490 } else { 491 map = *mapp++; 492 bit = 1; 493 } 494 } 495 forw = i - start; 496 /* 497 * Find the size of the cluster going backward. 498 */ 499 start = blkno - 1; 500 end = start - fs->fs_contigsumsize; 501 if (end < 0) 502 end = -1; 503 mapp = &freemapp[start / NBBY]; 504 map = *mapp--; 505 bit = 1 << (start % NBBY); 506 for (i = start; i > end; i--) { 507 if ((map & bit) == 0) 508 break; 509 if ((i & (NBBY - 1)) != 0) { 510 bit >>= 1; 511 } else { 512 map = *mapp--; 513 bit = 1 << (NBBY - 1); 514 } 515 } 516 back = start - i; 517 /* 518 * Account for old cluster and the possibly new forward and 519 * back clusters. 520 */ 521 i = back + forw + 1; 522 if (i > fs->fs_contigsumsize) 523 i = fs->fs_contigsumsize; 524 sump[i] += cnt; 525 if (back > 0) 526 sump[back] -= cnt; 527 if (forw > 0) 528 sump[forw] -= cnt; 529 /* 530 * Update cluster summary information. 531 */ 532 lp = &sump[fs->fs_contigsumsize]; 533 for (i = fs->fs_contigsumsize; i > 0; i--) 534 if (*lp-- > 0) 535 break; 536 fs->fs_maxcluster[cgp->cg_cgx] = i; 537 } 538