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