17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 287c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate /* 317c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988 327c478bd9Sstevel@tonic-gate * The Regents of the University of California 337c478bd9Sstevel@tonic-gate * All Rights Reserved 347c478bd9Sstevel@tonic-gate * 357c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from 367c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its 377c478bd9Sstevel@tonic-gate * contributors. 387c478bd9Sstevel@tonic-gate */ 397c478bd9Sstevel@tonic-gate 407c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 417c478bd9Sstevel@tonic-gate 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate /* 447c478bd9Sstevel@tonic-gate * The maximum supported file system size (in sectors) is the 457c478bd9Sstevel@tonic-gate * number of frags that can be represented in an int32_t field 467c478bd9Sstevel@tonic-gate * (INT_MAX) times the maximum number of sectors per frag. Since 477c478bd9Sstevel@tonic-gate * the maximum frag size is MAXBSIZE, the maximum number of sectors 487c478bd9Sstevel@tonic-gate * per frag is MAXBSIZE/DEV_BSIZE. 497c478bd9Sstevel@tonic-gate */ 507c478bd9Sstevel@tonic-gate #define FS_MAX (((diskaddr_t)INT_MAX) * (MAXBSIZE/DEV_BSIZE)) 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate /* 537c478bd9Sstevel@tonic-gate * make file system for cylinder-group style file systems 547c478bd9Sstevel@tonic-gate * 557c478bd9Sstevel@tonic-gate * usage: 567c478bd9Sstevel@tonic-gate * 577c478bd9Sstevel@tonic-gate * mkfs [-F FSType] [-V] [-G [-P]] [-M dirname] [-m] [options] 587c478bd9Sstevel@tonic-gate * [-o specific_options] special size 597c478bd9Sstevel@tonic-gate * [nsect ntrack bsize fsize cpg minfree rps nbpi opt apc rotdelay 607c478bd9Sstevel@tonic-gate * 2 3 4 5 6 7 8 9 10 11 12 617c478bd9Sstevel@tonic-gate * nrpos maxcontig mtb] 627c478bd9Sstevel@tonic-gate * 13 14 15 637c478bd9Sstevel@tonic-gate * 647c478bd9Sstevel@tonic-gate * where specific_options are: 657c478bd9Sstevel@tonic-gate * N - no create 667c478bd9Sstevel@tonic-gate * nsect - The number of sectors per track 677c478bd9Sstevel@tonic-gate * ntrack - The number of tracks per cylinder 687c478bd9Sstevel@tonic-gate * bsize - block size 697c478bd9Sstevel@tonic-gate * fragsize - fragment size 707c478bd9Sstevel@tonic-gate * cgsize - The number of disk cylinders per cylinder group. 717c478bd9Sstevel@tonic-gate * free - minimum free space 727c478bd9Sstevel@tonic-gate * rps - rotational speed (rev/sec). 737c478bd9Sstevel@tonic-gate * nbpi - number of data bytes per allocated inode 747c478bd9Sstevel@tonic-gate * opt - optimization (space, time) 757c478bd9Sstevel@tonic-gate * apc - number of alternates 767c478bd9Sstevel@tonic-gate * gap - gap size 777c478bd9Sstevel@tonic-gate * nrpos - number of rotational positions 787c478bd9Sstevel@tonic-gate * maxcontig - maximum number of logical blocks that will be 797c478bd9Sstevel@tonic-gate * allocated contiguously before inserting rotational delay 807c478bd9Sstevel@tonic-gate * mtb - if "y", set up file system for eventual growth to over a 817c478bd9Sstevel@tonic-gate * a terabyte 827c478bd9Sstevel@tonic-gate * -P Do not grow the file system, but print on stdout the maximal 837c478bd9Sstevel@tonic-gate * size in sectors to which the file system can be increased. The calculated 847c478bd9Sstevel@tonic-gate * size is limited by the value provided by the operand size. 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * Note that -P is a project-private interface and together with -G intended 877c478bd9Sstevel@tonic-gate * to be used only by the growfs script. It is therefore purposely not 887c478bd9Sstevel@tonic-gate * documented in the man page. 897c478bd9Sstevel@tonic-gate * The -P option is covered by PSARC case 2003/422. 907c478bd9Sstevel@tonic-gate */ 917c478bd9Sstevel@tonic-gate 927c478bd9Sstevel@tonic-gate /* 937c478bd9Sstevel@tonic-gate * The following constants set the defaults used for the number 947c478bd9Sstevel@tonic-gate * of sectors/track (fs_nsect), and number of tracks/cyl (fs_ntrak). 957c478bd9Sstevel@tonic-gate * 967c478bd9Sstevel@tonic-gate * NSECT NTRAK 977c478bd9Sstevel@tonic-gate * 72MB CDC 18 9 987c478bd9Sstevel@tonic-gate * 30MB CDC 18 5 997c478bd9Sstevel@tonic-gate * 720KB Diskette 9 2 100*6451fdbcSvsakar * 101*6451fdbcSvsakar * However the defaults will be different for disks larger than CHSLIMIT. 1027c478bd9Sstevel@tonic-gate */ 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate #define DFLNSECT 32 1057c478bd9Sstevel@tonic-gate #define DFLNTRAK 16 1067c478bd9Sstevel@tonic-gate 1077c478bd9Sstevel@tonic-gate /* 108*6451fdbcSvsakar * The following default sectors and tracks values are used for 109*6451fdbcSvsakar * non-efi disks that are larger than the CHS addressing limit. The 110*6451fdbcSvsakar * existing default cpg of 16 (DESCPG) holds good for larger disks too. 1117c478bd9Sstevel@tonic-gate */ 112*6451fdbcSvsakar #define DEF_SECTORS_EFI 128 113*6451fdbcSvsakar #define DEF_TRACKS_EFI 48 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate /* 1167c478bd9Sstevel@tonic-gate * The maximum number of cylinders in a group depends upon how much 1177c478bd9Sstevel@tonic-gate * information can be stored on a single cylinder. The default is to 1187c478bd9Sstevel@tonic-gate * use 16 cylinders per group. This is effectively tradition - it was 1197c478bd9Sstevel@tonic-gate * the largest value acceptable under SunOs 4.1 1207c478bd9Sstevel@tonic-gate */ 1217c478bd9Sstevel@tonic-gate #define DESCPG 16 /* desired fs_cpg */ 1227c478bd9Sstevel@tonic-gate 123*6451fdbcSvsakar /* 124*6451fdbcSvsakar * The following two constants set the default block and fragment sizes. 125*6451fdbcSvsakar * Both constants must be a power of 2 and meet the following constraints: 126*6451fdbcSvsakar * MINBSIZE <= DESBLKSIZE <= MAXBSIZE 127*6451fdbcSvsakar * DEV_BSIZE <= DESFRAGSIZE <= DESBLKSIZE 128*6451fdbcSvsakar * DESBLKSIZE / DESFRAGSIZE <= 8 129*6451fdbcSvsakar */ 130*6451fdbcSvsakar #define DESBLKSIZE 8192 131*6451fdbcSvsakar #define DESFRAGSIZE 1024 132*6451fdbcSvsakar 1337c478bd9Sstevel@tonic-gate /* 1347c478bd9Sstevel@tonic-gate * MINFREE gives the minimum acceptable percentage of file system 1357c478bd9Sstevel@tonic-gate * blocks which may be free. If the freelist drops below this level 1367c478bd9Sstevel@tonic-gate * only the superuser may continue to allocate blocks. This may 1377c478bd9Sstevel@tonic-gate * be set to 0 if no reserve of free blocks is deemed necessary, 1387c478bd9Sstevel@tonic-gate * however throughput drops by fifty percent if the file system 1397c478bd9Sstevel@tonic-gate * is run at between 90% and 100% full; thus the default value of 1407c478bd9Sstevel@tonic-gate * fs_minfree is 10%. With 10% free space, fragmentation is not a 1417c478bd9Sstevel@tonic-gate * problem, so we choose to optimize for time. 1427c478bd9Sstevel@tonic-gate */ 1437c478bd9Sstevel@tonic-gate #define MINFREE 10 1447c478bd9Sstevel@tonic-gate #define DEFAULTOPT FS_OPTTIME 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate /* 1477c478bd9Sstevel@tonic-gate * ROTDELAY gives the minimum number of milliseconds to initiate 1487c478bd9Sstevel@tonic-gate * another disk transfer on the same cylinder. It is no longer used 1497c478bd9Sstevel@tonic-gate * and will always default to 0. 1507c478bd9Sstevel@tonic-gate */ 1517c478bd9Sstevel@tonic-gate #define ROTDELAY 0 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate /* 1547c478bd9Sstevel@tonic-gate * MAXBLKPG determines the maximum number of data blocks which are 1557c478bd9Sstevel@tonic-gate * placed in a single cylinder group. The default is one indirect 1567c478bd9Sstevel@tonic-gate * block worth of data blocks. 1577c478bd9Sstevel@tonic-gate */ 1587c478bd9Sstevel@tonic-gate #define MAXBLKPG(bsize) ((bsize) / sizeof (daddr32_t)) 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate /* 1617c478bd9Sstevel@tonic-gate * Each file system has a number of inodes statically allocated. 1627c478bd9Sstevel@tonic-gate * We allocate one inode slot per NBPI bytes, expecting this 1637c478bd9Sstevel@tonic-gate * to be far more than we will ever need. 1647c478bd9Sstevel@tonic-gate */ 1657c478bd9Sstevel@tonic-gate #define NBPI 2048 /* Number Bytes Per Inode */ 1667c478bd9Sstevel@tonic-gate #define MTB_NBPI (MB) /* Number Bytes Per Inode for multi-terabyte */ 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate /* 1697c478bd9Sstevel@tonic-gate * Disks are assumed to rotate at 60HZ, unless otherwise specified. 1707c478bd9Sstevel@tonic-gate */ 1717c478bd9Sstevel@tonic-gate #define DEFHZ 60 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate /* 1747c478bd9Sstevel@tonic-gate * Cylinder group related limits. 1757c478bd9Sstevel@tonic-gate * 1767c478bd9Sstevel@tonic-gate * For each cylinder we keep track of the availability of blocks at different 1777c478bd9Sstevel@tonic-gate * rotational positions, so that we can lay out the data to be picked 1787c478bd9Sstevel@tonic-gate * up with minimum rotational latency. NRPOS is the number of rotational 1797c478bd9Sstevel@tonic-gate * positions which we distinguish. With NRPOS 8 the resolution of our 1807c478bd9Sstevel@tonic-gate * summary information is 2ms for a typical 3600 rpm drive. 1817c478bd9Sstevel@tonic-gate */ 1827c478bd9Sstevel@tonic-gate #define NRPOS 8 /* number distinct rotational positions */ 1837c478bd9Sstevel@tonic-gate 184*6451fdbcSvsakar #ifdef DEBUG 185*6451fdbcSvsakar #define dprintf(x) printf x 186*6451fdbcSvsakar #else 187*6451fdbcSvsakar #define dprintf(x) 188*6451fdbcSvsakar #endif 189*6451fdbcSvsakar 190*6451fdbcSvsakar /* 191*6451fdbcSvsakar * For the -N option, when calculating the backup superblocks, do not print 192*6451fdbcSvsakar * them if we are not really sure. We may have to try an alternate method of 193*6451fdbcSvsakar * arriving at the superblocks. So defer printing till a handful of superblocks 194*6451fdbcSvsakar * look good. 195*6451fdbcSvsakar */ 196*6451fdbcSvsakar #define tprintf(x) if (Nflag && retry) \ 197*6451fdbcSvsakar strncat(tmpbuf, x, strlen(x)); \ 198*6451fdbcSvsakar else \ 199*6451fdbcSvsakar (void) fprintf(stderr, x); 200*6451fdbcSvsakar 201*6451fdbcSvsakar #define ALTSB 32 /* Location of first backup superblock */ 202*6451fdbcSvsakar 2037c478bd9Sstevel@tonic-gate /* 2047c478bd9Sstevel@tonic-gate * range_check "user_supplied" flag values. 2057c478bd9Sstevel@tonic-gate */ 2067c478bd9Sstevel@tonic-gate #define RC_DEFAULT 0 2077c478bd9Sstevel@tonic-gate #define RC_KEYWORD 1 2087c478bd9Sstevel@tonic-gate #define RC_POSITIONAL 2 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate #ifndef STANDALONE 2117c478bd9Sstevel@tonic-gate #include <stdio.h> 2127c478bd9Sstevel@tonic-gate #include <sys/mnttab.h> 2137c478bd9Sstevel@tonic-gate #endif 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate #include <stdlib.h> 2167c478bd9Sstevel@tonic-gate #include <unistd.h> 2177c478bd9Sstevel@tonic-gate #include <malloc.h> 2187c478bd9Sstevel@tonic-gate #include <string.h> 2197c478bd9Sstevel@tonic-gate #include <strings.h> 2207c478bd9Sstevel@tonic-gate #include <ctype.h> 2217c478bd9Sstevel@tonic-gate #include <errno.h> 2227c478bd9Sstevel@tonic-gate #include <sys/param.h> 2237c478bd9Sstevel@tonic-gate #include <time.h> 2247c478bd9Sstevel@tonic-gate #include <sys/types.h> 2257c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 2267c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 2277c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fsdir.h> 2287c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_inode.h> 2297c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fs.h> 2307c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_log.h> 2317c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 2327c478bd9Sstevel@tonic-gate #include <sys/filio.h> 2337c478bd9Sstevel@tonic-gate #include <limits.h> 2347c478bd9Sstevel@tonic-gate #include <sys/int_const.h> 2357c478bd9Sstevel@tonic-gate #include <signal.h> 2367c478bd9Sstevel@tonic-gate #include <sys/efi_partition.h> 2377c478bd9Sstevel@tonic-gate #include "roll_log.h" 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate #define bcopy(f, t, n) (void) memcpy(t, f, n) 2407c478bd9Sstevel@tonic-gate #define bzero(s, n) (void) memset(s, 0, n) 2417c478bd9Sstevel@tonic-gate #define bcmp(s, d, n) memcmp(s, d, n) 2427c478bd9Sstevel@tonic-gate 2437c478bd9Sstevel@tonic-gate #define index(s, r) strchr(s, r) 2447c478bd9Sstevel@tonic-gate #define rindex(s, r) strrchr(s, r) 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate #include <sys/stat.h> 2477c478bd9Sstevel@tonic-gate #include <sys/statvfs.h> 2487c478bd9Sstevel@tonic-gate #include <locale.h> 2497c478bd9Sstevel@tonic-gate #include <fcntl.h> 2507c478bd9Sstevel@tonic-gate #include <sys/isa_defs.h> /* for ENDIAN defines */ 2517c478bd9Sstevel@tonic-gate #include <sys/vtoc.h> 2527c478bd9Sstevel@tonic-gate 2537c478bd9Sstevel@tonic-gate #include <sys/dkio.h> 2547c478bd9Sstevel@tonic-gate #include <sys/asynch.h> 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate extern offset_t llseek(); 2577c478bd9Sstevel@tonic-gate extern char *getfullblkname(); 2587c478bd9Sstevel@tonic-gate extern long lrand48(); 2597c478bd9Sstevel@tonic-gate 2607c478bd9Sstevel@tonic-gate extern int optind; 2617c478bd9Sstevel@tonic-gate extern char *optarg; 2627c478bd9Sstevel@tonic-gate 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate /* 2657c478bd9Sstevel@tonic-gate * The size of a cylinder group is calculated by CGSIZE. The maximum size 2667c478bd9Sstevel@tonic-gate * is limited by the fact that cylinder groups are at most one block. 2677c478bd9Sstevel@tonic-gate * Its size is derived from the size of the maps maintained in the 2687c478bd9Sstevel@tonic-gate * cylinder group and the (struct cg) size. 2697c478bd9Sstevel@tonic-gate */ 2707c478bd9Sstevel@tonic-gate #define CGSIZE(fs) \ 2717c478bd9Sstevel@tonic-gate /* base cg */ (sizeof (struct cg) + \ 2727c478bd9Sstevel@tonic-gate /* blktot size */ (fs)->fs_cpg * sizeof (long) + \ 2737c478bd9Sstevel@tonic-gate /* blks size */ (fs)->fs_cpg * (fs)->fs_nrpos * sizeof (short) + \ 2747c478bd9Sstevel@tonic-gate /* inode map */ howmany((fs)->fs_ipg, NBBY) + \ 2757c478bd9Sstevel@tonic-gate /* block map */ howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY)) 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate /* 2787c478bd9Sstevel@tonic-gate * We limit the size of the inode map to be no more than a 2797c478bd9Sstevel@tonic-gate * third of the cylinder group space, since we must leave at 2807c478bd9Sstevel@tonic-gate * least an equal amount of space for the block map. 2817c478bd9Sstevel@tonic-gate * 2827c478bd9Sstevel@tonic-gate * N.B.: MAXIpG must be a multiple of INOPB(fs). 2837c478bd9Sstevel@tonic-gate */ 2847c478bd9Sstevel@tonic-gate #define MAXIpG(fs) roundup((fs)->fs_bsize * NBBY / 3, INOPB(fs)) 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate /* 2877c478bd9Sstevel@tonic-gate * Same as MAXIpG, but parameterized by the block size (b) and the 2887c478bd9Sstevel@tonic-gate * cylinder group divisor (d), which is the reciprocal of the fraction of the 2897c478bd9Sstevel@tonic-gate * cylinder group overhead block that is used for the inode map. So for 2907c478bd9Sstevel@tonic-gate * example, if d = 5, the macro's computation assumes that 1/5 of the 2917c478bd9Sstevel@tonic-gate * cylinder group overhead block can be dedicated to the inode map. 2927c478bd9Sstevel@tonic-gate */ 2937c478bd9Sstevel@tonic-gate #define MAXIpG_B(b, d) roundup((b) * NBBY / (d), (b) / sizeof (struct dinode)) 2947c478bd9Sstevel@tonic-gate 2957c478bd9Sstevel@tonic-gate #define UMASK 0755 2967c478bd9Sstevel@tonic-gate #define MAXINOPB (MAXBSIZE / sizeof (struct dinode)) 2977c478bd9Sstevel@tonic-gate #define POWEROF2(num) (((num) & ((num) - 1)) == 0) 2987c478bd9Sstevel@tonic-gate #define MB (1024*1024) 2997c478bd9Sstevel@tonic-gate #define BETWEEN(x, l, h) ((x) >= (l) && (x) <= (h)) 3007c478bd9Sstevel@tonic-gate 3017c478bd9Sstevel@tonic-gate /* 3027c478bd9Sstevel@tonic-gate * Used to set the inode generation number. Since both inodes and dinodes 3037c478bd9Sstevel@tonic-gate * are dealt with, we really need a pointer to an icommon here. 3047c478bd9Sstevel@tonic-gate */ 3057c478bd9Sstevel@tonic-gate #define IRANDOMIZE(icp) (icp)->ic_gen = lrand48(); 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate /* 3087c478bd9Sstevel@tonic-gate * Flags for number() 3097c478bd9Sstevel@tonic-gate */ 3107c478bd9Sstevel@tonic-gate #define ALLOW_PERCENT 0x01 /* allow trailing `%' on number */ 3117c478bd9Sstevel@tonic-gate #define ALLOW_MS1 0x02 /* allow trailing `ms', state 1 */ 3127c478bd9Sstevel@tonic-gate #define ALLOW_MS2 0x04 /* allow trailing `ms', state 2 */ 3137c478bd9Sstevel@tonic-gate #define ALLOW_END_ONLY 0x08 /* must be at end of number & suffixes */ 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate #define MAXAIO 1000 /* maximum number of outstanding I/O's we'll manage */ 3167c478bd9Sstevel@tonic-gate #define BLOCK 1 /* block in aiowait */ 3177c478bd9Sstevel@tonic-gate #define NOBLOCK 0 /* don't block in aiowait */ 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate #define RELEASE 1 /* free an aio buffer after use */ 3207c478bd9Sstevel@tonic-gate #define SAVE 0 /* don't free the buffer */ 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate typedef struct aio_trans { 3237c478bd9Sstevel@tonic-gate aio_result_t resultbuf; 3247c478bd9Sstevel@tonic-gate diskaddr_t bno; 3257c478bd9Sstevel@tonic-gate char *buffer; 3267c478bd9Sstevel@tonic-gate int size; 3277c478bd9Sstevel@tonic-gate int release; 3287c478bd9Sstevel@tonic-gate struct aio_trans *next; 3297c478bd9Sstevel@tonic-gate } aio_trans; 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate typedef struct aio_results { 3327c478bd9Sstevel@tonic-gate int max; 3337c478bd9Sstevel@tonic-gate int outstanding; 3347c478bd9Sstevel@tonic-gate int maxpend; 3357c478bd9Sstevel@tonic-gate aio_trans *trans; 3367c478bd9Sstevel@tonic-gate } aio_results; 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate int aio_inited = 0; 3397c478bd9Sstevel@tonic-gate aio_results results; 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate /* 3427c478bd9Sstevel@tonic-gate * Allow up to MAXBUF aio requests that each have a unique buffer. 3437c478bd9Sstevel@tonic-gate * More aio's might be done, but not using memory through the getbuf() 3447c478bd9Sstevel@tonic-gate * interface. This can be raised, but you run into the potential of 3457c478bd9Sstevel@tonic-gate * using more memory than is physically available on the machine, 3467c478bd9Sstevel@tonic-gate * and if you start swapping, you can forget about performance. 3477c478bd9Sstevel@tonic-gate * To prevent this, we also limit the total memory used for a given 3487c478bd9Sstevel@tonic-gate * type of buffer to MAXBUFMEM. 3497c478bd9Sstevel@tonic-gate * 3507c478bd9Sstevel@tonic-gate * Tests indicate a cylinder group's worth of inodes takes: 3517c478bd9Sstevel@tonic-gate * 3527c478bd9Sstevel@tonic-gate * NBPI Size of Inode Buffer 3537c478bd9Sstevel@tonic-gate * 2k 1688k 3547c478bd9Sstevel@tonic-gate * 8k 424k 3557c478bd9Sstevel@tonic-gate * 3567c478bd9Sstevel@tonic-gate * initcg() stores all the inodes for a cylinder group in one buffer, 3577c478bd9Sstevel@tonic-gate * so allowing 20 buffers could take 32 MB if not limited by MAXBUFMEM. 3587c478bd9Sstevel@tonic-gate */ 3597c478bd9Sstevel@tonic-gate #define MAXBUF 20 3607c478bd9Sstevel@tonic-gate #define MAXBUFMEM (8 * 1024 * 1024) 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate /* 3637c478bd9Sstevel@tonic-gate * header information for buffers managed by getbuf() and freebuf() 3647c478bd9Sstevel@tonic-gate */ 3657c478bd9Sstevel@tonic-gate typedef struct bufhdr { 3667c478bd9Sstevel@tonic-gate struct bufhdr *head; 3677c478bd9Sstevel@tonic-gate struct bufhdr *next; 3687c478bd9Sstevel@tonic-gate } bufhdr; 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate int bufhdrsize; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate bufhdr inodebuf = { NULL, NULL }; 3737c478bd9Sstevel@tonic-gate bufhdr cgsumbuf = { NULL, NULL }; 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate #define SECTORS_PER_TERABYTE (1LL << 31) 3767c478bd9Sstevel@tonic-gate /* 3777c478bd9Sstevel@tonic-gate * The following constant specifies an upper limit for file system size 3787c478bd9Sstevel@tonic-gate * that is actually a lot bigger than we expect to support with UFS. (Since 3797c478bd9Sstevel@tonic-gate * it's specified in sectors, the file system size would be 2**44 * 512, 3807c478bd9Sstevel@tonic-gate * which is 2**53, which is 8192 Terabytes.) However, it's useful 3817c478bd9Sstevel@tonic-gate * for checking the basic sanity of a size value that is input on the 3827c478bd9Sstevel@tonic-gate * command line. 3837c478bd9Sstevel@tonic-gate */ 3847c478bd9Sstevel@tonic-gate #define FS_SIZE_UPPER_LIMIT 0x100000000000LL 3857c478bd9Sstevel@tonic-gate 3867c478bd9Sstevel@tonic-gate /* 3877c478bd9Sstevel@tonic-gate * Forward declarations 3887c478bd9Sstevel@tonic-gate */ 3897c478bd9Sstevel@tonic-gate static char *getbuf(bufhdr *bufhead, int size); 3907c478bd9Sstevel@tonic-gate static void freebuf(char *buf); 3917c478bd9Sstevel@tonic-gate static void freetrans(aio_trans *transp); 3927c478bd9Sstevel@tonic-gate static aio_trans *get_aiop(); 3937c478bd9Sstevel@tonic-gate static aio_trans *wait_for_write(int block); 3947c478bd9Sstevel@tonic-gate static void initcg(int cylno); 3957c478bd9Sstevel@tonic-gate static void fsinit(); 3967c478bd9Sstevel@tonic-gate static int makedir(struct direct *protodir, int entries); 3977c478bd9Sstevel@tonic-gate static void iput(struct inode *ip); 3987c478bd9Sstevel@tonic-gate static void rdfs(diskaddr_t bno, int size, char *bf); 3997c478bd9Sstevel@tonic-gate static void wtfs(diskaddr_t bno, int size, char *bf); 4007c478bd9Sstevel@tonic-gate static void awtfs(diskaddr_t bno, int size, char *bf, int release); 4017c478bd9Sstevel@tonic-gate static void wtfs_breakup(diskaddr_t bno, int size, char *bf); 4027c478bd9Sstevel@tonic-gate static int isblock(struct fs *fs, unsigned char *cp, int h); 4037c478bd9Sstevel@tonic-gate static void clrblock(struct fs *fs, unsigned char *cp, int h); 4047c478bd9Sstevel@tonic-gate static void setblock(struct fs *fs, unsigned char *cp, int h); 4057c478bd9Sstevel@tonic-gate static void usage(); 4067c478bd9Sstevel@tonic-gate static void dump_fscmd(char *fsys, int fsi); 4077c478bd9Sstevel@tonic-gate static uint64_t number(uint64_t d_value, char *param, int flags); 4087c478bd9Sstevel@tonic-gate static int match(char *s); 4097c478bd9Sstevel@tonic-gate static char checkopt(char *optim); 4107c478bd9Sstevel@tonic-gate static char checkmtb(char *mtbarg); 4117c478bd9Sstevel@tonic-gate static void range_check(long *varp, char *name, long minimum, 4127c478bd9Sstevel@tonic-gate long maximum, long def_val, int user_supplied); 4137c478bd9Sstevel@tonic-gate static void range_check_64(uint64_t *varp, char *name, uint64_t minimum, 4147c478bd9Sstevel@tonic-gate uint64_t maximum, uint64_t def_val, int user_supplied); 4157c478bd9Sstevel@tonic-gate static daddr32_t alloc(int size, int mode); 4167c478bd9Sstevel@tonic-gate static diskaddr_t get_max_size(int fd); 4177c478bd9Sstevel@tonic-gate static long get_max_track_size(int fd); 4187c478bd9Sstevel@tonic-gate static void block_sigint(sigset_t *old_mask); 4197c478bd9Sstevel@tonic-gate static void unblock_sigint(sigset_t *old_mask); 4207c478bd9Sstevel@tonic-gate static void recover_from_sigint(int signum); 4217c478bd9Sstevel@tonic-gate static int confirm_abort(void); 4227c478bd9Sstevel@tonic-gate static int getline(FILE *fp, char *loc, int maxlen); 4237c478bd9Sstevel@tonic-gate static void flush_writes(void); 4247c478bd9Sstevel@tonic-gate static long compute_maxcpg(long, long, long, long, long); 4257c478bd9Sstevel@tonic-gate static int in_64bit_mode(void); 4267c478bd9Sstevel@tonic-gate static int validate_size(int fd, diskaddr_t size); 427355d6bb5Sswilcox static void dump_sblock(void); 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate union { 4307c478bd9Sstevel@tonic-gate struct fs fs; 4317c478bd9Sstevel@tonic-gate char pad[SBSIZE]; 432*6451fdbcSvsakar } fsun, altfsun; 4337c478bd9Sstevel@tonic-gate #define sblock fsun.fs 434*6451fdbcSvsakar #define altsblock altfsun.fs 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate struct csum *fscs; 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate union cgun { 4397c478bd9Sstevel@tonic-gate struct cg cg; 4407c478bd9Sstevel@tonic-gate char pad[MAXBSIZE]; 4417c478bd9Sstevel@tonic-gate } cgun; 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate #define acg cgun.cg 4447c478bd9Sstevel@tonic-gate /* 4457c478bd9Sstevel@tonic-gate * Size of screen in cols in which to fit output 4467c478bd9Sstevel@tonic-gate */ 4477c478bd9Sstevel@tonic-gate #define WIDTH 80 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate struct dinode zino[MAXBSIZE / sizeof (struct dinode)]; 4507c478bd9Sstevel@tonic-gate 4517c478bd9Sstevel@tonic-gate /* 4527c478bd9Sstevel@tonic-gate * file descriptors used for rdfs(fsi) and wtfs(fso). 4537c478bd9Sstevel@tonic-gate * Initialized to an illegal file descriptor number. 4547c478bd9Sstevel@tonic-gate */ 4557c478bd9Sstevel@tonic-gate int fsi = -1; 4567c478bd9Sstevel@tonic-gate int fso = -1; 4577c478bd9Sstevel@tonic-gate 4587c478bd9Sstevel@tonic-gate /* 4597c478bd9Sstevel@tonic-gate * The BIG parameter is machine dependent. It should be a longlong integer 4607c478bd9Sstevel@tonic-gate * constant that can be used by the number parser to check the validity 4617c478bd9Sstevel@tonic-gate * of numeric parameters. 4627c478bd9Sstevel@tonic-gate */ 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate #define BIG 0x7fffffffffffffffLL 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate /* Used to indicate to number() that a bogus value should cause us to exit */ 4677c478bd9Sstevel@tonic-gate #define NO_DEFAULT LONG_MIN 4687c478bd9Sstevel@tonic-gate 469*6451fdbcSvsakar /* 470*6451fdbcSvsakar * INVALIDSBLIMIT is the number of bad backup superblocks that will be 471*6451fdbcSvsakar * tolerated before we decide to try arriving at a different set of them 472*6451fdbcSvsakar * using a different logic. This is applicable for non-EFI disks only. 473*6451fdbcSvsakar */ 474*6451fdbcSvsakar #define INVALIDSBLIMIT 10 475*6451fdbcSvsakar 4767c478bd9Sstevel@tonic-gate /* 4777c478bd9Sstevel@tonic-gate * The *_flag variables are used to indicate that the user specified 4787c478bd9Sstevel@tonic-gate * the values, rather than that we made them up ourselves. We can 4797c478bd9Sstevel@tonic-gate * complain about the user giving us bogus values. 4807c478bd9Sstevel@tonic-gate */ 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate /* semi-constants */ 4837c478bd9Sstevel@tonic-gate long sectorsize = DEV_BSIZE; /* bytes/sector from param.h */ 4847c478bd9Sstevel@tonic-gate long bbsize = BBSIZE; /* boot block size */ 4857c478bd9Sstevel@tonic-gate long sbsize = SBSIZE; /* superblock size */ 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate /* parameters */ 4887c478bd9Sstevel@tonic-gate diskaddr_t fssize_db; /* file system size in disk blocks */ 4897c478bd9Sstevel@tonic-gate diskaddr_t fssize_frag; /* file system size in frags */ 4907c478bd9Sstevel@tonic-gate long cpg; /* cylinders/cylinder group */ 4917c478bd9Sstevel@tonic-gate int cpg_flag = RC_DEFAULT; 4927c478bd9Sstevel@tonic-gate long rotdelay = -1; /* rotational delay between blocks */ 4937c478bd9Sstevel@tonic-gate int rotdelay_flag = RC_DEFAULT; 4947c478bd9Sstevel@tonic-gate long maxcontig; /* max contiguous blocks to allocate */ 4957c478bd9Sstevel@tonic-gate int maxcontig_flag = RC_DEFAULT; 4967c478bd9Sstevel@tonic-gate long nsect = DFLNSECT; /* sectors per track */ 4977c478bd9Sstevel@tonic-gate int nsect_flag = RC_DEFAULT; 4987c478bd9Sstevel@tonic-gate long ntrack = DFLNTRAK; /* tracks per cylinder group */ 4997c478bd9Sstevel@tonic-gate int ntrack_flag = RC_DEFAULT; 5007c478bd9Sstevel@tonic-gate long bsize = DESBLKSIZE; /* filesystem block size */ 5017c478bd9Sstevel@tonic-gate int bsize_flag = RC_DEFAULT; 5027c478bd9Sstevel@tonic-gate long fragsize = DESFRAGSIZE; /* filesystem fragment size */ 5037c478bd9Sstevel@tonic-gate int fragsize_flag = RC_DEFAULT; 5047c478bd9Sstevel@tonic-gate long minfree = MINFREE; /* fs_minfree */ 5057c478bd9Sstevel@tonic-gate int minfree_flag = RC_DEFAULT; 5067c478bd9Sstevel@tonic-gate long rps = DEFHZ; /* revolutions/second of drive */ 5077c478bd9Sstevel@tonic-gate int rps_flag = RC_DEFAULT; 5087c478bd9Sstevel@tonic-gate long nbpi = NBPI; /* number of bytes per inode */ 5097c478bd9Sstevel@tonic-gate int nbpi_flag = RC_DEFAULT; 5107c478bd9Sstevel@tonic-gate long nrpos = NRPOS; /* number of rotational positions */ 5117c478bd9Sstevel@tonic-gate int nrpos_flag = RC_DEFAULT; 5127c478bd9Sstevel@tonic-gate long apc = 0; /* alternate sectors per cylinder */ 5137c478bd9Sstevel@tonic-gate int apc_flag = RC_DEFAULT; 5147c478bd9Sstevel@tonic-gate char opt = 't'; /* optimization style, `t' or `s' */ 5157c478bd9Sstevel@tonic-gate char mtb = 'n'; /* multi-terabyte format, 'y' or 'n' */ 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate long debug = 0; /* enable debugging output */ 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate int spc_flag = 0; /* alternate sectors specified or */ 5207c478bd9Sstevel@tonic-gate /* found */ 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate /* global state */ 5237c478bd9Sstevel@tonic-gate int Nflag; /* do not write to disk */ 5247c478bd9Sstevel@tonic-gate int mflag; /* return the command line used to create this FS */ 525355d6bb5Sswilcox int rflag; /* report the superblock in an easily-parsed form */ 526355d6bb5Sswilcox int Rflag; /* dump the superblock in binary */ 5277c478bd9Sstevel@tonic-gate char *fsys; 5287c478bd9Sstevel@tonic-gate time_t mkfstime; 5297c478bd9Sstevel@tonic-gate char *string; 530*6451fdbcSvsakar int label_type; 5317c478bd9Sstevel@tonic-gate 5327c478bd9Sstevel@tonic-gate /* 5337c478bd9Sstevel@tonic-gate * logging support 5347c478bd9Sstevel@tonic-gate */ 5357c478bd9Sstevel@tonic-gate int ismdd; /* true if device is a SVM device */ 5367c478bd9Sstevel@tonic-gate int islog; /* true if ufs or SVM logging is enabled */ 5377c478bd9Sstevel@tonic-gate int islogok; /* true if ufs/SVM log state is good */ 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate static int isufslog; /* true if ufs logging is enabled */ 5407c478bd9Sstevel@tonic-gate static int waslog; /* true when ufs logging disabled during grow */ 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate /* 5437c478bd9Sstevel@tonic-gate * growfs defines, globals, and forward references 5447c478bd9Sstevel@tonic-gate */ 5457c478bd9Sstevel@tonic-gate #define NOTENOUGHSPACE 33 5467c478bd9Sstevel@tonic-gate int grow; 5477c478bd9Sstevel@tonic-gate static int Pflag; /* probe to which size the fs can be grown */ 5487c478bd9Sstevel@tonic-gate int ismounted; 5497c478bd9Sstevel@tonic-gate char *directory; 5507c478bd9Sstevel@tonic-gate diskaddr_t grow_fssize; 5517c478bd9Sstevel@tonic-gate long grow_fs_size; 5527c478bd9Sstevel@tonic-gate long grow_fs_ncg; 5537c478bd9Sstevel@tonic-gate diskaddr_t grow_fs_csaddr; 5547c478bd9Sstevel@tonic-gate long grow_fs_cssize; 5557c478bd9Sstevel@tonic-gate int grow_fs_clean; 5567c478bd9Sstevel@tonic-gate struct csum *grow_fscs; 5577c478bd9Sstevel@tonic-gate diskaddr_t grow_sifrag; 5587c478bd9Sstevel@tonic-gate int test; 5597c478bd9Sstevel@tonic-gate int testforce; 5607c478bd9Sstevel@tonic-gate diskaddr_t testfrags; 5617c478bd9Sstevel@tonic-gate int inlockexit; 5627c478bd9Sstevel@tonic-gate int isbad; 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate void lockexit(int); 5657c478bd9Sstevel@tonic-gate void randomgeneration(void); 5667c478bd9Sstevel@tonic-gate void checksummarysize(void); 567*6451fdbcSvsakar int checksblock(struct fs, int); 5687c478bd9Sstevel@tonic-gate void growinit(char *); 5697c478bd9Sstevel@tonic-gate void checkdev(char *, char *); 5707c478bd9Sstevel@tonic-gate void checkmount(struct mnttab *, char *); 5717c478bd9Sstevel@tonic-gate struct dinode *gdinode(ino_t); 5727c478bd9Sstevel@tonic-gate int csfraginrange(daddr32_t); 5737c478bd9Sstevel@tonic-gate struct csfrag *findcsfrag(daddr32_t, struct csfrag **); 5747c478bd9Sstevel@tonic-gate void checkindirect(ino_t, daddr32_t *, daddr32_t, int); 5757c478bd9Sstevel@tonic-gate void addcsfrag(ino_t, daddr32_t, struct csfrag **); 5767c478bd9Sstevel@tonic-gate void delcsfrag(daddr32_t, struct csfrag **); 5777c478bd9Sstevel@tonic-gate void checkdirect(ino_t, daddr32_t *, daddr32_t *, int); 5787c478bd9Sstevel@tonic-gate void findcsfragino(void); 5797c478bd9Sstevel@tonic-gate void fixindirect(daddr32_t, int); 5807c478bd9Sstevel@tonic-gate void fixdirect(caddr_t, daddr32_t, daddr32_t *, int); 5817c478bd9Sstevel@tonic-gate void fixcsfragino(void); 5827c478bd9Sstevel@tonic-gate void extendsummaryinfo(void); 5837c478bd9Sstevel@tonic-gate int notenoughspace(void); 5847c478bd9Sstevel@tonic-gate void unalloccsfragino(void); 5857c478bd9Sstevel@tonic-gate void unalloccsfragfree(void); 5867c478bd9Sstevel@tonic-gate void findcsfragfree(void); 5877c478bd9Sstevel@tonic-gate void copycsfragino(void); 5887c478bd9Sstevel@tonic-gate void rdcg(long); 5897c478bd9Sstevel@tonic-gate void wtcg(void); 5907c478bd9Sstevel@tonic-gate void flcg(void); 5917c478bd9Sstevel@tonic-gate void allocfrags(long, daddr32_t *, long *); 5927c478bd9Sstevel@tonic-gate void alloccsfragino(void); 5937c478bd9Sstevel@tonic-gate void alloccsfragfree(void); 5947c478bd9Sstevel@tonic-gate void freefrags(daddr32_t, long, long); 5957c478bd9Sstevel@tonic-gate int findfreerange(long *, long *); 5967c478bd9Sstevel@tonic-gate void resetallocinfo(void); 5977c478bd9Sstevel@tonic-gate void extendcg(long); 5987c478bd9Sstevel@tonic-gate void ulockfs(void); 5997c478bd9Sstevel@tonic-gate void wlockfs(void); 6007c478bd9Sstevel@tonic-gate void clockfs(void); 6017c478bd9Sstevel@tonic-gate void wtsb(void); 6027c478bd9Sstevel@tonic-gate static int64_t checkfragallocated(daddr32_t); 6037c478bd9Sstevel@tonic-gate static struct csum *read_summaryinfo(struct fs *); 6047c478bd9Sstevel@tonic-gate static diskaddr_t probe_summaryinfo(); 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate void 6077c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 6087c478bd9Sstevel@tonic-gate { 6097c478bd9Sstevel@tonic-gate long i, mincpc, mincpg, ibpcl; 6107c478bd9Sstevel@tonic-gate long cylno, rpos, blk, j, warn = 0; 6117c478bd9Sstevel@tonic-gate long mincpgcnt, maxcpg; 6127c478bd9Sstevel@tonic-gate uint64_t used, bpcg, inospercg; 6137c478bd9Sstevel@tonic-gate long mapcramped, inodecramped; 6147c478bd9Sstevel@tonic-gate long postblsize, rotblsize, totalsbsize; 6157c478bd9Sstevel@tonic-gate FILE *mnttab; 6167c478bd9Sstevel@tonic-gate struct mnttab mntp; 6177c478bd9Sstevel@tonic-gate char *special; 6187c478bd9Sstevel@tonic-gate struct statvfs64 fs; 619*6451fdbcSvsakar struct dk_geom dkg; 6207c478bd9Sstevel@tonic-gate struct dk_cinfo dkcinfo; 6217c478bd9Sstevel@tonic-gate char pbuf[sizeof (uint64_t) * 3 + 1]; 622*6451fdbcSvsakar char *tmpbuf; 6237c478bd9Sstevel@tonic-gate int width, plen; 6247c478bd9Sstevel@tonic-gate uint64_t num; 6257c478bd9Sstevel@tonic-gate int c, saverr; 6267c478bd9Sstevel@tonic-gate diskaddr_t max_fssize; 6277c478bd9Sstevel@tonic-gate long tmpmaxcontig = -1; 6287c478bd9Sstevel@tonic-gate struct sigaction sigact; 6297c478bd9Sstevel@tonic-gate uint64_t nbytes64; 6307c478bd9Sstevel@tonic-gate int remaining_cg; 6317c478bd9Sstevel@tonic-gate int do_dot = 0; 632*6451fdbcSvsakar int use_efi_dflts = 0, retry = 0; 633*6451fdbcSvsakar int invalid_sb_cnt, ret, skip_this_sb; 634*6451fdbcSvsakar int save_nsect, save_ntrack, save_cpg; 6357c478bd9Sstevel@tonic-gate 6367c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) 6397c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" 6407c478bd9Sstevel@tonic-gate #endif 6417c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "F:bmo:VPGM:T:t:")) != EOF) { 6447c478bd9Sstevel@tonic-gate switch (c) { 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate case 'F': 6477c478bd9Sstevel@tonic-gate string = optarg; 6487c478bd9Sstevel@tonic-gate if (strcmp(string, "ufs") != 0) 6497c478bd9Sstevel@tonic-gate usage(); 6507c478bd9Sstevel@tonic-gate break; 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate case 'm': /* return command line used to create this FS */ 6537c478bd9Sstevel@tonic-gate mflag++; 6547c478bd9Sstevel@tonic-gate break; 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate case 'o': 6577c478bd9Sstevel@tonic-gate /* 6587c478bd9Sstevel@tonic-gate * ufs specific options. 6597c478bd9Sstevel@tonic-gate */ 6607c478bd9Sstevel@tonic-gate string = optarg; 6617c478bd9Sstevel@tonic-gate while (*string != '\0') { 6627c478bd9Sstevel@tonic-gate if (match("nsect=")) { 6637c478bd9Sstevel@tonic-gate nsect = number(DFLNSECT, "nsect", 0); 6647c478bd9Sstevel@tonic-gate nsect_flag = RC_KEYWORD; 6657c478bd9Sstevel@tonic-gate } else if (match("ntrack=")) { 6667c478bd9Sstevel@tonic-gate ntrack = number(DFLNTRAK, "ntrack", 0); 6677c478bd9Sstevel@tonic-gate ntrack_flag = RC_KEYWORD; 6687c478bd9Sstevel@tonic-gate } else if (match("bsize=")) { 6697c478bd9Sstevel@tonic-gate bsize = number(DESBLKSIZE, "bsize", 0); 6707c478bd9Sstevel@tonic-gate bsize_flag = RC_KEYWORD; 6717c478bd9Sstevel@tonic-gate } else if (match("fragsize=")) { 6727c478bd9Sstevel@tonic-gate fragsize = number(DESFRAGSIZE, 6737c478bd9Sstevel@tonic-gate "fragsize", 0); 6747c478bd9Sstevel@tonic-gate fragsize_flag = RC_KEYWORD; 6757c478bd9Sstevel@tonic-gate } else if (match("cgsize=")) { 6767c478bd9Sstevel@tonic-gate cpg = number(DESCPG, "cgsize", 0); 6777c478bd9Sstevel@tonic-gate cpg_flag = RC_KEYWORD; 6787c478bd9Sstevel@tonic-gate } else if (match("free=")) { 6797c478bd9Sstevel@tonic-gate minfree = number(MINFREE, "free", 6807c478bd9Sstevel@tonic-gate ALLOW_PERCENT); 6817c478bd9Sstevel@tonic-gate minfree_flag = RC_KEYWORD; 6827c478bd9Sstevel@tonic-gate } else if (match("maxcontig=")) { 6837c478bd9Sstevel@tonic-gate tmpmaxcontig = 6847c478bd9Sstevel@tonic-gate number(-1, "maxcontig", 0); 6857c478bd9Sstevel@tonic-gate maxcontig_flag = RC_KEYWORD; 6867c478bd9Sstevel@tonic-gate } else if (match("nrpos=")) { 6877c478bd9Sstevel@tonic-gate nrpos = number(NRPOS, "nrpos", 0); 6887c478bd9Sstevel@tonic-gate nrpos_flag = RC_KEYWORD; 6897c478bd9Sstevel@tonic-gate } else if (match("rps=")) { 6907c478bd9Sstevel@tonic-gate rps = number(DEFHZ, "rps", 0); 6917c478bd9Sstevel@tonic-gate rps_flag = RC_KEYWORD; 6927c478bd9Sstevel@tonic-gate } else if (match("nbpi=")) { 6937c478bd9Sstevel@tonic-gate nbpi = number(NBPI, "nbpi", 0); 6947c478bd9Sstevel@tonic-gate nbpi_flag = RC_KEYWORD; 6957c478bd9Sstevel@tonic-gate } else if (match("opt=")) { 6967c478bd9Sstevel@tonic-gate opt = checkopt(string); 6977c478bd9Sstevel@tonic-gate } else if (match("mtb=")) { 6987c478bd9Sstevel@tonic-gate mtb = checkmtb(string); 6997c478bd9Sstevel@tonic-gate } else if (match("apc=")) { 7007c478bd9Sstevel@tonic-gate apc = number(0, "apc", 0); 7017c478bd9Sstevel@tonic-gate apc_flag = RC_KEYWORD; 7027c478bd9Sstevel@tonic-gate } else if (match("gap=")) { 7037c478bd9Sstevel@tonic-gate (void) number(0, "gap", ALLOW_MS1); 7047c478bd9Sstevel@tonic-gate rotdelay = ROTDELAY; 7057c478bd9Sstevel@tonic-gate rotdelay_flag = RC_DEFAULT; 7067c478bd9Sstevel@tonic-gate } else if (match("debug=")) { 7077c478bd9Sstevel@tonic-gate debug = number(0, "debug", 0); 7087c478bd9Sstevel@tonic-gate } else if (match("N")) { 7097c478bd9Sstevel@tonic-gate Nflag++; 710355d6bb5Sswilcox } else if (match("calcsb")) { 711355d6bb5Sswilcox rflag++; 712355d6bb5Sswilcox Nflag++; 713355d6bb5Sswilcox } else if (match("calcbinsb")) { 714355d6bb5Sswilcox rflag++; 715355d6bb5Sswilcox Rflag++; 716355d6bb5Sswilcox Nflag++; 7177c478bd9Sstevel@tonic-gate } else if (*string == '\0') { 7187c478bd9Sstevel@tonic-gate break; 7197c478bd9Sstevel@tonic-gate } else { 7207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 7217c478bd9Sstevel@tonic-gate "illegal option: %s\n"), 7227c478bd9Sstevel@tonic-gate string); 7237c478bd9Sstevel@tonic-gate usage(); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate if (*string == ',') string++; 7277c478bd9Sstevel@tonic-gate if (*string == ' ') string++; 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate break; 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate case 'V': 7327c478bd9Sstevel@tonic-gate { 7337c478bd9Sstevel@tonic-gate char *opt_text; 7347c478bd9Sstevel@tonic-gate int opt_count; 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate (void) fprintf(stdout, gettext("mkfs -F ufs ")); 7377c478bd9Sstevel@tonic-gate for (opt_count = 1; opt_count < argc; 7387c478bd9Sstevel@tonic-gate opt_count++) { 7397c478bd9Sstevel@tonic-gate opt_text = argv[opt_count]; 7407c478bd9Sstevel@tonic-gate if (opt_text) 7417c478bd9Sstevel@tonic-gate (void) fprintf(stdout, " %s ", 7427c478bd9Sstevel@tonic-gate opt_text); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "\n"); 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate break; 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate case 'b': /* do nothing for this */ 7497c478bd9Sstevel@tonic-gate break; 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate case 'M': /* grow the mounted file system */ 7527c478bd9Sstevel@tonic-gate directory = optarg; 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 7557c478bd9Sstevel@tonic-gate case 'G': /* grow the file system */ 7567c478bd9Sstevel@tonic-gate grow = 1; 7577c478bd9Sstevel@tonic-gate break; 7587c478bd9Sstevel@tonic-gate case 'P': /* probe the file system growing size */ 7597c478bd9Sstevel@tonic-gate Pflag = 1; 7607c478bd9Sstevel@tonic-gate grow = 1; /* probe mode implies fs growing */ 7617c478bd9Sstevel@tonic-gate break; 7627c478bd9Sstevel@tonic-gate case 'T': /* For testing */ 7637c478bd9Sstevel@tonic-gate testforce = 1; 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 7667c478bd9Sstevel@tonic-gate case 't': 7677c478bd9Sstevel@tonic-gate test = 1; 7687c478bd9Sstevel@tonic-gate string = optarg; 7697c478bd9Sstevel@tonic-gate testfrags = number(NO_DEFAULT, "testfrags", 0); 7707c478bd9Sstevel@tonic-gate break; 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate case '?': 7737c478bd9Sstevel@tonic-gate usage(); 7747c478bd9Sstevel@tonic-gate break; 7757c478bd9Sstevel@tonic-gate } 7767c478bd9Sstevel@tonic-gate } 7777c478bd9Sstevel@tonic-gate #ifdef MKFS_DEBUG 7787c478bd9Sstevel@tonic-gate /* 7797c478bd9Sstevel@tonic-gate * Turning on MKFS_DEBUG causes mkfs to produce a filesystem 7807c478bd9Sstevel@tonic-gate * that can be reproduced by setting the time to 0 and seeding 7817c478bd9Sstevel@tonic-gate * the random number generator to a constant. 7827c478bd9Sstevel@tonic-gate */ 7837c478bd9Sstevel@tonic-gate mkfstime = 0; /* reproducible results */ 7847c478bd9Sstevel@tonic-gate #else 7857c478bd9Sstevel@tonic-gate (void) time(&mkfstime); 7867c478bd9Sstevel@tonic-gate #endif 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate if (optind >= (argc - 1)) { 7897c478bd9Sstevel@tonic-gate if (optind > (argc - 1)) { 7907c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7917c478bd9Sstevel@tonic-gate gettext("special not specified\n")); 7927c478bd9Sstevel@tonic-gate usage(); 7937c478bd9Sstevel@tonic-gate } else if (mflag == 0) { 7947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 7957c478bd9Sstevel@tonic-gate gettext("size not specified\n")); 7967c478bd9Sstevel@tonic-gate usage(); 7977c478bd9Sstevel@tonic-gate } 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate argc -= optind; 8007c478bd9Sstevel@tonic-gate argv = &argv[optind]; 8017c478bd9Sstevel@tonic-gate 8027c478bd9Sstevel@tonic-gate fsys = argv[0]; 8037c478bd9Sstevel@tonic-gate fsi = open64(fsys, O_RDONLY); 8047c478bd9Sstevel@tonic-gate if (fsi < 0) { 8057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: cannot open\n"), fsys); 8067c478bd9Sstevel@tonic-gate lockexit(32); 8077c478bd9Sstevel@tonic-gate } 8087c478bd9Sstevel@tonic-gate 8097c478bd9Sstevel@tonic-gate if (mflag) { 8107c478bd9Sstevel@tonic-gate dump_fscmd(fsys, fsi); 8117c478bd9Sstevel@tonic-gate lockexit(0); 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate /* 8157c478bd9Sstevel@tonic-gate * The task of setting all of the configuration parameters for a 8167c478bd9Sstevel@tonic-gate * UFS file system is basically a matter of solving n equations 8177c478bd9Sstevel@tonic-gate * in m variables. Typically, m is greater than n, so there is 8187c478bd9Sstevel@tonic-gate * usually more than one valid solution. Since this is usually 8197c478bd9Sstevel@tonic-gate * an under-constrained problem, it's not always obvious what the 8207c478bd9Sstevel@tonic-gate * "best" configuration is. 8217c478bd9Sstevel@tonic-gate * 8227c478bd9Sstevel@tonic-gate * In general, the approach is to 8237c478bd9Sstevel@tonic-gate * 1. Determine the values for the file system parameters 8247c478bd9Sstevel@tonic-gate * that are externally contrained and therefore not adjustable 8257c478bd9Sstevel@tonic-gate * by mkfs (such as the device's size and maxtransfer size). 8267c478bd9Sstevel@tonic-gate * 2. Acquire the user's requested setting for all configuration 8277c478bd9Sstevel@tonic-gate * values that can be set on the command line. 8287c478bd9Sstevel@tonic-gate * 3. Determine the final value of all configuration values, by 8297c478bd9Sstevel@tonic-gate * the following approach: 8307c478bd9Sstevel@tonic-gate * - set the file system block size (fs_bsize). Although 8317c478bd9Sstevel@tonic-gate * this could be regarded as an adjustable parameter, in 8327c478bd9Sstevel@tonic-gate * fact, it's pretty much a constant. At this time, it's 8337c478bd9Sstevel@tonic-gate * generally set to 8k (with older hardware, it can 8347c478bd9Sstevel@tonic-gate * sometimes make sense to set it to 4k, but those 8357c478bd9Sstevel@tonic-gate * situations are pretty rare now). 8367c478bd9Sstevel@tonic-gate * - re-adjust the maximum file system size based on the 8377c478bd9Sstevel@tonic-gate * value of the file system block size. Since the 8387c478bd9Sstevel@tonic-gate * frag size can't be any larger than a file system 8397c478bd9Sstevel@tonic-gate * block, and the number of frags in the file system 8407c478bd9Sstevel@tonic-gate * has to fit into 31 bits, the file system block size 8417c478bd9Sstevel@tonic-gate * affects the maximum file system size. 8427c478bd9Sstevel@tonic-gate * - now that the real maximum file system is known, set the 8437c478bd9Sstevel@tonic-gate * actual size of the file system to be created to 8447c478bd9Sstevel@tonic-gate * MIN(requested size, maximum file system size). 8457c478bd9Sstevel@tonic-gate * - now validate, and if necessary, adjust the following 8467c478bd9Sstevel@tonic-gate * values: 8477c478bd9Sstevel@tonic-gate * rotdelay 8487c478bd9Sstevel@tonic-gate * nsect 8497c478bd9Sstevel@tonic-gate * maxcontig 8507c478bd9Sstevel@tonic-gate * apc 8517c478bd9Sstevel@tonic-gate * frag_size 8527c478bd9Sstevel@tonic-gate * rps 8537c478bd9Sstevel@tonic-gate * minfree 8547c478bd9Sstevel@tonic-gate * nrpos 8557c478bd9Sstevel@tonic-gate * nrack 8567c478bd9Sstevel@tonic-gate * nbpi 8577c478bd9Sstevel@tonic-gate * - calculate maxcpg (the maximum value of the cylinders-per- 8587c478bd9Sstevel@tonic-gate * cylinder-group configuration parameters). There are two 8597c478bd9Sstevel@tonic-gate * algorithms for calculating maxcpg: an old one, which is 8607c478bd9Sstevel@tonic-gate * used for file systems of less than 1 terabyte, and a 8617c478bd9Sstevel@tonic-gate * new one, implemented in the function compute_maxcpg(), 8627c478bd9Sstevel@tonic-gate * which is used for file systems of greater than 1 TB. 8637c478bd9Sstevel@tonic-gate * The difference between them is that compute_maxcpg() 8647c478bd9Sstevel@tonic-gate * really tries to maximize the cpg value. The old 8657c478bd9Sstevel@tonic-gate * algorithm fails to take advantage of smaller frags and 8667c478bd9Sstevel@tonic-gate * lower inode density when determining the maximum cpg, 8677c478bd9Sstevel@tonic-gate * and thus comes up with much lower numbers in some 8687c478bd9Sstevel@tonic-gate * configurations. At some point, we might use the 8697c478bd9Sstevel@tonic-gate * new algorithm for determining maxcpg for all file 8707c478bd9Sstevel@tonic-gate * systems, but at this time, the changes implemented for 8717c478bd9Sstevel@tonic-gate * multi-terabyte UFS are NOT being automatically applied 8727c478bd9Sstevel@tonic-gate * to UFS file systems of less than a terabyte (in the 8737c478bd9Sstevel@tonic-gate * interest of not changing existing UFS policy too much 8747c478bd9Sstevel@tonic-gate * until the ramifications of the changes are well-understood 8757c478bd9Sstevel@tonic-gate * and have been evaluated for their effects on performance.) 8767c478bd9Sstevel@tonic-gate * - check the current values of the configuration parameters 8777c478bd9Sstevel@tonic-gate * against the various constraints imposed by UFS. These 8787c478bd9Sstevel@tonic-gate * include: 8797c478bd9Sstevel@tonic-gate * * There must be at least one inode in each 8807c478bd9Sstevel@tonic-gate * cylinder group. 8817c478bd9Sstevel@tonic-gate * * The cylinder group overhead block, which 8827c478bd9Sstevel@tonic-gate * contains the inode and frag bigmaps, must fit 8837c478bd9Sstevel@tonic-gate * within one file system block. 8847c478bd9Sstevel@tonic-gate * * The space required for inode maps should 8857c478bd9Sstevel@tonic-gate * occupy no more than a third of the cylinder 8867c478bd9Sstevel@tonic-gate * group overhead block. 8877c478bd9Sstevel@tonic-gate * * The rotational position tables have to fit 8887c478bd9Sstevel@tonic-gate * within the available space in the super block. 8897c478bd9Sstevel@tonic-gate * Adjust the configuration values that can be adjusted 8907c478bd9Sstevel@tonic-gate * so that these constraints are satisfied. The 8917c478bd9Sstevel@tonic-gate * configuration values that are adjustable are: 8927c478bd9Sstevel@tonic-gate * * frag size 8937c478bd9Sstevel@tonic-gate * * cylinders per group 8947c478bd9Sstevel@tonic-gate * * inode density (can be increased) 8957c478bd9Sstevel@tonic-gate * * number of rotational positions (the rotational 8967c478bd9Sstevel@tonic-gate * position tables are eliminated altogether if 8977c478bd9Sstevel@tonic-gate * there isn't enough room for them.) 8987c478bd9Sstevel@tonic-gate * 4. Set the values for all the dependent configuration 8997c478bd9Sstevel@tonic-gate * values (those that aren't settable on the command 9007c478bd9Sstevel@tonic-gate * line and which are completely dependent on the 9017c478bd9Sstevel@tonic-gate * adjustable parameters). This include cpc (cycles 9027c478bd9Sstevel@tonic-gate * per cylinder, spc (sectors-per-cylinder), and many others. 9037c478bd9Sstevel@tonic-gate */ 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate max_fssize = get_max_size(fsi); 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* 9087c478bd9Sstevel@tonic-gate * Get and check positional arguments, if any. 9097c478bd9Sstevel@tonic-gate */ 9107c478bd9Sstevel@tonic-gate switch (argc - 1) { 9117c478bd9Sstevel@tonic-gate default: 9127c478bd9Sstevel@tonic-gate usage(); 9137c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 9147c478bd9Sstevel@tonic-gate case 15: 9157c478bd9Sstevel@tonic-gate mtb = checkmtb(argv[15]); 9167c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9177c478bd9Sstevel@tonic-gate case 14: 9187c478bd9Sstevel@tonic-gate string = argv[14]; 9197c478bd9Sstevel@tonic-gate tmpmaxcontig = number(-1, "maxcontig", 0); 9207c478bd9Sstevel@tonic-gate maxcontig_flag = RC_POSITIONAL; 9217c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9227c478bd9Sstevel@tonic-gate case 13: 9237c478bd9Sstevel@tonic-gate string = argv[13]; 9247c478bd9Sstevel@tonic-gate nrpos = number(NRPOS, "nrpos", 0); 9257c478bd9Sstevel@tonic-gate nrpos_flag = RC_POSITIONAL; 9267c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9277c478bd9Sstevel@tonic-gate case 12: 9287c478bd9Sstevel@tonic-gate string = argv[12]; 9297c478bd9Sstevel@tonic-gate rotdelay = ROTDELAY; 9307c478bd9Sstevel@tonic-gate rotdelay_flag = RC_DEFAULT; 9317c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9327c478bd9Sstevel@tonic-gate case 11: 9337c478bd9Sstevel@tonic-gate string = argv[11]; 9347c478bd9Sstevel@tonic-gate apc = number(0, "apc", 0); 9357c478bd9Sstevel@tonic-gate apc_flag = RC_POSITIONAL; 9367c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9377c478bd9Sstevel@tonic-gate case 10: 9387c478bd9Sstevel@tonic-gate opt = checkopt(argv[10]); 9397c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9407c478bd9Sstevel@tonic-gate case 9: 9417c478bd9Sstevel@tonic-gate string = argv[9]; 9427c478bd9Sstevel@tonic-gate nbpi = number(NBPI, "nbpi", 0); 9437c478bd9Sstevel@tonic-gate nbpi_flag = RC_POSITIONAL; 9447c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9457c478bd9Sstevel@tonic-gate case 8: 9467c478bd9Sstevel@tonic-gate string = argv[8]; 9477c478bd9Sstevel@tonic-gate rps = number(DEFHZ, "rps", 0); 9487c478bd9Sstevel@tonic-gate rps_flag = RC_POSITIONAL; 9497c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9507c478bd9Sstevel@tonic-gate case 7: 9517c478bd9Sstevel@tonic-gate string = argv[7]; 9527c478bd9Sstevel@tonic-gate minfree = number(MINFREE, "free", ALLOW_PERCENT); 9537c478bd9Sstevel@tonic-gate minfree_flag = RC_POSITIONAL; 9547c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9557c478bd9Sstevel@tonic-gate case 6: 9567c478bd9Sstevel@tonic-gate string = argv[6]; 9577c478bd9Sstevel@tonic-gate cpg = number(DESCPG, "cgsize", 0); 9587c478bd9Sstevel@tonic-gate cpg_flag = RC_POSITIONAL; 9597c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9607c478bd9Sstevel@tonic-gate case 5: 9617c478bd9Sstevel@tonic-gate string = argv[5]; 9627c478bd9Sstevel@tonic-gate fragsize = number(DESFRAGSIZE, "fragsize", 0); 9637c478bd9Sstevel@tonic-gate fragsize_flag = RC_POSITIONAL; 9647c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9657c478bd9Sstevel@tonic-gate case 4: 9667c478bd9Sstevel@tonic-gate string = argv[4]; 9677c478bd9Sstevel@tonic-gate bsize = number(DESBLKSIZE, "bsize", 0); 9687c478bd9Sstevel@tonic-gate bsize_flag = RC_POSITIONAL; 9697c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9707c478bd9Sstevel@tonic-gate case 3: 9717c478bd9Sstevel@tonic-gate string = argv[3]; 9727c478bd9Sstevel@tonic-gate ntrack = number(DFLNTRAK, "ntrack", 0); 9737c478bd9Sstevel@tonic-gate ntrack_flag = RC_POSITIONAL; 9747c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9757c478bd9Sstevel@tonic-gate case 2: 9767c478bd9Sstevel@tonic-gate string = argv[2]; 9777c478bd9Sstevel@tonic-gate nsect = number(DFLNSECT, "nsect", 0); 9787c478bd9Sstevel@tonic-gate nsect_flag = RC_POSITIONAL; 9797c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9807c478bd9Sstevel@tonic-gate case 1: 9817c478bd9Sstevel@tonic-gate string = argv[1]; 9827c478bd9Sstevel@tonic-gate fssize_db = number(max_fssize, "size", 0); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate 9867c478bd9Sstevel@tonic-gate if ((maxcontig_flag == RC_DEFAULT) || (tmpmaxcontig == -1) || 9877c478bd9Sstevel@tonic-gate (maxcontig == -1)) { 9887c478bd9Sstevel@tonic-gate long maxtrax = get_max_track_size(fsi); 9897c478bd9Sstevel@tonic-gate maxcontig = maxtrax / bsize; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate } else { 9927c478bd9Sstevel@tonic-gate maxcontig = tmpmaxcontig; 9937c478bd9Sstevel@tonic-gate } 994*6451fdbcSvsakar dprintf(("DeBuG maxcontig : %ld\n", maxcontig)); 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate if (rotdelay == -1) { /* default by newfs and mkfs */ 9977c478bd9Sstevel@tonic-gate rotdelay = ROTDELAY; 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate if (cpg_flag == RC_DEFAULT) { /* If not explicity set, use default */ 10017c478bd9Sstevel@tonic-gate cpg = DESCPG; 10027c478bd9Sstevel@tonic-gate } 1003*6451fdbcSvsakar dprintf(("DeBuG cpg : %ld\n", cpg)); 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate /* 10067c478bd9Sstevel@tonic-gate * Now that we have the semi-sane args, either positional, via -o, 10077c478bd9Sstevel@tonic-gate * or by defaulting, handle inter-dependencies and range checks. 10087c478bd9Sstevel@tonic-gate */ 10097c478bd9Sstevel@tonic-gate 10107c478bd9Sstevel@tonic-gate /* 10117c478bd9Sstevel@tonic-gate * Settle the file system block size first, since it's a fixed 10127c478bd9Sstevel@tonic-gate * parameter once set and so many other parameters, including 10137c478bd9Sstevel@tonic-gate * max_fssize, depend on it. 10147c478bd9Sstevel@tonic-gate */ 10157c478bd9Sstevel@tonic-gate range_check(&bsize, "bsize", MINBSIZE, MAXBSIZE, DESBLKSIZE, 10167c478bd9Sstevel@tonic-gate bsize_flag); 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate if (!POWEROF2(bsize)) { 10197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10207c478bd9Sstevel@tonic-gate gettext("block size must be a power of 2, not %ld\n"), 10217c478bd9Sstevel@tonic-gate bsize); 10227c478bd9Sstevel@tonic-gate bsize = DESBLKSIZE; 10237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10247c478bd9Sstevel@tonic-gate gettext("mkfs: bsize reset to default %ld\n"), 10257c478bd9Sstevel@tonic-gate bsize); 10267c478bd9Sstevel@tonic-gate } 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate if (fssize_db > max_fssize && validate_size(fsi, fssize_db)) { 10297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 10307c478bd9Sstevel@tonic-gate "Warning: the requested size of this file system\n" 10317c478bd9Sstevel@tonic-gate "(%lld sectors) is greater than the size of the\n" 10327c478bd9Sstevel@tonic-gate "device reported by the driver (%lld sectors).\n" 10337c478bd9Sstevel@tonic-gate "However, a read of the device at the requested size\n" 10347c478bd9Sstevel@tonic-gate "does succeed, so the requested size will be used.\n"), 10357c478bd9Sstevel@tonic-gate fssize_db, max_fssize); 10367c478bd9Sstevel@tonic-gate max_fssize = fssize_db; 10377c478bd9Sstevel@tonic-gate } 10387c478bd9Sstevel@tonic-gate /* 10397c478bd9Sstevel@tonic-gate * Since the maximum allocatable unit (the frag) must be less than 10407c478bd9Sstevel@tonic-gate * or equal to bsize, and the number of frags must be less than or 10417c478bd9Sstevel@tonic-gate * equal to INT_MAX, the total size of the file system (in 10427c478bd9Sstevel@tonic-gate * bytes) must be less than or equal to bsize * INT_MAX. 10437c478bd9Sstevel@tonic-gate */ 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate if (max_fssize > ((diskaddr_t)bsize/DEV_BSIZE) * INT_MAX) 10467c478bd9Sstevel@tonic-gate max_fssize = ((diskaddr_t)bsize/DEV_BSIZE) * INT_MAX; 10477c478bd9Sstevel@tonic-gate range_check_64(&fssize_db, "size", 1024LL, max_fssize, max_fssize, 1); 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate if (fssize_db >= SECTORS_PER_TERABYTE) { 10507c478bd9Sstevel@tonic-gate mtb = 'y'; 10517c478bd9Sstevel@tonic-gate if (!in_64bit_mode()) { 10527c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 10537c478bd9Sstevel@tonic-gate "mkfs: Warning: Creating a file system greater than 1 terabyte on a\n" 10547c478bd9Sstevel@tonic-gate " system running a 32-bit kernel. This file system will not be\n" 10557c478bd9Sstevel@tonic-gate " accessible until the system is rebooted with a 64-bit kernel.\n")); 10567c478bd9Sstevel@tonic-gate } 10577c478bd9Sstevel@tonic-gate } 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate /* 1060*6451fdbcSvsakar * With newer and much larger disks, the newfs(1M) and mkfs_ufs(1M) 1061*6451fdbcSvsakar * commands had problems in correctly handling the "native" geometries 1062*6451fdbcSvsakar * for various storage devices. 1063*6451fdbcSvsakar * 1064*6451fdbcSvsakar * To handle the new age disks, mkfs_ufs(1M) will use the EFI style 1065*6451fdbcSvsakar * for non-EFI disks that are larger than the CHS addressing limit 1066*6451fdbcSvsakar * ( > 8GB approx ) and ignore the disk geometry information for 1067*6451fdbcSvsakar * these drives. This is what is currently done for multi-terrabyte 1068*6451fdbcSvsakar * filesystems on EFI disks. 1069*6451fdbcSvsakar * 1070*6451fdbcSvsakar * However if the user asked for a specific layout by supplying values 1071*6451fdbcSvsakar * for these parameters, honour the user supplied parameters. 10727c478bd9Sstevel@tonic-gate */ 1073*6451fdbcSvsakar 1074*6451fdbcSvsakar if (mtb != 'y' && label_type == LABEL_TYPE_VTOC && 1075*6451fdbcSvsakar ((nsect == -1 && ntrack == -1) || 1076*6451fdbcSvsakar (grow && ntrack_flag == RC_DEFAULT))) { 1077*6451fdbcSvsakar /* 1078*6451fdbcSvsakar * "-1" indicates that we were called from newfs and these 1079*6451fdbcSvsakar * arguments were not passed in command line. Calculate nsect 1080*6451fdbcSvsakar * and ntrack in the same manner as newfs. 1081*6451fdbcSvsakar * 1082*6451fdbcSvsakar * This is required because, the defaults for nsect and ntrack 1083*6451fdbcSvsakar * is hardcoded in mkfs, whereas to generate the alternate 1084*6451fdbcSvsakar * superblock locations for the -N option, there is a need for 1085*6451fdbcSvsakar * the geometry based values that newfs would have arrived at. 1086*6451fdbcSvsakar * Newfs would have arrived at these values as below. 1087*6451fdbcSvsakar */ 1088*6451fdbcSvsakar 1089*6451fdbcSvsakar if (ioctl(fsi, DKIOCGGEOM, &dkg)) { 1090*6451fdbcSvsakar dprintf(("%s: Unable to read Disk geometry", fsys)); 1091*6451fdbcSvsakar perror(gettext("Unable to read Disk geometry")); 1092*6451fdbcSvsakar lockexit(32); 1093*6451fdbcSvsakar } else { 1094*6451fdbcSvsakar nsect = dkg.dkg_nsect; 1095*6451fdbcSvsakar ntrack = dkg.dkg_nhead; 1096*6451fdbcSvsakar #ifdef i386 /* Bug 1170182 */ 1097*6451fdbcSvsakar if (ntrack > 32 && (ntrack % 16) != 0) { 1098*6451fdbcSvsakar ntrack -= (ntrack % 16); 1099*6451fdbcSvsakar } 1100*6451fdbcSvsakar #endif 1101*6451fdbcSvsakar if ((dkg.dkg_ncyl * dkg.dkg_nhead * dkg.dkg_nsect) 1102*6451fdbcSvsakar > CHSLIMIT) { 1103*6451fdbcSvsakar use_efi_dflts = 1; 1104*6451fdbcSvsakar retry = 1; 1105*6451fdbcSvsakar } 1106*6451fdbcSvsakar } 1107*6451fdbcSvsakar dprintf(("DeBuG mkfs: geom = %ld CHSLIMIT = %d\n", 1108*6451fdbcSvsakar dkg.dkg_ncyl * dkg.dkg_nhead * dkg.dkg_nsect, 1109*6451fdbcSvsakar CHSLIMIT)); 1110*6451fdbcSvsakar } 1111*6451fdbcSvsakar 1112*6451fdbcSvsakar /* 1113*6451fdbcSvsakar * For the newfs -N case, even if the disksize is > CHSLIMIT, do not 1114*6451fdbcSvsakar * blindly follow EFI style. If the fs_version indicates a geometry 1115*6451fdbcSvsakar * based layout, try that one first. If it fails we can always try the 1116*6451fdbcSvsakar * other logic. 1117*6451fdbcSvsakar * 1118*6451fdbcSvsakar * If we were called from growfs, we will have a problem if we mix 1119*6451fdbcSvsakar * and match the filesystem creation and growth styles. For example, 1120*6451fdbcSvsakar * if we create using EFI style and we have to also grow using EFI 1121*6451fdbcSvsakar * style. So follow the style indicated by the fs_version. 1122*6451fdbcSvsakar * 1123*6451fdbcSvsakar * Read and verify the primary superblock. If it looks sane, use the 1124*6451fdbcSvsakar * fs_version from the superblock. If the primary superblock does 1125*6451fdbcSvsakar * not look good, read and verify the first alternate superblock at 1126*6451fdbcSvsakar * ALTSB. Use the fs_version to decide whether to use the 1127*6451fdbcSvsakar * EFI style logic or the old geometry based logic to calculate 1128*6451fdbcSvsakar * the alternate superblock locations. 1129*6451fdbcSvsakar */ 1130*6451fdbcSvsakar if ((Nflag && use_efi_dflts) || (grow)) { 1131*6451fdbcSvsakar if (grow && ntrack_flag != RC_DEFAULT) 1132*6451fdbcSvsakar goto retry_alternate_logic; 1133*6451fdbcSvsakar rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, 1134*6451fdbcSvsakar (char *)&altsblock); 1135*6451fdbcSvsakar ret = checksblock(altsblock, 1); 1136*6451fdbcSvsakar 1137*6451fdbcSvsakar if (!ret) { 1138*6451fdbcSvsakar if (altsblock.fs_magic == MTB_UFS_MAGIC) { 1139*6451fdbcSvsakar mtb = 'y'; 1140*6451fdbcSvsakar goto retry_alternate_logic; 1141*6451fdbcSvsakar } 1142*6451fdbcSvsakar use_efi_dflts = (altsblock.fs_version == 1143*6451fdbcSvsakar UFS_EFISTYLE4NONEFI_VERSION_2) ? 1 : 0; 1144*6451fdbcSvsakar } else { 1145*6451fdbcSvsakar /* 1146*6451fdbcSvsakar * The primary superblock didn't help in determining 1147*6451fdbcSvsakar * the fs_version. Try the first alternate superblock. 1148*6451fdbcSvsakar */ 1149*6451fdbcSvsakar dprintf(("DeBuG checksblock() failed - error : %d" 1150*6451fdbcSvsakar " for sb : %d\n", ret, SBOFF/sectorsize)); 1151*6451fdbcSvsakar rdfs((diskaddr_t)ALTSB, (int)sbsize, 1152*6451fdbcSvsakar (char *)&altsblock); 1153*6451fdbcSvsakar ret = checksblock(altsblock, 1); 1154*6451fdbcSvsakar 1155*6451fdbcSvsakar if (!ret) { 1156*6451fdbcSvsakar if (altsblock.fs_magic == MTB_UFS_MAGIC) { 1157*6451fdbcSvsakar mtb = 'y'; 1158*6451fdbcSvsakar goto retry_alternate_logic; 1159*6451fdbcSvsakar } 1160*6451fdbcSvsakar use_efi_dflts = (altsblock.fs_version == 1161*6451fdbcSvsakar UFS_EFISTYLE4NONEFI_VERSION_2) ? 1 : 0; 1162*6451fdbcSvsakar } else 1163*6451fdbcSvsakar dprintf(("DeBuG checksblock() failed - error : %d" 1164*6451fdbcSvsakar " for sb : %d\n", ret, ALTSB)); 1165*6451fdbcSvsakar } 1166*6451fdbcSvsakar } 1167*6451fdbcSvsakar 1168*6451fdbcSvsakar retry_alternate_logic: 1169*6451fdbcSvsakar invalid_sb_cnt = 0; 1170*6451fdbcSvsakar if (use_efi_dflts) { 1171*6451fdbcSvsakar save_nsect = nsect; 1172*6451fdbcSvsakar save_ntrack = ntrack; 1173*6451fdbcSvsakar save_cpg = cpg; 1174*6451fdbcSvsakar 1175*6451fdbcSvsakar nsect = DEF_SECTORS_EFI; 1176*6451fdbcSvsakar ntrack = DEF_TRACKS_EFI; 1177*6451fdbcSvsakar cpg = DESCPG; 1178*6451fdbcSvsakar 1179*6451fdbcSvsakar dprintf(("\nDeBuG Using EFI defaults\n")); 1180*6451fdbcSvsakar dprintf(("DeBuG save_nsect=%d, save_ntrack=%d, save_cpg=%d\n", 1181*6451fdbcSvsakar save_nsect, save_ntrack, save_cpg)); 1182*6451fdbcSvsakar } else { 1183*6451fdbcSvsakar save_nsect = DEF_SECTORS_EFI; 1184*6451fdbcSvsakar save_ntrack = DEF_TRACKS_EFI; 1185*6451fdbcSvsakar save_cpg = DESCPG; 1186*6451fdbcSvsakar dprintf(("\n\nDeBuG mkfs: Using Geometry\n")); 1187*6451fdbcSvsakar dprintf(("DeBuG save_nsect=%d, save_ntrack=%d, save_cpg=%d\n", 1188*6451fdbcSvsakar save_nsect, save_ntrack, save_cpg)); 1189*6451fdbcSvsakar /* 1190*6451fdbcSvsakar * 32K based on max block size of 64K, and rotational layout 1191*6451fdbcSvsakar * test of nsect <= (256 * sectors/block). Current block size 1192*6451fdbcSvsakar * limit is not 64K, but it's growing soon. 1193*6451fdbcSvsakar */ 1194*6451fdbcSvsakar range_check(&nsect, "nsect", 1, 32768, DFLNSECT, nsect_flag); 1195*6451fdbcSvsakar /* 1196*6451fdbcSvsakar * ntrack is the number of tracks per cylinder. 1197*6451fdbcSvsakar * The ntrack value must be between 1 and the total number of 1198*6451fdbcSvsakar * sectors in the file system. 1199*6451fdbcSvsakar */ 1200*6451fdbcSvsakar range_check(&ntrack, "ntrack", 1, 1201*6451fdbcSvsakar fssize_db > INT_MAX ? INT_MAX : (uint32_t)fssize_db, 1202*6451fdbcSvsakar DFLNTRAK, ntrack_flag); 1203*6451fdbcSvsakar } 1204*6451fdbcSvsakar 12057c478bd9Sstevel@tonic-gate range_check(&apc, "apc", 0, nsect - 1, 0, apc_flag); 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate if (mtb == 'y') 12087c478bd9Sstevel@tonic-gate fragsize = bsize; 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate range_check(&fragsize, "fragsize", sectorsize, bsize, 12117c478bd9Sstevel@tonic-gate MAX(bsize / MAXFRAG, MIN(DESFRAGSIZE, bsize)), fragsize_flag); 12127c478bd9Sstevel@tonic-gate 12137c478bd9Sstevel@tonic-gate if ((bsize / MAXFRAG) > fragsize) { 12147c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 12157c478bd9Sstevel@tonic-gate "fragment size %ld is too small, minimum with block size %ld is %ld\n"), 12167c478bd9Sstevel@tonic-gate fragsize, bsize, bsize / MAXFRAG); 12177c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12187c478bd9Sstevel@tonic-gate gettext("mkfs: fragsize reset to minimum %ld\n"), 12197c478bd9Sstevel@tonic-gate bsize / MAXFRAG); 12207c478bd9Sstevel@tonic-gate fragsize = bsize / MAXFRAG; 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate if (!POWEROF2(fragsize)) { 12247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12257c478bd9Sstevel@tonic-gate gettext("fragment size must be a power of 2, not %ld\n"), 12267c478bd9Sstevel@tonic-gate fragsize); 12277c478bd9Sstevel@tonic-gate fragsize = MAX(bsize / MAXFRAG, MIN(DESFRAGSIZE, bsize)); 12287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12297c478bd9Sstevel@tonic-gate gettext("mkfs: fragsize reset to %ld\n"), 12307c478bd9Sstevel@tonic-gate fragsize); 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate /* At this point, bsize must be >= fragsize, so no need to check it */ 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate if (bsize < PAGESIZE) { 12367c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 12377c478bd9Sstevel@tonic-gate "WARNING: filesystem block size (%ld) is smaller than " 12387c478bd9Sstevel@tonic-gate "memory page size (%ld).\nResulting filesystem can not be " 12397c478bd9Sstevel@tonic-gate "mounted on this system.\n\n"), 12407c478bd9Sstevel@tonic-gate bsize, (long)PAGESIZE); 12417c478bd9Sstevel@tonic-gate } 12427c478bd9Sstevel@tonic-gate 12437c478bd9Sstevel@tonic-gate range_check(&rps, "rps", 1, 1000, DEFHZ, rps_flag); 12447c478bd9Sstevel@tonic-gate range_check(&minfree, "free", 0, 99, MINFREE, minfree_flag); 12457c478bd9Sstevel@tonic-gate range_check(&nrpos, "nrpos", 1, nsect, MIN(nsect, NRPOS), nrpos_flag); 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate /* 12487c478bd9Sstevel@tonic-gate * nbpi is variable, but 2MB seems a reasonable upper limit, 12497c478bd9Sstevel@tonic-gate * as 4MB tends to cause problems (using otherwise-default 12507c478bd9Sstevel@tonic-gate * parameters). The true limit is where we end up with one 12517c478bd9Sstevel@tonic-gate * inode per cylinder group. If this file system is being 12527c478bd9Sstevel@tonic-gate * configured for multi-terabyte access, nbpi must be at least 1MB. 12537c478bd9Sstevel@tonic-gate */ 12547c478bd9Sstevel@tonic-gate if (mtb == 'y' && nbpi < MTB_NBPI) { 12557c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("mkfs: bad value for nbpi: " 12567c478bd9Sstevel@tonic-gate "must be at least 1048576 for multi-terabyte, " 12577c478bd9Sstevel@tonic-gate "nbpi reset to default 1048576\n")); 12587c478bd9Sstevel@tonic-gate nbpi = MTB_NBPI; 12597c478bd9Sstevel@tonic-gate } 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate if (mtb == 'y') 12627c478bd9Sstevel@tonic-gate range_check(&nbpi, "nbpi", MTB_NBPI, 2 * MB, MTB_NBPI, 12637c478bd9Sstevel@tonic-gate nbpi_flag); 12647c478bd9Sstevel@tonic-gate else 12657c478bd9Sstevel@tonic-gate range_check(&nbpi, "nbpi", DEV_BSIZE, 2 * MB, NBPI, nbpi_flag); 12667c478bd9Sstevel@tonic-gate 12677c478bd9Sstevel@tonic-gate /* 12687c478bd9Sstevel@tonic-gate * maxcpg is another variably-limited parameter. Calculate 12697c478bd9Sstevel@tonic-gate * the limit based on what we've got for its dependent 12707c478bd9Sstevel@tonic-gate * variables. Effectively, it's how much space is left in the 12717c478bd9Sstevel@tonic-gate * superblock after all the other bits are accounted for. We 12727c478bd9Sstevel@tonic-gate * only fill in sblock fields so we can use MAXIpG. 12737c478bd9Sstevel@tonic-gate * 12747c478bd9Sstevel@tonic-gate * If the calculation of maxcpg below (for the mtb == 'n' 12757c478bd9Sstevel@tonic-gate * case) is changed, update newfs as well. 12767c478bd9Sstevel@tonic-gate * 12777c478bd9Sstevel@tonic-gate * For old-style, non-MTB format file systems, use the old 12787c478bd9Sstevel@tonic-gate * algorithm for calculating the maximum cylinder group size, 12797c478bd9Sstevel@tonic-gate * even though it limits the cylinder group more than necessary. 12807c478bd9Sstevel@tonic-gate * Since layout can affect performance, we don't want to change 12817c478bd9Sstevel@tonic-gate * the default layout for non-MTB file systems at this time. 12827c478bd9Sstevel@tonic-gate * However, for MTB file systems, use the new maxcpg calculation, 12837c478bd9Sstevel@tonic-gate * which really maxes out the cylinder group size. 12847c478bd9Sstevel@tonic-gate */ 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate sblock.fs_bsize = bsize; 12877c478bd9Sstevel@tonic-gate sblock.fs_inopb = sblock.fs_bsize / sizeof (struct dinode); 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate if (mtb == 'n') { 12907c478bd9Sstevel@tonic-gate maxcpg = (bsize - sizeof (struct cg) - 12917c478bd9Sstevel@tonic-gate howmany(MAXIpG(&sblock), NBBY)) / 12927c478bd9Sstevel@tonic-gate (sizeof (long) + nrpos * sizeof (short) + 12937c478bd9Sstevel@tonic-gate nsect / (MAXFRAG * NBBY)); 12947c478bd9Sstevel@tonic-gate } else { 12957c478bd9Sstevel@tonic-gate maxcpg = compute_maxcpg(bsize, fragsize, nbpi, nrpos, 12967c478bd9Sstevel@tonic-gate nsect * ntrack); 12977c478bd9Sstevel@tonic-gate } 12987c478bd9Sstevel@tonic-gate 1299*6451fdbcSvsakar dprintf(("DeBuG cpg : %ld\n", cpg)); 13007c478bd9Sstevel@tonic-gate if (cpg == -1) 13017c478bd9Sstevel@tonic-gate cpg = maxcpg; 1302*6451fdbcSvsakar dprintf(("DeBuG cpg : %ld\n", cpg)); 1303*6451fdbcSvsakar 13047c478bd9Sstevel@tonic-gate /* 13057c478bd9Sstevel@tonic-gate * mincpg is variable in complex ways, so we really can't 13067c478bd9Sstevel@tonic-gate * do a sane lower-end limit check at this point. 13077c478bd9Sstevel@tonic-gate */ 13087c478bd9Sstevel@tonic-gate range_check(&cpg, "cgsize", 1, maxcpg, MIN(maxcpg, DESCPG), cpg_flag); 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * get the controller info 13127c478bd9Sstevel@tonic-gate */ 13137c478bd9Sstevel@tonic-gate ismdd = 0; 13147c478bd9Sstevel@tonic-gate islog = 0; 13157c478bd9Sstevel@tonic-gate islogok = 0; 13167c478bd9Sstevel@tonic-gate waslog = 0; 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate if (ioctl(fsi, DKIOCINFO, &dkcinfo) == 0) 13197c478bd9Sstevel@tonic-gate /* 13207c478bd9Sstevel@tonic-gate * if it is an MDD (disksuite) device 13217c478bd9Sstevel@tonic-gate */ 13227c478bd9Sstevel@tonic-gate if (dkcinfo.dki_ctype == DKC_MD) { 13237c478bd9Sstevel@tonic-gate ismdd++; 13247c478bd9Sstevel@tonic-gate /* 13257c478bd9Sstevel@tonic-gate * check the logging device 13267c478bd9Sstevel@tonic-gate */ 13277c478bd9Sstevel@tonic-gate if (ioctl(fsi, _FIOISLOG, NULL) == 0) { 13287c478bd9Sstevel@tonic-gate islog++; 13297c478bd9Sstevel@tonic-gate if (ioctl(fsi, _FIOISLOGOK, NULL) == 0) 13307c478bd9Sstevel@tonic-gate islogok++; 13317c478bd9Sstevel@tonic-gate } 13327c478bd9Sstevel@tonic-gate } 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate /* 13357c478bd9Sstevel@tonic-gate * Do not grow the file system, but print on stdout the maximum 13367c478bd9Sstevel@tonic-gate * size in sectors to which the file system can be increased. 13377c478bd9Sstevel@tonic-gate * The calculated size is limited by fssize_db. 13387c478bd9Sstevel@tonic-gate * Note that we don't lock the filesystem and therefore under rare 13397c478bd9Sstevel@tonic-gate * conditions (the filesystem is mounted, the free block count is 13407c478bd9Sstevel@tonic-gate * almost zero, and the superuser is still changing it) the calculated 13417c478bd9Sstevel@tonic-gate * size can be imprecise. 13427c478bd9Sstevel@tonic-gate */ 13437c478bd9Sstevel@tonic-gate if (Pflag) { 13447c478bd9Sstevel@tonic-gate (void) printf("%llu\n", probe_summaryinfo()); 13457c478bd9Sstevel@tonic-gate exit(0); 13467c478bd9Sstevel@tonic-gate } 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate /* 13497c478bd9Sstevel@tonic-gate * If we're growing an existing filesystem, then we're about 13507c478bd9Sstevel@tonic-gate * to start doing things that can require recovery efforts if 13517c478bd9Sstevel@tonic-gate * we get interrupted, so make sure we get a chance to do so. 13527c478bd9Sstevel@tonic-gate */ 13537c478bd9Sstevel@tonic-gate if (grow) { 13547c478bd9Sstevel@tonic-gate sigact.sa_handler = recover_from_sigint; 13557c478bd9Sstevel@tonic-gate sigemptyset(&sigact.sa_mask); 13567c478bd9Sstevel@tonic-gate sigact.sa_flags = SA_RESTART; 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate if (sigaction(SIGINT, &sigact, (struct sigaction *)NULL) < 0) { 13597c478bd9Sstevel@tonic-gate perror(gettext("Could not register SIGINT handler")); 13607c478bd9Sstevel@tonic-gate lockexit(3); 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate } 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate if (!Nflag) { 13657c478bd9Sstevel@tonic-gate /* 13667c478bd9Sstevel@tonic-gate * Check if MNTTAB is trustable 13677c478bd9Sstevel@tonic-gate */ 13687c478bd9Sstevel@tonic-gate if (statvfs64(MNTTAB, &fs) < 0) { 13697c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("can't statvfs %s\n"), 13707c478bd9Sstevel@tonic-gate MNTTAB); 13717c478bd9Sstevel@tonic-gate exit(32); 13727c478bd9Sstevel@tonic-gate } 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate if (strcmp(MNTTYPE_MNTFS, fs.f_basetype) != 0) { 13757c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 13767c478bd9Sstevel@tonic-gate "%s file system type is not %s, can't mkfs\n"), 13777c478bd9Sstevel@tonic-gate MNTTAB, MNTTYPE_MNTFS); 13787c478bd9Sstevel@tonic-gate exit(32); 13797c478bd9Sstevel@tonic-gate } 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate special = getfullblkname(fsys); 13827c478bd9Sstevel@tonic-gate checkdev(fsys, special); 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate /* 13857c478bd9Sstevel@tonic-gate * If we found the block device name, 13867c478bd9Sstevel@tonic-gate * then check the mount table. 13877c478bd9Sstevel@tonic-gate * if mounted, and growing write lock the file system 13887c478bd9Sstevel@tonic-gate * 13897c478bd9Sstevel@tonic-gate */ 13907c478bd9Sstevel@tonic-gate if ((special != NULL) && (*special != '\0')) { 13917c478bd9Sstevel@tonic-gate if ((mnttab = fopen(MNTTAB, "r")) == NULL) { 13927c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 13937c478bd9Sstevel@tonic-gate "can't open %s\n"), MNTTAB); 13947c478bd9Sstevel@tonic-gate exit(32); 13957c478bd9Sstevel@tonic-gate } 13967c478bd9Sstevel@tonic-gate while ((getmntent(mnttab, &mntp)) == NULL) { 13977c478bd9Sstevel@tonic-gate if (grow) { 13987c478bd9Sstevel@tonic-gate checkmount(&mntp, special); 13997c478bd9Sstevel@tonic-gate continue; 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate if (strcmp(special, mntp.mnt_special) == 0) { 14027c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 14037c478bd9Sstevel@tonic-gate "%s is mounted, can't mkfs\n"), 14047c478bd9Sstevel@tonic-gate special); 14057c478bd9Sstevel@tonic-gate exit(32); 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate } 14087c478bd9Sstevel@tonic-gate (void) fclose(mnttab); 14097c478bd9Sstevel@tonic-gate } 14107c478bd9Sstevel@tonic-gate 14117c478bd9Sstevel@tonic-gate if (directory && (ismounted == 0)) { 14127c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s is not mounted\n"), 14137c478bd9Sstevel@tonic-gate special); 14147c478bd9Sstevel@tonic-gate lockexit(32); 14157c478bd9Sstevel@tonic-gate } 14167c478bd9Sstevel@tonic-gate 14177c478bd9Sstevel@tonic-gate fso = (grow) ? open64(fsys, O_WRONLY) : creat64(fsys, 0666); 14187c478bd9Sstevel@tonic-gate if (fso < 0) { 14197c478bd9Sstevel@tonic-gate saverr = errno; 14207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14217c478bd9Sstevel@tonic-gate gettext("%s: cannot create: %s\n"), 14227c478bd9Sstevel@tonic-gate fsys, strerror(saverr)); 14237c478bd9Sstevel@tonic-gate lockexit(32); 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate } else { 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * For the -N case, a file descriptor is needed for the llseek() 14307c478bd9Sstevel@tonic-gate * in wtfs(). See the comment in wtfs() for more information. 14317c478bd9Sstevel@tonic-gate * 14327c478bd9Sstevel@tonic-gate * Get a file descriptor that's read-only so that this code 14337c478bd9Sstevel@tonic-gate * doesn't accidentally write to the file. 14347c478bd9Sstevel@tonic-gate */ 14357c478bd9Sstevel@tonic-gate fso = open64(fsys, O_RDONLY); 14367c478bd9Sstevel@tonic-gate if (fso < 0) { 14377c478bd9Sstevel@tonic-gate saverr = errno; 14387c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: cannot open: %s\n"), 14397c478bd9Sstevel@tonic-gate fsys, strerror(saverr)); 14407c478bd9Sstevel@tonic-gate lockexit(32); 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate } 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate /* 14457c478bd9Sstevel@tonic-gate * seed random # generator (for ic_generation) 14467c478bd9Sstevel@tonic-gate */ 14477c478bd9Sstevel@tonic-gate #ifdef MKFS_DEBUG 14487c478bd9Sstevel@tonic-gate srand48(12962); /* reproducible results */ 14497c478bd9Sstevel@tonic-gate #else 14507c478bd9Sstevel@tonic-gate srand48((long)(time((time_t *)NULL) + getpid())); 14517c478bd9Sstevel@tonic-gate #endif 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate if (grow) { 14547c478bd9Sstevel@tonic-gate growinit(fsys); 14557c478bd9Sstevel@tonic-gate goto grow00; 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate /* 14597c478bd9Sstevel@tonic-gate * Validate the given file system size. 14607c478bd9Sstevel@tonic-gate * Verify that its last block can actually be accessed. 14617c478bd9Sstevel@tonic-gate * 14627c478bd9Sstevel@tonic-gate * Note: it's ok to use sblock as a buffer because it is immediately 14637c478bd9Sstevel@tonic-gate * overwritten by the rdfs() of the superblock in the next line. 14647c478bd9Sstevel@tonic-gate * 14657c478bd9Sstevel@tonic-gate * ToDo: Because the size checking is done in rdfs()/wtfs(), the 14667c478bd9Sstevel@tonic-gate * error message for specifying an illegal size is very unfriendly. 14677c478bd9Sstevel@tonic-gate * In the future, one could replace the rdfs()/wtfs() calls 14687c478bd9Sstevel@tonic-gate * below with in-line calls to read() or write(). This allows better 14697c478bd9Sstevel@tonic-gate * error messages to be put in place. 14707c478bd9Sstevel@tonic-gate */ 14717c478bd9Sstevel@tonic-gate rdfs(fssize_db - 1, (int)sectorsize, (char *)&sblock); 14727c478bd9Sstevel@tonic-gate 14737c478bd9Sstevel@tonic-gate /* 14747c478bd9Sstevel@tonic-gate * make the fs unmountable 14757c478bd9Sstevel@tonic-gate */ 14767c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock); 14777c478bd9Sstevel@tonic-gate sblock.fs_magic = -1; 14787c478bd9Sstevel@tonic-gate sblock.fs_clean = FSBAD; 14797c478bd9Sstevel@tonic-gate sblock.fs_state = FSOKAY - sblock.fs_time; 14807c478bd9Sstevel@tonic-gate wtfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock); 14817c478bd9Sstevel@tonic-gate bzero(&sblock, (size_t)sbsize); 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate sblock.fs_nsect = nsect; 14847c478bd9Sstevel@tonic-gate sblock.fs_ntrak = ntrack; 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate /* 14877c478bd9Sstevel@tonic-gate * Validate specified/determined spc 14887c478bd9Sstevel@tonic-gate * and calculate minimum cylinders per group. 14897c478bd9Sstevel@tonic-gate */ 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate /* 14927c478bd9Sstevel@tonic-gate * sectors/cyl = tracks/cyl * sectors/track 14937c478bd9Sstevel@tonic-gate */ 14947c478bd9Sstevel@tonic-gate sblock.fs_spc = sblock.fs_ntrak * sblock.fs_nsect; 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate grow00: 14977c478bd9Sstevel@tonic-gate if (apc_flag) { 14987c478bd9Sstevel@tonic-gate sblock.fs_spc -= apc; 14997c478bd9Sstevel@tonic-gate } 15007c478bd9Sstevel@tonic-gate /* 15017c478bd9Sstevel@tonic-gate * Have to test for this separately from apc_flag, due to 15027c478bd9Sstevel@tonic-gate * the growfs case.... 15037c478bd9Sstevel@tonic-gate */ 15047c478bd9Sstevel@tonic-gate if (sblock.fs_spc != sblock.fs_ntrak * sblock.fs_nsect) { 15057c478bd9Sstevel@tonic-gate spc_flag = 1; 15067c478bd9Sstevel@tonic-gate } 15077c478bd9Sstevel@tonic-gate if (grow) 15087c478bd9Sstevel@tonic-gate goto grow10; 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate sblock.fs_nrpos = nrpos; 15117c478bd9Sstevel@tonic-gate sblock.fs_bsize = bsize; 15127c478bd9Sstevel@tonic-gate sblock.fs_fsize = fragsize; 15137c478bd9Sstevel@tonic-gate sblock.fs_minfree = minfree; 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate grow10: 15167c478bd9Sstevel@tonic-gate if (nbpi < sblock.fs_fsize) { 15177c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 15187c478bd9Sstevel@tonic-gate "warning: wasteful data byte allocation / inode (nbpi):\n")); 15197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 15207c478bd9Sstevel@tonic-gate "%ld smaller than allocatable fragment size of %d\n"), 15217c478bd9Sstevel@tonic-gate nbpi, sblock.fs_fsize); 15227c478bd9Sstevel@tonic-gate } 15237c478bd9Sstevel@tonic-gate if (grow) 15247c478bd9Sstevel@tonic-gate goto grow20; 15257c478bd9Sstevel@tonic-gate 15267c478bd9Sstevel@tonic-gate if (opt == 's') 15277c478bd9Sstevel@tonic-gate sblock.fs_optim = FS_OPTSPACE; 15287c478bd9Sstevel@tonic-gate else 15297c478bd9Sstevel@tonic-gate sblock.fs_optim = FS_OPTTIME; 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate sblock.fs_bmask = ~(sblock.fs_bsize - 1); 15327c478bd9Sstevel@tonic-gate sblock.fs_fmask = ~(sblock.fs_fsize - 1); 15337c478bd9Sstevel@tonic-gate /* 15347c478bd9Sstevel@tonic-gate * Planning now for future expansion. 15357c478bd9Sstevel@tonic-gate */ 15367c478bd9Sstevel@tonic-gate #if defined(_BIG_ENDIAN) 15377c478bd9Sstevel@tonic-gate sblock.fs_qbmask.val[0] = 0; 15387c478bd9Sstevel@tonic-gate sblock.fs_qbmask.val[1] = ~sblock.fs_bmask; 15397c478bd9Sstevel@tonic-gate sblock.fs_qfmask.val[0] = 0; 15407c478bd9Sstevel@tonic-gate sblock.fs_qfmask.val[1] = ~sblock.fs_fmask; 15417c478bd9Sstevel@tonic-gate #endif 15427c478bd9Sstevel@tonic-gate #if defined(_LITTLE_ENDIAN) 15437c478bd9Sstevel@tonic-gate sblock.fs_qbmask.val[0] = ~sblock.fs_bmask; 15447c478bd9Sstevel@tonic-gate sblock.fs_qbmask.val[1] = 0; 15457c478bd9Sstevel@tonic-gate sblock.fs_qfmask.val[0] = ~sblock.fs_fmask; 15467c478bd9Sstevel@tonic-gate sblock.fs_qfmask.val[1] = 0; 15477c478bd9Sstevel@tonic-gate #endif 15487c478bd9Sstevel@tonic-gate for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1) 15497c478bd9Sstevel@tonic-gate sblock.fs_bshift++; 15507c478bd9Sstevel@tonic-gate for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1) 15517c478bd9Sstevel@tonic-gate sblock.fs_fshift++; 15527c478bd9Sstevel@tonic-gate sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize); 15537c478bd9Sstevel@tonic-gate for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1) 15547c478bd9Sstevel@tonic-gate sblock.fs_fragshift++; 15557c478bd9Sstevel@tonic-gate if (sblock.fs_frag > MAXFRAG) { 15567c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 15577c478bd9Sstevel@tonic-gate "fragment size %d is too small, minimum with block size %d is %d\n"), 15587c478bd9Sstevel@tonic-gate sblock.fs_fsize, sblock.fs_bsize, 15597c478bd9Sstevel@tonic-gate sblock.fs_bsize / MAXFRAG); 15607c478bd9Sstevel@tonic-gate lockexit(32); 15617c478bd9Sstevel@tonic-gate } 15627c478bd9Sstevel@tonic-gate sblock.fs_nindir = sblock.fs_bsize / sizeof (daddr32_t); 15637c478bd9Sstevel@tonic-gate sblock.fs_inopb = sblock.fs_bsize / sizeof (struct dinode); 15647c478bd9Sstevel@tonic-gate sblock.fs_nspf = sblock.fs_fsize / sectorsize; 15657c478bd9Sstevel@tonic-gate for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1) 15667c478bd9Sstevel@tonic-gate sblock.fs_fsbtodb++; 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate /* 15697c478bd9Sstevel@tonic-gate * Compute the super-block, cylinder group, and inode blocks. 15707c478bd9Sstevel@tonic-gate * Note that these "blkno" are really fragment addresses. 15717c478bd9Sstevel@tonic-gate * For example, on an 8K/1K (block/fragment) system, fs_sblkno is 16, 15727c478bd9Sstevel@tonic-gate * fs_cblkno is 24, and fs_iblkno is 32. This is why CGSIZE is so 15737c478bd9Sstevel@tonic-gate * important: only 1 FS block is allocated for the cg struct (fragment 15747c478bd9Sstevel@tonic-gate * numbers 24 through 31). 15757c478bd9Sstevel@tonic-gate */ 15767c478bd9Sstevel@tonic-gate sblock.fs_sblkno = 15777c478bd9Sstevel@tonic-gate roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag); 15787c478bd9Sstevel@tonic-gate sblock.fs_cblkno = (daddr32_t)(sblock.fs_sblkno + 15797c478bd9Sstevel@tonic-gate roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag)); 15807c478bd9Sstevel@tonic-gate sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag; 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate sblock.fs_cgoffset = roundup( 15837c478bd9Sstevel@tonic-gate howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag); 15847c478bd9Sstevel@tonic-gate for (sblock.fs_cgmask = -1, i = sblock.fs_ntrak; i > 1; i >>= 1) 15857c478bd9Sstevel@tonic-gate sblock.fs_cgmask <<= 1; 15867c478bd9Sstevel@tonic-gate if (!POWEROF2(sblock.fs_ntrak)) 15877c478bd9Sstevel@tonic-gate sblock.fs_cgmask <<= 1; 15887c478bd9Sstevel@tonic-gate /* 15897c478bd9Sstevel@tonic-gate * Validate specified/determined spc 15907c478bd9Sstevel@tonic-gate * and calculate minimum cylinders per group. 15917c478bd9Sstevel@tonic-gate */ 15927c478bd9Sstevel@tonic-gate 15937c478bd9Sstevel@tonic-gate for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc; 15947c478bd9Sstevel@tonic-gate sblock.fs_cpc > 1 && (i & 1) == 0; 15957c478bd9Sstevel@tonic-gate sblock.fs_cpc >>= 1, i >>= 1) 15967c478bd9Sstevel@tonic-gate /* void */; 15977c478bd9Sstevel@tonic-gate mincpc = sblock.fs_cpc; 15987c478bd9Sstevel@tonic-gate 15997c478bd9Sstevel@tonic-gate /* if these calculations are changed, check dump_fscmd also */ 16007c478bd9Sstevel@tonic-gate bpcg = (uint64_t)sblock.fs_spc * sectorsize; 16017c478bd9Sstevel@tonic-gate inospercg = (uint64_t)roundup(bpcg / sizeof (struct dinode), 16027c478bd9Sstevel@tonic-gate INOPB(&sblock)); 16037c478bd9Sstevel@tonic-gate if (inospercg > MAXIpG(&sblock)) 16047c478bd9Sstevel@tonic-gate inospercg = MAXIpG(&sblock); 16057c478bd9Sstevel@tonic-gate used = (uint64_t)(sblock.fs_iblkno + inospercg / 16067c478bd9Sstevel@tonic-gate INOPF(&sblock)) * NSPF(&sblock); 16077c478bd9Sstevel@tonic-gate mincpgcnt = (long)howmany((uint64_t)sblock.fs_cgoffset * 16087c478bd9Sstevel@tonic-gate (~sblock.fs_cgmask) + used, sblock.fs_spc); 16097c478bd9Sstevel@tonic-gate mincpg = roundup(mincpgcnt, mincpc); 16107c478bd9Sstevel@tonic-gate /* 16117c478bd9Sstevel@tonic-gate * Insure that cylinder group with mincpg has enough space 16127c478bd9Sstevel@tonic-gate * for block maps 16137c478bd9Sstevel@tonic-gate */ 16147c478bd9Sstevel@tonic-gate sblock.fs_cpg = mincpg; 16157c478bd9Sstevel@tonic-gate sblock.fs_ipg = (int32_t)inospercg; 16167c478bd9Sstevel@tonic-gate mapcramped = 0; 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate /* 16197c478bd9Sstevel@tonic-gate * Make sure the cg struct fits within the file system block. 16207c478bd9Sstevel@tonic-gate * Use larger block sizes until it fits 16217c478bd9Sstevel@tonic-gate */ 16227c478bd9Sstevel@tonic-gate while (CGSIZE(&sblock) > sblock.fs_bsize) { 16237c478bd9Sstevel@tonic-gate mapcramped = 1; 16247c478bd9Sstevel@tonic-gate if (sblock.fs_bsize < MAXBSIZE) { 16257c478bd9Sstevel@tonic-gate sblock.fs_bsize <<= 1; 16267c478bd9Sstevel@tonic-gate if ((i & 1) == 0) { 16277c478bd9Sstevel@tonic-gate i >>= 1; 16287c478bd9Sstevel@tonic-gate } else { 16297c478bd9Sstevel@tonic-gate sblock.fs_cpc <<= 1; 16307c478bd9Sstevel@tonic-gate mincpc <<= 1; 16317c478bd9Sstevel@tonic-gate mincpg = roundup(mincpgcnt, mincpc); 16327c478bd9Sstevel@tonic-gate sblock.fs_cpg = mincpg; 16337c478bd9Sstevel@tonic-gate } 16347c478bd9Sstevel@tonic-gate sblock.fs_frag <<= 1; 16357c478bd9Sstevel@tonic-gate sblock.fs_fragshift += 1; 16367c478bd9Sstevel@tonic-gate if (sblock.fs_frag <= MAXFRAG) 16377c478bd9Sstevel@tonic-gate continue; 16387c478bd9Sstevel@tonic-gate } 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate /* 16417c478bd9Sstevel@tonic-gate * Looped far enough. The fragment is now as large as the 16427c478bd9Sstevel@tonic-gate * filesystem block! 16437c478bd9Sstevel@tonic-gate */ 16447c478bd9Sstevel@tonic-gate if (sblock.fs_fsize == sblock.fs_bsize) { 16457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 16467c478bd9Sstevel@tonic-gate "There is no block size that can support this disk\n")); 16477c478bd9Sstevel@tonic-gate lockexit(32); 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate /* 16517c478bd9Sstevel@tonic-gate * Try a larger fragment. Double the fragment size. 16527c478bd9Sstevel@tonic-gate */ 16537c478bd9Sstevel@tonic-gate sblock.fs_frag >>= 1; 16547c478bd9Sstevel@tonic-gate sblock.fs_fragshift -= 1; 16557c478bd9Sstevel@tonic-gate sblock.fs_fsize <<= 1; 16567c478bd9Sstevel@tonic-gate sblock.fs_nspf <<= 1; 16577c478bd9Sstevel@tonic-gate } 16587c478bd9Sstevel@tonic-gate /* 16597c478bd9Sstevel@tonic-gate * Insure that cylinder group with mincpg has enough space for inodes 16607c478bd9Sstevel@tonic-gate */ 16617c478bd9Sstevel@tonic-gate inodecramped = 0; 16627c478bd9Sstevel@tonic-gate used *= sectorsize; 16637c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)mincpg * bpcg - used; 16647c478bd9Sstevel@tonic-gate inospercg = (uint64_t)roundup((nbytes64 / nbpi), INOPB(&sblock)); 16657c478bd9Sstevel@tonic-gate sblock.fs_ipg = (int32_t)inospercg; 16667c478bd9Sstevel@tonic-gate while (inospercg > MAXIpG(&sblock)) { 16677c478bd9Sstevel@tonic-gate inodecramped = 1; 16687c478bd9Sstevel@tonic-gate if (mincpc == 1 || sblock.fs_frag == 1 || 16697c478bd9Sstevel@tonic-gate sblock.fs_bsize == MINBSIZE) 16707c478bd9Sstevel@tonic-gate break; 16717c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)mincpg * bpcg - used; 16727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 16737c478bd9Sstevel@tonic-gate gettext("With a block size of %d %s %lu\n"), 16747c478bd9Sstevel@tonic-gate sblock.fs_bsize, gettext("minimum bytes per inode is"), 16757c478bd9Sstevel@tonic-gate (uint32_t)(nbytes64 / MAXIpG(&sblock) + 1)); 16767c478bd9Sstevel@tonic-gate sblock.fs_bsize >>= 1; 16777c478bd9Sstevel@tonic-gate sblock.fs_frag >>= 1; 16787c478bd9Sstevel@tonic-gate sblock.fs_fragshift -= 1; 16797c478bd9Sstevel@tonic-gate mincpc >>= 1; 16807c478bd9Sstevel@tonic-gate sblock.fs_cpg = roundup(mincpgcnt, mincpc); 16817c478bd9Sstevel@tonic-gate if (CGSIZE(&sblock) > sblock.fs_bsize) { 16827c478bd9Sstevel@tonic-gate sblock.fs_bsize <<= 1; 16837c478bd9Sstevel@tonic-gate break; 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate mincpg = sblock.fs_cpg; 16867c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)mincpg * bpcg - used; 16877c478bd9Sstevel@tonic-gate inospercg = (uint64_t)roundup((nbytes64 / nbpi), 16887c478bd9Sstevel@tonic-gate INOPB(&sblock)); 16897c478bd9Sstevel@tonic-gate sblock.fs_ipg = (int32_t)inospercg; 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate if (inodecramped) { 16927c478bd9Sstevel@tonic-gate if (inospercg > MAXIpG(&sblock)) { 16937c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)mincpg * bpcg - used; 16947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 16957c478bd9Sstevel@tonic-gate "Minimum bytes per inode is %d\n"), 16967c478bd9Sstevel@tonic-gate (uint32_t)(nbytes64 / MAXIpG(&sblock) + 1)); 16977c478bd9Sstevel@tonic-gate } else if (!mapcramped) { 16987c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 16997c478bd9Sstevel@tonic-gate "With %ld bytes per inode, minimum cylinders per group is %ld\n"), 17007c478bd9Sstevel@tonic-gate nbpi, mincpg); 17017c478bd9Sstevel@tonic-gate } 17027c478bd9Sstevel@tonic-gate } 17037c478bd9Sstevel@tonic-gate if (mapcramped) { 17047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17057c478bd9Sstevel@tonic-gate "With %d sectors per cylinder, minimum cylinders " 17067c478bd9Sstevel@tonic-gate "per group is %ld\n"), 17077c478bd9Sstevel@tonic-gate sblock.fs_spc, mincpg); 17087c478bd9Sstevel@tonic-gate } 17097c478bd9Sstevel@tonic-gate if (inodecramped || mapcramped) { 17107c478bd9Sstevel@tonic-gate /* 17117c478bd9Sstevel@tonic-gate * To make this at least somewhat comprehensible in 17127c478bd9Sstevel@tonic-gate * the world of i18n, figure out what we're going to 17137c478bd9Sstevel@tonic-gate * say and then say it all at one time. The days of 17147c478bd9Sstevel@tonic-gate * needing to scrimp on string space are behind us.... 17157c478bd9Sstevel@tonic-gate */ 17167c478bd9Sstevel@tonic-gate if ((sblock.fs_bsize != bsize) && 17177c478bd9Sstevel@tonic-gate (sblock.fs_fsize != fragsize)) { 17187c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17197c478bd9Sstevel@tonic-gate "This requires the block size to be changed from %ld to %d\n" 17207c478bd9Sstevel@tonic-gate "and the fragment size to be changed from %ld to %d\n"), 17217c478bd9Sstevel@tonic-gate bsize, sblock.fs_bsize, 17227c478bd9Sstevel@tonic-gate fragsize, sblock.fs_fsize); 17237c478bd9Sstevel@tonic-gate } else if (sblock.fs_bsize != bsize) { 17247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17257c478bd9Sstevel@tonic-gate "This requires the block size to be changed from %ld to %d\n"), 17267c478bd9Sstevel@tonic-gate bsize, sblock.fs_bsize); 17277c478bd9Sstevel@tonic-gate } else if (sblock.fs_fsize != fragsize) { 17287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17297c478bd9Sstevel@tonic-gate "This requires the fragment size to be changed from %ld to %d\n"), 17307c478bd9Sstevel@tonic-gate fragsize, sblock.fs_fsize); 17317c478bd9Sstevel@tonic-gate } else { 17327c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17337c478bd9Sstevel@tonic-gate "Unable to make filesystem fit with the given constraints\n")); 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17367c478bd9Sstevel@tonic-gate "Please re-run mkfs with corrected parameters\n")); 17377c478bd9Sstevel@tonic-gate lockexit(32); 17387c478bd9Sstevel@tonic-gate } 17397c478bd9Sstevel@tonic-gate /* 17407c478bd9Sstevel@tonic-gate * Calculate the number of cylinders per group 17417c478bd9Sstevel@tonic-gate */ 17427c478bd9Sstevel@tonic-gate sblock.fs_cpg = cpg; 17437c478bd9Sstevel@tonic-gate if (sblock.fs_cpg % mincpc != 0) { 17447c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17457c478bd9Sstevel@tonic-gate "Warning: cylinder groups must have a multiple " 17467c478bd9Sstevel@tonic-gate "of %ld cylinders with the given\n parameters\n"), 17477c478bd9Sstevel@tonic-gate mincpc); 17487c478bd9Sstevel@tonic-gate sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc); 17497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Rounded cgsize up to %d\n"), 17507c478bd9Sstevel@tonic-gate sblock.fs_cpg); 17517c478bd9Sstevel@tonic-gate } 17527c478bd9Sstevel@tonic-gate /* 17537c478bd9Sstevel@tonic-gate * Must insure there is enough space for inodes 17547c478bd9Sstevel@tonic-gate */ 17557c478bd9Sstevel@tonic-gate /* if these calculations are changed, check dump_fscmd also */ 17567c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used; 17577c478bd9Sstevel@tonic-gate sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi), INOPB(&sblock)); 17587c478bd9Sstevel@tonic-gate 17597c478bd9Sstevel@tonic-gate /* 17607c478bd9Sstevel@tonic-gate * Slim down cylinders per group, until the inodes can fit. 17617c478bd9Sstevel@tonic-gate */ 17627c478bd9Sstevel@tonic-gate while (sblock.fs_ipg > MAXIpG(&sblock)) { 17637c478bd9Sstevel@tonic-gate inodecramped = 1; 17647c478bd9Sstevel@tonic-gate sblock.fs_cpg -= mincpc; 17657c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used; 17667c478bd9Sstevel@tonic-gate sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi), 17677c478bd9Sstevel@tonic-gate INOPB(&sblock)); 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate /* 17707c478bd9Sstevel@tonic-gate * Must insure there is enough space to hold block map. 17717c478bd9Sstevel@tonic-gate * Cut down on cylinders per group, until the cg struct fits in a 17727c478bd9Sstevel@tonic-gate * filesystem block. 17737c478bd9Sstevel@tonic-gate */ 17747c478bd9Sstevel@tonic-gate while (CGSIZE(&sblock) > sblock.fs_bsize) { 17757c478bd9Sstevel@tonic-gate mapcramped = 1; 17767c478bd9Sstevel@tonic-gate sblock.fs_cpg -= mincpc; 17777c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used; 17787c478bd9Sstevel@tonic-gate sblock.fs_ipg = roundup((uint32_t)(nbytes64 / nbpi), 17797c478bd9Sstevel@tonic-gate INOPB(&sblock)); 17807c478bd9Sstevel@tonic-gate } 17817c478bd9Sstevel@tonic-gate sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock); 17827c478bd9Sstevel@tonic-gate if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) { 17837c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 17847c478bd9Sstevel@tonic-gate gettext("newfs: panic (fs_cpg * fs_spc) %% NSPF != 0\n")); 17857c478bd9Sstevel@tonic-gate lockexit(32); 17867c478bd9Sstevel@tonic-gate } 17877c478bd9Sstevel@tonic-gate if (sblock.fs_cpg < mincpg) { 17887c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 17897c478bd9Sstevel@tonic-gate "With the given parameters, cgsize must be at least %ld; please re-run mkfs\n"), 17907c478bd9Sstevel@tonic-gate mincpg); 17917c478bd9Sstevel@tonic-gate lockexit(32); 17927c478bd9Sstevel@tonic-gate } 17937c478bd9Sstevel@tonic-gate sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock)); 17947c478bd9Sstevel@tonic-gate grow20: 17957c478bd9Sstevel@tonic-gate /* 17967c478bd9Sstevel@tonic-gate * Now have size for file system and nsect and ntrak. 17977c478bd9Sstevel@tonic-gate * Determine number of cylinders and blocks in the file system. 17987c478bd9Sstevel@tonic-gate */ 17997c478bd9Sstevel@tonic-gate fssize_frag = (int64_t)dbtofsb(&sblock, fssize_db); 18007c478bd9Sstevel@tonic-gate if (fssize_frag > INT_MAX) { 18017c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 18027c478bd9Sstevel@tonic-gate "There are too many fragments in the system, increase fragment size\n"), 18037c478bd9Sstevel@tonic-gate mincpg); 18047c478bd9Sstevel@tonic-gate lockexit(32); 18057c478bd9Sstevel@tonic-gate } 18067c478bd9Sstevel@tonic-gate sblock.fs_size = (int32_t)fssize_frag; 18077c478bd9Sstevel@tonic-gate sblock.fs_ncyl = (int32_t)(fssize_frag * NSPF(&sblock) / sblock.fs_spc); 18087c478bd9Sstevel@tonic-gate if (fssize_frag * NSPF(&sblock) > 18097c478bd9Sstevel@tonic-gate (uint64_t)sblock.fs_ncyl * sblock.fs_spc) { 18107c478bd9Sstevel@tonic-gate sblock.fs_ncyl++; 18117c478bd9Sstevel@tonic-gate warn = 1; 18127c478bd9Sstevel@tonic-gate } 18137c478bd9Sstevel@tonic-gate if (sblock.fs_ncyl < 1) { 18147c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 18157c478bd9Sstevel@tonic-gate "file systems must have at least one cylinder\n")); 18167c478bd9Sstevel@tonic-gate lockexit(32); 18177c478bd9Sstevel@tonic-gate } 18187c478bd9Sstevel@tonic-gate if (grow) 18197c478bd9Sstevel@tonic-gate goto grow30; 18207c478bd9Sstevel@tonic-gate /* 18217c478bd9Sstevel@tonic-gate * Determine feasability/values of rotational layout tables. 18227c478bd9Sstevel@tonic-gate * 18237c478bd9Sstevel@tonic-gate * The size of the rotational layout tables is limited by the size 18247c478bd9Sstevel@tonic-gate * of the file system block, fs_bsize. The amount of space 18257c478bd9Sstevel@tonic-gate * available for tables is calculated as (fs_bsize - sizeof (struct 18267c478bd9Sstevel@tonic-gate * fs)). The size of these tables is inversely proportional to the 18277c478bd9Sstevel@tonic-gate * block size of the file system. The size increases if sectors per 18287c478bd9Sstevel@tonic-gate * track are not powers of two, because more cylinders must be 18297c478bd9Sstevel@tonic-gate * described by the tables before the rotational pattern repeats 18307c478bd9Sstevel@tonic-gate * (fs_cpc). 18317c478bd9Sstevel@tonic-gate */ 18327c478bd9Sstevel@tonic-gate sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT; 18337c478bd9Sstevel@tonic-gate sblock.fs_sbsize = fragroundup(&sblock, sizeof (struct fs)); 18347c478bd9Sstevel@tonic-gate sblock.fs_npsect = sblock.fs_nsect; 18357c478bd9Sstevel@tonic-gate if (sblock.fs_ntrak == 1) { 18367c478bd9Sstevel@tonic-gate sblock.fs_cpc = 0; 18377c478bd9Sstevel@tonic-gate goto next; 18387c478bd9Sstevel@tonic-gate } 18397c478bd9Sstevel@tonic-gate postblsize = sblock.fs_nrpos * sblock.fs_cpc * sizeof (short); 18407c478bd9Sstevel@tonic-gate rotblsize = sblock.fs_cpc * sblock.fs_spc / NSPB(&sblock); 18417c478bd9Sstevel@tonic-gate totalsbsize = sizeof (struct fs) + rotblsize; 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate /* do static allocation if nrpos == 8 and fs_cpc == 16 */ 18447c478bd9Sstevel@tonic-gate if (sblock.fs_nrpos == 8 && sblock.fs_cpc <= 16) { 18457c478bd9Sstevel@tonic-gate /* use old static table space */ 18467c478bd9Sstevel@tonic-gate sblock.fs_postbloff = (char *)(&sblock.fs_opostbl[0][0]) - 18477c478bd9Sstevel@tonic-gate (char *)(&sblock.fs_link); 18487c478bd9Sstevel@tonic-gate sblock.fs_rotbloff = &sblock.fs_space[0] - 18497c478bd9Sstevel@tonic-gate (uchar_t *)(&sblock.fs_link); 18507c478bd9Sstevel@tonic-gate } else { 18517c478bd9Sstevel@tonic-gate /* use 4.3 dynamic table space */ 18527c478bd9Sstevel@tonic-gate sblock.fs_postbloff = &sblock.fs_space[0] - 18537c478bd9Sstevel@tonic-gate (uchar_t *)(&sblock.fs_link); 18547c478bd9Sstevel@tonic-gate sblock.fs_rotbloff = sblock.fs_postbloff + postblsize; 18557c478bd9Sstevel@tonic-gate totalsbsize += postblsize; 18567c478bd9Sstevel@tonic-gate } 18577c478bd9Sstevel@tonic-gate if (totalsbsize > sblock.fs_bsize || 18587c478bd9Sstevel@tonic-gate sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) { 18597c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 18607c478bd9Sstevel@tonic-gate "Warning: insufficient space in super block for\n" 18617c478bd9Sstevel@tonic-gate "rotational layout tables with nsect %d, ntrack %d, " 18627c478bd9Sstevel@tonic-gate "and nrpos %d.\nOmitting tables - file system " 18637c478bd9Sstevel@tonic-gate "performance may be impaired.\n"), 18647c478bd9Sstevel@tonic-gate sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_nrpos); 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate /* 18677c478bd9Sstevel@tonic-gate * Setting fs_cpc to 0 tells alloccgblk() in ufs_alloc.c to 18687c478bd9Sstevel@tonic-gate * ignore the positional layout table and rotational 18697c478bd9Sstevel@tonic-gate * position table. 18707c478bd9Sstevel@tonic-gate */ 18717c478bd9Sstevel@tonic-gate sblock.fs_cpc = 0; 18727c478bd9Sstevel@tonic-gate goto next; 18737c478bd9Sstevel@tonic-gate } 18747c478bd9Sstevel@tonic-gate sblock.fs_sbsize = fragroundup(&sblock, totalsbsize); 18757c478bd9Sstevel@tonic-gate 18767c478bd9Sstevel@tonic-gate 18777c478bd9Sstevel@tonic-gate /* 18787c478bd9Sstevel@tonic-gate * calculate the available blocks for each rotational position 18797c478bd9Sstevel@tonic-gate */ 18807c478bd9Sstevel@tonic-gate for (cylno = 0; cylno < sblock.fs_cpc; cylno++) 18817c478bd9Sstevel@tonic-gate for (rpos = 0; rpos < sblock.fs_nrpos; rpos++) 18827c478bd9Sstevel@tonic-gate fs_postbl(&sblock, cylno)[rpos] = -1; 18837c478bd9Sstevel@tonic-gate for (i = (rotblsize - 1) * sblock.fs_frag; 18847c478bd9Sstevel@tonic-gate i >= 0; i -= sblock.fs_frag) { 18857c478bd9Sstevel@tonic-gate cylno = cbtocylno(&sblock, i); 18867c478bd9Sstevel@tonic-gate rpos = cbtorpos(&sblock, i); 18877c478bd9Sstevel@tonic-gate blk = fragstoblks(&sblock, i); 18887c478bd9Sstevel@tonic-gate if (fs_postbl(&sblock, cylno)[rpos] == -1) 18897c478bd9Sstevel@tonic-gate fs_rotbl(&sblock)[blk] = 0; 18907c478bd9Sstevel@tonic-gate else 18917c478bd9Sstevel@tonic-gate fs_rotbl(&sblock)[blk] = 18927c478bd9Sstevel@tonic-gate fs_postbl(&sblock, cylno)[rpos] - blk; 18937c478bd9Sstevel@tonic-gate fs_postbl(&sblock, cylno)[rpos] = blk; 18947c478bd9Sstevel@tonic-gate } 18957c478bd9Sstevel@tonic-gate next: 18967c478bd9Sstevel@tonic-gate grow30: 18977c478bd9Sstevel@tonic-gate /* 18987c478bd9Sstevel@tonic-gate * Compute/validate number of cylinder groups. 18997c478bd9Sstevel@tonic-gate * Note that if an excessively large filesystem is specified 19007c478bd9Sstevel@tonic-gate * (e.g., more than 16384 cylinders for an 8K filesystem block), it 19017c478bd9Sstevel@tonic-gate * does not get detected until checksummarysize() 19027c478bd9Sstevel@tonic-gate */ 19037c478bd9Sstevel@tonic-gate sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg; 19047c478bd9Sstevel@tonic-gate if (sblock.fs_ncyl % sblock.fs_cpg) 19057c478bd9Sstevel@tonic-gate sblock.fs_ncg++; 19067c478bd9Sstevel@tonic-gate sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock); 19077c478bd9Sstevel@tonic-gate i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1); 19087c478bd9Sstevel@tonic-gate ibpcl = cgdmin(&sblock, i) - cgbase(&sblock, i); 19097c478bd9Sstevel@tonic-gate if (ibpcl >= sblock.fs_fpg) { 19107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 19117c478bd9Sstevel@tonic-gate "inode blocks/cyl group (%d) >= data blocks (%d)\n"), 19127c478bd9Sstevel@tonic-gate cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag, 19137c478bd9Sstevel@tonic-gate sblock.fs_fpg / sblock.fs_frag); 19147c478bd9Sstevel@tonic-gate if ((ibpcl < 0) || (sblock.fs_fpg < 0)) { 19157c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 19167c478bd9Sstevel@tonic-gate "number of cylinders per cylinder group (%d) must be decreased.\n"), 19177c478bd9Sstevel@tonic-gate sblock.fs_cpg); 19187c478bd9Sstevel@tonic-gate } else { 19197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 19207c478bd9Sstevel@tonic-gate "number of cylinders per cylinder group (%d) must be increased.\n"), 19217c478bd9Sstevel@tonic-gate sblock.fs_cpg); 19227c478bd9Sstevel@tonic-gate } 19237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 19247c478bd9Sstevel@tonic-gate "Note that cgsize may have been adjusted to allow struct cg to fit.\n")); 19257c478bd9Sstevel@tonic-gate lockexit(32); 19267c478bd9Sstevel@tonic-gate } 19277c478bd9Sstevel@tonic-gate j = sblock.fs_ncg - 1; 19287c478bd9Sstevel@tonic-gate if ((i = fssize_frag - j * sblock.fs_fpg) < sblock.fs_fpg && 19297c478bd9Sstevel@tonic-gate cgdmin(&sblock, j) - cgbase(&sblock, j) > i) { 19307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 19317c478bd9Sstevel@tonic-gate "Warning: inode blocks/cyl group (%d) >= data " 19327c478bd9Sstevel@tonic-gate "blocks (%ld) in last\n cylinder group. This " 19337c478bd9Sstevel@tonic-gate "implies %ld sector(s) cannot be allocated.\n"), 19347c478bd9Sstevel@tonic-gate (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag, 19357c478bd9Sstevel@tonic-gate i / sblock.fs_frag, i * NSPF(&sblock)); 19367c478bd9Sstevel@tonic-gate sblock.fs_ncg--; 19377c478bd9Sstevel@tonic-gate sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg; 19387c478bd9Sstevel@tonic-gate sblock.fs_size = fssize_frag = 19397c478bd9Sstevel@tonic-gate (int64_t)sblock.fs_ncyl * (int64_t)sblock.fs_spc / 19407c478bd9Sstevel@tonic-gate (int64_t)NSPF(&sblock); 19417c478bd9Sstevel@tonic-gate warn = 0; 19427c478bd9Sstevel@tonic-gate } 19437c478bd9Sstevel@tonic-gate if (warn && !spc_flag) { 19447c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 19457c478bd9Sstevel@tonic-gate "Warning: %d sector(s) in last cylinder unallocated\n"), 19467c478bd9Sstevel@tonic-gate sblock.fs_spc - (uint32_t)(fssize_frag * NSPF(&sblock) - 19477c478bd9Sstevel@tonic-gate (uint64_t)(sblock.fs_ncyl - 1) * sblock.fs_spc)); 19487c478bd9Sstevel@tonic-gate } 19497c478bd9Sstevel@tonic-gate /* 19507c478bd9Sstevel@tonic-gate * fill in remaining fields of the super block 19517c478bd9Sstevel@tonic-gate */ 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate /* 19547c478bd9Sstevel@tonic-gate * The csum records are stored in cylinder group 0, starting at 19557c478bd9Sstevel@tonic-gate * cgdmin, the first data block. 19567c478bd9Sstevel@tonic-gate */ 19577c478bd9Sstevel@tonic-gate sblock.fs_csaddr = cgdmin(&sblock, 0); 19587c478bd9Sstevel@tonic-gate sblock.fs_cssize = 19597c478bd9Sstevel@tonic-gate fragroundup(&sblock, sblock.fs_ncg * sizeof (struct csum)); 19607c478bd9Sstevel@tonic-gate i = sblock.fs_bsize / sizeof (struct csum); 19617c478bd9Sstevel@tonic-gate sblock.fs_csmask = ~(i - 1); 19627c478bd9Sstevel@tonic-gate for (sblock.fs_csshift = 0; i > 1; i >>= 1) 19637c478bd9Sstevel@tonic-gate sblock.fs_csshift++; 19647c478bd9Sstevel@tonic-gate fscs = (struct csum *)calloc(1, sblock.fs_cssize); 19657c478bd9Sstevel@tonic-gate 19667c478bd9Sstevel@tonic-gate checksummarysize(); 19677c478bd9Sstevel@tonic-gate if (mtb == 'y') { 19687c478bd9Sstevel@tonic-gate sblock.fs_magic = MTB_UFS_MAGIC; 19697c478bd9Sstevel@tonic-gate sblock.fs_version = MTB_UFS_VERSION_1; 19707c478bd9Sstevel@tonic-gate } else { 19717c478bd9Sstevel@tonic-gate sblock.fs_magic = FS_MAGIC; 1972*6451fdbcSvsakar if (use_efi_dflts) 1973*6451fdbcSvsakar sblock.fs_version = UFS_EFISTYLE4NONEFI_VERSION_2; 1974*6451fdbcSvsakar else 1975*6451fdbcSvsakar sblock.fs_version = UFS_VERSION_MIN; 19767c478bd9Sstevel@tonic-gate } 19777c478bd9Sstevel@tonic-gate 19787c478bd9Sstevel@tonic-gate if (grow) { 19797c478bd9Sstevel@tonic-gate bcopy((caddr_t)grow_fscs, (caddr_t)fscs, (int)grow_fs_cssize); 19807c478bd9Sstevel@tonic-gate extendsummaryinfo(); 19817c478bd9Sstevel@tonic-gate goto grow40; 19827c478bd9Sstevel@tonic-gate } 19837c478bd9Sstevel@tonic-gate sblock.fs_rotdelay = rotdelay; 19847c478bd9Sstevel@tonic-gate sblock.fs_maxcontig = maxcontig; 19857c478bd9Sstevel@tonic-gate sblock.fs_maxbpg = MAXBLKPG(sblock.fs_bsize); 19867c478bd9Sstevel@tonic-gate 19877c478bd9Sstevel@tonic-gate sblock.fs_rps = rps; 19887c478bd9Sstevel@tonic-gate sblock.fs_cgrotor = 0; 19897c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_ndir = 0; 19907c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nbfree = 0; 19917c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nifree = 0; 19927c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nffree = 0; 19937c478bd9Sstevel@tonic-gate sblock.fs_fmod = 0; 19947c478bd9Sstevel@tonic-gate sblock.fs_ronly = 0; 19957c478bd9Sstevel@tonic-gate sblock.fs_time = mkfstime; 19967c478bd9Sstevel@tonic-gate sblock.fs_state = FSOKAY - sblock.fs_time; 19977c478bd9Sstevel@tonic-gate sblock.fs_clean = FSCLEAN; 19987c478bd9Sstevel@tonic-gate grow40: 19997c478bd9Sstevel@tonic-gate 2000355d6bb5Sswilcox /* 2001355d6bb5Sswilcox * If all that's needed is a dump of the superblock we 2002355d6bb5Sswilcox * would use by default, we've got it now. So, splat it 2003355d6bb5Sswilcox * out and leave. 2004355d6bb5Sswilcox */ 2005355d6bb5Sswilcox if (rflag) { 2006355d6bb5Sswilcox dump_sblock(); 2007355d6bb5Sswilcox lockexit(0); 2008355d6bb5Sswilcox } 20097c478bd9Sstevel@tonic-gate /* 20107c478bd9Sstevel@tonic-gate * Dump out summary information about file system. 20117c478bd9Sstevel@tonic-gate */ 20127c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 20137c478bd9Sstevel@tonic-gate "%s:\t%lld sectors in %d cylinders of %d tracks, %d sectors\n"), 20147c478bd9Sstevel@tonic-gate fsys, (uint64_t)sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl, 20157c478bd9Sstevel@tonic-gate sblock.fs_ntrak, sblock.fs_nsect); 20167c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 20177c478bd9Sstevel@tonic-gate "\t%.1fMB in %d cyl groups (%d c/g, %.2fMB/g, %d i/g)\n"), 20187c478bd9Sstevel@tonic-gate (float)sblock.fs_size * sblock.fs_fsize / MB, sblock.fs_ncg, 20197c478bd9Sstevel@tonic-gate sblock.fs_cpg, (float)sblock.fs_fpg * sblock.fs_fsize / MB, 20207c478bd9Sstevel@tonic-gate sblock.fs_ipg); 2021*6451fdbcSvsakar 2022*6451fdbcSvsakar tmpbuf = calloc(sblock.fs_ncg / 50 + 500, 1); 2023*6451fdbcSvsakar if (tmpbuf == NULL) { 2024*6451fdbcSvsakar perror("calloc"); 2025*6451fdbcSvsakar lockexit(32); 2026*6451fdbcSvsakar } 20277c478bd9Sstevel@tonic-gate /* 20287c478bd9Sstevel@tonic-gate * Now build the cylinders group blocks and 20297c478bd9Sstevel@tonic-gate * then print out indices of cylinder groups. 20307c478bd9Sstevel@tonic-gate */ 2031*6451fdbcSvsakar tprintf(gettext( 20327c478bd9Sstevel@tonic-gate "super-block backups (for fsck -F ufs -o b=#) at:\n")); 20337c478bd9Sstevel@tonic-gate for (width = cylno = 0; cylno < sblock.fs_ncg && cylno < 10; cylno++) { 20347c478bd9Sstevel@tonic-gate if ((grow == 0) || (cylno >= grow_fs_ncg)) 20357c478bd9Sstevel@tonic-gate initcg(cylno); 20367c478bd9Sstevel@tonic-gate num = fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)); 2037*6451fdbcSvsakar /* 2038*6451fdbcSvsakar * If Nflag and if the disk is larger than the CHSLIMIT, 2039*6451fdbcSvsakar * then sanity test the superblocks before reporting. If there 2040*6451fdbcSvsakar * are too many superblocks which look insane, we probably 2041*6451fdbcSvsakar * have to retry with alternate logic. If we are already 2042*6451fdbcSvsakar * retrying, then our efforts to arrive at alternate 2043*6451fdbcSvsakar * superblocks failed, so complain and exit. 2044*6451fdbcSvsakar */ 2045*6451fdbcSvsakar if (Nflag && retry) { 2046*6451fdbcSvsakar skip_this_sb = 0; 2047*6451fdbcSvsakar rdfs((diskaddr_t)num, sbsize, (char *)&altsblock); 2048*6451fdbcSvsakar ret = checksblock(altsblock, 1); 2049*6451fdbcSvsakar if (ret) { 2050*6451fdbcSvsakar skip_this_sb = 1; 2051*6451fdbcSvsakar invalid_sb_cnt++; 2052*6451fdbcSvsakar dprintf(("DeBuG checksblock() failed - error : %d" 2053*6451fdbcSvsakar " for sb : %llu invalid_sb_cnt : %d\n", 2054*6451fdbcSvsakar ret, num, invalid_sb_cnt)); 2055*6451fdbcSvsakar } else { 2056*6451fdbcSvsakar /* 2057*6451fdbcSvsakar * Though the superblock looks sane, verify if the 2058*6451fdbcSvsakar * fs_version in the superblock and the logic that 2059*6451fdbcSvsakar * we are using to arrive at the superblocks match. 2060*6451fdbcSvsakar */ 2061*6451fdbcSvsakar if (use_efi_dflts && altsblock.fs_version 2062*6451fdbcSvsakar != UFS_EFISTYLE4NONEFI_VERSION_2) { 2063*6451fdbcSvsakar skip_this_sb = 1; 2064*6451fdbcSvsakar invalid_sb_cnt++; 2065*6451fdbcSvsakar } 2066*6451fdbcSvsakar } 2067*6451fdbcSvsakar if (invalid_sb_cnt >= INVALIDSBLIMIT) { 2068*6451fdbcSvsakar if (retry > 1) { 2069*6451fdbcSvsakar (void) fprintf(stderr, gettext( 2070*6451fdbcSvsakar "Error determining alternate " 2071*6451fdbcSvsakar "superblock locations\n")); 2072*6451fdbcSvsakar free(tmpbuf); 2073*6451fdbcSvsakar lockexit(32); 2074*6451fdbcSvsakar } 2075*6451fdbcSvsakar retry++; 2076*6451fdbcSvsakar use_efi_dflts = !use_efi_dflts; 2077*6451fdbcSvsakar nsect = save_nsect; 2078*6451fdbcSvsakar ntrack = save_ntrack; 2079*6451fdbcSvsakar cpg = save_cpg; 2080*6451fdbcSvsakar free(tmpbuf); 2081*6451fdbcSvsakar goto retry_alternate_logic; 2082*6451fdbcSvsakar } 2083*6451fdbcSvsakar if (skip_this_sb) 2084*6451fdbcSvsakar continue; 2085*6451fdbcSvsakar } 20867c478bd9Sstevel@tonic-gate (void) sprintf(pbuf, " %llu,", num); 20877c478bd9Sstevel@tonic-gate plen = strlen(pbuf); 20887c478bd9Sstevel@tonic-gate if ((width + plen) > (WIDTH - 1)) { 20897c478bd9Sstevel@tonic-gate width = plen; 2090*6451fdbcSvsakar tprintf("\n"); 20917c478bd9Sstevel@tonic-gate } else { 20927c478bd9Sstevel@tonic-gate width += plen; 20937c478bd9Sstevel@tonic-gate } 2094*6451fdbcSvsakar if (Nflag && retry) 2095*6451fdbcSvsakar strncat(tmpbuf, pbuf, strlen(pbuf)); 2096*6451fdbcSvsakar else 2097*6451fdbcSvsakar (void) fprintf(stderr, "%s", pbuf); 20987c478bd9Sstevel@tonic-gate } 2099*6451fdbcSvsakar tprintf("\n"); 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate remaining_cg = sblock.fs_ncg - cylno; 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate /* 21047c478bd9Sstevel@tonic-gate * If there are more than 300 cylinder groups still to be 21057c478bd9Sstevel@tonic-gate * initialized, print a "." for every 50 cylinder groups. 21067c478bd9Sstevel@tonic-gate */ 21077c478bd9Sstevel@tonic-gate if (remaining_cg > 300) { 2108*6451fdbcSvsakar tprintf(gettext("Initializing cylinder groups:\n")); 21097c478bd9Sstevel@tonic-gate do_dot = 1; 21107c478bd9Sstevel@tonic-gate } 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate /* 21137c478bd9Sstevel@tonic-gate * Now initialize all cylinder groups between the first ten 21147c478bd9Sstevel@tonic-gate * and the last ten. 21157c478bd9Sstevel@tonic-gate * 21167c478bd9Sstevel@tonic-gate * If the number of cylinder groups was less than 10, all of the 21177c478bd9Sstevel@tonic-gate * cylinder group offsets would have printed in the last loop 21187c478bd9Sstevel@tonic-gate * and cylno will already be equal to sblock.fs_ncg and so this 21197c478bd9Sstevel@tonic-gate * loop will not be entered. If there are less than 20 cylinder 21207c478bd9Sstevel@tonic-gate * groups, cylno is already less than fs_ncg - 10, so this loop 21217c478bd9Sstevel@tonic-gate * won't be entered in that case either. 21227c478bd9Sstevel@tonic-gate */ 21237c478bd9Sstevel@tonic-gate 21247c478bd9Sstevel@tonic-gate i = 0; 21257c478bd9Sstevel@tonic-gate for (; cylno < sblock.fs_ncg - 10; cylno++) { 21267c478bd9Sstevel@tonic-gate if ((grow == 0) || (cylno >= grow_fs_ncg)) 21277c478bd9Sstevel@tonic-gate initcg(cylno); 21287c478bd9Sstevel@tonic-gate if (do_dot && cylno % 50 == 0) { 2129*6451fdbcSvsakar tprintf("."); 21307c478bd9Sstevel@tonic-gate i++; 21317c478bd9Sstevel@tonic-gate if (i == WIDTH - 1) { 2132*6451fdbcSvsakar tprintf("\n"); 21337c478bd9Sstevel@tonic-gate i = 0; 21347c478bd9Sstevel@tonic-gate } 21357c478bd9Sstevel@tonic-gate } 21367c478bd9Sstevel@tonic-gate } 21377c478bd9Sstevel@tonic-gate 21387c478bd9Sstevel@tonic-gate /* 21397c478bd9Sstevel@tonic-gate * Now print the cylinder group offsets for the last 10 21407c478bd9Sstevel@tonic-gate * cylinder groups, if any are left. 21417c478bd9Sstevel@tonic-gate */ 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate if (do_dot) { 2144*6451fdbcSvsakar tprintf(gettext( 21457c478bd9Sstevel@tonic-gate "\nsuper-block backups for last 10 cylinder groups at:\n")); 21467c478bd9Sstevel@tonic-gate } 21477c478bd9Sstevel@tonic-gate for (width = 0; cylno < sblock.fs_ncg; cylno++) { 21487c478bd9Sstevel@tonic-gate if ((grow == 0) || (cylno >= grow_fs_ncg)) 21497c478bd9Sstevel@tonic-gate initcg(cylno); 21507c478bd9Sstevel@tonic-gate num = fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)); 2151*6451fdbcSvsakar if (Nflag && retry) { 2152*6451fdbcSvsakar skip_this_sb = 0; 2153*6451fdbcSvsakar rdfs((diskaddr_t)num, sbsize, (char *)&altsblock); 2154*6451fdbcSvsakar ret = checksblock(altsblock, 1); 2155*6451fdbcSvsakar if (ret) { 2156*6451fdbcSvsakar skip_this_sb = 1; 2157*6451fdbcSvsakar invalid_sb_cnt++; 2158*6451fdbcSvsakar dprintf(("DeBuG checksblock() failed - error : %d" 2159*6451fdbcSvsakar " for sb : %llu invalid_sb_cnt : %d\n", 2160*6451fdbcSvsakar ret, num, invalid_sb_cnt)); 2161*6451fdbcSvsakar } else { 2162*6451fdbcSvsakar /* 2163*6451fdbcSvsakar * Though the superblock looks sane, verify if the 2164*6451fdbcSvsakar * fs_version in the superblock and the logic that 2165*6451fdbcSvsakar * we are using to arrive at the superblocks match. 2166*6451fdbcSvsakar */ 2167*6451fdbcSvsakar if (use_efi_dflts && altsblock.fs_version 2168*6451fdbcSvsakar != UFS_EFISTYLE4NONEFI_VERSION_2) { 2169*6451fdbcSvsakar skip_this_sb = 1; 2170*6451fdbcSvsakar invalid_sb_cnt++; 2171*6451fdbcSvsakar } 2172*6451fdbcSvsakar } 2173*6451fdbcSvsakar if (invalid_sb_cnt >= INVALIDSBLIMIT) { 2174*6451fdbcSvsakar if (retry > 1) { 2175*6451fdbcSvsakar (void) fprintf(stderr, gettext( 2176*6451fdbcSvsakar "Error determining alternate " 2177*6451fdbcSvsakar "superblock locations\n")); 2178*6451fdbcSvsakar free(tmpbuf); 2179*6451fdbcSvsakar lockexit(32); 2180*6451fdbcSvsakar } 2181*6451fdbcSvsakar retry++; 2182*6451fdbcSvsakar use_efi_dflts = !use_efi_dflts; 2183*6451fdbcSvsakar nsect = save_nsect; 2184*6451fdbcSvsakar ntrack = save_ntrack; 2185*6451fdbcSvsakar cpg = save_cpg; 2186*6451fdbcSvsakar free(tmpbuf); 2187*6451fdbcSvsakar goto retry_alternate_logic; 2188*6451fdbcSvsakar } 2189*6451fdbcSvsakar if (skip_this_sb) 2190*6451fdbcSvsakar continue; 2191*6451fdbcSvsakar } 2192*6451fdbcSvsakar /* Don't print ',' for the last superblock */ 2193*6451fdbcSvsakar if (cylno == sblock.fs_ncg-1) 2194*6451fdbcSvsakar (void) sprintf(pbuf, " %llu", num); 2195*6451fdbcSvsakar else 2196*6451fdbcSvsakar (void) sprintf(pbuf, " %llu,", num); 21977c478bd9Sstevel@tonic-gate plen = strlen(pbuf); 21987c478bd9Sstevel@tonic-gate if ((width + plen) > (WIDTH - 1)) { 21997c478bd9Sstevel@tonic-gate width = plen; 2200*6451fdbcSvsakar tprintf("\n"); 22017c478bd9Sstevel@tonic-gate } else { 22027c478bd9Sstevel@tonic-gate width += plen; 22037c478bd9Sstevel@tonic-gate } 2204*6451fdbcSvsakar if (Nflag && retry) 2205*6451fdbcSvsakar strncat(tmpbuf, pbuf, strlen(pbuf)); 2206*6451fdbcSvsakar else 2207*6451fdbcSvsakar (void) fprintf(stderr, "%s", pbuf); 22087c478bd9Sstevel@tonic-gate } 2209*6451fdbcSvsakar tprintf("\n"); 2210*6451fdbcSvsakar if (Nflag) { 2211*6451fdbcSvsakar if (retry) 2212*6451fdbcSvsakar fprintf(stderr, "%s", tmpbuf); 2213*6451fdbcSvsakar free(tmpbuf); 22147c478bd9Sstevel@tonic-gate lockexit(0); 2215*6451fdbcSvsakar } 2216*6451fdbcSvsakar 2217*6451fdbcSvsakar free(tmpbuf); 22187c478bd9Sstevel@tonic-gate if (grow) 22197c478bd9Sstevel@tonic-gate goto grow50; 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate /* 22227c478bd9Sstevel@tonic-gate * Now construct the initial file system, 22237c478bd9Sstevel@tonic-gate * then write out the super-block. 22247c478bd9Sstevel@tonic-gate */ 22257c478bd9Sstevel@tonic-gate fsinit(); 22267c478bd9Sstevel@tonic-gate grow50: 22277c478bd9Sstevel@tonic-gate /* 22287c478bd9Sstevel@tonic-gate * write the superblock and csum information 22297c478bd9Sstevel@tonic-gate */ 22307c478bd9Sstevel@tonic-gate wtsb(); 22317c478bd9Sstevel@tonic-gate 22327c478bd9Sstevel@tonic-gate /* 22337c478bd9Sstevel@tonic-gate * extend the last cylinder group in the original file system 22347c478bd9Sstevel@tonic-gate */ 22357c478bd9Sstevel@tonic-gate if (grow) { 22367c478bd9Sstevel@tonic-gate extendcg(grow_fs_ncg-1); 22377c478bd9Sstevel@tonic-gate wtsb(); 22387c478bd9Sstevel@tonic-gate } 22397c478bd9Sstevel@tonic-gate 22407c478bd9Sstevel@tonic-gate /* 22417c478bd9Sstevel@tonic-gate * Write out the duplicate super blocks to the first 10 22427c478bd9Sstevel@tonic-gate * cylinder groups (or fewer, if there are fewer than 10 22437c478bd9Sstevel@tonic-gate * cylinder groups). 22447c478bd9Sstevel@tonic-gate */ 22457c478bd9Sstevel@tonic-gate for (cylno = 0; cylno < sblock.fs_ncg && cylno < 10; cylno++) 22467c478bd9Sstevel@tonic-gate awtfs(fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)), 22477c478bd9Sstevel@tonic-gate (int)sbsize, (char *)&sblock, SAVE); 22487c478bd9Sstevel@tonic-gate 22497c478bd9Sstevel@tonic-gate /* 22507c478bd9Sstevel@tonic-gate * Now write out duplicate super blocks to the remaining 22517c478bd9Sstevel@tonic-gate * cylinder groups. In the case of multi-terabyte file 22527c478bd9Sstevel@tonic-gate * systems, just write out the super block to the last ten 22537c478bd9Sstevel@tonic-gate * cylinder groups (or however many are left). 22547c478bd9Sstevel@tonic-gate */ 22557c478bd9Sstevel@tonic-gate if (mtb == 'y') { 22567c478bd9Sstevel@tonic-gate if (sblock.fs_ncg <= 10) 22577c478bd9Sstevel@tonic-gate cylno = sblock.fs_ncg; 22587c478bd9Sstevel@tonic-gate else if (sblock.fs_ncg <= 20) 22597c478bd9Sstevel@tonic-gate cylno = 10; 22607c478bd9Sstevel@tonic-gate else 22617c478bd9Sstevel@tonic-gate cylno = sblock.fs_ncg - 10; 22627c478bd9Sstevel@tonic-gate } 22637c478bd9Sstevel@tonic-gate 22647c478bd9Sstevel@tonic-gate for (; cylno < sblock.fs_ncg; cylno++) 22657c478bd9Sstevel@tonic-gate awtfs(fsbtodb(&sblock, (uint64_t)cgsblock(&sblock, cylno)), 22667c478bd9Sstevel@tonic-gate (int)sbsize, (char *)&sblock, SAVE); 22677c478bd9Sstevel@tonic-gate 22687c478bd9Sstevel@tonic-gate /* 22697c478bd9Sstevel@tonic-gate * Flush out all the AIO writes we've done. It's not 22707c478bd9Sstevel@tonic-gate * necessary to do this explicitly, but it's the only 22717c478bd9Sstevel@tonic-gate * way to report any errors from those writes. 22727c478bd9Sstevel@tonic-gate */ 22737c478bd9Sstevel@tonic-gate flush_writes(); 22747c478bd9Sstevel@tonic-gate 22757c478bd9Sstevel@tonic-gate /* 22767c478bd9Sstevel@tonic-gate * set clean flag 22777c478bd9Sstevel@tonic-gate */ 22787c478bd9Sstevel@tonic-gate if (grow) 22797c478bd9Sstevel@tonic-gate sblock.fs_clean = grow_fs_clean; 22807c478bd9Sstevel@tonic-gate else 22817c478bd9Sstevel@tonic-gate sblock.fs_clean = FSCLEAN; 22827c478bd9Sstevel@tonic-gate sblock.fs_time = mkfstime; 22837c478bd9Sstevel@tonic-gate sblock.fs_state = FSOKAY - sblock.fs_time; 22847c478bd9Sstevel@tonic-gate wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock); 22857c478bd9Sstevel@tonic-gate isbad = 0; 22867c478bd9Sstevel@tonic-gate 22877c478bd9Sstevel@tonic-gate if (fsync(fso) == -1) { 22887c478bd9Sstevel@tonic-gate saverr = errno; 22897c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 22907c478bd9Sstevel@tonic-gate gettext("mkfs: fsync failed on write disk: %s\n"), 22917c478bd9Sstevel@tonic-gate strerror(saverr)); 22927c478bd9Sstevel@tonic-gate /* we're just cleaning up, so keep going */ 22937c478bd9Sstevel@tonic-gate } 22947c478bd9Sstevel@tonic-gate if (close(fsi) == -1) { 22957c478bd9Sstevel@tonic-gate saverr = errno; 22967c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 22977c478bd9Sstevel@tonic-gate gettext("mkfs: close failed on read disk: %s\n"), 22987c478bd9Sstevel@tonic-gate strerror(saverr)); 22997c478bd9Sstevel@tonic-gate /* we're just cleaning up, so keep going */ 23007c478bd9Sstevel@tonic-gate } 23017c478bd9Sstevel@tonic-gate if (close(fso) == -1) { 23027c478bd9Sstevel@tonic-gate saverr = errno; 23037c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 23047c478bd9Sstevel@tonic-gate gettext("mkfs: close failed on write disk: %s\n"), 23057c478bd9Sstevel@tonic-gate strerror(saverr)); 23067c478bd9Sstevel@tonic-gate /* we're just cleaning up, so keep going */ 23077c478bd9Sstevel@tonic-gate } 23087c478bd9Sstevel@tonic-gate fsi = fso = -1; 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate #ifndef STANDALONE 23117c478bd9Sstevel@tonic-gate lockexit(0); 23127c478bd9Sstevel@tonic-gate #endif 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate 23157c478bd9Sstevel@tonic-gate /* 23167c478bd9Sstevel@tonic-gate * Figure out how big the partition we're dealing with is. 23177c478bd9Sstevel@tonic-gate * The value returned is in disk blocks (sectors); 23187c478bd9Sstevel@tonic-gate */ 23197c478bd9Sstevel@tonic-gate static diskaddr_t 23207c478bd9Sstevel@tonic-gate get_max_size(int fd) 23217c478bd9Sstevel@tonic-gate { 23227c478bd9Sstevel@tonic-gate struct vtoc vtoc; 23237c478bd9Sstevel@tonic-gate dk_gpt_t *efi_vtoc; 23247c478bd9Sstevel@tonic-gate diskaddr_t slicesize; 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate int index = read_vtoc(fd, &vtoc); 23277c478bd9Sstevel@tonic-gate 2328*6451fdbcSvsakar if (index >= 0) { 2329*6451fdbcSvsakar label_type = LABEL_TYPE_VTOC; 2330*6451fdbcSvsakar } else { 23317c478bd9Sstevel@tonic-gate if (index == VT_ENOTSUP || index == VT_ERROR) { 23327c478bd9Sstevel@tonic-gate /* it might be an EFI label */ 23337c478bd9Sstevel@tonic-gate index = efi_alloc_and_read(fd, &efi_vtoc); 2334*6451fdbcSvsakar label_type = LABEL_TYPE_EFI; 23357c478bd9Sstevel@tonic-gate } 23367c478bd9Sstevel@tonic-gate } 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate if (index < 0) { 23397c478bd9Sstevel@tonic-gate switch (index) { 23407c478bd9Sstevel@tonic-gate case VT_ERROR: 23417c478bd9Sstevel@tonic-gate break; 23427c478bd9Sstevel@tonic-gate case VT_EIO: 23437c478bd9Sstevel@tonic-gate errno = EIO; 23447c478bd9Sstevel@tonic-gate break; 23457c478bd9Sstevel@tonic-gate case VT_EINVAL: 23467c478bd9Sstevel@tonic-gate errno = EINVAL; 23477c478bd9Sstevel@tonic-gate } 23487c478bd9Sstevel@tonic-gate perror(gettext("Can not determine partition size")); 23497c478bd9Sstevel@tonic-gate lockexit(32); 23507c478bd9Sstevel@tonic-gate } 23517c478bd9Sstevel@tonic-gate 2352*6451fdbcSvsakar if (label_type == LABEL_TYPE_EFI) { 23537c478bd9Sstevel@tonic-gate slicesize = efi_vtoc->efi_parts[index].p_size; 23547c478bd9Sstevel@tonic-gate efi_free(efi_vtoc); 23557c478bd9Sstevel@tonic-gate } else { 23567c478bd9Sstevel@tonic-gate /* 23577c478bd9Sstevel@tonic-gate * In the vtoc struct, p_size is a 32-bit signed quantity. 23587c478bd9Sstevel@tonic-gate * In the dk_gpt struct (efi's version of the vtoc), p_size 23597c478bd9Sstevel@tonic-gate * is an unsigned 64-bit quantity. By casting the vtoc's 23607c478bd9Sstevel@tonic-gate * psize to an unsigned 32-bit quantity, it will be copied 23617c478bd9Sstevel@tonic-gate * to 'slicesize' (an unsigned 64-bit diskaddr_t) without 23627c478bd9Sstevel@tonic-gate * sign extension. 23637c478bd9Sstevel@tonic-gate */ 23647c478bd9Sstevel@tonic-gate 23657c478bd9Sstevel@tonic-gate slicesize = (uint32_t)vtoc.v_part[index].p_size; 23667c478bd9Sstevel@tonic-gate } 23677c478bd9Sstevel@tonic-gate 2368*6451fdbcSvsakar dprintf(("DeBuG get_max_size index = %d, p_size = %lld, dolimit = %d\n", 2369*6451fdbcSvsakar index, slicesize, (slicesize > FS_MAX))); 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate /* 23727c478bd9Sstevel@tonic-gate * The next line limits a UFS file system to the maximum 23737c478bd9Sstevel@tonic-gate * supported size. 23747c478bd9Sstevel@tonic-gate */ 23757c478bd9Sstevel@tonic-gate 23767c478bd9Sstevel@tonic-gate if (slicesize > FS_MAX) 23777c478bd9Sstevel@tonic-gate return (FS_MAX); 23787c478bd9Sstevel@tonic-gate return (slicesize); 23797c478bd9Sstevel@tonic-gate } 23807c478bd9Sstevel@tonic-gate 23817c478bd9Sstevel@tonic-gate static long 23827c478bd9Sstevel@tonic-gate get_max_track_size(int fd) 23837c478bd9Sstevel@tonic-gate { 23847c478bd9Sstevel@tonic-gate struct dk_cinfo ci; 23857c478bd9Sstevel@tonic-gate long track_size = -1; 23867c478bd9Sstevel@tonic-gate 23877c478bd9Sstevel@tonic-gate if (ioctl(fd, DKIOCINFO, &ci) == 0) { 23887c478bd9Sstevel@tonic-gate track_size = ci.dki_maxtransfer * DEV_BSIZE; 23897c478bd9Sstevel@tonic-gate } 23907c478bd9Sstevel@tonic-gate 23917c478bd9Sstevel@tonic-gate if ((track_size < 0)) { 23927c478bd9Sstevel@tonic-gate int error = 0; 23937c478bd9Sstevel@tonic-gate int maxphys; 23947c478bd9Sstevel@tonic-gate int gotit = 0; 23957c478bd9Sstevel@tonic-gate 23967c478bd9Sstevel@tonic-gate gotit = fsgetmaxphys(&maxphys, &error); 23977c478bd9Sstevel@tonic-gate if (gotit) { 23987c478bd9Sstevel@tonic-gate track_size = MIN(MB, maxphys); 23997c478bd9Sstevel@tonic-gate } else { 24007c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 24017c478bd9Sstevel@tonic-gate "Warning: Could not get system value for maxphys. The value for\n" 24027c478bd9Sstevel@tonic-gate "maxcontig will default to 1MB.\n")); 24037c478bd9Sstevel@tonic-gate track_size = MB; 24047c478bd9Sstevel@tonic-gate } 24057c478bd9Sstevel@tonic-gate } 24067c478bd9Sstevel@tonic-gate return (track_size); 24077c478bd9Sstevel@tonic-gate } 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate /* 24107c478bd9Sstevel@tonic-gate * Initialize a cylinder group. 24117c478bd9Sstevel@tonic-gate */ 24127c478bd9Sstevel@tonic-gate static void 24137c478bd9Sstevel@tonic-gate initcg(int cylno) 24147c478bd9Sstevel@tonic-gate { 24157c478bd9Sstevel@tonic-gate diskaddr_t cbase, d; 24167c478bd9Sstevel@tonic-gate diskaddr_t dlower; /* last data block before cg metadata */ 24177c478bd9Sstevel@tonic-gate diskaddr_t dupper; /* first data block after cg metadata */ 24187c478bd9Sstevel@tonic-gate diskaddr_t dmax; 24197c478bd9Sstevel@tonic-gate int64_t i; 24207c478bd9Sstevel@tonic-gate struct csum *cs; 24217c478bd9Sstevel@tonic-gate struct dinode *inode_buffer; 24227c478bd9Sstevel@tonic-gate int size; 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate /* 24257c478bd9Sstevel@tonic-gate * Variables used to store intermediate results as a part of 24267c478bd9Sstevel@tonic-gate * the internal implementation of the cbtocylno() macros. 24277c478bd9Sstevel@tonic-gate */ 24287c478bd9Sstevel@tonic-gate diskaddr_t bno; /* UFS block number (not sector number) */ 24297c478bd9Sstevel@tonic-gate int cbcylno; /* current cylinder number */ 24307c478bd9Sstevel@tonic-gate int cbcylno_sect; /* sector offset within cylinder */ 24317c478bd9Sstevel@tonic-gate int cbsect_incr; /* amount to increment sector offset */ 24327c478bd9Sstevel@tonic-gate 24337c478bd9Sstevel@tonic-gate /* 24347c478bd9Sstevel@tonic-gate * Variables used to store intermediate results as a part of 24357c478bd9Sstevel@tonic-gate * the internal implementation of the cbtorpos() macros. 24367c478bd9Sstevel@tonic-gate */ 24377c478bd9Sstevel@tonic-gate short *cgblks; /* pointer to array of free blocks in cg */ 24387c478bd9Sstevel@tonic-gate int trackrpos; /* tmp variable for rotation position */ 24397c478bd9Sstevel@tonic-gate int trackoff; /* offset within a track */ 24407c478bd9Sstevel@tonic-gate int trackoff_incr; /* amount to increment trackoff */ 24417c478bd9Sstevel@tonic-gate int rpos; /* rotation position of current block */ 24427c478bd9Sstevel@tonic-gate int rpos_incr; /* amount to increment rpos per block */ 24437c478bd9Sstevel@tonic-gate 24447c478bd9Sstevel@tonic-gate union cgun *icgun; /* local pointer to a cg summary block */ 24457c478bd9Sstevel@tonic-gate #define icg (icgun->cg) 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate icgun = (union cgun *)getbuf(&cgsumbuf, sizeof (union cgun)); 24487c478bd9Sstevel@tonic-gate 24497c478bd9Sstevel@tonic-gate /* 24507c478bd9Sstevel@tonic-gate * Determine block bounds for cylinder group. 24517c478bd9Sstevel@tonic-gate * Allow space for super block summary information in first 24527c478bd9Sstevel@tonic-gate * cylinder group. 24537c478bd9Sstevel@tonic-gate */ 24547c478bd9Sstevel@tonic-gate cbase = cgbase(&sblock, cylno); 24557c478bd9Sstevel@tonic-gate dmax = cbase + sblock.fs_fpg; 24567c478bd9Sstevel@tonic-gate if (dmax > sblock.fs_size) /* last cg may be smaller than normal */ 24577c478bd9Sstevel@tonic-gate dmax = sblock.fs_size; 24587c478bd9Sstevel@tonic-gate dlower = cgsblock(&sblock, cylno) - cbase; 24597c478bd9Sstevel@tonic-gate dupper = cgdmin(&sblock, cylno) - cbase; 24607c478bd9Sstevel@tonic-gate if (cylno == 0) 24617c478bd9Sstevel@tonic-gate dupper += howmany(sblock.fs_cssize, sblock.fs_fsize); 24627c478bd9Sstevel@tonic-gate cs = fscs + cylno; 24637c478bd9Sstevel@tonic-gate icg.cg_time = mkfstime; 24647c478bd9Sstevel@tonic-gate icg.cg_magic = CG_MAGIC; 24657c478bd9Sstevel@tonic-gate icg.cg_cgx = cylno; 2466355d6bb5Sswilcox /* last one gets whatever's left */ 24677c478bd9Sstevel@tonic-gate if (cylno == sblock.fs_ncg - 1) 2468355d6bb5Sswilcox icg.cg_ncyl = sblock.fs_ncyl - (sblock.fs_cpg * cylno); 24697c478bd9Sstevel@tonic-gate else 24707c478bd9Sstevel@tonic-gate icg.cg_ncyl = sblock.fs_cpg; 24717c478bd9Sstevel@tonic-gate icg.cg_niblk = sblock.fs_ipg; 24727c478bd9Sstevel@tonic-gate icg.cg_ndblk = dmax - cbase; 24737c478bd9Sstevel@tonic-gate icg.cg_cs.cs_ndir = 0; 24747c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nffree = 0; 24757c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nbfree = 0; 24767c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nifree = 0; 24777c478bd9Sstevel@tonic-gate icg.cg_rotor = 0; 24787c478bd9Sstevel@tonic-gate icg.cg_frotor = 0; 24797c478bd9Sstevel@tonic-gate icg.cg_irotor = 0; 24807c478bd9Sstevel@tonic-gate icg.cg_btotoff = &icg.cg_space[0] - (uchar_t *)(&icg.cg_link); 24817c478bd9Sstevel@tonic-gate icg.cg_boff = icg.cg_btotoff + sblock.fs_cpg * sizeof (long); 24827c478bd9Sstevel@tonic-gate icg.cg_iusedoff = icg.cg_boff + 24837c478bd9Sstevel@tonic-gate sblock.fs_cpg * sblock.fs_nrpos * sizeof (short); 24847c478bd9Sstevel@tonic-gate icg.cg_freeoff = icg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY); 24857c478bd9Sstevel@tonic-gate icg.cg_nextfreeoff = icg.cg_freeoff + 24867c478bd9Sstevel@tonic-gate howmany(sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY); 24877c478bd9Sstevel@tonic-gate for (i = 0; i < sblock.fs_frag; i++) { 24887c478bd9Sstevel@tonic-gate icg.cg_frsum[i] = 0; 24897c478bd9Sstevel@tonic-gate } 24907c478bd9Sstevel@tonic-gate bzero((caddr_t)cg_inosused(&icg), icg.cg_freeoff - icg.cg_iusedoff); 24917c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nifree += sblock.fs_ipg; 24927c478bd9Sstevel@tonic-gate if (cylno == 0) 24937c478bd9Sstevel@tonic-gate for (i = 0; i < UFSROOTINO; i++) { 24947c478bd9Sstevel@tonic-gate setbit(cg_inosused(&icg), i); 24957c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nifree--; 24967c478bd9Sstevel@tonic-gate } 24977c478bd9Sstevel@tonic-gate 24987c478bd9Sstevel@tonic-gate /* 24997c478bd9Sstevel@tonic-gate * Initialize all the inodes in the cylinder group using 25007c478bd9Sstevel@tonic-gate * random numbers. 25017c478bd9Sstevel@tonic-gate */ 25027c478bd9Sstevel@tonic-gate size = sblock.fs_ipg * sizeof (struct dinode); 25037c478bd9Sstevel@tonic-gate inode_buffer = (struct dinode *)getbuf(&inodebuf, size); 25047c478bd9Sstevel@tonic-gate 25057c478bd9Sstevel@tonic-gate for (i = 0; i < sblock.fs_ipg; i++) { 25067c478bd9Sstevel@tonic-gate IRANDOMIZE(&(inode_buffer[i].di_ic)); 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate 25097c478bd9Sstevel@tonic-gate /* 25107c478bd9Sstevel@tonic-gate * Write all inodes in a single write for performance. 25117c478bd9Sstevel@tonic-gate */ 25127c478bd9Sstevel@tonic-gate awtfs(fsbtodb(&sblock, (uint64_t)cgimin(&sblock, cylno)), (int)size, 25137c478bd9Sstevel@tonic-gate (char *)inode_buffer, RELEASE); 25147c478bd9Sstevel@tonic-gate 25157c478bd9Sstevel@tonic-gate bzero((caddr_t)cg_blktot(&icg), icg.cg_boff - icg.cg_btotoff); 25167c478bd9Sstevel@tonic-gate bzero((caddr_t)cg_blks(&sblock, &icg, 0), 25177c478bd9Sstevel@tonic-gate icg.cg_iusedoff - icg.cg_boff); 25187c478bd9Sstevel@tonic-gate bzero((caddr_t)cg_blksfree(&icg), icg.cg_nextfreeoff - icg.cg_freeoff); 25197c478bd9Sstevel@tonic-gate 25207c478bd9Sstevel@tonic-gate if (cylno > 0) { 25217c478bd9Sstevel@tonic-gate for (d = 0; d < dlower; d += sblock.fs_frag) { 25227c478bd9Sstevel@tonic-gate setblock(&sblock, cg_blksfree(&icg), d/sblock.fs_frag); 25237c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nbfree++; 25247c478bd9Sstevel@tonic-gate cg_blktot(&icg)[cbtocylno(&sblock, d)]++; 25257c478bd9Sstevel@tonic-gate cg_blks(&sblock, &icg, cbtocylno(&sblock, d)) 25267c478bd9Sstevel@tonic-gate [cbtorpos(&sblock, d)]++; 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate sblock.fs_dsize += dlower; 25297c478bd9Sstevel@tonic-gate } 25307c478bd9Sstevel@tonic-gate sblock.fs_dsize += icg.cg_ndblk - dupper; 25317c478bd9Sstevel@tonic-gate if ((i = dupper % sblock.fs_frag) != 0) { 25327c478bd9Sstevel@tonic-gate icg.cg_frsum[sblock.fs_frag - i]++; 25337c478bd9Sstevel@tonic-gate for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) { 25347c478bd9Sstevel@tonic-gate setbit(cg_blksfree(&icg), dupper); 25357c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nffree++; 25367c478bd9Sstevel@tonic-gate } 25377c478bd9Sstevel@tonic-gate } 25387c478bd9Sstevel@tonic-gate 25397c478bd9Sstevel@tonic-gate /* 25407c478bd9Sstevel@tonic-gate * WARNING: The following code is somewhat confusing, but 25417c478bd9Sstevel@tonic-gate * results in a substantial performance improvement in mkfs. 25427c478bd9Sstevel@tonic-gate * 25437c478bd9Sstevel@tonic-gate * Instead of using cbtocylno() and cbtorpos() macros, we 25447c478bd9Sstevel@tonic-gate * keep track of all the intermediate state of those macros 25457c478bd9Sstevel@tonic-gate * in some variables. This allows simple addition to be 25467c478bd9Sstevel@tonic-gate * done to calculate the results as we step through the 25477c478bd9Sstevel@tonic-gate * blocks in an orderly fashion instead of the slower 25487c478bd9Sstevel@tonic-gate * multiplication and division the macros are forced to 25497c478bd9Sstevel@tonic-gate * used so they can support random input. (Multiplication, 25507c478bd9Sstevel@tonic-gate * division, and remainder operations typically take about 25517c478bd9Sstevel@tonic-gate * 10x as many processor cycles as other operations.) 25527c478bd9Sstevel@tonic-gate * 25537c478bd9Sstevel@tonic-gate * The basic idea is to take code: 25547c478bd9Sstevel@tonic-gate * 25557c478bd9Sstevel@tonic-gate * for (x = starting_x; x < max; x++) 25567c478bd9Sstevel@tonic-gate * y = (x * c) / z 25577c478bd9Sstevel@tonic-gate * 25587c478bd9Sstevel@tonic-gate * and rewrite it to take advantage of the fact that 25597c478bd9Sstevel@tonic-gate * the variable x is incrementing in an orderly way: 25607c478bd9Sstevel@tonic-gate * 25617c478bd9Sstevel@tonic-gate * intermediate = starting_x * c 25627c478bd9Sstevel@tonic-gate * yval = intermediate / z 25637c478bd9Sstevel@tonic-gate * for (x = starting_x; x < max; x++) { 25647c478bd9Sstevel@tonic-gate * y = yval; 25657c478bd9Sstevel@tonic-gate * intermediate += c 25667c478bd9Sstevel@tonic-gate * if (intermediate > z) { 25677c478bd9Sstevel@tonic-gate * yval++; 25687c478bd9Sstevel@tonic-gate * intermediate -= z 25697c478bd9Sstevel@tonic-gate * } 25707c478bd9Sstevel@tonic-gate * } 25717c478bd9Sstevel@tonic-gate * 25727c478bd9Sstevel@tonic-gate * Performance has improved as much as 4X using this code. 25737c478bd9Sstevel@tonic-gate */ 25747c478bd9Sstevel@tonic-gate 25757c478bd9Sstevel@tonic-gate /* 25767c478bd9Sstevel@tonic-gate * Initialize the starting points for all the cbtocylno() 25777c478bd9Sstevel@tonic-gate * macro variables and figure out the increments needed each 25787c478bd9Sstevel@tonic-gate * time through the loop. 25797c478bd9Sstevel@tonic-gate */ 25807c478bd9Sstevel@tonic-gate cbcylno_sect = dupper * NSPF(&sblock); 25817c478bd9Sstevel@tonic-gate cbsect_incr = sblock.fs_frag * NSPF(&sblock); 25827c478bd9Sstevel@tonic-gate cbcylno = cbcylno_sect / sblock.fs_spc; 25837c478bd9Sstevel@tonic-gate cbcylno_sect %= sblock.fs_spc; 25847c478bd9Sstevel@tonic-gate cgblks = cg_blks(&sblock, &icg, cbcylno); 25857c478bd9Sstevel@tonic-gate bno = dupper / sblock.fs_frag; 25867c478bd9Sstevel@tonic-gate 25877c478bd9Sstevel@tonic-gate /* 25887c478bd9Sstevel@tonic-gate * Initialize the starting points for all the cbtorpos() 25897c478bd9Sstevel@tonic-gate * macro variables and figure out the increments needed each 25907c478bd9Sstevel@tonic-gate * time through the loop. 25917c478bd9Sstevel@tonic-gate * 25927c478bd9Sstevel@tonic-gate * It's harder to simplify the cbtorpos() macro if there were 25937c478bd9Sstevel@tonic-gate * alternate sectors specified (or if they previously existed 25947c478bd9Sstevel@tonic-gate * in the growfs case). Since this is rare, we just revert to 25957c478bd9Sstevel@tonic-gate * using the macros in this case and skip the variable setup. 25967c478bd9Sstevel@tonic-gate */ 25977c478bd9Sstevel@tonic-gate if (!spc_flag) { 25987c478bd9Sstevel@tonic-gate trackrpos = (cbcylno_sect % sblock.fs_nsect) * sblock.fs_nrpos; 25997c478bd9Sstevel@tonic-gate rpos = trackrpos / sblock.fs_nsect; 26007c478bd9Sstevel@tonic-gate trackoff = trackrpos % sblock.fs_nsect; 26017c478bd9Sstevel@tonic-gate trackoff_incr = cbsect_incr * sblock.fs_nrpos; 26027c478bd9Sstevel@tonic-gate rpos_incr = (trackoff_incr / sblock.fs_nsect) % sblock.fs_nrpos; 26037c478bd9Sstevel@tonic-gate trackoff_incr = trackoff_incr % sblock.fs_nsect; 26047c478bd9Sstevel@tonic-gate } 26057c478bd9Sstevel@tonic-gate 26067c478bd9Sstevel@tonic-gate /* 26077c478bd9Sstevel@tonic-gate * Loop through all the blocks, marking them free and 26087c478bd9Sstevel@tonic-gate * updating totals kept in the superblock and cg summary. 26097c478bd9Sstevel@tonic-gate */ 26107c478bd9Sstevel@tonic-gate for (d = dupper; d + sblock.fs_frag <= dmax - cbase; ) { 26117c478bd9Sstevel@tonic-gate setblock(&sblock, cg_blksfree(&icg), bno); 26127c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nbfree++; 26137c478bd9Sstevel@tonic-gate 26147c478bd9Sstevel@tonic-gate cg_blktot(&icg)[cbcylno]++; 26157c478bd9Sstevel@tonic-gate 26167c478bd9Sstevel@tonic-gate if (!spc_flag) 26177c478bd9Sstevel@tonic-gate cgblks[rpos]++; 26187c478bd9Sstevel@tonic-gate else 26197c478bd9Sstevel@tonic-gate cg_blks(&sblock, &icg, cbtocylno(&sblock, d)) 26207c478bd9Sstevel@tonic-gate [cbtorpos(&sblock, d)]++; 26217c478bd9Sstevel@tonic-gate 26227c478bd9Sstevel@tonic-gate d += sblock.fs_frag; 26237c478bd9Sstevel@tonic-gate bno++; 26247c478bd9Sstevel@tonic-gate 26257c478bd9Sstevel@tonic-gate /* 26267c478bd9Sstevel@tonic-gate * Increment the sector offset within the cylinder 26277c478bd9Sstevel@tonic-gate * for the cbtocylno() macro reimplementation. If 26287c478bd9Sstevel@tonic-gate * we're beyond the end of the cylinder, update the 26297c478bd9Sstevel@tonic-gate * cylinder number, calculate the offset in the 26307c478bd9Sstevel@tonic-gate * new cylinder, and update the cgblks pointer 26317c478bd9Sstevel@tonic-gate * to the next rotational position. 26327c478bd9Sstevel@tonic-gate */ 26337c478bd9Sstevel@tonic-gate cbcylno_sect += cbsect_incr; 26347c478bd9Sstevel@tonic-gate if (cbcylno_sect >= sblock.fs_spc) { 26357c478bd9Sstevel@tonic-gate cbcylno++; 26367c478bd9Sstevel@tonic-gate cbcylno_sect -= sblock.fs_spc; 26377c478bd9Sstevel@tonic-gate cgblks += sblock.fs_nrpos; 26387c478bd9Sstevel@tonic-gate } 26397c478bd9Sstevel@tonic-gate 26407c478bd9Sstevel@tonic-gate /* 26417c478bd9Sstevel@tonic-gate * If there aren't alternate sectors, increment the 26427c478bd9Sstevel@tonic-gate * rotational position variables for the cbtorpos() 26437c478bd9Sstevel@tonic-gate * reimplementation. Note that we potentially 26447c478bd9Sstevel@tonic-gate * increment rpos twice. Once by rpos_incr, and one 26457c478bd9Sstevel@tonic-gate * more time when we wrap to a new track because 26467c478bd9Sstevel@tonic-gate * trackoff >= fs_nsect. 26477c478bd9Sstevel@tonic-gate */ 26487c478bd9Sstevel@tonic-gate if (!spc_flag) { 26497c478bd9Sstevel@tonic-gate trackoff += trackoff_incr; 26507c478bd9Sstevel@tonic-gate rpos += rpos_incr; 26517c478bd9Sstevel@tonic-gate if (trackoff >= sblock.fs_nsect) { 26527c478bd9Sstevel@tonic-gate trackoff -= sblock.fs_nsect; 26537c478bd9Sstevel@tonic-gate rpos++; 26547c478bd9Sstevel@tonic-gate } 26557c478bd9Sstevel@tonic-gate if (rpos >= sblock.fs_nrpos) 26567c478bd9Sstevel@tonic-gate rpos -= sblock.fs_nrpos; 26577c478bd9Sstevel@tonic-gate } 26587c478bd9Sstevel@tonic-gate } 26597c478bd9Sstevel@tonic-gate 26607c478bd9Sstevel@tonic-gate if (d < dmax - cbase) { 26617c478bd9Sstevel@tonic-gate icg.cg_frsum[dmax - cbase - d]++; 26627c478bd9Sstevel@tonic-gate for (; d < dmax - cbase; d++) { 26637c478bd9Sstevel@tonic-gate setbit(cg_blksfree(&icg), d); 26647c478bd9Sstevel@tonic-gate icg.cg_cs.cs_nffree++; 26657c478bd9Sstevel@tonic-gate } 26667c478bd9Sstevel@tonic-gate } 26677c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_ndir += icg.cg_cs.cs_ndir; 26687c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nffree += icg.cg_cs.cs_nffree; 26697c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nbfree += icg.cg_cs.cs_nbfree; 26707c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nifree += icg.cg_cs.cs_nifree; 26717c478bd9Sstevel@tonic-gate *cs = icg.cg_cs; 26727c478bd9Sstevel@tonic-gate awtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, cylno)), 26737c478bd9Sstevel@tonic-gate sblock.fs_bsize, (char *)&icg, RELEASE); 26747c478bd9Sstevel@tonic-gate } 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate /* 26777c478bd9Sstevel@tonic-gate * initialize the file system 26787c478bd9Sstevel@tonic-gate */ 26797c478bd9Sstevel@tonic-gate struct inode node; 26807c478bd9Sstevel@tonic-gate 26817c478bd9Sstevel@tonic-gate #define LOSTDIR 26827c478bd9Sstevel@tonic-gate #ifdef LOSTDIR 26837c478bd9Sstevel@tonic-gate #define PREDEFDIR 3 26847c478bd9Sstevel@tonic-gate #else 26857c478bd9Sstevel@tonic-gate #define PREDEFDIR 2 26867c478bd9Sstevel@tonic-gate #endif 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate struct direct root_dir[] = { 26897c478bd9Sstevel@tonic-gate { UFSROOTINO, sizeof (struct direct), 1, "." }, 26907c478bd9Sstevel@tonic-gate { UFSROOTINO, sizeof (struct direct), 2, ".." }, 26917c478bd9Sstevel@tonic-gate #ifdef LOSTDIR 26927c478bd9Sstevel@tonic-gate { LOSTFOUNDINO, sizeof (struct direct), 10, "lost+found" }, 26937c478bd9Sstevel@tonic-gate #endif 26947c478bd9Sstevel@tonic-gate }; 26957c478bd9Sstevel@tonic-gate #ifdef LOSTDIR 26967c478bd9Sstevel@tonic-gate struct direct lost_found_dir[] = { 26977c478bd9Sstevel@tonic-gate { LOSTFOUNDINO, sizeof (struct direct), 1, "." }, 26987c478bd9Sstevel@tonic-gate { UFSROOTINO, sizeof (struct direct), 2, ".." }, 26997c478bd9Sstevel@tonic-gate { 0, DIRBLKSIZ, 0, 0 }, 27007c478bd9Sstevel@tonic-gate }; 27017c478bd9Sstevel@tonic-gate #endif 27027c478bd9Sstevel@tonic-gate char buf[MAXBSIZE]; 27037c478bd9Sstevel@tonic-gate 27047c478bd9Sstevel@tonic-gate static void 27057c478bd9Sstevel@tonic-gate fsinit() 27067c478bd9Sstevel@tonic-gate { 27077c478bd9Sstevel@tonic-gate int i; 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate /* 27117c478bd9Sstevel@tonic-gate * initialize the node 27127c478bd9Sstevel@tonic-gate */ 27137c478bd9Sstevel@tonic-gate node.i_atime = mkfstime; 27147c478bd9Sstevel@tonic-gate node.i_mtime = mkfstime; 27157c478bd9Sstevel@tonic-gate node.i_ctime = mkfstime; 27167c478bd9Sstevel@tonic-gate #ifdef LOSTDIR 27177c478bd9Sstevel@tonic-gate /* 27187c478bd9Sstevel@tonic-gate * create the lost+found directory 27197c478bd9Sstevel@tonic-gate */ 27207c478bd9Sstevel@tonic-gate (void) makedir(lost_found_dir, 2); 27217c478bd9Sstevel@tonic-gate for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ) { 27227c478bd9Sstevel@tonic-gate bcopy(&lost_found_dir[2], &buf[i], DIRSIZ(&lost_found_dir[2])); 27237c478bd9Sstevel@tonic-gate } 27247c478bd9Sstevel@tonic-gate node.i_number = LOSTFOUNDINO; 27257c478bd9Sstevel@tonic-gate node.i_smode = node.i_mode = IFDIR | 0700; 27267c478bd9Sstevel@tonic-gate node.i_nlink = 2; 27277c478bd9Sstevel@tonic-gate node.i_size = sblock.fs_bsize; 27287c478bd9Sstevel@tonic-gate node.i_db[0] = alloc((int)node.i_size, node.i_mode); 27297c478bd9Sstevel@tonic-gate node.i_blocks = btodb(fragroundup(&sblock, (int)node.i_size)); 27307c478bd9Sstevel@tonic-gate IRANDOMIZE(&node.i_ic); 27317c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)node.i_db[0]), (int)node.i_size, buf); 27327c478bd9Sstevel@tonic-gate iput(&node); 27337c478bd9Sstevel@tonic-gate #endif 27347c478bd9Sstevel@tonic-gate /* 27357c478bd9Sstevel@tonic-gate * create the root directory 27367c478bd9Sstevel@tonic-gate */ 27377c478bd9Sstevel@tonic-gate node.i_number = UFSROOTINO; 27387c478bd9Sstevel@tonic-gate node.i_mode = node.i_smode = IFDIR | UMASK; 27397c478bd9Sstevel@tonic-gate node.i_nlink = PREDEFDIR; 27407c478bd9Sstevel@tonic-gate node.i_size = makedir(root_dir, PREDEFDIR); 27417c478bd9Sstevel@tonic-gate node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode); 27427c478bd9Sstevel@tonic-gate /* i_size < 2GB because we are initializing the file system */ 27437c478bd9Sstevel@tonic-gate node.i_blocks = btodb(fragroundup(&sblock, (int)node.i_size)); 27447c478bd9Sstevel@tonic-gate IRANDOMIZE(&node.i_ic); 27457c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)node.i_db[0]), sblock.fs_fsize, buf); 27467c478bd9Sstevel@tonic-gate iput(&node); 27477c478bd9Sstevel@tonic-gate } 27487c478bd9Sstevel@tonic-gate 27497c478bd9Sstevel@tonic-gate /* 27507c478bd9Sstevel@tonic-gate * construct a set of directory entries in "buf". 27517c478bd9Sstevel@tonic-gate * return size of directory. 27527c478bd9Sstevel@tonic-gate */ 27537c478bd9Sstevel@tonic-gate static int 27547c478bd9Sstevel@tonic-gate makedir(struct direct *protodir, int entries) 27557c478bd9Sstevel@tonic-gate { 27567c478bd9Sstevel@tonic-gate char *cp; 27577c478bd9Sstevel@tonic-gate int i; 27587c478bd9Sstevel@tonic-gate ushort_t spcleft; 27597c478bd9Sstevel@tonic-gate 27607c478bd9Sstevel@tonic-gate spcleft = DIRBLKSIZ; 27617c478bd9Sstevel@tonic-gate for (cp = buf, i = 0; i < entries - 1; i++) { 27627c478bd9Sstevel@tonic-gate protodir[i].d_reclen = DIRSIZ(&protodir[i]); 27637c478bd9Sstevel@tonic-gate bcopy(&protodir[i], cp, protodir[i].d_reclen); 27647c478bd9Sstevel@tonic-gate cp += protodir[i].d_reclen; 27657c478bd9Sstevel@tonic-gate spcleft -= protodir[i].d_reclen; 27667c478bd9Sstevel@tonic-gate } 27677c478bd9Sstevel@tonic-gate protodir[i].d_reclen = spcleft; 27687c478bd9Sstevel@tonic-gate bcopy(&protodir[i], cp, DIRSIZ(&protodir[i])); 27697c478bd9Sstevel@tonic-gate return (DIRBLKSIZ); 27707c478bd9Sstevel@tonic-gate } 27717c478bd9Sstevel@tonic-gate 27727c478bd9Sstevel@tonic-gate /* 27737c478bd9Sstevel@tonic-gate * allocate a block or frag 27747c478bd9Sstevel@tonic-gate */ 27757c478bd9Sstevel@tonic-gate static daddr32_t 27767c478bd9Sstevel@tonic-gate alloc(int size, int mode) 27777c478bd9Sstevel@tonic-gate { 27787c478bd9Sstevel@tonic-gate int i, frag; 27797c478bd9Sstevel@tonic-gate daddr32_t d; 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize, 27827c478bd9Sstevel@tonic-gate (char *)&acg); 27837c478bd9Sstevel@tonic-gate if (acg.cg_magic != CG_MAGIC) { 27847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cg 0: bad magic number\n")); 27857c478bd9Sstevel@tonic-gate lockexit(32); 27867c478bd9Sstevel@tonic-gate } 27877c478bd9Sstevel@tonic-gate if (acg.cg_cs.cs_nbfree == 0) { 27887c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 27897c478bd9Sstevel@tonic-gate gettext("first cylinder group ran out of space\n")); 27907c478bd9Sstevel@tonic-gate lockexit(32); 27917c478bd9Sstevel@tonic-gate } 27927c478bd9Sstevel@tonic-gate for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag) 27937c478bd9Sstevel@tonic-gate if (isblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag)) 27947c478bd9Sstevel@tonic-gate goto goth; 27957c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 27967c478bd9Sstevel@tonic-gate gettext("internal error: can't find block in cyl 0\n")); 27977c478bd9Sstevel@tonic-gate lockexit(32); 27987c478bd9Sstevel@tonic-gate goth: 27997c478bd9Sstevel@tonic-gate clrblock(&sblock, cg_blksfree(&acg), d / sblock.fs_frag); 28007c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nbfree--; 28017c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nbfree--; 28027c478bd9Sstevel@tonic-gate fscs[0].cs_nbfree--; 28037c478bd9Sstevel@tonic-gate if (mode & IFDIR) { 28047c478bd9Sstevel@tonic-gate acg.cg_cs.cs_ndir++; 28057c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_ndir++; 28067c478bd9Sstevel@tonic-gate fscs[0].cs_ndir++; 28077c478bd9Sstevel@tonic-gate } 28087c478bd9Sstevel@tonic-gate cg_blktot(&acg)[cbtocylno(&sblock, d)]--; 28097c478bd9Sstevel@tonic-gate cg_blks(&sblock, &acg, cbtocylno(&sblock, d))[cbtorpos(&sblock, d)]--; 28107c478bd9Sstevel@tonic-gate if (size != sblock.fs_bsize) { 28117c478bd9Sstevel@tonic-gate frag = howmany(size, sblock.fs_fsize); 28127c478bd9Sstevel@tonic-gate fscs[0].cs_nffree += sblock.fs_frag - frag; 28137c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag; 28147c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nffree += sblock.fs_frag - frag; 28157c478bd9Sstevel@tonic-gate acg.cg_frsum[sblock.fs_frag - frag]++; 28167c478bd9Sstevel@tonic-gate for (i = frag; i < sblock.fs_frag; i++) 28177c478bd9Sstevel@tonic-gate setbit(cg_blksfree(&acg), d + i); 28187c478bd9Sstevel@tonic-gate } 28197c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize, 28207c478bd9Sstevel@tonic-gate (char *)&acg); 28217c478bd9Sstevel@tonic-gate return (d); 28227c478bd9Sstevel@tonic-gate } 28237c478bd9Sstevel@tonic-gate 28247c478bd9Sstevel@tonic-gate /* 28257c478bd9Sstevel@tonic-gate * Allocate an inode on the disk 28267c478bd9Sstevel@tonic-gate */ 28277c478bd9Sstevel@tonic-gate static void 28287c478bd9Sstevel@tonic-gate iput(struct inode *ip) 28297c478bd9Sstevel@tonic-gate { 28307c478bd9Sstevel@tonic-gate struct dinode buf[MAXINOPB]; 28317c478bd9Sstevel@tonic-gate diskaddr_t d; 28327c478bd9Sstevel@tonic-gate 28337c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize, 28347c478bd9Sstevel@tonic-gate (char *)&acg); 28357c478bd9Sstevel@tonic-gate if (acg.cg_magic != CG_MAGIC) { 28367c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cg 0: bad magic number\n")); 28377c478bd9Sstevel@tonic-gate lockexit(32); 28387c478bd9Sstevel@tonic-gate } 28397c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nifree--; 28407c478bd9Sstevel@tonic-gate setbit(cg_inosused(&acg), ip->i_number); 28417c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, 0)), sblock.fs_cgsize, 28427c478bd9Sstevel@tonic-gate (char *)&acg); 28437c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nifree--; 28447c478bd9Sstevel@tonic-gate fscs[0].cs_nifree--; 28457c478bd9Sstevel@tonic-gate if ((int)ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) { 28467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 28477c478bd9Sstevel@tonic-gate gettext("fsinit: inode value out of range (%d).\n"), 28487c478bd9Sstevel@tonic-gate ip->i_number); 28497c478bd9Sstevel@tonic-gate lockexit(32); 28507c478bd9Sstevel@tonic-gate } 28517c478bd9Sstevel@tonic-gate d = fsbtodb(&sblock, (uint64_t)itod(&sblock, (int)ip->i_number)); 28527c478bd9Sstevel@tonic-gate rdfs(d, sblock.fs_bsize, (char *)buf); 28537c478bd9Sstevel@tonic-gate buf[itoo(&sblock, (int)ip->i_number)].di_ic = ip->i_ic; 28547c478bd9Sstevel@tonic-gate wtfs(d, sblock.fs_bsize, (char *)buf); 28557c478bd9Sstevel@tonic-gate } 28567c478bd9Sstevel@tonic-gate 28577c478bd9Sstevel@tonic-gate /* 28587c478bd9Sstevel@tonic-gate * getbuf() -- Get a buffer for use in an AIO operation. Buffer 28597c478bd9Sstevel@tonic-gate * is zero'd the first time returned, left with whatever 28607c478bd9Sstevel@tonic-gate * was in memory after that. This function actually gets 28617c478bd9Sstevel@tonic-gate * enough memory the first time it's called to support 28627c478bd9Sstevel@tonic-gate * MAXBUF buffers like a slab allocator. When all the 28637c478bd9Sstevel@tonic-gate * buffers are in use, it waits for an aio to complete 28647c478bd9Sstevel@tonic-gate * and make a buffer available. 28657c478bd9Sstevel@tonic-gate * 28667c478bd9Sstevel@tonic-gate * Never returns an error. Either succeeds or exits. 28677c478bd9Sstevel@tonic-gate */ 28687c478bd9Sstevel@tonic-gate static char * 28697c478bd9Sstevel@tonic-gate getbuf(bufhdr *bufhead, int size) 28707c478bd9Sstevel@tonic-gate { 28717c478bd9Sstevel@tonic-gate bufhdr *pbuf; 28727c478bd9Sstevel@tonic-gate bufhdr *prev; 28737c478bd9Sstevel@tonic-gate int i; 28747c478bd9Sstevel@tonic-gate int buf_size, max_bufs; 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate /* 28777c478bd9Sstevel@tonic-gate * Initialize all the buffers 28787c478bd9Sstevel@tonic-gate */ 28797c478bd9Sstevel@tonic-gate if (bufhead->head == NULL) { 28807c478bd9Sstevel@tonic-gate /* 28817c478bd9Sstevel@tonic-gate * round up the size of our buffer header to a 28827c478bd9Sstevel@tonic-gate * 16 byte boundary so the address we return to 28837c478bd9Sstevel@tonic-gate * the caller is "suitably aligned". 28847c478bd9Sstevel@tonic-gate */ 28857c478bd9Sstevel@tonic-gate bufhdrsize = (sizeof (bufhdr) + 15) & ~15; 28867c478bd9Sstevel@tonic-gate 28877c478bd9Sstevel@tonic-gate /* 28887c478bd9Sstevel@tonic-gate * Add in our header to the buffer and round it all up to 28897c478bd9Sstevel@tonic-gate * a 16 byte boundry so each member of the slab is aligned. 28907c478bd9Sstevel@tonic-gate */ 28917c478bd9Sstevel@tonic-gate buf_size = (size + bufhdrsize + 15) & ~15; 28927c478bd9Sstevel@tonic-gate 28937c478bd9Sstevel@tonic-gate /* 28947c478bd9Sstevel@tonic-gate * Limit number of buffers to lesser of MAXBUFMEM's worth 28957c478bd9Sstevel@tonic-gate * or MAXBUF, whichever is less. 28967c478bd9Sstevel@tonic-gate */ 28977c478bd9Sstevel@tonic-gate max_bufs = MAXBUFMEM / buf_size; 28987c478bd9Sstevel@tonic-gate if (max_bufs > MAXBUF) 28997c478bd9Sstevel@tonic-gate max_bufs = MAXBUF; 29007c478bd9Sstevel@tonic-gate 29017c478bd9Sstevel@tonic-gate pbuf = (bufhdr *)calloc(max_bufs, buf_size); 29027c478bd9Sstevel@tonic-gate if (pbuf == NULL) { 29037c478bd9Sstevel@tonic-gate perror("calloc"); 29047c478bd9Sstevel@tonic-gate lockexit(32); 29057c478bd9Sstevel@tonic-gate } 29067c478bd9Sstevel@tonic-gate 29077c478bd9Sstevel@tonic-gate bufhead->head = bufhead; 29087c478bd9Sstevel@tonic-gate prev = bufhead; 29097c478bd9Sstevel@tonic-gate for (i = 0; i < max_bufs; i++) { 29107c478bd9Sstevel@tonic-gate pbuf->head = bufhead; 29117c478bd9Sstevel@tonic-gate prev->next = pbuf; 29127c478bd9Sstevel@tonic-gate prev = pbuf; 29137c478bd9Sstevel@tonic-gate pbuf = (bufhdr *)((char *)pbuf + buf_size); 29147c478bd9Sstevel@tonic-gate } 29157c478bd9Sstevel@tonic-gate } 29167c478bd9Sstevel@tonic-gate 29177c478bd9Sstevel@tonic-gate /* 29187c478bd9Sstevel@tonic-gate * Get an available buffer, waiting for I/O if necessary 29197c478bd9Sstevel@tonic-gate */ 29207c478bd9Sstevel@tonic-gate wait_for_write(NOBLOCK); 29217c478bd9Sstevel@tonic-gate while (bufhead->next == NULL) 29227c478bd9Sstevel@tonic-gate wait_for_write(BLOCK); 29237c478bd9Sstevel@tonic-gate 29247c478bd9Sstevel@tonic-gate /* 29257c478bd9Sstevel@tonic-gate * Take the buffer off the list 29267c478bd9Sstevel@tonic-gate */ 29277c478bd9Sstevel@tonic-gate pbuf = bufhead->next; 29287c478bd9Sstevel@tonic-gate bufhead->next = pbuf->next; 29297c478bd9Sstevel@tonic-gate pbuf->next = NULL; 29307c478bd9Sstevel@tonic-gate 29317c478bd9Sstevel@tonic-gate /* 29327c478bd9Sstevel@tonic-gate * return the empty buffer space just past the header 29337c478bd9Sstevel@tonic-gate */ 29347c478bd9Sstevel@tonic-gate return ((char *)pbuf + bufhdrsize); 29357c478bd9Sstevel@tonic-gate } 29367c478bd9Sstevel@tonic-gate 29377c478bd9Sstevel@tonic-gate /* 29387c478bd9Sstevel@tonic-gate * freebuf() -- Free a buffer gotten previously through getbuf. 29397c478bd9Sstevel@tonic-gate * Puts the buffer back on the appropriate list for 29407c478bd9Sstevel@tonic-gate * later use. Never calls free(). 29417c478bd9Sstevel@tonic-gate * 29427c478bd9Sstevel@tonic-gate * Assumes that SIGINT is blocked. 29437c478bd9Sstevel@tonic-gate */ 29447c478bd9Sstevel@tonic-gate static void 29457c478bd9Sstevel@tonic-gate freebuf(char *buf) 29467c478bd9Sstevel@tonic-gate { 29477c478bd9Sstevel@tonic-gate bufhdr *pbuf; 29487c478bd9Sstevel@tonic-gate bufhdr *bufhead; 29497c478bd9Sstevel@tonic-gate 29507c478bd9Sstevel@tonic-gate /* 29517c478bd9Sstevel@tonic-gate * get the header for this buffer 29527c478bd9Sstevel@tonic-gate */ 29537c478bd9Sstevel@tonic-gate pbuf = (bufhdr *)(buf - bufhdrsize); 29547c478bd9Sstevel@tonic-gate 29557c478bd9Sstevel@tonic-gate /* 29567c478bd9Sstevel@tonic-gate * Put it back on the list of available buffers 29577c478bd9Sstevel@tonic-gate */ 29587c478bd9Sstevel@tonic-gate bufhead = pbuf->head; 29597c478bd9Sstevel@tonic-gate pbuf->next = bufhead->next; 29607c478bd9Sstevel@tonic-gate bufhead->next = pbuf; 29617c478bd9Sstevel@tonic-gate } 29627c478bd9Sstevel@tonic-gate 29637c478bd9Sstevel@tonic-gate /* 29647c478bd9Sstevel@tonic-gate * freetrans() -- Free a transaction gotten previously through getaiop. 29657c478bd9Sstevel@tonic-gate * Puts the transaction struct back on the appropriate list for 29667c478bd9Sstevel@tonic-gate * later use. Never calls free(). 29677c478bd9Sstevel@tonic-gate * 29687c478bd9Sstevel@tonic-gate * Assumes that SIGINT is blocked. 29697c478bd9Sstevel@tonic-gate */ 29707c478bd9Sstevel@tonic-gate static void 29717c478bd9Sstevel@tonic-gate freetrans(aio_trans *transp) 29727c478bd9Sstevel@tonic-gate { 29737c478bd9Sstevel@tonic-gate /* 29747c478bd9Sstevel@tonic-gate * free the buffer associated with this AIO if needed 29757c478bd9Sstevel@tonic-gate */ 29767c478bd9Sstevel@tonic-gate if (transp->release == RELEASE) 29777c478bd9Sstevel@tonic-gate freebuf(transp->buffer); 29787c478bd9Sstevel@tonic-gate 29797c478bd9Sstevel@tonic-gate /* 29807c478bd9Sstevel@tonic-gate * Put transaction on the free list 29817c478bd9Sstevel@tonic-gate */ 29827c478bd9Sstevel@tonic-gate transp->next = results.trans; 29837c478bd9Sstevel@tonic-gate results.trans = transp; 29847c478bd9Sstevel@tonic-gate } 29857c478bd9Sstevel@tonic-gate 29867c478bd9Sstevel@tonic-gate /* 29877c478bd9Sstevel@tonic-gate * wait_for_write() -- Wait for an aio write to complete. Return 29887c478bd9Sstevel@tonic-gate * the transaction structure for that write. 29897c478bd9Sstevel@tonic-gate * 29907c478bd9Sstevel@tonic-gate * Blocks SIGINT if necessary. 29917c478bd9Sstevel@tonic-gate */ 29927c478bd9Sstevel@tonic-gate aio_trans * 29937c478bd9Sstevel@tonic-gate wait_for_write(int block) 29947c478bd9Sstevel@tonic-gate { 29957c478bd9Sstevel@tonic-gate aio_trans *transp; 29967c478bd9Sstevel@tonic-gate aio_result_t *resultp; 29977c478bd9Sstevel@tonic-gate static struct timeval zero_wait = { 0, 0 }; 29987c478bd9Sstevel@tonic-gate sigset_t old_mask; 29997c478bd9Sstevel@tonic-gate 30007c478bd9Sstevel@tonic-gate /* 30017c478bd9Sstevel@tonic-gate * If we know there aren't any outstanding transactions, just return 30027c478bd9Sstevel@tonic-gate */ 30037c478bd9Sstevel@tonic-gate if (results.outstanding == 0) 30047c478bd9Sstevel@tonic-gate return ((aio_trans *) 0); 30057c478bd9Sstevel@tonic-gate 30067c478bd9Sstevel@tonic-gate block_sigint(&old_mask); 30077c478bd9Sstevel@tonic-gate 30087c478bd9Sstevel@tonic-gate resultp = aiowait(block ? NULL : &zero_wait); 30097c478bd9Sstevel@tonic-gate if (resultp == NULL || 30107c478bd9Sstevel@tonic-gate (resultp == (aio_result_t *)-1 && errno == EINVAL)) { 30117c478bd9Sstevel@tonic-gate unblock_sigint(&old_mask); 30127c478bd9Sstevel@tonic-gate return ((aio_trans *) 0); 30137c478bd9Sstevel@tonic-gate } 30147c478bd9Sstevel@tonic-gate 30157c478bd9Sstevel@tonic-gate results.outstanding--; 30167c478bd9Sstevel@tonic-gate transp = (aio_trans *)resultp; 30177c478bd9Sstevel@tonic-gate 30187c478bd9Sstevel@tonic-gate if (resultp->aio_return != transp->size) { 30197c478bd9Sstevel@tonic-gate if (resultp->aio_return == -1) { 30207c478bd9Sstevel@tonic-gate /* 30217c478bd9Sstevel@tonic-gate * The aiowrite() may have failed because the 30227c478bd9Sstevel@tonic-gate * kernel didn't have enough memory to do the job. 30237c478bd9Sstevel@tonic-gate * Flush all pending writes and try a normal 30247c478bd9Sstevel@tonic-gate * write(). wtfs_breakup() will call exit if it 30257c478bd9Sstevel@tonic-gate * fails, so we don't worry about errors here. 30267c478bd9Sstevel@tonic-gate */ 30277c478bd9Sstevel@tonic-gate flush_writes(); 30287c478bd9Sstevel@tonic-gate wtfs_breakup(transp->bno, transp->size, transp->buffer); 30297c478bd9Sstevel@tonic-gate } else { 30307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 30317c478bd9Sstevel@tonic-gate "short write (%d of %d bytes) on sector %lld\n"), 30327c478bd9Sstevel@tonic-gate resultp->aio_return, transp->size, 30337c478bd9Sstevel@tonic-gate transp->bno); 30347c478bd9Sstevel@tonic-gate /* 30357c478bd9Sstevel@tonic-gate * Don't unblock SIGINT, to avoid potential 30367c478bd9Sstevel@tonic-gate * looping due to queued interrupts and 30377c478bd9Sstevel@tonic-gate * error handling. 30387c478bd9Sstevel@tonic-gate */ 30397c478bd9Sstevel@tonic-gate lockexit(32); 30407c478bd9Sstevel@tonic-gate } 30417c478bd9Sstevel@tonic-gate } 30427c478bd9Sstevel@tonic-gate 30437c478bd9Sstevel@tonic-gate resultp->aio_return = 0; 30447c478bd9Sstevel@tonic-gate freetrans(transp); 30457c478bd9Sstevel@tonic-gate unblock_sigint(&old_mask); 30467c478bd9Sstevel@tonic-gate return (transp); 30477c478bd9Sstevel@tonic-gate } 30487c478bd9Sstevel@tonic-gate 30497c478bd9Sstevel@tonic-gate /* 30507c478bd9Sstevel@tonic-gate * flush_writes() -- flush all the outstanding aio writes. 30517c478bd9Sstevel@tonic-gate */ 30527c478bd9Sstevel@tonic-gate static void 30537c478bd9Sstevel@tonic-gate flush_writes(void) 30547c478bd9Sstevel@tonic-gate { 30557c478bd9Sstevel@tonic-gate while (wait_for_write(BLOCK)) 30567c478bd9Sstevel@tonic-gate ; 30577c478bd9Sstevel@tonic-gate } 30587c478bd9Sstevel@tonic-gate 30597c478bd9Sstevel@tonic-gate /* 30607c478bd9Sstevel@tonic-gate * get_aiop() -- find and return an aio_trans structure on which a new 30617c478bd9Sstevel@tonic-gate * aio can be done. Blocks on aiowait() if needed. Reaps 30627c478bd9Sstevel@tonic-gate * all outstanding completed aio's. 30637c478bd9Sstevel@tonic-gate * 30647c478bd9Sstevel@tonic-gate * Assumes that SIGINT is blocked. 30657c478bd9Sstevel@tonic-gate */ 30667c478bd9Sstevel@tonic-gate aio_trans * 30677c478bd9Sstevel@tonic-gate get_aiop() 30687c478bd9Sstevel@tonic-gate { 30697c478bd9Sstevel@tonic-gate int i; 30707c478bd9Sstevel@tonic-gate aio_trans *transp; 30717c478bd9Sstevel@tonic-gate aio_trans *prev; 30727c478bd9Sstevel@tonic-gate 30737c478bd9Sstevel@tonic-gate /* 30747c478bd9Sstevel@tonic-gate * initialize aio stuff 30757c478bd9Sstevel@tonic-gate */ 30767c478bd9Sstevel@tonic-gate if (!aio_inited) { 30777c478bd9Sstevel@tonic-gate aio_inited = 1; 30787c478bd9Sstevel@tonic-gate 30797c478bd9Sstevel@tonic-gate results.maxpend = 0; 30807c478bd9Sstevel@tonic-gate results.outstanding = 0; 30817c478bd9Sstevel@tonic-gate results.max = MAXAIO; 30827c478bd9Sstevel@tonic-gate 30837c478bd9Sstevel@tonic-gate results.trans = (aio_trans *)calloc(results.max, 30847c478bd9Sstevel@tonic-gate sizeof (aio_trans)); 30857c478bd9Sstevel@tonic-gate if (results.trans == NULL) { 30867c478bd9Sstevel@tonic-gate perror("calloc"); 30877c478bd9Sstevel@tonic-gate lockexit(32); 30887c478bd9Sstevel@tonic-gate } 30897c478bd9Sstevel@tonic-gate 30907c478bd9Sstevel@tonic-gate /* 30917c478bd9Sstevel@tonic-gate * Initialize the linked list of aio transaction 30927c478bd9Sstevel@tonic-gate * structures. Note that the final "next" pointer 30937c478bd9Sstevel@tonic-gate * will be NULL since we got the buffer from calloc(). 30947c478bd9Sstevel@tonic-gate */ 30957c478bd9Sstevel@tonic-gate prev = results.trans; 30967c478bd9Sstevel@tonic-gate for (i = 1; i < results.max; i++) { 30977c478bd9Sstevel@tonic-gate prev->next = &(results.trans[i]); 30987c478bd9Sstevel@tonic-gate prev = prev->next; 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate } 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate wait_for_write(NOBLOCK); 31037c478bd9Sstevel@tonic-gate while (results.trans == NULL) 31047c478bd9Sstevel@tonic-gate wait_for_write(BLOCK); 31057c478bd9Sstevel@tonic-gate transp = results.trans; 31067c478bd9Sstevel@tonic-gate results.trans = results.trans->next; 31077c478bd9Sstevel@tonic-gate 31087c478bd9Sstevel@tonic-gate transp->next = 0; 31097c478bd9Sstevel@tonic-gate transp->resultbuf.aio_return = AIO_INPROGRESS; 31107c478bd9Sstevel@tonic-gate return (transp); 31117c478bd9Sstevel@tonic-gate } 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate /* 31147c478bd9Sstevel@tonic-gate * read a block from the file system 31157c478bd9Sstevel@tonic-gate */ 31167c478bd9Sstevel@tonic-gate static void 31177c478bd9Sstevel@tonic-gate rdfs(diskaddr_t bno, int size, char *bf) 31187c478bd9Sstevel@tonic-gate { 31197c478bd9Sstevel@tonic-gate int n, saverr; 31207c478bd9Sstevel@tonic-gate 31217c478bd9Sstevel@tonic-gate /* 31227c478bd9Sstevel@tonic-gate * In case we need any data that's pending in an aiowrite(), 31237c478bd9Sstevel@tonic-gate * we wait for them all to complete before doing a read. 31247c478bd9Sstevel@tonic-gate */ 31257c478bd9Sstevel@tonic-gate flush_writes(); 31267c478bd9Sstevel@tonic-gate 31277c478bd9Sstevel@tonic-gate /* 31287c478bd9Sstevel@tonic-gate * Note: the llseek() can succeed, even if the offset is out of range. 31297c478bd9Sstevel@tonic-gate * It's not until the file i/o operation (the read()) that one knows 31307c478bd9Sstevel@tonic-gate * for sure if the raw device can handle the offset. 31317c478bd9Sstevel@tonic-gate */ 31327c478bd9Sstevel@tonic-gate if (llseek(fsi, (offset_t)bno * sectorsize, 0) < 0) { 31337c478bd9Sstevel@tonic-gate saverr = errno; 31347c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 31357c478bd9Sstevel@tonic-gate gettext("seek error on sector %lld: %s\n"), 31367c478bd9Sstevel@tonic-gate bno, strerror(saverr)); 31377c478bd9Sstevel@tonic-gate lockexit(32); 31387c478bd9Sstevel@tonic-gate } 31397c478bd9Sstevel@tonic-gate n = read(fsi, bf, size); 31407c478bd9Sstevel@tonic-gate if (n != size) { 31417c478bd9Sstevel@tonic-gate saverr = errno; 31427c478bd9Sstevel@tonic-gate if (n == -1) 31437c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 31447c478bd9Sstevel@tonic-gate gettext("read error on sector %lld: %s\n"), 31457c478bd9Sstevel@tonic-gate bno, strerror(saverr)); 31467c478bd9Sstevel@tonic-gate else 31477c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 31487c478bd9Sstevel@tonic-gate "short read (%d of %d bytes) on sector %lld\n"), 31497c478bd9Sstevel@tonic-gate n, size, bno); 31507c478bd9Sstevel@tonic-gate lockexit(32); 31517c478bd9Sstevel@tonic-gate } 31527c478bd9Sstevel@tonic-gate } 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate /* 31557c478bd9Sstevel@tonic-gate * write a block to the file system 31567c478bd9Sstevel@tonic-gate */ 31577c478bd9Sstevel@tonic-gate static void 31587c478bd9Sstevel@tonic-gate wtfs(diskaddr_t bno, int size, char *bf) 31597c478bd9Sstevel@tonic-gate { 31607c478bd9Sstevel@tonic-gate int n, saverr; 31617c478bd9Sstevel@tonic-gate 31627c478bd9Sstevel@tonic-gate if (fso == -1) 31637c478bd9Sstevel@tonic-gate return; 31647c478bd9Sstevel@tonic-gate 31657c478bd9Sstevel@tonic-gate /* 31667c478bd9Sstevel@tonic-gate * Note: the llseek() can succeed, even if the offset is out of range. 31677c478bd9Sstevel@tonic-gate * It's not until the file i/o operation (the write()) that one knows 31687c478bd9Sstevel@tonic-gate * for sure if the raw device can handle the offset. 31697c478bd9Sstevel@tonic-gate */ 31707c478bd9Sstevel@tonic-gate if (llseek(fso, (offset_t)bno * sectorsize, 0) < 0) { 31717c478bd9Sstevel@tonic-gate saverr = errno; 31727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 31737c478bd9Sstevel@tonic-gate gettext("seek error on sector %lld: %s\n"), 31747c478bd9Sstevel@tonic-gate bno, strerror(saverr)); 31757c478bd9Sstevel@tonic-gate lockexit(32); 31767c478bd9Sstevel@tonic-gate } 31777c478bd9Sstevel@tonic-gate if (Nflag) 31787c478bd9Sstevel@tonic-gate return; 31797c478bd9Sstevel@tonic-gate n = write(fso, bf, size); 31807c478bd9Sstevel@tonic-gate if (n != size) { 31817c478bd9Sstevel@tonic-gate saverr = errno; 31827c478bd9Sstevel@tonic-gate if (n == -1) 31837c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 31847c478bd9Sstevel@tonic-gate gettext("write error on sector %lld: %s\n"), 31857c478bd9Sstevel@tonic-gate bno, strerror(saverr)); 31867c478bd9Sstevel@tonic-gate else 31877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 31887c478bd9Sstevel@tonic-gate "short write (%d of %d bytes) on sector %lld\n"), 31897c478bd9Sstevel@tonic-gate n, size, bno); 31907c478bd9Sstevel@tonic-gate lockexit(32); 31917c478bd9Sstevel@tonic-gate } 31927c478bd9Sstevel@tonic-gate } 31937c478bd9Sstevel@tonic-gate 31947c478bd9Sstevel@tonic-gate /* 31957c478bd9Sstevel@tonic-gate * write a block to the file system -- buffered with aio 31967c478bd9Sstevel@tonic-gate */ 31977c478bd9Sstevel@tonic-gate static void 31987c478bd9Sstevel@tonic-gate awtfs(diskaddr_t bno, int size, char *bf, int release) 31997c478bd9Sstevel@tonic-gate { 32007c478bd9Sstevel@tonic-gate int n; 32017c478bd9Sstevel@tonic-gate aio_trans *transp; 32027c478bd9Sstevel@tonic-gate sigset_t old_mask; 32037c478bd9Sstevel@tonic-gate 32047c478bd9Sstevel@tonic-gate if (fso == -1) 32057c478bd9Sstevel@tonic-gate return; 32067c478bd9Sstevel@tonic-gate 32077c478bd9Sstevel@tonic-gate /* 32087c478bd9Sstevel@tonic-gate * We need to keep things consistent if we get interrupted, 32097c478bd9Sstevel@tonic-gate * so defer any expected interrupts for the time being. 32107c478bd9Sstevel@tonic-gate */ 32117c478bd9Sstevel@tonic-gate block_sigint(&old_mask); 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate if (Nflag) { 32147c478bd9Sstevel@tonic-gate if (release == RELEASE) 32157c478bd9Sstevel@tonic-gate freebuf(bf); 32167c478bd9Sstevel@tonic-gate } else { 32177c478bd9Sstevel@tonic-gate transp = get_aiop(); 32187c478bd9Sstevel@tonic-gate transp->bno = bno; 32197c478bd9Sstevel@tonic-gate transp->buffer = bf; 32207c478bd9Sstevel@tonic-gate transp->size = size; 32217c478bd9Sstevel@tonic-gate transp->release = release; 32227c478bd9Sstevel@tonic-gate 32237c478bd9Sstevel@tonic-gate n = aiowrite(fso, bf, size, (off_t)bno * sectorsize, 32247c478bd9Sstevel@tonic-gate SEEK_SET, &transp->resultbuf); 32257c478bd9Sstevel@tonic-gate 32267c478bd9Sstevel@tonic-gate if (n < 0) { 32277c478bd9Sstevel@tonic-gate /* 32287c478bd9Sstevel@tonic-gate * The aiowrite() may have failed because the 32297c478bd9Sstevel@tonic-gate * kernel didn't have enough memory to do the job. 32307c478bd9Sstevel@tonic-gate * Flush all pending writes and try a normal 32317c478bd9Sstevel@tonic-gate * write(). wtfs_breakup() will call exit if it 32327c478bd9Sstevel@tonic-gate * fails, so we don't worry about errors here. 32337c478bd9Sstevel@tonic-gate */ 32347c478bd9Sstevel@tonic-gate flush_writes(); 32357c478bd9Sstevel@tonic-gate wtfs_breakup(transp->bno, transp->size, transp->buffer); 32367c478bd9Sstevel@tonic-gate freetrans(transp); 32377c478bd9Sstevel@tonic-gate } else { 32387c478bd9Sstevel@tonic-gate /* 32397c478bd9Sstevel@tonic-gate * Keep track of our pending writes. 32407c478bd9Sstevel@tonic-gate */ 32417c478bd9Sstevel@tonic-gate results.outstanding++; 32427c478bd9Sstevel@tonic-gate if (results.outstanding > results.maxpend) 32437c478bd9Sstevel@tonic-gate results.maxpend = results.outstanding; 32447c478bd9Sstevel@tonic-gate } 32457c478bd9Sstevel@tonic-gate } 32467c478bd9Sstevel@tonic-gate 32477c478bd9Sstevel@tonic-gate unblock_sigint(&old_mask); 32487c478bd9Sstevel@tonic-gate } 32497c478bd9Sstevel@tonic-gate 32507c478bd9Sstevel@tonic-gate 32517c478bd9Sstevel@tonic-gate /* 32527c478bd9Sstevel@tonic-gate * write a block to the file system, but break it up into sbsize 32537c478bd9Sstevel@tonic-gate * chunks to avoid forcing a large amount of memory to be locked down. 32547c478bd9Sstevel@tonic-gate * Only used as a fallback when an aio write has failed. 32557c478bd9Sstevel@tonic-gate */ 32567c478bd9Sstevel@tonic-gate static void 32577c478bd9Sstevel@tonic-gate wtfs_breakup(diskaddr_t bno, int size, char *bf) 32587c478bd9Sstevel@tonic-gate { 32597c478bd9Sstevel@tonic-gate int n, saverr; 32607c478bd9Sstevel@tonic-gate int wsize; 32617c478bd9Sstevel@tonic-gate int block_incr = sbsize / sectorsize; 32627c478bd9Sstevel@tonic-gate 32637c478bd9Sstevel@tonic-gate if (size < sbsize) 32647c478bd9Sstevel@tonic-gate wsize = size; 32657c478bd9Sstevel@tonic-gate else 32667c478bd9Sstevel@tonic-gate wsize = sbsize; 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate n = 0; 32697c478bd9Sstevel@tonic-gate while (size) { 32707c478bd9Sstevel@tonic-gate /* 32717c478bd9Sstevel@tonic-gate * Note: the llseek() can succeed, even if the offset is 32727c478bd9Sstevel@tonic-gate * out of range. It's not until the file i/o operation 32737c478bd9Sstevel@tonic-gate * (the write()) that one knows for sure if the raw device 32747c478bd9Sstevel@tonic-gate * can handle the offset. 32757c478bd9Sstevel@tonic-gate */ 32767c478bd9Sstevel@tonic-gate if (llseek(fso, (offset_t)bno * sectorsize, 0) < 0) { 32777c478bd9Sstevel@tonic-gate saverr = errno; 32787c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 32797c478bd9Sstevel@tonic-gate gettext("seek error on sector %lld: %s\n"), 32807c478bd9Sstevel@tonic-gate bno, strerror(saverr)); 32817c478bd9Sstevel@tonic-gate lockexit(32); 32827c478bd9Sstevel@tonic-gate } 32837c478bd9Sstevel@tonic-gate 32847c478bd9Sstevel@tonic-gate n = write(fso, bf, wsize); 32857c478bd9Sstevel@tonic-gate if (n == -1) { 32867c478bd9Sstevel@tonic-gate saverr = errno; 32877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 32887c478bd9Sstevel@tonic-gate gettext("write error on sector %lld: %s\n"), 32897c478bd9Sstevel@tonic-gate bno, strerror(saverr)); 32907c478bd9Sstevel@tonic-gate lockexit(32); 32917c478bd9Sstevel@tonic-gate } 32927c478bd9Sstevel@tonic-gate if (n != wsize) { 32937c478bd9Sstevel@tonic-gate saverr = errno; 32947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 32957c478bd9Sstevel@tonic-gate "short write (%d of %d bytes) on sector %lld\n"), 32967c478bd9Sstevel@tonic-gate n, size, bno); 32977c478bd9Sstevel@tonic-gate lockexit(32); 32987c478bd9Sstevel@tonic-gate } 32997c478bd9Sstevel@tonic-gate 33007c478bd9Sstevel@tonic-gate bno += block_incr; 33017c478bd9Sstevel@tonic-gate bf += wsize; 33027c478bd9Sstevel@tonic-gate size -= wsize; 33037c478bd9Sstevel@tonic-gate if (size < wsize) 33047c478bd9Sstevel@tonic-gate wsize = size; 33057c478bd9Sstevel@tonic-gate } 33067c478bd9Sstevel@tonic-gate } 33077c478bd9Sstevel@tonic-gate 33087c478bd9Sstevel@tonic-gate 33097c478bd9Sstevel@tonic-gate /* 33107c478bd9Sstevel@tonic-gate * check if a block is available 33117c478bd9Sstevel@tonic-gate */ 33127c478bd9Sstevel@tonic-gate static int 33137c478bd9Sstevel@tonic-gate isblock(struct fs *fs, unsigned char *cp, int h) 33147c478bd9Sstevel@tonic-gate { 33157c478bd9Sstevel@tonic-gate unsigned char mask; 33167c478bd9Sstevel@tonic-gate 33177c478bd9Sstevel@tonic-gate switch (fs->fs_frag) { 33187c478bd9Sstevel@tonic-gate case 8: 33197c478bd9Sstevel@tonic-gate return (cp[h] == 0xff); 33207c478bd9Sstevel@tonic-gate case 4: 33217c478bd9Sstevel@tonic-gate mask = 0x0f << ((h & 0x1) << 2); 33227c478bd9Sstevel@tonic-gate return ((cp[h >> 1] & mask) == mask); 33237c478bd9Sstevel@tonic-gate case 2: 33247c478bd9Sstevel@tonic-gate mask = 0x03 << ((h & 0x3) << 1); 33257c478bd9Sstevel@tonic-gate return ((cp[h >> 2] & mask) == mask); 33267c478bd9Sstevel@tonic-gate case 1: 33277c478bd9Sstevel@tonic-gate mask = 0x01 << (h & 0x7); 33287c478bd9Sstevel@tonic-gate return ((cp[h >> 3] & mask) == mask); 33297c478bd9Sstevel@tonic-gate default: 33307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag); 33317c478bd9Sstevel@tonic-gate return (0); 33327c478bd9Sstevel@tonic-gate } 33337c478bd9Sstevel@tonic-gate } 33347c478bd9Sstevel@tonic-gate 33357c478bd9Sstevel@tonic-gate /* 33367c478bd9Sstevel@tonic-gate * take a block out of the map 33377c478bd9Sstevel@tonic-gate */ 33387c478bd9Sstevel@tonic-gate static void 33397c478bd9Sstevel@tonic-gate clrblock(struct fs *fs, unsigned char *cp, int h) 33407c478bd9Sstevel@tonic-gate { 33417c478bd9Sstevel@tonic-gate switch ((fs)->fs_frag) { 33427c478bd9Sstevel@tonic-gate case 8: 33437c478bd9Sstevel@tonic-gate cp[h] = 0; 33447c478bd9Sstevel@tonic-gate return; 33457c478bd9Sstevel@tonic-gate case 4: 33467c478bd9Sstevel@tonic-gate cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); 33477c478bd9Sstevel@tonic-gate return; 33487c478bd9Sstevel@tonic-gate case 2: 33497c478bd9Sstevel@tonic-gate cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); 33507c478bd9Sstevel@tonic-gate return; 33517c478bd9Sstevel@tonic-gate case 1: 33527c478bd9Sstevel@tonic-gate cp[h >> 3] &= ~(0x01 << (h & 0x7)); 33537c478bd9Sstevel@tonic-gate return; 33547c478bd9Sstevel@tonic-gate default: 33557c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 33567c478bd9Sstevel@tonic-gate gettext("clrblock: bad fs_frag value %d\n"), fs->fs_frag); 33577c478bd9Sstevel@tonic-gate return; 33587c478bd9Sstevel@tonic-gate } 33597c478bd9Sstevel@tonic-gate } 33607c478bd9Sstevel@tonic-gate 33617c478bd9Sstevel@tonic-gate /* 33627c478bd9Sstevel@tonic-gate * put a block into the map 33637c478bd9Sstevel@tonic-gate */ 33647c478bd9Sstevel@tonic-gate static void 33657c478bd9Sstevel@tonic-gate setblock(struct fs *fs, unsigned char *cp, int h) 33667c478bd9Sstevel@tonic-gate { 33677c478bd9Sstevel@tonic-gate switch (fs->fs_frag) { 33687c478bd9Sstevel@tonic-gate case 8: 33697c478bd9Sstevel@tonic-gate cp[h] = 0xff; 33707c478bd9Sstevel@tonic-gate return; 33717c478bd9Sstevel@tonic-gate case 4: 33727c478bd9Sstevel@tonic-gate cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); 33737c478bd9Sstevel@tonic-gate return; 33747c478bd9Sstevel@tonic-gate case 2: 33757c478bd9Sstevel@tonic-gate cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); 33767c478bd9Sstevel@tonic-gate return; 33777c478bd9Sstevel@tonic-gate case 1: 33787c478bd9Sstevel@tonic-gate cp[h >> 3] |= (0x01 << (h & 0x7)); 33797c478bd9Sstevel@tonic-gate return; 33807c478bd9Sstevel@tonic-gate default: 33817c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 33827c478bd9Sstevel@tonic-gate gettext("setblock: bad fs_frag value %d\n"), fs->fs_frag); 33837c478bd9Sstevel@tonic-gate return; 33847c478bd9Sstevel@tonic-gate } 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate 33877c478bd9Sstevel@tonic-gate static void 33887c478bd9Sstevel@tonic-gate usage() 33897c478bd9Sstevel@tonic-gate { 33907c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 33917c478bd9Sstevel@tonic-gate gettext("ufs usage: mkfs [-F FSType] [-V] [-m] [-o options] " 33927c478bd9Sstevel@tonic-gate "special " /* param 0 */ 33937c478bd9Sstevel@tonic-gate "size(sectors) \\ \n")); /* param 1 */ 33947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 33957c478bd9Sstevel@tonic-gate "[nsect " /* param 2 */ 33967c478bd9Sstevel@tonic-gate "ntrack " /* param 3 */ 33977c478bd9Sstevel@tonic-gate "bsize " /* param 4 */ 33987c478bd9Sstevel@tonic-gate "fragsize " /* param 5 */ 33997c478bd9Sstevel@tonic-gate "cpg " /* param 6 */ 34007c478bd9Sstevel@tonic-gate "free " /* param 7 */ 34017c478bd9Sstevel@tonic-gate "rps " /* param 8 */ 34027c478bd9Sstevel@tonic-gate "nbpi " /* param 9 */ 34037c478bd9Sstevel@tonic-gate "opt " /* param 10 */ 34047c478bd9Sstevel@tonic-gate "apc " /* param 11 */ 34057c478bd9Sstevel@tonic-gate "gap " /* param 12 */ 34067c478bd9Sstevel@tonic-gate "nrpos " /* param 13 */ 34077c478bd9Sstevel@tonic-gate "maxcontig " /* param 14 */ 34087c478bd9Sstevel@tonic-gate "mtb]\n"); /* param 15 */ 34097c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 34107c478bd9Sstevel@tonic-gate gettext(" -m : dump fs cmd line used to make this partition\n" 34117c478bd9Sstevel@tonic-gate " -V :print this command line and return\n" 34127c478bd9Sstevel@tonic-gate " -o :ufs options: :nsect=%d,ntrack=%d,bsize=%d,fragsize=%d\n" 34137c478bd9Sstevel@tonic-gate " -o :ufs options: :cgsize=%d,free=%d,rps=%d,nbpi=%d,opt=%c\n" 34147c478bd9Sstevel@tonic-gate " -o :ufs options: :apc=%d,gap=%d,nrpos=%d,maxcontig=%d\n" 3415355d6bb5Sswilcox " -o :ufs options: :mtb=%c,calcsb,calcbinsb\n" 34167c478bd9Sstevel@tonic-gate "NOTE that all -o suboptions: must be separated only by commas so as to\n" 34177c478bd9Sstevel@tonic-gate "be parsed as a single argument\n"), 34187c478bd9Sstevel@tonic-gate nsect, ntrack, bsize, fragsize, cpg, sblock.fs_minfree, rps, 34197c478bd9Sstevel@tonic-gate nbpi, opt, apc, (rotdelay == -1) ? 0 : rotdelay, 34207c478bd9Sstevel@tonic-gate sblock.fs_nrpos, maxcontig, mtb); 34217c478bd9Sstevel@tonic-gate lockexit(32); 34227c478bd9Sstevel@tonic-gate } 34237c478bd9Sstevel@tonic-gate 34247c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 34257c478bd9Sstevel@tonic-gate static void 34267c478bd9Sstevel@tonic-gate dump_fscmd(char *fsys, int fsi) 34277c478bd9Sstevel@tonic-gate { 34287c478bd9Sstevel@tonic-gate int64_t used, bpcg, inospercg; 34297c478bd9Sstevel@tonic-gate int64_t nbpi; 34307c478bd9Sstevel@tonic-gate uint64_t nbytes64; 34317c478bd9Sstevel@tonic-gate 34327c478bd9Sstevel@tonic-gate bzero((char *)&sblock, sizeof (sblock)); 34337c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)SBLOCK, SBSIZE, (char *)&sblock); 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate /* 34367c478bd9Sstevel@tonic-gate * ensure a valid file system and if not, exit with error or else 34377c478bd9Sstevel@tonic-gate * we will end up computing block numbers etc and dividing by zero 34387c478bd9Sstevel@tonic-gate * which will cause floating point errors in this routine. 34397c478bd9Sstevel@tonic-gate */ 34407c478bd9Sstevel@tonic-gate 34417c478bd9Sstevel@tonic-gate if ((sblock.fs_magic != FS_MAGIC) && 34427c478bd9Sstevel@tonic-gate (sblock.fs_magic != MTB_UFS_MAGIC)) { 34437c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 34447c478bd9Sstevel@tonic-gate "[not currently a valid file system - bad superblock]\n")); 34457c478bd9Sstevel@tonic-gate lockexit(32); 34467c478bd9Sstevel@tonic-gate } 34477c478bd9Sstevel@tonic-gate 3448*6451fdbcSvsakar if (sblock.fs_magic == FS_MAGIC && 3449*6451fdbcSvsakar (sblock.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 && 3450*6451fdbcSvsakar sblock.fs_version != UFS_VERSION_MIN)) { 3451*6451fdbcSvsakar (void) fprintf(stderr, gettext( 3452*6451fdbcSvsakar "Unknown version of UFS format: %d\n"), sblock.fs_version); 3453*6451fdbcSvsakar lockexit(32); 3454*6451fdbcSvsakar } 3455*6451fdbcSvsakar 34567c478bd9Sstevel@tonic-gate if (sblock.fs_magic == MTB_UFS_MAGIC && 34577c478bd9Sstevel@tonic-gate (sblock.fs_version > MTB_UFS_VERSION_1 || 34587c478bd9Sstevel@tonic-gate sblock.fs_version < MTB_UFS_VERSION_MIN)) { 34597c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 34607c478bd9Sstevel@tonic-gate "Unknown version of UFS format: %d\n"), sblock.fs_version); 34617c478bd9Sstevel@tonic-gate lockexit(32); 34627c478bd9Sstevel@tonic-gate } 34637c478bd9Sstevel@tonic-gate 34647c478bd9Sstevel@tonic-gate /* 34657c478bd9Sstevel@tonic-gate * Compute a reasonable nbpi value. 34667c478bd9Sstevel@tonic-gate * The algorithm for "used" is copied from code 34677c478bd9Sstevel@tonic-gate * in main() verbatim. 34687c478bd9Sstevel@tonic-gate * The nbpi equation is taken from main where the 34697c478bd9Sstevel@tonic-gate * fs_ipg value is set for the last time. The INOPB(...) - 1 34707c478bd9Sstevel@tonic-gate * is used to account for the roundup. 34717c478bd9Sstevel@tonic-gate * The problem is that a range of nbpi values map to 34727c478bd9Sstevel@tonic-gate * the same file system layout. So it is not possible 34737c478bd9Sstevel@tonic-gate * to calculate the exact value specified when the file 34747c478bd9Sstevel@tonic-gate * system was created. So instead we determine the top 34757c478bd9Sstevel@tonic-gate * end of the range of values. 34767c478bd9Sstevel@tonic-gate */ 34777c478bd9Sstevel@tonic-gate bpcg = sblock.fs_spc * sectorsize; 34787c478bd9Sstevel@tonic-gate inospercg = (int64_t)roundup(bpcg / sizeof (struct dinode), 34797c478bd9Sstevel@tonic-gate INOPB(&sblock)); 34807c478bd9Sstevel@tonic-gate if (inospercg > MAXIpG(&sblock)) 34817c478bd9Sstevel@tonic-gate inospercg = MAXIpG(&sblock); 34827c478bd9Sstevel@tonic-gate used = (int64_t) 34837c478bd9Sstevel@tonic-gate (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock); 34847c478bd9Sstevel@tonic-gate used *= sectorsize; 34857c478bd9Sstevel@tonic-gate nbytes64 = (uint64_t)sblock.fs_cpg * bpcg - used; 34867c478bd9Sstevel@tonic-gate 34877c478bd9Sstevel@tonic-gate /* 34887c478bd9Sstevel@tonic-gate * The top end of the range of values for nbpi may not be 34897c478bd9Sstevel@tonic-gate * a valid command line value for mkfs. Report the bottom 34907c478bd9Sstevel@tonic-gate * end instead. 34917c478bd9Sstevel@tonic-gate */ 34927c478bd9Sstevel@tonic-gate nbpi = (int64_t)(nbytes64 / (sblock.fs_ipg)); 34937c478bd9Sstevel@tonic-gate 34947c478bd9Sstevel@tonic-gate (void) fprintf(stdout, gettext("mkfs -F ufs -o "), fsys); 34957c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "nsect=%d,ntrack=%d,", 34967c478bd9Sstevel@tonic-gate sblock.fs_nsect, sblock.fs_ntrak); 34977c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "bsize=%d,fragsize=%d,cgsize=%d,free=%d,", 34987c478bd9Sstevel@tonic-gate sblock.fs_bsize, sblock.fs_fsize, sblock.fs_cpg, sblock.fs_minfree); 34997c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "rps=%d,nbpi=%lld,opt=%c,apc=%d,gap=%d,", 35007c478bd9Sstevel@tonic-gate sblock.fs_rps, nbpi, (sblock.fs_optim == FS_OPTSPACE) ? 's' : 't', 35017c478bd9Sstevel@tonic-gate (sblock.fs_ntrak * sblock.fs_nsect) - sblock.fs_spc, 35027c478bd9Sstevel@tonic-gate sblock.fs_rotdelay); 35037c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "nrpos=%d,maxcontig=%d,mtb=%c ", 35047c478bd9Sstevel@tonic-gate sblock.fs_nrpos, sblock.fs_maxcontig, 35057c478bd9Sstevel@tonic-gate ((sblock.fs_magic == MTB_UFS_MAGIC) ? 'y' : 'n')); 35067c478bd9Sstevel@tonic-gate (void) fprintf(stdout, "%s %lld\n", fsys, 35077c478bd9Sstevel@tonic-gate fsbtodb(&sblock, sblock.fs_size)); 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate bzero((char *)&sblock, sizeof (sblock)); 35107c478bd9Sstevel@tonic-gate } 35117c478bd9Sstevel@tonic-gate 35127c478bd9Sstevel@tonic-gate /* number ************************************************************* */ 35137c478bd9Sstevel@tonic-gate /* */ 35147c478bd9Sstevel@tonic-gate /* Convert a numeric string arg to binary */ 35157c478bd9Sstevel@tonic-gate /* */ 35167c478bd9Sstevel@tonic-gate /* Args: d_value - default value, if have parse error */ 35177c478bd9Sstevel@tonic-gate /* param - the name of the argument, for error messages */ 35187c478bd9Sstevel@tonic-gate /* flags - parser state and what's allowed in the arg */ 35197c478bd9Sstevel@tonic-gate /* Global arg: string - pointer to command arg */ 35207c478bd9Sstevel@tonic-gate /* */ 35217c478bd9Sstevel@tonic-gate /* Valid forms: 123 | 123k | 123*123 | 123x123 */ 35227c478bd9Sstevel@tonic-gate /* */ 35237c478bd9Sstevel@tonic-gate /* Return: converted number */ 35247c478bd9Sstevel@tonic-gate /* */ 35257c478bd9Sstevel@tonic-gate /* ******************************************************************** */ 35267c478bd9Sstevel@tonic-gate 35277c478bd9Sstevel@tonic-gate static uint64_t 35287c478bd9Sstevel@tonic-gate number(uint64_t d_value, char *param, int flags) 35297c478bd9Sstevel@tonic-gate { 35307c478bd9Sstevel@tonic-gate char *cs; 35317c478bd9Sstevel@tonic-gate uint64_t n, t; 35327c478bd9Sstevel@tonic-gate uint64_t cut = BIG / 10; /* limit to avoid overflow */ 35337c478bd9Sstevel@tonic-gate int minus = 0; 35347c478bd9Sstevel@tonic-gate 35357c478bd9Sstevel@tonic-gate cs = string; 35367c478bd9Sstevel@tonic-gate if (*cs == '-') { 35377c478bd9Sstevel@tonic-gate minus = 1; 35387c478bd9Sstevel@tonic-gate cs += 1; 35397c478bd9Sstevel@tonic-gate } 35407c478bd9Sstevel@tonic-gate if ((*cs < '0') || (*cs > '9')) { 35417c478bd9Sstevel@tonic-gate goto bail_out; 35427c478bd9Sstevel@tonic-gate } 35437c478bd9Sstevel@tonic-gate n = 0; 35447c478bd9Sstevel@tonic-gate while ((*cs >= '0') && (*cs <= '9') && (n <= cut)) { 35457c478bd9Sstevel@tonic-gate n = n*10 + *cs++ - '0'; 35467c478bd9Sstevel@tonic-gate } 35477c478bd9Sstevel@tonic-gate if (minus) 35487c478bd9Sstevel@tonic-gate n = -n; 35497c478bd9Sstevel@tonic-gate for (;;) { 35507c478bd9Sstevel@tonic-gate switch (*cs++) { 35517c478bd9Sstevel@tonic-gate case 'k': 35527c478bd9Sstevel@tonic-gate if (flags & ALLOW_END_ONLY) 35537c478bd9Sstevel@tonic-gate goto bail_out; 35547c478bd9Sstevel@tonic-gate if (n > (BIG / 1024)) 35557c478bd9Sstevel@tonic-gate goto overflow; 35567c478bd9Sstevel@tonic-gate n *= 1024; 35577c478bd9Sstevel@tonic-gate continue; 35587c478bd9Sstevel@tonic-gate 35597c478bd9Sstevel@tonic-gate case '*': 35607c478bd9Sstevel@tonic-gate case 'x': 35617c478bd9Sstevel@tonic-gate if (flags & ALLOW_END_ONLY) 35627c478bd9Sstevel@tonic-gate goto bail_out; 35637c478bd9Sstevel@tonic-gate string = cs; 35647c478bd9Sstevel@tonic-gate t = number(d_value, param, flags); 35657c478bd9Sstevel@tonic-gate if (n > (BIG / t)) 35667c478bd9Sstevel@tonic-gate goto overflow; 35677c478bd9Sstevel@tonic-gate n *= t; 35687c478bd9Sstevel@tonic-gate cs = string + 1; /* adjust for -- below */ 35697c478bd9Sstevel@tonic-gate 35707c478bd9Sstevel@tonic-gate /* recursion has read rest of expression */ 35717c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 35727c478bd9Sstevel@tonic-gate 35737c478bd9Sstevel@tonic-gate case ',': 35747c478bd9Sstevel@tonic-gate case '\0': 35757c478bd9Sstevel@tonic-gate cs--; 35767c478bd9Sstevel@tonic-gate string = cs; 35777c478bd9Sstevel@tonic-gate return (n); 35787c478bd9Sstevel@tonic-gate 35797c478bd9Sstevel@tonic-gate case '%': 35807c478bd9Sstevel@tonic-gate if (flags & ALLOW_END_ONLY) 35817c478bd9Sstevel@tonic-gate goto bail_out; 35827c478bd9Sstevel@tonic-gate if (flags & ALLOW_PERCENT) { 35837c478bd9Sstevel@tonic-gate flags &= ~ALLOW_PERCENT; 35847c478bd9Sstevel@tonic-gate flags |= ALLOW_END_ONLY; 35857c478bd9Sstevel@tonic-gate continue; 35867c478bd9Sstevel@tonic-gate } 35877c478bd9Sstevel@tonic-gate goto bail_out; 35887c478bd9Sstevel@tonic-gate 35897c478bd9Sstevel@tonic-gate case 'm': 35907c478bd9Sstevel@tonic-gate if (flags & ALLOW_END_ONLY) 35917c478bd9Sstevel@tonic-gate goto bail_out; 35927c478bd9Sstevel@tonic-gate if (flags & ALLOW_MS1) { 35937c478bd9Sstevel@tonic-gate flags &= ~ALLOW_MS1; 35947c478bd9Sstevel@tonic-gate flags |= ALLOW_MS2; 35957c478bd9Sstevel@tonic-gate continue; 35967c478bd9Sstevel@tonic-gate } 35977c478bd9Sstevel@tonic-gate goto bail_out; 35987c478bd9Sstevel@tonic-gate 35997c478bd9Sstevel@tonic-gate case 's': 36007c478bd9Sstevel@tonic-gate if (flags & ALLOW_END_ONLY) 36017c478bd9Sstevel@tonic-gate goto bail_out; 36027c478bd9Sstevel@tonic-gate if (flags & ALLOW_MS2) { 36037c478bd9Sstevel@tonic-gate flags &= ~ALLOW_MS2; 36047c478bd9Sstevel@tonic-gate flags |= ALLOW_END_ONLY; 36057c478bd9Sstevel@tonic-gate continue; 36067c478bd9Sstevel@tonic-gate } 36077c478bd9Sstevel@tonic-gate goto bail_out; 36087c478bd9Sstevel@tonic-gate 36097c478bd9Sstevel@tonic-gate case '0': case '1': case '2': case '3': case '4': 36107c478bd9Sstevel@tonic-gate case '5': case '6': case '7': case '8': case '9': 36117c478bd9Sstevel@tonic-gate overflow: 36127c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 36137c478bd9Sstevel@tonic-gate gettext("mkfs: value for %s overflowed\n"), 36147c478bd9Sstevel@tonic-gate param); 36157c478bd9Sstevel@tonic-gate while ((*cs != '\0') && (*cs != ',')) 36167c478bd9Sstevel@tonic-gate cs++; 36177c478bd9Sstevel@tonic-gate string = cs; 36187c478bd9Sstevel@tonic-gate return (BIG); 36197c478bd9Sstevel@tonic-gate 36207c478bd9Sstevel@tonic-gate default: 36217c478bd9Sstevel@tonic-gate bail_out: 36227c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 36237c478bd9Sstevel@tonic-gate "mkfs: bad numeric arg for %s: \"%s\"\n"), 36247c478bd9Sstevel@tonic-gate param, string); 36257c478bd9Sstevel@tonic-gate while ((*cs != '\0') && (*cs != ',')) 36267c478bd9Sstevel@tonic-gate cs++; 36277c478bd9Sstevel@tonic-gate string = cs; 36287c478bd9Sstevel@tonic-gate if (d_value != NO_DEFAULT) { 36297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 36307c478bd9Sstevel@tonic-gate gettext("mkfs: %s reset to default %lld\n"), 36317c478bd9Sstevel@tonic-gate param, d_value); 36327c478bd9Sstevel@tonic-gate return (d_value); 36337c478bd9Sstevel@tonic-gate } 36347c478bd9Sstevel@tonic-gate lockexit(2); 36357c478bd9Sstevel@tonic-gate 36367c478bd9Sstevel@tonic-gate } 36377c478bd9Sstevel@tonic-gate } /* never gets here */ 36387c478bd9Sstevel@tonic-gate } 36397c478bd9Sstevel@tonic-gate 36407c478bd9Sstevel@tonic-gate /* match ************************************************************** */ 36417c478bd9Sstevel@tonic-gate /* */ 36427c478bd9Sstevel@tonic-gate /* Compare two text strings for equality */ 36437c478bd9Sstevel@tonic-gate /* */ 36447c478bd9Sstevel@tonic-gate /* Arg: s - pointer to string to match with a command arg */ 36457c478bd9Sstevel@tonic-gate /* Global arg: string - pointer to command arg */ 36467c478bd9Sstevel@tonic-gate /* */ 36477c478bd9Sstevel@tonic-gate /* Return: 1 if match, 0 if no match */ 36487c478bd9Sstevel@tonic-gate /* If match, also reset `string' to point to the text */ 36497c478bd9Sstevel@tonic-gate /* that follows the matching text. */ 36507c478bd9Sstevel@tonic-gate /* */ 36517c478bd9Sstevel@tonic-gate /* ******************************************************************** */ 36527c478bd9Sstevel@tonic-gate 36537c478bd9Sstevel@tonic-gate static int 36547c478bd9Sstevel@tonic-gate match(char *s) 36557c478bd9Sstevel@tonic-gate { 36567c478bd9Sstevel@tonic-gate char *cs; 36577c478bd9Sstevel@tonic-gate 36587c478bd9Sstevel@tonic-gate cs = string; 36597c478bd9Sstevel@tonic-gate while (*cs++ == *s) { 36607c478bd9Sstevel@tonic-gate if (*s++ == '\0') { 36617c478bd9Sstevel@tonic-gate goto true; 36627c478bd9Sstevel@tonic-gate } 36637c478bd9Sstevel@tonic-gate } 36647c478bd9Sstevel@tonic-gate if (*s != '\0') { 36657c478bd9Sstevel@tonic-gate return (0); 36667c478bd9Sstevel@tonic-gate } 36677c478bd9Sstevel@tonic-gate 36687c478bd9Sstevel@tonic-gate true: 36697c478bd9Sstevel@tonic-gate cs--; 36707c478bd9Sstevel@tonic-gate string = cs; 36717c478bd9Sstevel@tonic-gate return (1); 36727c478bd9Sstevel@tonic-gate } 36737c478bd9Sstevel@tonic-gate 36747c478bd9Sstevel@tonic-gate /* 36757c478bd9Sstevel@tonic-gate * GROWFS ROUTINES 36767c478bd9Sstevel@tonic-gate */ 36777c478bd9Sstevel@tonic-gate 36787c478bd9Sstevel@tonic-gate /* ARGSUSED */ 36797c478bd9Sstevel@tonic-gate void 36807c478bd9Sstevel@tonic-gate lockexit(int exitstatus) 36817c478bd9Sstevel@tonic-gate { 36827c478bd9Sstevel@tonic-gate if (Pflag) { 36837c478bd9Sstevel@tonic-gate /* the probe mode neither changes nor locks the filesystem */ 36847c478bd9Sstevel@tonic-gate exit(exitstatus); 36857c478bd9Sstevel@tonic-gate } 36867c478bd9Sstevel@tonic-gate 36877c478bd9Sstevel@tonic-gate /* 36887c478bd9Sstevel@tonic-gate * flush the dirty cylinder group 36897c478bd9Sstevel@tonic-gate */ 36907c478bd9Sstevel@tonic-gate if (inlockexit == 0) { 36917c478bd9Sstevel@tonic-gate inlockexit = 1; 36927c478bd9Sstevel@tonic-gate flcg(); 36937c478bd9Sstevel@tonic-gate } 36947c478bd9Sstevel@tonic-gate 36957c478bd9Sstevel@tonic-gate if (aio_inited) { 36967c478bd9Sstevel@tonic-gate flush_writes(); 36977c478bd9Sstevel@tonic-gate } 36987c478bd9Sstevel@tonic-gate 36997c478bd9Sstevel@tonic-gate /* 37007c478bd9Sstevel@tonic-gate * make sure the file system is unlocked before exiting 37017c478bd9Sstevel@tonic-gate */ 37027c478bd9Sstevel@tonic-gate if ((inlockexit == 1) && (!isbad)) { 37037c478bd9Sstevel@tonic-gate inlockexit = 2; 37047c478bd9Sstevel@tonic-gate ulockfs(); 37057c478bd9Sstevel@tonic-gate /* 37067c478bd9Sstevel@tonic-gate * if logging was enabled, then re-enable it 37077c478bd9Sstevel@tonic-gate */ 37087c478bd9Sstevel@tonic-gate if (waslog) { 37097c478bd9Sstevel@tonic-gate if (rl_log_control(fsys, _FIOLOGENABLE) != RL_SUCCESS) { 37107c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37117c478bd9Sstevel@tonic-gate "failed to re-enable logging\n")); 37127c478bd9Sstevel@tonic-gate } 37137c478bd9Sstevel@tonic-gate } 37147c478bd9Sstevel@tonic-gate } else if (grow) { 37157c478bd9Sstevel@tonic-gate if (isbad) { 37167c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37177c478bd9Sstevel@tonic-gate "Filesystem is currently inconsistent. It " 37187c478bd9Sstevel@tonic-gate "must be repaired with fsck(1M)\nbefore being " 37197c478bd9Sstevel@tonic-gate "used. Use the following command to " 37207c478bd9Sstevel@tonic-gate "do this:\n\n\tfsck %s\n\n"), 37217c478bd9Sstevel@tonic-gate fsys); 37227c478bd9Sstevel@tonic-gate 37237c478bd9Sstevel@tonic-gate if (ismounted) { 37247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37257c478bd9Sstevel@tonic-gate "You will be told that the filesystem " 37267c478bd9Sstevel@tonic-gate "is already mounted, and asked if you\n" 37277c478bd9Sstevel@tonic-gate "wish to continue. Answer `yes' to " 37287c478bd9Sstevel@tonic-gate "this question.\n\n")); 37297c478bd9Sstevel@tonic-gate } 37307c478bd9Sstevel@tonic-gate 37317c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37327c478bd9Sstevel@tonic-gate "One problem should be reported, that " 37337c478bd9Sstevel@tonic-gate "the summary information is bad.\n" 37347c478bd9Sstevel@tonic-gate "You will then be asked if it " 37357c478bd9Sstevel@tonic-gate "should be salvaged. Answer `yes' " 37367c478bd9Sstevel@tonic-gate "to\nthis question.\n\n")); 37377c478bd9Sstevel@tonic-gate } 37387c478bd9Sstevel@tonic-gate 37397c478bd9Sstevel@tonic-gate if (ismounted) { 37407c478bd9Sstevel@tonic-gate /* 37417c478bd9Sstevel@tonic-gate * In theory, there's no way to get here without 37427c478bd9Sstevel@tonic-gate * isbad also being set, but be robust in the 37437c478bd9Sstevel@tonic-gate * face of future code changes. 37447c478bd9Sstevel@tonic-gate */ 37457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37467c478bd9Sstevel@tonic-gate "The filesystem is currently mounted " 37477c478bd9Sstevel@tonic-gate "read-only and write-locked. ")); 37487c478bd9Sstevel@tonic-gate if (isbad) { 37497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37507c478bd9Sstevel@tonic-gate "After\nrunning fsck, unlock the " 37517c478bd9Sstevel@tonic-gate "filesystem and ")); 37527c478bd9Sstevel@tonic-gate } else { 37537c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37547c478bd9Sstevel@tonic-gate "Unlock the filesystem\nand ")); 37557c478bd9Sstevel@tonic-gate } 37567c478bd9Sstevel@tonic-gate 37577c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 37587c478bd9Sstevel@tonic-gate "re-enable writing with\nthe following " 37597c478bd9Sstevel@tonic-gate "command:\n\n\tlockfs -u %s\n\n"), 37607c478bd9Sstevel@tonic-gate directory); 37617c478bd9Sstevel@tonic-gate } 37627c478bd9Sstevel@tonic-gate } 37637c478bd9Sstevel@tonic-gate 37647c478bd9Sstevel@tonic-gate exit(exitstatus); 37657c478bd9Sstevel@tonic-gate } 37667c478bd9Sstevel@tonic-gate 37677c478bd9Sstevel@tonic-gate void 37687c478bd9Sstevel@tonic-gate randomgeneration() 37697c478bd9Sstevel@tonic-gate { 37707c478bd9Sstevel@tonic-gate int i; 37717c478bd9Sstevel@tonic-gate struct dinode *dp; 37727c478bd9Sstevel@tonic-gate 37737c478bd9Sstevel@tonic-gate /* 37747c478bd9Sstevel@tonic-gate * always perform fsirand(1) function... newfs will notice that 37757c478bd9Sstevel@tonic-gate * the inodes have been randomized and will not call fsirand itself 37767c478bd9Sstevel@tonic-gate */ 37777c478bd9Sstevel@tonic-gate for (i = 0, dp = zino; i < sblock.fs_inopb; ++i, ++dp) 37787c478bd9Sstevel@tonic-gate IRANDOMIZE(&dp->di_ic); 37797c478bd9Sstevel@tonic-gate } 37807c478bd9Sstevel@tonic-gate 37817c478bd9Sstevel@tonic-gate /* 37827c478bd9Sstevel@tonic-gate * Check the size of the summary information. 37837c478bd9Sstevel@tonic-gate * Fields in sblock are not changed in this function. 37847c478bd9Sstevel@tonic-gate * 37857c478bd9Sstevel@tonic-gate * For an 8K filesystem block, the maximum number of cylinder groups is 16384. 37867c478bd9Sstevel@tonic-gate * MAXCSBUFS {32} * 8K {FS block size} 37877c478bd9Sstevel@tonic-gate * divided by (sizeof csum) {16} 37887c478bd9Sstevel@tonic-gate * 37897c478bd9Sstevel@tonic-gate * Note that MAXCSBUFS is not used in the kernel; as of Solaris 2.6 build 32, 37907c478bd9Sstevel@tonic-gate * this is the only place where it's referenced. 37917c478bd9Sstevel@tonic-gate */ 37927c478bd9Sstevel@tonic-gate void 37937c478bd9Sstevel@tonic-gate checksummarysize() 37947c478bd9Sstevel@tonic-gate { 37957c478bd9Sstevel@tonic-gate diskaddr_t dmax; 37967c478bd9Sstevel@tonic-gate diskaddr_t dmin; 37977c478bd9Sstevel@tonic-gate int64_t cg0frags; 37987c478bd9Sstevel@tonic-gate int64_t cg0blocks; 37997c478bd9Sstevel@tonic-gate int64_t maxncg; 38007c478bd9Sstevel@tonic-gate int64_t maxfrags; 38017c478bd9Sstevel@tonic-gate uint64_t fs_size; 38027c478bd9Sstevel@tonic-gate uint64_t maxfs_blocks; /* filesystem blocks for max filesystem size */ 38037c478bd9Sstevel@tonic-gate 38047c478bd9Sstevel@tonic-gate /* 38057c478bd9Sstevel@tonic-gate * compute the maximum summary info size 38067c478bd9Sstevel@tonic-gate */ 38077c478bd9Sstevel@tonic-gate dmin = cgdmin(&sblock, 0); 38087c478bd9Sstevel@tonic-gate dmax = cgbase(&sblock, 0) + sblock.fs_fpg; 38097c478bd9Sstevel@tonic-gate fs_size = (grow) ? grow_fs_size : sblock.fs_size; 38107c478bd9Sstevel@tonic-gate if (dmax > fs_size) 38117c478bd9Sstevel@tonic-gate dmax = fs_size; 38127c478bd9Sstevel@tonic-gate cg0frags = dmax - dmin; 38137c478bd9Sstevel@tonic-gate cg0blocks = cg0frags / sblock.fs_frag; 38147c478bd9Sstevel@tonic-gate cg0frags = cg0blocks * sblock.fs_frag; 38157c478bd9Sstevel@tonic-gate maxncg = (longlong_t)cg0blocks * 38167c478bd9Sstevel@tonic-gate (longlong_t)(sblock.fs_bsize / sizeof (struct csum)); 38177c478bd9Sstevel@tonic-gate 38187c478bd9Sstevel@tonic-gate maxfs_blocks = FS_MAX; 38197c478bd9Sstevel@tonic-gate 38207c478bd9Sstevel@tonic-gate if (maxncg > ((longlong_t)maxfs_blocks / (longlong_t)sblock.fs_fpg) + 1) 38217c478bd9Sstevel@tonic-gate maxncg = ((longlong_t)maxfs_blocks / 38227c478bd9Sstevel@tonic-gate (longlong_t)sblock.fs_fpg) + 1; 38237c478bd9Sstevel@tonic-gate 38247c478bd9Sstevel@tonic-gate maxfrags = maxncg * (longlong_t)sblock.fs_fpg; 38257c478bd9Sstevel@tonic-gate 38267c478bd9Sstevel@tonic-gate if (maxfrags > maxfs_blocks) 38277c478bd9Sstevel@tonic-gate maxfrags = maxfs_blocks; 38287c478bd9Sstevel@tonic-gate 38297c478bd9Sstevel@tonic-gate 38307c478bd9Sstevel@tonic-gate /* 38317c478bd9Sstevel@tonic-gate * remember for later processing in extendsummaryinfo() 38327c478bd9Sstevel@tonic-gate */ 38337c478bd9Sstevel@tonic-gate if (test) 38347c478bd9Sstevel@tonic-gate grow_sifrag = dmin + (cg0blocks * sblock.fs_frag); 38357c478bd9Sstevel@tonic-gate if (testfrags == 0) 38367c478bd9Sstevel@tonic-gate testfrags = cg0frags; 38377c478bd9Sstevel@tonic-gate if (testforce) 38387c478bd9Sstevel@tonic-gate if (testfrags > cg0frags) { 38397c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 38407c478bd9Sstevel@tonic-gate gettext("Too many test frags (%lld); " 38417c478bd9Sstevel@tonic-gate "try %lld\n"), testfrags, cg0frags); 38427c478bd9Sstevel@tonic-gate lockexit(32); 38437c478bd9Sstevel@tonic-gate } 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate /* 38467c478bd9Sstevel@tonic-gate * if summary info is too large (too many cg's) tell the user and exit 38477c478bd9Sstevel@tonic-gate */ 38487c478bd9Sstevel@tonic-gate if ((longlong_t)sblock.fs_size > maxfrags) { 38497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 38507c478bd9Sstevel@tonic-gate "Too many cylinder groups with %llu sectors;\n try " 38517c478bd9Sstevel@tonic-gate "increasing cgsize, or decreasing fssize to %llu\n"), 38527c478bd9Sstevel@tonic-gate fsbtodb(&sblock, (uint64_t)sblock.fs_size), 38537c478bd9Sstevel@tonic-gate fsbtodb(&sblock, (uint64_t)maxfrags)); 38547c478bd9Sstevel@tonic-gate lockexit(32); 38557c478bd9Sstevel@tonic-gate } 38567c478bd9Sstevel@tonic-gate } 38577c478bd9Sstevel@tonic-gate 3858*6451fdbcSvsakar /* 3859*6451fdbcSvsakar * checksblock() has two uses: 3860*6451fdbcSvsakar * - One is to sanity test the superblock and is used when newfs(1M) 3861*6451fdbcSvsakar * is invoked with the "-N" option. If any discrepancy was found, 3862*6451fdbcSvsakar * just return whatever error was found and do not exit. 3863*6451fdbcSvsakar * - the other use of it is in places where you expect the superblock 3864*6451fdbcSvsakar * to be sane, and if it isn't, then we exit. 3865*6451fdbcSvsakar * Which of the above two actions to take is indicated with the second argument. 3866*6451fdbcSvsakar */ 38677c478bd9Sstevel@tonic-gate 3868*6451fdbcSvsakar int 3869*6451fdbcSvsakar checksblock(struct fs sb, int proceed) 3870*6451fdbcSvsakar { 3871*6451fdbcSvsakar int err = 0; 3872*6451fdbcSvsakar char *errmsg; 3873*6451fdbcSvsakar 3874*6451fdbcSvsakar if ((sb.fs_magic != FS_MAGIC) && (sb.fs_magic != MTB_UFS_MAGIC)) { 3875*6451fdbcSvsakar err = 1; 3876*6451fdbcSvsakar errmsg = gettext("Bad superblock; magic number wrong\n"); 3877*6451fdbcSvsakar } else if ((sb.fs_magic == FS_MAGIC && 3878*6451fdbcSvsakar (sb.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 && 3879*6451fdbcSvsakar sb.fs_version != UFS_VERSION_MIN)) || 3880*6451fdbcSvsakar (sb.fs_magic == MTB_UFS_MAGIC && 3881*6451fdbcSvsakar (sb.fs_version > MTB_UFS_VERSION_1 || 3882*6451fdbcSvsakar sb.fs_version < MTB_UFS_VERSION_MIN))) { 3883*6451fdbcSvsakar err = 2; 3884*6451fdbcSvsakar errmsg = gettext("Unrecognized version of UFS\n"); 3885*6451fdbcSvsakar } else if (sb.fs_ncg < 1) { 3886*6451fdbcSvsakar err = 3; 3887*6451fdbcSvsakar errmsg = gettext("Bad superblock; ncg out of range\n"); 3888*6451fdbcSvsakar } else if (sb.fs_cpg < 1) { 3889*6451fdbcSvsakar err = 4; 3890*6451fdbcSvsakar errmsg = gettext("Bad superblock; cpg out of range\n"); 3891*6451fdbcSvsakar } else if (sb.fs_ncg * sb.fs_cpg < sb.fs_ncyl || 3892*6451fdbcSvsakar (sb.fs_ncg - 1) * sb.fs_cpg >= sb.fs_ncyl) { 3893*6451fdbcSvsakar err = 5; 3894*6451fdbcSvsakar errmsg = gettext("Bad superblock; ncyl out of range\n"); 3895*6451fdbcSvsakar } else if (sb.fs_sbsize <= 0 || sb.fs_sbsize > sb.fs_bsize) { 3896*6451fdbcSvsakar err = 6; 3897*6451fdbcSvsakar errmsg = gettext("Bad superblock; superblock size out of range\n"); 3898*6451fdbcSvsakar } 3899*6451fdbcSvsakar 3900*6451fdbcSvsakar 3901*6451fdbcSvsakar if (proceed) { 3902*6451fdbcSvsakar if (err) dprintf(("%s", errmsg)); 3903*6451fdbcSvsakar return (err); 3904*6451fdbcSvsakar } 3905*6451fdbcSvsakar 3906*6451fdbcSvsakar if (err) { 3907*6451fdbcSvsakar fprintf(stderr, "%s", errmsg); 39087c478bd9Sstevel@tonic-gate lockexit(32); 39097c478bd9Sstevel@tonic-gate } 39107c478bd9Sstevel@tonic-gate } 39117c478bd9Sstevel@tonic-gate 39127c478bd9Sstevel@tonic-gate /* 39137c478bd9Sstevel@tonic-gate * Roll the embedded log, if any, and set up the global variables 39147c478bd9Sstevel@tonic-gate * islog, islogok and isufslog. 39157c478bd9Sstevel@tonic-gate */ 39167c478bd9Sstevel@tonic-gate static void 39177c478bd9Sstevel@tonic-gate logsetup(char *devstr) 39187c478bd9Sstevel@tonic-gate { 39197c478bd9Sstevel@tonic-gate void *buf, *ud_buf; 39207c478bd9Sstevel@tonic-gate extent_block_t *ebp; 39217c478bd9Sstevel@tonic-gate ml_unit_t *ul; 39227c478bd9Sstevel@tonic-gate ml_odunit_t *ud; 39237c478bd9Sstevel@tonic-gate 39247c478bd9Sstevel@tonic-gate /* 39257c478bd9Sstevel@tonic-gate * Does the superblock indicate that we are supposed to have a log ? 39267c478bd9Sstevel@tonic-gate */ 39277c478bd9Sstevel@tonic-gate if (sblock.fs_logbno == 0) { 39287c478bd9Sstevel@tonic-gate /* 39297c478bd9Sstevel@tonic-gate * No log present, nothing to do. 39307c478bd9Sstevel@tonic-gate */ 39317c478bd9Sstevel@tonic-gate islogok = 0; 39327c478bd9Sstevel@tonic-gate islog = 0; 39337c478bd9Sstevel@tonic-gate isufslog = 0; 39347c478bd9Sstevel@tonic-gate return; 39357c478bd9Sstevel@tonic-gate } else { 39367c478bd9Sstevel@tonic-gate /* 39377c478bd9Sstevel@tonic-gate * There's a log in a yet unknown state, attempt to roll it. 39387c478bd9Sstevel@tonic-gate */ 39397c478bd9Sstevel@tonic-gate islog = 1; 39407c478bd9Sstevel@tonic-gate islogok = 0; 39417c478bd9Sstevel@tonic-gate isufslog = 0; 39427c478bd9Sstevel@tonic-gate 39437c478bd9Sstevel@tonic-gate /* 39447c478bd9Sstevel@tonic-gate * We failed to roll the log, bail out. 39457c478bd9Sstevel@tonic-gate */ 39467c478bd9Sstevel@tonic-gate if (rl_roll_log(devstr) != RL_SUCCESS) 39477c478bd9Sstevel@tonic-gate return; 39487c478bd9Sstevel@tonic-gate 39497c478bd9Sstevel@tonic-gate isufslog = 1; 39507c478bd9Sstevel@tonic-gate 39517c478bd9Sstevel@tonic-gate /* log is not okay; check the fs */ 39527c478bd9Sstevel@tonic-gate if ((FSOKAY != (sblock.fs_state + sblock.fs_time)) || 39537c478bd9Sstevel@tonic-gate (sblock.fs_clean != FSLOG)) 39547c478bd9Sstevel@tonic-gate return; 39557c478bd9Sstevel@tonic-gate 39567c478bd9Sstevel@tonic-gate /* get the log allocation block */ 39577c478bd9Sstevel@tonic-gate buf = (void *)malloc(DEV_BSIZE); 39587c478bd9Sstevel@tonic-gate if (buf == (void *) NULL) 39597c478bd9Sstevel@tonic-gate return; 39607c478bd9Sstevel@tonic-gate 39617c478bd9Sstevel@tonic-gate ud_buf = (void *)malloc(DEV_BSIZE); 39627c478bd9Sstevel@tonic-gate if (ud_buf == (void *) NULL) { 39637c478bd9Sstevel@tonic-gate free(buf); 39647c478bd9Sstevel@tonic-gate return; 39657c478bd9Sstevel@tonic-gate } 39667c478bd9Sstevel@tonic-gate 39677c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)logbtodb(&sblock, sblock.fs_logbno), 39687c478bd9Sstevel@tonic-gate DEV_BSIZE, buf); 39697c478bd9Sstevel@tonic-gate ebp = (extent_block_t *)buf; 39707c478bd9Sstevel@tonic-gate 39717c478bd9Sstevel@tonic-gate /* log allocation block is not okay; check the fs */ 39727c478bd9Sstevel@tonic-gate if (ebp->type != LUFS_EXTENTS) { 39737c478bd9Sstevel@tonic-gate free(buf); 39747c478bd9Sstevel@tonic-gate free(ud_buf); 39757c478bd9Sstevel@tonic-gate return; 39767c478bd9Sstevel@tonic-gate } 39777c478bd9Sstevel@tonic-gate 39787c478bd9Sstevel@tonic-gate /* get the log state block(s) */ 39797c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)logbtodb(&sblock, ebp->extents[0].pbno), 39807c478bd9Sstevel@tonic-gate DEV_BSIZE, ud_buf); 39817c478bd9Sstevel@tonic-gate ud = (ml_odunit_t *)ud_buf; 39827c478bd9Sstevel@tonic-gate ul = (ml_unit_t *)malloc(sizeof (*ul)); 39837c478bd9Sstevel@tonic-gate ul->un_ondisk = *ud; 39847c478bd9Sstevel@tonic-gate 39857c478bd9Sstevel@tonic-gate /* log state is okay */ 39867c478bd9Sstevel@tonic-gate if ((ul->un_chksum == ul->un_head_ident + ul->un_tail_ident) && 39877c478bd9Sstevel@tonic-gate (ul->un_version == LUFS_VERSION_LATEST) && 39887c478bd9Sstevel@tonic-gate (ul->un_badlog == 0)) 39897c478bd9Sstevel@tonic-gate islogok = 1; 39907c478bd9Sstevel@tonic-gate free(ud_buf); 39917c478bd9Sstevel@tonic-gate free(buf); 39927c478bd9Sstevel@tonic-gate free(ul); 39937c478bd9Sstevel@tonic-gate } 39947c478bd9Sstevel@tonic-gate } 39957c478bd9Sstevel@tonic-gate 39967c478bd9Sstevel@tonic-gate void 39977c478bd9Sstevel@tonic-gate growinit(char *devstr) 39987c478bd9Sstevel@tonic-gate { 39997c478bd9Sstevel@tonic-gate int i; 40007c478bd9Sstevel@tonic-gate char buf[DEV_BSIZE]; 40017c478bd9Sstevel@tonic-gate 40027c478bd9Sstevel@tonic-gate /* 40037c478bd9Sstevel@tonic-gate * Read and verify the superblock 40047c478bd9Sstevel@tonic-gate */ 40057c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock); 4006*6451fdbcSvsakar (void) checksblock(sblock, 0); 40077c478bd9Sstevel@tonic-gate if (sblock.fs_postblformat != FS_DYNAMICPOSTBLFMT) { 40087c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 40097c478bd9Sstevel@tonic-gate gettext("old file system format; can't growfs\n")); 40107c478bd9Sstevel@tonic-gate lockexit(32); 40117c478bd9Sstevel@tonic-gate } 40127c478bd9Sstevel@tonic-gate 40137c478bd9Sstevel@tonic-gate /* 40147c478bd9Sstevel@tonic-gate * can't shrink a file system 40157c478bd9Sstevel@tonic-gate */ 40167c478bd9Sstevel@tonic-gate grow_fssize = fsbtodb(&sblock, (uint64_t)sblock.fs_size); 40177c478bd9Sstevel@tonic-gate if (fssize_db < grow_fssize) { 40187c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 40197c478bd9Sstevel@tonic-gate gettext("%lld sectors < current size of %lld sectors\n"), 40207c478bd9Sstevel@tonic-gate fssize_db, grow_fssize); 40217c478bd9Sstevel@tonic-gate lockexit(32); 40227c478bd9Sstevel@tonic-gate } 40237c478bd9Sstevel@tonic-gate 40247c478bd9Sstevel@tonic-gate /* 40257c478bd9Sstevel@tonic-gate * can't grow a system to over a terabyte unless it was set up 40267c478bd9Sstevel@tonic-gate * as an MTB UFS file system. 40277c478bd9Sstevel@tonic-gate */ 40287c478bd9Sstevel@tonic-gate if (mtb == 'y' && sblock.fs_magic != MTB_UFS_MAGIC) { 40297c478bd9Sstevel@tonic-gate if (fssize_db >= SECTORS_PER_TERABYTE) { 40307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 40317c478bd9Sstevel@tonic-gate "File system was not set up with the multi-terabyte format.\n")); 40327c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 40337c478bd9Sstevel@tonic-gate "Its size cannot be increased to a terabyte or more.\n")); 40347c478bd9Sstevel@tonic-gate } else { 40357c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 40367c478bd9Sstevel@tonic-gate "Cannot convert file system to multi-terabyte format.\n")); 40377c478bd9Sstevel@tonic-gate } 40387c478bd9Sstevel@tonic-gate lockexit(32); 40397c478bd9Sstevel@tonic-gate } 40407c478bd9Sstevel@tonic-gate 40417c478bd9Sstevel@tonic-gate logsetup(devstr); 40427c478bd9Sstevel@tonic-gate 40437c478bd9Sstevel@tonic-gate /* 40447c478bd9Sstevel@tonic-gate * can't growfs when logging device has errors 40457c478bd9Sstevel@tonic-gate */ 40467c478bd9Sstevel@tonic-gate if ((islog && !islogok) || 40477c478bd9Sstevel@tonic-gate ((FSOKAY == (sblock.fs_state + sblock.fs_time)) && 40487c478bd9Sstevel@tonic-gate (sblock.fs_clean == FSLOG && !islog))) { 40497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 40507c478bd9Sstevel@tonic-gate gettext("logging device has errors; can't growfs\n")); 40517c478bd9Sstevel@tonic-gate lockexit(32); 40527c478bd9Sstevel@tonic-gate } 40537c478bd9Sstevel@tonic-gate 40547c478bd9Sstevel@tonic-gate /* 40557c478bd9Sstevel@tonic-gate * disable ufs logging for growing 40567c478bd9Sstevel@tonic-gate */ 40577c478bd9Sstevel@tonic-gate if (isufslog) { 40587c478bd9Sstevel@tonic-gate if (rl_log_control(devstr, _FIOLOGDISABLE) != RL_SUCCESS) { 40597c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 40607c478bd9Sstevel@tonic-gate "failed to disable logging\n")); 40617c478bd9Sstevel@tonic-gate lockexit(32); 40627c478bd9Sstevel@tonic-gate } 40637c478bd9Sstevel@tonic-gate islog = 0; 40647c478bd9Sstevel@tonic-gate waslog = 1; 40657c478bd9Sstevel@tonic-gate } 40667c478bd9Sstevel@tonic-gate 40677c478bd9Sstevel@tonic-gate /* 40687c478bd9Sstevel@tonic-gate * if mounted write lock the file system to be grown 40697c478bd9Sstevel@tonic-gate */ 40707c478bd9Sstevel@tonic-gate if (ismounted) 40717c478bd9Sstevel@tonic-gate wlockfs(); 40727c478bd9Sstevel@tonic-gate 40737c478bd9Sstevel@tonic-gate /* 40747c478bd9Sstevel@tonic-gate * refresh dynamic superblock state - disabling logging will have 40757c478bd9Sstevel@tonic-gate * changed the amount of free space available in the file system 40767c478bd9Sstevel@tonic-gate */ 40777c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock); 40787c478bd9Sstevel@tonic-gate 40797c478bd9Sstevel@tonic-gate /* 40807c478bd9Sstevel@tonic-gate * make sure device is big enough 40817c478bd9Sstevel@tonic-gate */ 40827c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)fssize_db - 1, DEV_BSIZE, buf); 40837c478bd9Sstevel@tonic-gate wtfs((diskaddr_t)fssize_db - 1, DEV_BSIZE, buf); 40847c478bd9Sstevel@tonic-gate 40857c478bd9Sstevel@tonic-gate /* 40867c478bd9Sstevel@tonic-gate * read current summary information 40877c478bd9Sstevel@tonic-gate */ 40887c478bd9Sstevel@tonic-gate grow_fscs = read_summaryinfo(&sblock); 40897c478bd9Sstevel@tonic-gate 40907c478bd9Sstevel@tonic-gate /* 40917c478bd9Sstevel@tonic-gate * save some current size related fields from the superblock 40927c478bd9Sstevel@tonic-gate * These are used in extendsummaryinfo() 40937c478bd9Sstevel@tonic-gate */ 40947c478bd9Sstevel@tonic-gate grow_fs_size = sblock.fs_size; 40957c478bd9Sstevel@tonic-gate grow_fs_ncg = sblock.fs_ncg; 40967c478bd9Sstevel@tonic-gate grow_fs_csaddr = (diskaddr_t)sblock.fs_csaddr; 40977c478bd9Sstevel@tonic-gate grow_fs_cssize = sblock.fs_cssize; 40987c478bd9Sstevel@tonic-gate 40997c478bd9Sstevel@tonic-gate /* 41007c478bd9Sstevel@tonic-gate * save and reset the clean flag 41017c478bd9Sstevel@tonic-gate */ 41027c478bd9Sstevel@tonic-gate if (FSOKAY == (sblock.fs_state + sblock.fs_time)) 41037c478bd9Sstevel@tonic-gate grow_fs_clean = sblock.fs_clean; 41047c478bd9Sstevel@tonic-gate else 41057c478bd9Sstevel@tonic-gate grow_fs_clean = FSBAD; 41067c478bd9Sstevel@tonic-gate sblock.fs_clean = FSBAD; 41077c478bd9Sstevel@tonic-gate sblock.fs_state = FSOKAY - sblock.fs_time; 41087c478bd9Sstevel@tonic-gate isbad = 1; 41097c478bd9Sstevel@tonic-gate wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock); 41107c478bd9Sstevel@tonic-gate } 41117c478bd9Sstevel@tonic-gate 41127c478bd9Sstevel@tonic-gate void 41137c478bd9Sstevel@tonic-gate checkdev(char *rdev, char *bdev) 41147c478bd9Sstevel@tonic-gate { 41157c478bd9Sstevel@tonic-gate struct stat64 statarea; 41167c478bd9Sstevel@tonic-gate 41177c478bd9Sstevel@tonic-gate if (stat64(bdev, &statarea) < 0) { 41187c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("can't check mount point; ")); 41197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("can't stat %s\n"), bdev); 41207c478bd9Sstevel@tonic-gate lockexit(32); 41217c478bd9Sstevel@tonic-gate } 41227c478bd9Sstevel@tonic-gate if ((statarea.st_mode & S_IFMT) != S_IFBLK) { 41237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 41247c478bd9Sstevel@tonic-gate "can't check mount point; %s is not a block device\n"), 41257c478bd9Sstevel@tonic-gate bdev); 41267c478bd9Sstevel@tonic-gate lockexit(32); 41277c478bd9Sstevel@tonic-gate } 41287c478bd9Sstevel@tonic-gate if (stat64(rdev, &statarea) < 0) { 41297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("can't stat %s\n"), rdev); 41307c478bd9Sstevel@tonic-gate lockexit(32); 41317c478bd9Sstevel@tonic-gate } 41327c478bd9Sstevel@tonic-gate if ((statarea.st_mode & S_IFMT) != S_IFCHR) { 41337c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 41347c478bd9Sstevel@tonic-gate gettext("%s is not a character device\n"), rdev); 41357c478bd9Sstevel@tonic-gate lockexit(32); 41367c478bd9Sstevel@tonic-gate } 41377c478bd9Sstevel@tonic-gate } 41387c478bd9Sstevel@tonic-gate 41397c478bd9Sstevel@tonic-gate void 41407c478bd9Sstevel@tonic-gate checkmount(struct mnttab *mntp, char *bdevname) 41417c478bd9Sstevel@tonic-gate { 41427c478bd9Sstevel@tonic-gate struct stat64 statdir; 41437c478bd9Sstevel@tonic-gate struct stat64 statdev; 41447c478bd9Sstevel@tonic-gate 41457c478bd9Sstevel@tonic-gate if (strcmp(bdevname, mntp->mnt_special) == 0) { 41467c478bd9Sstevel@tonic-gate if (stat64(mntp->mnt_mountp, &statdir) == -1) { 41477c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("can't stat %s\n"), 41487c478bd9Sstevel@tonic-gate mntp->mnt_mountp); 41497c478bd9Sstevel@tonic-gate lockexit(32); 41507c478bd9Sstevel@tonic-gate } 41517c478bd9Sstevel@tonic-gate if (stat64(mntp->mnt_special, &statdev) == -1) { 41527c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("can't stat %s\n"), 41537c478bd9Sstevel@tonic-gate mntp->mnt_special); 41547c478bd9Sstevel@tonic-gate lockexit(32); 41557c478bd9Sstevel@tonic-gate } 41567c478bd9Sstevel@tonic-gate if (statdir.st_dev != statdev.st_rdev) { 41577c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 41587c478bd9Sstevel@tonic-gate "%s is not mounted on %s; mnttab(4) wrong\n"), 41597c478bd9Sstevel@tonic-gate mntp->mnt_special, mntp->mnt_mountp); 41607c478bd9Sstevel@tonic-gate lockexit(32); 41617c478bd9Sstevel@tonic-gate } 41627c478bd9Sstevel@tonic-gate ismounted = 1; 41637c478bd9Sstevel@tonic-gate if (directory) { 41647c478bd9Sstevel@tonic-gate if (strcmp(mntp->mnt_mountp, directory) != 0) { 41657c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 41667c478bd9Sstevel@tonic-gate gettext("%s is mounted on %s, not %s\n"), 4167355d6bb5Sswilcox bdevname, mntp->mnt_mountp, directory); 41687c478bd9Sstevel@tonic-gate lockexit(32); 41697c478bd9Sstevel@tonic-gate } 41707c478bd9Sstevel@tonic-gate } else { 41717c478bd9Sstevel@tonic-gate if (grow) 41727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 4173355d6bb5Sswilcox "%s is mounted on %s; can't growfs\n"), 4174355d6bb5Sswilcox bdevname, mntp->mnt_mountp); 41757c478bd9Sstevel@tonic-gate else 41767c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 4177355d6bb5Sswilcox gettext("%s is mounted, can't mkfs\n"), 4178355d6bb5Sswilcox bdevname); 41797c478bd9Sstevel@tonic-gate lockexit(32); 41807c478bd9Sstevel@tonic-gate } 41817c478bd9Sstevel@tonic-gate } 41827c478bd9Sstevel@tonic-gate } 41837c478bd9Sstevel@tonic-gate 41847c478bd9Sstevel@tonic-gate struct dinode *dibuf = 0; 41857c478bd9Sstevel@tonic-gate diskaddr_t difrag = 0; 41867c478bd9Sstevel@tonic-gate 41877c478bd9Sstevel@tonic-gate struct dinode * 41887c478bd9Sstevel@tonic-gate gdinode(ino_t ino) 41897c478bd9Sstevel@tonic-gate { 41907c478bd9Sstevel@tonic-gate /* 41917c478bd9Sstevel@tonic-gate * read the block of inodes containing inode number ino 41927c478bd9Sstevel@tonic-gate */ 41937c478bd9Sstevel@tonic-gate if (dibuf == 0) 41947c478bd9Sstevel@tonic-gate dibuf = (struct dinode *)malloc((unsigned)sblock.fs_bsize); 41957c478bd9Sstevel@tonic-gate if (itod(&sblock, ino) != difrag) { 41967c478bd9Sstevel@tonic-gate difrag = itod(&sblock, ino); 41977c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, (uint64_t)difrag), (int)sblock.fs_bsize, 41987c478bd9Sstevel@tonic-gate (char *)dibuf); 41997c478bd9Sstevel@tonic-gate } 42007c478bd9Sstevel@tonic-gate return (dibuf + (ino % INOPB(&sblock))); 42017c478bd9Sstevel@tonic-gate } 42027c478bd9Sstevel@tonic-gate 42037c478bd9Sstevel@tonic-gate /* 42047c478bd9Sstevel@tonic-gate * structure that manages the frags we need for extended summary info 42057c478bd9Sstevel@tonic-gate * These frags can be: 42067c478bd9Sstevel@tonic-gate * free 42077c478bd9Sstevel@tonic-gate * data block 42087c478bd9Sstevel@tonic-gate * alloc block 42097c478bd9Sstevel@tonic-gate */ 42107c478bd9Sstevel@tonic-gate struct csfrag { 42117c478bd9Sstevel@tonic-gate struct csfrag *next; /* next entry */ 42127c478bd9Sstevel@tonic-gate daddr32_t ofrag; /* old frag */ 42137c478bd9Sstevel@tonic-gate daddr32_t nfrag; /* new frag */ 42147c478bd9Sstevel@tonic-gate long cylno; /* cylno of nfrag */ 42157c478bd9Sstevel@tonic-gate long frags; /* number of frags */ 42167c478bd9Sstevel@tonic-gate long size; /* size in bytes */ 42177c478bd9Sstevel@tonic-gate ino_t ino; /* inode number */ 42187c478bd9Sstevel@tonic-gate long fixed; /* Boolean - Already fixed? */ 42197c478bd9Sstevel@tonic-gate }; 42207c478bd9Sstevel@tonic-gate struct csfrag *csfrag; /* state unknown */ 42217c478bd9Sstevel@tonic-gate struct csfrag *csfragino; /* frags belonging to an inode */ 42227c478bd9Sstevel@tonic-gate struct csfrag *csfragfree; /* frags that are free */ 42237c478bd9Sstevel@tonic-gate 42247c478bd9Sstevel@tonic-gate daddr32_t maxcsfrag = 0; /* maximum in range */ 42257c478bd9Sstevel@tonic-gate daddr32_t mincsfrag = 0x7fffffff; /* minimum in range */ 42267c478bd9Sstevel@tonic-gate 42277c478bd9Sstevel@tonic-gate int 42287c478bd9Sstevel@tonic-gate csfraginrange(daddr32_t frag) 42297c478bd9Sstevel@tonic-gate { 42307c478bd9Sstevel@tonic-gate return ((frag >= mincsfrag) && (frag <= maxcsfrag)); 42317c478bd9Sstevel@tonic-gate } 42327c478bd9Sstevel@tonic-gate 42337c478bd9Sstevel@tonic-gate struct csfrag * 42347c478bd9Sstevel@tonic-gate findcsfrag(daddr32_t frag, struct csfrag **cfap) 42357c478bd9Sstevel@tonic-gate { 42367c478bd9Sstevel@tonic-gate struct csfrag *cfp; 42377c478bd9Sstevel@tonic-gate 42387c478bd9Sstevel@tonic-gate if (!csfraginrange(frag)) 42397c478bd9Sstevel@tonic-gate return (NULL); 42407c478bd9Sstevel@tonic-gate 42417c478bd9Sstevel@tonic-gate for (cfp = *cfap; cfp; cfp = cfp->next) 42427c478bd9Sstevel@tonic-gate if (cfp->ofrag == frag) 42437c478bd9Sstevel@tonic-gate return (cfp); 42447c478bd9Sstevel@tonic-gate return (NULL); 42457c478bd9Sstevel@tonic-gate } 42467c478bd9Sstevel@tonic-gate 42477c478bd9Sstevel@tonic-gate void 42487c478bd9Sstevel@tonic-gate checkindirect(ino_t ino, daddr32_t *fragsp, daddr32_t frag, int level) 42497c478bd9Sstevel@tonic-gate { 42507c478bd9Sstevel@tonic-gate int i; 42517c478bd9Sstevel@tonic-gate int ne = sblock.fs_bsize / sizeof (daddr32_t); 42527c478bd9Sstevel@tonic-gate daddr32_t fsb[MAXBSIZE / sizeof (daddr32_t)]; 42537c478bd9Sstevel@tonic-gate 42547c478bd9Sstevel@tonic-gate if (frag == 0) 42557c478bd9Sstevel@tonic-gate return; 42567c478bd9Sstevel@tonic-gate 42577c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, frag), (int)sblock.fs_bsize, 42587c478bd9Sstevel@tonic-gate (char *)fsb); 42597c478bd9Sstevel@tonic-gate 42607c478bd9Sstevel@tonic-gate checkdirect(ino, fragsp, fsb, sblock.fs_bsize / sizeof (daddr32_t)); 42617c478bd9Sstevel@tonic-gate 42627c478bd9Sstevel@tonic-gate if (level) 42637c478bd9Sstevel@tonic-gate for (i = 0; i < ne && *fragsp; ++i) 42647c478bd9Sstevel@tonic-gate checkindirect(ino, fragsp, fsb[i], level-1); 42657c478bd9Sstevel@tonic-gate } 42667c478bd9Sstevel@tonic-gate 42677c478bd9Sstevel@tonic-gate void 42687c478bd9Sstevel@tonic-gate addcsfrag(ino_t ino, daddr32_t frag, struct csfrag **cfap) 42697c478bd9Sstevel@tonic-gate { 42707c478bd9Sstevel@tonic-gate struct csfrag *cfp, *curr, *prev; 42717c478bd9Sstevel@tonic-gate 42727c478bd9Sstevel@tonic-gate /* 42737c478bd9Sstevel@tonic-gate * establish a range for faster checking in csfraginrange() 42747c478bd9Sstevel@tonic-gate */ 42757c478bd9Sstevel@tonic-gate if (frag > maxcsfrag) 42767c478bd9Sstevel@tonic-gate maxcsfrag = frag; 42777c478bd9Sstevel@tonic-gate if (frag < mincsfrag) 42787c478bd9Sstevel@tonic-gate mincsfrag = frag; 42797c478bd9Sstevel@tonic-gate 42807c478bd9Sstevel@tonic-gate /* 42817c478bd9Sstevel@tonic-gate * if this frag belongs to an inode and is not the start of a block 42827c478bd9Sstevel@tonic-gate * then see if it is part of a frag range for this inode 42837c478bd9Sstevel@tonic-gate */ 42847c478bd9Sstevel@tonic-gate if (ino && (frag % sblock.fs_frag)) 42857c478bd9Sstevel@tonic-gate for (cfp = *cfap; cfp; cfp = cfp->next) { 42867c478bd9Sstevel@tonic-gate if (ino != cfp->ino) 42877c478bd9Sstevel@tonic-gate continue; 42887c478bd9Sstevel@tonic-gate if (frag != cfp->ofrag + cfp->frags) 42897c478bd9Sstevel@tonic-gate continue; 42907c478bd9Sstevel@tonic-gate cfp->frags++; 42917c478bd9Sstevel@tonic-gate cfp->size += sblock.fs_fsize; 42927c478bd9Sstevel@tonic-gate return; 42937c478bd9Sstevel@tonic-gate } 42947c478bd9Sstevel@tonic-gate /* 42957c478bd9Sstevel@tonic-gate * allocate a csfrag entry and insert it in an increasing order into the 42967c478bd9Sstevel@tonic-gate * specified list 42977c478bd9Sstevel@tonic-gate */ 42987c478bd9Sstevel@tonic-gate cfp = (struct csfrag *)calloc(1, sizeof (struct csfrag)); 42997c478bd9Sstevel@tonic-gate cfp->ino = ino; 43007c478bd9Sstevel@tonic-gate cfp->ofrag = frag; 43017c478bd9Sstevel@tonic-gate cfp->frags = 1; 43027c478bd9Sstevel@tonic-gate cfp->size = sblock.fs_fsize; 43037c478bd9Sstevel@tonic-gate for (prev = NULL, curr = *cfap; curr != NULL; 43047c478bd9Sstevel@tonic-gate prev = curr, curr = curr->next) { 43057c478bd9Sstevel@tonic-gate if (frag < curr->ofrag) { 43067c478bd9Sstevel@tonic-gate cfp->next = curr; 43077c478bd9Sstevel@tonic-gate if (prev) 43087c478bd9Sstevel@tonic-gate prev->next = cfp; /* middle element */ 43097c478bd9Sstevel@tonic-gate else 43107c478bd9Sstevel@tonic-gate *cfap = cfp; /* first element */ 43117c478bd9Sstevel@tonic-gate break; 43127c478bd9Sstevel@tonic-gate } 43137c478bd9Sstevel@tonic-gate if (curr->next == NULL) { 43147c478bd9Sstevel@tonic-gate curr->next = cfp; /* last element */ 43157c478bd9Sstevel@tonic-gate break; 43167c478bd9Sstevel@tonic-gate } 43177c478bd9Sstevel@tonic-gate } 43187c478bd9Sstevel@tonic-gate if (*cfap == NULL) /* will happen only once */ 43197c478bd9Sstevel@tonic-gate *cfap = cfp; 43207c478bd9Sstevel@tonic-gate } 43217c478bd9Sstevel@tonic-gate 43227c478bd9Sstevel@tonic-gate void 43237c478bd9Sstevel@tonic-gate delcsfrag(daddr32_t frag, struct csfrag **cfap) 43247c478bd9Sstevel@tonic-gate { 43257c478bd9Sstevel@tonic-gate struct csfrag *cfp; 43267c478bd9Sstevel@tonic-gate struct csfrag **cfpp; 43277c478bd9Sstevel@tonic-gate 43287c478bd9Sstevel@tonic-gate /* 43297c478bd9Sstevel@tonic-gate * free up entry whose beginning frag matches 43307c478bd9Sstevel@tonic-gate */ 43317c478bd9Sstevel@tonic-gate for (cfpp = cfap; *cfpp; cfpp = &(*cfpp)->next) { 43327c478bd9Sstevel@tonic-gate if (frag == (*cfpp)->ofrag) { 43337c478bd9Sstevel@tonic-gate cfp = *cfpp; 43347c478bd9Sstevel@tonic-gate *cfpp = (*cfpp)->next; 43357c478bd9Sstevel@tonic-gate free((char *)cfp); 43367c478bd9Sstevel@tonic-gate return; 43377c478bd9Sstevel@tonic-gate } 43387c478bd9Sstevel@tonic-gate } 43397c478bd9Sstevel@tonic-gate } 43407c478bd9Sstevel@tonic-gate 43417c478bd9Sstevel@tonic-gate /* 43427c478bd9Sstevel@tonic-gate * See whether any of the direct blocks in the array pointed by "db" and of 43437c478bd9Sstevel@tonic-gate * length "ne" are within the range of frags needed to extend the cylinder 43447c478bd9Sstevel@tonic-gate * summary. If so, remove those frags from the "as-yet-unclassified" list 43457c478bd9Sstevel@tonic-gate * (csfrag) and add them to the "owned-by-inode" list (csfragino). 43467c478bd9Sstevel@tonic-gate * For each such frag found, decrement the frag count pointed to by fragsp. 43477c478bd9Sstevel@tonic-gate * "ino" is the inode that contains (either directly or indirectly) the frags 43487c478bd9Sstevel@tonic-gate * being checked. 43497c478bd9Sstevel@tonic-gate */ 43507c478bd9Sstevel@tonic-gate void 43517c478bd9Sstevel@tonic-gate checkdirect(ino_t ino, daddr32_t *fragsp, daddr32_t *db, int ne) 43527c478bd9Sstevel@tonic-gate { 43537c478bd9Sstevel@tonic-gate int i; 43547c478bd9Sstevel@tonic-gate int j; 43557c478bd9Sstevel@tonic-gate int found; 43567c478bd9Sstevel@tonic-gate diskaddr_t frag; 43577c478bd9Sstevel@tonic-gate 43587c478bd9Sstevel@tonic-gate /* 43597c478bd9Sstevel@tonic-gate * scan for allocation within the new summary info range 43607c478bd9Sstevel@tonic-gate */ 43617c478bd9Sstevel@tonic-gate for (i = 0; i < ne && *fragsp; ++i) { 43627c478bd9Sstevel@tonic-gate if ((frag = *db++) != 0) { 43637c478bd9Sstevel@tonic-gate found = 0; 43647c478bd9Sstevel@tonic-gate for (j = 0; j < sblock.fs_frag && *fragsp; ++j) { 43657c478bd9Sstevel@tonic-gate if (found || (found = csfraginrange(frag))) { 43667c478bd9Sstevel@tonic-gate addcsfrag(ino, frag, &csfragino); 43677c478bd9Sstevel@tonic-gate delcsfrag(frag, &csfrag); 43687c478bd9Sstevel@tonic-gate } 43697c478bd9Sstevel@tonic-gate ++frag; 43707c478bd9Sstevel@tonic-gate --(*fragsp); 43717c478bd9Sstevel@tonic-gate } 43727c478bd9Sstevel@tonic-gate } 43737c478bd9Sstevel@tonic-gate } 43747c478bd9Sstevel@tonic-gate } 43757c478bd9Sstevel@tonic-gate 43767c478bd9Sstevel@tonic-gate void 43777c478bd9Sstevel@tonic-gate findcsfragino() 43787c478bd9Sstevel@tonic-gate { 43797c478bd9Sstevel@tonic-gate int i; 43807c478bd9Sstevel@tonic-gate int j; 43817c478bd9Sstevel@tonic-gate daddr32_t frags; 43827c478bd9Sstevel@tonic-gate struct dinode *dp; 43837c478bd9Sstevel@tonic-gate 43847c478bd9Sstevel@tonic-gate /* 43857c478bd9Sstevel@tonic-gate * scan all old inodes looking for allocations in the new 43867c478bd9Sstevel@tonic-gate * summary info range. Move the affected frag from the 43877c478bd9Sstevel@tonic-gate * generic csfrag list onto the `owned-by-inode' list csfragino. 43887c478bd9Sstevel@tonic-gate */ 43897c478bd9Sstevel@tonic-gate for (i = UFSROOTINO; i < grow_fs_ncg*sblock.fs_ipg && csfrag; ++i) { 43907c478bd9Sstevel@tonic-gate dp = gdinode((ino_t)i); 43917c478bd9Sstevel@tonic-gate switch (dp->di_mode & IFMT) { 43927c478bd9Sstevel@tonic-gate case IFSHAD : 43937c478bd9Sstevel@tonic-gate case IFLNK : 43947c478bd9Sstevel@tonic-gate case IFDIR : 43957c478bd9Sstevel@tonic-gate case IFREG : break; 43967c478bd9Sstevel@tonic-gate default : continue; 43977c478bd9Sstevel@tonic-gate } 43987c478bd9Sstevel@tonic-gate 43997c478bd9Sstevel@tonic-gate frags = dbtofsb(&sblock, dp->di_blocks); 44007c478bd9Sstevel@tonic-gate 44017c478bd9Sstevel@tonic-gate checkdirect((ino_t)i, &frags, &dp->di_db[0], NDADDR+NIADDR); 44027c478bd9Sstevel@tonic-gate for (j = 0; j < NIADDR && frags; ++j) 44037c478bd9Sstevel@tonic-gate checkindirect((ino_t)i, &frags, dp->di_ib[j], j); 44047c478bd9Sstevel@tonic-gate } 44057c478bd9Sstevel@tonic-gate } 44067c478bd9Sstevel@tonic-gate 44077c478bd9Sstevel@tonic-gate void 44087c478bd9Sstevel@tonic-gate fixindirect(daddr32_t frag, int level) 44097c478bd9Sstevel@tonic-gate { 44107c478bd9Sstevel@tonic-gate int i; 44117c478bd9Sstevel@tonic-gate int ne = sblock.fs_bsize / sizeof (daddr32_t); 44127c478bd9Sstevel@tonic-gate daddr32_t fsb[MAXBSIZE / sizeof (daddr32_t)]; 44137c478bd9Sstevel@tonic-gate 44147c478bd9Sstevel@tonic-gate if (frag == 0) 44157c478bd9Sstevel@tonic-gate return; 44167c478bd9Sstevel@tonic-gate 44177c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, (uint64_t)frag), (int)sblock.fs_bsize, 44187c478bd9Sstevel@tonic-gate (char *)fsb); 44197c478bd9Sstevel@tonic-gate 44207c478bd9Sstevel@tonic-gate fixdirect((caddr_t)fsb, frag, fsb, ne); 44217c478bd9Sstevel@tonic-gate 44227c478bd9Sstevel@tonic-gate if (level) 44237c478bd9Sstevel@tonic-gate for (i = 0; i < ne; ++i) 44247c478bd9Sstevel@tonic-gate fixindirect(fsb[i], level-1); 44257c478bd9Sstevel@tonic-gate } 44267c478bd9Sstevel@tonic-gate 44277c478bd9Sstevel@tonic-gate void 44287c478bd9Sstevel@tonic-gate fixdirect(caddr_t bp, daddr32_t frag, daddr32_t *db, int ne) 44297c478bd9Sstevel@tonic-gate { 44307c478bd9Sstevel@tonic-gate int i; 44317c478bd9Sstevel@tonic-gate struct csfrag *cfp; 44327c478bd9Sstevel@tonic-gate 44337c478bd9Sstevel@tonic-gate for (i = 0; i < ne; ++i, ++db) { 44347c478bd9Sstevel@tonic-gate if (*db == 0) 44357c478bd9Sstevel@tonic-gate continue; 44367c478bd9Sstevel@tonic-gate if ((cfp = findcsfrag(*db, &csfragino)) == NULL) 44377c478bd9Sstevel@tonic-gate continue; 44387c478bd9Sstevel@tonic-gate *db = cfp->nfrag; 44397c478bd9Sstevel@tonic-gate cfp->fixed = 1; 44407c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)frag), (int)sblock.fs_bsize, 44417c478bd9Sstevel@tonic-gate bp); 44427c478bd9Sstevel@tonic-gate } 44437c478bd9Sstevel@tonic-gate } 44447c478bd9Sstevel@tonic-gate 44457c478bd9Sstevel@tonic-gate void 44467c478bd9Sstevel@tonic-gate fixcsfragino() 44477c478bd9Sstevel@tonic-gate { 44487c478bd9Sstevel@tonic-gate int i; 44497c478bd9Sstevel@tonic-gate struct dinode *dp; 44507c478bd9Sstevel@tonic-gate struct csfrag *cfp; 44517c478bd9Sstevel@tonic-gate 44527c478bd9Sstevel@tonic-gate for (cfp = csfragino; cfp; cfp = cfp->next) { 44537c478bd9Sstevel@tonic-gate if (cfp->fixed) 44547c478bd9Sstevel@tonic-gate continue; 44557c478bd9Sstevel@tonic-gate dp = gdinode((ino_t)cfp->ino); 44567c478bd9Sstevel@tonic-gate fixdirect((caddr_t)dibuf, difrag, dp->di_db, NDADDR+NIADDR); 44577c478bd9Sstevel@tonic-gate for (i = 0; i < NIADDR; ++i) 44587c478bd9Sstevel@tonic-gate fixindirect(dp->di_ib[i], i); 44597c478bd9Sstevel@tonic-gate } 44607c478bd9Sstevel@tonic-gate } 44617c478bd9Sstevel@tonic-gate 44627c478bd9Sstevel@tonic-gate /* 44637c478bd9Sstevel@tonic-gate * Read the cylinders summary information specified by settings in the 44647c478bd9Sstevel@tonic-gate * passed 'fs' structure into a new allocated array of csum structures. 44657c478bd9Sstevel@tonic-gate * The caller is responsible for freeing the returned array. 44667c478bd9Sstevel@tonic-gate * Return a pointer to an array of csum structures. 44677c478bd9Sstevel@tonic-gate */ 44687c478bd9Sstevel@tonic-gate static struct csum * 44697c478bd9Sstevel@tonic-gate read_summaryinfo(struct fs *fsp) 44707c478bd9Sstevel@tonic-gate { 44717c478bd9Sstevel@tonic-gate struct csum *csp; 44727c478bd9Sstevel@tonic-gate int i; 44737c478bd9Sstevel@tonic-gate 44747c478bd9Sstevel@tonic-gate if ((csp = malloc((size_t)fsp->fs_cssize)) == NULL) { 44757c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cannot create csum list," 44767c478bd9Sstevel@tonic-gate " not enough memory\n")); 44777c478bd9Sstevel@tonic-gate exit(32); 44787c478bd9Sstevel@tonic-gate } 44797c478bd9Sstevel@tonic-gate 44807c478bd9Sstevel@tonic-gate for (i = 0; i < fsp->fs_cssize; i += fsp->fs_bsize) { 44817c478bd9Sstevel@tonic-gate rdfs(fsbtodb(fsp, 44827c478bd9Sstevel@tonic-gate (uint64_t)(fsp->fs_csaddr + numfrags(fsp, i))), 44837c478bd9Sstevel@tonic-gate (int)(fsp->fs_cssize - i < fsp->fs_bsize ? 44847c478bd9Sstevel@tonic-gate fsp->fs_cssize - i : fsp->fs_bsize), 44857c478bd9Sstevel@tonic-gate ((caddr_t)csp) + i); 44867c478bd9Sstevel@tonic-gate } 44877c478bd9Sstevel@tonic-gate 44887c478bd9Sstevel@tonic-gate return (csp); 44897c478bd9Sstevel@tonic-gate } 44907c478bd9Sstevel@tonic-gate 44917c478bd9Sstevel@tonic-gate /* 44927c478bd9Sstevel@tonic-gate * Check the allocation of fragments that are to be made part of a csum block. 44937c478bd9Sstevel@tonic-gate * A fragment is allocated if it is either in the csfragfree list or, it is 44947c478bd9Sstevel@tonic-gate * in the csfragino list and has new frags associated with it. 44957c478bd9Sstevel@tonic-gate * Return the number of allocated fragments. 44967c478bd9Sstevel@tonic-gate */ 44977c478bd9Sstevel@tonic-gate int64_t 44987c478bd9Sstevel@tonic-gate checkfragallocated(daddr32_t frag) 44997c478bd9Sstevel@tonic-gate { 45007c478bd9Sstevel@tonic-gate struct csfrag *cfp; 45017c478bd9Sstevel@tonic-gate /* 45027c478bd9Sstevel@tonic-gate * Since the lists are sorted we can break the search if the asked 45037c478bd9Sstevel@tonic-gate * frag is smaller then the one in the list. 45047c478bd9Sstevel@tonic-gate */ 45057c478bd9Sstevel@tonic-gate for (cfp = csfragfree; cfp != NULL && frag >= cfp->ofrag; 45067c478bd9Sstevel@tonic-gate cfp = cfp->next) { 45077c478bd9Sstevel@tonic-gate if (frag == cfp->ofrag) 45087c478bd9Sstevel@tonic-gate return (1); 45097c478bd9Sstevel@tonic-gate } 45107c478bd9Sstevel@tonic-gate for (cfp = csfragino; cfp != NULL && frag >= cfp->ofrag; 45117c478bd9Sstevel@tonic-gate cfp = cfp->next) { 45127c478bd9Sstevel@tonic-gate if (frag == cfp->ofrag && cfp->nfrag != 0) 45137c478bd9Sstevel@tonic-gate return (cfp->frags); 45147c478bd9Sstevel@tonic-gate } 45157c478bd9Sstevel@tonic-gate 45167c478bd9Sstevel@tonic-gate return (0); 45177c478bd9Sstevel@tonic-gate } 45187c478bd9Sstevel@tonic-gate 45197c478bd9Sstevel@tonic-gate /* 45207c478bd9Sstevel@tonic-gate * Figure out how much the filesystem can be grown. The limiting factor is 45217c478bd9Sstevel@tonic-gate * the available free space needed to extend the cg summary info block. 45227c478bd9Sstevel@tonic-gate * The free space is determined in three steps: 45237c478bd9Sstevel@tonic-gate * - Try to extend the cg summary block to the required size. 45247c478bd9Sstevel@tonic-gate * - Find free blocks in last cg. 45257c478bd9Sstevel@tonic-gate * - Find free space in the last already allocated fragment of the summary info 45267c478bd9Sstevel@tonic-gate * block, and use it for additional csum structures. 45277c478bd9Sstevel@tonic-gate * Return the maximum size of the new filesystem or 0 if it can't be grown. 45287c478bd9Sstevel@tonic-gate * Please note that this function leaves the global list pointers csfrag, 45297c478bd9Sstevel@tonic-gate * csfragfree, and csfragino initialized, and the caller is responsible for 45307c478bd9Sstevel@tonic-gate * freeing the lists. 45317c478bd9Sstevel@tonic-gate */ 45327c478bd9Sstevel@tonic-gate diskaddr_t 45337c478bd9Sstevel@tonic-gate probe_summaryinfo() 45347c478bd9Sstevel@tonic-gate { 45357c478bd9Sstevel@tonic-gate /* fragments by which the csum block can be extended. */ 45367c478bd9Sstevel@tonic-gate int64_t growth_csum_frags = 0; 45377c478bd9Sstevel@tonic-gate /* fragments by which the filesystem can be extended. */ 45387c478bd9Sstevel@tonic-gate int64_t growth_fs_frags = 0; 45397c478bd9Sstevel@tonic-gate int64_t new_fs_cssize; /* size of csum blk in the new FS */ 45407c478bd9Sstevel@tonic-gate int64_t new_fs_ncg; /* number of cg in the new FS */ 45417c478bd9Sstevel@tonic-gate int64_t spare_csum; 45427c478bd9Sstevel@tonic-gate daddr32_t oldfrag_daddr; 45437c478bd9Sstevel@tonic-gate daddr32_t newfrag_daddr; 45447c478bd9Sstevel@tonic-gate daddr32_t daddr; 45457c478bd9Sstevel@tonic-gate int i; 45467c478bd9Sstevel@tonic-gate 45477c478bd9Sstevel@tonic-gate /* 45487c478bd9Sstevel@tonic-gate * read and verify the superblock 45497c478bd9Sstevel@tonic-gate */ 45507c478bd9Sstevel@tonic-gate rdfs((diskaddr_t)(SBOFF / sectorsize), (int)sbsize, (char *)&sblock); 4551*6451fdbcSvsakar (void) checksblock(sblock, 0); 45527c478bd9Sstevel@tonic-gate 45537c478bd9Sstevel@tonic-gate /* 45547c478bd9Sstevel@tonic-gate * check how much we can extend the cg summary info block 45557c478bd9Sstevel@tonic-gate */ 45567c478bd9Sstevel@tonic-gate 45577c478bd9Sstevel@tonic-gate /* 45587c478bd9Sstevel@tonic-gate * read current summary information 45597c478bd9Sstevel@tonic-gate */ 45607c478bd9Sstevel@tonic-gate fscs = read_summaryinfo(&sblock); 45617c478bd9Sstevel@tonic-gate 45627c478bd9Sstevel@tonic-gate /* 45637c478bd9Sstevel@tonic-gate * build list of frags needed for cg summary info block extension 45647c478bd9Sstevel@tonic-gate */ 45657c478bd9Sstevel@tonic-gate oldfrag_daddr = howmany(sblock.fs_cssize, sblock.fs_fsize) + 45667c478bd9Sstevel@tonic-gate sblock.fs_csaddr; 45677c478bd9Sstevel@tonic-gate new_fs_ncg = howmany(dbtofsb(&sblock, fssize_db), sblock.fs_fpg); 45687c478bd9Sstevel@tonic-gate new_fs_cssize = fragroundup(&sblock, new_fs_ncg * sizeof (struct csum)); 45697c478bd9Sstevel@tonic-gate newfrag_daddr = howmany(new_fs_cssize, sblock.fs_fsize) + 45707c478bd9Sstevel@tonic-gate sblock.fs_csaddr; 45717c478bd9Sstevel@tonic-gate /* 45727c478bd9Sstevel@tonic-gate * add all of the frags that are required to grow the cyl summary to the 45737c478bd9Sstevel@tonic-gate * csfrag list, which is the generic/unknown list, since at this point 45747c478bd9Sstevel@tonic-gate * we don't yet know the state of those frags. 45757c478bd9Sstevel@tonic-gate */ 45767c478bd9Sstevel@tonic-gate for (daddr = oldfrag_daddr; daddr < newfrag_daddr; daddr++) 45777c478bd9Sstevel@tonic-gate addcsfrag((ino_t)0, daddr, &csfrag); 45787c478bd9Sstevel@tonic-gate 45797c478bd9Sstevel@tonic-gate /* 45807c478bd9Sstevel@tonic-gate * filter free fragments and allocate them. Note that the free frags 45817c478bd9Sstevel@tonic-gate * must be allocated first otherwise they could be grabbed by 45827c478bd9Sstevel@tonic-gate * alloccsfragino() for data frags. 45837c478bd9Sstevel@tonic-gate */ 45847c478bd9Sstevel@tonic-gate findcsfragfree(); 45857c478bd9Sstevel@tonic-gate alloccsfragfree(); 45867c478bd9Sstevel@tonic-gate 45877c478bd9Sstevel@tonic-gate /* 45887c478bd9Sstevel@tonic-gate * filter fragments owned by inodes and allocate them 45897c478bd9Sstevel@tonic-gate */ 45907c478bd9Sstevel@tonic-gate grow_fs_ncg = sblock.fs_ncg; /* findcsfragino() needs this glob. var. */ 45917c478bd9Sstevel@tonic-gate findcsfragino(); 45927c478bd9Sstevel@tonic-gate alloccsfragino(); 45937c478bd9Sstevel@tonic-gate 45947c478bd9Sstevel@tonic-gate if (notenoughspace()) { 45957c478bd9Sstevel@tonic-gate /* 45967c478bd9Sstevel@tonic-gate * check how many consecutive fragments could be allocated 45977c478bd9Sstevel@tonic-gate * in both lists. 45987c478bd9Sstevel@tonic-gate */ 45997c478bd9Sstevel@tonic-gate int64_t tmp_frags; 46007c478bd9Sstevel@tonic-gate for (daddr = oldfrag_daddr; daddr < newfrag_daddr; 46017c478bd9Sstevel@tonic-gate daddr += tmp_frags) { 46027c478bd9Sstevel@tonic-gate if ((tmp_frags = checkfragallocated(daddr)) > 0) 46037c478bd9Sstevel@tonic-gate growth_csum_frags += tmp_frags; 46047c478bd9Sstevel@tonic-gate else 46057c478bd9Sstevel@tonic-gate break; 46067c478bd9Sstevel@tonic-gate } 46077c478bd9Sstevel@tonic-gate } else { 46087c478bd9Sstevel@tonic-gate /* 46097c478bd9Sstevel@tonic-gate * We have all we need for the new desired size, 46107c478bd9Sstevel@tonic-gate * so clean up and report back. 46117c478bd9Sstevel@tonic-gate */ 46127c478bd9Sstevel@tonic-gate return (fssize_db); 46137c478bd9Sstevel@tonic-gate } 46147c478bd9Sstevel@tonic-gate 46157c478bd9Sstevel@tonic-gate /* 46167c478bd9Sstevel@tonic-gate * given the number of fragments by which the csum block can be grown 46177c478bd9Sstevel@tonic-gate * compute by how many new fragments the FS can be increased. 46187c478bd9Sstevel@tonic-gate * It is the number of csum instances per fragment multiplied by 46197c478bd9Sstevel@tonic-gate * `growth_csum_frags' and the number of fragments per cylinder group. 46207c478bd9Sstevel@tonic-gate */ 46217c478bd9Sstevel@tonic-gate growth_fs_frags = howmany(sblock.fs_fsize, sizeof (struct csum)) * 46227c478bd9Sstevel@tonic-gate growth_csum_frags * sblock.fs_fpg; 46237c478bd9Sstevel@tonic-gate 46247c478bd9Sstevel@tonic-gate /* 46257c478bd9Sstevel@tonic-gate * compute free fragments in the last cylinder group 46267c478bd9Sstevel@tonic-gate */ 46277c478bd9Sstevel@tonic-gate rdcg(sblock.fs_ncg - 1); 46287c478bd9Sstevel@tonic-gate growth_fs_frags += sblock.fs_fpg - acg.cg_ndblk; 46297c478bd9Sstevel@tonic-gate 46307c478bd9Sstevel@tonic-gate /* 46317c478bd9Sstevel@tonic-gate * compute how many csum instances are unused in the old csum block. 46327c478bd9Sstevel@tonic-gate * For each unused csum instance the FS can be grown by one cylinder 46337c478bd9Sstevel@tonic-gate * group without extending the csum block. 46347c478bd9Sstevel@tonic-gate */ 46357c478bd9Sstevel@tonic-gate spare_csum = howmany(sblock.fs_cssize, sizeof (struct csum)) - 46367c478bd9Sstevel@tonic-gate sblock.fs_ncg; 46377c478bd9Sstevel@tonic-gate if (spare_csum > 0) 46387c478bd9Sstevel@tonic-gate growth_fs_frags += spare_csum * sblock.fs_fpg; 46397c478bd9Sstevel@tonic-gate 46407c478bd9Sstevel@tonic-gate /* 46417c478bd9Sstevel@tonic-gate * recalculate the new filesystem size in sectors, shorten it by 46427c478bd9Sstevel@tonic-gate * the requested size `fssize_db' if necessary. 46437c478bd9Sstevel@tonic-gate */ 46447c478bd9Sstevel@tonic-gate if (growth_fs_frags > 0) { 46457c478bd9Sstevel@tonic-gate diskaddr_t sect; 46467c478bd9Sstevel@tonic-gate sect = (sblock.fs_size + growth_fs_frags) * sblock.fs_nspf; 46477c478bd9Sstevel@tonic-gate return ((sect > fssize_db) ? fssize_db : sect); 46487c478bd9Sstevel@tonic-gate } 46497c478bd9Sstevel@tonic-gate 46507c478bd9Sstevel@tonic-gate return (0); 46517c478bd9Sstevel@tonic-gate } 46527c478bd9Sstevel@tonic-gate 46537c478bd9Sstevel@tonic-gate void 46547c478bd9Sstevel@tonic-gate extendsummaryinfo() 46557c478bd9Sstevel@tonic-gate { 46567c478bd9Sstevel@tonic-gate int64_t i; 46577c478bd9Sstevel@tonic-gate int localtest = test; 46587c478bd9Sstevel@tonic-gate int64_t frags; 46597c478bd9Sstevel@tonic-gate daddr32_t oldfrag; 46607c478bd9Sstevel@tonic-gate daddr32_t newfrag; 46617c478bd9Sstevel@tonic-gate 46627c478bd9Sstevel@tonic-gate /* 46637c478bd9Sstevel@tonic-gate * if no-write (-N), don't bother 46647c478bd9Sstevel@tonic-gate */ 46657c478bd9Sstevel@tonic-gate if (Nflag) 46667c478bd9Sstevel@tonic-gate return; 46677c478bd9Sstevel@tonic-gate 46687c478bd9Sstevel@tonic-gate again: 46697c478bd9Sstevel@tonic-gate flcg(); 46707c478bd9Sstevel@tonic-gate /* 46717c478bd9Sstevel@tonic-gate * summary info did not change size -- do nothing unless in test mode 46727c478bd9Sstevel@tonic-gate */ 46737c478bd9Sstevel@tonic-gate if (grow_fs_cssize == sblock.fs_cssize) 46747c478bd9Sstevel@tonic-gate if (!localtest) 46757c478bd9Sstevel@tonic-gate return; 46767c478bd9Sstevel@tonic-gate 46777c478bd9Sstevel@tonic-gate /* 46787c478bd9Sstevel@tonic-gate * build list of frags needed for additional summary information 46797c478bd9Sstevel@tonic-gate */ 46807c478bd9Sstevel@tonic-gate oldfrag = howmany(grow_fs_cssize, sblock.fs_fsize) + grow_fs_csaddr; 46817c478bd9Sstevel@tonic-gate newfrag = howmany(sblock.fs_cssize, sblock.fs_fsize) + grow_fs_csaddr; 46827c478bd9Sstevel@tonic-gate /* 46837c478bd9Sstevel@tonic-gate * add all of the frags that are required to grow the cyl summary to the 46847c478bd9Sstevel@tonic-gate * csfrag list, which is the generic/unknown list, since at this point 46857c478bd9Sstevel@tonic-gate * we don't yet know the state of those frags. 46867c478bd9Sstevel@tonic-gate */ 46877c478bd9Sstevel@tonic-gate for (i = oldfrag, frags = 0; i < newfrag; ++i, ++frags) 46887c478bd9Sstevel@tonic-gate addcsfrag((ino_t)0, (diskaddr_t)i, &csfrag); 46897c478bd9Sstevel@tonic-gate /* 46907c478bd9Sstevel@tonic-gate * reduce the number of data blocks in the file system (fs_dsize) by 46917c478bd9Sstevel@tonic-gate * the number of frags that need to be added to the cyl summary 46927c478bd9Sstevel@tonic-gate */ 46937c478bd9Sstevel@tonic-gate sblock.fs_dsize -= (newfrag - oldfrag); 46947c478bd9Sstevel@tonic-gate 46957c478bd9Sstevel@tonic-gate /* 46967c478bd9Sstevel@tonic-gate * In test mode, we move more data than necessary from 46977c478bd9Sstevel@tonic-gate * cylinder group 0. The lookup/allocate/move code can be 46987c478bd9Sstevel@tonic-gate * better stressed without having to create HUGE file systems. 46997c478bd9Sstevel@tonic-gate */ 47007c478bd9Sstevel@tonic-gate if (localtest) 47017c478bd9Sstevel@tonic-gate for (i = newfrag; i < grow_sifrag; ++i) { 47027c478bd9Sstevel@tonic-gate if (frags >= testfrags) 47037c478bd9Sstevel@tonic-gate break; 47047c478bd9Sstevel@tonic-gate frags++; 47057c478bd9Sstevel@tonic-gate addcsfrag((ino_t)0, (diskaddr_t)i, &csfrag); 47067c478bd9Sstevel@tonic-gate } 47077c478bd9Sstevel@tonic-gate 47087c478bd9Sstevel@tonic-gate /* 47097c478bd9Sstevel@tonic-gate * move frags to free or inode lists, depending on owner 47107c478bd9Sstevel@tonic-gate */ 47117c478bd9Sstevel@tonic-gate findcsfragfree(); 47127c478bd9Sstevel@tonic-gate findcsfragino(); 47137c478bd9Sstevel@tonic-gate 47147c478bd9Sstevel@tonic-gate /* 47157c478bd9Sstevel@tonic-gate * if not all frags can be located, file system must be inconsistent 47167c478bd9Sstevel@tonic-gate */ 47177c478bd9Sstevel@tonic-gate if (csfrag) { 47187c478bd9Sstevel@tonic-gate isbad = 1; /* should already be set, but make sure */ 47197c478bd9Sstevel@tonic-gate lockexit(32); 47207c478bd9Sstevel@tonic-gate } 47217c478bd9Sstevel@tonic-gate 47227c478bd9Sstevel@tonic-gate /* 47237c478bd9Sstevel@tonic-gate * allocate the free frags. Note that the free frags must be allocated 47247c478bd9Sstevel@tonic-gate * first otherwise they could be grabbed by alloccsfragino() for data 47257c478bd9Sstevel@tonic-gate * frags. 47267c478bd9Sstevel@tonic-gate */ 47277c478bd9Sstevel@tonic-gate alloccsfragfree(); 47287c478bd9Sstevel@tonic-gate /* 47297c478bd9Sstevel@tonic-gate * allocate extra space for inode frags 47307c478bd9Sstevel@tonic-gate */ 47317c478bd9Sstevel@tonic-gate alloccsfragino(); 47327c478bd9Sstevel@tonic-gate 47337c478bd9Sstevel@tonic-gate /* 47347c478bd9Sstevel@tonic-gate * not enough space 47357c478bd9Sstevel@tonic-gate */ 47367c478bd9Sstevel@tonic-gate if (notenoughspace()) { 47377c478bd9Sstevel@tonic-gate unalloccsfragfree(); 47387c478bd9Sstevel@tonic-gate unalloccsfragino(); 47397c478bd9Sstevel@tonic-gate if (localtest && !testforce) { 47407c478bd9Sstevel@tonic-gate localtest = 0; 47417c478bd9Sstevel@tonic-gate goto again; 47427c478bd9Sstevel@tonic-gate } 47437c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Not enough free space\n")); 47447c478bd9Sstevel@tonic-gate lockexit(NOTENOUGHSPACE); 47457c478bd9Sstevel@tonic-gate } 47467c478bd9Sstevel@tonic-gate 47477c478bd9Sstevel@tonic-gate /* 47487c478bd9Sstevel@tonic-gate * copy the data from old frags to new frags 47497c478bd9Sstevel@tonic-gate */ 47507c478bd9Sstevel@tonic-gate copycsfragino(); 47517c478bd9Sstevel@tonic-gate 47527c478bd9Sstevel@tonic-gate /* 47537c478bd9Sstevel@tonic-gate * fix the inodes to point to the new frags 47547c478bd9Sstevel@tonic-gate */ 47557c478bd9Sstevel@tonic-gate fixcsfragino(); 47567c478bd9Sstevel@tonic-gate 47577c478bd9Sstevel@tonic-gate /* 47587c478bd9Sstevel@tonic-gate * We may have moved more frags than we needed. Free them. 47597c478bd9Sstevel@tonic-gate */ 47607c478bd9Sstevel@tonic-gate rdcg((long)0); 47617c478bd9Sstevel@tonic-gate for (i = newfrag; i <= maxcsfrag; ++i) 47627c478bd9Sstevel@tonic-gate setbit(cg_blksfree(&acg), i-cgbase(&sblock, 0)); 47637c478bd9Sstevel@tonic-gate wtcg(); 47647c478bd9Sstevel@tonic-gate 47657c478bd9Sstevel@tonic-gate flcg(); 47667c478bd9Sstevel@tonic-gate } 47677c478bd9Sstevel@tonic-gate 47687c478bd9Sstevel@tonic-gate /* 47697c478bd9Sstevel@tonic-gate * Check if all fragments in the `csfragino' list were reallocated. 47707c478bd9Sstevel@tonic-gate */ 47717c478bd9Sstevel@tonic-gate int 47727c478bd9Sstevel@tonic-gate notenoughspace() 47737c478bd9Sstevel@tonic-gate { 47747c478bd9Sstevel@tonic-gate struct csfrag *cfp; 47757c478bd9Sstevel@tonic-gate 47767c478bd9Sstevel@tonic-gate /* 47777c478bd9Sstevel@tonic-gate * If any element in the csfragino array has a "new frag location" 47787c478bd9Sstevel@tonic-gate * of 0, the allocfrags() function was unsuccessful in allocating 47797c478bd9Sstevel@tonic-gate * space for moving the frag represented by this array element. 47807c478bd9Sstevel@tonic-gate */ 47817c478bd9Sstevel@tonic-gate for (cfp = csfragino; cfp; cfp = cfp->next) 47827c478bd9Sstevel@tonic-gate if (cfp->nfrag == 0) 47837c478bd9Sstevel@tonic-gate return (1); 47847c478bd9Sstevel@tonic-gate return (0); 47857c478bd9Sstevel@tonic-gate } 47867c478bd9Sstevel@tonic-gate 47877c478bd9Sstevel@tonic-gate void 47887c478bd9Sstevel@tonic-gate unalloccsfragino() 47897c478bd9Sstevel@tonic-gate { 47907c478bd9Sstevel@tonic-gate struct csfrag *cfp; 47917c478bd9Sstevel@tonic-gate 47927c478bd9Sstevel@tonic-gate while ((cfp = csfragino) != NULL) { 47937c478bd9Sstevel@tonic-gate if (cfp->nfrag) 47947c478bd9Sstevel@tonic-gate freefrags(cfp->nfrag, cfp->frags, cfp->cylno); 47957c478bd9Sstevel@tonic-gate delcsfrag(cfp->ofrag, &csfragino); 47967c478bd9Sstevel@tonic-gate } 47977c478bd9Sstevel@tonic-gate } 47987c478bd9Sstevel@tonic-gate 47997c478bd9Sstevel@tonic-gate void 48007c478bd9Sstevel@tonic-gate unalloccsfragfree() 48017c478bd9Sstevel@tonic-gate { 48027c478bd9Sstevel@tonic-gate struct csfrag *cfp; 48037c478bd9Sstevel@tonic-gate 48047c478bd9Sstevel@tonic-gate while ((cfp = csfragfree) != NULL) { 48057c478bd9Sstevel@tonic-gate freefrags(cfp->ofrag, cfp->frags, cfp->cylno); 48067c478bd9Sstevel@tonic-gate delcsfrag(cfp->ofrag, &csfragfree); 48077c478bd9Sstevel@tonic-gate } 48087c478bd9Sstevel@tonic-gate } 48097c478bd9Sstevel@tonic-gate 48107c478bd9Sstevel@tonic-gate /* 48117c478bd9Sstevel@tonic-gate * For each frag in the "as-yet-unclassified" list (csfrag), see if 48127c478bd9Sstevel@tonic-gate * it's free (i.e., its bit is set in the free frag bit map). If so, 48137c478bd9Sstevel@tonic-gate * move it from the "as-yet-unclassified" list to the csfragfree list. 48147c478bd9Sstevel@tonic-gate */ 48157c478bd9Sstevel@tonic-gate void 48167c478bd9Sstevel@tonic-gate findcsfragfree() 48177c478bd9Sstevel@tonic-gate { 48187c478bd9Sstevel@tonic-gate struct csfrag *cfp; 48197c478bd9Sstevel@tonic-gate struct csfrag *cfpnext; 48207c478bd9Sstevel@tonic-gate 48217c478bd9Sstevel@tonic-gate /* 48227c478bd9Sstevel@tonic-gate * move free frags onto the free-frag list 48237c478bd9Sstevel@tonic-gate */ 48247c478bd9Sstevel@tonic-gate rdcg((long)0); 48257c478bd9Sstevel@tonic-gate for (cfp = csfrag; cfp; cfp = cfpnext) { 48267c478bd9Sstevel@tonic-gate cfpnext = cfp->next; 48277c478bd9Sstevel@tonic-gate if (isset(cg_blksfree(&acg), cfp->ofrag - cgbase(&sblock, 0))) { 48287c478bd9Sstevel@tonic-gate addcsfrag(cfp->ino, cfp->ofrag, &csfragfree); 48297c478bd9Sstevel@tonic-gate delcsfrag(cfp->ofrag, &csfrag); 48307c478bd9Sstevel@tonic-gate } 48317c478bd9Sstevel@tonic-gate } 48327c478bd9Sstevel@tonic-gate } 48337c478bd9Sstevel@tonic-gate 48347c478bd9Sstevel@tonic-gate void 48357c478bd9Sstevel@tonic-gate copycsfragino() 48367c478bd9Sstevel@tonic-gate { 48377c478bd9Sstevel@tonic-gate struct csfrag *cfp; 48387c478bd9Sstevel@tonic-gate char buf[MAXBSIZE]; 48397c478bd9Sstevel@tonic-gate 48407c478bd9Sstevel@tonic-gate /* 48417c478bd9Sstevel@tonic-gate * copy data from old frags to newly allocated frags 48427c478bd9Sstevel@tonic-gate */ 48437c478bd9Sstevel@tonic-gate for (cfp = csfragino; cfp; cfp = cfp->next) { 48447c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, (uint64_t)cfp->ofrag), (int)cfp->size, 48457c478bd9Sstevel@tonic-gate buf); 48467c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)cfp->nfrag), (int)cfp->size, 48477c478bd9Sstevel@tonic-gate buf); 48487c478bd9Sstevel@tonic-gate } 48497c478bd9Sstevel@tonic-gate } 48507c478bd9Sstevel@tonic-gate 48517c478bd9Sstevel@tonic-gate long curcylno = -1; 48527c478bd9Sstevel@tonic-gate int cylnodirty = 0; 48537c478bd9Sstevel@tonic-gate 48547c478bd9Sstevel@tonic-gate void 48557c478bd9Sstevel@tonic-gate rdcg(long cylno) 48567c478bd9Sstevel@tonic-gate { 48577c478bd9Sstevel@tonic-gate if (cylno != curcylno) { 48587c478bd9Sstevel@tonic-gate flcg(); 48597c478bd9Sstevel@tonic-gate curcylno = cylno; 48607c478bd9Sstevel@tonic-gate rdfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, curcylno)), 48617c478bd9Sstevel@tonic-gate (int)sblock.fs_cgsize, (char *)&acg); 48627c478bd9Sstevel@tonic-gate } 48637c478bd9Sstevel@tonic-gate } 48647c478bd9Sstevel@tonic-gate 48657c478bd9Sstevel@tonic-gate void 48667c478bd9Sstevel@tonic-gate flcg() 48677c478bd9Sstevel@tonic-gate { 48687c478bd9Sstevel@tonic-gate if (cylnodirty) { 48697c478bd9Sstevel@tonic-gate if (debug && Pflag) { 48707c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 48717c478bd9Sstevel@tonic-gate "Assert: cylnodirty set in probe mode\n"); 48727c478bd9Sstevel@tonic-gate return; 48737c478bd9Sstevel@tonic-gate } 48747c478bd9Sstevel@tonic-gate resetallocinfo(); 48757c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)cgtod(&sblock, curcylno)), 48767c478bd9Sstevel@tonic-gate (int)sblock.fs_cgsize, (char *)&acg); 48777c478bd9Sstevel@tonic-gate cylnodirty = 0; 48787c478bd9Sstevel@tonic-gate } 48797c478bd9Sstevel@tonic-gate curcylno = -1; 48807c478bd9Sstevel@tonic-gate } 48817c478bd9Sstevel@tonic-gate 48827c478bd9Sstevel@tonic-gate void 48837c478bd9Sstevel@tonic-gate wtcg() 48847c478bd9Sstevel@tonic-gate { 48857c478bd9Sstevel@tonic-gate if (!Pflag) { 48867c478bd9Sstevel@tonic-gate /* probe mode should never write to disk */ 48877c478bd9Sstevel@tonic-gate cylnodirty = 1; 48887c478bd9Sstevel@tonic-gate } 48897c478bd9Sstevel@tonic-gate } 48907c478bd9Sstevel@tonic-gate 48917c478bd9Sstevel@tonic-gate void 48927c478bd9Sstevel@tonic-gate allocfrags(long frags, daddr32_t *fragp, long *cylnop) 48937c478bd9Sstevel@tonic-gate { 48947c478bd9Sstevel@tonic-gate int i; 48957c478bd9Sstevel@tonic-gate int j; 48967c478bd9Sstevel@tonic-gate long bits; 48977c478bd9Sstevel@tonic-gate long bit; 48987c478bd9Sstevel@tonic-gate 48997c478bd9Sstevel@tonic-gate /* 49007c478bd9Sstevel@tonic-gate * Allocate a free-frag range in an old cylinder group 49017c478bd9Sstevel@tonic-gate */ 49027c478bd9Sstevel@tonic-gate for (i = 0, *fragp = 0; i < grow_fs_ncg; ++i) { 49037c478bd9Sstevel@tonic-gate if (((fscs+i)->cs_nffree < frags) && ((fscs+i)->cs_nbfree == 0)) 49047c478bd9Sstevel@tonic-gate continue; 49057c478bd9Sstevel@tonic-gate rdcg((long)i); 49067c478bd9Sstevel@tonic-gate bit = bits = 0; 49077c478bd9Sstevel@tonic-gate while (findfreerange(&bit, &bits)) { 49087c478bd9Sstevel@tonic-gate if (frags <= bits) { 49097c478bd9Sstevel@tonic-gate for (j = 0; j < frags; ++j) 49107c478bd9Sstevel@tonic-gate clrbit(cg_blksfree(&acg), bit+j); 49117c478bd9Sstevel@tonic-gate wtcg(); 49127c478bd9Sstevel@tonic-gate *cylnop = i; 49137c478bd9Sstevel@tonic-gate *fragp = bit + cgbase(&sblock, i); 49147c478bd9Sstevel@tonic-gate return; 49157c478bd9Sstevel@tonic-gate } 49167c478bd9Sstevel@tonic-gate bit += bits; 49177c478bd9Sstevel@tonic-gate } 49187c478bd9Sstevel@tonic-gate } 49197c478bd9Sstevel@tonic-gate } 49207c478bd9Sstevel@tonic-gate 49217c478bd9Sstevel@tonic-gate /* 49227c478bd9Sstevel@tonic-gate * Allocate space for frags that need to be moved in order to free up space for 49237c478bd9Sstevel@tonic-gate * expanding the cylinder summary info. 49247c478bd9Sstevel@tonic-gate * For each frag that needs to be moved (each frag or range of frags in 49257c478bd9Sstevel@tonic-gate * the csfragino list), allocate a new location and store the frag number 49267c478bd9Sstevel@tonic-gate * of that new location in the nfrag field of the csfrag struct. 49277c478bd9Sstevel@tonic-gate * If a new frag can't be allocated for any element in the csfragino list, 49287c478bd9Sstevel@tonic-gate * set the new frag number for that element to 0 and return immediately. 49297c478bd9Sstevel@tonic-gate * The notenoughspace() function will detect this condition. 49307c478bd9Sstevel@tonic-gate */ 49317c478bd9Sstevel@tonic-gate void 49327c478bd9Sstevel@tonic-gate alloccsfragino() 49337c478bd9Sstevel@tonic-gate { 49347c478bd9Sstevel@tonic-gate struct csfrag *cfp; 49357c478bd9Sstevel@tonic-gate 49367c478bd9Sstevel@tonic-gate /* 49377c478bd9Sstevel@tonic-gate * allocate space for inode frag ranges 49387c478bd9Sstevel@tonic-gate */ 49397c478bd9Sstevel@tonic-gate for (cfp = csfragino; cfp; cfp = cfp->next) { 49407c478bd9Sstevel@tonic-gate allocfrags(cfp->frags, &cfp->nfrag, &cfp->cylno); 49417c478bd9Sstevel@tonic-gate if (cfp->nfrag == 0) 49427c478bd9Sstevel@tonic-gate break; 49437c478bd9Sstevel@tonic-gate } 49447c478bd9Sstevel@tonic-gate } 49457c478bd9Sstevel@tonic-gate 49467c478bd9Sstevel@tonic-gate void 49477c478bd9Sstevel@tonic-gate alloccsfragfree() 49487c478bd9Sstevel@tonic-gate { 49497c478bd9Sstevel@tonic-gate struct csfrag *cfp; 49507c478bd9Sstevel@tonic-gate 49517c478bd9Sstevel@tonic-gate /* 49527c478bd9Sstevel@tonic-gate * allocate the free frags needed for extended summary info 49537c478bd9Sstevel@tonic-gate */ 49547c478bd9Sstevel@tonic-gate rdcg((long)0); 49557c478bd9Sstevel@tonic-gate 49567c478bd9Sstevel@tonic-gate for (cfp = csfragfree; cfp; cfp = cfp->next) 49577c478bd9Sstevel@tonic-gate clrbit(cg_blksfree(&acg), cfp->ofrag - cgbase(&sblock, 0)); 49587c478bd9Sstevel@tonic-gate 49597c478bd9Sstevel@tonic-gate wtcg(); 49607c478bd9Sstevel@tonic-gate } 49617c478bd9Sstevel@tonic-gate 49627c478bd9Sstevel@tonic-gate void 49637c478bd9Sstevel@tonic-gate freefrags(daddr32_t frag, long frags, long cylno) 49647c478bd9Sstevel@tonic-gate { 49657c478bd9Sstevel@tonic-gate int i; 49667c478bd9Sstevel@tonic-gate 49677c478bd9Sstevel@tonic-gate /* 49687c478bd9Sstevel@tonic-gate * free frags 49697c478bd9Sstevel@tonic-gate */ 49707c478bd9Sstevel@tonic-gate rdcg(cylno); 49717c478bd9Sstevel@tonic-gate for (i = 0; i < frags; ++i) { 49727c478bd9Sstevel@tonic-gate setbit(cg_blksfree(&acg), (frag+i) - cgbase(&sblock, cylno)); 49737c478bd9Sstevel@tonic-gate } 49747c478bd9Sstevel@tonic-gate wtcg(); 49757c478bd9Sstevel@tonic-gate } 49767c478bd9Sstevel@tonic-gate 49777c478bd9Sstevel@tonic-gate int 49787c478bd9Sstevel@tonic-gate findfreerange(long *bitp, long *bitsp) 49797c478bd9Sstevel@tonic-gate { 49807c478bd9Sstevel@tonic-gate long bit; 49817c478bd9Sstevel@tonic-gate 49827c478bd9Sstevel@tonic-gate /* 49837c478bd9Sstevel@tonic-gate * find a range of free bits in a cylinder group bit map 49847c478bd9Sstevel@tonic-gate */ 49857c478bd9Sstevel@tonic-gate for (bit = *bitp, *bitsp = 0; bit < acg.cg_ndblk; ++bit) 49867c478bd9Sstevel@tonic-gate if (isset(cg_blksfree(&acg), bit)) 49877c478bd9Sstevel@tonic-gate break; 49887c478bd9Sstevel@tonic-gate 49897c478bd9Sstevel@tonic-gate if (bit >= acg.cg_ndblk) 49907c478bd9Sstevel@tonic-gate return (0); 49917c478bd9Sstevel@tonic-gate 49927c478bd9Sstevel@tonic-gate *bitp = bit; 49937c478bd9Sstevel@tonic-gate *bitsp = 1; 49947c478bd9Sstevel@tonic-gate for (++bit; bit < acg.cg_ndblk; ++bit, ++(*bitsp)) { 49957c478bd9Sstevel@tonic-gate if ((bit % sblock.fs_frag) == 0) 49967c478bd9Sstevel@tonic-gate break; 49977c478bd9Sstevel@tonic-gate if (isclr(cg_blksfree(&acg), bit)) 49987c478bd9Sstevel@tonic-gate break; 49997c478bd9Sstevel@tonic-gate } 50007c478bd9Sstevel@tonic-gate return (1); 50017c478bd9Sstevel@tonic-gate } 50027c478bd9Sstevel@tonic-gate 50037c478bd9Sstevel@tonic-gate void 50047c478bd9Sstevel@tonic-gate resetallocinfo() 50057c478bd9Sstevel@tonic-gate { 50067c478bd9Sstevel@tonic-gate long cno; 50077c478bd9Sstevel@tonic-gate long bit; 50087c478bd9Sstevel@tonic-gate long bits; 50097c478bd9Sstevel@tonic-gate 50107c478bd9Sstevel@tonic-gate /* 50117c478bd9Sstevel@tonic-gate * Compute the free blocks/frags info and update the appropriate 50127c478bd9Sstevel@tonic-gate * inmemory superblock, summary info, and cylinder group fields 50137c478bd9Sstevel@tonic-gate */ 50147c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nffree -= acg.cg_cs.cs_nffree; 50157c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nbfree -= acg.cg_cs.cs_nbfree; 50167c478bd9Sstevel@tonic-gate 50177c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nffree = 0; 50187c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nbfree = 0; 50197c478bd9Sstevel@tonic-gate 50207c478bd9Sstevel@tonic-gate bzero((caddr_t)acg.cg_frsum, sizeof (acg.cg_frsum)); 50217c478bd9Sstevel@tonic-gate bzero((caddr_t)cg_blktot(&acg), (int)(acg.cg_iusedoff-acg.cg_btotoff)); 50227c478bd9Sstevel@tonic-gate 50237c478bd9Sstevel@tonic-gate bit = bits = 0; 50247c478bd9Sstevel@tonic-gate while (findfreerange(&bit, &bits)) { 50257c478bd9Sstevel@tonic-gate if (bits == sblock.fs_frag) { 50267c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nbfree++; 50277c478bd9Sstevel@tonic-gate cno = cbtocylno(&sblock, bit); 50287c478bd9Sstevel@tonic-gate cg_blktot(&acg)[cno]++; 50297c478bd9Sstevel@tonic-gate cg_blks(&sblock, &acg, cno)[cbtorpos(&sblock, bit)]++; 50307c478bd9Sstevel@tonic-gate } else { 50317c478bd9Sstevel@tonic-gate acg.cg_cs.cs_nffree += bits; 50327c478bd9Sstevel@tonic-gate acg.cg_frsum[bits]++; 50337c478bd9Sstevel@tonic-gate } 50347c478bd9Sstevel@tonic-gate bit += bits; 50357c478bd9Sstevel@tonic-gate } 50367c478bd9Sstevel@tonic-gate 50377c478bd9Sstevel@tonic-gate *(fscs + acg.cg_cgx) = acg.cg_cs; 50387c478bd9Sstevel@tonic-gate 50397c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree; 50407c478bd9Sstevel@tonic-gate sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree; 50417c478bd9Sstevel@tonic-gate } 50427c478bd9Sstevel@tonic-gate 50437c478bd9Sstevel@tonic-gate void 50447c478bd9Sstevel@tonic-gate extendcg(long cylno) 50457c478bd9Sstevel@tonic-gate { 50467c478bd9Sstevel@tonic-gate int i; 50477c478bd9Sstevel@tonic-gate diskaddr_t dupper; 50487c478bd9Sstevel@tonic-gate diskaddr_t cbase; 50497c478bd9Sstevel@tonic-gate diskaddr_t dmax; 50507c478bd9Sstevel@tonic-gate 50517c478bd9Sstevel@tonic-gate /* 50527c478bd9Sstevel@tonic-gate * extend the cylinder group at the end of the old file system 50537c478bd9Sstevel@tonic-gate * if it was partially allocated becase of lack of space 50547c478bd9Sstevel@tonic-gate */ 50557c478bd9Sstevel@tonic-gate flcg(); 50567c478bd9Sstevel@tonic-gate rdcg(cylno); 50577c478bd9Sstevel@tonic-gate 50587c478bd9Sstevel@tonic-gate dupper = acg.cg_ndblk; 50597c478bd9Sstevel@tonic-gate if (cylno == sblock.fs_ncg - 1) 5060355d6bb5Sswilcox acg.cg_ncyl = sblock.fs_ncyl - (sblock.fs_cpg * cylno); 50617c478bd9Sstevel@tonic-gate else 50627c478bd9Sstevel@tonic-gate acg.cg_ncyl = sblock.fs_cpg; 50637c478bd9Sstevel@tonic-gate cbase = cgbase(&sblock, cylno); 50647c478bd9Sstevel@tonic-gate dmax = cbase + sblock.fs_fpg; 50657c478bd9Sstevel@tonic-gate if (dmax > sblock.fs_size) 50667c478bd9Sstevel@tonic-gate dmax = sblock.fs_size; 50677c478bd9Sstevel@tonic-gate acg.cg_ndblk = dmax - cbase; 50687c478bd9Sstevel@tonic-gate 50697c478bd9Sstevel@tonic-gate for (i = dupper; i < acg.cg_ndblk; ++i) 50707c478bd9Sstevel@tonic-gate setbit(cg_blksfree(&acg), i); 50717c478bd9Sstevel@tonic-gate 50727c478bd9Sstevel@tonic-gate sblock.fs_dsize += (acg.cg_ndblk - dupper); 50737c478bd9Sstevel@tonic-gate 50747c478bd9Sstevel@tonic-gate wtcg(); 50757c478bd9Sstevel@tonic-gate flcg(); 50767c478bd9Sstevel@tonic-gate } 50777c478bd9Sstevel@tonic-gate 50787c478bd9Sstevel@tonic-gate struct lockfs lockfs; 50797c478bd9Sstevel@tonic-gate int lockfd; 50807c478bd9Sstevel@tonic-gate int islocked; 50817c478bd9Sstevel@tonic-gate int lockfskey; 50827c478bd9Sstevel@tonic-gate char lockfscomment[128]; 50837c478bd9Sstevel@tonic-gate 50847c478bd9Sstevel@tonic-gate void 50857c478bd9Sstevel@tonic-gate ulockfs() 50867c478bd9Sstevel@tonic-gate { 50877c478bd9Sstevel@tonic-gate /* 50887c478bd9Sstevel@tonic-gate * if the file system was locked, unlock it before exiting 50897c478bd9Sstevel@tonic-gate */ 50907c478bd9Sstevel@tonic-gate if (islocked == 0) 50917c478bd9Sstevel@tonic-gate return; 50927c478bd9Sstevel@tonic-gate 50937c478bd9Sstevel@tonic-gate /* 50947c478bd9Sstevel@tonic-gate * first, check if the lock held 50957c478bd9Sstevel@tonic-gate */ 50967c478bd9Sstevel@tonic-gate lockfs.lf_flags = LOCKFS_MOD; 50977c478bd9Sstevel@tonic-gate if (ioctl(lockfd, _FIOLFSS, &lockfs) == -1) { 50987c478bd9Sstevel@tonic-gate perror(directory); 50997c478bd9Sstevel@tonic-gate lockexit(32); 51007c478bd9Sstevel@tonic-gate } 51017c478bd9Sstevel@tonic-gate 51027c478bd9Sstevel@tonic-gate if (LOCKFS_IS_MOD(&lockfs)) { 51037c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 51047c478bd9Sstevel@tonic-gate gettext("FILE SYSTEM CHANGED DURING GROWFS!\n")); 51057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 51067c478bd9Sstevel@tonic-gate gettext(" See lockfs(1), umount(1), and fsck(1)\n")); 51077c478bd9Sstevel@tonic-gate lockexit(32); 51087c478bd9Sstevel@tonic-gate } 51097c478bd9Sstevel@tonic-gate /* 51107c478bd9Sstevel@tonic-gate * unlock the file system 51117c478bd9Sstevel@tonic-gate */ 51127c478bd9Sstevel@tonic-gate lockfs.lf_lock = LOCKFS_ULOCK; 51137c478bd9Sstevel@tonic-gate lockfs.lf_flags = 0; 51147c478bd9Sstevel@tonic-gate lockfs.lf_key = lockfskey; 51157c478bd9Sstevel@tonic-gate clockfs(); 51167c478bd9Sstevel@tonic-gate if (ioctl(lockfd, _FIOLFS, &lockfs) == -1) { 51177c478bd9Sstevel@tonic-gate perror(directory); 51187c478bd9Sstevel@tonic-gate lockexit(32); 51197c478bd9Sstevel@tonic-gate } 51207c478bd9Sstevel@tonic-gate } 51217c478bd9Sstevel@tonic-gate 51227c478bd9Sstevel@tonic-gate void 51237c478bd9Sstevel@tonic-gate wlockfs() 51247c478bd9Sstevel@tonic-gate { 51257c478bd9Sstevel@tonic-gate 51267c478bd9Sstevel@tonic-gate /* 51277c478bd9Sstevel@tonic-gate * if no-write (-N), don't bother 51287c478bd9Sstevel@tonic-gate */ 51297c478bd9Sstevel@tonic-gate if (Nflag) 51307c478bd9Sstevel@tonic-gate return; 51317c478bd9Sstevel@tonic-gate /* 51327c478bd9Sstevel@tonic-gate * open the mountpoint, and write lock the file system 51337c478bd9Sstevel@tonic-gate */ 51347c478bd9Sstevel@tonic-gate if ((lockfd = open64(directory, O_RDONLY)) == -1) { 51357c478bd9Sstevel@tonic-gate perror(directory); 51367c478bd9Sstevel@tonic-gate lockexit(32); 51377c478bd9Sstevel@tonic-gate } 51387c478bd9Sstevel@tonic-gate 51397c478bd9Sstevel@tonic-gate /* 51407c478bd9Sstevel@tonic-gate * check if it is already locked 51417c478bd9Sstevel@tonic-gate */ 51427c478bd9Sstevel@tonic-gate if (ioctl(lockfd, _FIOLFSS, &lockfs) == -1) { 51437c478bd9Sstevel@tonic-gate perror(directory); 51447c478bd9Sstevel@tonic-gate lockexit(32); 51457c478bd9Sstevel@tonic-gate } 51467c478bd9Sstevel@tonic-gate 51477c478bd9Sstevel@tonic-gate if (lockfs.lf_lock != LOCKFS_WLOCK) { 51487c478bd9Sstevel@tonic-gate lockfs.lf_lock = LOCKFS_WLOCK; 51497c478bd9Sstevel@tonic-gate lockfs.lf_flags = 0; 51507c478bd9Sstevel@tonic-gate lockfs.lf_key = 0; 51517c478bd9Sstevel@tonic-gate clockfs(); 51527c478bd9Sstevel@tonic-gate if (ioctl(lockfd, _FIOLFS, &lockfs) == -1) { 51537c478bd9Sstevel@tonic-gate perror(directory); 51547c478bd9Sstevel@tonic-gate lockexit(32); 51557c478bd9Sstevel@tonic-gate } 51567c478bd9Sstevel@tonic-gate } 51577c478bd9Sstevel@tonic-gate islocked = 1; 51587c478bd9Sstevel@tonic-gate lockfskey = lockfs.lf_key; 51597c478bd9Sstevel@tonic-gate } 51607c478bd9Sstevel@tonic-gate 51617c478bd9Sstevel@tonic-gate void 51627c478bd9Sstevel@tonic-gate clockfs() 51637c478bd9Sstevel@tonic-gate { 51647c478bd9Sstevel@tonic-gate time_t t; 51657c478bd9Sstevel@tonic-gate char *ct; 51667c478bd9Sstevel@tonic-gate 51677c478bd9Sstevel@tonic-gate (void) time(&t); 51687c478bd9Sstevel@tonic-gate ct = ctime(&t); 51697c478bd9Sstevel@tonic-gate ct[strlen(ct)-1] = '\0'; 51707c478bd9Sstevel@tonic-gate 51717c478bd9Sstevel@tonic-gate (void) sprintf(lockfscomment, "%s -- mkfs pid %d", ct, getpid()); 51727c478bd9Sstevel@tonic-gate lockfs.lf_comlen = strlen(lockfscomment)+1; 51737c478bd9Sstevel@tonic-gate lockfs.lf_comment = lockfscomment; 51747c478bd9Sstevel@tonic-gate } 51757c478bd9Sstevel@tonic-gate 51767c478bd9Sstevel@tonic-gate /* 51777c478bd9Sstevel@tonic-gate * Write the csum records and the superblock 51787c478bd9Sstevel@tonic-gate */ 51797c478bd9Sstevel@tonic-gate void 51807c478bd9Sstevel@tonic-gate wtsb() 51817c478bd9Sstevel@tonic-gate { 51827c478bd9Sstevel@tonic-gate long i; 51837c478bd9Sstevel@tonic-gate 51847c478bd9Sstevel@tonic-gate /* 51857c478bd9Sstevel@tonic-gate * write summary information 51867c478bd9Sstevel@tonic-gate */ 51877c478bd9Sstevel@tonic-gate for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) 51887c478bd9Sstevel@tonic-gate wtfs(fsbtodb(&sblock, (uint64_t)(sblock.fs_csaddr + 51897c478bd9Sstevel@tonic-gate numfrags(&sblock, i))), 51907c478bd9Sstevel@tonic-gate (int)(sblock.fs_cssize - i < sblock.fs_bsize ? 51917c478bd9Sstevel@tonic-gate sblock.fs_cssize - i : sblock.fs_bsize), 51927c478bd9Sstevel@tonic-gate ((char *)fscs) + i); 51937c478bd9Sstevel@tonic-gate 51947c478bd9Sstevel@tonic-gate /* 51957c478bd9Sstevel@tonic-gate * write superblock 51967c478bd9Sstevel@tonic-gate */ 51977c478bd9Sstevel@tonic-gate sblock.fs_time = mkfstime; 51987c478bd9Sstevel@tonic-gate wtfs((diskaddr_t)(SBOFF / sectorsize), sbsize, (char *)&sblock); 51997c478bd9Sstevel@tonic-gate } 52007c478bd9Sstevel@tonic-gate 52017c478bd9Sstevel@tonic-gate /* 52027c478bd9Sstevel@tonic-gate * Verify that the optimization selection is reasonable, and advance 52037c478bd9Sstevel@tonic-gate * the global "string" appropriately. 52047c478bd9Sstevel@tonic-gate */ 52057c478bd9Sstevel@tonic-gate static char 52067c478bd9Sstevel@tonic-gate checkopt(char *optim) 52077c478bd9Sstevel@tonic-gate { 52087c478bd9Sstevel@tonic-gate char opt; 52097c478bd9Sstevel@tonic-gate int limit = strcspn(optim, ","); 52107c478bd9Sstevel@tonic-gate 52117c478bd9Sstevel@tonic-gate switch (limit) { 52127c478bd9Sstevel@tonic-gate case 0: /* missing indicator (have comma or nul) */ 52137c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52147c478bd9Sstevel@tonic-gate "mkfs: missing optimization flag reset to `t' (time)\n")); 52157c478bd9Sstevel@tonic-gate opt = 't'; 52167c478bd9Sstevel@tonic-gate break; 52177c478bd9Sstevel@tonic-gate 52187c478bd9Sstevel@tonic-gate case 1: /* single-character indicator */ 52197c478bd9Sstevel@tonic-gate opt = *optim; 52207c478bd9Sstevel@tonic-gate if ((opt != 's') && (opt != 't')) { 52217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52227c478bd9Sstevel@tonic-gate "mkfs: bad optimization value `%c' reset to `t' (time)\n"), 52237c478bd9Sstevel@tonic-gate opt); 52247c478bd9Sstevel@tonic-gate opt = 't'; 52257c478bd9Sstevel@tonic-gate } 52267c478bd9Sstevel@tonic-gate break; 52277c478bd9Sstevel@tonic-gate 52287c478bd9Sstevel@tonic-gate default: /* multi-character indicator */ 52297c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52307c478bd9Sstevel@tonic-gate "mkfs: bad optimization value `%*.*s' reset to `t' (time)\n"), 52317c478bd9Sstevel@tonic-gate limit, limit, optim); 52327c478bd9Sstevel@tonic-gate opt = 't'; 52337c478bd9Sstevel@tonic-gate break; 52347c478bd9Sstevel@tonic-gate } 52357c478bd9Sstevel@tonic-gate 52367c478bd9Sstevel@tonic-gate string += limit; 52377c478bd9Sstevel@tonic-gate 52387c478bd9Sstevel@tonic-gate return (opt); 52397c478bd9Sstevel@tonic-gate } 52407c478bd9Sstevel@tonic-gate 52417c478bd9Sstevel@tonic-gate /* 52427c478bd9Sstevel@tonic-gate * Verify that the mtb selection is reasonable, and advance 52437c478bd9Sstevel@tonic-gate * the global "string" appropriately. 52447c478bd9Sstevel@tonic-gate */ 52457c478bd9Sstevel@tonic-gate static char 52467c478bd9Sstevel@tonic-gate checkmtb(char *mtbarg) 52477c478bd9Sstevel@tonic-gate { 52487c478bd9Sstevel@tonic-gate char mtbc; 52497c478bd9Sstevel@tonic-gate int limit = strcspn(mtbarg, ","); 52507c478bd9Sstevel@tonic-gate 52517c478bd9Sstevel@tonic-gate switch (limit) { 52527c478bd9Sstevel@tonic-gate case 0: /* missing indicator (have comma or nul) */ 52537c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52547c478bd9Sstevel@tonic-gate "mkfs: missing mtb flag reset to `n' (no mtb support)\n")); 52557c478bd9Sstevel@tonic-gate mtbc = 'n'; 52567c478bd9Sstevel@tonic-gate break; 52577c478bd9Sstevel@tonic-gate 52587c478bd9Sstevel@tonic-gate case 1: /* single-character indicator */ 52597c478bd9Sstevel@tonic-gate mtbc = tolower(*mtbarg); 52607c478bd9Sstevel@tonic-gate if ((mtbc != 'y') && (mtbc != 'n')) { 52617c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52627c478bd9Sstevel@tonic-gate "mkfs: bad mtb value `%c' reset to `n' (no mtb support)\n"), 52637c478bd9Sstevel@tonic-gate mtbc); 52647c478bd9Sstevel@tonic-gate mtbc = 'n'; 52657c478bd9Sstevel@tonic-gate } 52667c478bd9Sstevel@tonic-gate break; 52677c478bd9Sstevel@tonic-gate 52687c478bd9Sstevel@tonic-gate default: /* multi-character indicator */ 52697c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52707c478bd9Sstevel@tonic-gate "mkfs: bad mtb value `%*.*s' reset to `n' (no mtb support)\n"), 52717c478bd9Sstevel@tonic-gate limit, limit, mtbarg); 52727c478bd9Sstevel@tonic-gate opt = 'n'; 52737c478bd9Sstevel@tonic-gate break; 52747c478bd9Sstevel@tonic-gate } 52757c478bd9Sstevel@tonic-gate 52767c478bd9Sstevel@tonic-gate string += limit; 52777c478bd9Sstevel@tonic-gate 52787c478bd9Sstevel@tonic-gate return (mtbc); 52797c478bd9Sstevel@tonic-gate } 52807c478bd9Sstevel@tonic-gate 52817c478bd9Sstevel@tonic-gate /* 52827c478bd9Sstevel@tonic-gate * Verify that a value is in a range. If it is not, resets it to 52837c478bd9Sstevel@tonic-gate * its default value if one is supplied, exits otherwise. 52847c478bd9Sstevel@tonic-gate * 52857c478bd9Sstevel@tonic-gate * When testing, can compare user_supplied to RC_KEYWORD or RC_POSITIONAL. 52867c478bd9Sstevel@tonic-gate */ 52877c478bd9Sstevel@tonic-gate static void 52887c478bd9Sstevel@tonic-gate range_check(long *varp, char *name, long minimum, long maximum, 52897c478bd9Sstevel@tonic-gate long def_val, int user_supplied) 52907c478bd9Sstevel@tonic-gate { 5291*6451fdbcSvsakar dprintf(("DeBuG %s : %ld (%ld %ld %ld)\n", 5292*6451fdbcSvsakar name, *varp, minimum, maximum, def_val)); 5293*6451fdbcSvsakar 52947c478bd9Sstevel@tonic-gate if ((*varp < minimum) || (*varp > maximum)) { 52957c478bd9Sstevel@tonic-gate if (user_supplied != RC_DEFAULT) { 52967c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 52977c478bd9Sstevel@tonic-gate "mkfs: bad value for %s: %ld must be between %ld and %ld\n"), 52987c478bd9Sstevel@tonic-gate name, *varp, minimum, maximum); 52997c478bd9Sstevel@tonic-gate } 53007c478bd9Sstevel@tonic-gate if (def_val != NO_DEFAULT) { 53017c478bd9Sstevel@tonic-gate if (user_supplied) { 53027c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 53037c478bd9Sstevel@tonic-gate gettext("mkfs: %s reset to default %ld\n"), 53047c478bd9Sstevel@tonic-gate name, def_val); 53057c478bd9Sstevel@tonic-gate } 53067c478bd9Sstevel@tonic-gate *varp = def_val; 5307*6451fdbcSvsakar dprintf(("DeBuG %s : %ld\n", name, *varp)); 53087c478bd9Sstevel@tonic-gate return; 53097c478bd9Sstevel@tonic-gate } 53107c478bd9Sstevel@tonic-gate lockexit(2); 53117c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 53127c478bd9Sstevel@tonic-gate } 53137c478bd9Sstevel@tonic-gate } 53147c478bd9Sstevel@tonic-gate 53157c478bd9Sstevel@tonic-gate /* 53167c478bd9Sstevel@tonic-gate * Verify that a value is in a range. If it is not, resets it to 53177c478bd9Sstevel@tonic-gate * its default value if one is supplied, exits otherwise. 53187c478bd9Sstevel@tonic-gate * 53197c478bd9Sstevel@tonic-gate * When testing, can compare user_supplied to RC_KEYWORD or RC_POSITIONAL. 53207c478bd9Sstevel@tonic-gate */ 53217c478bd9Sstevel@tonic-gate static void 53227c478bd9Sstevel@tonic-gate range_check_64(uint64_t *varp, char *name, uint64_t minimum, uint64_t maximum, 53237c478bd9Sstevel@tonic-gate uint64_t def_val, int user_supplied) 53247c478bd9Sstevel@tonic-gate { 53257c478bd9Sstevel@tonic-gate if ((*varp < minimum) || (*varp > maximum)) { 53267c478bd9Sstevel@tonic-gate if (user_supplied != RC_DEFAULT) { 53277c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext( 53287c478bd9Sstevel@tonic-gate "mkfs: bad value for %s: %lld must be between %lld and %lld\n"), 53297c478bd9Sstevel@tonic-gate name, *varp, minimum, maximum); 53307c478bd9Sstevel@tonic-gate } 53317c478bd9Sstevel@tonic-gate if (def_val != NO_DEFAULT) { 53327c478bd9Sstevel@tonic-gate if (user_supplied) { 53337c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 53347c478bd9Sstevel@tonic-gate gettext("mkfs: %s reset to default %lld\n"), 53357c478bd9Sstevel@tonic-gate name, def_val); 53367c478bd9Sstevel@tonic-gate } 53377c478bd9Sstevel@tonic-gate *varp = def_val; 53387c478bd9Sstevel@tonic-gate return; 53397c478bd9Sstevel@tonic-gate } 53407c478bd9Sstevel@tonic-gate lockexit(2); 53417c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 53427c478bd9Sstevel@tonic-gate } 53437c478bd9Sstevel@tonic-gate } 53447c478bd9Sstevel@tonic-gate 53457c478bd9Sstevel@tonic-gate /* 53467c478bd9Sstevel@tonic-gate * Blocks SIGINT from delivery. Returns the previous mask in the 53477c478bd9Sstevel@tonic-gate * buffer provided, so that mask may be later restored. 53487c478bd9Sstevel@tonic-gate */ 53497c478bd9Sstevel@tonic-gate static void 53507c478bd9Sstevel@tonic-gate block_sigint(sigset_t *old_mask) 53517c478bd9Sstevel@tonic-gate { 53527c478bd9Sstevel@tonic-gate sigset_t block_mask; 53537c478bd9Sstevel@tonic-gate 53547c478bd9Sstevel@tonic-gate if (sigemptyset(&block_mask) < 0) { 53557c478bd9Sstevel@tonic-gate fprintf(stderr, gettext("Could not clear signal mask\n")); 53567c478bd9Sstevel@tonic-gate lockexit(3); 53577c478bd9Sstevel@tonic-gate } 53587c478bd9Sstevel@tonic-gate if (sigaddset(&block_mask, SIGINT) < 0) { 53597c478bd9Sstevel@tonic-gate fprintf(stderr, gettext("Could not set signal mask\n")); 53607c478bd9Sstevel@tonic-gate lockexit(3); 53617c478bd9Sstevel@tonic-gate } 53627c478bd9Sstevel@tonic-gate if (sigprocmask(SIG_BLOCK, &block_mask, old_mask) < 0) { 53637c478bd9Sstevel@tonic-gate fprintf(stderr, gettext("Could not block SIGINT\n")); 53647c478bd9Sstevel@tonic-gate lockexit(3); 53657c478bd9Sstevel@tonic-gate } 53667c478bd9Sstevel@tonic-gate } 53677c478bd9Sstevel@tonic-gate 53687c478bd9Sstevel@tonic-gate /* 53697c478bd9Sstevel@tonic-gate * Restores the signal mask that was in force before a call 53707c478bd9Sstevel@tonic-gate * to block_sigint(). This may actually still have SIGINT blocked, 53717c478bd9Sstevel@tonic-gate * if we've been recursively invoked. 53727c478bd9Sstevel@tonic-gate */ 53737c478bd9Sstevel@tonic-gate static void 53747c478bd9Sstevel@tonic-gate unblock_sigint(sigset_t *old_mask) 53757c478bd9Sstevel@tonic-gate { 53767c478bd9Sstevel@tonic-gate if (sigprocmask(SIG_UNBLOCK, old_mask, (sigset_t *)NULL) < 0) { 53777c478bd9Sstevel@tonic-gate fprintf(stderr, gettext("Could not restore signal mask\n")); 53787c478bd9Sstevel@tonic-gate lockexit(3); 53797c478bd9Sstevel@tonic-gate } 53807c478bd9Sstevel@tonic-gate } 53817c478bd9Sstevel@tonic-gate 53827c478bd9Sstevel@tonic-gate /* 53837c478bd9Sstevel@tonic-gate * Attempt to be somewhat graceful about being interrupted, rather than 53847c478bd9Sstevel@tonic-gate * just silently leaving the filesystem in an unusable state. 53857c478bd9Sstevel@tonic-gate * 53867c478bd9Sstevel@tonic-gate * The kernel has blocked SIGINT upon entry, so we don't have to worry 53877c478bd9Sstevel@tonic-gate * about recursion if the user starts pounding on the keyboard. 53887c478bd9Sstevel@tonic-gate */ 53897c478bd9Sstevel@tonic-gate static void 53907c478bd9Sstevel@tonic-gate recover_from_sigint(int signum) 53917c478bd9Sstevel@tonic-gate { 53927c478bd9Sstevel@tonic-gate if (fso > -1) { 53937c478bd9Sstevel@tonic-gate if ((Nflag != 0) || confirm_abort()) { 53947c478bd9Sstevel@tonic-gate lockexit(4); 53957c478bd9Sstevel@tonic-gate } 53967c478bd9Sstevel@tonic-gate } 53977c478bd9Sstevel@tonic-gate } 53987c478bd9Sstevel@tonic-gate 53997c478bd9Sstevel@tonic-gate static int 54007c478bd9Sstevel@tonic-gate confirm_abort(void) 54017c478bd9Sstevel@tonic-gate { 54027c478bd9Sstevel@tonic-gate char line[80]; 54037c478bd9Sstevel@tonic-gate 54047c478bd9Sstevel@tonic-gate printf(gettext("\n\nAborting at this point will leave the filesystem " 54057c478bd9Sstevel@tonic-gate "in an inconsistent\nstate. If you do choose to stop, " 54067c478bd9Sstevel@tonic-gate "you will be given instructions on how to\nrecover " 54077c478bd9Sstevel@tonic-gate "the filesystem. Do you wish to cancel the filesystem " 54087c478bd9Sstevel@tonic-gate "grow\noperation (y/n)?")); 54097c478bd9Sstevel@tonic-gate if (getline(stdin, line, sizeof (line)) == EOF) 54107c478bd9Sstevel@tonic-gate line[0] = 'y'; 54117c478bd9Sstevel@tonic-gate 54127c478bd9Sstevel@tonic-gate printf("\n"); 54137c478bd9Sstevel@tonic-gate if (line[0] == 'y' || line[0] == 'Y') 54147c478bd9Sstevel@tonic-gate return (1); 54157c478bd9Sstevel@tonic-gate else { 54167c478bd9Sstevel@tonic-gate return (0); 54177c478bd9Sstevel@tonic-gate } 54187c478bd9Sstevel@tonic-gate } 54197c478bd9Sstevel@tonic-gate 54207c478bd9Sstevel@tonic-gate static int 54217c478bd9Sstevel@tonic-gate getline(FILE *fp, char *loc, int maxlen) 54227c478bd9Sstevel@tonic-gate { 54237c478bd9Sstevel@tonic-gate int n; 54247c478bd9Sstevel@tonic-gate char *p, *lastloc; 54257c478bd9Sstevel@tonic-gate 54267c478bd9Sstevel@tonic-gate p = loc; 54277c478bd9Sstevel@tonic-gate lastloc = &p[maxlen-1]; 54287c478bd9Sstevel@tonic-gate while ((n = getc(fp)) != '\n') { 54297c478bd9Sstevel@tonic-gate if (n == EOF) 54307c478bd9Sstevel@tonic-gate return (EOF); 54317c478bd9Sstevel@tonic-gate if (!isspace(n) && p < lastloc) 54327c478bd9Sstevel@tonic-gate *p++ = n; 54337c478bd9Sstevel@tonic-gate } 54347c478bd9Sstevel@tonic-gate *p = 0; 54357c478bd9Sstevel@tonic-gate return (p - loc); 54367c478bd9Sstevel@tonic-gate } 54377c478bd9Sstevel@tonic-gate 54387c478bd9Sstevel@tonic-gate /* 54397c478bd9Sstevel@tonic-gate * Calculate the maximum value of cylinders-per-group for a file 54407c478bd9Sstevel@tonic-gate * system with the characteristics: 54417c478bd9Sstevel@tonic-gate * 54427c478bd9Sstevel@tonic-gate * bsize - file system block size 54437c478bd9Sstevel@tonic-gate * fragsize - frag size 54447c478bd9Sstevel@tonic-gate * nbpi - number of bytes of disk space per inode 54457c478bd9Sstevel@tonic-gate * nrpos - number of rotational positions 54467c478bd9Sstevel@tonic-gate * spc - sectors per cylinder 54477c478bd9Sstevel@tonic-gate * 54487c478bd9Sstevel@tonic-gate * These five characteristic are not adjustable (by this function). 54497c478bd9Sstevel@tonic-gate * The only attribute of the file system which IS adjusted by this 54507c478bd9Sstevel@tonic-gate * function in order to maximize cylinders-per-group is the proportion 54517c478bd9Sstevel@tonic-gate * of the cylinder group overhead block used for the inode map. The 54527c478bd9Sstevel@tonic-gate * inode map cannot occupy more than one-third of the cylinder group 54537c478bd9Sstevel@tonic-gate * overhead block, but it's OK for it to occupy less than one-third 54547c478bd9Sstevel@tonic-gate * of the overhead block. 54557c478bd9Sstevel@tonic-gate * 54567c478bd9Sstevel@tonic-gate * The setting of nbpi determines one possible value for the maximum 54577c478bd9Sstevel@tonic-gate * size of a cylinder group. It does so because it determines the total 54587c478bd9Sstevel@tonic-gate * number of inodes in the file system (file system size is fixed, and 54597c478bd9Sstevel@tonic-gate * nbpi is fixed, so the total number of inodes is fixed too). The 54607c478bd9Sstevel@tonic-gate * cylinder group has to be small enough so that the number of inodes 54617c478bd9Sstevel@tonic-gate * in the cylinder group is less than or equal to the number of bits 54627c478bd9Sstevel@tonic-gate * in one-third (or whatever proportion is assumed) of a file system 54637c478bd9Sstevel@tonic-gate * block. The details of the calculation are: 54647c478bd9Sstevel@tonic-gate * 54657c478bd9Sstevel@tonic-gate * The macro MAXIpG_B(bsize, inode_divisor) determines the maximum 54667c478bd9Sstevel@tonic-gate * number of inodes that can be in a cylinder group, given the 54677c478bd9Sstevel@tonic-gate * proportion of the cylinder group overhead block used for the 54687c478bd9Sstevel@tonic-gate * inode bitmaps (an inode_divisor of 3 means that 1/3 of the 54697c478bd9Sstevel@tonic-gate * block is used for inode bitmaps; an inode_divisor of 12 means 54707c478bd9Sstevel@tonic-gate * that 1/12 of the block is used for inode bitmaps.) 54717c478bd9Sstevel@tonic-gate * 54727c478bd9Sstevel@tonic-gate * Once the number of inodes per cylinder group is known, the 54737c478bd9Sstevel@tonic-gate * maximum value of cylinders-per-group (determined by nbpi) 54747c478bd9Sstevel@tonic-gate * is calculated by the formula 54757c478bd9Sstevel@tonic-gate * 54767c478bd9Sstevel@tonic-gate * maxcpg_given_nbpi = (size of a cylinder group)/(size of a cylinder) 54777c478bd9Sstevel@tonic-gate * 54787c478bd9Sstevel@tonic-gate * = (inodes-per-cg * nbpi)/(spc * DEV_BSIZE) 54797c478bd9Sstevel@tonic-gate * 54807c478bd9Sstevel@tonic-gate * (Interestingly, the size of the file system never enters 54817c478bd9Sstevel@tonic-gate * into this calculation.) 54827c478bd9Sstevel@tonic-gate * 54837c478bd9Sstevel@tonic-gate * Another possible value for the maximum cylinder group size is determined 54847c478bd9Sstevel@tonic-gate * by frag_size and nrpos. The frags in the cylinder group must be 54857c478bd9Sstevel@tonic-gate * representable in the frag bitmaps in the cylinder overhead block and the 54867c478bd9Sstevel@tonic-gate * rotational positions for each cylinder must be represented in the 54877c478bd9Sstevel@tonic-gate * rotational position tables. The calculation of the maximum cpg 54887c478bd9Sstevel@tonic-gate * value, given the frag and nrpos vales, is: 54897c478bd9Sstevel@tonic-gate * 54907c478bd9Sstevel@tonic-gate * maxcpg_given_fragsize = 54917c478bd9Sstevel@tonic-gate * (available space in the overhead block) / (size of per-cylinder data) 54927c478bd9Sstevel@tonic-gate * 54937c478bd9Sstevel@tonic-gate * The available space in the overhead block = 54947c478bd9Sstevel@tonic-gate * bsize - sizeof (struct cg) - space_used_for_inode_bitmaps 54957c478bd9Sstevel@tonic-gate * 54967c478bd9Sstevel@tonic-gate * The size of the per-cylinder data is: 54977c478bd9Sstevel@tonic-gate * sizeof(long) # for the "blocks avail per cylinder" field 54987c478bd9Sstevel@tonic-gate * + nrpos * sizeof(short) # for the rotational position table entry 54997c478bd9Sstevel@tonic-gate * + frags-per-cylinder/NBBY # number of bytes to represent this 55007c478bd9Sstevel@tonic-gate * # cylinder in the frag bitmap 55017c478bd9Sstevel@tonic-gate * 55027c478bd9Sstevel@tonic-gate * The two calculated maximum values of cylinder-per-group will typically 55037c478bd9Sstevel@tonic-gate * turn out to be different, since they are derived from two different 55047c478bd9Sstevel@tonic-gate * constraints. Usually, maxcpg_given_nbpi is much bigger than 55057c478bd9Sstevel@tonic-gate * maxcpg_given_fragsize. But they can be brought together by 55067c478bd9Sstevel@tonic-gate * adjusting the proportion of the overhead block dedicated to 55077c478bd9Sstevel@tonic-gate * the inode bitmaps. Decreasing the proportion of the cylinder 55087c478bd9Sstevel@tonic-gate * group overhead block used for inode maps will decrease 55097c478bd9Sstevel@tonic-gate * maxcpg_given_nbpi and increase maxcpg_given_fragsize. 55107c478bd9Sstevel@tonic-gate * 55117c478bd9Sstevel@tonic-gate * This function calculates the initial values of maxcpg_given_nbpi 55127c478bd9Sstevel@tonic-gate * and maxcpg_given_fragsize assuming that 1/3 of the cg overhead 55137c478bd9Sstevel@tonic-gate * block is used for inode bitmaps. Then it decreases the proportion 55147c478bd9Sstevel@tonic-gate * of the cg overhead block used for inode bitmaps (by increasing 55157c478bd9Sstevel@tonic-gate * the value of inode_divisor) until maxcpg_given_nbpi and 55167c478bd9Sstevel@tonic-gate * maxcpg_given_fragsize are the same, or stop changing, or 55177c478bd9Sstevel@tonic-gate * maxcpg_given_nbpi is less than maxcpg_given_fragsize. 55187c478bd9Sstevel@tonic-gate * 55197c478bd9Sstevel@tonic-gate * The loop terminates when any of the following occur: 55207c478bd9Sstevel@tonic-gate * * maxcpg_given_fragsize is greater than or equal to 55217c478bd9Sstevel@tonic-gate * maxcpg_given_nbpi 55227c478bd9Sstevel@tonic-gate * * neither maxcpg_given_fragsize nor maxcpg_given_nbpi 55237c478bd9Sstevel@tonic-gate * change in the expected direction 55247c478bd9Sstevel@tonic-gate * 55257c478bd9Sstevel@tonic-gate * The loop is guaranteed to terminate because it only continues 55267c478bd9Sstevel@tonic-gate * while maxcpg_given_fragsize and maxcpg_given_nbpi are approaching 55277c478bd9Sstevel@tonic-gate * each other. As soon they cross each other, or neither one changes 55287c478bd9Sstevel@tonic-gate * in the direction of the other, or one of them moves in the wrong 55297c478bd9Sstevel@tonic-gate * direction, the loop completes. 55307c478bd9Sstevel@tonic-gate */ 55317c478bd9Sstevel@tonic-gate 55327c478bd9Sstevel@tonic-gate static long 55337c478bd9Sstevel@tonic-gate compute_maxcpg(long bsize, long fragsize, long nbpi, long nrpos, long spc) 55347c478bd9Sstevel@tonic-gate { 55357c478bd9Sstevel@tonic-gate int maxcpg_given_nbpi; /* in cylinders */ 55367c478bd9Sstevel@tonic-gate int maxcpg_given_fragsize; /* in cylinders */ 55377c478bd9Sstevel@tonic-gate int spf; /* sectors per frag */ 55387c478bd9Sstevel@tonic-gate int inode_divisor; 55397c478bd9Sstevel@tonic-gate int old_max_given_frag = 0; 55407c478bd9Sstevel@tonic-gate int old_max_given_nbpi = INT_MAX; 55417c478bd9Sstevel@tonic-gate 55427c478bd9Sstevel@tonic-gate spf = fragsize / DEV_BSIZE; 55437c478bd9Sstevel@tonic-gate inode_divisor = 3; 55447c478bd9Sstevel@tonic-gate 55457c478bd9Sstevel@tonic-gate while (1) { 55467c478bd9Sstevel@tonic-gate maxcpg_given_nbpi = 55477c478bd9Sstevel@tonic-gate (((int64_t)(MAXIpG_B(bsize, inode_divisor))) * nbpi) / 55487c478bd9Sstevel@tonic-gate (DEV_BSIZE * ((int64_t)spc)); 55497c478bd9Sstevel@tonic-gate maxcpg_given_fragsize = 55507c478bd9Sstevel@tonic-gate (bsize - (sizeof (struct cg)) - (bsize / inode_divisor)) / 55517c478bd9Sstevel@tonic-gate (sizeof (long) + nrpos * sizeof (short) + 55527c478bd9Sstevel@tonic-gate (spc / spf) / NBBY); 55537c478bd9Sstevel@tonic-gate 55547c478bd9Sstevel@tonic-gate if (maxcpg_given_fragsize >= maxcpg_given_nbpi) 55557c478bd9Sstevel@tonic-gate return (maxcpg_given_nbpi); 55567c478bd9Sstevel@tonic-gate 55577c478bd9Sstevel@tonic-gate /* 55587c478bd9Sstevel@tonic-gate * If neither value moves toward the other, return the 55597c478bd9Sstevel@tonic-gate * least of the old values (we use the old instead of the 55607c478bd9Sstevel@tonic-gate * new because: if the old is the same as the new, it 55617c478bd9Sstevel@tonic-gate * doesn't matter which ones we use. If one of the 55627c478bd9Sstevel@tonic-gate * values changed, but in the wrong direction, the 55637c478bd9Sstevel@tonic-gate * new values are suspect. Better use the old. This 55647c478bd9Sstevel@tonic-gate * shouldn't happen, but it's best to check. 55657c478bd9Sstevel@tonic-gate */ 55667c478bd9Sstevel@tonic-gate 55677c478bd9Sstevel@tonic-gate if (!(maxcpg_given_nbpi < old_max_given_nbpi) && 55687c478bd9Sstevel@tonic-gate !(maxcpg_given_fragsize > old_max_given_frag)) 55697c478bd9Sstevel@tonic-gate return (MIN(old_max_given_nbpi, old_max_given_frag)); 55707c478bd9Sstevel@tonic-gate 55717c478bd9Sstevel@tonic-gate /* 55727c478bd9Sstevel@tonic-gate * This is probably impossible, but if one of the maxcpg 55737c478bd9Sstevel@tonic-gate * values moved in the "right" direction and one moved 55747c478bd9Sstevel@tonic-gate * in the "wrong" direction (that is, the two values moved 55757c478bd9Sstevel@tonic-gate * in the same direction), the previous conditional won't 55767c478bd9Sstevel@tonic-gate * recognize that the values aren't converging (since at 55777c478bd9Sstevel@tonic-gate * least one value moved in the "right" direction, the 55787c478bd9Sstevel@tonic-gate * last conditional says "keep going"). 55797c478bd9Sstevel@tonic-gate * 55807c478bd9Sstevel@tonic-gate * Just to make absolutely certain that the loop terminates, 55817c478bd9Sstevel@tonic-gate * check for one of the values moving in the "wrong" direction 55827c478bd9Sstevel@tonic-gate * and terminate the loop if it happens. 55837c478bd9Sstevel@tonic-gate */ 55847c478bd9Sstevel@tonic-gate 55857c478bd9Sstevel@tonic-gate if (maxcpg_given_nbpi > old_max_given_nbpi || 55867c478bd9Sstevel@tonic-gate maxcpg_given_fragsize < old_max_given_frag) 55877c478bd9Sstevel@tonic-gate return (MIN(old_max_given_nbpi, old_max_given_frag)); 55887c478bd9Sstevel@tonic-gate 55897c478bd9Sstevel@tonic-gate old_max_given_nbpi = maxcpg_given_nbpi; 55907c478bd9Sstevel@tonic-gate old_max_given_frag = maxcpg_given_fragsize; 55917c478bd9Sstevel@tonic-gate 55927c478bd9Sstevel@tonic-gate inode_divisor++; 55937c478bd9Sstevel@tonic-gate } 55947c478bd9Sstevel@tonic-gate } 55957c478bd9Sstevel@tonic-gate 55967c478bd9Sstevel@tonic-gate static int 55977c478bd9Sstevel@tonic-gate in_64bit_mode(void) 55987c478bd9Sstevel@tonic-gate { 55997c478bd9Sstevel@tonic-gate /* cmd must be an absolute path, for security */ 56007c478bd9Sstevel@tonic-gate char *cmd = "/usr/bin/isainfo -b"; 56017c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 56027c478bd9Sstevel@tonic-gate FILE *ptr; 56037c478bd9Sstevel@tonic-gate int retval = 0; 56047c478bd9Sstevel@tonic-gate 56057c478bd9Sstevel@tonic-gate putenv("IFS= \t"); 56067c478bd9Sstevel@tonic-gate if ((ptr = popen(cmd, "r")) != NULL) { 56077c478bd9Sstevel@tonic-gate if (fgets(buf, BUFSIZ, ptr) != NULL && 56087c478bd9Sstevel@tonic-gate strncmp(buf, "64", 2) == 0) 56097c478bd9Sstevel@tonic-gate retval = 1; 56107c478bd9Sstevel@tonic-gate (void) pclose(ptr); 56117c478bd9Sstevel@tonic-gate } 56127c478bd9Sstevel@tonic-gate return (retval); 56137c478bd9Sstevel@tonic-gate } 56147c478bd9Sstevel@tonic-gate 56157c478bd9Sstevel@tonic-gate /* 56167c478bd9Sstevel@tonic-gate * validate_size 56177c478bd9Sstevel@tonic-gate * 56187c478bd9Sstevel@tonic-gate * Return 1 if the device appears to be at least "size" sectors long. 56197c478bd9Sstevel@tonic-gate * Return 0 if it's shorter or we can't read it. 56207c478bd9Sstevel@tonic-gate */ 56217c478bd9Sstevel@tonic-gate 56227c478bd9Sstevel@tonic-gate static int 56237c478bd9Sstevel@tonic-gate validate_size(int fd, diskaddr_t size) 56247c478bd9Sstevel@tonic-gate { 56257c478bd9Sstevel@tonic-gate char buf[DEV_BSIZE]; 56267c478bd9Sstevel@tonic-gate int rc; 56277c478bd9Sstevel@tonic-gate 56287c478bd9Sstevel@tonic-gate if ((llseek(fd, (offset_t)((size - 1) * DEV_BSIZE), SEEK_SET) == -1) || 56297c478bd9Sstevel@tonic-gate (read(fd, buf, DEV_BSIZE)) != DEV_BSIZE) 56307c478bd9Sstevel@tonic-gate rc = 0; 56317c478bd9Sstevel@tonic-gate else 56327c478bd9Sstevel@tonic-gate rc = 1; 56337c478bd9Sstevel@tonic-gate return (rc); 56347c478bd9Sstevel@tonic-gate } 5635355d6bb5Sswilcox 5636355d6bb5Sswilcox /* 5637355d6bb5Sswilcox * Print every field of the calculated superblock, along with 5638355d6bb5Sswilcox * its value. To make parsing easier on the caller, the value 5639355d6bb5Sswilcox * is printed first, then the name. Additionally, there's only 5640355d6bb5Sswilcox * one name/value pair per line. All values are reported in 5641355d6bb5Sswilcox * hexadecimal (with the traditional 0x prefix), as that's slightly 5642355d6bb5Sswilcox * easier for humans to read. Not that they're expected to, but 5643355d6bb5Sswilcox * debugging happens. 5644355d6bb5Sswilcox */ 5645355d6bb5Sswilcox static void 5646355d6bb5Sswilcox dump_sblock(void) 5647355d6bb5Sswilcox { 5648355d6bb5Sswilcox int row, column, pending, written; 5649355d6bb5Sswilcox caddr_t source; 5650355d6bb5Sswilcox 5651355d6bb5Sswilcox if (Rflag) { 5652355d6bb5Sswilcox pending = sizeof (sblock); 5653355d6bb5Sswilcox source = (caddr_t)&sblock; 5654355d6bb5Sswilcox do { 5655355d6bb5Sswilcox written = write(fileno(stdout), source, pending); 5656355d6bb5Sswilcox pending -= written; 5657355d6bb5Sswilcox source += written; 5658355d6bb5Sswilcox } while ((pending > 0) && (written > 0)); 5659355d6bb5Sswilcox 5660355d6bb5Sswilcox if (written < 0) { 5661355d6bb5Sswilcox perror(gettext("Binary dump of superblock failed")); 5662355d6bb5Sswilcox lockexit(1); 5663355d6bb5Sswilcox } 5664355d6bb5Sswilcox return; 5665355d6bb5Sswilcox } else { 5666355d6bb5Sswilcox printf("0x%x sblock.fs_link\n", sblock.fs_link); 5667355d6bb5Sswilcox printf("0x%x sblock.fs_rolled\n", sblock.fs_rolled); 5668355d6bb5Sswilcox printf("0x%x sblock.fs_sblkno\n", sblock.fs_sblkno); 5669355d6bb5Sswilcox printf("0x%x sblock.fs_cblkno\n", sblock.fs_cblkno); 5670355d6bb5Sswilcox printf("0x%x sblock.fs_iblkno\n", sblock.fs_iblkno); 5671355d6bb5Sswilcox printf("0x%x sblock.fs_dblkno\n", sblock.fs_dblkno); 5672355d6bb5Sswilcox printf("0x%x sblock.fs_cgoffset\n", sblock.fs_cgoffset); 5673355d6bb5Sswilcox printf("0x%x sblock.fs_cgmask\n", sblock.fs_cgmask); 5674355d6bb5Sswilcox printf("0x%x sblock.fs_time\n", sblock.fs_time); 5675355d6bb5Sswilcox printf("0x%x sblock.fs_size\n", sblock.fs_size); 5676355d6bb5Sswilcox printf("0x%x sblock.fs_dsize\n", sblock.fs_dsize); 5677355d6bb5Sswilcox printf("0x%x sblock.fs_ncg\n", sblock.fs_ncg); 5678355d6bb5Sswilcox printf("0x%x sblock.fs_bsize\n", sblock.fs_bsize); 5679355d6bb5Sswilcox printf("0x%x sblock.fs_fsize\n", sblock.fs_fsize); 5680355d6bb5Sswilcox printf("0x%x sblock.fs_frag\n", sblock.fs_frag); 5681355d6bb5Sswilcox printf("0x%x sblock.fs_minfree\n", sblock.fs_minfree); 5682355d6bb5Sswilcox printf("0x%x sblock.fs_rotdelay\n", sblock.fs_rotdelay); 5683355d6bb5Sswilcox printf("0x%x sblock.fs_rps\n", sblock.fs_rps); 5684355d6bb5Sswilcox printf("0x%x sblock.fs_bmask\n", sblock.fs_bmask); 5685355d6bb5Sswilcox printf("0x%x sblock.fs_fmask\n", sblock.fs_fmask); 5686355d6bb5Sswilcox printf("0x%x sblock.fs_bshift\n", sblock.fs_bshift); 5687355d6bb5Sswilcox printf("0x%x sblock.fs_fshift\n", sblock.fs_fshift); 5688355d6bb5Sswilcox printf("0x%x sblock.fs_maxcontig\n", sblock.fs_maxcontig); 5689355d6bb5Sswilcox printf("0x%x sblock.fs_maxbpg\n", sblock.fs_maxbpg); 5690355d6bb5Sswilcox printf("0x%x sblock.fs_fragshift\n", sblock.fs_fragshift); 5691355d6bb5Sswilcox printf("0x%x sblock.fs_fsbtodb\n", sblock.fs_fsbtodb); 5692355d6bb5Sswilcox printf("0x%x sblock.fs_sbsize\n", sblock.fs_sbsize); 5693355d6bb5Sswilcox printf("0x%x sblock.fs_csmask\n", sblock.fs_csmask); 5694355d6bb5Sswilcox printf("0x%x sblock.fs_csshift\n", sblock.fs_csshift); 5695355d6bb5Sswilcox printf("0x%x sblock.fs_nindir\n", sblock.fs_nindir); 5696355d6bb5Sswilcox printf("0x%x sblock.fs_inopb\n", sblock.fs_inopb); 5697355d6bb5Sswilcox printf("0x%x sblock.fs_nspf\n", sblock.fs_nspf); 5698355d6bb5Sswilcox printf("0x%x sblock.fs_optim\n", sblock.fs_optim); 5699355d6bb5Sswilcox #ifdef _LITTLE_ENDIAN 5700355d6bb5Sswilcox printf("0x%x sblock.fs_state\n", sblock.fs_state); 5701355d6bb5Sswilcox #else 5702355d6bb5Sswilcox printf("0x%x sblock.fs_npsect\n", sblock.fs_npsect); 5703355d6bb5Sswilcox #endif 5704355d6bb5Sswilcox printf("0x%x sblock.fs_si\n", sblock.fs_si); 5705355d6bb5Sswilcox printf("0x%x sblock.fs_trackskew\n", sblock.fs_trackskew); 5706355d6bb5Sswilcox printf("0x%x sblock.fs_id[0]\n", sblock.fs_id[0]); 5707355d6bb5Sswilcox printf("0x%x sblock.fs_id[1]\n", sblock.fs_id[1]); 5708355d6bb5Sswilcox printf("0x%x sblock.fs_csaddr\n", sblock.fs_csaddr); 5709355d6bb5Sswilcox printf("0x%x sblock.fs_cssize\n", sblock.fs_cssize); 5710355d6bb5Sswilcox printf("0x%x sblock.fs_cgsize\n", sblock.fs_cgsize); 5711355d6bb5Sswilcox printf("0x%x sblock.fs_ntrak\n", sblock.fs_ntrak); 5712355d6bb5Sswilcox printf("0x%x sblock.fs_nsect\n", sblock.fs_nsect); 5713355d6bb5Sswilcox printf("0x%x sblock.fs_spc\n", sblock.fs_spc); 5714355d6bb5Sswilcox printf("0x%x sblock.fs_ncyl\n", sblock.fs_ncyl); 5715355d6bb5Sswilcox printf("0x%x sblock.fs_cpg\n", sblock.fs_cpg); 5716355d6bb5Sswilcox printf("0x%x sblock.fs_ipg\n", sblock.fs_ipg); 5717355d6bb5Sswilcox printf("0x%x sblock.fs_fpg\n", sblock.fs_fpg); 5718355d6bb5Sswilcox printf("0x%x sblock.fs_cstotal\n", sblock.fs_cstotal); 5719355d6bb5Sswilcox printf("0x%x sblock.fs_fmod\n", sblock.fs_fmod); 5720355d6bb5Sswilcox printf("0x%x sblock.fs_clean\n", sblock.fs_clean); 5721355d6bb5Sswilcox printf("0x%x sblock.fs_ronly\n", sblock.fs_ronly); 5722355d6bb5Sswilcox printf("0x%x sblock.fs_flags\n", sblock.fs_flags); 5723355d6bb5Sswilcox printf("0x%x sblock.fs_fsmnt\n", sblock.fs_fsmnt); 5724355d6bb5Sswilcox printf("0x%x sblock.fs_cgrotor\n", sblock.fs_cgrotor); 5725355d6bb5Sswilcox printf("0x%x sblock.fs_u.fs_csp\n", sblock.fs_u.fs_csp); 5726355d6bb5Sswilcox printf("0x%x sblock.fs_cpc\n", sblock.fs_cpc); 5727355d6bb5Sswilcox 5728355d6bb5Sswilcox /* 5729355d6bb5Sswilcox * No macros are defined for the dimensions of the 5730355d6bb5Sswilcox * opostbl array. 5731355d6bb5Sswilcox */ 5732355d6bb5Sswilcox for (row = 0; row < 16; row++) { 5733355d6bb5Sswilcox for (column = 0; column < 8; column++) { 5734355d6bb5Sswilcox printf("0x%x sblock.fs_opostbl[%d][%d]\n", 5735355d6bb5Sswilcox sblock.fs_opostbl[row][column], 5736355d6bb5Sswilcox row, column); 5737355d6bb5Sswilcox } 5738355d6bb5Sswilcox } 5739355d6bb5Sswilcox 5740355d6bb5Sswilcox /* 5741355d6bb5Sswilcox * Ditto the size of sparecon. 5742355d6bb5Sswilcox */ 5743355d6bb5Sswilcox for (row = 0; row < 51; row++) { 5744355d6bb5Sswilcox printf("0x%x sblock.fs_sparecon[%d]\n", 5745355d6bb5Sswilcox sblock.fs_sparecon[row], row); 5746355d6bb5Sswilcox } 5747355d6bb5Sswilcox 5748355d6bb5Sswilcox printf("0x%x sblock.fs_version\n", sblock.fs_version); 5749355d6bb5Sswilcox printf("0x%x sblock.fs_logbno\n", sblock.fs_logbno); 5750355d6bb5Sswilcox printf("0x%x sblock.fs_reclaim\n", sblock.fs_reclaim); 5751355d6bb5Sswilcox printf("0x%x sblock.fs_sparecon2\n", sblock.fs_sparecon2); 5752355d6bb5Sswilcox #ifdef _LITTLE_ENDIAN 5753355d6bb5Sswilcox printf("0x%x sblock.fs_npsect\n", sblock.fs_npsect); 5754355d6bb5Sswilcox #else 5755355d6bb5Sswilcox printf("0x%x sblock.fs_state\n", sblock.fs_state); 5756355d6bb5Sswilcox #endif 5757355d6bb5Sswilcox printf("0x%llx sblock.fs_qbmask\n", sblock.fs_qbmask); 5758355d6bb5Sswilcox printf("0x%llx sblock.fs_qfmask\n", sblock.fs_qfmask); 5759355d6bb5Sswilcox printf("0x%x sblock.fs_postblformat\n", sblock.fs_postblformat); 5760355d6bb5Sswilcox printf("0x%x sblock.fs_nrpos\n", sblock.fs_nrpos); 5761355d6bb5Sswilcox printf("0x%x sblock.fs_postbloff\n", sblock.fs_postbloff); 5762355d6bb5Sswilcox printf("0x%x sblock.fs_rotbloff\n", sblock.fs_rotbloff); 5763355d6bb5Sswilcox printf("0x%x sblock.fs_magic\n", sblock.fs_magic); 5764355d6bb5Sswilcox 5765355d6bb5Sswilcox /* 5766355d6bb5Sswilcox * fs_space isn't of much use in this context, so we'll 5767355d6bb5Sswilcox * just ignore it for now. 5768355d6bb5Sswilcox */ 5769355d6bb5Sswilcox } 5770355d6bb5Sswilcox } 5771