1 /* 2 * Copyright (c) 2008 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 /* 35 * Clean up specific HAMMER filesystems or all HAMMER filesystems. 36 * 37 * If no filesystems are specified any HAMMER- or null-mounted hammer PFS's 38 * are cleaned. 39 * 40 * Each HAMMER filesystem may contain a configuration file. If no 41 * configuration file is present one will be created with the following 42 * defaults: 43 * 44 * snapshots 1d 60d (0d 0d for /tmp, /var/tmp, /usr/obj) 45 * prune 1d 5m 46 * rebalance 1d 5m 47 * #dedup 1d 5m (not enabled by default) 48 * reblock 1d 5m 49 * recopy 30d 10m 50 * 51 * All hammer commands create and maintain cycle files in the snapshots 52 * directory. 53 * 54 * For HAMMER version 2- the configuration file is a named 'config' in 55 * the snapshots directory, which defaults to <pfs>/snapshots. 56 * For HAMMER version 3+ the configuration file is saved in filesystem 57 * meta-data. The snapshots directory defaults to /var/hammer/<pfs> 58 * (/var/hammer/root for root mount). 59 */ 60 61 #include <libutil.h> 62 63 #include "hammer.h" 64 65 struct didpfs { 66 struct didpfs *next; 67 uuid_t uuid; 68 }; 69 70 static void do_cleanup(const char *path); 71 static void config_init(const char *path, struct hammer_ioc_config *config); 72 static void migrate_config(FILE *fp, struct hammer_ioc_config *config); 73 static void migrate_snapshots(int fd, const char *snapshots_path); 74 static void migrate_one_snapshot(int fd, const char *fpath, 75 struct hammer_ioc_snapshot *snapshot); 76 static int strtosecs(char *ptr); 77 static const char *dividing_slash(const char *path); 78 static int check_period(const char *snapshots_path, const char *cmd, int arg1, 79 time_t *savep); 80 static void save_period(const char *snapshots_path, const char *cmd, 81 time_t savet); 82 static int check_softlinks(int fd, int new_config, const char *snapshots_path); 83 static void cleanup_softlinks(int fd, int new_config, 84 const char *snapshots_path, int arg2, char *arg3); 85 static void delete_snapshots(int fd, struct hammer_ioc_snapshot *dsnapshot); 86 static int check_expired(const char *fpath, int arg2); 87 88 static int create_snapshot(const char *path, const char *snapshots_path); 89 static int cleanup_rebalance(const char *path, const char *snapshots_path, 90 int arg1, int arg2); 91 static int cleanup_prune(const char *path, const char *snapshots_path, 92 int arg1, int arg2, int snapshots_disabled); 93 static int cleanup_reblock(const char *path, const char *snapshots_path, 94 int arg1, int arg2); 95 static int cleanup_recopy(const char *path, const char *snapshots_path, 96 int arg1, int arg2); 97 static int cleanup_dedup(const char *path, const char *snapshots_path, 98 int arg1, int arg2); 99 100 static void runcmd(int *resp, const char *ctl, ...) __printflike(2, 3); 101 102 #define WS " \t\r\n" 103 104 struct didpfs *FirstPFS; 105 106 void 107 hammer_cmd_cleanup(char **av, int ac) 108 { 109 char *fstype, *fs, *path; 110 struct statfs *stfsbuf; 111 int mntsize, i; 112 113 tzset(); 114 if (ac == 0) { 115 mntsize = getmntinfo(&stfsbuf, MNT_NOWAIT); 116 if (mntsize > 0) { 117 for (i=0; i < mntsize; i++) { 118 /* 119 * We will cleanup in the case fstype is hammer. 120 * If we have null-mounted PFS, we check the 121 * mount source. If it looks like a PFS, we 122 * proceed to cleanup also. 123 */ 124 fstype = stfsbuf[i].f_fstypename; 125 fs = stfsbuf[i].f_mntfromname; 126 if ((strcmp(fstype, "hammer") == 0) || 127 ((strcmp(fstype, "null") == 0) && 128 (strstr(fs, "/@@0x") != NULL || 129 strstr(fs, "/@@-1") != NULL))) { 130 path = stfsbuf[i].f_mntonname; 131 do_cleanup(path); 132 } 133 } 134 } 135 } else { 136 while (ac) { 137 do_cleanup(*av); 138 --ac; 139 ++av; 140 } 141 } 142 } 143 144 static 145 void 146 do_cleanup(const char *path) 147 { 148 struct hammer_ioc_pseudofs_rw pfs; 149 struct hammer_ioc_config config; 150 struct hammer_ioc_version version; 151 union hammer_ioc_mrecord_any mrec_tmp; 152 char *snapshots_path = NULL; 153 char *config_path; 154 struct stat st; 155 char *cmd; 156 char *ptr; 157 int arg1; 158 int arg2; 159 char *arg3; 160 time_t savet; 161 char buf[256]; 162 char *cbase; 163 char *cptr; 164 FILE *fp = NULL; 165 struct didpfs *didpfs; 166 int snapshots_disabled = 0; 167 int prune_warning = 0; 168 int new_config = 0; 169 int snapshots_from_pfs = 0; 170 int fd; 171 int r; 172 int found_rebal = 0; 173 174 bzero(&mrec_tmp, sizeof(mrec_tmp)); 175 clrpfs(&pfs, &mrec_tmp.pfs.pfsd, -1); 176 177 printf("cleanup %-20s -", path); 178 fd = open(path, O_RDONLY); 179 if (fd < 0) { 180 printf(" unable to access directory: %s\n", strerror(errno)); 181 return; 182 } 183 if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) < 0) { 184 printf(" not a HAMMER filesystem: %s\n", strerror(errno)); 185 close(fd); 186 return; 187 } 188 if (pfs.version != HAMMER_IOC_PSEUDOFS_VERSION) { 189 printf(" unrecognized HAMMER version\n"); 190 close(fd); 191 return; 192 } 193 bzero(&version, sizeof(version)); 194 if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) < 0) { 195 printf(" HAMMER filesystem but couldn't retrieve version!\n"); 196 close(fd); 197 return; 198 } 199 HammerVersion = version.cur_version; 200 201 bzero(&config, sizeof(config)); 202 if (version.cur_version >= 3) { 203 if (ioctl(fd, HAMMERIOC_GET_CONFIG, &config) == 0 && 204 config.head.error == 0) { 205 new_config = 1; 206 } 207 } 208 209 /* 210 * Make sure we have not already handled this PFS. Several nullfs 211 * mounts might alias the same PFS. 212 */ 213 for (didpfs = FirstPFS; didpfs; didpfs = didpfs->next) { 214 if (bcmp(&didpfs->uuid, &mrec_tmp.pfs.pfsd.unique_uuid, sizeof(uuid_t)) == 0) { 215 printf(" PFS#%d already handled\n", pfs.pfs_id); 216 close(fd); 217 return; 218 } 219 } 220 didpfs = malloc(sizeof(*didpfs)); 221 didpfs->next = FirstPFS; 222 FirstPFS = didpfs; 223 didpfs->uuid = mrec_tmp.pfs.pfsd.unique_uuid; 224 225 /* 226 * Calculate the old snapshots directory for HAMMER VERSION < 3 227 * 228 * If the directory is explicitly specified in the PFS config 229 * we flag it and will not migrate it later. 230 */ 231 if (mrec_tmp.pfs.pfsd.snapshots[0] == '/') { 232 asprintf(&snapshots_path, "%s", mrec_tmp.pfs.pfsd.snapshots); 233 snapshots_from_pfs = 1; 234 } else if (mrec_tmp.pfs.pfsd.snapshots[0]) { 235 printf(" WARNING: pfs-slave's snapshots dir is not absolute\n"); 236 close(fd); 237 return; 238 } else if (hammer_is_pfs_slave(&mrec_tmp.pfs.pfsd)) { 239 if (version.cur_version < 3) { 240 printf(" WARNING: must configure snapshot dir for PFS slave\n"); 241 printf("\tWe suggest <fs>/var/slaves/<name> where " 242 "<fs> is the base HAMMER fs\n"); 243 printf("\tcontaining the slave\n"); 244 close(fd); 245 return; 246 } 247 } else { 248 asprintf(&snapshots_path, 249 "%s%ssnapshots", path, dividing_slash(path)); 250 } 251 252 /* 253 * Check for old-style config file 254 */ 255 if (snapshots_path) { 256 asprintf(&config_path, "%s/config", snapshots_path); 257 fp = fopen(config_path, "r"); 258 } 259 260 /* 261 * Handle upgrades to hammer version 3, move the config 262 * file into meta-data. 263 * 264 * For the old config read the file into the config structure, 265 * we will parse it out of the config structure regardless. 266 */ 267 if (version.cur_version >= 3) { 268 if (fp) { 269 printf("(migrating) "); 270 fflush(stdout); 271 migrate_config(fp, &config); 272 migrate_snapshots(fd, snapshots_path); 273 fclose(fp); 274 if (ioctl(fd, HAMMERIOC_SET_CONFIG, &config) < 0) { 275 printf(" cannot init meta-data config!\n"); 276 close(fd); 277 return; 278 } 279 remove(config_path); 280 } else if (new_config == 0) { 281 config_init(path, &config); 282 if (ioctl(fd, HAMMERIOC_SET_CONFIG, &config) < 0) { 283 printf(" cannot init meta-data config!\n"); 284 close(fd); 285 return; 286 } 287 } 288 new_config = 1; 289 } else { 290 /* 291 * Create missing snapshots directory for HAMMER VERSION < 3 292 */ 293 if (stat(snapshots_path, &st) < 0) { 294 if (mkdir(snapshots_path, 0755) != 0) { 295 free(snapshots_path); 296 printf(" unable to create snapshot dir \"%s\": %s\n", 297 snapshots_path, strerror(errno)); 298 close(fd); 299 return; 300 } 301 } 302 303 /* 304 * Create missing config file for HAMMER VERSION < 3 305 */ 306 if (fp == NULL) { 307 config_init(path, &config); 308 fp = fopen(config_path, "w"); 309 if (fp) { 310 fwrite(config.config.text, 1, 311 strlen(config.config.text), fp); 312 fclose(fp); 313 } 314 } else { 315 migrate_config(fp, &config); 316 fclose(fp); 317 } 318 } 319 320 /* 321 * If snapshots_from_pfs is not set we calculate the new snapshots 322 * directory default (in /var) for HAMMER VERSION >= 3 and migrate 323 * the old snapshots directory over. 324 * 325 * People who have set an explicit snapshots directory will have 326 * to migrate the data manually into /var/hammer, or not bother at 327 * all. People running slaves may wish to migrate it and then 328 * clear the snapshots specification in the PFS config for the 329 * slave. 330 */ 331 if (new_config && snapshots_from_pfs == 0) { 332 char *npath; 333 334 if (path[0] != '/') { 335 printf(" path must start with '/'\n"); 336 return; 337 } 338 if (strcmp(path, "/") == 0) 339 asprintf(&npath, "%s/root", SNAPSHOTS_BASE); 340 else 341 asprintf(&npath, "%s/%s", SNAPSHOTS_BASE, path + 1); 342 if (snapshots_path) { 343 if (stat(npath, &st) < 0 && errno == ENOENT) { 344 if (stat(snapshots_path, &st) < 0 && errno == ENOENT) { 345 printf(" HAMMER UPGRADE: Creating snapshots\n" 346 "\tCreating snapshots in %s\n", 347 npath); 348 runcmd(&r, "mkdir -p %s", npath); 349 } else { 350 printf(" HAMMER UPGRADE: Moving snapshots\n" 351 "\tMoving snapshots from %s to %s\n", 352 snapshots_path, npath); 353 runcmd(&r, "mkdir -p %s", npath); 354 runcmd(&r, "cpdup %s %s", snapshots_path, npath); 355 if (r != 0) { 356 printf("Unable to move snapshots directory!\n"); 357 printf("Please fix this critical error.\n"); 358 printf("Aborting cleanup of %s\n", path); 359 close(fd); 360 return; 361 } 362 runcmd(&r, "rm -rf %s", snapshots_path); 363 } 364 } 365 free(snapshots_path); 366 } else if (stat(npath, &st) < 0 && errno == ENOENT) { 367 runcmd(&r, "mkdir -p %s", npath); 368 } 369 snapshots_path = npath; 370 } 371 372 /* 373 * Lock the PFS. fd is the base directory of the mounted PFS. 374 */ 375 if (flock(fd, LOCK_EX|LOCK_NB) == -1) { 376 if (errno == EWOULDBLOCK) 377 printf(" PFS#%d locked by other process\n", pfs.pfs_id); 378 else 379 printf(" can not lock %s: %s\n", config_path, strerror(errno)); 380 close(fd); 381 return; 382 } 383 384 printf(" handle PFS#%d using %s\n", pfs.pfs_id, snapshots_path); 385 386 struct pidfh *pfh = NULL; 387 static char pidfile[PIDFILE_BUFSIZE]; 388 389 snprintf (pidfile, PIDFILE_BUFSIZE, "%s/hammer.cleanup.%d", 390 pidfile_loc, getpid()); 391 pfh = pidfile_open(pidfile, 0644, NULL); 392 if (pfh == NULL) 393 warn ("Unable to open or create %s", pidfile); 394 pidfile_write(pfh); 395 396 /* 397 * Process the config file 398 */ 399 cbase = config.config.text; 400 401 while ((cptr = strchr(cbase, '\n')) != NULL) { 402 bcopy(cbase, buf, cptr - cbase); 403 buf[cptr - cbase] = 0; 404 cbase = cptr + 1; 405 406 cmd = strtok(buf, WS); 407 if (cmd == NULL || cmd[0] == '#') 408 continue; 409 410 arg1 = 0; 411 arg2 = 0; 412 arg3 = NULL; 413 if ((ptr = strtok(NULL, WS)) != NULL) { 414 arg1 = strtosecs(ptr); 415 if ((ptr = strtok(NULL, WS)) != NULL) { 416 arg2 = strtosecs(ptr); 417 arg3 = strtok(NULL, WS); 418 } 419 } 420 421 printf("%20s - ", cmd); 422 fflush(stdout); 423 424 r = 1; 425 if (strcmp(cmd, "snapshots") == 0) { 426 if (arg1 == 0) { 427 if (arg2 && 428 check_softlinks(fd, new_config, 429 snapshots_path)) { 430 printf("only removing old snapshots\n"); 431 prune_warning = 1; 432 cleanup_softlinks(fd, new_config, 433 snapshots_path, 434 arg2, arg3); 435 } else { 436 printf("disabled\n"); 437 snapshots_disabled = 1; 438 } 439 } else 440 if (check_period(snapshots_path, cmd, arg1, &savet)) { 441 printf("run\n"); 442 cleanup_softlinks(fd, new_config, 443 snapshots_path, 444 arg2, arg3); 445 r = create_snapshot(path, snapshots_path); 446 } else { 447 printf("skip\n"); 448 } 449 } else if (arg1 == 0) { 450 /* 451 * The commands following this check can't handle 452 * a period of 0, so call the feature disabled and 453 * ignore the directive. 454 */ 455 printf("disabled\n"); 456 } else if (strcmp(cmd, "prune") == 0) { 457 if (check_period(snapshots_path, cmd, arg1, &savet)) { 458 if (prune_warning) { 459 printf("run - WARNING snapshot " 460 "softlinks present " 461 "but snapshots disabled\n"); 462 } else { 463 printf("run\n"); 464 } 465 r = cleanup_prune(path, snapshots_path, 466 arg1, arg2, snapshots_disabled); 467 } else { 468 printf("skip\n"); 469 } 470 } else if (strcmp(cmd, "rebalance") == 0) { 471 found_rebal = 1; 472 if (check_period(snapshots_path, cmd, arg1, &savet)) { 473 printf("run"); 474 fflush(stdout); 475 if (VerboseOpt) 476 printf("\n"); 477 r = cleanup_rebalance(path, snapshots_path, 478 arg1, arg2); 479 } else { 480 printf("skip\n"); 481 } 482 } else if (strcmp(cmd, "reblock") == 0) { 483 if (check_period(snapshots_path, cmd, arg1, &savet)) { 484 printf("run"); 485 fflush(stdout); 486 if (VerboseOpt) 487 printf("\n"); 488 r = cleanup_reblock(path, snapshots_path, 489 arg1, arg2); 490 } else { 491 printf("skip\n"); 492 } 493 } else if (strcmp(cmd, "recopy") == 0) { 494 if (check_period(snapshots_path, cmd, arg1, &savet)) { 495 printf("run"); 496 fflush(stdout); 497 if (VerboseOpt) 498 printf("\n"); 499 r = cleanup_recopy(path, snapshots_path, 500 arg1, arg2); 501 } else { 502 printf("skip\n"); 503 } 504 } else if (strcmp(cmd, "dedup") == 0) { 505 if (check_period(snapshots_path, cmd, arg1, &savet)) { 506 printf("run"); 507 fflush(stdout); 508 if (VerboseOpt) 509 printf("\n"); 510 r = cleanup_dedup(path, snapshots_path, 511 arg1, arg2); 512 } else { 513 printf("skip\n"); 514 } 515 } else { 516 printf("unknown directive\n"); 517 r = 1; 518 } 519 if (r == 0) 520 save_period(snapshots_path, cmd, savet); 521 } 522 523 /* 524 * Add new rebalance feature if the config doesn't have it. 525 * (old style config only). 526 */ 527 if (new_config == 0 && found_rebal == 0) { 528 if ((fp = fopen(config_path, "r+")) != NULL) { 529 fseek(fp, 0L, 2); 530 fprintf(fp, "rebalance 1d 5m\n"); 531 fclose(fp); 532 } 533 } 534 535 /* 536 * Cleanup, and delay a little 537 */ 538 close(fd); 539 usleep(1000); 540 pidfile_close(pfh); 541 pidfile_remove(pfh); 542 } 543 544 /* 545 * Initialize new config data (new or old style) 546 */ 547 static 548 void 549 config_init(const char *path, struct hammer_ioc_config *config) 550 { 551 const char *snapshots; 552 553 if (strcmp(path, "/tmp") == 0 || 554 strcmp(path, "/var/tmp") == 0 || 555 strcmp(path, "/usr/obj") == 0) { 556 snapshots = "snapshots 0d 0d\n"; 557 } else { 558 snapshots = "snapshots 1d 60d\n"; 559 } 560 bzero(config->config.text, sizeof(config->config.text)); 561 snprintf(config->config.text, sizeof(config->config.text) - 1, "%s%s", 562 snapshots, 563 "prune 1d 5m\n" 564 "rebalance 1d 5m\n" 565 "#dedup 1d 5m\n" 566 "reblock 1d 5m\n" 567 "recopy 30d 10m\n"); 568 } 569 570 /* 571 * Migrate configuration data from the old snapshots/config 572 * file to the new meta-data format. 573 */ 574 static 575 void 576 migrate_config(FILE *fp, struct hammer_ioc_config *config) 577 { 578 int n; 579 580 n = fread(config->config.text, 1, sizeof(config->config.text) - 1, fp); 581 if (n >= 0) 582 bzero(config->config.text + n, sizeof(config->config.text) - n); 583 } 584 585 /* 586 * Migrate snapshot softlinks in the snapshots directory to the 587 * new meta-data format. The softlinks are left intact, but 588 * this way the pruning code won't lose track of them if you 589 * happen to blow away the snapshots directory. 590 */ 591 static 592 void 593 migrate_snapshots(int fd, const char *snapshots_path) 594 { 595 struct hammer_ioc_snapshot snapshot; 596 struct dirent *den; 597 struct stat st; 598 DIR *dir; 599 char *fpath; 600 601 bzero(&snapshot, sizeof(snapshot)); 602 603 if ((dir = opendir(snapshots_path)) != NULL) { 604 while ((den = readdir(dir)) != NULL) { 605 if (den->d_name[0] == '.') 606 continue; 607 asprintf(&fpath, "%s/%s", snapshots_path, den->d_name); 608 if (lstat(fpath, &st) == 0 && S_ISLNK(st.st_mode)) 609 migrate_one_snapshot(fd, fpath, &snapshot); 610 free(fpath); 611 } 612 closedir(dir); 613 } 614 migrate_one_snapshot(fd, NULL, &snapshot); 615 616 } 617 618 /* 619 * Migrate a single snapshot. If fpath is NULL the ioctl is flushed, 620 * otherwise it is flushed when it fills up. 621 */ 622 static 623 void 624 migrate_one_snapshot(int fd, const char *fpath, 625 struct hammer_ioc_snapshot *snapshot) 626 { 627 if (fpath) { 628 hammer_snapshot_data_t snap; 629 struct tm tm; 630 time_t t; 631 int year; 632 int month; 633 int day = 0; 634 int hour = 0; 635 int minute = 0; 636 int r; 637 char linkbuf[1024]; 638 const char *ptr; 639 hammer_tid_t tid; 640 641 t = (time_t)-1; 642 tid = (hammer_tid_t)(int64_t)-1; 643 644 /* fpath may contain directory components */ 645 if ((ptr = strrchr(fpath, '/')) != NULL) 646 ++ptr; 647 else 648 ptr = fpath; 649 while (*ptr && *ptr != '-' && *ptr != '.') 650 ++ptr; 651 if (*ptr) 652 ++ptr; 653 r = sscanf(ptr, "%4d%2d%2d-%2d%2d", 654 &year, &month, &day, &hour, &minute); 655 656 if (r >= 3) { 657 bzero(&tm, sizeof(tm)); 658 tm.tm_isdst = -1; 659 tm.tm_min = minute; 660 tm.tm_hour = hour; 661 tm.tm_mday = day; 662 tm.tm_mon = month - 1; 663 tm.tm_year = year - 1900; 664 t = mktime(&tm); 665 } 666 bzero(linkbuf, sizeof(linkbuf)); 667 if (readlink(fpath, linkbuf, sizeof(linkbuf) - 1) > 0 && 668 (ptr = strrchr(linkbuf, '@')) != NULL && 669 ptr > linkbuf && ptr[-1] == '@') { 670 tid = strtoull(ptr + 1, NULL, 16); 671 } 672 if (t != (time_t)-1 && tid != (hammer_tid_t)(int64_t)-1) { 673 snap = &snapshot->snaps[snapshot->count]; 674 bzero(snap, sizeof(*snap)); 675 snap->tid = tid; 676 snap->ts = (uint64_t)t * 1000000ULL; 677 snprintf(snap->label, sizeof(snap->label), 678 "migrated"); 679 ++snapshot->count; 680 } else { 681 printf(" non-canonical snapshot softlink: %s->%s\n", 682 fpath, linkbuf); 683 } 684 } 685 686 if ((fpath == NULL && snapshot->count) || 687 snapshot->count == HAMMER_SNAPS_PER_IOCTL) { 688 printf(" (%d snapshots)", snapshot->count); 689 again: 690 if (ioctl(fd, HAMMERIOC_ADD_SNAPSHOT, snapshot) < 0) { 691 printf(" Ioctl to migrate snapshots failed: %s\n", 692 strerror(errno)); 693 } else if (snapshot->head.error == EALREADY) { 694 ++snapshot->index; 695 goto again; 696 } else if (snapshot->head.error) { 697 printf(" Ioctl to migrate snapshots failed: %s\n", 698 strerror(snapshot->head.error)); 699 } 700 printf("index %d\n", snapshot->index); 701 snapshot->index = 0; 702 snapshot->count = 0; 703 snapshot->head.error = 0; 704 } 705 } 706 707 static 708 int 709 strtosecs(char *ptr) 710 { 711 int val; 712 713 val = strtol(ptr, &ptr, 0); 714 switch(*ptr) { 715 case 'd': 716 val *= 24; 717 /* fall through */ 718 case 'h': 719 val *= 60; 720 /* fall through */ 721 case 'm': 722 val *= 60; 723 /* fall through */ 724 case 's': 725 break; 726 default: 727 errx(1, "illegal suffix converting %s", ptr); 728 /* not reached */ 729 break; 730 } 731 return(val); 732 } 733 734 static 735 const char * 736 dividing_slash(const char *path) 737 { 738 int len = strlen(path); 739 if (len && path[len-1] == '/') 740 return(""); 741 else 742 return("/"); 743 } 744 745 /* 746 * Check whether the desired period has elapsed since the last successful 747 * run. The run may take a while and cross a boundary so we remember the 748 * current time_t so we can save it later on. 749 * 750 * Periods in minutes, hours, or days are assumed to have been crossed 751 * if the local time crosses a minute, hour, or day boundary regardless 752 * of how close the last operation actually was. 753 * 754 * If ForceOpt is set always return true. 755 */ 756 static 757 int 758 check_period(const char *snapshots_path, const char *cmd, int arg1, 759 time_t *savep) 760 { 761 char *check_path; 762 struct tm tp1; 763 struct tm tp2; 764 FILE *fp; 765 time_t baset, lastt; 766 char buf[256]; 767 768 time(savep); 769 localtime_r(savep, &tp1); 770 771 /* 772 * Force run if -F 773 */ 774 if (ForceOpt) 775 return(1); 776 777 /* 778 * Retrieve the start time of the last successful operation. 779 */ 780 asprintf(&check_path, "%s/.%s.period", snapshots_path, cmd); 781 fp = fopen(check_path, "r"); 782 free(check_path); 783 if (fp == NULL) 784 return(1); 785 if (fgets(buf, sizeof(buf), fp) == NULL) { 786 fclose(fp); 787 return(1); 788 } 789 fclose(fp); 790 791 lastt = strtol(buf, NULL, 0); 792 localtime_r(&lastt, &tp2); 793 794 /* 795 * Normalize the times. e.g. if asked to do something on a 1-day 796 * interval the operation will be performed as soon as the day 797 * turns over relative to the previous operation, even if the previous 798 * operation ran a few seconds ago just before midnight. 799 */ 800 if (arg1 % 60 == 0) { 801 tp1.tm_sec = 0; 802 tp2.tm_sec = 0; 803 } 804 if (arg1 % (60 * 60) == 0) { 805 tp1.tm_min = 0; 806 tp2.tm_min = 0; 807 } 808 if (arg1 % (24 * 60 * 60) == 0) { 809 tp1.tm_hour = 0; 810 tp2.tm_hour = 0; 811 } 812 813 baset = mktime(&tp1); 814 lastt = mktime(&tp2); 815 816 #if 0 817 printf("%lld vs %lld\n", (long long)(baset - lastt), (long long)arg1); 818 #endif 819 820 if ((int)(baset - lastt) >= arg1) 821 return(1); 822 return(0); 823 } 824 825 /* 826 * Store the start time of the last successful operation. 827 */ 828 static 829 void 830 save_period(const char *snapshots_path, const char *cmd, 831 time_t savet) 832 { 833 char *ocheck_path; 834 char *ncheck_path; 835 FILE *fp; 836 837 asprintf(&ocheck_path, "%s/.%s.period", snapshots_path, cmd); 838 asprintf(&ncheck_path, "%s/.%s.period.new", snapshots_path, cmd); 839 fp = fopen(ncheck_path, "w"); 840 if (fp) { 841 fprintf(fp, "0x%08llx\n", (long long)savet); 842 if (fclose(fp) == 0) 843 rename(ncheck_path, ocheck_path); 844 remove(ncheck_path); 845 } else { 846 fprintf(stderr, "hammer: Unable to create period-file %s: %s\n", 847 ncheck_path, strerror(errno)); 848 } 849 } 850 851 /* 852 * Simply count the number of softlinks in the snapshots dir 853 */ 854 static 855 int 856 check_softlinks(int fd, int new_config, const char *snapshots_path) 857 { 858 struct dirent *den; 859 struct stat st; 860 DIR *dir; 861 char *fpath; 862 int res = 0; 863 864 /* 865 * Old-style softlink-based snapshots 866 */ 867 if ((dir = opendir(snapshots_path)) != NULL) { 868 while ((den = readdir(dir)) != NULL) { 869 if (den->d_name[0] == '.') 870 continue; 871 asprintf(&fpath, "%s/%s", snapshots_path, den->d_name); 872 if (lstat(fpath, &st) == 0 && S_ISLNK(st.st_mode)) 873 ++res; 874 free(fpath); 875 } 876 closedir(dir); 877 } 878 879 /* 880 * New-style snapshots are stored as filesystem meta-data, 881 * count those too. 882 */ 883 if (new_config) { 884 struct hammer_ioc_snapshot snapshot; 885 886 bzero(&snapshot, sizeof(snapshot)); 887 do { 888 if (ioctl(fd, HAMMERIOC_GET_SNAPSHOT, &snapshot) < 0) { 889 err(2, "hammer cleanup: check_softlink " 890 "snapshot error"); 891 /* not reached */ 892 } 893 res += snapshot.count; 894 } while (snapshot.head.error == 0 && snapshot.count); 895 } 896 return (res); 897 } 898 899 /* 900 * Clean up expired softlinks in the snapshots dir 901 */ 902 static 903 void 904 cleanup_softlinks(int fd, int new_config, 905 const char *snapshots_path, int arg2, char *arg3) 906 { 907 struct dirent *den; 908 struct stat st; 909 DIR *dir; 910 char *fpath; 911 int anylink = 0; 912 913 if (arg3 != NULL && strstr(arg3, "any") != NULL) 914 anylink = 1; 915 916 if ((dir = opendir(snapshots_path)) != NULL) { 917 while ((den = readdir(dir)) != NULL) { 918 if (den->d_name[0] == '.') 919 continue; 920 asprintf(&fpath, "%s/%s", snapshots_path, den->d_name); 921 if (lstat(fpath, &st) == 0 && S_ISLNK(st.st_mode) && 922 (anylink || strncmp(den->d_name, "snap-", 5) == 0)) { 923 if (check_expired(den->d_name, arg2)) { 924 if (VerboseOpt) { 925 printf(" expire %s\n", 926 fpath); 927 } 928 remove(fpath); 929 } 930 } 931 free(fpath); 932 } 933 closedir(dir); 934 } 935 936 /* 937 * New-style snapshots are stored as filesystem meta-data, 938 * count those too. 939 */ 940 if (new_config) { 941 struct hammer_ioc_snapshot snapshot; 942 struct hammer_ioc_snapshot dsnapshot; 943 hammer_snapshot_data_t snap; 944 struct tm *tp; 945 time_t t; 946 time_t dt; 947 char snapts[32]; 948 uint32_t i; 949 950 bzero(&snapshot, sizeof(snapshot)); 951 bzero(&dsnapshot, sizeof(dsnapshot)); 952 do { 953 if (ioctl(fd, HAMMERIOC_GET_SNAPSHOT, &snapshot) < 0) { 954 err(2, "hammer cleanup: check_softlink " 955 "snapshot error"); 956 /* not reached */ 957 } 958 for (i = 0; i < snapshot.count; ++i) { 959 snap = &snapshot.snaps[i]; 960 t = snap->ts / 1000000ULL; 961 dt = time(NULL) - t; 962 if ((int)dt > arg2 || snap->tid == 0) { 963 dsnapshot.snaps[dsnapshot.count++] = 964 *snap; 965 } 966 if ((int)dt > arg2 && VerboseOpt) { 967 tp = localtime(&t); 968 strftime(snapts, sizeof(snapts), 969 "%Y-%m-%d %H:%M:%S %Z", tp); 970 printf(" expire 0x%016jx %s %s\n", 971 (uintmax_t)snap->tid, 972 snapts, 973 snap->label); 974 } 975 if (dsnapshot.count == HAMMER_SNAPS_PER_IOCTL) 976 delete_snapshots(fd, &dsnapshot); 977 } 978 } while (snapshot.head.error == 0 && snapshot.count); 979 980 if (dsnapshot.count) 981 delete_snapshots(fd, &dsnapshot); 982 } 983 } 984 985 static 986 void 987 delete_snapshots(int fd, struct hammer_ioc_snapshot *dsnapshot) 988 { 989 for (;;) { 990 if (ioctl(fd, HAMMERIOC_DEL_SNAPSHOT, dsnapshot) < 0) { 991 printf(" Ioctl to delete snapshots failed: %s\n", 992 strerror(errno)); 993 break; 994 } 995 if (dsnapshot->head.error) { 996 printf(" Ioctl to delete snapshots failed at " 997 "snap=%016jx: %s\n", 998 dsnapshot->snaps[dsnapshot->index].tid, 999 strerror(dsnapshot->head.error)); 1000 if (++dsnapshot->index < dsnapshot->count) 1001 continue; 1002 } 1003 break; 1004 } 1005 dsnapshot->index = 0; 1006 dsnapshot->count = 0; 1007 dsnapshot->head.error = 0; 1008 } 1009 1010 /* 1011 * Take a softlink path in the form snap-yyyymmdd-hhmm and the 1012 * expiration in seconds (arg2) and return non-zero if the softlink 1013 * has expired. 1014 */ 1015 static 1016 int 1017 check_expired(const char *fpath, int arg2) 1018 { 1019 struct tm tm; 1020 time_t t; 1021 int year; 1022 int month; 1023 int day = 0; 1024 int hour = 0; 1025 int minute = 0; 1026 int r; 1027 1028 while (*fpath && *fpath != '-' && *fpath != '.') 1029 ++fpath; 1030 if (*fpath) 1031 ++fpath; 1032 1033 r = sscanf(fpath, "%4d%2d%2d-%2d%2d", 1034 &year, &month, &day, &hour, &minute); 1035 1036 if (r >= 3) { 1037 bzero(&tm, sizeof(tm)); 1038 tm.tm_isdst = -1; 1039 tm.tm_min = minute; 1040 tm.tm_hour = hour; 1041 tm.tm_mday = day; 1042 tm.tm_mon = month - 1; 1043 tm.tm_year = year - 1900; 1044 t = mktime(&tm); 1045 if (t == (time_t)-1) 1046 return(0); 1047 t = time(NULL) - t; 1048 if ((int)t > arg2) 1049 return(1); 1050 } 1051 return(0); 1052 } 1053 1054 /* 1055 * Issue a snapshot. 1056 */ 1057 static 1058 int 1059 create_snapshot(const char *path, const char *snapshots_path) 1060 { 1061 int r; 1062 1063 runcmd(&r, "hammer snapshot %s %s", path, snapshots_path); 1064 return(r); 1065 } 1066 1067 static 1068 int 1069 cleanup_prune(const char *path, const char *snapshots_path, 1070 int arg1 __unused, int arg2, int snapshots_disabled) 1071 { 1072 const char *path_or_snapshots_path; 1073 1074 /* 1075 * If the snapshots_path (e.g. /var/hammer/...) has no snapshots 1076 * in it then prune will get confused and prune the filesystem 1077 * containing the snapshots_path instead of the requested 1078 * filesystem. De-confuse prune. We need a better way. 1079 */ 1080 if (hammer_softprune_testdir(snapshots_path)) 1081 path_or_snapshots_path = snapshots_path; 1082 else 1083 path_or_snapshots_path = path; 1084 1085 /* 1086 * If snapshots have been disabled run prune-everything instead 1087 * of prune. 1088 */ 1089 if (snapshots_disabled && arg2) { 1090 runcmd(NULL, 1091 "hammer -c %s/.prune.cycle -t %d prune-everything %s", 1092 snapshots_path, arg2, path); 1093 } else if (snapshots_disabled) { 1094 runcmd(NULL, "hammer prune-everything %s", path); 1095 } else if (arg2) { 1096 runcmd(NULL, "hammer -c %s/.prune.cycle -t %d prune %s", 1097 snapshots_path, arg2, path_or_snapshots_path); 1098 } else { 1099 runcmd(NULL, "hammer prune %s", path_or_snapshots_path); 1100 } 1101 return(0); 1102 } 1103 1104 static 1105 int 1106 cleanup_rebalance(const char *path, const char *snapshots_path, 1107 int arg1 __unused, int arg2) 1108 { 1109 if (VerboseOpt == 0) { 1110 printf("."); 1111 fflush(stdout); 1112 } 1113 1114 runcmd(NULL, 1115 "hammer -c %s/.rebalance.cycle -t %d rebalance %s", 1116 snapshots_path, arg2, path); 1117 if (VerboseOpt == 0) { 1118 printf("."); 1119 fflush(stdout); 1120 } 1121 if (VerboseOpt == 0) 1122 printf("\n"); 1123 return(0); 1124 } 1125 1126 static 1127 int 1128 cleanup_reblock(const char *path, const char *snapshots_path, 1129 int arg1 __unused, int arg2) 1130 { 1131 if (VerboseOpt == 0) { 1132 printf("."); 1133 fflush(stdout); 1134 } 1135 1136 /* 1137 * When reblocking the B-Tree always reblock everything in normal 1138 * mode. 1139 */ 1140 runcmd(NULL, 1141 "hammer -c %s/.reblock-1.cycle -t %d reblock-btree %s", 1142 snapshots_path, arg2, path); 1143 if (VerboseOpt == 0) { 1144 printf("."); 1145 fflush(stdout); 1146 } 1147 1148 /* 1149 * When reblocking the inodes always reblock everything in normal 1150 * mode. 1151 */ 1152 runcmd(NULL, 1153 "hammer -c %s/.reblock-2.cycle -t %d reblock-inodes %s", 1154 snapshots_path, arg2, path); 1155 if (VerboseOpt == 0) { 1156 printf("."); 1157 fflush(stdout); 1158 } 1159 1160 /* 1161 * When reblocking the directories always reblock everything in normal 1162 * mode. 1163 */ 1164 runcmd(NULL, 1165 "hammer -c %s/.reblock-4.cycle -t %d reblock-dirs %s", 1166 snapshots_path, arg2, path); 1167 if (VerboseOpt == 0) { 1168 printf("."); 1169 fflush(stdout); 1170 } 1171 1172 /* 1173 * Do not reblock all the data in normal mode. 1174 */ 1175 runcmd(NULL, 1176 "hammer -c %s/.reblock-3.cycle -t %d reblock-data %s 95", 1177 snapshots_path, arg2, path); 1178 if (VerboseOpt == 0) 1179 printf("\n"); 1180 return(0); 1181 } 1182 1183 static 1184 int 1185 cleanup_recopy(const char *path, const char *snapshots_path, 1186 int arg1 __unused, int arg2) 1187 { 1188 if (VerboseOpt == 0) { 1189 printf("."); 1190 fflush(stdout); 1191 } 1192 runcmd(NULL, 1193 "hammer -c %s/.recopy-1.cycle -t %d reblock-btree %s", 1194 snapshots_path, arg2, path); 1195 if (VerboseOpt == 0) { 1196 printf("."); 1197 fflush(stdout); 1198 } 1199 runcmd(NULL, 1200 "hammer -c %s/.recopy-2.cycle -t %d reblock-inodes %s", 1201 snapshots_path, arg2, path); 1202 if (VerboseOpt == 0) { 1203 printf("."); 1204 fflush(stdout); 1205 } 1206 runcmd(NULL, 1207 "hammer -c %s/.recopy-4.cycle -t %d reblock-dirs %s", 1208 snapshots_path, arg2, path); 1209 if (VerboseOpt == 0) { 1210 printf("."); 1211 fflush(stdout); 1212 } 1213 runcmd(NULL, 1214 "hammer -c %s/.recopy-3.cycle -t %d reblock-data %s", 1215 snapshots_path, arg2, path); 1216 if (VerboseOpt == 0) 1217 printf("\n"); 1218 return(0); 1219 } 1220 1221 static 1222 int 1223 cleanup_dedup(const char *path, const char *snapshots_path __unused, 1224 int arg1 __unused, int arg2) 1225 { 1226 if (VerboseOpt == 0) { 1227 printf("."); 1228 fflush(stdout); 1229 } 1230 1231 runcmd(NULL, "hammer -t %d dedup %s", arg2, path); 1232 if (VerboseOpt == 0) { 1233 printf("."); 1234 fflush(stdout); 1235 } 1236 if (VerboseOpt == 0) 1237 printf("\n"); 1238 return(0); 1239 } 1240 1241 static 1242 void 1243 runcmd(int *resp, const char *ctl, ...) 1244 { 1245 va_list va; 1246 char *cmd; 1247 char *arg; 1248 char **av; 1249 int n; 1250 int nmax; 1251 int res; 1252 pid_t pid; 1253 1254 /* 1255 * Generate the command 1256 */ 1257 va_start(va, ctl); 1258 vasprintf(&cmd, ctl, va); 1259 va_end(va); 1260 if (VerboseOpt) 1261 printf(" %s\n", cmd); 1262 1263 /* 1264 * Break us down into arguments. We do not just use system() here 1265 * because it blocks SIGINT and friends. 1266 */ 1267 n = 0; 1268 nmax = 16; 1269 av = malloc(sizeof(char *) * nmax); 1270 1271 for (arg = strtok(cmd, WS); arg; arg = strtok(NULL, WS)) { 1272 if (n == nmax - 1) { 1273 nmax += 16; 1274 av = realloc(av, sizeof(char *) * nmax); 1275 } 1276 av[n++] = arg; 1277 } 1278 av[n++] = NULL; 1279 1280 /* 1281 * Run the command. 1282 */ 1283 RunningIoctl = 1; 1284 if ((pid = fork()) == 0) { 1285 if (VerboseOpt < 2) { 1286 int fd = open("/dev/null", O_RDWR); 1287 dup2(fd, 1); 1288 close(fd); 1289 } 1290 execvp(av[0], av); 1291 _exit(127); 1292 } else if (pid < 0) { 1293 res = 127; 1294 } else { 1295 int status; 1296 1297 while (waitpid(pid, &status, 0) != pid) 1298 ; 1299 res = WEXITSTATUS(status); 1300 } 1301 RunningIoctl = 0; 1302 if (DidInterrupt) 1303 _exit(1); 1304 1305 free(cmd); 1306 free(av); 1307 if (resp) 1308 *resp = res; 1309 } 1310