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 * $DragonFly: src/sbin/hammer/cmd_softprune.c,v 1.7 2008/08/21 23:28:43 thomas Exp $ 35 */ 36 37 #include "hammer.h" 38 39 struct softprune { 40 struct softprune *next; 41 struct statfs fs; 42 char *filesystem; 43 struct hammer_ioc_prune prune; 44 int maxelms; 45 int prune_min; 46 }; 47 48 static void softprune_usage(int code); 49 static void hammer_softprune_scandir(struct softprune **basep, 50 struct hammer_ioc_prune *template, 51 const char *dirname); 52 static struct softprune *hammer_softprune_addentry(struct softprune **basep, 53 struct hammer_ioc_prune *template, 54 const char *dirpath, const char *denname, 55 struct stat *st, 56 const char *linkbuf, const char *tidptr); 57 static void hammer_softprune_finalize(struct softprune *scan); 58 59 /* 60 * prune <softlink-dir> 61 * prune-everything <filesystem> 62 */ 63 void 64 hammer_cmd_softprune(char **av, int ac, int everything_opt) 65 { 66 struct hammer_ioc_prune template; 67 struct hammer_ioc_pseudofs_rw pfs; 68 struct softprune *base, *scan; 69 int fd; 70 int rcode; 71 72 base = NULL; 73 rcode = 0; 74 if (TimeoutOpt > 0) 75 alarm(TimeoutOpt); 76 77 bzero(&pfs, sizeof(pfs)); 78 pfs.bytes = sizeof(*pfs.ondisk); 79 pfs.ondisk = malloc(pfs.bytes); 80 bzero(pfs.ondisk, pfs.bytes); 81 pfs.pfs_id = -1; 82 83 /* 84 * NOTE: To restrict to a single file XXX we have to set 85 * the localization the same (not yet implemented). Typically 86 * two passes would be needed, one using HAMMER_LOCALIZE_MISC 87 * and one using HAMMER_LOCALIZE_INODE. 88 */ 89 90 bzero(&template, sizeof(template)); 91 template.key_beg.localization = HAMMER_MIN_LOCALIZATION; 92 template.key_beg.obj_id = HAMMER_MIN_OBJID; 93 template.key_end.localization = HAMMER_MAX_LOCALIZATION; 94 template.key_end.obj_id = HAMMER_MAX_OBJID; 95 hammer_get_cycle(&template.key_end, NULL); 96 template.stat_oldest_tid = HAMMER_MAX_TID; 97 98 /* 99 * For now just allow one directory 100 */ 101 if (ac == 0 || ac > 1) 102 softprune_usage(1); 103 104 /* 105 * Scan the softlink directory. 106 */ 107 if (everything_opt) { 108 const char *dummylink = ""; 109 scan = hammer_softprune_addentry(&base, &template, 110 *av, NULL, NULL, 111 dummylink, dummylink); 112 if (scan == NULL) 113 softprune_usage(1); 114 scan->prune.nelms = 0; 115 scan->prune.head.flags |= HAMMER_IOC_PRUNE_ALL; 116 } else { 117 hammer_softprune_scandir(&base, &template, *av); 118 ++av; 119 --ac; 120 } 121 122 /* 123 * XXX future (need to store separate cycles for each filesystem) 124 */ 125 if (base == NULL) { 126 fprintf(stderr, "No snapshot softlinks found\n"); 127 exit(1); 128 } 129 if (base->next) { 130 fprintf(stderr, "Currently only one HAMMER filesystem may " 131 "be specified in the softlink scan\n"); 132 exit(1); 133 } 134 135 /* 136 * Issue the prunes 137 */ 138 for (scan = base; scan; scan = scan->next) { 139 /* 140 * Open the filesystem for ioctl calls and extract the 141 * PFS. 142 */ 143 fd = open(scan->filesystem, O_RDONLY); 144 if (fd < 0) { 145 warn("Unable to open %s", scan->filesystem); 146 rcode = 1; 147 continue; 148 } 149 150 if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) < 0) { 151 warn("Filesystem %s is not HAMMER", scan->filesystem); 152 rcode = 1; 153 close(fd); 154 continue; 155 } 156 scan->prune_min = pfs.ondisk->prune_min; 157 158 /* 159 * Finalize operations 160 */ 161 hammer_softprune_finalize(scan); 162 if (everything_opt) { 163 printf("Prune %s: EVERYTHING\n", 164 scan->filesystem); 165 } else { 166 printf("Prune %s: %d snapshots\n", 167 scan->filesystem, scan->prune.nelms); 168 } 169 if (scan->prune.nelms == 0 && 170 (scan->prune.head.flags & HAMMER_IOC_PRUNE_ALL) == 0) { 171 continue; 172 } 173 174 printf("Prune %s: objspace %016jx:%04x %016jx:%04x " 175 "pfs_id %d\n", 176 scan->filesystem, 177 (uintmax_t)scan->prune.key_beg.obj_id, 178 scan->prune.key_beg.localization, 179 (uintmax_t)scan->prune.key_end.obj_id, 180 scan->prune.key_end.localization, 181 pfs.pfs_id); 182 printf("Prune %s: prune_min is %dd/%02d:%02d:%02d\n", 183 scan->filesystem, 184 pfs.ondisk->prune_min / (24 * 60 * 60), 185 pfs.ondisk->prune_min / 60 / 60 % 24, 186 pfs.ondisk->prune_min / 60 % 60, 187 pfs.ondisk->prune_min % 60); 188 189 RunningIoctl = 1; 190 if (ioctl(fd, HAMMERIOC_PRUNE, &scan->prune) < 0) { 191 printf("Prune %s failed: %s\n", 192 scan->filesystem, strerror(errno)); 193 rcode = 2; 194 } else if (scan->prune.head.flags & HAMMER_IOC_HEAD_INTR) { 195 printf("Prune %s interrupted by timer at " 196 "%016jx %04x\n", 197 scan->filesystem, 198 (uintmax_t)scan->prune.key_cur.obj_id, 199 scan->prune.key_cur.localization); 200 if (CyclePath) 201 hammer_set_cycle(&scan->prune.key_cur, 0); 202 rcode = 0; 203 } else { 204 if (CyclePath) 205 hammer_reset_cycle(); 206 printf("Prune %s succeeded\n", scan->filesystem); 207 } 208 printf("Pruned %jd/%jd records (%jd directory entries) " 209 "and %jd bytes\n", 210 (uintmax_t)scan->prune.stat_rawrecords, 211 (uintmax_t)scan->prune.stat_scanrecords, 212 (uintmax_t)scan->prune.stat_dirrecords, 213 (uintmax_t)scan->prune.stat_bytes 214 ); 215 RunningIoctl = 0; 216 close(fd); 217 } 218 if (rcode) 219 exit(rcode); 220 } 221 222 /* 223 * Scan a directory for softlinks representing snapshots and build 224 * associated softprune structures. 225 */ 226 static void 227 hammer_softprune_scandir(struct softprune **basep, 228 struct hammer_ioc_prune *template, 229 const char *dirname) 230 { 231 struct stat st; 232 struct dirent *den; 233 DIR *dir; 234 char *path; 235 int len; 236 char *linkbuf; 237 char *ptr; 238 239 path = NULL; 240 linkbuf = malloc(MAXPATHLEN); 241 242 if ((dir = opendir(dirname)) == NULL) 243 err(1, "Cannot open directory %s", dirname); 244 while ((den = readdir(dir)) != NULL) { 245 if (strcmp(den->d_name, ".") == 0) 246 continue; 247 if (strcmp(den->d_name, "..") == 0) 248 continue; 249 if (path) 250 free(path); 251 asprintf(&path, "%s/%s", dirname, den->d_name); 252 if (lstat(path, &st) < 0) 253 continue; 254 if (!S_ISLNK(st.st_mode)) 255 continue; 256 if ((len = readlink(path, linkbuf, MAXPATHLEN - 1)) < 0) 257 continue; 258 linkbuf[len] = 0; 259 if ((ptr = strrchr(linkbuf, '@')) && 260 ptr > linkbuf && ptr[-1] == '@') { 261 hammer_softprune_addentry(basep, template, 262 dirname, den->d_name, &st, 263 linkbuf, ptr - 1); 264 } 265 } 266 free(linkbuf); 267 if (path) 268 free(path); 269 } 270 271 /* 272 * Add the softlink to the appropriate softprune structure, creating a new 273 * one if necessary. 274 */ 275 static 276 struct softprune * 277 hammer_softprune_addentry(struct softprune **basep, 278 struct hammer_ioc_prune *template, 279 const char *dirpath, const char *denname __unused, 280 struct stat *st, 281 const char *linkbuf, const char *tidptr) 282 { 283 struct hammer_ioc_prune_elm *elm; 284 struct softprune *scan; 285 struct statfs fs; 286 char *fspath; 287 288 /* 289 * Calculate filesystem path. 290 */ 291 if (linkbuf[0] == '/') { 292 asprintf(&fspath, "%*.*s", 293 (int)(tidptr - linkbuf), (int)(tidptr - linkbuf), 294 linkbuf); 295 } else { 296 asprintf(&fspath, "%s/%*.*s", dirpath, 297 (int)(tidptr - linkbuf), (int)(tidptr - linkbuf), 298 linkbuf); 299 } 300 if (statfs(fspath, &fs) < 0) { 301 free(fspath); 302 return(NULL); 303 } 304 305 /* 306 * Locate the filesystem in an existing softprune structure 307 */ 308 for (scan = *basep; scan; scan = scan->next) { 309 if (bcmp(&fs.f_fsid, &scan->fs.f_fsid, sizeof(fs.f_fsid)) != 0) 310 continue; 311 if (strcmp(fs.f_mntonname, scan->fs.f_mntonname) != 0) 312 continue; 313 break; 314 } 315 316 /* 317 * Create a new softprune structure if necessasry 318 */ 319 if (scan == NULL) { 320 scan = malloc(sizeof(*scan)); 321 bzero(scan, sizeof(*scan)); 322 323 scan->fs = fs; 324 scan->filesystem = fspath; 325 scan->prune = *template; 326 scan->maxelms = 32; 327 scan->prune.elms = malloc(sizeof(*elm) * scan->maxelms); 328 scan->next = *basep; 329 *basep = scan; 330 } else { 331 free(fspath); 332 } 333 334 /* 335 * Add the entry (unsorted). Just set the beg_tid, we will sort 336 * and set the remaining entries later. 337 * 338 * Always leave one entry free for our terminator. 339 */ 340 if (scan->prune.nelms >= scan->maxelms - 1) { 341 scan->maxelms = (scan->maxelms * 3 / 2); 342 scan->prune.elms = realloc(scan->prune.elms, 343 sizeof(*elm) * scan->maxelms); 344 } 345 346 /* 347 * NOTE: Temporarily store the snapshot timestamp in mod_tid. 348 * This will be cleaned up in the finalization phase. 349 */ 350 elm = &scan->prune.elms[scan->prune.nelms]; 351 elm->beg_tid = strtoull(tidptr + 2, NULL, 0); 352 elm->end_tid = 0; 353 elm->mod_tid = 0; 354 if (st) { 355 if (st->st_ctime < st->st_mtime) 356 elm->mod_tid = st->st_ctime; 357 else 358 elm->mod_tid = st->st_mtime; 359 } 360 ++scan->prune.nelms; 361 return(scan); 362 } 363 364 /* 365 * Finalize a softprune structure after scanning in its softlinks. 366 * Sort the elements, remove duplicates, and then fill in end_tid and 367 * mod_tid. 368 * 369 * The array must end up in descending order. 370 */ 371 static int 372 hammer_softprune_qsort_cmp(const void *arg1, const void *arg2) 373 { 374 const struct hammer_ioc_prune_elm *elm1 = arg1; 375 const struct hammer_ioc_prune_elm *elm2 = arg2; 376 377 if (elm1->beg_tid < elm2->beg_tid) 378 return(1); 379 if (elm1->beg_tid > elm2->beg_tid) 380 return(-1); 381 return(0); 382 } 383 384 static void 385 hammer_softprune_finalize(struct softprune *scan) 386 { 387 struct hammer_ioc_prune_elm *elm; 388 time_t t; 389 long delta; 390 int i; 391 392 /* 393 * Don't do anything if there are no elements. 394 */ 395 if (scan->prune.nelms == 0) 396 return; 397 398 /* 399 * Sort the elements in descending order, remove duplicates, and 400 * fill in any missing bits. 401 */ 402 qsort(scan->prune.elms, scan->prune.nelms, sizeof(*elm), 403 hammer_softprune_qsort_cmp); 404 405 for (i = 0; i < scan->prune.nelms; ++i) { 406 elm = &scan->prune.elms[i]; 407 if (i == 0) { 408 /* 409 * First (highest TID) (also last if only one element) 410 */ 411 elm->end_tid = HAMMER_MAX_TID; 412 } else if (elm[0].beg_tid == elm[-1].beg_tid) { 413 /* 414 * Remove duplicate 415 */ 416 --scan->prune.nelms; 417 if (i != scan->prune.nelms) { 418 bcopy(elm + 1, elm, 419 (scan->prune.nelms - i) * sizeof(*elm)); 420 } 421 --i; 422 continue; 423 } else { 424 /* 425 * Middle or last. 426 */ 427 elm->end_tid = elm[-1].beg_tid; 428 } 429 } 430 431 /* 432 * If a minimum retention time (in seconds) is configured for the 433 * PFS, remove any snapshots from the pruning list that are within 434 * the period. 435 */ 436 if (scan->prune_min) { 437 t = time(NULL); 438 for (i = scan->prune.nelms - 1; i >= 0; --i) { 439 elm = &scan->prune.elms[i]; 440 if (elm->mod_tid == 0) 441 continue; 442 delta = (long)(t - (time_t)elm->mod_tid); 443 if (delta < scan->prune_min) 444 break; 445 } 446 ++i; 447 if (i) { 448 printf("Prune %s: prune_min: Will not clean between " 449 "the teeth of the first %d snapshots\n", 450 scan->filesystem, i); 451 bcopy(&scan->prune.elms[i], &scan->prune.elms[0], 452 (scan->prune.nelms - i) * sizeof(scan->prune.elms[0])); 453 scan->prune.elms[0].end_tid = HAMMER_MAX_TID; 454 scan->prune.nelms -= i; 455 } 456 } 457 458 /* 459 * Remove the first entry. This entry represents the prune from 460 * the most recent snapshot to current. We wish to retain the 461 * fine-grained history for this region. 462 */ 463 if (scan->prune.nelms) { 464 bcopy(&scan->prune.elms[1], &scan->prune.elms[0], 465 (scan->prune.nelms - 1) * sizeof(scan->prune.elms[0])); 466 --scan->prune.nelms; 467 } 468 469 /* 470 * Add a final element to prune everything from transaction id 471 * 0 to the lowest transaction id (aka last so far). 472 */ 473 if (scan->prune.nelms) { 474 assert(scan->prune.nelms < scan->maxelms); 475 elm = &scan->prune.elms[scan->prune.nelms]; 476 elm->beg_tid = 1; 477 elm->end_tid = elm[-1].beg_tid; 478 ++scan->prune.nelms; 479 } 480 481 /* 482 * Adjust mod_tid to what the ioctl() expects. 483 */ 484 for (i = 0; i < scan->prune.nelms; ++i) { 485 elm = &scan->prune.elms[i]; 486 elm->mod_tid = elm->end_tid - elm->beg_tid; 487 printf("TID %016jx - %016jx\n", 488 (uintmax_t)elm->beg_tid, (uintmax_t)elm->end_tid); 489 } 490 } 491 492 static 493 void 494 softprune_usage(int code) 495 { 496 fprintf(stderr, "Badly formed prune command, use:\n"); 497 fprintf(stderr, "hammer prune <softlink-dir>\n"); 498 fprintf(stderr, "hammer prune-everything <filesystem>\n"); 499 exit(code); 500 } 501 502 503