1 /* 2 * Copyright (c) 2004,2005 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/jscan/jfile.c,v 1.10 2005/09/07 07:20:23 dillon Exp $ 35 */ 36 37 #include "jscan.h" 38 #include <dirent.h> 39 40 static void jalign(struct jfile *jf, enum jdirection direction); 41 static int jreadbuf(struct jfile *jf, enum jdirection direction, 42 void *buf, int bytes); 43 44 /* 45 * Open a file descriptor for journal record access. 46 * 47 * NOTE: only seekable descriptors are supported for backwards scans. 48 */ 49 struct jfile * 50 jopen_fd(int fd) 51 { 52 struct jfile *jf; 53 54 jf = malloc(sizeof(struct jfile)); 55 bzero(jf, sizeof(struct jfile)); 56 jf->jf_fd = fd; 57 jf->jf_write_fd = -1; 58 jf->jf_open_flags = O_RDONLY; 59 jf->jf_pos = 0; 60 return(jf); 61 } 62 63 /* 64 * Open a prefix set. <prefix>.nnnnnnnnn files or a <prefix>.transid file 65 * must exist to succeed. No file descriptor is actually opened but 66 * the sequence number is initialized to the beginning or end of the set. 67 */ 68 struct jfile * 69 jopen_prefix(const char *prefix, int rw) 70 { 71 struct jfile *jf; 72 struct jdata *jd; 73 unsigned int seq_beg = -1; 74 unsigned int seq_end = -1; 75 unsigned int seq; 76 struct stat st; 77 const char *dirname; 78 struct dirent *den; 79 DIR *dir; 80 char *basename; 81 char *data; 82 char *ptr; 83 int hastransid; 84 int baselen; 85 int fd; 86 87 dirname = data = strdup(prefix); 88 if ((basename = strrchr(dirname, '/')) != NULL) { 89 *basename++ = 0; 90 } else { 91 basename = data; 92 dirname = "./"; 93 } 94 baselen = strlen(basename); 95 if ((dir = opendir(dirname)) != NULL) { 96 while ((den = readdir(dir)) != NULL) { 97 if (strncmp(den->d_name, basename, baselen) == 0 && 98 den->d_name[baselen] == '.' 99 ) { 100 seq = strtoul(den->d_name + baselen + 1, &ptr, 16); 101 if (*ptr == 0 && seq != UINT_MAX) { 102 if (seq_beg == (unsigned int)-1 || seq_beg > seq) 103 seq_beg = seq; 104 if (seq_end == (unsigned int)-1 || seq_end < seq) 105 seq_end = seq; 106 } 107 } 108 } 109 closedir(dir); 110 } 111 free(data); 112 113 hastransid = 0; 114 asprintf(&data, "%s.transid", prefix); 115 if (stat(data, &st) == 0) 116 hastransid = 1; 117 free(data); 118 119 if (seq_beg != (unsigned int)-1 || hastransid) { 120 if (seq_beg == (unsigned int)-1) { 121 seq_beg = 0; 122 seq_end = 0; 123 if (rw) { 124 asprintf(&data, "%s.%08x", prefix, 0); 125 if ((fd = open(data, O_RDWR|O_CREAT, 0666)) >= 0) 126 close(fd); 127 free(data); 128 } 129 } 130 jf = malloc(sizeof(struct jfile)); 131 bzero(jf, sizeof(struct jfile)); 132 jf->jf_fd = -1; 133 jf->jf_write_fd = -1; 134 jf->jf_prefix = strdup(prefix); 135 jf->jf_seq = seq_beg; 136 jf->jf_seq_beg = seq_beg; 137 jf->jf_seq_end = seq_end; 138 jf->jf_open_flags = rw ? (O_RDWR|O_CREAT) : O_RDONLY; 139 if (verbose_opt) 140 fprintf(stderr, "Open prefix set %08x-%08x\n", seq_beg, seq_end); 141 if ((jd = jread(jf, NULL, JD_BACKWARDS)) != NULL) { 142 jf->jf_last_transid = jd->jd_transid; 143 jfree(jf, jd); 144 } 145 } else { 146 jf = NULL; 147 } 148 return(jf); 149 } 150 151 /* 152 * Get a prefix set ready for append. 153 */ 154 int 155 jrecord_init(const char *prefix) 156 { 157 struct jfile *jf; 158 struct stat st; 159 char *data; 160 int hasseqspace; 161 int fd; 162 163 /* 164 * Determine whether we already have a prefix set or whether we need 165 * to create one. 166 */ 167 jf = jopen_prefix(prefix, 0); 168 hasseqspace = 0; 169 if (jf) { 170 if (jf->jf_seq_beg != (unsigned int)-1) 171 hasseqspace = 1; 172 jclose(jf); 173 } 174 asprintf(&data, "%s.transid", prefix); 175 176 /* 177 * If the sequence exists the transid file must ALREADY exist for us 178 * to be able to safely 'append' to the space. Locked-down sequence 179 * spaces do not have a transid file. 180 */ 181 if (hasseqspace) { 182 fd = open(data, O_RDWR, 0666); 183 } else { 184 fd = open(data, O_RDWR|O_CREAT, 0666); 185 } 186 free(data); 187 if (fd < 0) 188 return(-1); 189 if (fstat(fd, &st) == 0 && st.st_size == 0) 190 write(fd, "0000000000000000\n", 17); /* starting transid in hex */ 191 close(fd); 192 return(0); 193 } 194 195 /* 196 * Close a previously opened journal, clean up any side allocations. 197 */ 198 void 199 jclose(struct jfile *jf) 200 { 201 if (jf->jf_fd >= 0) { 202 close(jf->jf_fd); 203 jf->jf_fd = -1; 204 } 205 if (jf->jf_write_fd >= 0) { 206 close(jf->jf_write_fd); 207 jf->jf_write_fd = -1; 208 } 209 free(jf); 210 } 211 212 /* 213 * Locate the next (or previous) raw record given a jfile, current record, 214 * and direction. If the current record is NULL then the first or last 215 * record for the current sequence number is returned. 216 * 217 * PAD RECORD SPECIAL CASE. Pad records can be 16 bytes long, which means 218 * that that rawrecend overlaps the transid field of the rawrecbeg. Because 219 * the transid is garbage, we must skip and cannot return pad records. 220 */ 221 struct jdata * 222 jread(struct jfile *jf, struct jdata *jd, enum jdirection direction) 223 { 224 struct journal_rawrecbeg head; 225 struct journal_rawrecbeg *headp; 226 struct journal_rawrecend tail; 227 struct journal_rawrecend *tailp; 228 struct stat st; 229 char *filename; 230 int allocsize; 231 int recsize; 232 int search; 233 int error; 234 int n; 235 236 if (jd) { 237 /* 238 * Handle the next/previous record case. If running in the forwards 239 * direction we position the file just after jd. If running in the 240 * backwards direction we position the file at the base of jd so 241 * the backwards read gets the previous record. 242 * 243 * In prefix mode we have to get the right descriptor open and 244 * position the file, since the fall through code resets to the 245 * beginning or end if it has to open a descriptor. 246 */ 247 assert(direction != JD_SEQFIRST && direction != JD_SEQLAST); 248 if (jf->jf_prefix) { 249 if (jf->jf_fd >= 0 && jf->jf_seq != jd->jd_seq) { 250 close(jf->jf_fd); 251 jf->jf_fd = -1; 252 } 253 jf->jf_seq = jd->jd_seq; 254 if (jf->jf_fd < 0) { 255 asprintf(&filename, "%s.%08x", jf->jf_prefix, jf->jf_seq); 256 jf->jf_fd = open(filename, O_RDONLY); 257 if (verbose_opt > 1) 258 fprintf(stderr, "Open %s fd %d\n", filename, jf->jf_fd); 259 free(filename); 260 } 261 } 262 if ((jmodes & JMODEF_INPUT_PIPE) == 0) { 263 if (direction == JD_FORWARDS) { 264 jf->jf_pos = jd->jd_pos + jd->jd_size; 265 lseek(jf->jf_fd, jf->jf_pos, 0); 266 } else { 267 jf->jf_pos = jd->jd_pos; 268 /* lseek(jf->jf_fd, jf->jf_pos, 0); not needed */ 269 } 270 } else { 271 assert(direction == JD_FORWARDS && jf->jf_prefix == NULL); 272 assert(jf->jf_pos == jd->jd_pos + jd->jd_size); 273 } 274 jfree(jf, jd); 275 } else { 276 /* 277 * Handle the first/last record case. In the prefix case we only 278 * need to set jf_seq and close the file handle and fall through. 279 * The SEQ modes maintain the current jf_seq (kinda a hack). 280 */ 281 if (jf->jf_prefix) { 282 if (jf->jf_fd >= 0) { 283 close(jf->jf_fd); 284 jf->jf_fd = -1; 285 } 286 switch(direction) { 287 case JD_FORWARDS: 288 jf->jf_seq = jf->jf_seq_beg; 289 break; 290 case JD_BACKWARDS: 291 jf->jf_seq = jf->jf_seq_end; 292 break; 293 case JD_SEQFIRST: 294 direction = JD_FORWARDS; 295 break; 296 case JD_SEQLAST: 297 direction = JD_BACKWARDS; 298 break; 299 } 300 } else if ((jmodes & JMODEF_INPUT_PIPE) == 0) { 301 switch(direction) { 302 case JD_SEQFIRST: 303 direction = JD_FORWARDS; 304 /* fall through */ 305 case JD_FORWARDS: 306 jf->jf_pos = lseek(jf->jf_fd, 0L, SEEK_SET); 307 break; 308 case JD_SEQLAST: 309 direction = JD_BACKWARDS; 310 /* fall through */ 311 case JD_BACKWARDS: 312 jf->jf_pos = lseek(jf->jf_fd, 0L, SEEK_END); 313 break; 314 } 315 } else { 316 if (direction == JD_SEQFIRST) 317 direction = JD_FORWARDS; 318 assert(jf->jf_pos == 0 && direction == JD_FORWARDS); 319 } 320 } 321 322 top: 323 /* 324 * If we are doing a prefix scan and the descriptor is not open, 325 * open the file based on jf_seq and position it to the beginning 326 * or end based on the direction. This is how we iterate through 327 * the prefix set. 328 */ 329 if (jf->jf_fd < 0) { 330 asprintf(&filename, "%s.%08x", jf->jf_prefix, jf->jf_seq); 331 jf->jf_fd = open(filename, O_RDONLY); 332 if (verbose_opt > 1) 333 fprintf(stderr, "Open %s fd %d\n", filename, jf->jf_fd); 334 free(filename); 335 if (direction == JD_FORWARDS) 336 jf->jf_pos = lseek(jf->jf_fd, 0L, SEEK_SET); 337 else 338 jf->jf_pos = lseek(jf->jf_fd, 0L, SEEK_END); 339 } 340 341 /* 342 * Get the current offset and make sure it is 16-byte aligned. If it 343 * isn't, align it and enter search mode. 344 */ 345 if (jf->jf_pos & 15) { 346 jf_warn(jf, "realigning bad offset and entering search mode"); 347 jalign(jf, direction); 348 search = 1; 349 } else { 350 search = 0; 351 } 352 353 error = 0; 354 if (direction == JD_FORWARDS) { 355 /* 356 * Scan the journal forwards. Note that the file pointer might not 357 * be seekable. 358 */ 359 while ((error = jreadbuf(jf, direction, &head, sizeof(head))) == sizeof(head)) { 360 if (head.begmagic != JREC_BEGMAGIC) { 361 if (search == 0) 362 jf_warn(jf, "bad beginmagic, searching for new record"); 363 search = 1; 364 jalign(jf, direction); 365 continue; 366 } 367 368 /* 369 * The actual record is 16-byte aligned. head.recsize contains 370 * the unaligned record size. 371 */ 372 recsize = (head.recsize + 15) & ~15; 373 if (recsize < JREC_MINRECSIZE || recsize > JREC_MAXRECSIZE) { 374 if (search == 0) 375 jf_warn(jf, "bad recordsize: %d\n", recsize); 376 search = 1; 377 jalign(jf, direction); 378 continue; 379 } 380 allocsize = offsetof(struct jdata, jd_data[recsize]); 381 allocsize = (allocsize + 255) & ~255; 382 jd = malloc(allocsize); 383 bzero(jd, offsetof(struct jdata, jd_data[0])); 384 bcopy(&head, jd->jd_data, sizeof(head)); 385 n = jreadbuf(jf, direction, jd->jd_data + sizeof(head), 386 recsize - sizeof(head)); 387 if (n != (int)(recsize - sizeof(head))) { 388 if (search == 0) 389 jf_warn(jf, "Incomplete stream record\n"); 390 search = 1; 391 jalign(jf, direction); 392 free(jd); 393 continue; 394 } 395 396 tailp = (void *)(jd->jd_data + recsize - sizeof(*tailp)); 397 if (tailp->endmagic != JREC_ENDMAGIC) { 398 if (search == 0) 399 jf_warn(jf, "bad endmagic, searching for new record"); 400 search = 1; 401 jalign(jf, direction); 402 free(jd); 403 continue; 404 } 405 406 /* 407 * Skip pad records. 408 */ 409 if (head.streamid == JREC_STREAMID_PAD) { 410 free(jd); 411 continue; 412 } 413 414 /* 415 * note: recsize is aligned (the actual record size), 416 * head.recsize is unaligned (the actual payload size). 417 */ 418 jd->jd_transid = head.transid; 419 jd->jd_alloc = allocsize; 420 jd->jd_size = recsize; 421 jd->jd_seq = jf->jf_seq; 422 jd->jd_pos = jf->jf_pos - recsize; 423 jd->jd_refs = 1; 424 return(jd); 425 } 426 } else { 427 /* 428 * Scan the journal backwards. Note that jread()'s reverse-seek and 429 * read. The data read will be forward ordered, however. 430 */ 431 while ((error = jreadbuf(jf, direction, &tail, sizeof(tail))) == sizeof(tail)) { 432 if (tail.endmagic != JREC_ENDMAGIC) { 433 if (search == 0) 434 jf_warn(jf, "bad endmagic, searching for new record"); 435 search = 1; 436 jalign(jf, direction); 437 continue; 438 } 439 440 /* 441 * The actual record is 16-byte aligned. head.recsize contains 442 * the unaligned record size. 443 */ 444 recsize = (tail.recsize + 15) & ~15; 445 if (recsize < JREC_MINRECSIZE || recsize > JREC_MAXRECSIZE) { 446 if (search == 0) 447 jf_warn(jf, "bad recordsize: %d\n", recsize); 448 search = 1; 449 jalign(jf, direction); 450 continue; 451 } 452 allocsize = offsetof(struct jdata, jd_data[recsize]); 453 allocsize = (allocsize + 255) & ~255; 454 jd = malloc(allocsize); 455 bzero(jd, offsetof(struct jdata, jd_data[0])); 456 bcopy(&tail, jd->jd_data + recsize - sizeof(tail), sizeof(tail)); 457 n = jreadbuf(jf, direction, jd->jd_data, recsize - sizeof(tail)); 458 if (n != (int)(recsize - sizeof(tail))) { 459 if (search == 0) 460 jf_warn(jf, "Incomplete stream record\n"); 461 search = 1; 462 jalign(jf, direction); 463 free(jd); 464 continue; 465 } 466 467 headp = (void *)jd->jd_data; 468 if (headp->begmagic != JREC_BEGMAGIC) { 469 if (search == 0) 470 jf_warn(jf, "bad begmagic, searching for new record"); 471 search = 1; 472 jalign(jf, direction); 473 free(jd); 474 continue; 475 } 476 477 /* 478 * Skip pad records. 479 */ 480 if (head.streamid == JREC_STREAMID_PAD) { 481 free(jd); 482 continue; 483 } 484 485 /* 486 * note: recsize is aligned (the actual record size), 487 * head.recsize is unaligned (the actual payload size). 488 */ 489 jd->jd_transid = headp->transid; 490 jd->jd_alloc = allocsize; 491 jd->jd_size = recsize; 492 jd->jd_seq = jf->jf_seq; 493 jd->jd_pos = jf->jf_pos; 494 jd->jd_refs = 1; 495 return(jd); 496 } 497 } 498 499 /* 500 * If reading in prefix mode and there is no more data, close the 501 * current descriptor, adjust the sequence number, and loop. 502 * 503 * If we hit the end of the sequence space and were asked to loop, 504 * check for the next sequence number and adjust jf_seq_end. Leave 505 * the current descriptor open so we do not loose track of its seek 506 * position, and also to catch a race where another jscan may have 507 * written more data to the current sequence number before rolling 508 * the next sequence number. 509 */ 510 if (error == 0 && jf->jf_prefix) { 511 if (direction == JD_FORWARDS) { 512 if (jf->jf_seq < jf->jf_seq_end) { 513 ++jf->jf_seq; 514 if (verbose_opt) 515 fprintf(stderr, "jread: roll to seq %08x\n", jf->jf_seq); 516 if (jf->jf_fd >= 0) { 517 close(jf->jf_fd); 518 jf->jf_fd = -1; 519 } 520 goto top; 521 } 522 if (jmodes & JMODEF_LOOP_FOREVER) { 523 asprintf(&filename, "%s.%08x", jf->jf_prefix, jf->jf_seq + 1); 524 if (stat(filename, &st) == 0) { 525 ++jf->jf_seq_end; 526 if (verbose_opt) 527 fprintf(stderr, "jread: roll seq_end to %08x\n", 528 jf->jf_seq_end); 529 } else { 530 sleep(5); 531 } 532 goto top; 533 } 534 } else { 535 if (jf->jf_seq > jf->jf_seq_beg) { 536 --jf->jf_seq; 537 if (verbose_opt) 538 fprintf(stderr, "jread: roll to seq %08x\n", jf->jf_seq); 539 if (jf->jf_fd >= 0) { 540 close(jf->jf_fd); 541 jf->jf_fd = -1; 542 } 543 goto top; 544 } 545 } 546 } 547 548 /* 549 * If we hit EOF and were asked to loop forever on the input, leave 550 * the current descriptor open, sleep, and loop. 551 * 552 * We have already handled the prefix case. This feature only works 553 * when doing forward scans and the input is not a pipe. 554 */ 555 if (error == 0 && jf->jf_prefix == NULL && 556 (jmodes & JMODEF_LOOP_FOREVER) && 557 !(jmodes & JMODEF_INPUT_PIPE) && 558 direction == JD_FORWARDS 559 ) { 560 sleep(5); 561 goto top; 562 } 563 564 /* 565 * Otherwise there are no more records and we are done. 566 */ 567 return(NULL); 568 } 569 570 /* 571 * Write a record out. If this is a prefix set and the file would 572 * exceed record_size, we rotate into a new sequence number. 573 */ 574 void 575 jwrite(struct jfile *jf, struct jdata *jd) 576 { 577 struct stat st; 578 char *path; 579 int n; 580 581 assert(jf->jf_prefix); 582 583 again: 584 /* 585 * Open/create a new file in the prefix set 586 */ 587 if (jf->jf_write_fd < 0) { 588 asprintf(&path, "%s.%08x", jf->jf_prefix, jf->jf_seq_end); 589 jf->jf_write_fd = open(path, O_RDWR|O_CREAT, 0666); 590 if (jf->jf_write_fd < 0 || fstat(jf->jf_write_fd, &st) != 0) { 591 fprintf(stderr, "Unable to open/create %s\n", path); 592 exit(1); 593 } 594 jf->jf_write_pos = st.st_size; 595 lseek(jf->jf_write_fd, jf->jf_write_pos, 0); 596 free(path); 597 } 598 599 /* 600 * Each file must contain at least one raw record, even if it exceeds 601 * the user-requested record-size. Apart from that, we cycle to the next 602 * file when its size would exceed the user-specified 603 */ 604 if (jf->jf_write_pos > 0 && 605 jf->jf_write_pos + jd->jd_size > prefix_file_size 606 ) { 607 close(jf->jf_write_fd); 608 jf->jf_write_fd = -1; 609 ++jf->jf_seq_end; 610 goto again; 611 } 612 613 /* 614 * Terminate if a failure occurs (for now). 615 */ 616 n = write(jf->jf_write_fd, jd->jd_data, jd->jd_size); 617 if (n != jd->jd_size) { 618 ftruncate(jf->jf_write_fd, jf->jf_write_pos); 619 fprintf(stderr, "jwrite: failed %s\n", strerror(errno)); 620 exit(1); 621 } 622 jf->jf_write_pos += n; 623 jf->jf_last_transid = jd->jd_transid; 624 } 625 626 /* 627 * Attempt to locate and return the record specified by the transid. The 628 * returned record may be inexact. 629 * 630 * If scanning forwards this function guarentees that no record prior 631 * to the returned record is >= transid. 632 * 633 * If scanning backwards this function guarentees that no record after 634 * the returned record is <= transid. 635 */ 636 struct jdata * 637 jseek(struct jfile *jf, int64_t transid, enum jdirection direction) 638 { 639 unsigned int seq; 640 struct jdata *jd = NULL; 641 642 /* 643 * If the input is a pipe we can't seek. 644 */ 645 if (jmodes & JMODEF_INPUT_PIPE) { 646 assert(direction == JD_FORWARDS); 647 return (jread(jf, NULL, direction)); 648 } 649 650 if (jf->jf_prefix) { 651 /* 652 * If we have a prefix set search the sequence space backwards until 653 * we find the file most likely to contain the transaction id. 654 */ 655 if (verbose_opt > 2) { 656 fprintf(stderr, "jseek prefix set %s %08x-%08x\n", jf->jf_prefix, 657 jf->jf_seq_beg, jf->jf_seq_end); 658 } 659 jd = NULL; 660 for (seq = jf->jf_seq_end; seq != jf->jf_seq_beg - 1; --seq) { 661 if (verbose_opt > 2) 662 fprintf(stderr, "try seq %08x\n", seq); 663 jf->jf_seq = seq; 664 if ((jd = jread(jf, NULL, JD_SEQFIRST)) != NULL) { 665 if (jd->jd_transid == transid) 666 return(jd); 667 if (jd->jd_transid < transid) { 668 jfree(jf, jd); 669 break; 670 } 671 jfree(jf, jd); 672 } 673 } 674 675 /* 676 * if transid is less the first file in the sequence space we 677 * return NULL if scanning backwards, indicating no records are 678 * available, or the first record in the sequence space if we 679 * are scanning forwards. 680 */ 681 if (seq == jf->jf_seq_beg - 1) { 682 if (direction == JD_BACKWARDS) 683 return(NULL); 684 else 685 return(jread(jf, NULL, JD_FORWARDS)); 686 } 687 if (verbose_opt > 1) 688 fprintf(stderr, "jseek input prefix set to seq %08x\n", seq); 689 } 690 691 /* 692 * Position us to the end of the current record, then scan backwards 693 * looking for the requested transid. 694 */ 695 jd = jread(jf, NULL, JD_SEQLAST); 696 while (jd != NULL) { 697 if (jd->jd_transid <= transid) { 698 if (jd->jd_transid < transid) { 699 if (direction == JD_FORWARDS) 700 jd =jread(jf, jd, JD_FORWARDS); 701 } 702 if (verbose_opt > 1) { 703 fprintf(stderr, "jseek returning seq %08x offset 0x%08jx\n", 704 jd->jd_seq, (uintmax_t)jd->jd_pos); 705 } 706 return(jd); 707 } 708 jd = jread(jf, jd, JD_BACKWARDS); 709 } 710 711 /* 712 * We scanned the whole file with no luck, all the transid's are 713 * greater then the requested transid. If the intended read 714 * direction is backwards there are no records and we return NULL. 715 * If it is forwards we return the first record. 716 */ 717 if (direction == JD_BACKWARDS) 718 return(NULL); 719 else 720 return(jread(jf, NULL, JD_FORWARDS)); 721 } 722 723 /* 724 * Data returned by jread() is persistent until released. 725 */ 726 struct jdata * 727 jref(struct jdata *jd) 728 { 729 ++jd->jd_refs; 730 return(jd); 731 } 732 733 void 734 jfree(struct jfile *jf __unused, struct jdata *jd) 735 { 736 if (--jd->jd_refs == 0) 737 free(jd); 738 } 739 740 /* 741 * Align us to the next 16 byte boundary. If scanning forwards we align 742 * forwards if not already aligned. If scanning backwards we align 743 * backwards if not already aligned. We only have to synchronize the 744 * seek position with the file seek position for forward scans. 745 */ 746 static void 747 jalign(struct jfile *jf, enum jdirection direction) 748 { 749 char dummy[16]; 750 int bytes; 751 752 if ((int)jf->jf_pos & 15) { 753 if (direction == JD_FORWARDS) { 754 bytes = 16 - ((int)jf->jf_pos & 15); 755 jreadbuf(jf, direction, dummy, bytes); 756 } else { 757 jf->jf_pos = jf->jf_pos & ~(off_t)15; 758 } 759 } 760 } 761 762 /* 763 * Read the next raw journal record forwards or backwards and return a 764 * pointer to it. Note that the file pointer's actual seek position does 765 * not match jf_pos in the reverse direction case. 766 */ 767 static int 768 jreadbuf(struct jfile *jf, enum jdirection direction, void *buf, int bytes) 769 { 770 int ttl = 0; 771 int n; 772 773 if (jf->jf_fd < 0) 774 return(0); 775 776 if (direction == JD_FORWARDS) { 777 while (ttl != bytes) { 778 n = read(jf->jf_fd, (char *)buf + ttl, bytes - ttl); 779 if (n <= 0) { 780 if (n < 0 && ttl == 0) 781 ttl = -errno; 782 break; 783 } 784 ttl += n; 785 jf->jf_pos += n; 786 } 787 } else { 788 if (jf->jf_pos >= bytes) { 789 jf->jf_pos -= bytes; 790 lseek(jf->jf_fd, jf->jf_pos, 0); 791 while (ttl != bytes) { 792 n = read(jf->jf_fd, (char *)buf + ttl, bytes - ttl); 793 if (n <= 0) { 794 if (n < 0 && ttl == 0) 795 ttl = -errno; 796 break; 797 } 798 ttl += n; 799 } 800 } 801 } 802 return(ttl); 803 } 804 805