160727d8bSWarner Losh /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 4df8bae1dSRodney W. Grimes * Copyright (c) 1982, 1986, 1989, 1993 5df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 6df8bae1dSRodney W. Grimes * 7df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 8df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 9df8bae1dSRodney W. Grimes * are met: 10df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 12df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 13df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 14df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 1515c377c3SEd Maste * 3. Neither the name of the University nor the names of its contributors 16df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 17df8bae1dSRodney W. Grimes * without specific prior written permission. 18df8bae1dSRodney W. Grimes * 19df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29df8bae1dSRodney W. Grimes * SUCH DAMAGE. 30df8bae1dSRodney W. Grimes * 31996c772fSJohn Dyson * @(#)ffs_subr.c 8.5 (Berkeley) 3/21/95 32df8bae1dSRodney W. Grimes */ 33df8bae1dSRodney W. Grimes 34f4636c59SDavid E. O'Brien #include <sys/cdefs.h> 35f4636c59SDavid E. O'Brien __FBSDID("$FreeBSD$"); 36f4636c59SDavid E. O'Brien 37df8bae1dSRodney W. Grimes #include <sys/param.h> 38df8bae1dSRodney W. Grimes 39c4473420SPeter Wemm #ifndef _KERNEL 40dffce215SKirk McKusick #include <stdio.h> 41dffce215SKirk McKusick #include <string.h> 42dffce215SKirk McKusick #include <stdlib.h> 43dffce215SKirk McKusick #include <time.h> 44dffce215SKirk McKusick #include <sys/errno.h> 45996c772fSJohn Dyson #include <ufs/ufs/dinode.h> 461c85e6a3SKirk McKusick #include <ufs/ffs/fs.h> 47dffce215SKirk McKusick 48ec888383SKirk McKusick uint32_t calculate_crc32c(uint32_t, const void *, size_t); 49ade67b50SKirk McKusick uint32_t ffs_calc_sbhash(struct fs *); 50dffce215SKirk McKusick struct malloc_type; 51dffce215SKirk McKusick #define UFS_MALLOC(size, type, flags) malloc(size) 52dffce215SKirk McKusick #define UFS_FREE(ptr, type) free(ptr) 53fb14e73cSKirk McKusick /* 54fb14e73cSKirk McKusick * Request standard superblock location in ffs_sbget 55fb14e73cSKirk McKusick */ 56fb14e73cSKirk McKusick #define STDSB -1 /* Fail if check-hash is bad */ 57fb14e73cSKirk McKusick #define STDSB_NOHASHFAIL -2 /* Ignore check-hash failure */ 58dffce215SKirk McKusick 59dffce215SKirk McKusick #else /* _KERNEL */ 60df8bae1dSRodney W. Grimes #include <sys/systm.h> 61f89d2072SXin LI #include <sys/gsb_crc32.h> 621cd52ec3SBruce Evans #include <sys/lock.h> 631c85e6a3SKirk McKusick #include <sys/malloc.h> 641c85e6a3SKirk McKusick #include <sys/mount.h> 65df8bae1dSRodney W. Grimes #include <sys/vnode.h> 669626b608SPoul-Henning Kamp #include <sys/bio.h> 67df8bae1dSRodney W. Grimes #include <sys/buf.h> 6808637435SBruce Evans #include <sys/ucred.h> 6908637435SBruce Evans 70df8bae1dSRodney W. Grimes #include <ufs/ufs/quota.h> 71df8bae1dSRodney W. Grimes #include <ufs/ufs/inode.h> 721c85e6a3SKirk McKusick #include <ufs/ufs/extattr.h> 731c85e6a3SKirk McKusick #include <ufs/ufs/ufsmount.h> 741c85e6a3SKirk McKusick #include <ufs/ufs/ufs_extern.h> 75996c772fSJohn Dyson #include <ufs/ffs/ffs_extern.h> 761c85e6a3SKirk McKusick #include <ufs/ffs/fs.h> 77df8bae1dSRodney W. Grimes 78dffce215SKirk McKusick #define UFS_MALLOC(size, type, flags) malloc(size, type, flags) 79dffce215SKirk McKusick #define UFS_FREE(ptr, type) free(ptr, type) 80dffce215SKirk McKusick 81fb14e73cSKirk McKusick #endif /* _KERNEL */ 82df8bae1dSRodney W. Grimes 83df8bae1dSRodney W. Grimes /* 848f829a5cSKirk McKusick * Verify an inode check-hash. 858f829a5cSKirk McKusick */ 868f829a5cSKirk McKusick int 878f829a5cSKirk McKusick ffs_verify_dinode_ckhash(struct fs *fs, struct ufs2_dinode *dip) 888f829a5cSKirk McKusick { 89c8f55fc4SKirk McKusick uint32_t ckhash, save_ckhash; 908f829a5cSKirk McKusick 918f829a5cSKirk McKusick /* 928f829a5cSKirk McKusick * Return success if unallocated or we are not doing inode check-hash. 938f829a5cSKirk McKusick */ 948f829a5cSKirk McKusick if (dip->di_mode == 0 || (fs->fs_metackhash & CK_INODE) == 0) 958f829a5cSKirk McKusick return (0); 968f829a5cSKirk McKusick /* 978f829a5cSKirk McKusick * Exclude di_ckhash from the crc32 calculation, e.g., always use 988f829a5cSKirk McKusick * a check-hash value of zero when calculating the check-hash. 998f829a5cSKirk McKusick */ 1008f829a5cSKirk McKusick save_ckhash = dip->di_ckhash; 1018f829a5cSKirk McKusick dip->di_ckhash = 0; 102c8f55fc4SKirk McKusick ckhash = calculate_crc32c(~0L, (void *)dip, sizeof(*dip)); 1038f829a5cSKirk McKusick dip->di_ckhash = save_ckhash; 104c8f55fc4SKirk McKusick if (save_ckhash == ckhash) 1058f829a5cSKirk McKusick return (0); 106c8f55fc4SKirk McKusick return (EINVAL); 1078f829a5cSKirk McKusick } 1088f829a5cSKirk McKusick 1098f829a5cSKirk McKusick /* 1108f829a5cSKirk McKusick * Update an inode check-hash. 1118f829a5cSKirk McKusick */ 1128f829a5cSKirk McKusick void 1138f829a5cSKirk McKusick ffs_update_dinode_ckhash(struct fs *fs, struct ufs2_dinode *dip) 1148f829a5cSKirk McKusick { 1158f829a5cSKirk McKusick 1168f829a5cSKirk McKusick if (dip->di_mode == 0 || (fs->fs_metackhash & CK_INODE) == 0) 1178f829a5cSKirk McKusick return; 1188f829a5cSKirk McKusick /* 1198f829a5cSKirk McKusick * Exclude old di_ckhash from the crc32 calculation, e.g., always use 1208f829a5cSKirk McKusick * a check-hash value of zero when calculating the new check-hash. 1218f829a5cSKirk McKusick */ 1228f829a5cSKirk McKusick dip->di_ckhash = 0; 1238f829a5cSKirk McKusick dip->di_ckhash = calculate_crc32c(~0L, (void *)dip, sizeof(*dip)); 1248f829a5cSKirk McKusick } 1258f829a5cSKirk McKusick 1268f829a5cSKirk McKusick /* 127dffce215SKirk McKusick * These are the low-level functions that actually read and write 128dffce215SKirk McKusick * the superblock and its associated data. 129dffce215SKirk McKusick */ 130dffce215SKirk McKusick static off_t sblock_try[] = SBLOCKSEARCH; 131fb14e73cSKirk McKusick static int readsuper(void *, struct fs **, off_t, int, int, 132dffce215SKirk McKusick int (*)(void *, off_t, void **, int)); 133dffce215SKirk McKusick 134dffce215SKirk McKusick /* 135dffce215SKirk McKusick * Read a superblock from the devfd device. 136dffce215SKirk McKusick * 137dffce215SKirk McKusick * If an alternate superblock is specified, it is read. Otherwise the 138dffce215SKirk McKusick * set of locations given in the SBLOCKSEARCH list is searched for a 139dffce215SKirk McKusick * superblock. Memory is allocated for the superblock by the readfunc and 140dffce215SKirk McKusick * is returned. If filltype is non-NULL, additional memory is allocated 141dffce215SKirk McKusick * of type filltype and filled in with the superblock summary information. 142efbf3964SKirk McKusick * All memory is freed when any error is returned. 143dffce215SKirk McKusick * 144dffce215SKirk McKusick * If a superblock is found, zero is returned. Otherwise one of the 145dffce215SKirk McKusick * following error values is returned: 146dffce215SKirk McKusick * EIO: non-existent or truncated superblock. 147dffce215SKirk McKusick * EIO: error reading summary information. 148dffce215SKirk McKusick * ENOENT: no usable known superblock found. 149dffce215SKirk McKusick * ENOSPC: failed to allocate space for the superblock. 150dffce215SKirk McKusick * EINVAL: The previous newfs operation on this volume did not complete. 151dffce215SKirk McKusick * The administrator must complete newfs before using this volume. 152dffce215SKirk McKusick */ 153dffce215SKirk McKusick int 1544cbd996aSKirk McKusick ffs_sbget(void *devfd, struct fs **fsp, off_t altsblock, 155dffce215SKirk McKusick struct malloc_type *filltype, 156dffce215SKirk McKusick int (*readfunc)(void *devfd, off_t loc, void **bufp, int size)) 157dffce215SKirk McKusick { 158dffce215SKirk McKusick struct fs *fs; 15934816cb9SKirk McKusick struct fs_summary_info *fs_si; 1604cbd996aSKirk McKusick int i, error, size, blks; 161dffce215SKirk McKusick uint8_t *space; 162dffce215SKirk McKusick int32_t *lp; 163fb14e73cSKirk McKusick int chkhash; 164dffce215SKirk McKusick char *buf; 165dffce215SKirk McKusick 166efbf3964SKirk McKusick fs = NULL; 16716759360SMark Johnston *fsp = NULL; 168fb14e73cSKirk McKusick if (altsblock >= 0) { 169996d40f9SKirk McKusick if ((error = readsuper(devfd, &fs, altsblock, 1, 0, 170efbf3964SKirk McKusick readfunc)) != 0) { 171efbf3964SKirk McKusick if (fs != NULL) 172efbf3964SKirk McKusick UFS_FREE(fs, filltype); 1734cbd996aSKirk McKusick return (error); 174efbf3964SKirk McKusick } 175dffce215SKirk McKusick } else { 176996d40f9SKirk McKusick chkhash = 1; 177fb14e73cSKirk McKusick if (altsblock == STDSB_NOHASHFAIL) 178fb14e73cSKirk McKusick chkhash = 0; 179dffce215SKirk McKusick for (i = 0; sblock_try[i] != -1; i++) { 180efbf3964SKirk McKusick if ((error = readsuper(devfd, &fs, sblock_try[i], 0, 181fb14e73cSKirk McKusick chkhash, readfunc)) == 0) 182dffce215SKirk McKusick break; 183efbf3964SKirk McKusick if (fs != NULL) { 184efbf3964SKirk McKusick UFS_FREE(fs, filltype); 185efbf3964SKirk McKusick fs = NULL; 186efbf3964SKirk McKusick } 1874cbd996aSKirk McKusick if (error == ENOENT) 188dffce215SKirk McKusick continue; 1894cbd996aSKirk McKusick return (error); 190dffce215SKirk McKusick } 191dffce215SKirk McKusick if (sblock_try[i] == -1) 192dffce215SKirk McKusick return (ENOENT); 193dffce215SKirk McKusick } 194dffce215SKirk McKusick /* 195dffce215SKirk McKusick * Read in the superblock summary information. 196dffce215SKirk McKusick */ 197dffce215SKirk McKusick size = fs->fs_cssize; 198dffce215SKirk McKusick blks = howmany(size, fs->fs_fsize); 199dffce215SKirk McKusick if (fs->fs_contigsumsize > 0) 200dffce215SKirk McKusick size += fs->fs_ncg * sizeof(int32_t); 201dffce215SKirk McKusick size += fs->fs_ncg * sizeof(u_int8_t); 202efbf3964SKirk McKusick /* When running in libufs or libsa, UFS_MALLOC may fail */ 20334816cb9SKirk McKusick if ((fs_si = UFS_MALLOC(sizeof(*fs_si), filltype, M_WAITOK)) == NULL) { 20434816cb9SKirk McKusick UFS_FREE(fs, filltype); 20534816cb9SKirk McKusick return (ENOSPC); 20634816cb9SKirk McKusick } 20734816cb9SKirk McKusick bzero(fs_si, sizeof(*fs_si)); 20834816cb9SKirk McKusick fs->fs_si = fs_si; 209efbf3964SKirk McKusick if ((space = UFS_MALLOC(size, filltype, M_WAITOK)) == NULL) { 21034816cb9SKirk McKusick UFS_FREE(fs->fs_si, filltype); 211efbf3964SKirk McKusick UFS_FREE(fs, filltype); 212efbf3964SKirk McKusick return (ENOSPC); 213efbf3964SKirk McKusick } 214dffce215SKirk McKusick fs->fs_csp = (struct csum *)space; 215dffce215SKirk McKusick for (i = 0; i < blks; i += fs->fs_frag) { 216dffce215SKirk McKusick size = fs->fs_bsize; 217dffce215SKirk McKusick if (i + fs->fs_frag > blks) 218dffce215SKirk McKusick size = (blks - i) * fs->fs_fsize; 21916759360SMark Johnston buf = NULL; 2204cbd996aSKirk McKusick error = (*readfunc)(devfd, 221dffce215SKirk McKusick dbtob(fsbtodb(fs, fs->fs_csaddr + i)), (void **)&buf, size); 2224cbd996aSKirk McKusick if (error) { 223efbf3964SKirk McKusick if (buf != NULL) 22416759360SMark Johnston UFS_FREE(buf, filltype); 225dffce215SKirk McKusick UFS_FREE(fs->fs_csp, filltype); 22634816cb9SKirk McKusick UFS_FREE(fs->fs_si, filltype); 227efbf3964SKirk McKusick UFS_FREE(fs, filltype); 2284cbd996aSKirk McKusick return (error); 229dffce215SKirk McKusick } 230dffce215SKirk McKusick memcpy(space, buf, size); 231dffce215SKirk McKusick UFS_FREE(buf, filltype); 232dffce215SKirk McKusick space += size; 233dffce215SKirk McKusick } 234dffce215SKirk McKusick if (fs->fs_contigsumsize > 0) { 235dffce215SKirk McKusick fs->fs_maxcluster = lp = (int32_t *)space; 236dffce215SKirk McKusick for (i = 0; i < fs->fs_ncg; i++) 237dffce215SKirk McKusick *lp++ = fs->fs_contigsumsize; 238dffce215SKirk McKusick space = (uint8_t *)lp; 239dffce215SKirk McKusick } 240dffce215SKirk McKusick size = fs->fs_ncg * sizeof(u_int8_t); 241dffce215SKirk McKusick fs->fs_contigdirs = (u_int8_t *)space; 242dffce215SKirk McKusick bzero(fs->fs_contigdirs, size); 243efbf3964SKirk McKusick *fsp = fs; 244dffce215SKirk McKusick return (0); 245dffce215SKirk McKusick } 246dffce215SKirk McKusick 247dffce215SKirk McKusick /* 248dffce215SKirk McKusick * Try to read a superblock from the location specified by sblockloc. 249dffce215SKirk McKusick * Return zero on success or an errno on failure. 250dffce215SKirk McKusick */ 251dffce215SKirk McKusick static int 252528833faSKirk McKusick readsuper(void *devfd, struct fs **fsp, off_t sblockloc, int isaltsblk, 253fb14e73cSKirk McKusick int chkhash, int (*readfunc)(void *devfd, off_t loc, void **bufp, int size)) 254dffce215SKirk McKusick { 255dffce215SKirk McKusick struct fs *fs; 256ec888383SKirk McKusick int error, res; 257ec888383SKirk McKusick uint32_t ckhash; 258dffce215SKirk McKusick 259dffce215SKirk McKusick error = (*readfunc)(devfd, sblockloc, (void **)fsp, SBLOCKSIZE); 260dffce215SKirk McKusick if (error != 0) 261dffce215SKirk McKusick return (error); 262dffce215SKirk McKusick fs = *fsp; 263dffce215SKirk McKusick if (fs->fs_magic == FS_BAD_MAGIC) 264dffce215SKirk McKusick return (EINVAL); 265528833faSKirk McKusick if (((fs->fs_magic == FS_UFS1_MAGIC && (isaltsblk || 2664cbd996aSKirk McKusick sblockloc <= SBLOCK_UFS1)) || 267528833faSKirk McKusick (fs->fs_magic == FS_UFS2_MAGIC && (isaltsblk || 2684cbd996aSKirk McKusick sblockloc == fs->fs_sblockloc))) && 269dffce215SKirk McKusick fs->fs_ncg >= 1 && 270dffce215SKirk McKusick fs->fs_bsize >= MINBSIZE && 271dffce215SKirk McKusick fs->fs_bsize <= MAXBSIZE && 272ec888383SKirk McKusick fs->fs_bsize >= roundup(sizeof(struct fs), DEV_BSIZE) && 273ec888383SKirk McKusick fs->fs_sbsize <= SBLOCKSIZE) { 274a02bd3e3SKirk McKusick /* 275a02bd3e3SKirk McKusick * If the filesystem has been run on a kernel without 276a02bd3e3SKirk McKusick * metadata check hashes, disable them. 277a02bd3e3SKirk McKusick */ 278a02bd3e3SKirk McKusick if ((fs->fs_flags & FS_METACKHASH) == 0) 279a02bd3e3SKirk McKusick fs->fs_metackhash = 0; 280996d40f9SKirk McKusick /* 281996d40f9SKirk McKusick * Clear any check-hashes that are not maintained 282996d40f9SKirk McKusick * by this kernel. Also clear any unsupported flags. 283996d40f9SKirk McKusick */ 284996d40f9SKirk McKusick fs->fs_metackhash &= CK_SUPPORTED; 285996d40f9SKirk McKusick fs->fs_flags &= FS_SUPPORTED; 286ade67b50SKirk McKusick if (fs->fs_ckhash != (ckhash = ffs_calc_sbhash(fs))) { 287ec888383SKirk McKusick #ifdef _KERNEL 288ec888383SKirk McKusick res = uprintf("Superblock check-hash failed: recorded " 289fb14e73cSKirk McKusick "check-hash 0x%x != computed check-hash 0x%x%s\n", 290fb14e73cSKirk McKusick fs->fs_ckhash, ckhash, 291fb14e73cSKirk McKusick chkhash == 0 ? " (Ignored)" : ""); 292ec888383SKirk McKusick #else 293ec888383SKirk McKusick res = 0; 294ec888383SKirk McKusick #endif 295ec888383SKirk McKusick /* 296ec888383SKirk McKusick * Print check-hash failure if no controlling terminal 297ec888383SKirk McKusick * in kernel or always if in user-mode (libufs). 298ec888383SKirk McKusick */ 299ec888383SKirk McKusick if (res == 0) 300ec888383SKirk McKusick printf("Superblock check-hash failed: recorded " 301ec888383SKirk McKusick "check-hash 0x%x != computed check-hash " 302fb14e73cSKirk McKusick "0x%x%s\n", fs->fs_ckhash, ckhash, 303fb14e73cSKirk McKusick chkhash == 0 ? " (Ignored)" : ""); 304fb14e73cSKirk McKusick if (chkhash == 0) { 305fb14e73cSKirk McKusick fs->fs_flags |= FS_NEEDSFSCK; 306fb14e73cSKirk McKusick fs->fs_fmod = 1; 307fb14e73cSKirk McKusick return (0); 308fb14e73cSKirk McKusick } 309fb14e73cSKirk McKusick fs->fs_fmod = 0; 31095ca762dSKirk McKusick return (EINTEGRITY); 311ec888383SKirk McKusick } 312dffce215SKirk McKusick /* Have to set for old filesystems that predate this field */ 313dffce215SKirk McKusick fs->fs_sblockactualloc = sblockloc; 314efbf3964SKirk McKusick /* Not yet any summary information */ 31534816cb9SKirk McKusick fs->fs_si = NULL; 316dffce215SKirk McKusick return (0); 317dffce215SKirk McKusick } 318dffce215SKirk McKusick return (ENOENT); 319dffce215SKirk McKusick } 320dffce215SKirk McKusick 321dffce215SKirk McKusick /* 322dffce215SKirk McKusick * Write a superblock to the devfd device from the memory pointed to by fs. 323dffce215SKirk McKusick * Write out the superblock summary information if it is present. 324dffce215SKirk McKusick * 325dffce215SKirk McKusick * If the write is successful, zero is returned. Otherwise one of the 326dffce215SKirk McKusick * following error values is returned: 327dffce215SKirk McKusick * EIO: failed to write superblock. 328dffce215SKirk McKusick * EIO: failed to write superblock summary information. 329dffce215SKirk McKusick */ 330dffce215SKirk McKusick int 331dffce215SKirk McKusick ffs_sbput(void *devfd, struct fs *fs, off_t loc, 332dffce215SKirk McKusick int (*writefunc)(void *devfd, off_t loc, void *buf, int size)) 333dffce215SKirk McKusick { 334dffce215SKirk McKusick int i, error, blks, size; 335dffce215SKirk McKusick uint8_t *space; 336dffce215SKirk McKusick 337dffce215SKirk McKusick /* 338dffce215SKirk McKusick * If there is summary information, write it first, so if there 339dffce215SKirk McKusick * is an error, the superblock will not be marked as clean. 340dffce215SKirk McKusick */ 34134816cb9SKirk McKusick if (fs->fs_si != NULL && fs->fs_csp != NULL) { 342dffce215SKirk McKusick blks = howmany(fs->fs_cssize, fs->fs_fsize); 343dffce215SKirk McKusick space = (uint8_t *)fs->fs_csp; 344dffce215SKirk McKusick for (i = 0; i < blks; i += fs->fs_frag) { 345dffce215SKirk McKusick size = fs->fs_bsize; 346dffce215SKirk McKusick if (i + fs->fs_frag > blks) 347dffce215SKirk McKusick size = (blks - i) * fs->fs_fsize; 348dffce215SKirk McKusick if ((error = (*writefunc)(devfd, 349dffce215SKirk McKusick dbtob(fsbtodb(fs, fs->fs_csaddr + i)), 350dffce215SKirk McKusick space, size)) != 0) 351dffce215SKirk McKusick return (error); 352dffce215SKirk McKusick space += size; 353dffce215SKirk McKusick } 354dffce215SKirk McKusick } 355dffce215SKirk McKusick fs->fs_fmod = 0; 35693440bbeSKirk McKusick #ifndef _KERNEL 35793440bbeSKirk McKusick { 35893440bbeSKirk McKusick struct fs_summary_info *fs_si; 35993440bbeSKirk McKusick 36093440bbeSKirk McKusick fs->fs_time = time(NULL); 36193440bbeSKirk McKusick /* Clear the pointers for the duration of writing. */ 36293440bbeSKirk McKusick fs_si = fs->fs_si; 36393440bbeSKirk McKusick fs->fs_si = NULL; 364ade67b50SKirk McKusick fs->fs_ckhash = ffs_calc_sbhash(fs); 36593440bbeSKirk McKusick error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize); 36693440bbeSKirk McKusick fs->fs_si = fs_si; 36793440bbeSKirk McKusick } 36893440bbeSKirk McKusick #else /* _KERNEL */ 36993440bbeSKirk McKusick fs->fs_time = time_second; 37093440bbeSKirk McKusick fs->fs_ckhash = ffs_calc_sbhash(fs); 37193440bbeSKirk McKusick error = (*writefunc)(devfd, loc, fs, fs->fs_sbsize); 37293440bbeSKirk McKusick #endif /* _KERNEL */ 373dffce215SKirk McKusick return (error); 374dffce215SKirk McKusick } 375dffce215SKirk McKusick 376dffce215SKirk McKusick /* 377ec888383SKirk McKusick * Calculate the check-hash for a superblock. 378ec888383SKirk McKusick */ 379ade67b50SKirk McKusick uint32_t 380ade67b50SKirk McKusick ffs_calc_sbhash(struct fs *fs) 381ec888383SKirk McKusick { 382ec888383SKirk McKusick uint32_t ckhash, save_ckhash; 383ec888383SKirk McKusick 384ec888383SKirk McKusick /* 385ec888383SKirk McKusick * A filesystem that was using a superblock ckhash may be moved 386ec888383SKirk McKusick * to an older kernel that does not support ckhashes. The 387ec888383SKirk McKusick * older kernel will clear the FS_METACKHASH flag indicating 388ec888383SKirk McKusick * that it does not update hashes. When the disk is moved back 389ec888383SKirk McKusick * to a kernel capable of ckhashes it disables them on mount: 390ec888383SKirk McKusick * 391ec888383SKirk McKusick * if ((fs->fs_flags & FS_METACKHASH) == 0) 392ec888383SKirk McKusick * fs->fs_metackhash = 0; 393ec888383SKirk McKusick * 394ec888383SKirk McKusick * This leaves (fs->fs_metackhash & CK_SUPERBLOCK) == 0) with an 395ec888383SKirk McKusick * old stale value in the fs->fs_ckhash field. Thus the need to 396ec888383SKirk McKusick * just accept what is there. 397ec888383SKirk McKusick */ 398ec888383SKirk McKusick if ((fs->fs_metackhash & CK_SUPERBLOCK) == 0) 399ec888383SKirk McKusick return (fs->fs_ckhash); 400ec888383SKirk McKusick 401ec888383SKirk McKusick save_ckhash = fs->fs_ckhash; 402ec888383SKirk McKusick fs->fs_ckhash = 0; 403ec888383SKirk McKusick /* 404ec888383SKirk McKusick * If newly read from disk, the caller is responsible for 405ec888383SKirk McKusick * verifying that fs->fs_sbsize <= SBLOCKSIZE. 406ec888383SKirk McKusick */ 407ec888383SKirk McKusick ckhash = calculate_crc32c(~0L, (void *)fs, fs->fs_sbsize); 408ec888383SKirk McKusick fs->fs_ckhash = save_ckhash; 409ec888383SKirk McKusick return (ckhash); 410ec888383SKirk McKusick } 411ec888383SKirk McKusick 412ec888383SKirk McKusick /* 413df8bae1dSRodney W. Grimes * Update the frsum fields to reflect addition or deletion 414df8bae1dSRodney W. Grimes * of some frags. 415df8bae1dSRodney W. Grimes */ 416df8bae1dSRodney W. Grimes void 41715c377c3SEd Maste ffs_fragacct(struct fs *fs, int fragmap, int32_t fraglist[], int cnt) 418df8bae1dSRodney W. Grimes { 419df8bae1dSRodney W. Grimes int inblk; 42005f4ff5dSPoul-Henning Kamp int field, subfield; 42105f4ff5dSPoul-Henning Kamp int siz, pos; 422df8bae1dSRodney W. Grimes 423df8bae1dSRodney W. Grimes inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1; 424df8bae1dSRodney W. Grimes fragmap <<= 1; 425df8bae1dSRodney W. Grimes for (siz = 1; siz < fs->fs_frag; siz++) { 426df8bae1dSRodney W. Grimes if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0) 427df8bae1dSRodney W. Grimes continue; 428df8bae1dSRodney W. Grimes field = around[siz]; 429df8bae1dSRodney W. Grimes subfield = inside[siz]; 430df8bae1dSRodney W. Grimes for (pos = siz; pos <= fs->fs_frag; pos++) { 431df8bae1dSRodney W. Grimes if ((fragmap & field) == subfield) { 432df8bae1dSRodney W. Grimes fraglist[siz] += cnt; 433df8bae1dSRodney W. Grimes pos += siz; 434df8bae1dSRodney W. Grimes field <<= siz; 435df8bae1dSRodney W. Grimes subfield <<= siz; 436df8bae1dSRodney W. Grimes } 437df8bae1dSRodney W. Grimes field <<= 1; 438df8bae1dSRodney W. Grimes subfield <<= 1; 439df8bae1dSRodney W. Grimes } 440df8bae1dSRodney W. Grimes } 441df8bae1dSRodney W. Grimes } 442df8bae1dSRodney W. Grimes 443df8bae1dSRodney W. Grimes /* 444df8bae1dSRodney W. Grimes * block operations 445df8bae1dSRodney W. Grimes * 446df8bae1dSRodney W. Grimes * check if a block is available 447df8bae1dSRodney W. Grimes */ 448df8bae1dSRodney W. Grimes int 44915c377c3SEd Maste ffs_isblock(struct fs *fs, unsigned char *cp, ufs1_daddr_t h) 450df8bae1dSRodney W. Grimes { 451df8bae1dSRodney W. Grimes unsigned char mask; 452df8bae1dSRodney W. Grimes 453df8bae1dSRodney W. Grimes switch ((int)fs->fs_frag) { 454df8bae1dSRodney W. Grimes case 8: 455df8bae1dSRodney W. Grimes return (cp[h] == 0xff); 456df8bae1dSRodney W. Grimes case 4: 457df8bae1dSRodney W. Grimes mask = 0x0f << ((h & 0x1) << 2); 458df8bae1dSRodney W. Grimes return ((cp[h >> 1] & mask) == mask); 459df8bae1dSRodney W. Grimes case 2: 460df8bae1dSRodney W. Grimes mask = 0x03 << ((h & 0x3) << 1); 461df8bae1dSRodney W. Grimes return ((cp[h >> 2] & mask) == mask); 462df8bae1dSRodney W. Grimes case 1: 463df8bae1dSRodney W. Grimes mask = 0x01 << (h & 0x7); 464df8bae1dSRodney W. Grimes return ((cp[h >> 3] & mask) == mask); 465df8bae1dSRodney W. Grimes default: 466113db2ddSJeff Roberson #ifdef _KERNEL 467df8bae1dSRodney W. Grimes panic("ffs_isblock"); 468113db2ddSJeff Roberson #endif 469113db2ddSJeff Roberson break; 470113db2ddSJeff Roberson } 471113db2ddSJeff Roberson return (0); 472113db2ddSJeff Roberson } 473113db2ddSJeff Roberson 474113db2ddSJeff Roberson /* 475113db2ddSJeff Roberson * check if a block is free 476113db2ddSJeff Roberson */ 477113db2ddSJeff Roberson int 47815c377c3SEd Maste ffs_isfreeblock(struct fs *fs, u_char *cp, ufs1_daddr_t h) 479113db2ddSJeff Roberson { 480113db2ddSJeff Roberson 481113db2ddSJeff Roberson switch ((int)fs->fs_frag) { 482113db2ddSJeff Roberson case 8: 483113db2ddSJeff Roberson return (cp[h] == 0); 484113db2ddSJeff Roberson case 4: 485113db2ddSJeff Roberson return ((cp[h >> 1] & (0x0f << ((h & 0x1) << 2))) == 0); 486113db2ddSJeff Roberson case 2: 487113db2ddSJeff Roberson return ((cp[h >> 2] & (0x03 << ((h & 0x3) << 1))) == 0); 488113db2ddSJeff Roberson case 1: 489113db2ddSJeff Roberson return ((cp[h >> 3] & (0x01 << (h & 0x7))) == 0); 490113db2ddSJeff Roberson default: 491113db2ddSJeff Roberson #ifdef _KERNEL 492113db2ddSJeff Roberson panic("ffs_isfreeblock"); 493113db2ddSJeff Roberson #endif 494113db2ddSJeff Roberson break; 495df8bae1dSRodney W. Grimes } 496589c7af9SKirk McKusick return (0); 497df8bae1dSRodney W. Grimes } 498df8bae1dSRodney W. Grimes 499df8bae1dSRodney W. Grimes /* 500df8bae1dSRodney W. Grimes * take a block out of the map 501df8bae1dSRodney W. Grimes */ 502df8bae1dSRodney W. Grimes void 50315c377c3SEd Maste ffs_clrblock(struct fs *fs, u_char *cp, ufs1_daddr_t h) 504df8bae1dSRodney W. Grimes { 505df8bae1dSRodney W. Grimes 506df8bae1dSRodney W. Grimes switch ((int)fs->fs_frag) { 507df8bae1dSRodney W. Grimes case 8: 508df8bae1dSRodney W. Grimes cp[h] = 0; 509df8bae1dSRodney W. Grimes return; 510df8bae1dSRodney W. Grimes case 4: 511df8bae1dSRodney W. Grimes cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); 512df8bae1dSRodney W. Grimes return; 513df8bae1dSRodney W. Grimes case 2: 514df8bae1dSRodney W. Grimes cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); 515df8bae1dSRodney W. Grimes return; 516df8bae1dSRodney W. Grimes case 1: 517df8bae1dSRodney W. Grimes cp[h >> 3] &= ~(0x01 << (h & 0x7)); 518df8bae1dSRodney W. Grimes return; 519df8bae1dSRodney W. Grimes default: 520113db2ddSJeff Roberson #ifdef _KERNEL 521df8bae1dSRodney W. Grimes panic("ffs_clrblock"); 522113db2ddSJeff Roberson #endif 523113db2ddSJeff Roberson break; 524df8bae1dSRodney W. Grimes } 525df8bae1dSRodney W. Grimes } 526df8bae1dSRodney W. Grimes 527df8bae1dSRodney W. Grimes /* 528df8bae1dSRodney W. Grimes * put a block into the map 529df8bae1dSRodney W. Grimes */ 530df8bae1dSRodney W. Grimes void 53115c377c3SEd Maste ffs_setblock(struct fs *fs, unsigned char *cp, ufs1_daddr_t h) 532df8bae1dSRodney W. Grimes { 533df8bae1dSRodney W. Grimes 534df8bae1dSRodney W. Grimes switch ((int)fs->fs_frag) { 535df8bae1dSRodney W. Grimes case 8: 536df8bae1dSRodney W. Grimes cp[h] = 0xff; 537df8bae1dSRodney W. Grimes return; 538df8bae1dSRodney W. Grimes case 4: 539df8bae1dSRodney W. Grimes cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); 540df8bae1dSRodney W. Grimes return; 541df8bae1dSRodney W. Grimes case 2: 542df8bae1dSRodney W. Grimes cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); 543df8bae1dSRodney W. Grimes return; 544df8bae1dSRodney W. Grimes case 1: 545df8bae1dSRodney W. Grimes cp[h >> 3] |= (0x01 << (h & 0x7)); 546df8bae1dSRodney W. Grimes return; 547df8bae1dSRodney W. Grimes default: 548113db2ddSJeff Roberson #ifdef _KERNEL 549df8bae1dSRodney W. Grimes panic("ffs_setblock"); 550113db2ddSJeff Roberson #endif 551113db2ddSJeff Roberson break; 552df8bae1dSRodney W. Grimes } 553df8bae1dSRodney W. Grimes } 554113db2ddSJeff Roberson 555113db2ddSJeff Roberson /* 556113db2ddSJeff Roberson * Update the cluster map because of an allocation or free. 557113db2ddSJeff Roberson * 558113db2ddSJeff Roberson * Cnt == 1 means free; cnt == -1 means allocating. 559113db2ddSJeff Roberson */ 560113db2ddSJeff Roberson void 56115c377c3SEd Maste ffs_clusteracct(struct fs *fs, struct cg *cgp, ufs1_daddr_t blkno, int cnt) 562113db2ddSJeff Roberson { 563113db2ddSJeff Roberson int32_t *sump; 564113db2ddSJeff Roberson int32_t *lp; 565113db2ddSJeff Roberson u_char *freemapp, *mapp; 566e1c27cf7SKirk McKusick int i, start, end, forw, back, map; 567e1c27cf7SKirk McKusick u_int bit; 568113db2ddSJeff Roberson 569113db2ddSJeff Roberson if (fs->fs_contigsumsize <= 0) 570113db2ddSJeff Roberson return; 571113db2ddSJeff Roberson freemapp = cg_clustersfree(cgp); 572113db2ddSJeff Roberson sump = cg_clustersum(cgp); 573113db2ddSJeff Roberson /* 574113db2ddSJeff Roberson * Allocate or clear the actual block. 575113db2ddSJeff Roberson */ 576113db2ddSJeff Roberson if (cnt > 0) 577113db2ddSJeff Roberson setbit(freemapp, blkno); 578113db2ddSJeff Roberson else 579113db2ddSJeff Roberson clrbit(freemapp, blkno); 580113db2ddSJeff Roberson /* 581113db2ddSJeff Roberson * Find the size of the cluster going forward. 582113db2ddSJeff Roberson */ 583113db2ddSJeff Roberson start = blkno + 1; 584113db2ddSJeff Roberson end = start + fs->fs_contigsumsize; 585113db2ddSJeff Roberson if (end >= cgp->cg_nclusterblks) 586113db2ddSJeff Roberson end = cgp->cg_nclusterblks; 587113db2ddSJeff Roberson mapp = &freemapp[start / NBBY]; 588113db2ddSJeff Roberson map = *mapp++; 589e1c27cf7SKirk McKusick bit = 1U << (start % NBBY); 590113db2ddSJeff Roberson for (i = start; i < end; i++) { 591113db2ddSJeff Roberson if ((map & bit) == 0) 592113db2ddSJeff Roberson break; 593113db2ddSJeff Roberson if ((i & (NBBY - 1)) != (NBBY - 1)) { 594113db2ddSJeff Roberson bit <<= 1; 595113db2ddSJeff Roberson } else { 596113db2ddSJeff Roberson map = *mapp++; 597113db2ddSJeff Roberson bit = 1; 598113db2ddSJeff Roberson } 599113db2ddSJeff Roberson } 600113db2ddSJeff Roberson forw = i - start; 601113db2ddSJeff Roberson /* 602113db2ddSJeff Roberson * Find the size of the cluster going backward. 603113db2ddSJeff Roberson */ 604113db2ddSJeff Roberson start = blkno - 1; 605113db2ddSJeff Roberson end = start - fs->fs_contigsumsize; 606113db2ddSJeff Roberson if (end < 0) 607113db2ddSJeff Roberson end = -1; 608113db2ddSJeff Roberson mapp = &freemapp[start / NBBY]; 609113db2ddSJeff Roberson map = *mapp--; 610e1c27cf7SKirk McKusick bit = 1U << (start % NBBY); 611113db2ddSJeff Roberson for (i = start; i > end; i--) { 612113db2ddSJeff Roberson if ((map & bit) == 0) 613113db2ddSJeff Roberson break; 614113db2ddSJeff Roberson if ((i & (NBBY - 1)) != 0) { 615113db2ddSJeff Roberson bit >>= 1; 616113db2ddSJeff Roberson } else { 617113db2ddSJeff Roberson map = *mapp--; 618e1c27cf7SKirk McKusick bit = 1U << (NBBY - 1); 619113db2ddSJeff Roberson } 620113db2ddSJeff Roberson } 621113db2ddSJeff Roberson back = start - i; 622113db2ddSJeff Roberson /* 623113db2ddSJeff Roberson * Account for old cluster and the possibly new forward and 624113db2ddSJeff Roberson * back clusters. 625113db2ddSJeff Roberson */ 626113db2ddSJeff Roberson i = back + forw + 1; 627113db2ddSJeff Roberson if (i > fs->fs_contigsumsize) 628113db2ddSJeff Roberson i = fs->fs_contigsumsize; 629113db2ddSJeff Roberson sump[i] += cnt; 630113db2ddSJeff Roberson if (back > 0) 631113db2ddSJeff Roberson sump[back] -= cnt; 632113db2ddSJeff Roberson if (forw > 0) 633113db2ddSJeff Roberson sump[forw] -= cnt; 634113db2ddSJeff Roberson /* 635113db2ddSJeff Roberson * Update cluster summary information. 636113db2ddSJeff Roberson */ 637113db2ddSJeff Roberson lp = &sump[fs->fs_contigsumsize]; 638113db2ddSJeff Roberson for (i = fs->fs_contigsumsize; i > 0; i--) 639113db2ddSJeff Roberson if (*lp-- > 0) 640113db2ddSJeff Roberson break; 641113db2ddSJeff Roberson fs->fs_maxcluster[cgp->cg_cgx] = i; 642113db2ddSJeff Roberson } 643