1 /* $NetBSD: lfs_cleanerd.c,v 1.60 2019/08/30 23:37:23 brad Exp $ */ 2 3 /*- 4 * Copyright (c) 2005 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Konrad E. Schroder <perseant (at) hhhh.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * The cleaner daemon for the NetBSD Log-structured File System. 34 * Only tested for use with version 2 LFSs. 35 */ 36 37 #include <sys/syslog.h> 38 #include <sys/param.h> 39 #include <sys/mount.h> 40 #include <sys/stat.h> 41 #include <ufs/lfs/lfs.h> 42 43 #include <assert.h> 44 #include <err.h> 45 #include <errno.h> 46 #include <fcntl.h> 47 #include <semaphore.h> 48 #include <stdbool.h> 49 #include <stdio.h> 50 #include <stdlib.h> 51 #include <string.h> 52 #include <unistd.h> 53 #include <time.h> 54 #include <util.h> 55 56 #include "bufcache.h" 57 #include "vnode.h" 58 #include "lfs_user.h" 59 #include "fdfs.h" 60 #include "cleaner.h" 61 #include "kernelops.h" 62 #include "mount_lfs.h" 63 64 /* 65 * Global variables. 66 */ 67 /* XXX these top few should really be fs-specific */ 68 int use_fs_idle; /* Use fs idle rather than cpu idle time */ 69 int use_bytes; /* Use bytes written rather than segments cleaned */ 70 double load_threshold; /* How idle is idle (CPU idle) */ 71 int atatime; /* How many segments (bytes) to clean at a time */ 72 73 int nfss; /* Number of filesystems monitored by this cleanerd */ 74 struct clfs **fsp; /* Array of extended filesystem structures */ 75 int segwait_timeout; /* Time to wait in lfs_segwait() */ 76 int do_quit; /* Quit after one cleaning loop */ 77 int do_coalesce; /* Coalesce filesystem */ 78 int do_small; /* Use small writes through markv */ 79 char *do_asdevice; /* Use this as the raw device */ 80 char *copylog_filename; /* File to use for fs debugging analysis */ 81 int inval_segment; /* Segment to invalidate */ 82 int stat_report; /* Report statistics for this period of cycles */ 83 int debug; /* Turn on debugging */ 84 struct cleaner_stats { 85 double util_tot; 86 double util_sos; 87 off_t bytes_read; 88 off_t bytes_written; 89 off_t segs_cleaned; 90 off_t segs_empty; 91 off_t segs_error; 92 } cleaner_stats; 93 94 extern u_int32_t cksum(void *, size_t); 95 extern u_int32_t lfs_sb_cksum(struct dlfs *); 96 extern u_int32_t lfs_cksum_part(void *, size_t, u_int32_t); 97 extern int ulfs_getlbns(struct lfs *, struct uvnode *, daddr_t, struct indir *, int *); 98 99 /* Ugh */ 100 #define FSMNT_SIZE MAX(sizeof(((struct dlfs *)0)->dlfs_fsmnt), \ 101 sizeof(((struct dlfs64 *)0)->dlfs_fsmnt)) 102 103 104 /* Compat */ 105 void pwarn(const char *unused, ...) { /* Does nothing */ }; 106 107 /* 108 * Log a message if debugging is turned on. 109 */ 110 void 111 dlog(const char *fmt, ...) 112 { 113 va_list ap; 114 115 if (debug == 0) 116 return; 117 118 va_start(ap, fmt); 119 vsyslog(LOG_DEBUG, fmt, ap); 120 va_end(ap); 121 } 122 123 /* 124 * Remove the specified filesystem from the list, due to its having 125 * become unmounted or other error condition. 126 */ 127 void 128 handle_error(struct clfs **cfsp, int n) 129 { 130 syslog(LOG_NOTICE, "%s: detaching cleaner", lfs_sb_getfsmnt(cfsp[n])); 131 free(cfsp[n]); 132 if (n != nfss - 1) 133 cfsp[n] = cfsp[nfss - 1]; 134 --nfss; 135 } 136 137 /* 138 * Reinitialize a filesystem if, e.g., its size changed. 139 */ 140 int 141 reinit_fs(struct clfs *fs) 142 { 143 char fsname[FSMNT_SIZE]; 144 145 memcpy(fsname, lfs_sb_getfsmnt(fs), sizeof(fsname)); 146 fsname[sizeof(fsname) - 1] = '\0'; 147 148 kops.ko_close(fs->clfs_ifilefd); 149 kops.ko_close(fs->clfs_devfd); 150 fd_reclaim(fs->clfs_devvp); 151 fd_reclaim(fs->lfs_ivnode); 152 free(fs->clfs_dev); 153 free(fs->clfs_segtab); 154 free(fs->clfs_segtabp); 155 156 return init_fs(fs, fsname); 157 } 158 159 #ifdef REPAIR_ZERO_FINFO 160 /* 161 * Use fsck's lfs routines to load the Ifile from an unmounted fs. 162 * We interpret "fsname" as the name of the raw disk device. 163 */ 164 int 165 init_unmounted_fs(struct clfs *fs, char *fsname) 166 { 167 struct lfs *disc_fs; 168 int i; 169 170 fs->clfs_dev = fsname; 171 if ((fs->clfs_devfd = kops.ko_open(fs->clfs_dev, O_RDWR)) < 0) { 172 syslog(LOG_ERR, "couldn't open device %s read/write", 173 fs->clfs_dev); 174 return -1; 175 } 176 177 disc_fs = lfs_init(fs->clfs_devfd, 0, 0, 0, 0); 178 179 fs->lfs_dlfs = disc_fs->lfs_dlfs; /* Structure copy */ 180 strncpy(fs->lfs_fsmnt, fsname, MNAMELEN); 181 fs->lfs_ivnode = (struct uvnode *)disc_fs->lfs_ivnode; 182 fs->clfs_devvp = fd_vget(fs->clfs_devfd, fs->lfs_fsize, fs->lfs_ssize, 183 atatime); 184 185 /* Allocate and clear segtab */ 186 fs->clfs_segtab = (struct clfs_seguse *)malloc(lfs_sb_getnseg(fs) * 187 sizeof(*fs->clfs_segtab)); 188 fs->clfs_segtabp = (struct clfs_seguse **)malloc(lfs_sb_getnseg(fs) * 189 sizeof(*fs->clfs_segtabp)); 190 for (i = 0; i < lfs_sb_getnseg(fs); i++) { 191 fs->clfs_segtabp[i] = &(fs->clfs_segtab[i]); 192 fs->clfs_segtab[i].flags = 0x0; 193 } 194 syslog(LOG_NOTICE, "%s: unmounted cleaner starting", fsname); 195 196 return 0; 197 } 198 #endif 199 200 /* 201 * Set up the file descriptors, including the Ifile descriptor. 202 * If we can't get the Ifile, this is not an LFS (or the kernel is 203 * too old to support the fcntl). 204 * XXX Merge this and init_unmounted_fs, switching on whether 205 * XXX "fsname" is a dir or a char special device. Should 206 * XXX also be able to read unmounted devices out of fstab, the way 207 * XXX fsck does. 208 */ 209 int 210 init_fs(struct clfs *fs, char *fsname) 211 { 212 char mnttmp[FSMNT_SIZE]; 213 struct statvfs sf; 214 int rootfd; 215 int i; 216 void *sbuf; 217 size_t mlen; 218 219 if (do_asdevice != NULL) { 220 fs->clfs_dev = strndup(do_asdevice,strlen(do_asdevice) + 2); 221 if (fs->clfs_dev == NULL) { 222 syslog(LOG_ERR, "couldn't malloc device name string: %m"); 223 return -1; 224 } 225 } else { 226 /* 227 * Get the raw device from the block device. 228 * XXX this is ugly. Is there a way to discover the raw device 229 * XXX for a given mount point? 230 */ 231 if (kops.ko_statvfs(fsname, &sf, ST_WAIT) < 0) 232 return -1; 233 mlen = strlen(sf.f_mntfromname) + 2; 234 fs->clfs_dev = malloc(mlen); 235 if (fs->clfs_dev == NULL) { 236 syslog(LOG_ERR, "couldn't malloc device name string: %m"); 237 return -1; 238 } 239 if (getdiskrawname(fs->clfs_dev, mlen, sf.f_mntfromname) == NULL) { 240 syslog(LOG_ERR, "couldn't convert '%s' to raw name: %m", 241 sf.f_mntfromname); 242 return -1; 243 } 244 } 245 if ((fs->clfs_devfd = kops.ko_open(fs->clfs_dev, O_RDONLY, 0)) < 0) { 246 syslog(LOG_ERR, "couldn't open device %s for reading: %m", 247 fs->clfs_dev); 248 return -1; 249 } 250 251 /* Find the Ifile and open it */ 252 if ((rootfd = kops.ko_open(fsname, O_RDONLY, 0)) < 0) 253 return -2; 254 if (kops.ko_fcntl(rootfd, LFCNIFILEFH, &fs->clfs_ifilefh) < 0) 255 return -3; 256 if ((fs->clfs_ifilefd = kops.ko_fhopen(&fs->clfs_ifilefh, 257 sizeof(fs->clfs_ifilefh), O_RDONLY)) < 0) 258 return -4; 259 kops.ko_close(rootfd); 260 261 sbuf = malloc(LFS_SBPAD); 262 if (sbuf == NULL) { 263 syslog(LOG_ERR, "couldn't malloc superblock buffer"); 264 return -1; 265 } 266 267 /* Load in the superblock */ 268 if (kops.ko_pread(fs->clfs_devfd, sbuf, LFS_SBPAD, LFS_LABELPAD) < 0) { 269 free(sbuf); 270 return -1; 271 } 272 273 __CTASSERT(sizeof(struct dlfs) == sizeof(struct dlfs64)); 274 memcpy(&fs->lfs_dlfs_u, sbuf, sizeof(struct dlfs)); 275 free(sbuf); 276 277 /* If it is not LFS, complain and exit! */ 278 switch (fs->lfs_dlfs_u.u_32.dlfs_magic) { 279 case LFS_MAGIC: 280 fs->lfs_is64 = false; 281 fs->lfs_dobyteswap = false; 282 break; 283 case LFS_MAGIC_SWAPPED: 284 fs->lfs_is64 = false; 285 fs->lfs_dobyteswap = true; 286 break; 287 case LFS64_MAGIC: 288 fs->lfs_is64 = true; 289 fs->lfs_dobyteswap = false; 290 break; 291 case LFS64_MAGIC_SWAPPED: 292 fs->lfs_is64 = true; 293 fs->lfs_dobyteswap = true; 294 break; 295 default: 296 syslog(LOG_ERR, "%s: not LFS", fsname); 297 return -1; 298 } 299 /* XXX: can this ever need to be set? does the cleaner even care? */ 300 fs->lfs_hasolddirfmt = 0; 301 302 /* If this is not a version 2 filesystem, complain and exit */ 303 if (lfs_sb_getversion(fs) != 2) { 304 syslog(LOG_ERR, "%s: not a version 2 LFS", fsname); 305 return -1; 306 } 307 308 /* Assume fsname is the mounted name */ 309 strncpy(mnttmp, fsname, sizeof(mnttmp)); 310 mnttmp[sizeof(mnttmp) - 1] = '\0'; 311 lfs_sb_setfsmnt(fs, mnttmp); 312 313 /* Set up vnodes for Ifile and raw device */ 314 fs->lfs_ivnode = fd_vget(fs->clfs_ifilefd, lfs_sb_getbsize(fs), 0, 0); 315 fs->clfs_devvp = fd_vget(fs->clfs_devfd, lfs_sb_getfsize(fs), lfs_sb_getssize(fs), 316 atatime); 317 318 /* Allocate and clear segtab */ 319 fs->clfs_segtab = (struct clfs_seguse *)malloc(lfs_sb_getnseg(fs) * 320 sizeof(*fs->clfs_segtab)); 321 fs->clfs_segtabp = (struct clfs_seguse **)malloc(lfs_sb_getnseg(fs) * 322 sizeof(*fs->clfs_segtabp)); 323 if (fs->clfs_segtab == NULL || fs->clfs_segtabp == NULL) { 324 syslog(LOG_ERR, "%s: couldn't malloc segment table: %m", 325 fs->clfs_dev); 326 return -1; 327 } 328 329 for (i = 0; i < lfs_sb_getnseg(fs); i++) { 330 fs->clfs_segtabp[i] = &(fs->clfs_segtab[i]); 331 fs->clfs_segtab[i].flags = 0x0; 332 } 333 334 syslog(LOG_NOTICE, "%s: attaching cleaner", fsname); 335 return 0; 336 } 337 338 /* 339 * Invalidate all the currently held Ifile blocks so they will be 340 * reread when we clean. Check the size while we're at it, and 341 * resize the buffer cache if necessary. 342 */ 343 void 344 reload_ifile(struct clfs *fs) 345 { 346 struct ubuf *bp; 347 struct stat st; 348 int ohashmax; 349 extern int hashmax; 350 351 while ((bp = LIST_FIRST(&fs->lfs_ivnode->v_dirtyblkhd)) != NULL) { 352 bremfree(bp); 353 buf_destroy(bp); 354 } 355 while ((bp = LIST_FIRST(&fs->lfs_ivnode->v_cleanblkhd)) != NULL) { 356 bremfree(bp); 357 buf_destroy(bp); 358 } 359 360 /* If Ifile is larger than buffer cache, rehash */ 361 fstat(fs->clfs_ifilefd, &st); 362 if (st.st_size / lfs_sb_getbsize(fs) > hashmax) { 363 ohashmax = hashmax; 364 bufrehash(st.st_size / lfs_sb_getbsize(fs)); 365 dlog("%s: resized buffer hash from %d to %d", 366 lfs_sb_getfsmnt(fs), ohashmax, hashmax); 367 } 368 } 369 370 /* 371 * Get IFILE entry for the given inode, store in ifpp. The buffer 372 * which contains that data is returned in bpp, and must be brelse()d 373 * by the caller. 374 * 375 * XXX this is cutpaste of LFS_IENTRY from lfs.h; unify the two. 376 */ 377 void 378 lfs_ientry(IFILE **ifpp, struct clfs *fs, ino_t ino, struct ubuf **bpp) 379 { 380 IFILE64 *ifp64; 381 IFILE32 *ifp32; 382 IFILE_V1 *ifp_v1; 383 int error; 384 385 error = bread(fs->lfs_ivnode, 386 ino / lfs_sb_getifpb(fs) + lfs_sb_getcleansz(fs) + 387 lfs_sb_getsegtabsz(fs), lfs_sb_getbsize(fs), 0, bpp); 388 if (error) 389 syslog(LOG_ERR, "%s: ientry failed for ino %d", 390 lfs_sb_getfsmnt(fs), (int)ino); 391 if (fs->lfs_is64) { 392 ifp64 = (IFILE64 *)(*bpp)->b_data; 393 ifp64 += ino % lfs_sb_getifpb(fs); 394 *ifpp = (IFILE *)ifp64; 395 } else if (lfs_sb_getversion(fs) > 1) { 396 ifp32 = (IFILE32 *)(*bpp)->b_data; 397 ifp32 += ino % lfs_sb_getifpb(fs); 398 *ifpp = (IFILE *)ifp32; 399 } else { 400 ifp_v1 = (IFILE_V1 *)(*bpp)->b_data; 401 ifp_v1 += ino % lfs_sb_getifpb(fs); 402 *ifpp = (IFILE *)ifp_v1; 403 } 404 return; 405 } 406 407 #ifdef TEST_PATTERN 408 /* 409 * Check ULFS_ROOTINO for file data. The assumption is that we are running 410 * the "twofiles" test with the rest of the filesystem empty. Files 411 * created by "twofiles" match the test pattern, but ULFS_ROOTINO and the 412 * executable itself (assumed to be inode 3) should not match. 413 */ 414 static void 415 check_test_pattern(BLOCK_INFO *bip) 416 { 417 int j; 418 unsigned char *cp = bip->bi_bp; 419 420 /* Check inode sanity */ 421 if (bip->bi_lbn == LFS_UNUSED_LBN) { 422 assert(((struct ulfs1_dinode *)bip->bi_bp)->di_inumber == 423 bip->bi_inode); 424 } 425 426 /* These can have the test pattern and it's all good */ 427 if (bip->bi_inode > 3) 428 return; 429 430 for (j = 0; j < bip->bi_size; j++) { 431 if (cp[j] != (j & 0xff)) 432 break; 433 } 434 assert(j < bip->bi_size); 435 } 436 #endif /* TEST_PATTERN */ 437 438 /* 439 * Parse the partial segment at daddr, adding its information to 440 * bip. Return the address of the next partial segment to read. 441 */ 442 static daddr_t 443 parse_pseg(struct clfs *fs, daddr_t daddr, BLOCK_INFO **bipp, int *bic) 444 { 445 SEGSUM *ssp; 446 IFILE *ifp; 447 BLOCK_INFO *bip, *nbip; 448 daddr_t idaddr, odaddr; 449 FINFO *fip; 450 IINFO *iip; 451 struct ubuf *ifbp; 452 union lfs_dinode *dip; 453 u_int32_t ck, vers; 454 int fic, inoc, obic; 455 size_t sumstart; 456 int i; 457 char *cp; 458 459 odaddr = daddr; 460 obic = *bic; 461 bip = *bipp; 462 463 /* 464 * Retrieve the segment header, set up the SEGSUM pointer 465 * as well as the first FINFO and inode address pointer. 466 */ 467 cp = fd_ptrget(fs->clfs_devvp, daddr); 468 ssp = (SEGSUM *)cp; 469 iip = SEGSUM_IINFOSTART(fs, cp); 470 fip = SEGSUM_FINFOBASE(fs, cp); 471 472 /* 473 * Check segment header magic and checksum 474 */ 475 if (lfs_ss_getmagic(fs, ssp) != SS_MAGIC) { 476 syslog(LOG_WARNING, "%s: sumsum magic number bad at 0x%jx:" 477 " read 0x%x, expected 0x%x", lfs_sb_getfsmnt(fs), 478 (intmax_t)daddr, lfs_ss_getmagic(fs, ssp), SS_MAGIC); 479 return 0x0; 480 } 481 sumstart = lfs_ss_getsumstart(fs); 482 ck = cksum((char *)ssp + sumstart, lfs_sb_getsumsize(fs) - sumstart); 483 if (ck != lfs_ss_getsumsum(fs, ssp)) { 484 syslog(LOG_WARNING, "%s: sumsum checksum mismatch at 0x%jx:" 485 " read 0x%x, computed 0x%x", lfs_sb_getfsmnt(fs), 486 (intmax_t)daddr, lfs_ss_getsumsum(fs, ssp), ck); 487 return 0x0; 488 } 489 490 /* Initialize data sum */ 491 ck = 0; 492 493 /* Point daddr at next block after segment summary */ 494 ++daddr; 495 496 /* 497 * Loop over file info and inode pointers. We always move daddr 498 * forward here because we are also computing the data checksum 499 * as we go. 500 */ 501 fic = inoc = 0; 502 while (fic < lfs_ss_getnfinfo(fs, ssp) || inoc < lfs_ss_getninos(fs, ssp)) { 503 /* 504 * We must have either a file block or an inode block. 505 * If we don't have either one, it's an error. 506 */ 507 if (fic >= lfs_ss_getnfinfo(fs, ssp) && lfs_ii_getblock(fs, iip) != daddr) { 508 syslog(LOG_WARNING, "%s: bad pseg at %jx (seg %d)", 509 lfs_sb_getfsmnt(fs), (intmax_t)odaddr, lfs_dtosn(fs, odaddr)); 510 *bipp = bip; 511 return 0x0; 512 } 513 514 /* 515 * Note each inode from the inode blocks 516 */ 517 if (inoc < lfs_ss_getninos(fs, ssp) && lfs_ii_getblock(fs, iip) == daddr) { 518 cp = fd_ptrget(fs->clfs_devvp, daddr); 519 ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck); 520 for (i = 0; i < lfs_sb_getinopb(fs); i++) { 521 dip = DINO_IN_BLOCK(fs, cp, i); 522 if (lfs_dino_getinumber(fs, dip) == 0) 523 break; 524 525 /* 526 * Check currency before adding it 527 */ 528 #ifndef REPAIR_ZERO_FINFO 529 lfs_ientry(&ifp, fs, lfs_dino_getinumber(fs, dip), &ifbp); 530 idaddr = lfs_if_getdaddr(fs, ifp); 531 brelse(ifbp, 0); 532 if (idaddr != daddr) 533 #endif 534 continue; 535 536 /* 537 * A current inode. Add it. 538 */ 539 ++*bic; 540 nbip = (BLOCK_INFO *)realloc(bip, *bic * 541 sizeof(*bip)); 542 if (nbip) 543 bip = nbip; 544 else { 545 --*bic; 546 *bipp = bip; 547 return 0x0; 548 } 549 bip[*bic - 1].bi_inode = lfs_dino_getinumber(fs, dip); 550 bip[*bic - 1].bi_lbn = LFS_UNUSED_LBN; 551 bip[*bic - 1].bi_daddr = daddr; 552 bip[*bic - 1].bi_segcreate = lfs_ss_getcreate(fs, ssp); 553 bip[*bic - 1].bi_version = lfs_dino_getgen(fs, dip); 554 bip[*bic - 1].bi_bp = dip; 555 bip[*bic - 1].bi_size = DINOSIZE(fs); 556 } 557 inoc += i; 558 daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs)); 559 iip = NEXTLOWER_IINFO(fs, iip); 560 continue; 561 } 562 563 /* 564 * Note each file block from the finfo blocks 565 */ 566 if (fic >= lfs_ss_getnfinfo(fs, ssp)) 567 continue; 568 569 /* Count this finfo, whether or not we use it */ 570 ++fic; 571 572 /* 573 * If this finfo has nblocks==0, it was written wrong. 574 * Kernels with this problem always wrote this zero-sized 575 * finfo last, so just ignore it. 576 */ 577 if (lfs_fi_getnblocks(fs, fip) == 0) { 578 #ifdef REPAIR_ZERO_FINFO 579 struct ubuf *nbp; 580 SEGSUM *nssp; 581 582 syslog(LOG_WARNING, "fixing short FINFO at %jx (seg %d)", 583 (intmax_t)odaddr, lfs_dtosn(fs, odaddr)); 584 bread(fs->clfs_devvp, odaddr, lfs_sb_getfsize(fs), 585 0, &nbp); 586 nssp = (SEGSUM *)nbp->b_data; 587 --nssp->ss_nfinfo; 588 nssp->ss_sumsum = cksum(&nssp->ss_datasum, 589 lfs_sb_getsumsize(fs) - sizeof(nssp->ss_sumsum)); 590 bwrite(nbp); 591 #endif 592 syslog(LOG_WARNING, "zero-length FINFO at %jx (seg %d)", 593 (intmax_t)odaddr, lfs_dtosn(fs, odaddr)); 594 continue; 595 } 596 597 /* 598 * Check currency before adding blocks 599 */ 600 #ifdef REPAIR_ZERO_FINFO 601 vers = -1; 602 #else 603 lfs_ientry(&ifp, fs, lfs_fi_getino(fs, fip), &ifbp); 604 vers = lfs_if_getversion(fs, ifp); 605 brelse(ifbp, 0); 606 #endif 607 if (vers != lfs_fi_getversion(fs, fip)) { 608 size_t size; 609 610 /* Read all the blocks from the data summary */ 611 for (i = 0; i < lfs_fi_getnblocks(fs, fip); i++) { 612 size = (i == lfs_fi_getnblocks(fs, fip) - 1) ? 613 lfs_fi_getlastlength(fs, fip) : lfs_sb_getbsize(fs); 614 cp = fd_ptrget(fs->clfs_devvp, daddr); 615 ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck); 616 daddr += lfs_btofsb(fs, size); 617 } 618 fip = NEXT_FINFO(fs, fip); 619 continue; 620 } 621 622 /* Add all the blocks from the finfos (current or not) */ 623 nbip = (BLOCK_INFO *)realloc(bip, (*bic + lfs_fi_getnblocks(fs, fip)) * 624 sizeof(*bip)); 625 if (nbip) 626 bip = nbip; 627 else { 628 *bipp = bip; 629 return 0x0; 630 } 631 632 for (i = 0; i < lfs_fi_getnblocks(fs, fip); i++) { 633 bip[*bic + i].bi_inode = lfs_fi_getino(fs, fip); 634 bip[*bic + i].bi_lbn = lfs_fi_getblock(fs, fip, i); 635 bip[*bic + i].bi_daddr = daddr; 636 bip[*bic + i].bi_segcreate = lfs_ss_getcreate(fs, ssp); 637 bip[*bic + i].bi_version = lfs_fi_getversion(fs, fip); 638 bip[*bic + i].bi_size = (i == lfs_fi_getnblocks(fs, fip) - 1) ? 639 lfs_fi_getlastlength(fs, fip) : lfs_sb_getbsize(fs); 640 cp = fd_ptrget(fs->clfs_devvp, daddr); 641 ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck); 642 bip[*bic + i].bi_bp = cp; 643 daddr += lfs_btofsb(fs, bip[*bic + i].bi_size); 644 645 #ifdef TEST_PATTERN 646 check_test_pattern(bip + *bic + i); /* XXXDEBUG */ 647 #endif 648 } 649 *bic += lfs_fi_getnblocks(fs, fip); 650 fip = NEXT_FINFO(fs, fip); 651 } 652 653 #ifndef REPAIR_ZERO_FINFO 654 if (lfs_ss_getdatasum(fs, ssp) != ck) { 655 syslog(LOG_WARNING, "%s: data checksum bad at 0x%jx:" 656 " read 0x%x, computed 0x%x", lfs_sb_getfsmnt(fs), 657 (intmax_t)odaddr, 658 lfs_ss_getdatasum(fs, ssp), ck); 659 *bic = obic; 660 return 0x0; 661 } 662 #endif 663 664 *bipp = bip; 665 return daddr; 666 } 667 668 static void 669 log_segment_read(struct clfs *fs, int sn) 670 { 671 FILE *fp; 672 char *cp; 673 674 /* 675 * Write the segment read, and its contents, into a log file in 676 * the current directory. We don't need to log the location of 677 * the segment, since that can be inferred from the segments up 678 * to this point (ss_nextseg field of the previously written segment). 679 * 680 * We can use this info later to reconstruct the filesystem at any 681 * given point in time for analysis, by replaying the log forward 682 * indexed by the segment serial numbers; but it is not suitable 683 * for everyday use since the copylog will be simply enormous. 684 */ 685 cp = fd_ptrget(fs->clfs_devvp, lfs_sntod(fs, sn)); 686 687 fp = fopen(copylog_filename, "ab"); 688 if (fp != NULL) { 689 if (fwrite(cp, (size_t)lfs_sb_getssize(fs), 1, fp) != 1) { 690 perror("writing segment to copy log"); 691 } 692 } 693 fclose(fp); 694 } 695 696 /* 697 * Read a segment to populate the BLOCK_INFO structures. 698 * Return the number of partial segments read and parsed. 699 */ 700 int 701 load_segment(struct clfs *fs, int sn, BLOCK_INFO **bipp, int *bic) 702 { 703 daddr_t daddr; 704 int i, npseg; 705 706 daddr = lfs_sntod(fs, sn); 707 if (daddr < lfs_btofsb(fs, LFS_LABELPAD)) 708 daddr = lfs_btofsb(fs, LFS_LABELPAD); 709 for (i = 0; i < LFS_MAXNUMSB; i++) { 710 if (lfs_sb_getsboff(fs, i) == daddr) { 711 daddr += lfs_btofsb(fs, LFS_SBPAD); 712 break; 713 } 714 } 715 716 /* Preload the segment buffer */ 717 if (fd_preload(fs->clfs_devvp, lfs_sntod(fs, sn)) < 0) 718 return -1; 719 720 if (copylog_filename) 721 log_segment_read(fs, sn); 722 723 /* Note bytes read for stats */ 724 cleaner_stats.segs_cleaned++; 725 cleaner_stats.bytes_read += lfs_sb_getssize(fs); 726 ++fs->clfs_nactive; 727 728 npseg = 0; 729 while(lfs_dtosn(fs, daddr) == sn && 730 lfs_dtosn(fs, daddr + lfs_btofsb(fs, lfs_sb_getbsize(fs))) == sn) { 731 daddr = parse_pseg(fs, daddr, bipp, bic); 732 if (daddr == 0x0) { 733 ++cleaner_stats.segs_error; 734 break; 735 } 736 ++npseg; 737 } 738 739 return npseg; 740 } 741 742 void 743 calc_cb(struct clfs *fs, int sn, struct clfs_seguse *t) 744 { 745 time_t now; 746 int64_t age, benefit, cost; 747 748 time(&now); 749 age = (now < t->lastmod ? 0 : now - t->lastmod); 750 751 /* Under no circumstances clean active or already-clean segments */ 752 if ((t->flags & SEGUSE_ACTIVE) || !(t->flags & SEGUSE_DIRTY)) { 753 t->priority = 0; 754 return; 755 } 756 757 /* 758 * If the segment is empty, there is no reason to clean it. 759 * Clear its error condition, if any, since we are never going to 760 * try to parse this one. 761 */ 762 if (t->nbytes == 0) { 763 t->flags &= ~SEGUSE_ERROR; /* Strip error once empty */ 764 t->priority = 0; 765 return; 766 } 767 768 if (t->flags & SEGUSE_ERROR) { /* No good if not already empty */ 769 /* No benefit */ 770 t->priority = 0; 771 return; 772 } 773 774 if (t->nbytes > lfs_sb_getssize(fs)) { 775 /* Another type of error */ 776 syslog(LOG_WARNING, "segment %d: bad seguse count %d", 777 sn, t->nbytes); 778 t->flags |= SEGUSE_ERROR; 779 t->priority = 0; 780 return; 781 } 782 783 /* 784 * The non-degenerate case. Use Rosenblum's cost-benefit algorithm. 785 * Calculate the benefit from cleaning this segment (one segment, 786 * minus fragmentation, dirty blocks and a segment summary block) 787 * and weigh that against the cost (bytes read plus bytes written). 788 * We count the summary headers as "dirty" to avoid cleaning very 789 * old and very full segments. 790 */ 791 benefit = (int64_t)lfs_sb_getssize(fs) - t->nbytes - 792 (t->nsums + 1) * lfs_sb_getfsize(fs); 793 if (lfs_sb_getbsize(fs) > lfs_sb_getfsize(fs)) /* fragmentation */ 794 benefit -= (lfs_sb_getbsize(fs) / 2); 795 if (benefit <= 0) { 796 t->priority = 0; 797 return; 798 } 799 800 cost = lfs_sb_getssize(fs) + t->nbytes; 801 t->priority = (256 * benefit * age) / cost; 802 803 return; 804 } 805 806 /* 807 * Comparator for BLOCK_INFO structures. Anything not in one of the segments 808 * we're looking at sorts higher; after that we sort first by inode number 809 * and then by block number (unsigned, i.e., negative sorts higher) *but* 810 * sort inodes before data blocks. 811 */ 812 static int 813 bi_comparator(const void *va, const void *vb) 814 { 815 const BLOCK_INFO *a, *b; 816 817 a = (const BLOCK_INFO *)va; 818 b = (const BLOCK_INFO *)vb; 819 820 /* Check for out-of-place block */ 821 if (a->bi_segcreate == a->bi_daddr && 822 b->bi_segcreate != b->bi_daddr) 823 return -1; 824 if (a->bi_segcreate != a->bi_daddr && 825 b->bi_segcreate == b->bi_daddr) 826 return 1; 827 if (a->bi_size <= 0 && b->bi_size > 0) 828 return 1; 829 if (b->bi_size <= 0 && a->bi_size > 0) 830 return -1; 831 832 /* Check inode number */ 833 if (a->bi_inode != b->bi_inode) 834 return a->bi_inode - b->bi_inode; 835 836 /* Check lbn */ 837 if (a->bi_lbn == LFS_UNUSED_LBN) /* Inodes sort lower than blocks */ 838 return -1; 839 if (b->bi_lbn == LFS_UNUSED_LBN) 840 return 1; 841 if ((u_int64_t)a->bi_lbn > (u_int64_t)b->bi_lbn) 842 return 1; 843 else 844 return -1; 845 846 return 0; 847 } 848 849 /* 850 * Comparator for sort_segments: cost-benefit equation. 851 */ 852 static int 853 cb_comparator(const void *va, const void *vb) 854 { 855 const struct clfs_seguse *a, *b; 856 857 a = *(const struct clfs_seguse * const *)va; 858 b = *(const struct clfs_seguse * const *)vb; 859 return a->priority > b->priority ? -1 : 1; 860 } 861 862 void 863 toss_old_blocks(struct clfs *fs, BLOCK_INFO **bipp, blkcnt_t *bic, int *sizep) 864 { 865 blkcnt_t i; 866 int r; 867 BLOCK_INFO *bip = *bipp; 868 struct lfs_fcntl_markv /* { 869 BLOCK_INFO *blkiov; 870 int blkcnt; 871 } */ lim; 872 873 if (bic == 0 || bip == NULL) 874 return; 875 876 /* 877 * Kludge: Store the disk address in segcreate so we know which 878 * ones to toss. 879 */ 880 for (i = 0; i < *bic; i++) 881 bip[i].bi_segcreate = bip[i].bi_daddr; 882 883 /* 884 * XXX: blkcnt_t is 64 bits, so *bic might overflow size_t 885 * (the argument type of heapsort's number argument) on a 886 * 32-bit platform. However, if so we won't have got this far 887 * because we'll have failed trying to allocate the array. So 888 * while *bic here might cause a 64->32 truncation, it's safe. 889 */ 890 /* Sort the blocks */ 891 heapsort(bip, *bic, sizeof(BLOCK_INFO), bi_comparator); 892 893 /* Use bmapv to locate the blocks */ 894 lim.blkiov = bip; 895 lim.blkcnt = *bic; 896 if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNBMAPV, &lim)) < 0) { 897 syslog(LOG_WARNING, "%s: bmapv returned %d (%m)", 898 lfs_sb_getfsmnt(fs), r); 899 return; 900 } 901 902 /* Toss blocks not in this segment */ 903 heapsort(bip, *bic, sizeof(BLOCK_INFO), bi_comparator); 904 905 /* Get rid of stale blocks */ 906 if (sizep) 907 *sizep = 0; 908 for (i = 0; i < *bic; i++) { 909 if (bip[i].bi_segcreate != bip[i].bi_daddr) 910 break; 911 if (sizep) 912 *sizep += bip[i].bi_size; 913 } 914 *bic = i; /* XXX should we shrink bip? */ 915 *bipp = bip; 916 917 return; 918 } 919 920 /* 921 * Clean a segment and mark it invalid. 922 */ 923 int 924 invalidate_segment(struct clfs *fs, int sn) 925 { 926 BLOCK_INFO *bip; 927 int i, r, bic; 928 blkcnt_t widebic; 929 off_t nb; 930 double util; 931 struct lfs_fcntl_markv /* { 932 BLOCK_INFO *blkiov; 933 int blkcnt; 934 } */ lim; 935 936 dlog("%s: inval seg %d", lfs_sb_getfsmnt(fs), sn); 937 938 bip = NULL; 939 bic = 0; 940 fs->clfs_nactive = 0; 941 if (load_segment(fs, sn, &bip, &bic) <= 0) 942 return -1; 943 widebic = bic; 944 toss_old_blocks(fs, &bip, &widebic, NULL); 945 bic = widebic; 946 947 /* Record statistics */ 948 for (i = nb = 0; i < bic; i++) 949 nb += bip[i].bi_size; 950 util = ((double)nb) / (fs->clfs_nactive * lfs_sb_getssize(fs)); 951 cleaner_stats.util_tot += util; 952 cleaner_stats.util_sos += util * util; 953 cleaner_stats.bytes_written += nb; 954 955 /* 956 * Use markv to move the blocks. 957 */ 958 lim.blkiov = bip; 959 lim.blkcnt = bic; 960 if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNMARKV, &lim)) < 0) { 961 syslog(LOG_WARNING, "%s: markv returned %d (%m) " 962 "for seg %d", lfs_sb_getfsmnt(fs), r, sn); 963 return r; 964 } 965 966 /* 967 * Finally call invalidate to invalidate the segment. 968 */ 969 if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNINVAL, &sn)) < 0) { 970 syslog(LOG_WARNING, "%s: inval returned %d (%m) " 971 "for seg %d", lfs_sb_getfsmnt(fs), r, sn); 972 return r; 973 } 974 975 return 0; 976 } 977 978 /* 979 * Check to see if the given ino/lbn pair is represented in the BLOCK_INFO 980 * array we are sending to the kernel, or if the kernel will have to add it. 981 * The kernel will only add each such pair once, though, so keep track of 982 * previous requests in a separate "extra" BLOCK_INFO array. Returns 1 983 * if the block needs to be added, 0 if it is already represented. 984 */ 985 static int 986 check_or_add(ino_t ino, daddr_t lbn, BLOCK_INFO *bip, int bic, BLOCK_INFO **ebipp, int *ebicp) 987 { 988 BLOCK_INFO *t, *ebip = *ebipp; 989 int ebic = *ebicp; 990 int k; 991 992 for (k = 0; k < bic; k++) { 993 if (bip[k].bi_inode != ino) 994 break; 995 if (bip[k].bi_lbn == lbn) { 996 return 0; 997 } 998 } 999 1000 /* Look on the list of extra blocks, too */ 1001 for (k = 0; k < ebic; k++) { 1002 if (ebip[k].bi_inode == ino && ebip[k].bi_lbn == lbn) { 1003 return 0; 1004 } 1005 } 1006 1007 ++ebic; 1008 t = realloc(ebip, ebic * sizeof(BLOCK_INFO)); 1009 if (t == NULL) 1010 return 1; /* Note *ebicp is unchanged */ 1011 1012 ebip = t; 1013 ebip[ebic - 1].bi_inode = ino; 1014 ebip[ebic - 1].bi_lbn = lbn; 1015 1016 *ebipp = ebip; 1017 *ebicp = ebic; 1018 return 1; 1019 } 1020 1021 /* 1022 * Look for indirect blocks we will have to write which are not 1023 * contained in this collection of blocks. This constitutes 1024 * a hidden cleaning cost, since we are unaware of it until we 1025 * have already read the segments. Return the total cost, and fill 1026 * in *ifc with the part of that cost due to rewriting the Ifile. 1027 */ 1028 static off_t 1029 check_hidden_cost(struct clfs *fs, BLOCK_INFO *bip, int bic, off_t *ifc) 1030 { 1031 int start; 1032 struct indir in[ULFS_NIADDR + 1]; 1033 int num; 1034 int i, j, ebic; 1035 BLOCK_INFO *ebip; 1036 daddr_t lbn; 1037 1038 start = 0; 1039 ebip = NULL; 1040 ebic = 0; 1041 for (i = 0; i < bic; i++) { 1042 if (i == 0 || bip[i].bi_inode != bip[start].bi_inode) { 1043 start = i; 1044 /* 1045 * Look for IFILE blocks, unless this is the Ifile. 1046 */ 1047 if (bip[i].bi_inode != LFS_IFILE_INUM) { 1048 lbn = lfs_sb_getcleansz(fs) + bip[i].bi_inode / 1049 lfs_sb_getifpb(fs); 1050 *ifc += check_or_add(LFS_IFILE_INUM, lbn, 1051 bip, bic, &ebip, &ebic); 1052 } 1053 } 1054 if (bip[i].bi_lbn == LFS_UNUSED_LBN) 1055 continue; 1056 if (bip[i].bi_lbn < ULFS_NDADDR) 1057 continue; 1058 1059 /* XXX the struct lfs cast is completely wrong/unsafe */ 1060 ulfs_getlbns((struct lfs *)fs, NULL, (daddr_t)bip[i].bi_lbn, in, &num); 1061 for (j = 0; j < num; j++) { 1062 check_or_add(bip[i].bi_inode, in[j].in_lbn, 1063 bip + start, bic - start, &ebip, &ebic); 1064 } 1065 } 1066 return ebic; 1067 } 1068 1069 /* 1070 * Select segments to clean, add blocks from these segments to a cleaning 1071 * list, and send this list through lfs_markv() to move them to new 1072 * locations on disk. 1073 */ 1074 static int 1075 clean_fs(struct clfs *fs, const CLEANERINFO64 *cip) 1076 { 1077 int i, j, ngood, sn, bic, r, npos; 1078 blkcnt_t widebic; 1079 int bytes, totbytes; 1080 struct ubuf *bp; 1081 SEGUSE *sup; 1082 static BLOCK_INFO *bip; 1083 struct lfs_fcntl_markv /* { 1084 BLOCK_INFO *blkiov; 1085 int blkcnt; 1086 } */ lim; 1087 int mc; 1088 BLOCK_INFO *mbip; 1089 int inc; 1090 off_t nb; 1091 off_t goal; 1092 off_t extra, if_extra; 1093 double util; 1094 1095 /* Read the segment table into our private structure */ 1096 npos = 0; 1097 for (i = 0; i < lfs_sb_getnseg(fs); i+= lfs_sb_getsepb(fs)) { 1098 bread(fs->lfs_ivnode, 1099 lfs_sb_getcleansz(fs) + i / lfs_sb_getsepb(fs), 1100 lfs_sb_getbsize(fs), 0, &bp); 1101 for (j = 0; j < lfs_sb_getsepb(fs) && i + j < lfs_sb_getnseg(fs); j++) { 1102 sup = ((SEGUSE *)bp->b_data) + j; 1103 fs->clfs_segtab[i + j].nbytes = sup->su_nbytes; 1104 fs->clfs_segtab[i + j].nsums = sup->su_nsums; 1105 fs->clfs_segtab[i + j].lastmod = sup->su_lastmod; 1106 /* Keep error status but renew other flags */ 1107 fs->clfs_segtab[i + j].flags &= SEGUSE_ERROR; 1108 fs->clfs_segtab[i + j].flags |= sup->su_flags; 1109 1110 /* Compute cost-benefit coefficient */ 1111 calc_cb(fs, i + j, fs->clfs_segtab + i + j); 1112 if (fs->clfs_segtab[i + j].priority > 0) 1113 ++npos; 1114 } 1115 brelse(bp, 0); 1116 } 1117 1118 /* Sort segments based on cleanliness, fulness, and condition */ 1119 heapsort(fs->clfs_segtabp, lfs_sb_getnseg(fs), sizeof(struct clfs_seguse *), 1120 cb_comparator); 1121 1122 /* If no segment is cleanable, just return */ 1123 if (fs->clfs_segtabp[0]->priority == 0) { 1124 dlog("%s: no segment cleanable", lfs_sb_getfsmnt(fs)); 1125 return 0; 1126 } 1127 1128 /* Load some segments' blocks into bip */ 1129 bic = 0; 1130 fs->clfs_nactive = 0; 1131 ngood = 0; 1132 if (use_bytes) { 1133 /* Set attainable goal */ 1134 goal = lfs_sb_getssize(fs) * atatime; 1135 if (goal > (cip->clean - 1) * lfs_sb_getssize(fs) / 2) 1136 goal = MAX((cip->clean - 1) * lfs_sb_getssize(fs), 1137 lfs_sb_getssize(fs)) / 2; 1138 1139 dlog("%s: cleaning with goal %" PRId64 1140 " bytes (%d segs clean, %d cleanable)", 1141 lfs_sb_getfsmnt(fs), goal, cip->clean, npos); 1142 syslog(LOG_INFO, "%s: cleaning with goal %" PRId64 1143 " bytes (%d segs clean, %d cleanable)", 1144 lfs_sb_getfsmnt(fs), goal, cip->clean, npos); 1145 totbytes = 0; 1146 for (i = 0; i < lfs_sb_getnseg(fs) && totbytes < goal; i++) { 1147 if (fs->clfs_segtabp[i]->priority == 0) 1148 break; 1149 /* Upper bound on number of segments at once */ 1150 if (ngood * lfs_sb_getssize(fs) > 4 * goal) 1151 break; 1152 sn = (fs->clfs_segtabp[i] - fs->clfs_segtab); 1153 dlog("%s: add seg %d prio %" PRIu64 1154 " containing %ld bytes", 1155 lfs_sb_getfsmnt(fs), sn, fs->clfs_segtabp[i]->priority, 1156 fs->clfs_segtabp[i]->nbytes); 1157 if ((r = load_segment(fs, sn, &bip, &bic)) > 0) { 1158 ++ngood; 1159 widebic = bic; 1160 toss_old_blocks(fs, &bip, &widebic, &bytes); 1161 bic = widebic; 1162 totbytes += bytes; 1163 } else if (r == 0) 1164 fd_release(fs->clfs_devvp); 1165 else 1166 break; 1167 } 1168 } else { 1169 /* Set attainable goal */ 1170 goal = atatime; 1171 if (goal > cip->clean - 1) 1172 goal = MAX(cip->clean - 1, 1); 1173 1174 dlog("%s: cleaning with goal %d segments (%d clean, %d cleanable)", 1175 lfs_sb_getfsmnt(fs), (int)goal, cip->clean, npos); 1176 for (i = 0; i < lfs_sb_getnseg(fs) && ngood < goal; i++) { 1177 if (fs->clfs_segtabp[i]->priority == 0) 1178 break; 1179 sn = (fs->clfs_segtabp[i] - fs->clfs_segtab); 1180 dlog("%s: add seg %d prio %" PRIu64, 1181 lfs_sb_getfsmnt(fs), sn, fs->clfs_segtabp[i]->priority); 1182 if ((r = load_segment(fs, sn, &bip, &bic)) > 0) 1183 ++ngood; 1184 else if (r == 0) 1185 fd_release(fs->clfs_devvp); 1186 else 1187 break; 1188 } 1189 widebic = bic; 1190 toss_old_blocks(fs, &bip, &widebic, NULL); 1191 bic = widebic; 1192 } 1193 1194 /* If there is nothing to do, try again later. */ 1195 if (bic == 0) { 1196 dlog("%s: no blocks to clean in %d cleanable segments", 1197 lfs_sb_getfsmnt(fs), (int)ngood); 1198 fd_release_all(fs->clfs_devvp); 1199 return 0; 1200 } 1201 1202 /* Record statistics */ 1203 for (i = nb = 0; i < bic; i++) 1204 nb += bip[i].bi_size; 1205 util = ((double)nb) / (fs->clfs_nactive * lfs_sb_getssize(fs)); 1206 cleaner_stats.util_tot += util; 1207 cleaner_stats.util_sos += util * util; 1208 cleaner_stats.bytes_written += nb; 1209 1210 /* 1211 * Check out our blocks to see if there are hidden cleaning costs. 1212 * If there are, we might be cleaning ourselves deeper into a hole 1213 * rather than doing anything useful. 1214 * XXX do something about this. 1215 */ 1216 if_extra = 0; 1217 extra = lfs_sb_getbsize(fs) * (off_t)check_hidden_cost(fs, bip, bic, &if_extra); 1218 if_extra *= lfs_sb_getbsize(fs); 1219 1220 /* 1221 * Use markv to move the blocks. 1222 */ 1223 if (do_small) 1224 inc = MAXPHYS / lfs_sb_getbsize(fs) - 1; 1225 else 1226 inc = LFS_MARKV_MAXBLKCNT / 2; 1227 for (mc = 0, mbip = bip; mc < bic; mc += inc, mbip += inc) { 1228 lim.blkiov = mbip; 1229 lim.blkcnt = (bic - mc > inc ? inc : bic - mc); 1230 #ifdef TEST_PATTERN 1231 dlog("checking blocks %d-%d", mc, mc + lim.blkcnt - 1); 1232 for (i = 0; i < lim.blkcnt; i++) { 1233 check_test_pattern(mbip + i); 1234 } 1235 #endif /* TEST_PATTERN */ 1236 dlog("sending blocks %d-%d", mc, mc + lim.blkcnt - 1); 1237 if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNMARKV, &lim))<0) { 1238 int oerrno = errno; 1239 syslog(LOG_WARNING, "%s: markv returned %d (errno %d, %m)", 1240 lfs_sb_getfsmnt(fs), r, errno); 1241 if (oerrno != EAGAIN && oerrno != ESHUTDOWN) { 1242 syslog(LOG_DEBUG, "%s: errno %d, returning", 1243 lfs_sb_getfsmnt(fs), oerrno); 1244 fd_release_all(fs->clfs_devvp); 1245 return r; 1246 } 1247 if (oerrno == ESHUTDOWN) { 1248 syslog(LOG_NOTICE, "%s: filesystem unmounted", 1249 lfs_sb_getfsmnt(fs)); 1250 fd_release_all(fs->clfs_devvp); 1251 return r; 1252 } 1253 } 1254 } 1255 1256 /* 1257 * Report progress (or lack thereof) 1258 */ 1259 syslog(LOG_INFO, "%s: wrote %" PRId64 " dirty + %" 1260 PRId64 " supporting indirect + %" 1261 PRId64 " supporting Ifile = %" 1262 PRId64 " bytes to clean %d segs (%" PRId64 "%% recovery)", 1263 lfs_sb_getfsmnt(fs), (int64_t)nb, (int64_t)(extra - if_extra), 1264 (int64_t)if_extra, (int64_t)(nb + extra), ngood, 1265 (ngood ? (int64_t)(100 - (100 * (nb + extra)) / 1266 (ngood * lfs_sb_getssize(fs))) : 1267 (int64_t)0)); 1268 if (nb + extra >= ngood * lfs_sb_getssize(fs)) 1269 syslog(LOG_WARNING, "%s: cleaner not making forward progress", 1270 lfs_sb_getfsmnt(fs)); 1271 1272 /* 1273 * Finally call reclaim to prompt cleaning of the segments. 1274 */ 1275 kops.ko_fcntl(fs->clfs_ifilefd, LFCNRECLAIM, NULL); 1276 1277 fd_release_all(fs->clfs_devvp); 1278 return 0; 1279 } 1280 1281 /* 1282 * Read the cleanerinfo block and apply cleaning policy to determine whether 1283 * the given filesystem needs to be cleaned. Returns 1 if it does, 0 if it 1284 * does not, or -1 on error. 1285 */ 1286 static int 1287 needs_cleaning(struct clfs *fs, CLEANERINFO64 *cip) 1288 { 1289 CLEANERINFO *cipu; 1290 struct ubuf *bp; 1291 struct stat st; 1292 daddr_t fsb_per_seg, max_free_segs; 1293 time_t now; 1294 double loadavg; 1295 1296 /* If this fs is "on hold", don't clean it. */ 1297 if (fs->clfs_onhold) { 1298 #if defined(__GNUC__) && \ 1299 (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) && \ 1300 defined(__OPTIMIZE_SIZE__) 1301 /* 1302 * XXX: Work around apparent bug with GCC >= 4.8 and -Os: it 1303 * claims that ci.clean is uninitialized in clean_fs (at one 1304 * of the several uses of it, which is neither the first nor 1305 * last use) -- this doesn't happen with plain -O2. 1306 * 1307 * Hopefully in the future further rearrangements will allow 1308 * removing this hack. 1309 */ 1310 cip->clean = 0; 1311 #endif 1312 return 0; 1313 } 1314 1315 /* 1316 * Read the cleanerinfo block from the Ifile. We don't want 1317 * the cached information, so invalidate the buffer before 1318 * handing it back. 1319 */ 1320 if (bread(fs->lfs_ivnode, 0, lfs_sb_getbsize(fs), 0, &bp)) { 1321 syslog(LOG_ERR, "%s: can't read inode", lfs_sb_getfsmnt(fs)); 1322 return -1; 1323 } 1324 cipu = (CLEANERINFO *)bp->b_data; 1325 if (fs->lfs_is64) { 1326 /* Structure copy */ 1327 *cip = cipu->u_64; 1328 } else { 1329 /* Copy the fields and promote to 64 bit */ 1330 cip->clean = cipu->u_32.clean; 1331 cip->dirty = cipu->u_32.dirty; 1332 cip->bfree = cipu->u_32.bfree; 1333 cip->avail = cipu->u_32.avail; 1334 cip->free_head = cipu->u_32.free_head; 1335 cip->free_tail = cipu->u_32.free_tail; 1336 cip->flags = cipu->u_32.flags; 1337 } 1338 brelse(bp, B_INVAL); 1339 cleaner_stats.bytes_read += lfs_sb_getbsize(fs); 1340 1341 /* 1342 * If the number of segments changed under us, reinit. 1343 * We don't have to start over from scratch, however, 1344 * since we don't hold any buffers. 1345 */ 1346 if (lfs_sb_getnseg(fs) != cip->clean + cip->dirty) { 1347 if (reinit_fs(fs) < 0) { 1348 /* The normal case for unmount */ 1349 syslog(LOG_NOTICE, "%s: filesystem unmounted", lfs_sb_getfsmnt(fs)); 1350 return -1; 1351 } 1352 syslog(LOG_NOTICE, "%s: nsegs changed", lfs_sb_getfsmnt(fs)); 1353 } 1354 1355 /* Compute theoretical "free segments" maximum based on usage */ 1356 fsb_per_seg = lfs_segtod(fs, 1); 1357 max_free_segs = MAX(cip->bfree, 0) / fsb_per_seg + lfs_sb_getminfreeseg(fs); 1358 1359 dlog("%s: bfree = %d, avail = %d, clean = %d/%d", 1360 lfs_sb_getfsmnt(fs), cip->bfree, cip->avail, cip->clean, 1361 lfs_sb_getnseg(fs)); 1362 1363 /* If the writer is waiting on us, clean it */ 1364 if (cip->clean <= lfs_sb_getminfreeseg(fs) || 1365 (cip->flags & LFS_CLEANER_MUST_CLEAN)) 1366 return 1; 1367 1368 /* If there are enough segments, don't clean it */ 1369 if (cip->bfree - cip->avail <= fsb_per_seg && 1370 cip->avail > fsb_per_seg) 1371 return 0; 1372 1373 /* If we are in dire straits, clean it */ 1374 if (cip->bfree - cip->avail > fsb_per_seg && 1375 cip->avail <= fsb_per_seg) 1376 return 1; 1377 1378 /* If under busy threshold, clean regardless of load */ 1379 if (cip->clean < max_free_segs * BUSY_LIM) 1380 return 1; 1381 1382 /* Check busy status; clean if idle and under idle limit */ 1383 if (use_fs_idle) { 1384 /* Filesystem idle */ 1385 time(&now); 1386 if (fstat(fs->clfs_ifilefd, &st) < 0) { 1387 syslog(LOG_ERR, "%s: failed to stat ifile", 1388 lfs_sb_getfsmnt(fs)); 1389 return -1; 1390 } 1391 if (now - st.st_mtime > segwait_timeout && 1392 cip->clean < max_free_segs * IDLE_LIM) 1393 return 1; 1394 } else { 1395 /* CPU idle - use one-minute load avg */ 1396 if (getloadavg(&loadavg, 1) == -1) { 1397 syslog(LOG_ERR, "%s: failed to get load avg", 1398 lfs_sb_getfsmnt(fs)); 1399 return -1; 1400 } 1401 if (loadavg < load_threshold && 1402 cip->clean < max_free_segs * IDLE_LIM) 1403 return 1; 1404 } 1405 1406 return 0; 1407 } 1408 1409 /* 1410 * Report statistics. If the signal was SIGUSR2, clear the statistics too. 1411 * If the signal was SIGINT, exit. 1412 */ 1413 static void 1414 sig_report(int sig) 1415 { 1416 double avg = 0.0, stddev; 1417 1418 avg = cleaner_stats.util_tot / MAX(cleaner_stats.segs_cleaned, 1.0); 1419 stddev = cleaner_stats.util_sos / MAX(cleaner_stats.segs_cleaned - 1420 avg * avg, 1.0); 1421 syslog(LOG_INFO, "bytes read: %" PRId64, cleaner_stats.bytes_read); 1422 syslog(LOG_INFO, "bytes written: %" PRId64, cleaner_stats.bytes_written); 1423 syslog(LOG_INFO, "segments cleaned: %" PRId64, cleaner_stats.segs_cleaned); 1424 #if 0 1425 /* "Empty segments" is meaningless, since the kernel handles those */ 1426 syslog(LOG_INFO, "empty segments: %" PRId64, cleaner_stats.segs_empty); 1427 #endif 1428 syslog(LOG_INFO, "error segments: %" PRId64, cleaner_stats.segs_error); 1429 syslog(LOG_INFO, "utilization total: %g", cleaner_stats.util_tot); 1430 syslog(LOG_INFO, "utilization sos: %g", cleaner_stats.util_sos); 1431 syslog(LOG_INFO, "utilization avg: %4.2f", avg); 1432 syslog(LOG_INFO, "utilization sdev: %9.6f", stddev); 1433 1434 if (debug) 1435 bufstats(); 1436 1437 if (sig == SIGUSR2) 1438 memset(&cleaner_stats, 0, sizeof(cleaner_stats)); 1439 if (sig == SIGINT) 1440 exit(0); 1441 } 1442 1443 static void 1444 sig_exit(int sig) 1445 { 1446 exit(0); 1447 } 1448 1449 static void 1450 usage(void) 1451 { 1452 fprintf(stderr, "usage: lfs_cleanerd [-bcdfmqsJ] [-i segnum] [-l load] " 1453 "[-n nsegs] [-r report_freq] [-t timeout] fs_name ..."); 1454 } 1455 1456 #ifndef LFS_CLEANER_AS_LIB 1457 /* 1458 * Main. 1459 */ 1460 int 1461 main(int argc, char **argv) 1462 { 1463 1464 return lfs_cleaner_main(argc, argv); 1465 } 1466 #endif 1467 1468 int 1469 lfs_cleaner_main(int argc, char **argv) 1470 { 1471 int i, opt, error, r, loopcount, nodetach; 1472 struct timeval tv; 1473 #ifdef LFS_CLEANER_AS_LIB 1474 sem_t *semaddr = NULL; 1475 #endif 1476 CLEANERINFO64 ci; 1477 #ifndef USE_CLIENT_SERVER 1478 char *cp, *pidname; 1479 #endif 1480 1481 /* 1482 * Set up defaults 1483 */ 1484 atatime = 1; 1485 segwait_timeout = 300; /* Five minutes */ 1486 load_threshold = 0.2; 1487 stat_report = 0; 1488 inval_segment = -1; 1489 copylog_filename = NULL; 1490 nodetach = 0; 1491 do_asdevice = NULL; 1492 1493 /* 1494 * Parse command-line arguments 1495 */ 1496 while ((opt = getopt(argc, argv, "bC:cdDfi:J:l:mn:qr:sS:t:")) != -1) { 1497 switch (opt) { 1498 case 'b': /* Use bytes written, not segments read */ 1499 use_bytes = 1; 1500 break; 1501 case 'C': /* copy log */ 1502 copylog_filename = optarg; 1503 break; 1504 case 'c': /* Coalesce files */ 1505 do_coalesce++; 1506 break; 1507 case 'd': /* Debug mode. */ 1508 nodetach++; 1509 debug++; 1510 break; 1511 case 'D': /* stay-on-foreground */ 1512 nodetach++; 1513 break; 1514 case 'f': /* Use fs idle time rather than cpu idle */ 1515 use_fs_idle = 1; 1516 break; 1517 case 'i': /* Invalidate this segment */ 1518 inval_segment = atoi(optarg); 1519 break; 1520 case 'l': /* Load below which to clean */ 1521 load_threshold = atof(optarg); 1522 break; 1523 case 'm': /* [compat only] */ 1524 break; 1525 case 'n': /* How many segs to clean at once */ 1526 atatime = atoi(optarg); 1527 break; 1528 case 'q': /* Quit after one run */ 1529 do_quit = 1; 1530 break; 1531 case 'r': /* Report every stat_report segments */ 1532 stat_report = atoi(optarg); 1533 break; 1534 case 's': /* Small writes */ 1535 do_small = 1; 1536 break; 1537 #ifdef LFS_CLEANER_AS_LIB 1538 case 'S': /* semaphore */ 1539 semaddr = (void*)(uintptr_t)strtoull(optarg,NULL,0); 1540 break; 1541 #endif 1542 case 't': /* timeout */ 1543 segwait_timeout = atoi(optarg); 1544 break; 1545 case 'J': /* do as a device */ 1546 do_asdevice = optarg; 1547 break; 1548 default: 1549 usage(); 1550 /* NOTREACHED */ 1551 } 1552 } 1553 argc -= optind; 1554 argv += optind; 1555 1556 if (argc < 1) 1557 usage(); 1558 if (inval_segment >= 0 && argc != 1) { 1559 errx(1, "lfs_cleanerd: may only specify one filesystem when " 1560 "using -i flag"); 1561 } 1562 1563 if (do_coalesce) { 1564 errx(1, "lfs_cleanerd: -c disabled due to reports of file " 1565 "corruption; you may re-enable it by rebuilding the " 1566 "cleaner"); 1567 } 1568 1569 /* 1570 * Set up daemon mode or foreground mode 1571 */ 1572 if (nodetach) { 1573 openlog("lfs_cleanerd", LOG_NDELAY | LOG_PID | LOG_PERROR, 1574 LOG_DAEMON); 1575 signal(SIGINT, sig_report); 1576 } else { 1577 if (daemon(0, 0) == -1) 1578 err(1, "lfs_cleanerd: couldn't become a daemon!"); 1579 openlog("lfs_cleanerd", LOG_NDELAY | LOG_PID, LOG_DAEMON); 1580 signal(SIGINT, sig_exit); 1581 } 1582 1583 /* 1584 * Look for an already-running master daemon. If there is one, 1585 * send it our filesystems to add to its list and exit. 1586 * If there is none, become the master. 1587 */ 1588 #ifdef USE_CLIENT_SERVER 1589 try_to_become_master(argc, argv); 1590 #else 1591 /* XXX think about this */ 1592 asprintf(&pidname, "lfs_cleanerd:m:%s", argv[0]); 1593 if (pidname == NULL) { 1594 syslog(LOG_ERR, "malloc failed: %m"); 1595 exit(1); 1596 } 1597 for (cp = pidname; cp != NULL; cp = strchr(cp, '/')) 1598 *cp = '|'; 1599 pidfile(pidname); 1600 #endif 1601 1602 /* 1603 * Signals mean daemon should report its statistics 1604 */ 1605 memset(&cleaner_stats, 0, sizeof(cleaner_stats)); 1606 signal(SIGUSR1, sig_report); 1607 signal(SIGUSR2, sig_report); 1608 1609 /* 1610 * Start up buffer cache. We only use this for the Ifile, 1611 * and we will resize it if necessary, so it can start small. 1612 */ 1613 bufinit(4); 1614 1615 #ifdef REPAIR_ZERO_FINFO 1616 { 1617 BLOCK_INFO *bip = NULL; 1618 int bic = 0; 1619 1620 nfss = 1; 1621 fsp = (struct clfs **)malloc(sizeof(*fsp)); 1622 fsp[0] = (struct clfs *)calloc(1, sizeof(**fsp)); 1623 1624 if (init_unmounted_fs(fsp[0], argv[0]) < 0) { 1625 err(1, "init_unmounted_fs"); 1626 } 1627 dlog("Filesystem has %d segments", fsp[0]->lfs_nseg); 1628 for (i = 0; i < fsp[0]->lfs_nseg; i++) { 1629 load_segment(fsp[0], i, &bip, &bic); 1630 bic = 0; 1631 } 1632 exit(0); 1633 } 1634 #endif 1635 1636 /* 1637 * Initialize cleaning structures, open devices, etc. 1638 */ 1639 nfss = argc; 1640 fsp = (struct clfs **)malloc(nfss * sizeof(*fsp)); 1641 if (fsp == NULL) { 1642 syslog(LOG_ERR, "couldn't allocate fs table: %m"); 1643 exit(1); 1644 } 1645 for (i = 0; i < nfss; i++) { 1646 fsp[i] = (struct clfs *)calloc(1, sizeof(**fsp)); 1647 if ((r = init_fs(fsp[i], argv[i])) < 0) { 1648 syslog(LOG_ERR, "%s: couldn't init: error code %d", 1649 argv[i], r); 1650 handle_error(fsp, i); 1651 --i; /* Do the new #i over again */ 1652 } 1653 } 1654 1655 /* 1656 * If asked to coalesce, do so and exit. 1657 */ 1658 if (do_coalesce) { 1659 for (i = 0; i < nfss; i++) 1660 clean_all_inodes(fsp[i]); 1661 exit(0); 1662 } 1663 1664 /* 1665 * If asked to invalidate a segment, do that and exit. 1666 */ 1667 if (inval_segment >= 0) { 1668 invalidate_segment(fsp[0], inval_segment); 1669 exit(0); 1670 } 1671 1672 /* 1673 * Main cleaning loop. 1674 */ 1675 loopcount = 0; 1676 #ifdef LFS_CLEANER_AS_LIB 1677 if (semaddr) 1678 sem_post(semaddr); 1679 #endif 1680 error = 0; 1681 while (nfss > 0) { 1682 int cleaned_one; 1683 do { 1684 #ifdef USE_CLIENT_SERVER 1685 check_control_socket(); 1686 #endif 1687 cleaned_one = 0; 1688 for (i = 0; i < nfss; i++) { 1689 if ((error = needs_cleaning(fsp[i], &ci)) < 0) { 1690 syslog(LOG_DEBUG, "%s: needs_cleaning returned %d", 1691 getprogname(), error); 1692 handle_error(fsp, i); 1693 continue; 1694 } 1695 if (error == 0) /* No need to clean */ 1696 continue; 1697 1698 reload_ifile(fsp[i]); 1699 if ((error = clean_fs(fsp[i], &ci)) < 0) { 1700 syslog(LOG_DEBUG, "%s: clean_fs returned %d", 1701 getprogname(), error); 1702 handle_error(fsp, i); 1703 continue; 1704 } 1705 ++cleaned_one; 1706 } 1707 ++loopcount; 1708 if (stat_report && loopcount % stat_report == 0) 1709 sig_report(0); 1710 if (do_quit) 1711 exit(0); 1712 } while(cleaned_one); 1713 tv.tv_sec = segwait_timeout; 1714 tv.tv_usec = 0; 1715 /* XXX: why couldn't others work if fsp socket is shutdown? */ 1716 error = kops.ko_fcntl(fsp[0]->clfs_ifilefd,LFCNSEGWAITALL,&tv); 1717 if (error) { 1718 if (errno == ESHUTDOWN) { 1719 for (i = 0; i < nfss; i++) { 1720 syslog(LOG_INFO, "%s: shutdown", 1721 getprogname()); 1722 handle_error(fsp, i); 1723 assert(nfss == 0); 1724 } 1725 } else { 1726 #ifdef LFS_CLEANER_AS_LIB 1727 error = ESHUTDOWN; 1728 break; 1729 #else 1730 err(1, "LFCNSEGWAITALL"); 1731 #endif 1732 } 1733 } 1734 } 1735 1736 /* NOTREACHED */ 1737 return error; 1738 } 1739
Indexes created Sun Sep 21 16:09:51 GMT 2025