sbin/growfs/growfs.c

   1 /*
   2  * Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
   3  * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
   4  * Copyright (c) 2012 The FreeBSD Foundation
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt.
   9  *
  10  * Portions of this software were developed by Edward Tomasz Napierala
  11  * under sponsorship from the FreeBSD Foundation.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgment:
  23  *      This product includes software developed by the University of
  24  *      California, Berkeley and its contributors, as well as Christoph
  25  *      Herrmann and Thomas-Henning von Kamptz.
  26  * 4. Neither the name of the University nor the names of its contributors
  27  *    may be used to endorse or promote products derived from this software
  28  *    without specific prior written permission.
  29  *
  30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  40  * SUCH DAMAGE.
  41  *
  42  * $TSHeader: src/sbin/growfs/growfs.c,v 1.5 2000/12/12 19:31:00 tomsoft Exp $
  43  *
  44  */
  45
  46 #ifndef lint
  47 static const char copyright[] =
  48 "@(#) Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz\n\
  49 Copyright (c) 1980, 1989, 1993 The Regents of the University of California.\n\
  50 All rights reserved.\n";
  51 #endif /* not lint */
  52
  53 #include <sys/cdefs.h>
  54 __FBSDID("$FreeBSD$");
  55
  56 #include <sys/param.h>
  57 #include <sys/ioctl.h>
  58 #include <sys/stat.h>
  59 #include <sys/disk.h>
  60 #include <sys/ucred.h>
  61 #include <sys/mount.h>
  62
  63 #include <stdio.h>
  64 #include <paths.h>
  65 #include <ctype.h>
  66 #include <err.h>
  67 #include <fcntl.h>
  68 #include <fstab.h>
  69 #include <inttypes.h>
  70 #include <limits.h>
  71 #include <mntopts.h>
  72 #include <paths.h>
  73 #include <stdlib.h>
  74 #include <stdint.h>
  75 #include <string.h>
  76 #include <time.h>
  77 #include <unistd.h>
  78 #include <ufs/ufs/dinode.h>
  79 #include <ufs/ffs/fs.h>
  80 #include <libutil.h>
  81
  82 #include "debug.h"
  83
  84 #ifdef FS_DEBUG
  85 int     _dbg_lvl_ = (DL_INFO);  /* DL_TRC */
  86 #endif /* FS_DEBUG */
  87
  88 static union {
  89         struct fs       fs;
  90         char            pad[SBLOCKSIZE];
  91 } fsun1, fsun2;
  92 #define sblock  fsun1.fs        /* the new superblock */
  93 #define osblock fsun2.fs        /* the old superblock */
  94
  95 /*
  96  * Possible superblock locations ordered from most to least likely.
  97  */
  98 static int sblock_try[] = SBLOCKSEARCH;
  99 static ufs2_daddr_t sblockloc;
 100
 101 static union {
 102         struct cg       cg;
 103         char            pad[MAXBSIZE];
 104 } cgun1, cgun2;
 105 #define acg     cgun1.cg        /* a cylinder cgroup (new) */
 106 #define aocg    cgun2.cg        /* an old cylinder group */
 107
 108 static struct csum      *fscs;  /* cylinder summary */
 109
 110 static void     growfs(int, int, unsigned int);
 111 static void     rdfs(ufs2_daddr_t, size_t, void *, int);
 112 static void     wtfs(ufs2_daddr_t, size_t, void *, int, unsigned int);
 113 static int      charsperline(void);
 114 static void     usage(void);
 115 static int      isblock(struct fs *, unsigned char *, int);
 116 static void     clrblock(struct fs *, unsigned char *, int);
 117 static void     setblock(struct fs *, unsigned char *, int);
 118 static void     initcg(int, time_t, int, unsigned int);
 119 static void     updjcg(int, time_t, int, int, unsigned int);
 120 static void     updcsloc(time_t, int, int, unsigned int);
 121 static void     frag_adjust(ufs2_daddr_t, int);
 122 static void     updclst(int);
 123 static void     mount_reload(const struct statfs *stfs);
 124
 125 /*
 126  * Here we actually start growing the file system. We basically read the
 127  * cylinder summary from the first cylinder group as we want to update
 128  * this on the fly during our various operations. First we handle the
 129  * changes in the former last cylinder group. Afterwards we create all new
 130  * cylinder groups.  Now we handle the cylinder group containing the
 131  * cylinder summary which might result in a relocation of the whole
 132  * structure.  In the end we write back the updated cylinder summary, the
 133  * new superblock, and slightly patched versions of the super block
 134  * copies.
 135  */
 136 static void
 137 growfs(int fsi, int fso, unsigned int Nflag)
 138 {
 139         DBG_FUNC("growfs")
 140         time_t modtime;
 141         uint cylno;
 142         int i, j, width;
 143         char tmpbuf[100];
 144         static int randinit = 0;
 145
 146         DBG_ENTER;
 147
 148         if (!randinit) {
 149                 randinit = 1;
 150                 srandomdev();
 151         }
 152         time(&modtime);
 153
 154         /*
 155          * Get the cylinder summary into the memory.
 156          */
 157         fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);
 158         if (fscs == NULL)
 159                 errx(1, "calloc failed");
 160         for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
 161                 rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
 162                     numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
 163                     osblock.fs_bsize), (void *)(((char *)fscs) + i), fsi);
 164         }
 165
 166 #ifdef FS_DEBUG
 167         {
 168                 struct csum *dbg_csp;
 169                 int dbg_csc;
 170                 char dbg_line[80];
 171
 172                 dbg_csp = fscs;
 173
 174                 for (dbg_csc = 0; dbg_csc < osblock.fs_ncg; dbg_csc++) {
 175                         snprintf(dbg_line, sizeof(dbg_line),
 176                             "%d. old csum in old location", dbg_csc);
 177                         DBG_DUMP_CSUM(&osblock, dbg_line, dbg_csp++);
 178                 }
 179         }
 180 #endif /* FS_DEBUG */
 181         DBG_PRINT0("fscs read\n");
 182
 183         /*
 184          * Do all needed changes in the former last cylinder group.
 185          */
 186         updjcg(osblock.fs_ncg - 1, modtime, fsi, fso, Nflag);
 187
 188         /*
 189          * Dump out summary information about file system.
 190          */
 191 #ifdef FS_DEBUG
 192 #define B2MBFACTOR (1 / (1024.0 * 1024.0))
 193         printf("growfs: %.1fMB (%jd sectors) block size %d, fragment size %d\n",
 194             (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
 195             (intmax_t)fsbtodb(&sblock, sblock.fs_size), sblock.fs_bsize,
 196             sblock.fs_fsize);
 197         printf("\tusing %d cylinder groups of %.2fMB, %d blks, %d inodes.\n",
 198             sblock.fs_ncg, (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
 199             sblock.fs_fpg / sblock.fs_frag, sblock.fs_ipg);
 200         if (sblock.fs_flags & FS_DOSOFTDEP)
 201                 printf("\twith soft updates\n");
 202 #undef B2MBFACTOR
 203 #endif /* FS_DEBUG */
 204
 205         /*
 206          * Now build the cylinders group blocks and
 207          * then print out indices of cylinder groups.
 208          */
 209         printf("super-block backups (for fsck -b #) at:\n");
 210         i = 0;
 211         width = charsperline();
 212
 213         /*
 214          * Iterate for only the new cylinder groups.
 215          */
 216         for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
 217                 initcg(cylno, modtime, fso, Nflag);
 218                 j = sprintf(tmpbuf, " %jd%s",
 219                     (intmax_t)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
 220                     cylno < (sblock.fs_ncg - 1) ? "," : "" );
 221                 if (i + j >= width) {
 222                         printf("\n");
 223                         i = 0;
 224                 }
 225                 i += j;
 226                 printf("%s", tmpbuf);
 227                 fflush(stdout);
 228         }
 229         printf("\n");
 230
 231         /*
 232          * Do all needed changes in the first cylinder group.
 233          * allocate blocks in new location
 234          */
 235         updcsloc(modtime, fsi, fso, Nflag);
 236
 237         /*
 238          * Now write the cylinder summary back to disk.
 239          */
 240         for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
 241                 wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
 242                     (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
 243                     (void *)(((char *)fscs) + i), fso, Nflag);
 244         }
 245         DBG_PRINT0("fscs written\n");
 246
 247 #ifdef FS_DEBUG
 248         {
 249                 struct csum     *dbg_csp;
 250                 int     dbg_csc;
 251                 char    dbg_line[80];
 252
 253                 dbg_csp = fscs;
 254                 for (dbg_csc = 0; dbg_csc < sblock.fs_ncg; dbg_csc++) {
 255                         snprintf(dbg_line, sizeof(dbg_line),
 256                             "%d. new csum in new location", dbg_csc);
 257                         DBG_DUMP_CSUM(&sblock, dbg_line, dbg_csp++);
 258                 }
 259         }
 260 #endif /* FS_DEBUG */
 261
 262         /*
 263          * Now write the new superblock back to disk.
 264          */
 265         sblock.fs_time = modtime;
 266         wtfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
 267         DBG_PRINT0("sblock written\n");
 268         DBG_DUMP_FS(&sblock, "new initial sblock");
 269
 270         /*
 271          * Clean up the dynamic fields in our superblock copies.
 272          */
 273         sblock.fs_fmod = 0;
 274         sblock.fs_clean = 1;
 275         sblock.fs_ronly = 0;
 276         sblock.fs_cgrotor = 0;
 277         sblock.fs_state = 0;
 278         memset((void *)&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));
 279         sblock.fs_flags &= FS_DOSOFTDEP;
 280
 281         /*
 282          * XXX
 283          * The following fields are currently distributed from the superblock
 284          * to the copies:
 285          *     fs_minfree
 286          *     fs_rotdelay
 287          *     fs_maxcontig
 288          *     fs_maxbpg
 289          *     fs_minfree,
 290          *     fs_optim
 291          *     fs_flags regarding SOFTPDATES
 292          *
 293          * We probably should rather change the summary for the cylinder group
 294          * statistics here to the value of what would be in there, if the file
 295          * system were created initially with the new size. Therefor we still
 296          * need to find an easy way of calculating that.
 297          * Possibly we can try to read the first superblock copy and apply the
 298          * "diffed" stats between the old and new superblock by still copying
 299          * certain parameters onto that.
 300          */
 301
 302         /*
 303          * Write out the duplicate super blocks.
 304          */
 305         for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
 306                 wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
 307                     (size_t)SBLOCKSIZE, (void *)&sblock, fso, Nflag);
 308         }
 309         DBG_PRINT0("sblock copies written\n");
 310         DBG_DUMP_FS(&sblock, "new other sblocks");
 311
 312         DBG_LEAVE;
 313         return;
 314 }
 315
 316 /*
 317  * This creates a new cylinder group structure, for more details please see
 318  * the source of newfs(8), as this function is taken over almost unchanged.
 319  * As this is never called for the first cylinder group, the special
 320  * provisions for that case are removed here.
 321  */
 322 static void
 323 initcg(int cylno, time_t modtime, int fso, unsigned int Nflag)
 324 {
 325         DBG_FUNC("initcg")
 326         static caddr_t iobuf;
 327         long blkno, start;
 328         ino_t ino;
 329         ufs2_daddr_t i, cbase, dmax;
 330         struct ufs1_dinode *dp1;
 331         struct csum *cs;
 332         uint j, d, dupper, dlower;
 333
 334         if (iobuf == NULL && (iobuf = malloc(sblock.fs_bsize * 3)) == NULL)
 335                 errx(37, "panic: cannot allocate I/O buffer");
 336
 337         /*
 338          * Determine block bounds for cylinder group.
 339          * Allow space for super block summary information in first
 340          * cylinder group.
 341          */
 342         cbase = cgbase(&sblock, cylno);
 343         dmax = cbase + sblock.fs_fpg;
 344         if (dmax > sblock.fs_size)
 345                 dmax = sblock.fs_size;
 346         dlower = cgsblock(&sblock, cylno) - cbase;
 347         dupper = cgdmin(&sblock, cylno) - cbase;
 348         if (cylno == 0) /* XXX fscs may be relocated */
 349                 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
 350         cs = &fscs[cylno];
 351         memset(&acg, 0, sblock.fs_cgsize);
 352         acg.cg_time = modtime;
 353         acg.cg_magic = CG_MAGIC;
 354         acg.cg_cgx = cylno;
 355         acg.cg_niblk = sblock.fs_ipg;
 356         acg.cg_initediblk = sblock.fs_ipg < 2 * INOPB(&sblock) ?
 357             sblock.fs_ipg : 2 * INOPB(&sblock);
 358         acg.cg_ndblk = dmax - cbase;
 359         if (sblock.fs_contigsumsize > 0)
 360                 acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
 361         start = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
 362         if (sblock.fs_magic == FS_UFS2_MAGIC) {
 363                 acg.cg_iusedoff = start;
 364         } else {
 365                 acg.cg_old_ncyl = sblock.fs_old_cpg;
 366                 acg.cg_old_time = acg.cg_time;
 367                 acg.cg_time = 0;
 368                 acg.cg_old_niblk = acg.cg_niblk;
 369                 acg.cg_niblk = 0;
 370                 acg.cg_initediblk = 0;
 371                 acg.cg_old_btotoff = start;
 372                 acg.cg_old_boff = acg.cg_old_btotoff +
 373                     sblock.fs_old_cpg * sizeof(int32_t);
 374                 acg.cg_iusedoff = acg.cg_old_boff +
 375                     sblock.fs_old_cpg * sizeof(u_int16_t);
 376         }
 377         acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, CHAR_BIT);
 378         acg.cg_nextfreeoff = acg.cg_freeoff + howmany(sblock.fs_fpg, CHAR_BIT);
 379         if (sblock.fs_contigsumsize > 0) {
 380                 acg.cg_clustersumoff =
 381                     roundup(acg.cg_nextfreeoff, sizeof(u_int32_t));
 382                 acg.cg_clustersumoff -= sizeof(u_int32_t);
 383                 acg.cg_clusteroff = acg.cg_clustersumoff +
 384                     (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
 385                 acg.cg_nextfreeoff = acg.cg_clusteroff +
 386                     howmany(fragstoblks(&sblock, sblock.fs_fpg), CHAR_BIT);
 387         }
 388         if (acg.cg_nextfreeoff > (unsigned)sblock.fs_cgsize) {
 389                 /*
 390                  * This should never happen as we would have had that panic
 391                  * already on file system creation
 392                  */
 393                 errx(37, "panic: cylinder group too big");
 394         }
 395         acg.cg_cs.cs_nifree += sblock.fs_ipg;
 396         if (cylno == 0)
 397                 for (ino = 0; ino < ROOTINO; ino++) {
 398                         setbit(cg_inosused(&acg), ino);
 399                         acg.cg_cs.cs_nifree--;
 400                 }
 401         /*
 402          * For the old file system, we have to initialize all the inodes.
 403          */
 404         if (sblock.fs_magic == FS_UFS1_MAGIC) {
 405                 bzero(iobuf, sblock.fs_bsize);
 406                 for (i = 0; i < sblock.fs_ipg / INOPF(&sblock);
 407                     i += sblock.fs_frag) {
 408                         dp1 = (struct ufs1_dinode *)(void *)iobuf;
 409                         for (j = 0; j < INOPB(&sblock); j++) {
 410                                 dp1->di_gen = random();
 411                                 dp1++;
 412                         }
 413                         wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
 414                             sblock.fs_bsize, iobuf, fso, Nflag);
 415                 }
 416         }
 417         if (cylno > 0) {
 418                 /*
 419                  * In cylno 0, beginning space is reserved
 420                  * for boot and super blocks.
 421                  */
 422                 for (d = 0; d < dlower; d += sblock.fs_frag) {
 423                         blkno = d / sblock.fs_frag;
 424                         setblock(&sblock, cg_blksfree(&acg), blkno);
 425                         if (sblock.fs_contigsumsize > 0)
 426                                 setbit(cg_clustersfree(&acg), blkno);
 427                         acg.cg_cs.cs_nbfree++;
 428                 }
 429                 sblock.fs_dsize += dlower;
 430         }
 431         sblock.fs_dsize += acg.cg_ndblk - dupper;
 432         if ((i = dupper % sblock.fs_frag)) {
 433                 acg.cg_frsum[sblock.fs_frag - i]++;
 434                 for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
 435                         setbit(cg_blksfree(&acg), dupper);
 436                         acg.cg_cs.cs_nffree++;
 437                 }
 438         }
 439         for (d = dupper; d + sblock.fs_frag <= acg.cg_ndblk;
 440             d += sblock.fs_frag) {
 441                 blkno = d / sblock.fs_frag;
 442                 setblock(&sblock, cg_blksfree(&acg), blkno);
 443                 if (sblock.fs_contigsumsize > 0)
 444                         setbit(cg_clustersfree(&acg), blkno);
 445                 acg.cg_cs.cs_nbfree++;
 446         }
 447         if (d < acg.cg_ndblk) {
 448                 acg.cg_frsum[acg.cg_ndblk - d]++;
 449                 for (; d < acg.cg_ndblk; d++) {
 450                         setbit(cg_blksfree(&acg), d);
 451                         acg.cg_cs.cs_nffree++;
 452                 }
 453         }
 454         if (sblock.fs_contigsumsize > 0) {
 455                 int32_t *sump = cg_clustersum(&acg);
 456                 u_char *mapp = cg_clustersfree(&acg);
 457                 int map = *mapp++;
 458                 int bit = 1;
 459                 int run = 0;
 460
 461                 for (i = 0; i < acg.cg_nclusterblks; i++) {
 462                         if ((map & bit) != 0)
 463                                 run++;
 464                         else if (run != 0) {
 465                                 if (run > sblock.fs_contigsumsize)
 466                                         run = sblock.fs_contigsumsize;
 467                                 sump[run]++;
 468                                 run = 0;
 469                         }
 470                         if ((i & (CHAR_BIT - 1)) != CHAR_BIT - 1)
 471                                 bit <<= 1;
 472                         else {
 473                                 map = *mapp++;
 474                                 bit = 1;
 475                         }
 476                 }
 477                 if (run != 0) {
 478                         if (run > sblock.fs_contigsumsize)
 479                                 run = sblock.fs_contigsumsize;
 480                         sump[run]++;
 481                 }
 482         }
 483         sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
 484         sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
 485         sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
 486         sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
 487         *cs = acg.cg_cs;
 488
 489         memcpy(iobuf, &acg, sblock.fs_cgsize);
 490         memset(iobuf + sblock.fs_cgsize, '\0',
 491             sblock.fs_bsize * 3 - sblock.fs_cgsize);
 492
 493         wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
 494             sblock.fs_bsize * 3, iobuf, fso, Nflag);
 495         DBG_DUMP_CG(&sblock, "new cg", &acg);
 496
 497         DBG_LEAVE;
 498         return;
 499 }
 500
 501 /*
 502  * Here we add or subtract (sign +1/-1) the available fragments in a given
 503  * block to or from the fragment statistics. By subtracting before and adding
 504  * after an operation on the free frag map we can easy update the fragment
 505  * statistic, which seems to be otherwise a rather complex operation.
 506  */
 507 static void
 508 frag_adjust(ufs2_daddr_t frag, int sign)
 509 {
 510         DBG_FUNC("frag_adjust")
 511         int fragsize;
 512         int f;
 513
 514         DBG_ENTER;
 515
 516         fragsize = 0;
 517         /*
 518          * Here frag only needs to point to any fragment in the block we want
 519          * to examine.
 520          */
 521         for (f = rounddown(frag, sblock.fs_frag);
 522             f < roundup(frag + 1, sblock.fs_frag); f++) {
 523                 /*
 524                  * Count contiguous free fragments.
 525                  */
 526                 if (isset(cg_blksfree(&acg), f)) {
 527                         fragsize++;
 528                 } else {
 529                         if (fragsize && fragsize < sblock.fs_frag) {
 530                                 /*
 531                                  * We found something in between.
 532                                  */
 533                                 acg.cg_frsum[fragsize] += sign;
 534                                 DBG_PRINT2("frag_adjust [%d]+=%d\n",
 535                                     fragsize, sign);
 536                         }
 537                         fragsize = 0;
 538                 }
 539         }
 540         if (fragsize && fragsize < sblock.fs_frag) {
 541                 /*
 542                  * We found something.
 543                  */
 544                 acg.cg_frsum[fragsize] += sign;
 545                 DBG_PRINT2("frag_adjust [%d]+=%d\n", fragsize, sign);
 546         }
 547         DBG_PRINT2("frag_adjust [[%d]]+=%d\n", fragsize, sign);
 548
 549         DBG_LEAVE;
 550         return;
 551 }
 552
 553 /*
 554  * Here we do all needed work for the former last cylinder group. It has to be
 555  * changed in any case, even if the file system ended exactly on the end of
 556  * this group, as there is some slightly inconsistent handling of the number
 557  * of cylinders in the cylinder group. We start again by reading the cylinder
 558  * group from disk. If the last block was not fully available, we first handle
 559  * the missing fragments, then we handle all new full blocks in that file
 560  * system and finally we handle the new last fragmented block in the file
 561  * system.  We again have to handle the fragment statistics rotational layout
 562  * tables and cluster summary during all those operations.
 563  */
 564 static void
 565 updjcg(int cylno, time_t modtime, int fsi, int fso, unsigned int Nflag)
 566 {
 567         DBG_FUNC("updjcg")
 568         ufs2_daddr_t cbase, dmax, dupper;
 569         struct csum *cs;
 570         int i, k;
 571         int j = 0;
 572
 573         DBG_ENTER;
 574
 575         /*
 576          * Read the former last (joining) cylinder group from disk, and make
 577          * a copy.
 578          */
 579         rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
 580             (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
 581         DBG_PRINT0("jcg read\n");
 582         DBG_DUMP_CG(&sblock, "old joining cg", &aocg);
 583
 584         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
 585
 586         /*
 587          * If the cylinder group had already its new final size almost
 588          * nothing is to be done ... except:
 589          * For some reason the value of cg_ncyl in the last cylinder group has
 590          * to be zero instead of fs_cpg. As this is now no longer the last
 591          * cylinder group we have to change that value now to fs_cpg.
 592          */
 593
 594         if (cgbase(&osblock, cylno + 1) == osblock.fs_size) {
 595                 if (sblock.fs_magic == FS_UFS1_MAGIC)
 596                         acg.cg_old_ncyl = sblock.fs_old_cpg;
 597
 598                 wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
 599                     (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
 600                 DBG_PRINT0("jcg written\n");
 601                 DBG_DUMP_CG(&sblock, "new joining cg", &acg);
 602
 603                 DBG_LEAVE;
 604                 return;
 605         }
 606
 607         /*
 608          * Set up some variables needed later.
 609          */
 610         cbase = cgbase(&sblock, cylno);
 611         dmax = cbase + sblock.fs_fpg;
 612         if (dmax > sblock.fs_size)
 613                 dmax = sblock.fs_size;
 614         dupper = cgdmin(&sblock, cylno) - cbase;
 615         if (cylno == 0) /* XXX fscs may be relocated */
 616                 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
 617
 618         /*
 619          * Set pointer to the cylinder summary for our cylinder group.
 620          */
 621         cs = fscs + cylno;
 622
 623         /*
 624          * Touch the cylinder group, update all fields in the cylinder group as
 625          * needed, update the free space in the superblock.
 626          */
 627         acg.cg_time = modtime;
 628         if ((unsigned)cylno == sblock.fs_ncg - 1) {
 629                 /*
 630                  * This is still the last cylinder group.
 631                  */
 632                 if (sblock.fs_magic == FS_UFS1_MAGIC)
 633                         acg.cg_old_ncyl =
 634                             sblock.fs_old_ncyl % sblock.fs_old_cpg;
 635         } else {
 636                 acg.cg_old_ncyl = sblock.fs_old_cpg;
 637         }
 638         DBG_PRINT2("jcg dbg: %d %u", cylno, sblock.fs_ncg);
 639 #ifdef FS_DEBUG
 640         if (sblock.fs_magic == FS_UFS1_MAGIC)
 641                 DBG_PRINT2("%d %u", acg.cg_old_ncyl, sblock.fs_old_cpg);
 642 #endif
 643         DBG_PRINT0("\n");
 644         acg.cg_ndblk = dmax - cbase;
 645         sblock.fs_dsize += acg.cg_ndblk - aocg.cg_ndblk;
 646         if (sblock.fs_contigsumsize > 0)
 647                 acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
 648
 649         /*
 650          * Now we have to update the free fragment bitmap for our new free
 651          * space.  There again we have to handle the fragmentation and also
 652          * the rotational layout tables and the cluster summary.  This is
 653          * also done per fragment for the first new block if the old file
 654          * system end was not on a block boundary, per fragment for the new
 655          * last block if the new file system end is not on a block boundary,
 656          * and per block for all space in between.
 657          *
 658          * Handle the first new block here if it was partially available
 659          * before.
 660          */
 661         if (osblock.fs_size % sblock.fs_frag) {
 662                 if (roundup(osblock.fs_size, sblock.fs_frag) <=
 663                     sblock.fs_size) {
 664                         /*
 665                          * The new space is enough to fill at least this
 666                          * block
 667                          */
 668                         j = 0;
 669                         for (i = roundup(osblock.fs_size - cbase,
 670                             sblock.fs_frag) - 1; i >= osblock.fs_size - cbase;
 671                             i--) {
 672                                 setbit(cg_blksfree(&acg), i);
 673                                 acg.cg_cs.cs_nffree++;
 674                                 j++;
 675                         }
 676
 677                         /*
 678                          * Check if the fragment just created could join an
 679                          * already existing fragment at the former end of the
 680                          * file system.
 681                          */
 682                         if (isblock(&sblock, cg_blksfree(&acg),
 683                             ((osblock.fs_size - cgbase(&sblock, cylno)) /
 684                              sblock.fs_frag))) {
 685                                 /*
 686                                  * The block is now completely available.
 687                                  */
 688                                 DBG_PRINT0("block was\n");
 689                                 acg.cg_frsum[osblock.fs_size % sblock.fs_frag]--;
 690                                 acg.cg_cs.cs_nbfree++;
 691                                 acg.cg_cs.cs_nffree -= sblock.fs_frag;
 692                                 k = rounddown(osblock.fs_size - cbase,
 693                                     sblock.fs_frag);
 694                                 updclst((osblock.fs_size - cbase) /
 695                                     sblock.fs_frag);
 696                         } else {
 697                                 /*
 698                                  * Lets rejoin a possible partially growed
 699                                  * fragment.
 700                                  */
 701                                 k = 0;
 702                                 while (isset(cg_blksfree(&acg), i) &&
 703                                     (i >= rounddown(osblock.fs_size - cbase,
 704                                     sblock.fs_frag))) {
 705                                         i--;
 706                                         k++;
 707                                 }
 708                                 if (k)
 709                                         acg.cg_frsum[k]--;
 710                                 acg.cg_frsum[k + j]++;
 711                         }
 712                 } else {
 713                         /*
 714                          * We only grow by some fragments within this last
 715                          * block.
 716                          */
 717                         for (i = sblock.fs_size - cbase - 1;
 718                             i >= osblock.fs_size - cbase; i--) {
 719                                 setbit(cg_blksfree(&acg), i);
 720                                 acg.cg_cs.cs_nffree++;
 721                                 j++;
 722                         }
 723                         /*
 724                          * Lets rejoin a possible partially growed fragment.
 725                          */
 726                         k = 0;
 727                         while (isset(cg_blksfree(&acg), i) &&
 728                             (i >= rounddown(osblock.fs_size - cbase,
 729                             sblock.fs_frag))) {
 730                                 i--;
 731                                 k++;
 732                         }
 733                         if (k)
 734                                 acg.cg_frsum[k]--;
 735                         acg.cg_frsum[k + j]++;
 736                 }
 737         }
 738
 739         /*
 740          * Handle all new complete blocks here.
 741          */
 742         for (i = roundup(osblock.fs_size - cbase, sblock.fs_frag);
 743             i + sblock.fs_frag <= dmax - cbase; /* XXX <= or only < ? */
 744             i += sblock.fs_frag) {
 745                 j = i / sblock.fs_frag;
 746                 setblock(&sblock, cg_blksfree(&acg), j);
 747                 updclst(j);
 748                 acg.cg_cs.cs_nbfree++;
 749         }
 750
 751         /*
 752          * Handle the last new block if there are stll some new fragments left.
 753          * Here we don't have to bother about the cluster summary or the even
 754          * the rotational layout table.
 755          */
 756         if (i < (dmax - cbase)) {
 757                 acg.cg_frsum[dmax - cbase - i]++;
 758                 for (; i < dmax - cbase; i++) {
 759                         setbit(cg_blksfree(&acg), i);
 760                         acg.cg_cs.cs_nffree++;
 761                 }
 762         }
 763
 764         sblock.fs_cstotal.cs_nffree +=
 765             (acg.cg_cs.cs_nffree - aocg.cg_cs.cs_nffree);
 766         sblock.fs_cstotal.cs_nbfree +=
 767             (acg.cg_cs.cs_nbfree - aocg.cg_cs.cs_nbfree);
 768         /*
 769          * The following statistics are not changed here:
 770          *     sblock.fs_cstotal.cs_ndir
 771          *     sblock.fs_cstotal.cs_nifree
 772          * As the statistics for this cylinder group are ready, copy it to
 773          * the summary information array.
 774          */
 775         *cs = acg.cg_cs;
 776
 777         /*
 778          * Write the updated "joining" cylinder group back to disk.
 779          */
 780         wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
 781             (void *)&acg, fso, Nflag);
 782         DBG_PRINT0("jcg written\n");
 783         DBG_DUMP_CG(&sblock, "new joining cg", &acg);
 784
 785         DBG_LEAVE;
 786         return;
 787 }
 788
 789 /*
 790  * Here we update the location of the cylinder summary. We have two possible
 791  * ways of growing the cylinder summary:
 792  * (1)  We can try to grow the summary in the current location, and relocate
 793  *      possibly used blocks within the current cylinder group.
 794  * (2)  Alternatively we can relocate the whole cylinder summary to the first
 795  *      new completely empty cylinder group. Once the cylinder summary is no
 796  *      longer in the beginning of the first cylinder group you should never
 797  *      use a version of fsck which is not aware of the possibility to have
 798  *      this structure in a non standard place.
 799  * Option (2) is considered to be less intrusive to the structure of the file-
 800  * system, so that's the one being used.
 801  */
 802 static void
 803 updcsloc(time_t modtime, int fsi, int fso, unsigned int Nflag)
 804 {
 805         DBG_FUNC("updcsloc")
 806         struct csum *cs;
 807         int ocscg, ncscg;
 808         ufs2_daddr_t d;
 809         int lcs = 0;
 810         int block;
 811
 812         DBG_ENTER;
 813
 814         if (howmany(sblock.fs_cssize, sblock.fs_fsize) ==
 815             howmany(osblock.fs_cssize, osblock.fs_fsize)) {
 816                 /*
 817                  * No new fragment needed.
 818                  */
 819                 DBG_LEAVE;
 820                 return;
 821         }
 822         ocscg = dtog(&osblock, osblock.fs_csaddr);
 823         cs = fscs + ocscg;
 824
 825         /*
 826          * Read original cylinder group from disk, and make a copy.
 827          * XXX  If Nflag is set in some very rare cases we now miss
 828          *      some changes done in updjcg by reading the unmodified
 829          *      block from disk.
 830          */
 831         rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
 832             (size_t)osblock.fs_cgsize, (void *)&aocg, fsi);
 833         DBG_PRINT0("oscg read\n");
 834         DBG_DUMP_CG(&sblock, "old summary cg", &aocg);
 835
 836         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
 837
 838         /*
 839          * Touch the cylinder group, set up local variables needed later
 840          * and update the superblock.
 841          */
 842         acg.cg_time = modtime;
 843
 844         /*
 845          * XXX  In the case of having active snapshots we may need much more
 846          *      blocks for the copy on write. We need each block twice, and
 847          *      also up to 8*3 blocks for indirect blocks for all possible
 848          *      references.
 849          */
 850         /*
 851          * There is not enough space in the old cylinder group to
 852          * relocate all blocks as needed, so we relocate the whole
 853          * cylinder group summary to a new group. We try to use the
 854          * first complete new cylinder group just created. Within the
 855          * cylinder group we align the area immediately after the
 856          * cylinder group information location in order to be as
 857          * close as possible to the original implementation of ffs.
 858          *
 859          * First we have to make sure we'll find enough space in the
 860          * new cylinder group. If not, then we currently give up.
 861          * We start with freeing everything which was used by the
 862          * fragments of the old cylinder summary in the current group.
 863          * Now we write back the group meta data, read in the needed
 864          * meta data from the new cylinder group, and start allocating
 865          * within that group. Here we can assume, the group to be
 866          * completely empty. Which makes the handling of fragments and
 867          * clusters a lot easier.
 868          */
 869         DBG_TRC;
 870         if (sblock.fs_ncg - osblock.fs_ncg < 2)
 871                 errx(2, "panic: not enough space");
 872
 873         /*
 874          * Point "d" to the first fragment not used by the cylinder
 875          * summary.
 876          */
 877         d = osblock.fs_csaddr + (osblock.fs_cssize / osblock.fs_fsize);
 878
 879         /*
 880          * Set up last cluster size ("lcs") already here. Calculate
 881          * the size for the trailing cluster just behind where "d"
 882          * points to.
 883          */
 884         if (sblock.fs_contigsumsize > 0) {
 885                 for (block = howmany(d % sblock.fs_fpg, sblock.fs_frag),
 886                     lcs = 0; lcs < sblock.fs_contigsumsize; block++, lcs++) {
 887                         if (isclr(cg_clustersfree(&acg), block))
 888                                 break;
 889                 }
 890         }
 891
 892         /*
 893          * Point "d" to the last frag used by the cylinder summary.
 894          */
 895         d--;
 896
 897         DBG_PRINT1("d=%jd\n", (intmax_t)d);
 898         if ((d + 1) % sblock.fs_frag) {
 899                 /*
 900                  * The end of the cylinder summary is not a complete
 901                  * block.
 902                  */
 903                 DBG_TRC;
 904                 frag_adjust(d % sblock.fs_fpg, -1);
 905                 for (; (d + 1) % sblock.fs_frag; d--) {
 906                         DBG_PRINT1("d=%jd\n", (intmax_t)d);
 907                         setbit(cg_blksfree(&acg), d % sblock.fs_fpg);
 908                         acg.cg_cs.cs_nffree++;
 909                         sblock.fs_cstotal.cs_nffree++;
 910                 }
 911                 /*
 912                  * Point "d" to the last fragment of the last
 913                  * (incomplete) block of the cylinder summary.
 914                  */
 915                 d++;
 916                 frag_adjust(d % sblock.fs_fpg, 1);
 917
 918                 if (isblock(&sblock, cg_blksfree(&acg),
 919                     (d % sblock.fs_fpg) / sblock.fs_frag)) {
 920                         DBG_PRINT1("d=%jd\n", (intmax_t)d);
 921                         acg.cg_cs.cs_nffree -= sblock.fs_frag;
 922                         acg.cg_cs.cs_nbfree++;
 923                         sblock.fs_cstotal.cs_nffree -= sblock.fs_frag;
 924                         sblock.fs_cstotal.cs_nbfree++;
 925                         if (sblock.fs_contigsumsize > 0) {
 926                                 setbit(cg_clustersfree(&acg),
 927                                     (d % sblock.fs_fpg) / sblock.fs_frag);
 928                                 if (lcs < sblock.fs_contigsumsize) {
 929                                         if (lcs)
 930                                                 cg_clustersum(&acg)[lcs]--;
 931                                         lcs++;
 932                                         cg_clustersum(&acg)[lcs]++;
 933                                 }
 934                         }
 935                 }
 936                 /*
 937                  * Point "d" to the first fragment of the block before
 938                  * the last incomplete block.
 939                  */
 940                 d--;
 941         }
 942
 943         DBG_PRINT1("d=%jd\n", (intmax_t)d);
 944         for (d = rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr;
 945             d -= sblock.fs_frag) {
 946                 DBG_TRC;
 947                 DBG_PRINT1("d=%jd\n", (intmax_t)d);
 948                 setblock(&sblock, cg_blksfree(&acg),
 949                     (d % sblock.fs_fpg) / sblock.fs_frag);
 950                 acg.cg_cs.cs_nbfree++;
 951                 sblock.fs_cstotal.cs_nbfree++;
 952                 if (sblock.fs_contigsumsize > 0) {
 953                         setbit(cg_clustersfree(&acg),
 954                             (d % sblock.fs_fpg) / sblock.fs_frag);
 955                         /*
 956                          * The last cluster size is already set up.
 957                          */
 958                         if (lcs < sblock.fs_contigsumsize) {
 959                                 if (lcs)
 960                                         cg_clustersum(&acg)[lcs]--;
 961                                 lcs++;
 962                                 cg_clustersum(&acg)[lcs]++;
 963                         }
 964                 }
 965         }
 966         *cs = acg.cg_cs;
 967
 968         /*
 969          * Now write the former cylinder group containing the cylinder
 970          * summary back to disk.
 971          */
 972         wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
 973             (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
 974         DBG_PRINT0("oscg written\n");
 975         DBG_DUMP_CG(&sblock, "old summary cg", &acg);
 976
 977         /*
 978          * Find the beginning of the new cylinder group containing the
 979          * cylinder summary.
 980          */
 981         sblock.fs_csaddr = cgdmin(&sblock, osblock.fs_ncg);
 982         ncscg = dtog(&sblock, sblock.fs_csaddr);
 983         cs = fscs + ncscg;
 984
 985         /*
 986          * If Nflag is specified, we would now read random data instead
 987          * of an empty cg structure from disk. So we can't simulate that
 988          * part for now.
 989          */
 990         if (Nflag) {
 991                 DBG_PRINT0("nscg update skipped\n");
 992                 DBG_LEAVE;
 993                 return;
 994         }
 995
 996         /*
 997          * Read the future cylinder group containing the cylinder
 998          * summary from disk, and make a copy.
 999          */
1000         rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1001             (size_t)sblock.fs_cgsize, (void *)&aocg, fsi);
1002         DBG_PRINT0("nscg read\n");
1003         DBG_DUMP_CG(&sblock, "new summary cg", &aocg);
1004
1005         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
1006
1007         /*
1008          * Allocate all complete blocks used by the new cylinder
1009          * summary.
1010          */
1011         for (d = sblock.fs_csaddr; d + sblock.fs_frag <=
1012             sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize);
1013             d += sblock.fs_frag) {
1014                 clrblock(&sblock, cg_blksfree(&acg),
1015                     (d % sblock.fs_fpg) / sblock.fs_frag);
1016                 acg.cg_cs.cs_nbfree--;
1017                 sblock.fs_cstotal.cs_nbfree--;
1018                 if (sblock.fs_contigsumsize > 0) {
1019                         clrbit(cg_clustersfree(&acg),
1020                             (d % sblock.fs_fpg) / sblock.fs_frag);
1021                 }
1022         }
1023
1024         /*
1025          * Allocate all fragments used by the cylinder summary in the
1026          * last block.
1027          */
1028         if (d < sblock.fs_csaddr + (sblock.fs_cssize / sblock.fs_fsize)) {
1029                 for (; d - sblock.fs_csaddr <
1030                     sblock.fs_cssize/sblock.fs_fsize; d++) {
1031                         clrbit(cg_blksfree(&acg), d % sblock.fs_fpg);
1032                         acg.cg_cs.cs_nffree--;
1033                         sblock.fs_cstotal.cs_nffree--;
1034                 }
1035                 acg.cg_cs.cs_nbfree--;
1036                 acg.cg_cs.cs_nffree += sblock.fs_frag;
1037                 sblock.fs_cstotal.cs_nbfree--;
1038                 sblock.fs_cstotal.cs_nffree += sblock.fs_frag;
1039                 if (sblock.fs_contigsumsize > 0)
1040                         clrbit(cg_clustersfree(&acg),
1041                             (d % sblock.fs_fpg) / sblock.fs_frag);
1042
1043                 frag_adjust(d % sblock.fs_fpg, 1);
1044         }
1045         /*
1046          * XXX  Handle the cluster statistics here in the case this
1047          *      cylinder group is now almost full, and the remaining
1048          *      space is less then the maximum cluster size. This is
1049          *      probably not needed, as you would hardly find a file
1050          *      system which has only MAXCSBUFS+FS_MAXCONTIG of free
1051          *      space right behind the cylinder group information in
1052          *      any new cylinder group.
1053          */
1054
1055         /*
1056          * Update our statistics in the cylinder summary.
1057          */
1058         *cs = acg.cg_cs;
1059
1060         /*
1061          * Write the new cylinder group containing the cylinder summary
1062          * back to disk.
1063          */
1064         wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1065             (size_t)sblock.fs_cgsize, (void *)&acg, fso, Nflag);
1066         DBG_PRINT0("nscg written\n");
1067         DBG_DUMP_CG(&sblock, "new summary cg", &acg);
1068
1069         DBG_LEAVE;
1070         return;
1071 }
1072
1073 /*
1074  * Here we read some block(s) from disk.
1075  */
1076 static void
1077 rdfs(ufs2_daddr_t bno, size_t size, void *bf, int fsi)
1078 {
1079         DBG_FUNC("rdfs")
1080         ssize_t n;
1081
1082         DBG_ENTER;
1083
1084         if (bno < 0)
1085                 err(32, "rdfs: attempting to read negative block number");
1086         if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0)
1087                 err(33, "rdfs: seek error: %jd", (intmax_t)bno);
1088         n = read(fsi, bf, size);
1089         if (n != (ssize_t)size)
1090                 err(34, "rdfs: read error: %jd", (intmax_t)bno);
1091
1092         DBG_LEAVE;
1093         return;
1094 }
1095
1096 /*
1097  * Here we write some block(s) to disk.
1098  */
1099 static void
1100 wtfs(ufs2_daddr_t bno, size_t size, void *bf, int fso, unsigned int Nflag)
1101 {
1102         DBG_FUNC("wtfs")
1103         ssize_t n;
1104
1105         DBG_ENTER;
1106
1107         if (Nflag) {
1108                 DBG_LEAVE;
1109                 return;
1110         }
1111         if (lseek(fso, (off_t)bno * DEV_BSIZE, SEEK_SET) < 0)
1112                 err(35, "wtfs: seek error: %ld", (long)bno);
1113         n = write(fso, bf, size);
1114         if (n != (ssize_t)size)
1115                 err(36, "wtfs: write error: %ld", (long)bno);
1116
1117         DBG_LEAVE;
1118         return;
1119 }
1120
1121 /*
1122  * Here we check if all frags of a block are free. For more details again
1123  * please see the source of newfs(8), as this function is taken over almost
1124  * unchanged.
1125  */
1126 static int
1127 isblock(struct fs *fs, unsigned char *cp, int h)
1128 {
1129         DBG_FUNC("isblock")
1130         unsigned char mask;
1131
1132         DBG_ENTER;
1133
1134         switch (fs->fs_frag) {
1135         case 8:
1136                 DBG_LEAVE;
1137                 return (cp[h] == 0xff);
1138         case 4:
1139                 mask = 0x0f << ((h & 0x1) << 2);
1140                 DBG_LEAVE;
1141                 return ((cp[h >> 1] & mask) == mask);
1142         case 2:
1143                 mask = 0x03 << ((h & 0x3) << 1);
1144                 DBG_LEAVE;
1145                 return ((cp[h >> 2] & mask) == mask);
1146         case 1:
1147                 mask = 0x01 << (h & 0x7);
1148                 DBG_LEAVE;
1149                 return ((cp[h >> 3] & mask) == mask);
1150         default:
1151                 fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
1152                 DBG_LEAVE;
1153                 return (0);
1154         }
1155 }
1156
1157 /*
1158  * Here we allocate a complete block in the block map. For more details again
1159  * please see the source of newfs(8), as this function is taken over almost
1160  * unchanged.
1161  */
1162 static void
1163 clrblock(struct fs *fs, unsigned char *cp, int h)
1164 {
1165         DBG_FUNC("clrblock")
1166
1167         DBG_ENTER;
1168
1169         switch ((fs)->fs_frag) {
1170         case 8:
1171                 cp[h] = 0;
1172                 break;
1173         case 4:
1174                 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
1175                 break;
1176         case 2:
1177                 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
1178                 break;
1179         case 1:
1180                 cp[h >> 3] &= ~(0x01 << (h & 0x7));
1181                 break;
1182         default:
1183                 warnx("clrblock bad fs_frag %d", fs->fs_frag);
1184                 break;
1185         }
1186
1187         DBG_LEAVE;
1188         return;
1189 }
1190
1191 /*
1192  * Here we free a complete block in the free block map. For more details again
1193  * please see the source of newfs(8), as this function is taken over almost
1194  * unchanged.
1195  */
1196 static void
1197 setblock(struct fs *fs, unsigned char *cp, int h)
1198 {
1199         DBG_FUNC("setblock")
1200
1201         DBG_ENTER;
1202
1203         switch (fs->fs_frag) {
1204         case 8:
1205                 cp[h] = 0xff;
1206                 break;
1207         case 4:
1208                 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
1209                 break;
1210         case 2:
1211                 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
1212                 break;
1213         case 1:
1214                 cp[h >> 3] |= (0x01 << (h & 0x7));
1215                 break;
1216         default:
1217                 warnx("setblock bad fs_frag %d", fs->fs_frag);
1218                 break;
1219         }
1220
1221         DBG_LEAVE;
1222         return;
1223 }
1224
1225 /*
1226  * Figure out how many lines our current terminal has. For more details again
1227  * please see the source of newfs(8), as this function is taken over almost
1228  * unchanged.
1229  */
1230 static int
1231 charsperline(void)
1232 {
1233         DBG_FUNC("charsperline")
1234         int columns;
1235         char *cp;
1236         struct winsize ws;
1237
1238         DBG_ENTER;
1239
1240         columns = 0;
1241         if (ioctl(0, TIOCGWINSZ, &ws) != -1)
1242                 columns = ws.ws_col;
1243         if (columns == 0 && (cp = getenv("COLUMNS")))
1244                 columns = atoi(cp);
1245         if (columns == 0)
1246                 columns = 80;   /* last resort */
1247
1248         DBG_LEAVE;
1249         return (columns);
1250 }
1251
1252 static int
1253 is_dev(const char *name)
1254 {
1255         struct stat devstat;
1256
1257         if (stat(name, &devstat) != 0)
1258                 return (0);
1259         if (!S_ISCHR(devstat.st_mode))
1260                 return (0);
1261         return (1);
1262 }
1263
1264 /*
1265  * Return mountpoint on which the device is currently mounted.
1266  */
1267 static const struct statfs *
1268 dev_to_statfs(const char *dev)
1269 {
1270         struct stat devstat, mntdevstat;
1271         struct statfs *mntbuf, *statfsp;
1272         char device[MAXPATHLEN];
1273         char *mntdevname;
1274         int i, mntsize;
1275
1276         /*
1277          * First check the mounted filesystems.
1278          */
1279         if (stat(dev, &devstat) != 0)
1280                 return (NULL);
1281         if (!S_ISCHR(devstat.st_mode) && !S_ISBLK(devstat.st_mode))
1282                 return (NULL);
1283
1284         mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
1285         for (i = 0; i < mntsize; i++) {
1286                 statfsp = &mntbuf[i];
1287                 mntdevname = statfsp->f_mntfromname;
1288                 if (*mntdevname != '/') {
1289                         strcpy(device, _PATH_DEV);
1290                         strcat(device, mntdevname);
1291                         mntdevname = device;
1292                 }
1293                 if (stat(mntdevname, &mntdevstat) == 0 &&
1294                     mntdevstat.st_rdev == devstat.st_rdev)
1295                         return (statfsp);
1296         }
1297
1298         return (NULL);
1299 }
1300
1301 static const char *
1302 mountpoint_to_dev(const char *mountpoint)
1303 {
1304         struct statfs *mntbuf, *statfsp;
1305         struct fstab *fs;
1306         int i, mntsize;
1307
1308         /*
1309          * First check the mounted filesystems.
1310          */
1311         mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
1312         for (i = 0; i < mntsize; i++) {
1313                 statfsp = &mntbuf[i];
1314
1315                 if (strcmp(statfsp->f_mntonname, mountpoint) == 0)
1316                         return (statfsp->f_mntfromname);
1317         }
1318
1319         /*
1320          * Check the fstab.
1321          */
1322         fs = getfsfile(mountpoint);
1323         if (fs != NULL)
1324                 return (fs->fs_spec);
1325
1326         return (NULL);
1327 }
1328
1329 static const char *
1330 getdev(const char *name)
1331 {
1332         static char device[MAXPATHLEN];
1333         const char *cp, *dev;
1334
1335         if (is_dev(name))
1336                 return (name);
1337
1338         cp = strrchr(name, '/');
1339         if (cp == 0) {
1340                 snprintf(device, sizeof(device), "%s%s", _PATH_DEV, name);
1341                 if (is_dev(device))
1342                         return (device);
1343         }
1344
1345         dev = mountpoint_to_dev(name);
1346         if (dev != NULL && is_dev(dev))
1347                 return (dev);
1348
1349         return (NULL);
1350 }
1351
1352 /*
1353  * growfs(8) is a utility which allows to increase the size of an existing
1354  * ufs file system. Currently this can only be done on unmounted file system.
1355  * It recognizes some command line options to specify the new desired size,
1356  * and it does some basic checkings. The old file system size is determined
1357  * and after some more checks like we can really access the new last block
1358  * on the disk etc. we calculate the new parameters for the superblock. After
1359  * having done this we just call growfs() which will do the work.
1360  * We still have to provide support for snapshots. Therefore we first have to
1361  * understand what data structures are always replicated in the snapshot on
1362  * creation, for all other blocks we touch during our procedure, we have to
1363  * keep the old blocks unchanged somewhere available for the snapshots. If we
1364  * are lucky, then we only have to handle our blocks to be relocated in that
1365  * way.
1366  * Also we have to consider in what order we actually update the critical
1367  * data structures of the file system to make sure, that in case of a disaster
1368  * fsck(8) is still able to restore any lost data.
1369  * The foreseen last step then will be to provide for growing even mounted
1370  * file systems. There we have to extend the mount() system call to provide
1371  * userland access to the file system locking facility.
1372  */
1373 int
1374 main(int argc, char **argv)
1375 {
1376         DBG_FUNC("main")
1377         const char *device;
1378         const struct statfs *statfsp;
1379         uint64_t size = 0;
1380         off_t mediasize;
1381         int error, i, j, fsi, fso, ch, Nflag = 0, yflag = 0;
1382         char *p, reply[5], oldsizebuf[6], newsizebuf[6];
1383         void *testbuf;
1384
1385         DBG_ENTER;
1386
1387         while ((ch = getopt(argc, argv, "Ns:vy")) != -1) {
1388                 switch(ch) {
1389                 case 'N':
1390                         Nflag = 1;
1391                         break;
1392                 case 's':
1393                         size = (off_t)strtoumax(optarg, &p, 0);
1394                         if (p == NULL || *p == '\0')
1395                                 size *= DEV_BSIZE;
1396                         else if (*p == 'b' || *p == 'B')
1397                                 ; /* do nothing */
1398                         else if (*p == 'k' || *p == 'K')
1399                                 size <<= 10;
1400                         else if (*p == 'm' || *p == 'M')
1401                                 size <<= 20;
1402                         else if (*p == 'g' || *p == 'G')
1403                                 size <<= 30;
1404                         else if (*p == 't' || *p == 'T') {
1405                                 size <<= 30;
1406                                 size <<= 10;
1407                         } else
1408                                 errx(1, "unknown suffix on -s argument");
1409                         break;
1410                 case 'v': /* for compatibility to newfs */
1411                         break;
1412                 case 'y':
1413                         yflag = 1;
1414                         break;
1415                 case '?':
1416                         /* FALLTHROUGH */
1417                 default:
1418                         usage();
1419                 }
1420         }
1421         argc -= optind;
1422         argv += optind;
1423
1424         if (argc != 1)
1425                 usage();
1426
1427         /*
1428          * Now try to guess the device name.
1429          */
1430         device = getdev(*argv);
1431         if (device == NULL)
1432                 errx(1, "cannot find special device for %s", *argv);
1433
1434         statfsp = dev_to_statfs(device);
1435
1436         fsi = open(device, O_RDONLY);
1437         if (fsi < 0)
1438                 err(1, "%s", device);
1439
1440         /*
1441          * Try to guess the slice size if not specified.
1442          */
1443         if (ioctl(fsi, DIOCGMEDIASIZE, &mediasize) == -1)
1444                 err(1,"DIOCGMEDIASIZE");
1445
1446         /*
1447          * Check if that partition is suitable for growing a file system.
1448          */
1449         if (mediasize < 1)
1450                 errx(1, "partition is unavailable");
1451
1452         /*
1453          * Read the current superblock, and take a backup.
1454          */
1455         for (i = 0; sblock_try[i] != -1; i++) {
1456                 sblockloc = sblock_try[i] / DEV_BSIZE;
1457                 rdfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&(osblock), fsi);
1458                 if ((osblock.fs_magic == FS_UFS1_MAGIC ||
1459                     (osblock.fs_magic == FS_UFS2_MAGIC &&
1460                     osblock.fs_sblockloc == sblock_try[i])) &&
1461                     osblock.fs_bsize <= MAXBSIZE &&
1462                     osblock.fs_bsize >= (int32_t) sizeof(struct fs))
1463                         break;
1464         }
1465         if (sblock_try[i] == -1)
1466                 errx(1, "superblock not recognized");
1467         memcpy((void *)&fsun1, (void *)&fsun2, sizeof(fsun2));
1468
1469         DBG_OPEN("/tmp/growfs.debug"); /* already here we need a superblock */
1470         DBG_DUMP_FS(&sblock, "old sblock");
1471
1472         /*
1473          * Determine size to grow to. Default to the device size.
1474          */
1475         if (size == 0)
1476                 size = mediasize;
1477         else {
1478                 if (size > (uint64_t)mediasize) {
1479                         humanize_number(oldsizebuf, sizeof(oldsizebuf), size,
1480                             "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1481                         humanize_number(newsizebuf, sizeof(newsizebuf),
1482                             mediasize,
1483                             "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1484
1485                         errx(1, "requested size %s is larger "
1486                             "than the available %s", oldsizebuf, newsizebuf);
1487                 }
1488         }
1489
1490         /*
1491          * Make sure the new size is a multiple of fs_fsize; /dev/ufssuspend
1492          * only supports fragment-aligned IO requests.
1493          */
1494         size -= size % osblock.fs_fsize;
1495
1496         if (size <= (uint64_t)(osblock.fs_size * osblock.fs_fsize)) {
1497                 humanize_number(oldsizebuf, sizeof(oldsizebuf),
1498                     osblock.fs_size * osblock.fs_fsize,
1499                     "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1500                 humanize_number(newsizebuf, sizeof(newsizebuf), size,
1501                     "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1502
1503                 errx(1, "requested size %s is not larger than the current "
1504                    "filesystem size %s", newsizebuf, oldsizebuf);
1505         }
1506
1507         sblock.fs_size = dbtofsb(&osblock, size / DEV_BSIZE);
1508         sblock.fs_providersize = dbtofsb(&osblock, mediasize / DEV_BSIZE);
1509
1510         /*
1511          * Are we really growing?
1512          */
1513         if (osblock.fs_size >= sblock.fs_size) {
1514                 errx(1, "we are not growing (%jd->%jd)",
1515                     (intmax_t)osblock.fs_size, (intmax_t)sblock.fs_size);
1516         }
1517
1518         /*
1519          * Check if we find an active snapshot.
1520          */
1521         if (yflag == 0) {
1522                 for (j = 0; j < FSMAXSNAP; j++) {
1523                         if (sblock.fs_snapinum[j]) {
1524                                 errx(1, "active snapshot found in file system; "
1525                                     "please remove all snapshots before "
1526                                     "using growfs");
1527                         }
1528                         if (!sblock.fs_snapinum[j]) /* list is dense */
1529                                 break;
1530                 }
1531         }
1532
1533         if (yflag == 0 && Nflag == 0) {
1534                 if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) == 0)
1535                         printf("Device is mounted read-write; resizing will "
1536                             "result in temporary write suspension for %s.\n",
1537                             statfsp->f_mntonname);
1538                 printf("It's strongly recommended to make a backup "
1539                     "before growing the file system.\n"
1540                     "OK to grow filesystem on %s", device);
1541                 if (statfsp != NULL)
1542                         printf(", mounted on %s,", statfsp->f_mntonname);
1543                 humanize_number(oldsizebuf, sizeof(oldsizebuf),
1544                     osblock.fs_size * osblock.fs_fsize,
1545                     "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1546                 humanize_number(newsizebuf, sizeof(newsizebuf),
1547                     sblock.fs_size * sblock.fs_fsize,
1548                     "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1549                 printf(" from %s to %s? [Yes/No] ", oldsizebuf, newsizebuf);
1550                 fflush(stdout);
1551                 fgets(reply, (int)sizeof(reply), stdin);
1552                 if (strcmp(reply, "Yes\n")){
1553                         printf("\nNothing done\n");
1554                         exit (0);
1555                 }
1556         }
1557
1558         /*
1559          * Try to access our device for writing.  If it's not mounted,
1560          * or mounted read-only, simply open it; otherwise, use UFS
1561          * suspension mechanism.
1562          */
1563         if (Nflag) {
1564                 fso = -1;
1565         } else {
1566                 if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) == 0) {
1567                         fso = open(_PATH_UFSSUSPEND, O_RDWR);
1568                         if (fso == -1)
1569                                 err(1, "unable to open %s", _PATH_UFSSUSPEND);
1570                         error = ioctl(fso, UFSSUSPEND, &statfsp->f_fsid);
1571                         if (error != 0)
1572                                 err(1, "UFSSUSPEND");
1573                 } else {
1574                         fso = open(device, O_WRONLY);
1575                         if (fso < 0)
1576                                 err(1, "%s", device);
1577                 }
1578         }
1579
1580         /*
1581          * Try to access our new last block in the file system.
1582          */
1583         testbuf = malloc(sblock.fs_fsize);
1584         if (testbuf == NULL)
1585                 err(1, "malloc");
1586         rdfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),
1587             sblock.fs_fsize, testbuf, fsi);
1588         wtfs((ufs2_daddr_t)((size - sblock.fs_fsize) / DEV_BSIZE),
1589             sblock.fs_fsize, testbuf, fso, Nflag);
1590         free(testbuf);
1591
1592         /*
1593          * Now calculate new superblock values and check for reasonable
1594          * bound for new file system size:
1595          *     fs_size:    is derived from user input
1596          *     fs_dsize:   should get updated in the routines creating or
1597          *                 updating the cylinder groups on the fly
1598          *     fs_cstotal: should get updated in the routines creating or
1599          *                 updating the cylinder groups
1600          */
1601
1602         /*
1603          * Update the number of cylinders and cylinder groups in the file system.
1604          */
1605         if (sblock.fs_magic == FS_UFS1_MAGIC) {
1606                 sblock.fs_old_ncyl =
1607                     sblock.fs_size * sblock.fs_old_nspf / sblock.fs_old_spc;
1608                 if (sblock.fs_size * sblock.fs_old_nspf >
1609                     sblock.fs_old_ncyl * sblock.fs_old_spc)
1610                         sblock.fs_old_ncyl++;
1611         }
1612         sblock.fs_ncg = howmany(sblock.fs_size, sblock.fs_fpg);
1613
1614         /*
1615          * Allocate last cylinder group only if there is enough room
1616          * for at least one data block.
1617          */
1618         if (sblock.fs_size % sblock.fs_fpg != 0 &&
1619             sblock.fs_size <= cgdmin(&sblock, sblock.fs_ncg - 1)) {
1620                 humanize_number(oldsizebuf, sizeof(oldsizebuf),
1621                     (sblock.fs_size % sblock.fs_fpg) * sblock.fs_fsize,
1622                     "B", HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
1623                 warnx("no room to allocate last cylinder group; "
1624                     "leaving %s unused", oldsizebuf);
1625                 sblock.fs_ncg--;
1626                 if (sblock.fs_magic == FS_UFS1_MAGIC)
1627                         sblock.fs_old_ncyl = sblock.fs_ncg * sblock.fs_old_cpg;
1628                 sblock.fs_size = sblock.fs_ncg * sblock.fs_fpg;
1629         }
1630
1631         /*
1632          * Update the space for the cylinder group summary information in the
1633          * respective cylinder group data area.
1634          */
1635         sblock.fs_cssize =
1636             fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
1637
1638         if (osblock.fs_size >= sblock.fs_size)
1639                 errx(1, "not enough new space");
1640
1641         DBG_PRINT0("sblock calculated\n");
1642
1643         /*
1644          * Ok, everything prepared, so now let's do the tricks.
1645          */
1646         growfs(fsi, fso, Nflag);
1647
1648         close(fsi);
1649         if (fso > -1) {
1650                 if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) == 0) {
1651                         error = ioctl(fso, UFSRESUME);
1652                         if (error != 0)
1653                                 err(1, "UFSRESUME");
1654                 }
1655                 error = close(fso);
1656                 if (error != 0)
1657                         err(1, "close");
1658                 if (statfsp != NULL && (statfsp->f_flags & MNT_RDONLY) != 0)
1659                         mount_reload(statfsp);
1660         }
1661
1662         DBG_CLOSE;
1663
1664         DBG_LEAVE;
1665         return (0);
1666 }
1667
1668 /*
1669  * Dump a line of usage.
1670  */
1671 static void
1672 usage(void)
1673 {
1674         DBG_FUNC("usage")
1675
1676         DBG_ENTER;
1677
1678         fprintf(stderr, "usage: growfs [-Ny] [-s size] special | filesystem\n");
1679
1680         DBG_LEAVE;
1681         exit(1);
1682 }
1683
1684 /*
1685  * This updates most parameters and the bitmap related to cluster. We have to
1686  * assume that sblock, osblock, acg are set up.
1687  */
1688 static void
1689 updclst(int block)
1690 {
1691         DBG_FUNC("updclst")
1692         static int lcs = 0;
1693
1694         DBG_ENTER;
1695
1696         if (sblock.fs_contigsumsize < 1) /* no clustering */
1697                 return;
1698         /*
1699          * update cluster allocation map
1700          */
1701         setbit(cg_clustersfree(&acg), block);
1702
1703         /*
1704          * update cluster summary table
1705          */
1706         if (!lcs) {
1707                 /*
1708                  * calculate size for the trailing cluster
1709                  */
1710                 for (block--; lcs < sblock.fs_contigsumsize; block--, lcs++ ) {
1711                         if (isclr(cg_clustersfree(&acg), block))
1712                                 break;
1713                 }
1714         }
1715         if (lcs < sblock.fs_contigsumsize) {
1716                 if (lcs)
1717                         cg_clustersum(&acg)[lcs]--;
1718                 lcs++;
1719                 cg_clustersum(&acg)[lcs]++;
1720         }
1721
1722         DBG_LEAVE;
1723         return;
1724 }
1725
1726 static void
1727 mount_reload(const struct statfs *stfs)
1728 {
1729         char errmsg[255];
1730         struct iovec *iov;
1731         int iovlen;
1732
1733         iov = NULL;
1734         iovlen = 0;
1735         *errmsg = '\0';
1736         build_iovec(&iov, &iovlen, "fstype", __DECONST(char *, "ffs"), 4);
1737         build_iovec(&iov, &iovlen, "fspath", __DECONST(char *, stfs->f_mntonname), (size_t)-1);
1738         build_iovec(&iov, &iovlen, "errmsg", errmsg, sizeof(errmsg));
1739         build_iovec(&iov, &iovlen, "update", NULL, 0);
1740         build_iovec(&iov, &iovlen, "reload", NULL, 0);
1741
1742         if (nmount(iov, iovlen, stfs->f_flags) < 0) {
1743                 errmsg[sizeof(errmsg) - 1] = '\0';
1744                 err(9, "%s: cannot reload filesystem%s%s", stfs->f_mntonname,
1745                     *errmsg != '\0' ? ": " : "", errmsg);
1746         }
1747 }