1 /* 2 * Copyright (c) 2010 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 #include "hammer.h" 36 37 struct recover_dict { 38 struct recover_dict *next; 39 struct recover_dict *parent; 40 int64_t obj_id; 41 uint8_t obj_type; 42 uint8_t flags; 43 uint16_t pfs_id; 44 int64_t size; 45 char *name; 46 }; 47 48 #define DICTF_MADEDIR 0x01 49 #define DICTF_MADEFILE 0x02 50 #define DICTF_PARENT 0x04 /* parent attached for real */ 51 #define DICTF_TRAVERSED 0x80 52 53 static void recover_top(char *ptr); 54 static void recover_elm(hammer_btree_leaf_elm_t leaf); 55 static struct recover_dict *get_dict(int64_t obj_id, uint16_t pfs_id); 56 static char *recover_path(struct recover_dict *dict); 57 static void sanitize_string(char *str); 58 59 static const char *TargetDir; 60 static int CachedFd = -1; 61 static char *CachedPath; 62 63 void 64 hammer_cmd_recover(const char *target_dir) 65 { 66 struct buffer_info *data_buffer; 67 struct volume_info *scan; 68 struct volume_info *volume; 69 hammer_off_t off; 70 hammer_off_t off_end; 71 char *ptr; 72 73 AssertOnFailure = 0; 74 TargetDir = target_dir; 75 76 printf("Running raw scan of HAMMER image, recovering to %s\n", 77 TargetDir); 78 mkdir(TargetDir, 0777); 79 80 data_buffer = NULL; 81 TAILQ_FOREACH(scan, &VolList, entry) { 82 volume = get_volume(scan->vol_no); 83 84 off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0); 85 off_end = off + (volume->ondisk->vol_buf_end - volume->ondisk->vol_buf_beg); 86 while (off < off_end) { 87 ptr = get_buffer_data(off, &data_buffer, 0); 88 if (ptr) { 89 recover_top(ptr); 90 off += HAMMER_BUFSIZE; 91 } 92 } 93 } 94 rel_buffer(data_buffer); 95 96 if (CachedPath) { 97 free(CachedPath); 98 close(CachedFd); 99 CachedPath = NULL; 100 CachedFd = -1; 101 } 102 103 AssertOnFailure = 1; 104 } 105 106 /* 107 * Top level recovery processor. Assume the data is a B-Tree node. 108 * If the CRC is good we attempt to process the node, building the 109 * object space and creating the dictionary as we go. 110 */ 111 static void 112 recover_top(char *ptr) 113 { 114 struct hammer_node_ondisk *node; 115 hammer_btree_elm_t elm; 116 int maxcount; 117 int i; 118 119 for (node = (void *)ptr; (char *)node < ptr + HAMMER_BUFSIZE; ++node) { 120 if (crc32(&node->crc + 1, HAMMER_BTREE_CRCSIZE) == 121 node->crc && 122 node->type == HAMMER_BTREE_TYPE_LEAF) { 123 /* 124 * Scan elements 125 */ 126 maxcount = HAMMER_BTREE_LEAF_ELMS; 127 for (i = 0; i < node->count && i < maxcount; ++i) { 128 elm = &node->elms[i]; 129 if (elm->base.btype != 'R') 130 continue; 131 recover_elm(&elm->leaf); 132 } 133 } 134 } 135 } 136 137 static void 138 recover_elm(hammer_btree_leaf_elm_t leaf) 139 { 140 struct buffer_info *data_buffer = NULL; 141 struct recover_dict *dict; 142 struct recover_dict *dict2; 143 hammer_data_ondisk_t ondisk; 144 hammer_off_t data_offset; 145 struct stat st; 146 int chunk; 147 int len; 148 int zfill; 149 int64_t file_offset; 150 uint16_t pfs_id; 151 size_t nlen; 152 int fd; 153 char *name; 154 char *path1; 155 char *path2; 156 157 /* 158 * Ignore deleted records 159 */ 160 if (leaf->delete_ts) 161 return; 162 if ((data_offset = leaf->data_offset) != 0) 163 ondisk = get_buffer_data(data_offset, &data_buffer, 0); 164 else 165 ondisk = NULL; 166 if (ondisk == NULL) 167 goto done; 168 169 len = leaf->data_len; 170 chunk = HAMMER_BUFSIZE - ((int)data_offset & HAMMER_BUFMASK); 171 if (chunk > len) 172 chunk = len; 173 174 if (len < 0 || len > HAMMER_XBUFSIZE || len > chunk) 175 goto done; 176 177 pfs_id = lo_to_pfs(leaf->base.localization); 178 179 dict = get_dict(leaf->base.obj_id, pfs_id); 180 181 switch(leaf->base.rec_type) { 182 case HAMMER_RECTYPE_INODE: 183 /* 184 * We found an inode which also tells us where the file 185 * or directory is in the directory hierarchy. 186 */ 187 if (VerboseOpt) { 188 printf("file %016jx:%05d inode found\n", 189 (uintmax_t)leaf->base.obj_id, pfs_id); 190 } 191 path1 = recover_path(dict); 192 193 /* 194 * Attach the inode to its parent. This isn't strictly 195 * necessary because the information is also in the 196 * directory entries, but if we do not find the directory 197 * entry this ensures that the files will still be 198 * reasonably well organized in their proper directories. 199 */ 200 if ((dict->flags & DICTF_PARENT) == 0 && 201 dict->obj_id != HAMMER_OBJID_ROOT && 202 ondisk->inode.parent_obj_id != 0) { 203 dict->flags |= DICTF_PARENT; 204 dict->parent = get_dict(ondisk->inode.parent_obj_id, 205 pfs_id); 206 if (dict->parent && 207 (dict->parent->flags & DICTF_MADEDIR) == 0) { 208 dict->parent->flags |= DICTF_MADEDIR; 209 path2 = recover_path(dict->parent); 210 printf("mkdir %s\n", path2); 211 mkdir(path2, 0777); 212 free(path2); 213 path2 = NULL; 214 } 215 } 216 if (dict->obj_type == 0) 217 dict->obj_type = ondisk->inode.obj_type; 218 dict->size = ondisk->inode.size; 219 path2 = recover_path(dict); 220 221 if (lstat(path1, &st) == 0) { 222 if (ondisk->inode.obj_type == HAMMER_OBJTYPE_REGFILE) { 223 truncate(path1, dict->size); 224 /* chmod(path1, 0666); */ 225 } 226 if (strcmp(path1, path2)) { 227 printf("Rename %s -> %s\n", path1, path2); 228 rename(path1, path2); 229 } 230 } else if (ondisk->inode.obj_type == HAMMER_OBJTYPE_REGFILE) { 231 printf("mkinode (file) %s\n", path2); 232 fd = open(path2, O_RDWR|O_CREAT, 0666); 233 if (fd > 0) 234 close(fd); 235 } else if (ondisk->inode.obj_type == HAMMER_OBJTYPE_DIRECTORY) { 236 printf("mkinode (dir) %s\n", path2); 237 mkdir(path2, 0777); 238 dict->flags |= DICTF_MADEDIR; 239 } 240 free(path1); 241 free(path2); 242 break; 243 case HAMMER_RECTYPE_DATA: 244 /* 245 * File record data 246 */ 247 if (leaf->base.obj_id == 0) 248 break; 249 if (VerboseOpt) { 250 printf("file %016jx:%05d data %016jx,%d\n", 251 (uintmax_t)leaf->base.obj_id, 252 pfs_id, 253 (uintmax_t)leaf->base.key - len, 254 len); 255 } 256 257 /* 258 * Update the dictionary entry 259 */ 260 if (dict->obj_type == 0) 261 dict->obj_type = HAMMER_OBJTYPE_REGFILE; 262 263 /* 264 * If the parent directory has not been created we 265 * have to create it (typically a PFS%05d) 266 */ 267 if (dict->parent && 268 (dict->parent->flags & DICTF_MADEDIR) == 0) { 269 dict->parent->flags |= DICTF_MADEDIR; 270 path2 = recover_path(dict->parent); 271 printf("mkdir %s\n", path2); 272 mkdir(path2, 0777); 273 free(path2); 274 path2 = NULL; 275 } 276 277 /* 278 * Create the file if necessary, report file creations 279 */ 280 path1 = recover_path(dict); 281 if (CachedPath && strcmp(CachedPath, path1) == 0) { 282 fd = CachedFd; 283 } else { 284 fd = open(path1, O_CREAT|O_RDWR, 0666); 285 } 286 if (fd < 0) { 287 printf("Unable to create %s: %s\n", 288 path1, strerror(errno)); 289 free(path1); 290 break; 291 } 292 if ((dict->flags & DICTF_MADEFILE) == 0) { 293 dict->flags |= DICTF_MADEFILE; 294 printf("mkfile %s\n", path1); 295 } 296 297 /* 298 * And write the record. A HAMMER data block is aligned 299 * and may contain trailing zeros after the file EOF. The 300 * inode record is required to get the actual file size. 301 * 302 * However, when the inode record is not available 303 * we can do a sparse write and that will get it right 304 * most of the time even if the inode record is never 305 * found. 306 */ 307 file_offset = (int64_t)leaf->base.key - len; 308 lseek(fd, (off_t)file_offset, SEEK_SET); 309 while (len) { 310 if (dict->size == -1) { 311 for (zfill = chunk - 1; zfill >= 0; --zfill) { 312 if (((char *)ondisk)[zfill]) 313 break; 314 } 315 ++zfill; 316 } else { 317 zfill = chunk; 318 } 319 320 if (zfill) 321 write(fd, ondisk, zfill); 322 if (zfill < chunk) 323 lseek(fd, chunk - zfill, SEEK_CUR); 324 325 len -= chunk; 326 data_offset += chunk; 327 file_offset += chunk; 328 ondisk = get_buffer_data(data_offset, &data_buffer, 0); 329 if (ondisk == NULL) 330 break; 331 chunk = HAMMER_BUFSIZE - 332 ((int)data_offset & HAMMER_BUFMASK); 333 if (chunk > len) 334 chunk = len; 335 } 336 if (dict->size >= 0 && file_offset > dict->size) { 337 ftruncate(fd, dict->size); 338 /* fchmod(fd, 0666); */ 339 } 340 341 if (fd == CachedFd) { 342 free(path1); 343 } else if (CachedPath) { 344 free(CachedPath); 345 close(CachedFd); 346 CachedPath = path1; 347 CachedFd = fd; 348 } else { 349 CachedPath = path1; 350 CachedFd = fd; 351 } 352 break; 353 case HAMMER_RECTYPE_DIRENTRY: 354 nlen = len - offsetof(struct hammer_direntry_data, name[0]); 355 if ((int)nlen < 0) /* illegal length */ 356 break; 357 if (ondisk->entry.obj_id == 0 || 358 ondisk->entry.obj_id == HAMMER_OBJID_ROOT) 359 break; 360 name = malloc(nlen + 1); 361 bcopy(ondisk->entry.name, name, nlen); 362 name[nlen] = 0; 363 sanitize_string(name); 364 365 /* 366 * We can't deal with hardlinks so if the object already 367 * has a name assigned to it we just keep using that name. 368 */ 369 dict2 = get_dict(ondisk->entry.obj_id, pfs_id); 370 path1 = recover_path(dict2); 371 372 if (dict2->name == NULL) 373 dict2->name = name; 374 else 375 free(name); 376 377 /* 378 * Attach dict2 to its directory (dict), create the 379 * directory (dict) if necessary. We must ensure 380 * that the directory entry exists in order to be 381 * able to properly rename() the file without creating 382 * a namespace conflict. 383 */ 384 if ((dict2->flags & DICTF_PARENT) == 0) { 385 dict2->flags |= DICTF_PARENT; 386 dict2->parent = dict; 387 if ((dict->flags & DICTF_MADEDIR) == 0) { 388 dict->flags |= DICTF_MADEDIR; 389 path2 = recover_path(dict); 390 printf("mkdir %s\n", path2); 391 mkdir(path2, 0777); 392 free(path2); 393 path2 = NULL; 394 } 395 } 396 path2 = recover_path(dict2); 397 if (strcmp(path1, path2) != 0 && lstat(path1, &st) == 0) { 398 printf("Rename %s -> %s\n", path1, path2); 399 rename(path1, path2); 400 } 401 free(path1); 402 free(path2); 403 404 printf("dir %016jx:%05d entry %016jx \"%s\"\n", 405 (uintmax_t)leaf->base.obj_id, 406 pfs_id, 407 (uintmax_t)ondisk->entry.obj_id, 408 name); 409 break; 410 default: 411 /* 412 * Ignore any other record types 413 */ 414 break; 415 } 416 done: 417 rel_buffer(data_buffer); 418 } 419 420 #define RD_HSIZE 32768 421 #define RD_HMASK (RD_HSIZE - 1) 422 423 struct recover_dict *RDHash[RD_HSIZE]; 424 425 static 426 struct recover_dict * 427 get_dict(int64_t obj_id, uint16_t pfs_id) 428 { 429 struct recover_dict *dict; 430 int i; 431 432 if (obj_id == 0) 433 return(NULL); 434 435 i = crc32(&obj_id, sizeof(obj_id)) & RD_HMASK; 436 for (dict = RDHash[i]; dict; dict = dict->next) { 437 if (dict->obj_id == obj_id && 438 dict->pfs_id == pfs_id) { 439 break; 440 } 441 } 442 if (dict == NULL) { 443 dict = malloc(sizeof(*dict)); 444 bzero(dict, sizeof(*dict)); 445 dict->obj_id = obj_id; 446 dict->pfs_id = pfs_id; 447 dict->next = RDHash[i]; 448 dict->size = -1; 449 RDHash[i] = dict; 450 451 /* 452 * Always connect dangling dictionary entries to object 1 453 * (the root of the PFS). 454 * 455 * DICTF_PARENT will not be set until we know what the 456 * real parent directory object is. 457 */ 458 if (dict->obj_id != HAMMER_OBJID_ROOT) 459 dict->parent = get_dict(1, pfs_id); 460 } 461 return(dict); 462 } 463 464 struct path_info { 465 enum { PI_FIGURE, PI_LOAD } state; 466 uint16_t pfs_id; 467 char *base; 468 char *next; 469 int len; 470 }; 471 472 static void recover_path_helper(struct recover_dict *, struct path_info *); 473 474 static 475 char * 476 recover_path(struct recover_dict *dict) 477 { 478 struct path_info info; 479 480 bzero(&info, sizeof(info)); 481 info.pfs_id = dict->pfs_id; 482 info.state = PI_FIGURE; 483 recover_path_helper(dict, &info); 484 info.base = malloc(info.len); 485 info.next = info.base; 486 info.state = PI_LOAD; 487 recover_path_helper(dict, &info); 488 489 return(info.base); 490 } 491 492 static 493 void 494 recover_path_helper(struct recover_dict *dict, struct path_info *info) 495 { 496 /* 497 * Calculate path element length 498 */ 499 dict->flags |= DICTF_TRAVERSED; 500 501 switch(info->state) { 502 case PI_FIGURE: 503 if (dict->obj_id == HAMMER_OBJID_ROOT) 504 info->len += 8; 505 else if (dict->name) 506 info->len += strlen(dict->name); 507 else 508 info->len += 6 + 16; 509 ++info->len; 510 511 if (dict->parent && 512 (dict->parent->flags & DICTF_TRAVERSED) == 0) { 513 recover_path_helper(dict->parent, info); 514 } else { 515 info->len += strlen(TargetDir) + 1; 516 } 517 break; 518 case PI_LOAD: 519 if (dict->parent && 520 (dict->parent->flags & DICTF_TRAVERSED) == 0) { 521 recover_path_helper(dict->parent, info); 522 } else { 523 strcpy(info->next, TargetDir); 524 info->next += strlen(info->next); 525 } 526 527 *info->next++ = '/'; 528 if (dict->obj_id == HAMMER_OBJID_ROOT) { 529 snprintf(info->next, 8+1, "PFS%05d", info->pfs_id); 530 } else if (dict->name) { 531 strcpy(info->next, dict->name); 532 } else { 533 snprintf(info->next, 6+16+1, "obj_0x%016jx", 534 (uintmax_t)dict->obj_id); 535 } 536 info->next += strlen(info->next); 537 break; 538 } 539 dict->flags &= ~DICTF_TRAVERSED; 540 } 541 542 static 543 void 544 sanitize_string(char *str) 545 { 546 while (*str) { 547 if (!isprint(*str)) 548 *str = 'x'; 549 ++str; 550 } 551 } 552