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