sbin/growfs/growfs.c

   1 /*
   2  * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
   3  * Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
   4  * All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgment:
  19  *      This product includes software developed by the University of
  20  *      California, Berkeley and its contributors, as well as Christoph
  21  *      Herrmann and Thomas-Henning von Kamptz.
  22  * 4. Neither the name of the University nor the names of its contributors
  23  *    may be used to endorse or promote products derived from this software
  24  *    without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  *
  38  * $TSHeader: src/sbin/growfs/growfs.c,v 1.5 2000/12/12 19:31:00 tomsoft Exp $
  39  *
  40  * @(#) Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz Copyright (c) 1980, 1989, 1993 The Regents of the University of California. All rights reserved.
  41  * $FreeBSD: src/sbin/growfs/growfs.c,v 1.4.2.2 2001/08/14 12:45:11 chm Exp $
  42  */
  43
  44 /* ********************************************************** INCLUDES ***** */
  45 #include <sys/param.h>
  46 #include <sys/diskslice.h>
  47 #include <sys/ioctl.h>
  48 #include <sys/stat.h>
  49
  50 #include <stdio.h>
  51 #include <paths.h>
  52 #include <ctype.h>
  53 #include <err.h>
  54 #include <fcntl.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <unistd.h>
  58 #include <vfs/ufs/dinode.h>
  59 #include <vfs/ufs/fs.h>
  60
  61 #include "debug.h"
  62
  63 /* *************************************************** GLOBALS & TYPES ***** */
  64 #ifdef FS_DEBUG
  65 int     _dbg_lvl_ = (DL_INFO);  /* DL_TRC */
  66 #endif /* FS_DEBUG */
  67
  68 static union {
  69         struct fs       fs;
  70         char    pad[SBSIZE];
  71 } fsun1, fsun2;
  72 #define sblock  fsun1.fs        /* the new superblock */
  73 #define osblock fsun2.fs        /* the old superblock */
  74
  75 static union {
  76         struct cg       cg;
  77         char    pad[MAXBSIZE];
  78 } cgun1, cgun2;
  79 #define acg     cgun1.cg        /* a cylinder cgroup (new) */
  80 #define aocg    cgun2.cg        /* an old cylinder group */
  81
  82 static char     ablk[MAXBSIZE];         /* a block */
  83 static char     i1blk[MAXBSIZE];        /* some indirect blocks */
  84 static char     i2blk[MAXBSIZE];
  85 static char     i3blk[MAXBSIZE];
  86
  87         /* where to write back updated blocks */
  88 static daddr_t  in_src, i1_src, i2_src, i3_src;
  89
  90         /* what object contains the reference */
  91 enum pointer_source {
  92         GFS_PS_INODE,
  93         GFS_PS_IND_BLK_LVL1,
  94         GFS_PS_IND_BLK_LVL2,
  95         GFS_PS_IND_BLK_LVL3
  96 };
  97
  98 static struct csum      *fscs;          /* cylinder summary */
  99
 100 static struct ufs1_dinode       zino[MAXBSIZE/sizeof(struct ufs1_dinode)]; /* some inodes */
 101
 102 /*
 103  * An  array of elements of type struct gfs_bpp describes all blocks  to
 104  * be relocated in order to free the space needed for the cylinder group
 105  * summary for all cylinder groups located in the first cylinder group.
 106  */
 107 struct gfs_bpp {
 108         daddr_t old;            /* old block number */
 109         daddr_t new;            /* new block number */
 110 #define GFS_FL_FIRST    1
 111 #define GFS_FL_LAST     2
 112         unsigned int    flags;  /* special handling required */
 113         int     found;          /* how many references were updated */
 114 };
 115
 116 /* ******************************************************** PROTOTYPES ***** */
 117 static void     growfs(int, int, unsigned int);
 118 static void     rdfs(daddr_t, size_t, void *, int);
 119 static void     wtfs(daddr_t, size_t, void *, int, unsigned int);
 120 static daddr_t  alloc(void);
 121 static int      charsperline(void);
 122 static void     usage(void);
 123 static int      isblock(struct fs *, unsigned char *, int);
 124 static void     clrblock(struct fs *, unsigned char *, int);
 125 static void     setblock(struct fs *, unsigned char *, int);
 126 static void     initcg(int, time_t, int, unsigned int);
 127 static void     updjcg(int, time_t, int, int, unsigned int);
 128 static void     updcsloc(time_t, int, int, unsigned int);
 129 static struct ufs1_dinode       *ginode(ino_t, int, int);
 130 static void     frag_adjust(daddr_t, int);
 131 static void     cond_bl_upd(ufs_daddr_t *, struct gfs_bpp *,
 132     enum pointer_source, int, unsigned int);
 133 static void     updclst(int);
 134 static void     updrefs(int, ino_t, struct gfs_bpp *, int, int, unsigned int);
 135
 136 /* ************************************************************ growfs ***** */
 137 /*
 138  * Here  we actually start growing the filesystem. We basically  read  the
 139  * cylinder  summary  from the first cylinder group as we want  to  update
 140  * this  on  the fly during our various operations. First  we  handle  the
 141  * changes in the former last cylinder group. Afterwards we create all new
 142  * cylinder  groups.  Now  we handle the  cylinder  group  containing  the
 143  * cylinder  summary  which  might result in a  relocation  of  the  whole
 144  * structure.  In the end we write back the updated cylinder summary,  the
 145  * new superblock, and slightly patched versions of the super block
 146  * copies.
 147  */
 148 static void
 149 growfs(int fsi, int fso, unsigned int Nflag)
 150 {
 151         int     i;
 152         int     cylno, j;
 153         time_t  utime;
 154         int     width;
 155         char    tmpbuf[100];
 156 #ifdef FSIRAND
 157         static int      randinit=0;
 158
 159         DBG_ENTER;
 160
 161         if (!randinit) {
 162                 randinit = 1;
 163                 srandomdev();
 164         }
 165 #else /* not FSIRAND */
 166
 167         DBG_ENTER;
 168
 169 #endif /* FSIRAND */
 170         time(&utime);
 171
 172         /*
 173          * Get the cylinder summary into the memory.
 174          */
 175         fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);
 176         if(fscs == NULL) {
 177                 errx(1, "calloc failed");
 178         }
 179         for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
 180                 rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
 181                     numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
 182                     osblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
 183         }
 184
 185 #ifdef FS_DEBUG
 186 {
 187         struct csum     *dbg_csp;
 188         int     dbg_csc;
 189         char    dbg_line[80];
 190
 191         dbg_csp=fscs;
 192         for(dbg_csc=0; dbg_csc<osblock.fs_ncg; dbg_csc++) {
 193                 snprintf(dbg_line, sizeof(dbg_line),
 194                     "%d. old csum in old location", dbg_csc);
 195                 DBG_DUMP_CSUM(&osblock,
 196                     dbg_line,
 197                     dbg_csp++);
 198         }
 199 }
 200 #endif /* FS_DEBUG */
 201         DBG_PRINT0("fscs read\n");
 202
 203         /*
 204          * Do all needed changes in the former last cylinder group.
 205          */
 206         updjcg(osblock.fs_ncg-1, utime, fsi, fso, Nflag);
 207
 208         /*
 209          * Dump out summary information about file system.
 210          */
 211         printf("growfs:\t%d sectors in %d %s of %d tracks, %d sectors\n",
 212             sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
 213             "cylinders", sblock.fs_ntrak, sblock.fs_nsect);
 214 #define B2MBFACTOR (1 / (1024.0 * 1024.0))
 215         printf("\t%.1fMB in %d cyl groups (%d c/g, %.2fMB/g, %d i/g)\n",
 216             (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
 217             sblock.fs_ncg, sblock.fs_cpg,
 218             (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
 219             sblock.fs_ipg);
 220 #undef B2MBFACTOR
 221
 222         /*
 223          * Now build the cylinders group blocks and
 224          * then print out indices of cylinder groups.
 225          */
 226         printf("super-block backups (for fsck -b #) at:\n");
 227         i = 0;
 228         width = charsperline();
 229
 230         /*
 231          * Iterate for only the new cylinder groups.
 232          */
 233         for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
 234                 initcg(cylno, utime, fso, Nflag);
 235                 j = sprintf(tmpbuf, " %d%s",
 236                     (int)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
 237                     cylno < (sblock.fs_ncg-1) ? "," : "" );
 238                 if (i + j >= width) {
 239                         printf("\n");
 240                         i = 0;
 241                 }
 242                 i += j;
 243                 printf("%s", tmpbuf);
 244                 fflush(stdout);
 245         }
 246         printf("\n");
 247
 248         /*
 249          * Do all needed changes in the first cylinder group.
 250          * allocate blocks in new location
 251          */
 252         updcsloc(utime, fsi, fso, Nflag);
 253
 254         /*
 255          * Now write the cylinder summary back to disk.
 256          */
 257         for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
 258                 wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
 259                     (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
 260                     (void *)(((char *)fscs) + i), fso, Nflag);
 261         }
 262         DBG_PRINT0("fscs written\n");
 263
 264 #ifdef FS_DEBUG
 265 {
 266         struct csum     *dbg_csp;
 267         int     dbg_csc;
 268         char    dbg_line[80];
 269
 270         dbg_csp=fscs;
 271         for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) {
 272                 snprintf(dbg_line, sizeof(dbg_line),
 273                     "%d. new csum in new location", dbg_csc);
 274                 DBG_DUMP_CSUM(&sblock,
 275                     dbg_line,
 276                     dbg_csp++);
 277         }
 278 }
 279 #endif /* FS_DEBUG */
 280
 281         /*
 282          * Now write the new superblock back to disk.
 283          */
 284         sblock.fs_time = utime;
 285         wtfs((daddr_t)(SBOFF / DEV_BSIZE), (size_t)SBSIZE, &sblock,
 286             fso, Nflag);
 287         DBG_PRINT0("sblock written\n");
 288         DBG_DUMP_FS(&sblock,
 289             "new initial sblock");
 290
 291         /*
 292          * Clean up the dynamic fields in our superblock copies.
 293          */
 294         sblock.fs_fmod = 0;
 295         sblock.fs_clean = 1;
 296         sblock.fs_ronly = 0;
 297         sblock.fs_cgrotor = 0;
 298         sblock.fs_state = 0;
 299         memset((void *)&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));
 300         sblock.fs_flags &= FS_DOSOFTDEP;
 301
 302         /*
 303          * XXX
 304          * The following fields are currently distributed from the  superblock
 305          * to the copies:
 306          *     fs_minfree
 307          *     fs_rotdelay
 308          *     fs_maxcontig
 309          *     fs_maxbpg
 310          *     fs_minfree,
 311          *     fs_optim
 312          *     fs_flags regarding SOFTPDATES
 313          *
 314          * We probably should rather change the summary for the cylinder group
 315          * statistics here to the value of what would be in there, if the file
 316          * system were created initially with the new size. Therefor we  still
 317          * need to find an easy way of calculating that.
 318          * Possibly we can try to read the first superblock copy and apply the
 319          * "diffed" stats between the old and new superblock by still  copying
 320          * certain parameters onto that.
 321          */
 322
 323         /*
 324          * Write out the duplicate super blocks.
 325          */
 326         for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
 327                 wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
 328                     (size_t)SBSIZE, &sblock, fso, Nflag);
 329         }
 330         DBG_PRINT0("sblock copies written\n");
 331         DBG_DUMP_FS(&sblock,
 332             "new other sblocks");
 333
 334         DBG_LEAVE;
 335         return;
 336 }
 337
 338 /* ************************************************************ initcg ***** */
 339 /*
 340  * This creates a new cylinder group structure, for more details please  see
 341  * the  source of newfs(8), as this function is taken over almost unchanged.
 342  * As  this  is  never called for the  first  cylinder  group,  the  special
 343  * provisions for that case are removed here.
 344  */
 345 static void
 346 initcg(int cylno, time_t utime, int fso, unsigned int Nflag)
 347 {
 348         daddr_t cbase, d, dlower, dupper, dmax, blkno;
 349         int i;
 350         struct csum *cs;
 351 #ifdef FSIRAND
 352         int j;
 353 #endif
 354
 355         DBG_ENTER;
 356
 357         /*
 358          * Determine block bounds for cylinder group.
 359          */
 360         cbase = cgbase(&sblock, cylno);
 361         dmax = cbase + sblock.fs_fpg;
 362         if (dmax > sblock.fs_size) {
 363                 dmax = sblock.fs_size;
 364         }
 365         dlower = cgsblock(&sblock, cylno) - cbase;
 366         dupper = cgdmin(&sblock, cylno) - cbase;
 367         if (cylno == 0) { /* XXX fscs may be relocated */
 368                 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
 369         }
 370         cs = fscs + cylno;
 371         memset(&acg, 0, (size_t)sblock.fs_cgsize);
 372         acg.cg_time = utime;
 373         acg.cg_magic = CG_MAGIC;
 374         acg.cg_cgx = cylno;
 375         if (cylno == sblock.fs_ncg - 1) {
 376                 acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
 377         } else {
 378                 acg.cg_ncyl = sblock.fs_cpg;
 379         }
 380         acg.cg_niblk = sblock.fs_ipg;
 381         acg.cg_ndblk = dmax - cbase;
 382         if (sblock.fs_contigsumsize > 0) {
 383                 acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
 384         }
 385         acg.cg_btotoff = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
 386         acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(int32_t);
 387         acg.cg_iusedoff = acg.cg_boff +
 388             sblock.fs_cpg * sblock.fs_nrpos * sizeof(u_int16_t);
 389         acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
 390         if (sblock.fs_contigsumsize <= 0) {
 391                 acg.cg_nextfreeoff = acg.cg_freeoff +
 392                     howmany(sblock.fs_cpg* sblock.fs_spc/ NSPF(&sblock), NBBY);
 393         } else {
 394                 acg.cg_clustersumoff = acg.cg_freeoff + howmany
 395                     (sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -
 396                     sizeof(u_int32_t);
 397                 acg.cg_clustersumoff =
 398                     roundup(acg.cg_clustersumoff, sizeof(u_int32_t));
 399                 acg.cg_clusteroff = acg.cg_clustersumoff +
 400                     (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
 401                 acg.cg_nextfreeoff = acg.cg_clusteroff + howmany
 402                     (sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);
 403         }
 404         if (acg.cg_nextfreeoff-(intptr_t)(&acg.cg_firstfield) > sblock.fs_cgsize) {
 405                 /*
 406                  * XXX This should never happen as we would have had that panic
 407                  *     already on filesystem creation
 408                  */
 409                 errx(37, "panic: cylinder group too big");
 410         }
 411         acg.cg_cs.cs_nifree += sblock.fs_ipg;
 412         if (cylno == 0)
 413                 for (i = 0; (size_t)i < ROOTINO; i++) {
 414                         setbit(cg_inosused(&acg), i);
 415                         acg.cg_cs.cs_nifree--;
 416                 }
 417         for (i = 0; i < sblock.fs_ipg / INOPF(&sblock); i += sblock.fs_frag) {
 418 #ifdef FSIRAND
 419                 for (j = 0; j < sblock.fs_bsize / sizeof(struct ufs1_dinode); j++) {
 420                         zino[j].di_gen = random();
 421                 }
 422 #endif
 423                 wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
 424                     (size_t)sblock.fs_bsize, (void *)zino, fso, Nflag);
 425         }
 426         for (d = 0; d < dlower; d += sblock.fs_frag) {
 427                 blkno = d / sblock.fs_frag;
 428                 setblock(&sblock, cg_blksfree(&acg), blkno);
 429                 if (sblock.fs_contigsumsize > 0) {
 430                         setbit(cg_clustersfree(&acg), blkno);
 431                 }
 432                 acg.cg_cs.cs_nbfree++;
 433                 cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
 434                 cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
 435                     [cbtorpos(&sblock, d)]++;
 436         }
 437         sblock.fs_dsize += dlower;
 438         sblock.fs_dsize += acg.cg_ndblk - dupper;
 439         if ((i = dupper % sblock.fs_frag)) {
 440                 acg.cg_frsum[sblock.fs_frag - i]++;
 441                 for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
 442                         setbit(cg_blksfree(&acg), dupper);
 443                         acg.cg_cs.cs_nffree++;
 444                 }
 445         }
 446         for (d = dupper; d + sblock.fs_frag <= dmax - cbase; ) {
 447                 blkno = d / sblock.fs_frag;
 448                 setblock(&sblock, cg_blksfree(&acg), blkno);
 449                 if (sblock.fs_contigsumsize > 0) {
 450                         setbit(cg_clustersfree(&acg), blkno);
 451                 }
 452                 acg.cg_cs.cs_nbfree++;
 453                 cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
 454                 cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
 455                     [cbtorpos(&sblock, d)]++;
 456                 d += sblock.fs_frag;
 457         }
 458         if (d < dmax - cbase) {
 459                 acg.cg_frsum[dmax - cbase - d]++;
 460                 for (; d < dmax - cbase; d++) {
 461                         setbit(cg_blksfree(&acg), d);
 462                         acg.cg_cs.cs_nffree++;
 463                 }
 464         }
 465         if (sblock.fs_contigsumsize > 0) {
 466                 int32_t *sump = cg_clustersum(&acg);
 467                 u_char  *mapp = cg_clustersfree(&acg);
 468                 int     map = *mapp++;
 469                 int     bit = 1;
 470                 int     run = 0;
 471
 472                 for (i = 0; i < acg.cg_nclusterblks; i++) {
 473                         if ((map & bit) != 0) {
 474                                 run++;
 475                         } else if (run != 0) {
 476                                 if (run > sblock.fs_contigsumsize) {
 477                                         run = sblock.fs_contigsumsize;
 478                                 }
 479                                 sump[run]++;
 480                                 run = 0;
 481                         }
 482                         if ((i & (NBBY - 1)) != (NBBY - 1)) {
 483                                 bit <<= 1;
 484                         } else {
 485                                 map = *mapp++;
 486                                 bit = 1;
 487                         }
 488                 }
 489                 if (run != 0) {
 490                         if (run > sblock.fs_contigsumsize) {
 491                                 run = sblock.fs_contigsumsize;
 492                         }
 493                         sump[run]++;
 494                 }
 495         }
 496         sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
 497         sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
 498         sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
 499         sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
 500         *cs = acg.cg_cs;
 501         wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
 502             (size_t)sblock.fs_bsize, &acg, fso, Nflag);
 503         DBG_DUMP_CG(&sblock,
 504             "new cg",
 505             &acg);
 506
 507         DBG_LEAVE;
 508         return;
 509 }
 510
 511 /* ******************************************************* frag_adjust ***** */
 512 /*
 513  * Here  we add or subtract (sign +1/-1) the available fragments in  a  given
 514  * block to or from the fragment statistics. By subtracting before and adding
 515  * after  an operation on the free frag map we can easy update  the  fragment
 516  * statistic, which seems to be otherwise an rather complex operation.
 517  */
 518 static void
 519 frag_adjust(daddr_t frag, int sign)
 520 {
 521         int fragsize;
 522         int f;
 523
 524         DBG_ENTER;
 525
 526         fragsize=0;
 527         /*
 528          * Here frag only needs to point to any fragment in the block we want
 529          * to examine.
 530          */
 531         for(f=rounddown(frag, sblock.fs_frag);
 532             f<roundup(frag+1, sblock.fs_frag);
 533             f++) {
 534                 /*
 535                  * Count contiguos free fragments.
 536                  */
 537                 if(isset(cg_blksfree(&acg), f)) {
 538                         fragsize++;
 539                 } else {
 540                         if(fragsize && fragsize<sblock.fs_frag) {
 541                                 /*
 542                                  * We found something in between.
 543                                  */
 544                                 acg.cg_frsum[fragsize]+=sign;
 545                                 DBG_PRINT2("frag_adjust [%d]+=%d\n",
 546                                     fragsize,
 547                                     sign);
 548                         }
 549                         fragsize=0;
 550                 }
 551         }
 552         if(fragsize && fragsize<sblock.fs_frag) {
 553                 /*
 554                  * We found something.
 555                  */
 556                 acg.cg_frsum[fragsize]+=sign;
 557                 DBG_PRINT2("frag_adjust [%d]+=%d\n",
 558                     fragsize,
 559                     sign);
 560         }
 561         DBG_PRINT2("frag_adjust [[%d]]+=%d\n",
 562             fragsize,
 563             sign);
 564
 565         DBG_LEAVE;
 566         return;
 567 }
 568
 569 /* ******************************************************* cond_bl_upd ***** */
 570 /*
 571  * Here we conditionally update a pointer to a fragment. We check for all
 572  * relocated blocks if any of it's fragments is referenced by the current
 573  * field,  and update the pointer to the respective fragment in  our  new
 574  * block.  If  we find a reference we write back the  block  immediately,
 575  * as there is no easy way for our general block reading engine to figure
 576  * out if a write back operation is needed.
 577  */
 578 static void
 579 cond_bl_upd(ufs_daddr_t *block, struct gfs_bpp *field,
 580     enum pointer_source source, int fso, unsigned int Nflag)
 581 {
 582         struct gfs_bpp  *f;
 583         char *src;
 584         daddr_t dst=0;
 585
 586         DBG_ENTER;
 587
 588         f=field;
 589         while(f->old) { /* for all old blocks */
 590                 if(*block/sblock.fs_frag == f->old) {
 591                         /*
 592                          * The fragment is part of the block, so update.
 593                          */
 594                         *block=(f->new*sblock.fs_frag+(*block%sblock.fs_frag));
 595                         f->found++;
 596                         DBG_PRINT3("scg (%d->%d)[%d] reference updated\n",
 597                             f->old,
 598                             f->new,
 599                             *block%sblock.fs_frag);
 600
 601                         /* Write the block back to disk immediately */
 602                         switch (source) {
 603                         case GFS_PS_INODE:
 604                                 src=ablk;
 605                                 dst=in_src;
 606                                 break;
 607                         case GFS_PS_IND_BLK_LVL1:
 608                                 src=i1blk;
 609                                 dst=i1_src;
 610                                 break;
 611                         case GFS_PS_IND_BLK_LVL2:
 612                                 src=i2blk;
 613                                 dst=i2_src;
 614                                 break;
 615                         case GFS_PS_IND_BLK_LVL3:
 616                                 src=i3blk;
 617                                 dst=i3_src;
 618                                 break;
 619                         default:        /* error */
 620                                 src=NULL;
 621                                 break;
 622                         }
 623                         if(src) {
 624                                 /*
 625                                  * XXX  If src is not of type inode we have to
 626                                  *      implement  copy on write here in  case
 627                                  *      of active snapshots.
 628                                  */
 629                                 wtfs(dst, (size_t)sblock.fs_bsize, src,
 630                                     fso, Nflag);
 631                         }
 632
 633                         /*
 634                          * The same block can't be found again in this loop.
 635                          */
 636                         break;
 637                 }
 638                 f++;
 639         }
 640
 641         DBG_LEAVE;
 642         return;
 643 }
 644
 645 /* ************************************************************ updjcg ***** */
 646 /*
 647  * Here we do all needed work for the former last cylinder group. It has to be
 648  * changed  in  any case, even if the filesystem ended exactly on the  end  of
 649  * this  group, as there is some slightly inconsistent handling of the  number
 650  * of cylinders in the cylinder group. We start again by reading the  cylinder
 651  * group from disk. If the last block was not fully available, we first handle
 652  * the  missing  fragments, then we handle all new full blocks  in  that  file
 653  * system  and  finally we handle the new last fragmented block  in  the  file
 654  * system.  We again have to handle the fragment statistics rotational  layout
 655  * tables and cluster summary during all those operations.
 656  */
 657 static void
 658 updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag)
 659 {
 660         daddr_t cbase, dmax, dupper;
 661         struct csum     *cs;
 662         int     i,k;
 663         int     j=0;
 664
 665         DBG_ENTER;
 666
 667         /*
 668          * Read the former last (joining) cylinder group from disk, and make
 669          * a copy.
 670          */
 671         rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
 672             (size_t)osblock.fs_cgsize, &aocg, fsi);
 673         DBG_PRINT0("jcg read\n");
 674         DBG_DUMP_CG(&sblock,
 675             "old joining cg",
 676             &aocg);
 677
 678         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
 679
 680         /*
 681          * If  the  cylinder  group had already it's  new  final  size  almost
 682          * nothing is to be done ... except:
 683          * For some reason the value of cg_ncyl in the last cylinder group has
 684          * to  be  zero instead of fs_cpg. As this is now no longer  the  last
 685          * cylinder group we have to change that value now to fs_cpg.
 686          */
 687
 688         if(cgbase(&osblock, cylno+1) == osblock.fs_size) {
 689                 acg.cg_ncyl=sblock.fs_cpg;
 690
 691                 wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
 692                     (size_t)sblock.fs_cgsize, &acg, fso, Nflag);
 693                 DBG_PRINT0("jcg written\n");
 694                 DBG_DUMP_CG(&sblock,
 695                     "new joining cg",
 696                     &acg);
 697
 698                 DBG_LEAVE;
 699                 return;
 700         }
 701
 702         /*
 703          * Set up some variables needed later.
 704          */
 705         cbase = cgbase(&sblock, cylno);
 706         dmax = cbase + sblock.fs_fpg;
 707         if (dmax > sblock.fs_size)
 708                 dmax = sblock.fs_size;
 709         dupper = cgdmin(&sblock, cylno) - cbase;
 710         if (cylno == 0) { /* XXX fscs may be relocated */
 711                 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
 712         }
 713
 714         /*
 715          * Set pointer to the cylinder summary for our cylinder group.
 716          */
 717         cs = fscs + cylno;
 718
 719         /*
 720          * Touch the cylinder group, update all fields in the cylinder group as
 721          * needed, update the free space in the superblock.
 722          */
 723         acg.cg_time = utime;
 724         if (cylno == sblock.fs_ncg - 1) {
 725                 /*
 726                  * This is still the last cylinder group.
 727                  */
 728                 acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
 729         } else {
 730                 acg.cg_ncyl = sblock.fs_cpg;
 731         }
 732         DBG_PRINT4("jcg dbg: %d %u %d %u\n",
 733             cylno,
 734             sblock.fs_ncg,
 735             acg.cg_ncyl,
 736             sblock.fs_cpg);
 737         acg.cg_ndblk = dmax - cbase;
 738         sblock.fs_dsize += acg.cg_ndblk-aocg.cg_ndblk;
 739         if (sblock.fs_contigsumsize > 0) {
 740                 acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
 741         }
 742
 743         /*
 744          * Now  we have to update the free fragment bitmap for our new  free
 745          * space.  There again we have to handle the fragmentation and  also
 746          * the  rotational  layout tables and the cluster summary.  This  is
 747          * also  done per fragment for the first new block if the  old  file
 748          * system end was not on a block boundary, per fragment for the  new
 749          * last block if the new file system end is not on a block boundary,
 750          * and per block for all space in between.
 751          *
 752          * Handle the first new block here if it was partially available
 753          * before.
 754          */
 755         if(osblock.fs_size % sblock.fs_frag) {
 756                 if(roundup(osblock.fs_size, sblock.fs_frag)<=sblock.fs_size) {
 757                         /*
 758                          * The new space is enough to fill at least this
 759                          * block
 760                          */
 761                         j=0;
 762                         for(i=roundup(osblock.fs_size-cbase, sblock.fs_frag)-1;
 763                             i>=osblock.fs_size-cbase;
 764                             i--) {
 765                                 setbit(cg_blksfree(&acg), i);
 766                                 acg.cg_cs.cs_nffree++;
 767                                 j++;
 768                         }
 769
 770                         /*
 771                          * Check  if the fragment just created could join  an
 772                          * already existing fragment at the former end of the
 773                          * file system.
 774                          */
 775                         if(isblock(&sblock, cg_blksfree(&acg),
 776                             ((osblock.fs_size - cgbase(&sblock, cylno))/
 777                             sblock.fs_frag))) {
 778                                 /*
 779                                  * The block is now completely available
 780                                  */
 781                                 DBG_PRINT0("block was\n");
 782                                 acg.cg_frsum[osblock.fs_size%sblock.fs_frag]--;
 783                                 acg.cg_cs.cs_nbfree++;
 784                                 acg.cg_cs.cs_nffree-=sblock.fs_frag;
 785                                 k=rounddown(osblock.fs_size-cbase,
 786                                     sblock.fs_frag);
 787                                 cg_blktot(&acg)[cbtocylno(&sblock, k)]++;
 788                                 cg_blks(&sblock, &acg, cbtocylno(&sblock, k))
 789                                     [cbtorpos(&sblock, k)]++;
 790                                 updclst((osblock.fs_size-cbase)/sblock.fs_frag);
 791                         } else {
 792                                 /*
 793                                  * Lets rejoin a possible partially growed
 794                                  * fragment.
 795                                  */
 796                                 k=0;
 797                                 while(isset(cg_blksfree(&acg), i) &&
 798                                     (i>=rounddown(osblock.fs_size-cbase,
 799                                     sblock.fs_frag))) {
 800                                         i--;
 801                                         k++;
 802                                 }
 803                                 if(k) {
 804                                         acg.cg_frsum[k]--;
 805                                 }
 806                                 acg.cg_frsum[k+j]++;
 807                         }
 808                 } else {
 809                         /*
 810                          * We only grow by some fragments within this last
 811                          * block.
 812                          */
 813                         for(i=sblock.fs_size-cbase-1;
 814                                 i>=osblock.fs_size-cbase;
 815                                 i--) {
 816                                 setbit(cg_blksfree(&acg), i);
 817                                 acg.cg_cs.cs_nffree++;
 818                                 j++;
 819                         }
 820                         /*
 821                          * Lets rejoin a possible partially growed fragment.
 822                          */
 823                         k=0;
 824                         while(isset(cg_blksfree(&acg), i) &&
 825                             (i>=rounddown(osblock.fs_size-cbase,
 826                             sblock.fs_frag))) {
 827                                 i--;
 828                                 k++;
 829                         }
 830                         if(k) {
 831                                 acg.cg_frsum[k]--;
 832                         }
 833                         acg.cg_frsum[k+j]++;
 834                 }
 835         }
 836
 837         /*
 838          * Handle all new complete blocks here.
 839          */
 840         for(i=roundup(osblock.fs_size-cbase, sblock.fs_frag);
 841             i+sblock.fs_frag<=dmax-cbase;       /* XXX <= or only < ? */
 842             i+=sblock.fs_frag) {
 843                 j = i / sblock.fs_frag;
 844                 setblock(&sblock, cg_blksfree(&acg), j);
 845                 updclst(j);
 846                 acg.cg_cs.cs_nbfree++;
 847                 cg_blktot(&acg)[cbtocylno(&sblock, i)]++;
 848                 cg_blks(&sblock, &acg, cbtocylno(&sblock, i))
 849                     [cbtorpos(&sblock, i)]++;
 850         }
 851
 852         /*
 853          * Handle the last new block if there are stll some new fragments left.
 854          * Here  we don't have to bother about the cluster summary or the  even
 855          * the rotational layout table.
 856          */
 857         if (i < (dmax - cbase)) {
 858                 acg.cg_frsum[dmax - cbase - i]++;
 859                 for (; i < dmax - cbase; i++) {
 860                         setbit(cg_blksfree(&acg), i);
 861                         acg.cg_cs.cs_nffree++;
 862                 }
 863         }
 864
 865         sblock.fs_cstotal.cs_nffree +=
 866             (acg.cg_cs.cs_nffree - aocg.cg_cs.cs_nffree);
 867         sblock.fs_cstotal.cs_nbfree +=
 868             (acg.cg_cs.cs_nbfree - aocg.cg_cs.cs_nbfree);
 869         /*
 870          * The following statistics are not changed here:
 871          *     sblock.fs_cstotal.cs_ndir
 872          *     sblock.fs_cstotal.cs_nifree
 873          * As the statistics for this cylinder group are ready, copy it to
 874          * the summary information array.
 875          */
 876         *cs = acg.cg_cs;
 877
 878         /*
 879          * Write the updated "joining" cylinder group back to disk.
 880          */
 881         wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
 882             &acg, fso, Nflag);
 883         DBG_PRINT0("jcg written\n");
 884         DBG_DUMP_CG(&sblock,
 885             "new joining cg",
 886             &acg);
 887
 888         DBG_LEAVE;
 889         return;
 890 }
 891
 892 /* ********************************************************** updcsloc ***** */
 893 /*
 894  * Here  we update the location of the cylinder summary. We have  two  possible
 895  * ways of growing the cylinder summary.
 896  * (1)  We can try to grow the summary in the current location, and  relocate
 897  *      possibly used blocks within the current cylinder group.
 898  * (2)  Alternatively we can relocate the whole cylinder summary to the first
 899  *      new completely empty cylinder group. Once the cylinder summary is  no
 900  *      longer in the beginning of the first cylinder group you should  never
 901  *      use  a version of fsck which is not aware of the possibility to  have
 902  *      this structure in a non standard place.
 903  * Option (1) is considered to be less intrusive to the structure of the  file-
 904  * system. So we try to stick to that whenever possible. If there is not enough
 905  * space  in the cylinder group containing the cylinder summary we have to  use
 906  * method  (2). In case of active snapshots in the filesystem we  probably  can
 907  * completely avoid implementing copy on write if we stick to method (2) only.
 908  */
 909 static void
 910 updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag)
 911 {
 912         struct csum     *cs;
 913         int     ocscg, ncscg;
 914         int     blocks;
 915         daddr_t cbase, dupper, odupper, d, f, g;
 916         int     ind;
 917         int     cylno, inc;
 918         struct gfs_bpp  *bp;
 919         int     i, l;
 920         int     lcs=0;
 921         int     block;
 922
 923         DBG_ENTER;
 924
 925         if(howmany(sblock.fs_cssize, sblock.fs_fsize) ==
 926             howmany(osblock.fs_cssize, osblock.fs_fsize)) {
 927                 /*
 928                  * No new fragment needed.
 929                  */
 930                 DBG_LEAVE;
 931                 return;
 932         }
 933         ocscg=dtog(&osblock, osblock.fs_csaddr);
 934         cs=fscs+ocscg;
 935         blocks = 1+howmany(sblock.fs_cssize, sblock.fs_bsize)-
 936             howmany(osblock.fs_cssize, osblock.fs_bsize);
 937
 938         /*
 939          * Read original cylinder group from disk, and make a copy.
 940          * XXX  If Nflag is set in some very rare cases we now miss
 941          *      some changes done in updjcg by reading the unmodified
 942          *      block from disk.
 943          */
 944         rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
 945             (size_t)osblock.fs_cgsize, &aocg, fsi);
 946         DBG_PRINT0("oscg read\n");
 947         DBG_DUMP_CG(&sblock,
 948             "old summary cg",
 949             &aocg);
 950
 951         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
 952
 953         /*
 954          * Touch the cylinder group, set up local variables needed later
 955          * and update the superblock.
 956          */
 957         acg.cg_time = utime;
 958
 959         /*
 960          * XXX  In the case of having active snapshots we may need much more
 961          *      blocks for the copy on write. We need each block twice,  and
 962          *      also  up to 8*3 blocks for indirect blocks for all  possible
 963          *      references.
 964          */
 965         if(/*((int)sblock.fs_time&0x3)>0||*/ cs->cs_nbfree < blocks) {
 966                 /*
 967                  * There  is  not enough space in the old cylinder  group  to
 968                  * relocate  all blocks as needed, so we relocate  the  whole
 969                  * cylinder  group summary to a new group. We try to use  the
 970                  * first complete new cylinder group just created. Within the
 971                  * cylinder  group we allign the area immediately  after  the
 972                  * cylinder  group  information location in order  to  be  as
 973                  * close as possible to the original implementation of ffs.
 974                  *
 975                  * First  we have to make sure we'll find enough space in  the
 976                  * new  cylinder  group. If not, then we  currently  give  up.
 977                  * We  start  with freeing everything which was  used  by  the
 978                  * fragments of the old cylinder summary in the current group.
 979                  * Now  we write back the group meta data, read in the  needed
 980                  * meta data from the new cylinder group, and start allocating
 981                  * within  that  group. Here we can assume, the  group  to  be
 982                  * completely empty. Which makes the handling of fragments and
 983                  * clusters a lot easier.
 984                  */
 985                 DBG_TRC;
 986                 if(sblock.fs_ncg-osblock.fs_ncg < 2) {
 987                         errx(2, "panic: not enough space");
 988                 }
 989
 990                 /*
 991                  * Point "d" to the first fragment not used by the cylinder
 992                  * summary.
 993                  */
 994                 d=osblock.fs_csaddr+(osblock.fs_cssize/osblock.fs_fsize);
 995
 996                 /*
 997                  * Set up last cluster size ("lcs") already here. Calculate
 998                  * the size for the trailing cluster just behind where  "d"
 999                  * points to.
1000                  */
1001                 if(sblock.fs_contigsumsize > 0) {
1002                         for(block=howmany(d%sblock.fs_fpg, sblock.fs_frag),
1003                             lcs=0; lcs<sblock.fs_contigsumsize;
1004                             block++, lcs++) {
1005                                 if(isclr(cg_clustersfree(&acg), block)){
1006                                         break;
1007                                 }
1008                         }
1009                 }
1010
1011                 /*
1012                  * Point "d" to the last frag used by the cylinder summary.
1013                  */
1014                 d--;
1015
1016                 DBG_PRINT1("d=%d\n",
1017                     d);
1018                 if((d+1)%sblock.fs_frag) {
1019                         /*
1020                          * The end of the cylinder summary is not a complete
1021                          * block.
1022                          */
1023                         DBG_TRC;
1024                         frag_adjust(d%sblock.fs_fpg, -1);
1025                         for(; (d+1)%sblock.fs_frag; d--) {
1026                                 DBG_PRINT1("d=%d\n",
1027                                     d);
1028                                 setbit(cg_blksfree(&acg), d%sblock.fs_fpg);
1029                                 acg.cg_cs.cs_nffree++;
1030                                 sblock.fs_cstotal.cs_nffree++;
1031                         }
1032                         /*
1033                          * Point  "d" to the last fragment of the  last
1034                          * (incomplete) block of the clinder summary.
1035                          */
1036                         d++;
1037                         frag_adjust(d%sblock.fs_fpg, 1);
1038
1039                         if(isblock(&sblock, cg_blksfree(&acg),
1040                             (d%sblock.fs_fpg)/sblock.fs_frag)) {
1041                                 DBG_PRINT1("d=%d\n",
1042                                     d);
1043                                 acg.cg_cs.cs_nffree-=sblock.fs_frag;
1044                                 acg.cg_cs.cs_nbfree++;
1045                                 sblock.fs_cstotal.cs_nffree-=sblock.fs_frag;
1046                                 sblock.fs_cstotal.cs_nbfree++;
1047                                 cg_blktot(&acg)[cbtocylno(&sblock,
1048                                     d%sblock.fs_fpg)]++;
1049                                 cg_blks(&sblock, &acg, cbtocylno(&sblock,
1050                                     d%sblock.fs_fpg))[cbtorpos(&sblock,
1051                                     d%sblock.fs_fpg)]++;
1052                                 if(sblock.fs_contigsumsize > 0) {
1053                                         setbit(cg_clustersfree(&acg),
1054                                             (d%sblock.fs_fpg)/sblock.fs_frag);
1055                                         if(lcs < sblock.fs_contigsumsize) {
1056                                                 if(lcs) {
1057                                                         cg_clustersum(&acg)
1058                                                             [lcs]--;
1059                                                 }
1060                                                 lcs++;
1061                                                 cg_clustersum(&acg)[lcs]++;
1062                                         }
1063                                 }
1064                         }
1065                         /*
1066                          * Point "d" to the first fragment of the block before
1067                          * the last incomplete block.
1068                          */
1069                         d--;
1070                 }
1071
1072                 DBG_PRINT1("d=%d\n",
1073                     d);
1074                 for(d=rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr;
1075                     d-=sblock.fs_frag) {
1076                         DBG_TRC;
1077                         DBG_PRINT1("d=%d\n",
1078                             d);
1079                         setblock(&sblock, cg_blksfree(&acg),
1080                             (d%sblock.fs_fpg)/sblock.fs_frag);
1081                         acg.cg_cs.cs_nbfree++;
1082                         sblock.fs_cstotal.cs_nbfree++;
1083                         cg_blktot(&acg)[cbtocylno(&sblock, d%sblock.fs_fpg)]++;
1084                         cg_blks(&sblock, &acg, cbtocylno(&sblock,
1085                             d%sblock.fs_fpg))[cbtorpos(&sblock,
1086                             d%sblock.fs_fpg)]++;
1087                         if(sblock.fs_contigsumsize > 0) {
1088                                 setbit(cg_clustersfree(&acg),
1089                                     (d%sblock.fs_fpg)/sblock.fs_frag);
1090                                 /*
1091                                  * The last cluster size is already set up.
1092                                  */
1093                                 if(lcs < sblock.fs_contigsumsize) {
1094                                         if(lcs) {
1095                                                 cg_clustersum(&acg)[lcs]--;
1096                                         }
1097                                         lcs++;
1098                                         cg_clustersum(&acg)[lcs]++;
1099                                 }
1100                         }
1101                 }
1102                 *cs = acg.cg_cs;
1103
1104                 /*
1105                  * Now write the former cylinder group containing the cylinder
1106                  * summary back to disk.
1107                  */
1108                 wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
1109                     (size_t)sblock.fs_cgsize, &acg, fso, Nflag);
1110                 DBG_PRINT0("oscg written\n");
1111                 DBG_DUMP_CG(&sblock,
1112                     "old summary cg",
1113                     &acg);
1114
1115                 /*
1116                  * Find the beginning of the new cylinder group containing the
1117                  * cylinder summary.
1118                  */
1119                 sblock.fs_csaddr=cgdmin(&sblock, osblock.fs_ncg);
1120                 ncscg=dtog(&sblock, sblock.fs_csaddr);
1121                 cs=fscs+ncscg;
1122
1123
1124                 /*
1125                  * If Nflag is specified, we would now read random data instead
1126                  * of an empty cg structure from disk. So we can't simulate that
1127                  * part for now.
1128                  */
1129                 if(Nflag) {
1130                         DBG_PRINT0("nscg update skipped\n");
1131                         DBG_LEAVE;
1132                         return;
1133                 }
1134
1135                 /*
1136                  * Read the future cylinder group containing the cylinder
1137                  * summary from disk, and make a copy.
1138                  */
1139                 rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1140                     (size_t)sblock.fs_cgsize, &aocg, fsi);
1141                 DBG_PRINT0("nscg read\n");
1142                 DBG_DUMP_CG(&sblock,
1143                     "new summary cg",
1144                     &aocg);
1145
1146                 memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
1147
1148                 /*
1149                  * Allocate all complete blocks used by the new cylinder
1150                  * summary.
1151                  */
1152                 for(d=sblock.fs_csaddr; d+sblock.fs_frag <=
1153                     sblock.fs_csaddr+(sblock.fs_cssize/sblock.fs_fsize);
1154                     d+=sblock.fs_frag) {
1155                         clrblock(&sblock, cg_blksfree(&acg),
1156                             (d%sblock.fs_fpg)/sblock.fs_frag);
1157                         acg.cg_cs.cs_nbfree--;
1158                         sblock.fs_cstotal.cs_nbfree--;
1159                         cg_blktot(&acg)[cbtocylno(&sblock, d%sblock.fs_fpg)]--;
1160                         cg_blks(&sblock, &acg, cbtocylno(&sblock,
1161                             d%sblock.fs_fpg))[cbtorpos(&sblock,
1162                             d%sblock.fs_fpg)]--;
1163                         if(sblock.fs_contigsumsize > 0) {
1164                                 clrbit(cg_clustersfree(&acg),
1165                                     (d%sblock.fs_fpg)/sblock.fs_frag);
1166                         }
1167                 }
1168
1169                 /*
1170                  * Allocate all fragments used by the cylinder summary in the
1171                  * last block.
1172                  */
1173                 if(d<sblock.fs_csaddr+(sblock.fs_cssize/sblock.fs_fsize)) {
1174                         for(; d-sblock.fs_csaddr<
1175                             sblock.fs_cssize/sblock.fs_fsize;
1176                             d++) {
1177                                 clrbit(cg_blksfree(&acg), d%sblock.fs_fpg);
1178                                 acg.cg_cs.cs_nffree--;
1179                                 sblock.fs_cstotal.cs_nffree--;
1180                         }
1181                         acg.cg_cs.cs_nbfree--;
1182                         acg.cg_cs.cs_nffree+=sblock.fs_frag;
1183                         sblock.fs_cstotal.cs_nbfree--;
1184                         sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;
1185                         cg_blktot(&acg)[cbtocylno(&sblock, d%sblock.fs_fpg)]--;
1186                         cg_blks(&sblock, &acg, cbtocylno(&sblock,
1187                             d%sblock.fs_fpg))[cbtorpos(&sblock,
1188                             d%sblock.fs_fpg)]--;
1189                         if(sblock.fs_contigsumsize > 0) {
1190                                 clrbit(cg_clustersfree(&acg),
1191                                     (d%sblock.fs_fpg)/sblock.fs_frag);
1192                         }
1193
1194                         frag_adjust(d%sblock.fs_fpg, +1);
1195                 }
1196                 /*
1197                  * XXX  Handle the cluster statistics here in the case  this
1198                  *      cylinder group is now almost full, and the remaining
1199                  *      space is less then the maximum cluster size. This is
1200                  *      probably not needed, as you would hardly find a file
1201                  *      system which has only MAXCSBUFS+FS_MAXCONTIG of free
1202                  *      space right behind the cylinder group information in
1203                  *      any new cylinder group.
1204                  */
1205
1206                 /*
1207                  * Update our statistics in the cylinder summary.
1208                  */
1209                 *cs = acg.cg_cs;
1210
1211                 /*
1212                  * Write the new cylinder group containing the cylinder summary
1213                  * back to disk.
1214                  */
1215                 wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1216                     (size_t)sblock.fs_cgsize, &acg, fso, Nflag);
1217                 DBG_PRINT0("nscg written\n");
1218                 DBG_DUMP_CG(&sblock,
1219                     "new summary cg",
1220                     &acg);
1221
1222                 DBG_LEAVE;
1223                 return;
1224         }
1225         /*
1226          * We have got enough of space in the current cylinder group, so we
1227          * can relocate just a few blocks, and let the summary  information
1228          * grow in place where it is right now.
1229          */
1230         DBG_TRC;
1231
1232         cbase = cgbase(&osblock, ocscg);        /* old and new are equal */
1233         dupper = sblock.fs_csaddr - cbase +
1234             howmany(sblock.fs_cssize, sblock.fs_fsize);
1235         odupper = osblock.fs_csaddr - cbase +
1236             howmany(osblock.fs_cssize, osblock.fs_fsize);
1237
1238         sblock.fs_dsize -= dupper-odupper;
1239
1240         /*
1241          * Allocate the space for the array of blocks to be relocated.
1242          */
1243         bp=(struct gfs_bpp *)malloc(((dupper-odupper)/sblock.fs_frag+2)*
1244             sizeof(struct gfs_bpp));
1245         if(bp == NULL) {
1246                 errx(1, "malloc failed");
1247         }
1248         memset((char *)bp, 0, ((dupper-odupper)/sblock.fs_frag+2)*
1249             sizeof(struct gfs_bpp));
1250
1251         /*
1252          * Lock all new frags needed for the cylinder group summary. This  is
1253          * done per fragment in the first and last block of the new  required
1254          * area, and per block for all other blocks.
1255          *
1256          * Handle the first new  block here (but only if some fragments where
1257          * already used for the cylinder summary).
1258          */
1259         ind=0;
1260         frag_adjust(odupper, -1);
1261         for(d=odupper; ((d<dupper)&&(d%sblock.fs_frag)); d++) {
1262                 DBG_PRINT1("scg first frag check loop d=%d\n",
1263                     d);
1264                 if(isclr(cg_blksfree(&acg), d)) {
1265                         if (!ind) {
1266                                 bp[ind].old=d/sblock.fs_frag;
1267                                 bp[ind].flags|=GFS_FL_FIRST;
1268                                 if(roundup(d, sblock.fs_frag) >= dupper) {
1269                                         bp[ind].flags|=GFS_FL_LAST;
1270                                 }
1271                                 ind++;
1272                         }
1273                 } else {
1274                         clrbit(cg_blksfree(&acg), d);
1275                         acg.cg_cs.cs_nffree--;
1276                         sblock.fs_cstotal.cs_nffree--;
1277                 }
1278                 /*
1279                  * No cluster handling is needed here, as there was at least
1280                  * one  fragment in use by the cylinder summary in  the  old
1281                  * file system.
1282                  * No block-free counter handling here as this block was not
1283                  * a free block.
1284                  */
1285         }
1286         frag_adjust(odupper, 1);
1287
1288         /*
1289          * Handle all needed complete blocks here.
1290          */
1291         for(; d+sblock.fs_frag<=dupper; d+=sblock.fs_frag) {
1292                 DBG_PRINT1("scg block check loop d=%d\n",
1293                     d);
1294                 if(!isblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag)) {
1295                         for(f=d; f<d+sblock.fs_frag; f++) {
1296                                 if(isset(cg_blksfree(&aocg), f)) {
1297                                         acg.cg_cs.cs_nffree--;
1298                                         sblock.fs_cstotal.cs_nffree--;
1299                                 }
1300                         }
1301                         clrblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag);
1302                         bp[ind].old=d/sblock.fs_frag;
1303                         ind++;
1304                 } else {
1305                         clrblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag);
1306                         acg.cg_cs.cs_nbfree--;
1307                         sblock.fs_cstotal.cs_nbfree--;
1308                         cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
1309                         cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
1310                             [cbtorpos(&sblock, d)]--;
1311                         if(sblock.fs_contigsumsize > 0) {
1312                                 clrbit(cg_clustersfree(&acg), d/sblock.fs_frag);
1313                                 for(lcs=0, l=(d/sblock.fs_frag)+1;
1314                                     lcs<sblock.fs_contigsumsize;
1315                                     l++, lcs++ ) {
1316                                         if(isclr(cg_clustersfree(&acg),l)){
1317                                                 break;
1318                                         }
1319                                 }
1320                                 if(lcs < sblock.fs_contigsumsize) {
1321                                         cg_clustersum(&acg)[lcs+1]--;
1322                                         if(lcs) {
1323                                                 cg_clustersum(&acg)[lcs]++;
1324                                         }
1325                                 }
1326                         }
1327                 }
1328                 /*
1329                  * No fragment counter handling is needed here, as this finally
1330                  * doesn't change after the relocation.
1331                  */
1332         }
1333
1334         /*
1335          * Handle all fragments needed in the last new affected block.
1336          */
1337         if(d<dupper) {
1338                 frag_adjust(dupper-1, -1);
1339
1340                 if(isblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag)) {
1341                         acg.cg_cs.cs_nbfree--;
1342                         sblock.fs_cstotal.cs_nbfree--;
1343                         acg.cg_cs.cs_nffree+=sblock.fs_frag;
1344                         sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;
1345                         cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
1346                         cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
1347                             [cbtorpos(&sblock, d)]--;
1348                         if(sblock.fs_contigsumsize > 0) {
1349                                 clrbit(cg_clustersfree(&acg), d/sblock.fs_frag);
1350                                 for(lcs=0, l=(d/sblock.fs_frag)+1;
1351                                     lcs<sblock.fs_contigsumsize;
1352                                     l++, lcs++ ) {
1353                                         if(isclr(cg_clustersfree(&acg),l)){
1354                                                 break;
1355                                         }
1356                                 }
1357                                 if(lcs < sblock.fs_contigsumsize) {
1358                                         cg_clustersum(&acg)[lcs+1]--;
1359                                         if(lcs) {
1360                                                 cg_clustersum(&acg)[lcs]++;
1361                                         }
1362                                 }
1363                         }
1364                 }
1365
1366                 for(; d<dupper; d++) {
1367                         DBG_PRINT1("scg second frag check loop d=%d\n",
1368                             d);
1369                         if(isclr(cg_blksfree(&acg), d)) {
1370                                 bp[ind].old=d/sblock.fs_frag;
1371                                 bp[ind].flags|=GFS_FL_LAST;
1372                         } else {
1373                                 clrbit(cg_blksfree(&acg), d);
1374                                 acg.cg_cs.cs_nffree--;
1375                                 sblock.fs_cstotal.cs_nffree--;
1376                         }
1377                 }
1378                 if(bp[ind].flags & GFS_FL_LAST) { /* we have to advance here */
1379                         ind++;
1380                 }
1381                 frag_adjust(dupper-1, 1);
1382         }
1383
1384         /*
1385          * If we found a block to relocate just do so.
1386          */
1387         if(ind) {
1388                 for(i=0; i<ind; i++) {
1389                         if(!bp[i].old) { /* no more blocks listed */
1390                                 /*
1391                                  * XXX  A relative blocknumber should not be
1392                                  *      zero,   which  is   not   explicitly
1393                                  *      guaranteed by our code.
1394                                  */
1395                                 break;
1396                         }
1397                         /*
1398                          * Allocate a complete block in the same (current)
1399                          * cylinder group.
1400                          */
1401                         bp[i].new=alloc()/sblock.fs_frag;
1402
1403                         /*
1404                          * There is no frag_adjust() needed for the new block
1405                          * as it will have no fragments yet :-).
1406                          */
1407                         for(f=bp[i].old*sblock.fs_frag,
1408                             g=bp[i].new*sblock.fs_frag;
1409                             f<(bp[i].old+1)*sblock.fs_frag;
1410                             f++, g++) {
1411                                 if(isset(cg_blksfree(&aocg), f)) {
1412                                         setbit(cg_blksfree(&acg), g);
1413                                         acg.cg_cs.cs_nffree++;
1414                                         sblock.fs_cstotal.cs_nffree++;
1415                                 }
1416                         }
1417
1418                         /*
1419                          * Special handling is required if this was the  first
1420                          * block. We have to consider the fragments which were
1421                          * used by the cylinder summary in the original  block
1422                          * which  re to be free in the copy of our  block.  We
1423                          * have  to be careful if this first block happens  to
1424                          * be also the last block to be relocated.
1425                          */
1426                         if(bp[i].flags & GFS_FL_FIRST) {
1427                                 for(f=bp[i].old*sblock.fs_frag,
1428                                     g=bp[i].new*sblock.fs_frag;
1429                                     f<odupper;
1430                                     f++, g++) {
1431                                         setbit(cg_blksfree(&acg), g);
1432                                         acg.cg_cs.cs_nffree++;
1433                                         sblock.fs_cstotal.cs_nffree++;
1434                                 }
1435                                 if(!(bp[i].flags & GFS_FL_LAST)) {
1436                                         frag_adjust(bp[i].new*sblock.fs_frag,1);
1437                                 }
1438
1439                         }
1440
1441                         /*
1442                          * Special handling is required if this is the last
1443                          * block to be relocated.
1444                          */
1445                         if(bp[i].flags & GFS_FL_LAST) {
1446                                 frag_adjust(bp[i].new*sblock.fs_frag, 1);
1447                                 frag_adjust(bp[i].old*sblock.fs_frag, -1);
1448                                 for(f=dupper;
1449                                     f<roundup(dupper, sblock.fs_frag);
1450                                     f++) {
1451                                         if(isclr(cg_blksfree(&acg), f)) {
1452                                                 setbit(cg_blksfree(&acg), f);
1453                                                 acg.cg_cs.cs_nffree++;
1454                                                 sblock.fs_cstotal.cs_nffree++;
1455                                         }
1456                                 }
1457                                 frag_adjust(bp[i].old*sblock.fs_frag, 1);
1458                         }
1459
1460                         /*
1461                          * !!! Attach the cylindergroup offset here.
1462                          */
1463                         bp[i].old+=cbase/sblock.fs_frag;
1464                         bp[i].new+=cbase/sblock.fs_frag;
1465
1466                         /*
1467                          * Copy the content of the block.
1468                          */
1469                         /*
1470                          * XXX  Here we will have to implement a copy on write
1471                          *      in the case we have any active snapshots.
1472                          */
1473                         rdfs(fsbtodb(&sblock, bp[i].old*sblock.fs_frag),
1474                             (size_t)sblock.fs_bsize, &ablk, fsi);
1475                         wtfs(fsbtodb(&sblock, bp[i].new*sblock.fs_frag),
1476                             (size_t)sblock.fs_bsize, &ablk, fso, Nflag);
1477                         DBG_DUMP_HEX(&sblock,
1478                             "copied full block",
1479                             (unsigned char *)&ablk);
1480
1481                         DBG_PRINT2("scg (%d->%d) block relocated\n",
1482                             bp[i].old,
1483                             bp[i].new);
1484                 }
1485
1486                 /*
1487                  * Now we have to update all references to any fragment which
1488                  * belongs  to any block relocated. We iterate now  over  all
1489                  * cylinder  groups,  within those over all non  zero  length
1490                  * inodes.
1491                  */
1492                 for(cylno=0; cylno<osblock.fs_ncg; cylno++) {
1493                         DBG_PRINT1("scg doing cg (%d)\n",
1494                             cylno);
1495                         for(inc=osblock.fs_ipg-1 ; inc>=0 ; inc--) {
1496                                 updrefs(cylno, (ino_t)inc, bp, fsi, fso, Nflag);
1497                         }
1498                 }
1499
1500                 /*
1501                  * All inodes are checked, now make sure the number of
1502                  * references found make sense.
1503                  */
1504                 for(i=0; i<ind; i++) {
1505                         if(!bp[i].found || (bp[i].found>sblock.fs_frag)) {
1506                                 warnx("error: %d refs found for block %d.",
1507                                     bp[i].found, bp[i].old);
1508                         }
1509
1510                 }
1511         }
1512         /*
1513          * The following statistics are not changed here:
1514          *     sblock.fs_cstotal.cs_ndir
1515          *     sblock.fs_cstotal.cs_nifree
1516          * The following statistics were already updated on the fly:
1517          *     sblock.fs_cstotal.cs_nffree
1518          *     sblock.fs_cstotal.cs_nbfree
1519          * As the statistics for this cylinder group are ready, copy it to
1520          * the summary information array.
1521          */
1522
1523         *cs = acg.cg_cs;
1524
1525         /*
1526          * Write summary cylinder group back to disk.
1527          */
1528         wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), (size_t)sblock.fs_cgsize,
1529             &acg, fso, Nflag);
1530         DBG_PRINT0("scg written\n");
1531         DBG_DUMP_CG(&sblock,
1532             "new summary cg",
1533             &acg);
1534
1535         DBG_LEAVE;
1536         return;
1537 }
1538
1539 /* ************************************************************** rdfs ***** */
1540 /*
1541  * Here we read some block(s) from disk.
1542  */
1543 static void
1544 rdfs(daddr_t bno, size_t size, void *bf, int fsi)
1545 {
1546         ssize_t n;
1547
1548         DBG_ENTER;
1549
1550         if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
1551                 err(33, "rdfs: seek error: %ld", (long)bno);
1552         }
1553         n = read(fsi, bf, size);
1554         if (n != (ssize_t)size) {
1555                 err(34, "rdfs: read error: %ld", (long)bno);
1556         }
1557
1558         DBG_LEAVE;
1559         return;
1560 }
1561
1562 /* ************************************************************** wtfs ***** */
1563 /*
1564  * Here we write some block(s) to disk.
1565  */
1566 static void
1567 wtfs(daddr_t bno, size_t size, void *bf, int fso, unsigned int Nflag)
1568 {
1569         ssize_t n;
1570
1571         DBG_ENTER;
1572
1573         if (Nflag) {
1574                 DBG_LEAVE;
1575                 return;
1576         }
1577         if (lseek(fso, (off_t)bno * DEV_BSIZE, SEEK_SET) < 0) {
1578                 err(35, "wtfs: seek error: %ld", (long)bno);
1579         }
1580         n = write(fso, bf, size);
1581         if (n != (ssize_t)size) {
1582                 err(36, "wtfs: write error: %ld", (long)bno);
1583         }
1584
1585         DBG_LEAVE;
1586         return;
1587 }
1588
1589 /* ************************************************************* alloc ***** */
1590 /*
1591  * Here we allocate a free block in the current cylinder group. It is assumed,
1592  * that  acg contains the current cylinder group. As we may take a block  from
1593  * somewhere in the filesystem we have to handle cluster summary here.
1594  */
1595 static daddr_t
1596 alloc(void)
1597 {
1598         daddr_t d, blkno;
1599         int     lcs1, lcs2;
1600         int     l;
1601         int     csmin, csmax;
1602         int     dlower, dupper, dmax;
1603
1604         DBG_ENTER;
1605
1606         if (acg.cg_magic != CG_MAGIC) {
1607                 warnx("acg: bad magic number");
1608                 DBG_LEAVE;
1609                 return (0);
1610         }
1611         if (acg.cg_cs.cs_nbfree == 0) {
1612                 warnx("error: cylinder group ran out of space");
1613                 DBG_LEAVE;
1614                 return (0);
1615         }
1616         /*
1617          * We start seeking for free blocks only from the space available after
1618          * the  end of the new grown cylinder summary. Otherwise we allocate  a
1619          * block here which we have to relocate a couple of seconds later again
1620          * again, and we are not prepared to to this anyway.
1621          */
1622         blkno=-1;
1623         dlower=cgsblock(&sblock, acg.cg_cgx)-cgbase(&sblock, acg.cg_cgx);
1624         dupper=cgdmin(&sblock, acg.cg_cgx)-cgbase(&sblock, acg.cg_cgx);
1625         dmax=cgbase(&sblock, acg.cg_cgx)+sblock.fs_fpg;
1626         if (dmax > sblock.fs_size) {
1627                 dmax = sblock.fs_size;
1628         }
1629         dmax-=cgbase(&sblock, acg.cg_cgx); /* retransform into cg */
1630         csmin=sblock.fs_csaddr-cgbase(&sblock, acg.cg_cgx);
1631         csmax=csmin+howmany(sblock.fs_cssize, sblock.fs_fsize);
1632         DBG_PRINT3("seek range: dl=%d, du=%d, dm=%d\n",
1633             dlower,
1634             dupper,
1635             dmax);
1636         DBG_PRINT2("range cont: csmin=%d, csmax=%d\n",
1637             csmin,
1638             csmax);
1639
1640         for(d=0; (d<dlower && blkno==-1); d+=sblock.fs_frag) {
1641                 if(d>=csmin && d<=csmax) {
1642                         continue;
1643                 }
1644                 if(isblock(&sblock, cg_blksfree(&acg), fragstoblks(&sblock,
1645                     d))) {
1646                         blkno = fragstoblks(&sblock, d);/* Yeah found a block */
1647                         break;
1648                 }
1649         }
1650         for(d=dupper; (d<dmax && blkno==-1); d+=sblock.fs_frag) {
1651                 if(d>=csmin && d<=csmax) {
1652                         continue;
1653                 }
1654                 if(isblock(&sblock, cg_blksfree(&acg), fragstoblks(&sblock,
1655                     d))) {
1656                         blkno = fragstoblks(&sblock, d);/* Yeah found a block */
1657                         break;
1658                 }
1659         }
1660         if(blkno==-1) {
1661                 warnx("internal error: couldn't find promised block in cg");
1662                 DBG_LEAVE;
1663                 return (0);
1664         }
1665
1666         /*
1667          * This is needed if the block was found already in the first loop.
1668          */
1669         d=blkstofrags(&sblock, blkno);
1670
1671         clrblock(&sblock, cg_blksfree(&acg), blkno);
1672         if (sblock.fs_contigsumsize > 0) {
1673                 /*
1674                  * Handle the cluster allocation bitmap.
1675                  */
1676                 clrbit(cg_clustersfree(&acg), blkno);
1677                 /*
1678                  * We  possibly have split a cluster here, so we have  to  do
1679                  * recalculate the sizes of the remaining cluster halves now,
1680                  * and use them for updating the cluster summary information.
1681                  *
1682                  * Lets start with the blocks before our allocated block ...
1683                  */
1684                 for(lcs1=0, l=blkno-1; lcs1<sblock.fs_contigsumsize;
1685                     l--, lcs1++ ) {
1686                         if(isclr(cg_clustersfree(&acg),l)){
1687                                 break;
1688                         }
1689                 }
1690                 /*
1691                  * ... and continue with the blocks right after our allocated
1692                  * block.
1693                  */
1694                 for(lcs2=0, l=blkno+1; lcs2<sblock.fs_contigsumsize;
1695                     l++, lcs2++ ) {
1696                         if(isclr(cg_clustersfree(&acg),l)){
1697                                 break;
1698                         }
1699                 }
1700
1701                 /*
1702                  * Now update all counters.
1703                  */
1704                 cg_clustersum(&acg)[MIN(lcs1+lcs2+1,sblock.fs_contigsumsize)]--;
1705                 if(lcs1) {
1706                         cg_clustersum(&acg)[lcs1]++;
1707                 }
1708                 if(lcs2) {
1709                         cg_clustersum(&acg)[lcs2]++;
1710                 }
1711         }
1712         /*
1713          * Update all statistics based on blocks.
1714          */
1715         acg.cg_cs.cs_nbfree--;
1716         sblock.fs_cstotal.cs_nbfree--;
1717         cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
1718         cg_blks(&sblock, &acg, cbtocylno(&sblock, d))[cbtorpos(&sblock, d)]--;
1719
1720         DBG_LEAVE;
1721         return (d);
1722 }
1723
1724 /* *********************************************************** isblock ***** */
1725 /*
1726  * Here  we check if all frags of a block are free. For more details  again
1727  * please see the source of newfs(8), as this function is taken over almost
1728  * unchanged.
1729  */
1730 static int
1731 isblock(struct fs *fs, unsigned char *cp, int h)
1732 {
1733         unsigned char   mask;
1734
1735         DBG_ENTER;
1736
1737         switch (fs->fs_frag) {
1738         case 8:
1739                 DBG_LEAVE;
1740                 return (cp[h] == 0xff);
1741         case 4:
1742                 mask = 0x0f << ((h & 0x1) << 2);
1743                 DBG_LEAVE;
1744                 return ((cp[h >> 1] & mask) == mask);
1745         case 2:
1746                 mask = 0x03 << ((h & 0x3) << 1);
1747                 DBG_LEAVE;
1748                 return ((cp[h >> 2] & mask) == mask);
1749         case 1:
1750                 mask = 0x01 << (h & 0x7);
1751                 DBG_LEAVE;
1752                 return ((cp[h >> 3] & mask) == mask);
1753         default:
1754                 fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
1755                 DBG_LEAVE;
1756                 return (0);
1757         }
1758 }
1759
1760 /* ********************************************************** clrblock ***** */
1761 /*
1762  * Here we allocate a complete block in the block map. For more details again
1763  * please  see the source of newfs(8), as this function is taken over  almost
1764  * unchanged.
1765  */
1766 static void
1767 clrblock(struct fs *fs, unsigned char *cp, int h)
1768 {
1769         DBG_ENTER;
1770
1771         switch ((fs)->fs_frag) {
1772         case 8:
1773                 cp[h] = 0;
1774                 break;
1775         case 4:
1776                 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
1777                 break;
1778         case 2:
1779                 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
1780                 break;
1781         case 1:
1782                 cp[h >> 3] &= ~(0x01 << (h & 0x7));
1783                 break;
1784         default:
1785                 warnx("clrblock bad fs_frag %d", fs->fs_frag);
1786                 break;
1787         }
1788
1789         DBG_LEAVE;
1790         return;
1791 }
1792
1793 /* ********************************************************** setblock ***** */
1794 /*
1795  * Here we free a complete block in the free block map. For more details again
1796  * please  see the source of newfs(8), as this function is taken  over  almost
1797  * unchanged.
1798  */
1799 static void
1800 setblock(struct fs *fs, unsigned char *cp, int h)
1801 {
1802         DBG_ENTER;
1803
1804         switch (fs->fs_frag) {
1805         case 8:
1806                 cp[h] = 0xff;
1807                 break;
1808         case 4:
1809                 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
1810                 break;
1811         case 2:
1812                 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
1813                 break;
1814         case 1:
1815                 cp[h >> 3] |= (0x01 << (h & 0x7));
1816                 break;
1817         default:
1818                 warnx("setblock bad fs_frag %d", fs->fs_frag);
1819                 break;
1820         }
1821
1822         DBG_LEAVE;
1823         return;
1824 }
1825
1826 /* ************************************************************ ginode ***** */
1827 /*
1828  * This function provides access to an individual inode. We find out in which
1829  * block  the  requested inode is located, read it from disk if  needed,  and
1830  * return  the pointer into that block. We maintain a cache of one  block  to
1831  * not  read the same block again and again if we iterate linearly  over  all
1832  * inodes.
1833  */
1834 static struct ufs1_dinode *
1835 ginode(ino_t inumber, int fsi, int cg)
1836 {
1837         ufs_daddr_t     iblk;
1838         static ino_t    startinum=0;    /* first inode in cached block */
1839         struct ufs1_dinode      *pi;
1840
1841         DBG_ENTER;
1842
1843         pi=(struct ufs1_dinode *)(void *)ablk;
1844         inumber+=(cg * sblock.fs_ipg);
1845         if (startinum == 0 || inumber < startinum ||
1846             inumber >= startinum + INOPB(&sblock)) {
1847                 /*
1848                  * The block needed is not cached, so we have to read it from
1849                  * disk now.
1850                  */
1851                 iblk = ino_to_fsba(&sblock, inumber);
1852                 in_src=fsbtodb(&sblock, iblk);
1853                 rdfs(in_src, (size_t)sblock.fs_bsize, &ablk, fsi);
1854                 startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
1855         }
1856
1857         DBG_LEAVE;
1858         return (&(pi[inumber % INOPB(&sblock)]));
1859 }
1860
1861 /* ****************************************************** charsperline ***** */
1862 /*
1863  * Figure out how many lines our current terminal has. For more details again
1864  * please  see the source of newfs(8), as this function is taken over  almost
1865  * unchanged.
1866  */
1867 static int
1868 charsperline(void)
1869 {
1870         int     columns;
1871         char    *cp;
1872         struct winsize  ws;
1873
1874         DBG_ENTER;
1875
1876         columns = 0;
1877         if (ioctl(0, TIOCGWINSZ, &ws) != -1) {
1878                 columns = ws.ws_col;
1879         }
1880         if (columns == 0 && (cp = getenv("COLUMNS"))) {
1881                 columns = atoi(cp);
1882         }
1883         if (columns == 0) {
1884                 columns = 80;   /* last resort */
1885         }
1886
1887         DBG_LEAVE;
1888         return columns;
1889 }
1890
1891 /* ************************************************************** main ***** */
1892 /*
1893  * growfs(8)  is a utility which allows to increase the size of  an  existing
1894  * ufs filesystem. Currently this can only be done on unmounted file  system.
1895  * It  recognizes some command line options to specify the new desired  size,
1896  * and  it does some basic checkings. The old file system size is  determined
1897  * and  after some more checks like we can really access the new  last  block
1898  * on the disk etc. we calculate the new parameters for the superblock. After
1899  * having  done  this we just call growfs() which will do  the  work.  Before
1900  * we finish the only thing left is to update the disklabel.
1901  * We still have to provide support for snapshots. Therefore we first have to
1902  * understand  what data structures are always replicated in the snapshot  on
1903  * creation,  for all other blocks we touch during our procedure, we have  to
1904  * keep the old blocks unchanged somewhere available for the snapshots. If we
1905  * are lucky, then we only have to handle our blocks to be relocated in  that
1906  * way.
1907  * Also  we  have to consider in what order we actually update  the  critical
1908  * data structures of the filesystem to make sure, that in case of a disaster
1909  * fsck(8) is still able to restore any lost data.
1910  * The  foreseen last step then will be to provide for growing  even  mounted
1911  * file  systems. There we have to extend the mount() system call to  provide
1912  * userland access to the file system locking facility.
1913  */
1914 int
1915 main(int argc, char **argv)
1916 {
1917         struct partinfo pinfo;
1918         char    *device, *special, __unused *cp;
1919         char    ch;
1920         unsigned int    size=0;
1921         size_t  len;
1922         unsigned int    Nflag=0;
1923         int     ExpertFlag=0;
1924         struct stat     st;
1925         int     fsi,fso;
1926         char    reply[5];
1927 #ifdef FSMAXSNAP
1928         int     j;
1929 #endif /* FSMAXSNAP */
1930
1931         DBG_ENTER;
1932
1933         while((ch=getopt(argc, argv, "Ns:vy")) != -1) {
1934                 switch(ch) {
1935                 case 'N':
1936                         Nflag=1;
1937                         break;
1938                 case 's':
1939                         size=(size_t)atol(optarg);
1940                         if(size<1) {
1941                                 usage();
1942                         }
1943                         break;
1944                 case 'v': /* for compatibility to newfs */
1945                         break;
1946                 case 'y':
1947                         ExpertFlag=1;
1948                         break;
1949                 case '?':
1950                         /* FALLTHROUGH */
1951                 default:
1952                         usage();
1953                 }
1954         }
1955         argc -= optind;
1956         argv += optind;
1957
1958         if(argc != 1) {
1959                 usage();
1960         }
1961         device=*argv;
1962
1963         /*
1964          * Now try to guess the (raw)device name.
1965          */
1966         if (0 == strrchr(device, '/')) {
1967                 /*
1968                  * No path prefix was given, so try in that order:
1969                  *     /dev/r%s
1970                  *     /dev/%s
1971                  *     /dev/vinum/r%s
1972                  *     /dev/vinum/%s.
1973                  *
1974                  * FreeBSD now doesn't distinguish between raw and  block
1975                  * devices any longer, but it should still work this way.
1976                  */
1977                 len=strlen(device)+strlen(_PATH_DEV)+2+strlen("vinum/");
1978                 special=(char *)malloc(len);
1979                 if(special == NULL) {
1980                         errx(1, "malloc failed");
1981                 }
1982                 snprintf(special, len, "%sr%s", _PATH_DEV, device);
1983                 if (stat(special, &st) == -1) {
1984                         snprintf(special, len, "%s%s", _PATH_DEV, device);
1985                         if (stat(special, &st) == -1) {
1986                                 snprintf(special, len, "%svinum/r%s",
1987                                     _PATH_DEV, device);
1988                                 if (stat(special, &st) == -1) {
1989                                         /* For now this is the 'last resort' */
1990                                         snprintf(special, len, "%svinum/%s",
1991                                             _PATH_DEV, device);
1992                                 }
1993                         }
1994                 }
1995                 device = special;
1996         }
1997
1998         /*
1999          * Try to access our devices for writing ...
2000          */
2001         if (Nflag) {
2002                 fso = -1;
2003         } else {
2004                 fso = open(device, O_WRONLY);
2005                 if (fso < 0) {
2006                         err(1, "%s", device);
2007                 }
2008         }
2009
2010         /*
2011          * ... and reading.
2012          */
2013         fsi = open(device, O_RDONLY);
2014         if (fsi < 0) {
2015                 err(1, "%s", device);
2016         }
2017
2018         /*
2019          * Try  to read a label and gess the slice if not  specified.  This
2020          * code  should guess the right thing and avaid to bother the  user
2021          * user with the task of specifying the option -v on vinum volumes.
2022          */
2023         cp=device+strlen(device)-1;
2024
2025         if (ioctl(fsi, DIOCGPART, &pinfo) < 0) {
2026                 if (fstat(fsi, &st) < 0)
2027                         err(1, "unable to figure out the partition size");
2028                 pinfo.media_blocks  = st.st_size / DEV_BSIZE;
2029                 pinfo.media_blksize = DEV_BSIZE;
2030         }
2031
2032         /*
2033          * Check if that partition looks suited for growing a file system.
2034          */
2035         if (pinfo.media_blocks < 1) {
2036                 errx(1, "partition is unavailable");
2037         }
2038
2039         /*
2040          * Read the current superblock, and take a backup.
2041          */
2042         rdfs((daddr_t)(SBOFF/DEV_BSIZE), (size_t)SBSIZE, &osblock, fsi);
2043         if (osblock.fs_magic != FS_MAGIC) {
2044                 errx(1, "superblock not recognized");
2045         }
2046         memcpy((void *)&fsun1, (void *)&fsun2, sizeof(fsun2));
2047
2048         DBG_OPEN("/tmp/growfs.debug"); /* already here we need a superblock */
2049         DBG_DUMP_FS(&sblock,
2050             "old sblock");
2051
2052         /*
2053          * Determine size to grow to. Default to the full size specified in
2054          * the disk label.
2055          */
2056         sblock.fs_size = dbtofsb(&osblock, pinfo.media_blocks);
2057         if (size != 0) {
2058                 if (size > pinfo.media_blocks){
2059                         errx(1, "There is not enough space (%ju < %d)",
2060                              (intmax_t)pinfo.media_blocks, size);
2061                 }
2062                 sblock.fs_size = dbtofsb(&osblock, size);
2063         }
2064
2065         /*
2066          * Are we really growing ?
2067          */
2068         if(osblock.fs_size >= sblock.fs_size) {
2069                 errx(1, "we are not growing (%d->%d)", osblock.fs_size,
2070                     sblock.fs_size);
2071         }
2072
2073
2074 #ifdef FSMAXSNAP
2075         /*
2076          * Check if we find an active snapshot.
2077          */
2078         if(ExpertFlag == 0) {
2079                 for(j=0; j<FSMAXSNAP; j++) {
2080                         if(sblock.fs_snapinum[j]) {
2081                                 errx(1, "active snapshot found in filesystem\n"
2082                                     "   please remove all snapshots before "
2083                                     "using growfs\n");
2084                         }
2085                         if(!sblock.fs_snapinum[j]) { /* list is dense */
2086                                 break;
2087                         }
2088                 }
2089         }
2090 #endif
2091
2092         if (ExpertFlag == 0 && Nflag == 0) {
2093                 printf("We strongly recommend you to make a backup "
2094                     "before growing the Filesystem\n\n"
2095                     " Did you backup your data (Yes/No) ? ");
2096                 fgets(reply, (int)sizeof(reply), stdin);
2097                 if (strcmp(reply, "Yes\n")){
2098                         printf("\n Nothing done \n");
2099                         exit (0);
2100                 }
2101         }
2102
2103         printf("new filesystemsize is: %d frags\n", sblock.fs_size);
2104
2105         /*
2106          * Try to access our new last block in the filesystem. Even if we
2107          * later on realize we have to abort our operation, on that block
2108          * there should be no data, so we can't destroy something yet.
2109          */
2110         wtfs((daddr_t)pinfo.media_blocks-1, (size_t)DEV_BSIZE, &sblock, fso,
2111             Nflag);
2112
2113         /*
2114          * Now calculate new superblock values and check for reasonable
2115          * bound for new file system size:
2116          *     fs_size:    is derived from label or user input
2117          *     fs_dsize:   should get updated in the routines creating or
2118          *                 updating the cylinder groups on the fly
2119          *     fs_cstotal: should get updated in the routines creating or
2120          *                 updating the cylinder groups
2121          */
2122
2123         /*
2124          * Update the number of cylinders in the filesystem.
2125          */
2126         sblock.fs_ncyl = sblock.fs_size * NSPF(&sblock) / sblock.fs_spc;
2127         if (sblock.fs_size * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
2128                 sblock.fs_ncyl++;
2129         }
2130
2131         /*
2132          * Update the number of cylinder groups in the filesystem.
2133          */
2134         sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
2135         if (sblock.fs_ncyl % sblock.fs_cpg) {
2136                 sblock.fs_ncg++;
2137         }
2138
2139         if ((sblock.fs_size - (sblock.fs_ncg-1) * sblock.fs_fpg) <
2140             sblock.fs_fpg && cgdmin(&sblock, (sblock.fs_ncg-1))-
2141             cgbase(&sblock, (sblock.fs_ncg-1)) > (sblock.fs_size -
2142             (sblock.fs_ncg-1) * sblock.fs_fpg )) {
2143                 /*
2144                  * The space in the new last cylinder group is too small,
2145                  * so revert back.
2146                  */
2147                 sblock.fs_ncg--;
2148 #if 1 /* this is a bit more safe */
2149                 sblock.fs_ncyl = sblock.fs_ncg * sblock.fs_cpg;
2150 #else
2151                 sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
2152 #endif
2153                 sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
2154                 printf( "Warning: %d sector(s) cannot be allocated.\n",
2155                     (sblock.fs_size-(sblock.fs_ncg)*sblock.fs_fpg) *
2156                     NSPF(&sblock));
2157                 sblock.fs_size = sblock.fs_ncyl * sblock.fs_spc / NSPF(&sblock);
2158         }
2159
2160         /*
2161          * Update the space for the cylinder group summary information in the
2162          * respective cylinder group data area.
2163          */
2164         sblock.fs_cssize =
2165             fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
2166
2167         if(osblock.fs_size >= sblock.fs_size) {
2168                 errx(1, "not enough new space");
2169         }
2170
2171         DBG_PRINT0("sblock calculated\n");
2172
2173         /*
2174          * Ok, everything prepared, so now let's do the tricks.
2175          */
2176         growfs(fsi, fso, Nflag);
2177
2178         close(fsi);
2179         if(fso>-1) close(fso);
2180
2181         DBG_CLOSE;
2182
2183         DBG_LEAVE;
2184         return 0;
2185 }
2186
2187 /* ************************************************************* usage ***** */
2188 /*
2189  * Dump a line of usage.
2190  */
2191 static void
2192 usage(void)
2193 {
2194         DBG_ENTER;
2195
2196         fprintf(stderr, "usage: growfs [-Ny] [-s size] special\n");
2197
2198         DBG_LEAVE;
2199         exit(1);
2200 }
2201
2202 /* *********************************************************** updclst ***** */
2203 /*
2204  * This updates most paramters and the bitmap related to cluster. We have to
2205  * assume, that sblock, osblock, acg are set up.
2206  */
2207 static void
2208 updclst(int block)
2209 {
2210         static int      lcs=0;
2211
2212         DBG_ENTER;
2213
2214         if(sblock.fs_contigsumsize < 1) { /* no clustering */
2215                 return;
2216         }
2217         /*
2218          * update cluster allocation map
2219          */
2220         setbit(cg_clustersfree(&acg), block);
2221
2222         /*
2223          * update cluster summary table
2224          */
2225         if(!lcs) {
2226                 /*
2227                  * calculate size for the trailing cluster
2228                  */
2229                 for(block--; lcs<sblock.fs_contigsumsize; block--, lcs++ ) {
2230                         if(isclr(cg_clustersfree(&acg), block)){
2231                                 break;
2232                         }
2233                 }
2234         }
2235         if(lcs < sblock.fs_contigsumsize) {
2236                 if(lcs) {
2237                         cg_clustersum(&acg)[lcs]--;
2238                 }
2239                 lcs++;
2240                 cg_clustersum(&acg)[lcs]++;
2241         }
2242
2243         DBG_LEAVE;
2244         return;
2245 }
2246
2247 /* *********************************************************** updrefs ***** */
2248 /*
2249  * This updates all references to relocated blocks for the given inode.  The
2250  * inode is given as number within the cylinder group, and the number of the
2251  * cylinder group.
2252  */
2253 static void
2254 updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, unsigned int
2255     Nflag)
2256 {
2257         unsigned int    ictr, ind2ctr, ind3ctr;
2258         ufs_daddr_t     *iptr, *ind2ptr, *ind3ptr;
2259         struct ufs1_dinode      *ino;
2260         int     remaining_blocks;
2261
2262         DBG_ENTER;
2263
2264         /*
2265          * XXX We should skip unused inodes even from beeing read from disk
2266          *     here by using the bitmap.
2267          */
2268         ino=ginode(in, fsi, cg);
2269         if(!((ino->di_mode & IFMT)==IFDIR || (ino->di_mode & IFMT)==IFREG ||
2270             (ino->di_mode & IFMT)==IFLNK)) {
2271                 DBG_LEAVE;
2272                 return; /* only check DIR, FILE, LINK */
2273         }
2274         if(((ino->di_mode & IFMT)==IFLNK) && (ino->di_size<MAXSYMLINKLEN)) {
2275                 DBG_LEAVE;
2276                 return; /* skip short symlinks */
2277         }
2278         if(!ino->di_size) {
2279                 DBG_LEAVE;
2280                 return; /* skip empty file */
2281         }
2282         if(!ino->di_blocks) {
2283                 DBG_LEAVE;
2284                 return; /* skip empty swiss cheesy file or old fastlink */
2285         }
2286         DBG_PRINT2("scg checking inode (%ju in %d)\n",
2287             (uintmax_t)in,
2288             cg);
2289
2290         /*
2291          * Start checking all direct blocks.
2292          */
2293         remaining_blocks=howmany(ino->di_size, sblock.fs_bsize);
2294         for(ictr=0; ictr < MIN(NDADDR, (unsigned int)remaining_blocks);
2295             ictr++) {
2296                 iptr=&(ino->di_db[ictr]);
2297                 if(*iptr) {
2298                         cond_bl_upd(iptr, bp, GFS_PS_INODE, fso, Nflag);
2299                 }
2300         }
2301         DBG_PRINT0("~~scg direct blocks checked\n");
2302
2303         remaining_blocks-=NDADDR;
2304         if(remaining_blocks<0) {
2305                 DBG_LEAVE;
2306                 return;
2307         }
2308         if(ino->di_ib[0]) {
2309                 /*
2310                  * Start checking first indirect block
2311                  */
2312                 cond_bl_upd(&(ino->di_ib[0]), bp, GFS_PS_INODE, fso, Nflag);
2313                 i1_src=fsbtodb(&sblock, ino->di_ib[0]);
2314                 rdfs(i1_src, (size_t)sblock.fs_bsize, &i1blk, fsi);
2315                 for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
2316                     sizeof(ufs_daddr_t)), (unsigned int)remaining_blocks);
2317                     ictr++) {
2318                         iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
2319                         if(*iptr) {
2320                                 cond_bl_upd(iptr, bp, GFS_PS_IND_BLK_LVL1,
2321                                     fso, Nflag);
2322                         }
2323                 }
2324         }
2325         DBG_PRINT0("scg indirect_1 blocks checked\n");
2326
2327         remaining_blocks-= howmany(sblock.fs_bsize, sizeof(ufs_daddr_t));
2328         if(remaining_blocks<0) {
2329                 DBG_LEAVE;
2330                 return;
2331         }
2332         if(ino->di_ib[1]) {
2333                 /*
2334                  * Start checking second indirect block
2335                  */
2336                 cond_bl_upd(&(ino->di_ib[1]), bp, GFS_PS_INODE, fso, Nflag);
2337                 i2_src=fsbtodb(&sblock, ino->di_ib[1]);
2338                 rdfs(i2_src, (size_t)sblock.fs_bsize, &i2blk, fsi);
2339                 for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
2340                     sizeof(ufs_daddr_t)); ind2ctr++) {
2341                         ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)[ind2ctr];
2342                         if(!*ind2ptr) {
2343                                 continue;
2344                         }
2345                         cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2, fso,
2346                             Nflag);
2347                         i1_src=fsbtodb(&sblock, *ind2ptr);
2348                         rdfs(i1_src, (size_t)sblock.fs_bsize, &i1blk,
2349                             fsi);
2350                         for(ictr=0; ictr<MIN(howmany((unsigned int)
2351                             sblock.fs_bsize, sizeof(ufs_daddr_t)),
2352                             (unsigned int)remaining_blocks); ictr++) {
2353                                 iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
2354                                 if(*iptr) {
2355                                         cond_bl_upd(iptr, bp,
2356                                             GFS_PS_IND_BLK_LVL1, fso, Nflag);
2357                                 }
2358                         }
2359                 }
2360         }
2361         DBG_PRINT0("scg indirect_2 blocks checked\n");
2362
2363 #define SQUARE(a) ((a)*(a))
2364         remaining_blocks-=SQUARE(howmany(sblock.fs_bsize, sizeof(ufs_daddr_t)));
2365 #undef SQUARE
2366         if(remaining_blocks<0) {
2367                 DBG_LEAVE;
2368                 return;
2369         }
2370
2371         if(ino->di_ib[2]) {
2372                 /*
2373                  * Start checking third indirect block
2374                  */
2375                 cond_bl_upd(&(ino->di_ib[2]), bp, GFS_PS_INODE, fso, Nflag);
2376                 i3_src=fsbtodb(&sblock, ino->di_ib[2]);
2377                 rdfs(i3_src, (size_t)sblock.fs_bsize, &i3blk, fsi);
2378                 for(ind3ctr=0; ind3ctr < howmany(sblock.fs_bsize,
2379                     sizeof(ufs_daddr_t)); ind3ctr ++) {
2380                         ind3ptr=&((ufs_daddr_t *)(void *)&i3blk)[ind3ctr];
2381                         if(!*ind3ptr) {
2382                                 continue;
2383                         }
2384                         cond_bl_upd(ind3ptr, bp, GFS_PS_IND_BLK_LVL3, fso,
2385                             Nflag);
2386                         i2_src=fsbtodb(&sblock, *ind3ptr);
2387                         rdfs(i2_src, (size_t)sblock.fs_bsize, &i2blk,
2388                             fsi);
2389                         for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
2390                             sizeof(ufs_daddr_t)); ind2ctr ++) {
2391                                 ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
2392                                     [ind2ctr];
2393                                 if(!*ind2ptr) {
2394                                         continue;
2395                                 }
2396                                 cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2,
2397                                     fso, Nflag);
2398                                 i1_src=fsbtodb(&sblock, *ind2ptr);
2399                                 rdfs(i1_src, (size_t)sblock.fs_bsize,
2400                                     &i1blk, fsi);
2401                                 for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
2402                                     sizeof(ufs_daddr_t)),
2403                                     (unsigned int)remaining_blocks); ictr++) {
2404                                         iptr=&((ufs_daddr_t *)(void *)&i1blk)
2405                                             [ictr];
2406                                         if(*iptr) {
2407                                                 cond_bl_upd(iptr, bp,
2408                                                     GFS_PS_IND_BLK_LVL1, fso,
2409                                                     Nflag);
2410                                         }
2411                                 }
2412                         }
2413                 }
2414         }
2415
2416         DBG_PRINT0("scg indirect_3 blocks checked\n");
2417
2418         DBG_LEAVE;
2419         return;
2420 }
2421