mdw@git.distorted.org.uk Git - dvdrip/blob - dvd-sector-copy.c

   1 #include "lib.h"
   2
   3 static void usage(FILE *fp)
   4 {
   5   fprintf(fp,
   6           "usage: %s [-ci] [-B PARAM=VALUE,...] [-R MAP]\n"
   7           "\t[-b OUTMAP] [-r [START]-[END]] DEVICE OUTFILE\n",
   8           prog);
   9 }
  10
  11 #define MAXFILES (1 + 2*99 + 1)
  12 struct file {
  13   ident id;
  14   secaddr start, end;
  15 };
  16 DEFVEC(file_v, struct file);
  17 static file_v filetab = VEC_INIT;
  18
  19 enum { EV_STOP, EV_BEGIN, EV_END, EV_WRITE };
  20 struct event {
  21   unsigned char ev, file;
  22   secaddr pos;
  23 };
  24 DEFVEC(event_v, struct event);
  25 static event_v eventq = VEC_INIT;
  26
  27 static int compare_event(const void *a, const void *b)
  28 {
  29   const struct event *eva = a, *evb = b;
  30
  31   if (eva->pos < evb->pos) return (-1);
  32   else if (eva->pos > evb->pos) return (+1);
  33
  34   if (eva->ev < evb->ev) return (-1);
  35   else if (eva->ev > evb->ev) return (+1);
  36
  37   if (eva->file < evb->file) return (-1);
  38   else if (eva->file > evb->file) return (+1);
  39
  40   return (0);
  41 }
  42
  43 typedef uint_least32_t bits;
  44 static bits live[(MAXFILES + 31)/32];
  45
  46 static inline int livep(unsigned i)
  47   { return (live[i/32]&((bits)1 << (i%32))); }
  48 static inline void set_live(unsigned i)
  49   { live[i/32] |= (bits)1 << (i%32); }
  50 static inline void clear_live(unsigned i)
  51   { live[i/32] &= ~((bits)1 << (i%32)); }
  52 static inline int least_live(void)
  53 {
  54   unsigned i, n = (filetab.n + 32)/32;
  55   bits b;
  56
  57   for (i = 0; i < n; i++) { b = live[i]; if (b) goto found; }
  58   return (-1);
  59 found:
  60   i *= 32;
  61   if (!(b&0x0000ffff)) { b >>= 16; i += 16; }
  62   if (!(b&0x000000ff)) { b >>=  8; i +=  8; }
  63   if (!(b&0x0000000f)) { b >>=  4; i +=  4; }
  64   if (!(b&0x00000003)) { b >>=  2; i +=  2; }
  65   if (!(b&0x00000001)) { b >>=  1; i +=  1; }
  66   assert(b&1);
  67   return (i);
  68 }
  69
  70 static void put_event(unsigned evtype, unsigned file, secaddr pos)
  71 {
  72   struct event *ev;
  73
  74   VEC_PUSH(ev, &eventq);
  75   ev->ev = evtype; ev->file = file; ev->pos = pos;
  76 }
  77
  78 static void put_file(ident id, secaddr start, secaddr end)
  79 {
  80   struct file *f;
  81   size_t i;
  82
  83   VEC_PUSH(f, &filetab); i = f - filetab.v;
  84   f->id = id; f->start = start; f->end = end;
  85   put_event(EV_BEGIN, i, start);
  86   put_event(EV_END, i, end);
  87 }
  88
  89 static void put_menu(dvd_reader_t *dvd, unsigned title)
  90 {
  91   ident id = mkident(VOB, title, 0);
  92   char fn[MAXFNSZ];
  93   secaddr start, len;
  94
  95   store_filename(fn, id);
  96   start = UDFFindFile(dvd, fn, &len); if (!start) return;
  97 #ifdef DEBUG
  98   printf(";; %8"PRIuSEC" .. %-8"PRIuSEC": %s\n",
  99          start, start + SECTORS(len), fn);
 100 #endif
 101   put_file(id, start, start + SECTORS(len));
 102 }
 103
 104 static void put_title(dvd_reader_t *dvd, unsigned title)
 105 {
 106   char fn[MAXFNSZ];
 107   secaddr start[9], len[9];
 108   unsigned i, npart;
 109
 110   for (i = 0; i < 9; i++) {
 111     store_filename(fn, mkident(VOB, title, i + 1));
 112     start[i] = UDFFindFile(dvd, fn, &len[i]); if (!start[i]) break;
 113   }
 114   npart = i; if (!npart) return;
 115
 116 #ifdef DEBUG
 117   for (i = 0; i < npart; i++) {
 118     store_filename(fn, mkident(VOB, title, i + 1));
 119     printf(";; %8"PRIuSEC" .. %-8"PRIuSEC": %s\n",
 120            start[i], start[i] + SECTORS(len[i]), fn);
 121   }
 122 #endif
 123
 124   if (npart > 1)
 125     for (i = 0; i < npart - 1; i++) {
 126       if (len[i]%SECTORSZ)
 127         bail("title %u part %u length = %"PRIuSEC" not a multiple of %d",
 128              title, i, len[i], SECTORSZ);
 129       if (start[i] + len[i]/SECTORSZ != start[i + 1])
 130         bail
 131           ("title %u part %u end = %"PRIuSEC" /= part %u start = %"PRIuSEC"",
 132            title, i, start[i] + len[i]/SECTORSZ, i + 1, start[i + 1]);
 133     }
 134
 135   put_file(mkident(VOB, title, 1),
 136            start[0], start[npart - 1] + SECTORS(len[npart - 1]));
 137 }
 138
 139 static secaddr last_pos, limit, nsectors, ndone;
 140 static struct timeval last_time;
 141 static double wsum, wcount;
 142 static struct file *file;
 143 static secaddr bad_start;
 144 static unsigned retry, max_retries = 4;
 145 static int bad_err;
 146
 147 static const char throbber[] = "|<-<|>->";
 148 static unsigned throbix = 0;
 149
 150 static double scale_bytes(double n, const char **unit_out)
 151 {
 152   const char *unit = "";
 153
 154   if (n > 1600) { n /= 1024; unit = "k"; }
 155   if (n > 1600) { n /= 1024; unit = "M"; }
 156   if (n > 1600) { n /= 1024; unit = "G"; }
 157   if (n > 1600) { n /= 1024; unit = "T"; }
 158
 159   *unit_out = unit; return (n);
 160 }
 161
 162 static struct progress_item
 163   copy_progress, disc_progress,
 164   file_progress, badblock_progress;
 165
 166 #define TIMESTRMAX 16
 167 static char *fmttime(unsigned long t, char *buf)
 168 {
 169   if (t < 60) sprintf(buf, "%ld s", t);
 170   else if (t < 3600) sprintf(buf, "%ld:%02ld", t/60, t%60);
 171   else sprintf(buf, "%ld:%02ld:%02ld", t/3600, (t/60)%60, t%60);
 172   return (buf);
 173 }
 174
 175 static void render_perfstats(struct progress_render_state *render)
 176 {
 177   int eta;
 178   char timebuf[TIMESTRMAX];
 179   double rate;
 180   const char *unit;
 181
 182   if (!wsum || !wcount) { rate = 0; eta = -1; }
 183   else { rate = wsum/wcount; eta = (int)((nsectors - ndone)/rate + 0.5); }
 184
 185   rate = scale_bytes(rate*SECTORSZ, &unit);
 186   progress_putright(render, "ETA %s ", rate ? fmttime(eta, timebuf) : "???");
 187   progress_putright(render, "%.1f %sB/s, ", rate, unit);
 188 }
 189
 190 static void render_copy_progress(struct progress_item *item,
 191                                  struct progress_render_state *render)
 192 {
 193   double frac = (double)ndone/nsectors;
 194
 195   progress_putleft(render, " %c copied %.1f%%",
 196                    throbber[throbix], 100.0*frac);
 197   render_perfstats(render);
 198   progress_putleft(render, " (%"PRIuSEC" of %"PRIuSEC")", ndone, nsectors);
 199
 200   progress_showbar(render, frac);
 201 }
 202
 203 static void render_disc_progress(struct progress_item *item,
 204                                  struct progress_render_state *render)
 205 {
 206   double frac = (double)last_pos/limit;
 207
 208   progress_putleft(render, "        disc %.1f%% (%"PRIuSEC" of %"PRIuSEC")",
 209                    100.0*frac, last_pos, limit);
 210   progress_showbar(render, frac);
 211 }
 212
 213 static void render_file_progress(struct progress_item *item,
 214                                  struct progress_render_state *render)
 215 {
 216   secaddr off = last_pos - file->start, len = file->end - file->start;
 217   char fn[MAXFNSZ];
 218   double frac;
 219
 220   store_filename(fn, file->id);
 221   frac = (double)off/len;
 222   progress_putleft(render, "        `%s' %.1f%% (%"PRIuSEC" of %"PRIuSEC")",
 223                    fn, 100.0*frac, off, len);
 224   progress_showbar(render, frac);
 225 }
 226
 227 static void render_badblock_progress(struct progress_item *item,
 228                                      struct progress_render_state *render)
 229 {
 230   secaddr n = last_pos - bad_start;
 231   int bg;
 232
 233   if (!n) {
 234     progress_putleft(render, " Retrying bad sector %"PRIuSEC"", bad_start);
 235     progress_putright(render, "attempt %u/%u ", retry + 1, max_retries);
 236     bg = 4;
 237   } else {
 238     progress_putleft(render, " Found %"PRIuSEC" bad %s",
 239                      n, n == 1 ? "sector" : "sectors");
 240     progress_putright(render, "%"PRIuSEC" .. %"PRIuSEC" ",
 241                       bad_start, last_pos);
 242     bg = 1;
 243   }
 244   if (bad_err && bad_err != EIO)
 245     progress_putleft(render, " (%s)", strerror(bad_err));
 246   progress_shownotice(render, bg, 7);
 247 }
 248
 249 static double alpha = 0.1;
 250
 251 static void update_progress(secaddr pos)
 252 {
 253   struct timeval now;
 254   double t, f, g;
 255
 256   gettimeofday(&now, 0);
 257   t = tvdiff(&last_time, &now);
 258
 259 #define BETA (1 - alpha)
 260
 261   if (t) {
 262     g = wcount ? pow(BETA, t) : 0.0; f = (1 - g)/(1 - BETA);
 263     wsum = f*(pos - last_pos)/t + g*wsum;
 264     wcount = f + g*wcount;
 265     ndone += pos - last_pos;
 266     last_time = now; last_pos = pos;
 267   }
 268
 269 #undef BETA
 270
 271   throbix++; if (!throbber[throbix]) throbix = 0;
 272 }
 273
 274 static void report_progress(secaddr pos)
 275   { update_progress(pos); progress_update(&progress); }
 276
 277 static dvd_reader_t *dvd;
 278 static int dvdfd = -1, outfd = -1;
 279 static dvd_file_t *vob;
 280 static const char *mapfile; static FILE *mapfp;
 281 static const char *errfile; static FILE *errfp;
 282
 283 struct badblock { secaddr start, end; };
 284 DEFVEC(badblock_v, struct badblock);
 285 static badblock_v badblocks = VEC_INIT;
 286
 287 static int compare_badblock(const void *a, const void *b)
 288 {
 289   const struct badblock *ba = a, *bb = b;
 290
 291   if (ba->start < bb->start) return (-1);
 292   else if (ba->start > bb->start) return (+1);
 293
 294   if (ba->end < bb->end) return (-1);
 295   else if (ba->end > bb->end) return (+1);
 296
 297   return (0);
 298 }
 299
 300 static double bad_block_delay = 0.0;
 301 static double good_block_delay = 0.0;
 302
 303 static ssize_t read_sectors(secaddr pos, void *buf, secaddr want)
 304 {
 305   ssize_t n, done;
 306   size_t lo, mid, hi;
 307   int fakeerr = 0;
 308   struct badblock *bad, *best;
 309   unsigned char *p = buf;
 310
 311   if (badblocks.n) {
 312     best = 0; lo = 0; hi = badblocks.n;
 313 #ifdef DEBUG
 314     progress_clear(&progress);
 315     printf(";; searching badblocks for %"PRIuSEC" .. %"PRIuSEC"\n",
 316            pos, pos + want);
 317 #endif
 318     while (lo < hi) {
 319       mid = lo + (hi - lo)/2; bad = &badblocks.v[mid];
 320 #ifdef DEBUG
 321       printf(";;   try %zu (%"PRIuSEC" .. %"PRIuSEC")... ",
 322              mid, bad->start, bad->end);
 323 #endif
 324       if (pos < bad->start) { D( printf("high\n"); ) best = bad; hi = mid; }
 325       else if (pos >= bad->end) { D( printf("low\n"); ) lo = mid + 1; }
 326       else {
 327         D( printf("match!\n"); )
 328         errno = EIO; sit(bad_block_delay); return (-1);
 329       }
 330     }
 331 #ifdef DEBUG
 332     if (best)
 333       printf(";;   next is %"PRIuSEC" .. %"PRIuSEC"\n",
 334              best->start, best->end);
 335 #endif
 336     if (best && pos + want > best->start)
 337       { want = best->start - pos; fakeerr = EIO; sit(bad_block_delay); }
 338   }
 339   done = 0;
 340   while (want) {
 341     if (vob)
 342       { errno = 0; n = DVDReadBlocks(vob, pos - file->start, want, p); }
 343     else if (file) {
 344       if (lseek(dvdfd, (off_t)pos*SECTORSZ, SEEK_SET) < 0)
 345         bail_syserr(errno, "failed to seek to sector %"PRIuSEC"", pos);
 346       errno = 0; n = read(dvdfd, p, want*SECTORSZ);
 347       if (n >= 0) n /= SECTORSZ;
 348     } else {
 349       memset(p, 0, want*SECTORSZ);
 350       n = want;
 351     }
 352
 353     if (n > 0) { done += n; pos += n; p += n*SECTORSZ; want -= n; }
 354     else if (!n) break;
 355     else if (errno == EIO && errfile) {
 356       open_file_on_demand(errfile, &errfp, "bad-sector error log");
 357       fprintf(errfp, "%"PRIuSEC" %"PRIuSEC"\n", pos, pos + 1);
 358       check_write(errfp, "bad-sector error log");
 359       break;
 360     } else if (errno != EINTR) break;
 361   }
 362   if (fakeerr && !errno) errno = fakeerr;
 363   else if (done > 0 && good_block_delay) sit(done*good_block_delay);
 364   return (!done && errno ? -1 : done);
 365 }
 366
 367 static void record_bad_sectors(secaddr bad_lo, secaddr bad_hi)
 368 {
 369   char fn[MAXFNSZ];
 370
 371   if (!mapfile) return;
 372
 373   open_file_on_demand(mapfile, &mapfp, "bad-sector region map");
 374   fprintf(mapfp, "%"PRIuSEC" %"PRIuSEC" # %"PRIuSEC" sectors",
 375           bad_lo, bad_hi, bad_hi - bad_lo);
 376
 377   if (file && id_kind(file->id) != RAW) {
 378     store_filename(fn, file->id);
 379     fprintf(mapfp, "; `%s' %"PRIuSEC" .. %"PRIuSEC" of %"PRIuSEC"",
 380             fn, bad_lo - file->start, bad_hi - file->start,
 381             file->end - file->start);
 382   }
 383
 384   fputc('\n', mapfp);
 385   check_write(mapfp, "bad-sector region map");
 386 }
 387
 388 static void recovered(secaddr bad_lo, secaddr bad_hi)
 389 {
 390   char fn[MAXFNSZ];
 391
 392   progress_clear(&progress);
 393
 394   if (!file || id_kind(file->id) == RAW)
 395     moan("skipping %"PRIuSEC" bad sectors (%"PRIuSEC" .. %"PRIuSEC")",
 396          bad_hi - bad_lo, bad_lo, bad_hi);
 397   else {
 398     store_filename(fn, file->id);
 399     moan("skipping %"PRIuSEC" bad sectors (%"PRIuSEC" .. %"PRIuSEC"; "
 400          "`%s' %"PRIuSEC" .. %"PRIuSEC" of %"PRIuSEC")",
 401          bad_hi - bad_lo, bad_lo, bad_hi,
 402          fn, bad_lo - file->start, bad_hi - file->start,
 403          file->end - file->start);
 404   }
 405
 406   record_bad_sectors(bad_lo, bad_hi);
 407
 408   if (lseek(outfd, (off_t)(bad_hi - bad_lo)*SECTORSZ, SEEK_CUR) < 0)
 409     bail_syserr(errno, "failed to seek past bad sectors");
 410
 411   progress_removeitem(&progress, &badblock_progress);
 412   progress_update(&progress);
 413 }
 414
 415 struct recoverybuf {
 416   unsigned char *buf;
 417   secaddr sz, pos, start, end;
 418   secaddr good_lo, good_hi;
 419 };
 420
 421 static void rearrange_sectors(struct recoverybuf *r,
 422                               secaddr dest, secaddr src, secaddr len)
 423 {
 424   assert(dest + len <= r->sz);
 425   assert(src + len <= r->sz);
 426   memmove(r->buf + dest*SECTORSZ, r->buf + src*SECTORSZ, len*SECTORSZ);
 427 }
 428
 429 #ifdef DEBUG
 430 static PRINTF_LIKE(2, 3)
 431   void show_recovery_buffer_map(const struct recoverybuf *r,
 432                                 const char *what, ...)
 433 {
 434   va_list ap;
 435
 436   va_start(ap, what);
 437   progress_clear(&progress);
 438   printf(";; recovery buffer (");
 439   vprintf(what, ap);
 440   printf("): "
 441          "(%"PRIuSEC") ..%"PRIuSEC".. "
 442          "[%"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC"] "
 443          "..%"PRIuSEC".. (%"PRIuSEC")\n",
 444          r->pos, r->start,
 445          r->pos + r->start, r->end - r->start, r->pos + r->end,
 446          r->sz - r->end, r->pos + r->sz);
 447   va_end(ap);
 448   assert(r->start <= r->end);
 449   assert(r->end <= r->sz);
 450 }
 451 #endif
 452
 453 static ssize_t recovery_read_sectors(struct recoverybuf *r,
 454                                      secaddr pos, secaddr off, secaddr want)
 455 {
 456   ssize_t n;
 457
 458   assert(off <= r->sz); assert(want <= r->sz - off);
 459   n = read_sectors(pos, r->buf + off*SECTORSZ, want);
 460   return (n);
 461 }
 462
 463 static ssize_t recovery_read_buffer(struct recoverybuf *r,
 464                                     secaddr pos, secaddr want)
 465 {
 466   secaddr diff, pp, nn;
 467   ssize_t n;
 468
 469 #ifdef DEBUG
 470   progress_clear(&progress);
 471   show_recovery_buffer_map(r, "begin(%"PRIuSEC", %"PRIuSEC")", pos, want);
 472 #endif
 473
 474   if (pos < r->pos) {
 475     diff = r->pos - pos;
 476     if (r->start + diff >= r->sz) {
 477       r->pos = pos; r->start = r->end = 0;
 478 #ifdef DEBUG
 479       show_recovery_buffer_map(r, "cleared; shift up by %"PRIuSEC"", diff);
 480 #endif
 481     } else {
 482       if (r->end + diff > r->sz) r->end = r->sz - diff;
 483       rearrange_sectors(r, r->start + diff, r->start, r->end - r->start);
 484       r->pos -= diff; r->start += diff; r->end += diff;
 485 #ifdef DEBUG
 486       show_recovery_buffer_map(r, "shifted up by %"PRIuSEC"", diff);
 487 #endif
 488     }
 489   } else if (pos > r->pos + r->end) {
 490     r->pos = pos; r->start = r->end = 0;
 491 #ifdef DEBUG
 492     show_recovery_buffer_map(r, "cleared; beyond previous region");
 493 #endif
 494   } else if (pos + want > r->pos + r->sz) {
 495     diff = (pos + want) - (r->pos + r->sz);
 496     if (r->end <= diff) {
 497       r->pos = pos; r->start = r->end = 0;
 498 #ifdef DEBUG
 499       show_recovery_buffer_map(r, "cleared; shift down by %"PRIuSEC"", diff);
 500 #endif
 501     } else {
 502       if (r->start < diff) r->start = diff;
 503       rearrange_sectors(r, r->start - diff, r->start, r->end - r->start);
 504       r->pos += diff; r->start -= diff; r->end -= diff;
 505 #ifdef DEBUG
 506       show_recovery_buffer_map(r, "shifted down by %"PRIuSEC"", diff);
 507 #endif
 508     }
 509   }
 510
 511   if (pos < r->pos + r->start) {
 512     pp = pos - r->pos; nn = r->start - pp;
 513 #ifdef DEBUG
 514     printf(";; read low (%"PRIuSEC"@%"PRIuSEC", %"PRIuSEC")", pos, pp, nn);
 515     fflush(stdout);
 516 #endif
 517     n = recovery_read_sectors(r, pos, pp, nn);
 518 #ifdef DEBUG
 519     printf(" -> %zd\n", n);
 520 #endif
 521     if (n != nn) {
 522       if (n >= 0 && n > want) n = want;
 523       goto end;
 524     }
 525     r->start = pp;
 526 #ifdef DEBUG
 527     show_recovery_buffer_map(r, "joined new region");
 528 #endif
 529   }
 530
 531   if (pos + want > r->pos + r->end) {
 532     pp = r->end; nn = (pos + want) - (r->pos + r->end);
 533 #ifdef DEBUG
 534     printf(";; read high (%"PRIuSEC"@%"PRIuSEC", %"PRIuSEC")",
 535            r->pos + pp, pp, nn);
 536     fflush(stdout);
 537 #endif
 538     n = recovery_read_sectors(r, r->pos + pp, pp, nn);
 539 #ifdef DEBUG
 540     printf(" -> %zd\n", n);
 541 #endif
 542     if (n > 0) {
 543       r->end += n;
 544 #ifdef DEBUG
 545       show_recovery_buffer_map(r, "joined new region");
 546 #endif
 547     }
 548   }
 549
 550   n = r->pos + r->end - pos;
 551   if (!n && want) n = -1;
 552   else if (n > want) n = want;
 553
 554 end:
 555 #ifdef DEBUG
 556   show_recovery_buffer_map(r, "done; return %zd", n);
 557 #endif
 558   return (n);
 559 }
 560
 561 static ssize_t recovery_read_multiple(struct recoverybuf *r,
 562                                       secaddr pos, secaddr want)
 563 {
 564   ssize_t n;
 565   secaddr skip, want0 = want;
 566
 567   while (want > r->sz) {
 568     skip = want - r->sz;
 569     n = recovery_read_buffer(r, pos + skip, r->sz);
 570     if (n < r->sz) return (skip + (n >= 0 ? n : 0));
 571     want -= r->sz;
 572   }
 573   n = recovery_read_buffer(r, pos, want);
 574   if (n < 0 || n < want) return (n);
 575   return (want0);
 576 }
 577
 578 static ssize_t recovery_read(struct recoverybuf *r,
 579                              secaddr pos, secaddr want)
 580 {
 581   secaddr lo = pos, hi = pos + want, span;
 582   ssize_t n;
 583
 584   if (hi < r->good_lo || lo > r->good_hi) {
 585     n = recovery_read_multiple(r, lo, hi - lo);
 586     if (n > 0) { r->good_lo = lo; r->good_hi = lo + n; }
 587     return (n);
 588   }
 589
 590   if (hi > r->good_hi) {
 591     span = hi - r->good_hi;
 592     n = recovery_read_multiple(r, r->good_hi, span);
 593     if (n > 0) r->good_hi += n;
 594     if (n < 0 || n < span) return (r->good_hi - lo);
 595   }
 596
 597   if (lo < r->good_lo) {
 598     span = r->good_lo - lo;
 599     n = recovery_read_multiple(r, lo, span);
 600     if (n == span) r->good_lo = lo;
 601     else return (n);
 602   }
 603
 604   n = r->good_hi - pos; if (n > want) n = want;
 605   if (!n) { errno = EIO; n = -1; }
 606   return (n);
 607 }
 608
 609 static double clear_factor = 1.5;
 610 static secaddr clear_min = 1, clear_max = SECLIMIT;
 611 static double step_factor = 2.0;
 612 static secaddr step_min = 1, step_max = 0;
 613
 614 static secaddr run_length_wanted(secaddr pos, secaddr badlen, secaddr end)
 615 {
 616   secaddr want;
 617
 618   want = clear_factor*badlen;
 619   if (want < clear_min) want = clear_min;
 620   if (want > end - pos) want = end - pos;
 621   if (clear_max && want > clear_max) want = clear_max;
 622   return (want);
 623 }
 624
 625 static void report_bad_blocks_progress(secaddr bad_hi, int err)
 626   { bad_err = err; report_progress(bad_hi); }
 627
 628 static ssize_t find_good_sector(secaddr *pos_inout, secaddr end,
 629                                 unsigned char *buf, secaddr sz)
 630 {
 631   secaddr pos = *pos_inout, bad_lo, bad_hi, good, step, want;
 632   struct recoverybuf r;
 633   ssize_t n;
 634
 635   bad_start = pos; bad_err = errno;
 636   badblock_progress.render = render_badblock_progress;
 637   progress_additem(&progress, &badblock_progress);
 638
 639   r.buf = buf; r.sz = sz; r.pos = r.start = r.end = 0;
 640   r.good_lo = r.good_hi = 0;
 641
 642   want = sz; if (want > end - pos) want = end - pos;
 643   for (retry = 0; retry < max_retries; retry++) {
 644     report_bad_blocks_progress(pos, errno);
 645     n = recovery_read(&r, pos, want);
 646 #ifdef DEBUG
 647     progress_clear(&progress);
 648     printf(";; [retry] try reading %"PRIuSEC" .. %"PRIuSEC" -> %zd\n",
 649            pos, pos + want, n);
 650 #endif
 651     if (n > 0) {
 652       progress_clear(&progress);
 653       moan("sector %"PRIuSEC" read ok after retry", pos);
 654       progress_removeitem(&progress, &badblock_progress);
 655       progress_update(&progress);
 656       return (n);
 657     }
 658   }
 659
 660   bad_lo = pos; bad_hi = pos + 1;
 661   for (;;) {
 662     report_bad_blocks_progress(bad_hi, errno);
 663 #ifdef DEBUG
 664     progress_clear(&progress);
 665     printf(";; bounding bad-block region: "
 666            "%"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC"\n",
 667            bad_lo, bad_hi - bad_lo, bad_hi);
 668 #endif
 669     if (bad_hi >= end) {
 670       progress_clear(&progress);
 671       moan("giving up on this extent");
 672       recovered(bad_lo, end); *pos_inout = end;
 673       return (0);
 674     }
 675     step = (step_factor - 1)*(bad_hi - bad_lo);
 676     if (step < step_min) step = step_min;
 677     if (step_max && step > step_max) step = step_max;
 678     if (step > end - bad_hi) step = end - bad_hi;
 679     pos = bad_hi + step - 1;
 680     want = run_length_wanted(pos, step, end);
 681     n = recovery_read(&r, pos, want);
 682 #ifdef DEBUG
 683     printf(";; [bound] try reading %"PRIuSEC" .. %"PRIuSEC" -> %zd\n",
 684            pos, pos + want, n);
 685 #endif
 686     if (n == want) break;
 687     if (n < 0) n = 0;
 688     bad_hi = pos + n + 1;
 689   }
 690
 691   good = pos;
 692   while (good > bad_hi) {
 693     report_bad_blocks_progress(bad_hi, errno);
 694 #ifdef DEBUG
 695     progress_clear(&progress);
 696     printf(";; limiting bad-block region: "
 697            "%"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC"\n",
 698            bad_lo, bad_hi - bad_lo, bad_hi, good - bad_hi, good);
 699 #endif
 700     pos = bad_hi + (good - bad_hi)/2;
 701     step = pos - bad_lo;
 702     want = run_length_wanted(pos, step, end);
 703     n = recovery_read(&r, pos, want);
 704 #ifdef DEBUG
 705     printf(";; [limit] try reading %"PRIuSEC" .. %"PRIuSEC" -> %zd\n",
 706            pos, pos + want, n);
 707 #endif
 708     if (n < 0) n = 0;
 709     if (n == want) good = pos;
 710     else bad_hi = pos + n + 1;
 711   }
 712   recovered(bad_lo, bad_hi); *pos_inout = bad_hi;
 713   if (bad_hi < r.pos + r.start || r.pos + r.end <= bad_hi)
 714     n = 0;
 715   else {
 716     n = r.pos + r.end - bad_hi;
 717     rearrange_sectors(&r, 0, bad_hi - r.pos, n);
 718   }
 719 #ifdef DEBUG
 720   show_recovery_buffer_map(&r, "returning %zd good sectors at %"PRIuSEC"",
 721                            n, bad_hi);
 722 #endif
 723   return (n);
 724 }
 725
 726 static void emit(secaddr start, secaddr end)
 727 {
 728 #define BUFSECTORS 512
 729
 730   int least;
 731   unsigned char buf[BUFSECTORS*SECTORSZ];
 732   secaddr pos;
 733   size_t want;
 734   ssize_t n;
 735   static int first_time = 1;
 736 #ifdef DEBUG
 737   struct file *f;
 738   char fn[MAXFNSZ];
 739   int act = -1;
 740   int i;
 741 #endif
 742
 743   least = least_live();
 744
 745 #ifdef DEBUG
 746   printf(";; %8"PRIuSEC" .. %"PRIuSEC"\n", start, end);
 747
 748   for (i = 0; i < filetab.n; i++) {
 749     if (!livep(i)) continue;
 750     if (act == -1) act = i;
 751     f = &filetab.v[i]; store_filename(fn, f->id);
 752     printf(";;\t\t%8"PRIuSEC" .. %-8"PRIuSEC" %s\n",
 753            start - f->start, end - f->start, fn);
 754   }
 755   if (act == -1) printf(";;\t\t#<no live source>\n");
 756   assert(act == least);
 757 #endif
 758
 759   if (least == -1)
 760     { file = 0; vob = 0; }
 761   else {
 762     file = &filetab.v[least];
 763     switch (id_kind(file->id)) {
 764       case RAW:
 765         vob = 0;
 766         break;
 767       case VOB:
 768         if (first_time) { progress_clear(&progress); first_time = 0; }
 769         vob = DVDOpenFile(dvd, id_title(file->id),
 770                           id_part(file->id)
 771                             ? DVD_READ_TITLE_VOBS
 772                             : DVD_READ_MENU_VOBS);
 773         if (!vob)
 774           bail("failed to open %s %u",
 775                id_part(file->id) ? "title" : "menu",
 776                id_title(file->id));
 777         progress_update(&progress);
 778         break;
 779       default:
 780         abort();
 781     }
 782   }
 783
 784   if (file && id_kind(file->id) != RAW) {
 785     file_progress.render = render_file_progress;
 786     progress_additem(&progress, &file_progress);
 787   }
 788
 789   pos = start;
 790   while (pos < end) {
 791     want = end - pos; if (want > BUFSECTORS) want = BUFSECTORS;
 792     n = read_sectors(pos, buf, want);
 793
 794     if (n <= 0) n = find_good_sector(&pos, end, buf, BUFSECTORS);
 795     if (n > 0) { carefully_write(outfd, buf, n*SECTORSZ); pos += n; }
 796     report_progress(pos);
 797   }
 798
 799   if (vob) { DVDCloseFile(vob); vob = 0; }
 800
 801   if (file && id_kind(file->id) != RAW)
 802     progress_removeitem(&progress, &file_progress);
 803   progress_update(&progress);
 804
 805 #undef BUFSECTORS
 806 }
 807
 808 #define PRF_HYPHEN 1u
 809 static int parse_range(const char *p, unsigned f,
 810                        secaddr *start_out, secaddr *end_out)
 811 {
 812   char *q;
 813   int err, rc;
 814   unsigned long start, end;
 815
 816   err = errno;
 817
 818   if (ISDIGIT(*p)) {
 819     start = strtoul(p, &q, 0);
 820     if (errno || start >= SECLIMIT) { rc = -1; goto end; }
 821     *start_out = start; p = q;
 822   } else if (!(f&PRF_HYPHEN))
 823     { rc = -1; goto end; }
 824   else
 825     start = 0;
 826
 827   if (f&PRF_HYPHEN) {
 828     if (*p != '-')  { rc = -1; goto end; }
 829     p++;
 830   } else {
 831     if (!ISSPACE(*p)) { rc = -1; goto end; }
 832     do p++; while (ISSPACE(*p));
 833   }
 834
 835   if (ISDIGIT(*p)) {
 836     end = strtoul(p, &q, 0);
 837     if (errno || end > SECLIMIT || end < start) { rc = -1; goto end; }
 838     *end_out = end; p = q;
 839   } else if (!(f&PRF_HYPHEN))
 840     { rc = -1; goto end; }
 841
 842   if (!(f&PRF_HYPHEN)) while (ISSPACE(*p)) p++;
 843   if (*p && ((f&PRF_HYPHEN) || *p != '#')) { rc = -1; goto end; }
 844
 845   rc = 0;
 846 end:
 847   errno = err;
 848   return (rc);
 849 }
 850
 851 #ifdef DEBUG
 852 static void dump_eventq(const char *what)
 853 {
 854   unsigned i;
 855   const struct event *ev;
 856   char fn[MAXFNSZ];
 857
 858   printf("\n;; event dump (%s):\n", what);
 859   for (i = 0; i < eventq.n; i++) {
 860     ev = &eventq.v[i];
 861     switch (ev->ev) {
 862       case EV_BEGIN:
 863         store_filename(fn, filetab.v[ev->file].id);
 864         printf(";; %8"PRIuSEC": begin %s\n", ev->pos, fn);
 865         break;
 866       case EV_END:
 867         store_filename(fn, filetab.v[ev->file].id);
 868         printf(";; %8"PRIuSEC": end %s\n", ev->pos, fn);
 869         break;
 870       case EV_WRITE:
 871         printf(";; %8"PRIuSEC": write\n", ev->pos);
 872         break;
 873       case EV_STOP:
 874         printf(";; %8"PRIuSEC": stop\n", ev->pos);
 875         break;
 876       default:
 877         printf(";; %8"PRIuSEC": ?%u\n", ev->pos, ev->ev);
 878         break;
 879     }
 880   }
 881 }
 882 #endif
 883
 884 int main(int argc, char *argv[])
 885 {
 886   unsigned f = 0;
 887   const char *p;
 888   off_t volsz;
 889   secaddr pos;
 890   off_t off;
 891   secaddr start, end, last;
 892   const struct event *ev;
 893   const char *device, *outfile;
 894   struct badblock *bad;
 895   int opt, blksz;
 896   size_t i;
 897   FILE *fp;
 898   struct buf buf = BUF_INIT;
 899   struct timeval tv0, tv1;
 900   double t, rate, tot;
 901   const char *rateunit, *totunit;
 902   char timebuf[TIMESTRMAX], id_in[MAXIDSZ], id_out[MAXIDSZ];
 903   dvd_reader_t *dvd_out;
 904 #ifdef DEBUG
 905   const struct file *file;
 906   char fn[MAXFNSZ];
 907 #endif
 908
 909 #define f_bogus 1u
 910 #define f_continue 2u
 911 #define f_fixup 4u
 912 #define f_stats 8u
 913 #define f_checkid 16u
 914 #define f_write 256u
 915
 916   set_prog(argv[0]);
 917   for (;;) {
 918     opt = getopt(argc, argv, "hB:E:FR:X:b:cir:s"); if (opt < 0) break;
 919     switch (opt) {
 920       case 'h': usage(stderr); exit(0);
 921       case 'B':
 922         p = optarg;
 923 #define SKIP_PREFIX(s)                                                  \
 924         (STRNCMP(p, ==, s "=", sizeof(s)) && (p += sizeof(s), 1))
 925         for (;;) {
 926           if (SKIP_PREFIX("cf"))
 927             clear_factor = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
 928                                        "clear factor");
 929           else if (SKIP_PREFIX("cmin"))
 930             clear_min = parse_int(&p, PNF_JUNK, 1, SECLIMIT,
 931                                   "clear minimum");
 932           else if (SKIP_PREFIX("cmax"))
 933             clear_max = parse_int(&p, PNF_JUNK, 1, SECLIMIT,
 934                                   "clear maximum");
 935           else if (SKIP_PREFIX("sf"))
 936             step_factor = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
 937                                       "step factor");
 938           else if (SKIP_PREFIX("smin"))
 939             step_min = parse_int(&p, PNF_JUNK, 1, SECLIMIT - 1,
 940                                  "step minimum");
 941           else if (SKIP_PREFIX("smax"))
 942             step_max = parse_int(&p, PNF_JUNK, 1, SECLIMIT - 1,
 943                                  "step maximum");
 944           else if (SKIP_PREFIX("retry"))
 945             max_retries = parse_int(&p, PNF_JUNK, 0, INT_MAX, "retries");
 946           else if (SKIP_PREFIX("alpha"))
 947             alpha = parse_float(&p, PNF_JUNK, 0, 1, "average decay factor");
 948           else if (SKIP_PREFIX("_badwait"))
 949             bad_block_delay = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
 950                                           "bad-block delay");
 951           else if (SKIP_PREFIX("_blkwait"))
 952             good_block_delay = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
 953                                            "good block delay");
 954           else
 955             bail("unknown bad blocks parameter `%s'", p);
 956           if (!*p) break;
 957           else if (*p != ',') bail("unexpected junk in parameters");
 958           p++;
 959         }
 960 #undef SKIP_PREFIX
 961         break;
 962       case 'E': errfile = optarg; break;
 963       case 'F': f |= f_fixup; break;
 964       case 'R':
 965         fp = fopen(optarg, "r");
 966         if (!fp)
 967           bail_syserr(errno, "failed to open ranges file `%s'", optarg);
 968         i = 0; last = -1;
 969         for (;;) {
 970           buf_rewind(&buf); if (read_line(fp, &buf)) break;
 971           p = buf.p; i++;
 972           while (ISSPACE(*p)) p++;
 973           if (!*p || *p == '#') continue;
 974           if (parse_range(p, 0, &start, &end) ||
 975               (last <= SECLIMIT && start < last))
 976             bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
 977           if (start < end) {
 978             if (start == last)
 979               eventq.v[eventq.n - 1].pos = end;
 980             else {
 981               put_event(EV_WRITE, 0, start);
 982               put_event(EV_STOP, 0, end);
 983             }
 984             last = end;
 985           }
 986         }
 987         if (ferror(fp))
 988           bail_syserr(errno, "failed to read ranges file `%s'", optarg);
 989         break;
 990       case 'X':
 991         fp = fopen(optarg, "r");
 992         if (!fp)
 993           bail_syserr(errno, "failed to open bad-blocks file `%s'", optarg);
 994         i = 0; last = -1;
 995         for (;;) {
 996           buf_rewind(&buf); if (read_line(fp, &buf)) break;
 997           p = buf.p; i++;
 998           while (ISSPACE(*p)) p++;
 999           if (!*p || *p == '#') continue;
1000           if (parse_range(p, 0, &start, &end) ||
1001               (last <= SECLIMIT && start < last))
1002             bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
1003           if (start < end)
1004             { VEC_PUSH(bad, &badblocks); bad->start = start; bad->end = end; }
1005         }
1006         if (ferror(fp))
1007           bail_syserr(errno, "failed to read bad-blocks file `%s'", optarg);
1008         break;
1009       case 'b':
1010         if (mapfile) bail("can't have multiple map files");
1011         mapfile = optarg;
1012         break;
1013       case 'c': f |= f_continue; break;
1014       case 'i': f |= f_checkid; break;
1015       case 'r':
1016         start = 0; end = -1;
1017         if (parse_range(optarg, PRF_HYPHEN, &start, &end))
1018           bail("bad range `%s'", optarg);
1019         if (start < end) {
1020           put_event(EV_WRITE, 0, start);
1021           if (end <= SECLIMIT) put_event(EV_STOP, 0, end);
1022         }
1023         break;
1024       case 's': f |= f_stats; break;
1025       default: f |= f_bogus; break;
1026     }
1027   }
1028   if (argc - optind != 2) f |= f_bogus;
1029   if (f&f_bogus) { usage(stderr); exit(2); }
1030
1031   setlocale(LC_ALL, "");
1032   progress_init(&progress);
1033   device = argv[optind]; outfile = argv[optind + 1];
1034
1035   if (badblocks.n) {
1036     qsort(badblocks.v, badblocks.n, sizeof(struct badblock),
1037           compare_badblock);
1038 #ifdef DEBUG
1039     printf(";; fake bad blocks:\n");
1040     for (i = 0; i < badblocks.n; i++)
1041       printf(";;\t%8"PRIuSEC" .. %"PRIuSEC"\n",
1042              badblocks.v[i].start, badblocks.v[i].end);
1043 #endif
1044   }
1045
1046   if (open_dvd(device, O_RDONLY, &dvdfd, &dvd)) exit(2);
1047
1048   blksz = SECTORSZ; volsz = device_size(dvdfd, device, &blksz);
1049   if (blksz != SECTORSZ)
1050     bail("device `%s' block size %d /= %d", device, blksz, SECTORSZ);
1051   if (volsz%SECTORSZ)
1052     bail("device `%s' volume size %"PRIu64" not a multiple of %d",
1053          device, volsz, SECTORSZ);
1054
1055   if (f&f_checkid) {
1056     if (open_dvd(outfile, O_RDONLY, 0, &dvd_out)) exit(2);
1057     if (dvd_id(id_in, dvd, DIF_MUSTIFOHASH, device) ||
1058         dvd_id(id_out, dvd_out, DIF_MUSTIFOHASH, device))
1059       exit(2);
1060     if (STRCMP(id_in, !=, id_out))
1061       bail("DVD id mismatch: input `%s' is `%s'; output `%s' is `%s'",
1062            device, id_in, outfile, id_out);
1063   }
1064
1065   outfd = open(outfile, O_WRONLY | O_CREAT, 0666);
1066   if (outfd < 0)
1067     bail_syserr(errno, "failed to create output file `%s'", outfile);
1068
1069   if (f&f_continue) {
1070     off = lseek(outfd, 0, SEEK_END);
1071     if (off < 0)
1072       bail_syserr(errno, "failed to seek to end of output file `%s'",
1073                   outfile);
1074     put_event(EV_WRITE, 0, off/SECTORSZ);
1075   } else if (!eventq.n && !(f&f_fixup))
1076     put_event(EV_WRITE, 0, 0);
1077
1078   /* It's fast enough just to check everything. */
1079   put_menu(dvd, 0);
1080   for (i = 1; i < 100; i++) {
1081     put_menu(dvd, i);
1082     put_title(dvd, i);
1083   }
1084   put_file(mkident(RAW, 0, 0), 0, volsz/SECTORSZ);
1085   assert(filetab.n <= MAXFILES);
1086
1087   for (i = 0, limit = 0; i < filetab.n; i++)
1088     if (filetab.v[i].end > limit) limit = filetab.v[i].end;
1089
1090   if (end > limit) end = limit;
1091
1092 #ifdef DEBUG
1093   printf("\n;; files:\n");
1094   for (i = 0; i < filetab.n; i++) {
1095     file = &filetab.v[i];
1096     store_filename(fn, file->id);
1097     printf(";;\t%8"PRIuSEC" .. %-8"PRIuSEC" %s\n",
1098            file->start, file->end, fn);
1099   }
1100 #endif
1101
1102   qsort(eventq.v, eventq.n, sizeof(struct event), compare_event);
1103
1104   f &= ~f_write; start = 0;
1105   for (i = 0; i < eventq.n; i++) {
1106     ev = &eventq.v[i];
1107     switch (ev->ev) {
1108       case EV_WRITE:
1109         if (f&f_write)
1110           bail("overlapping ranges: range from %"PRIuSEC" "
1111                "still open at %"PRIuSEC"",
1112                start, ev->pos);
1113         f |= f_write; start = ev->pos;
1114         break;
1115       case EV_STOP:
1116         f &= ~f_write;
1117         break;
1118     }
1119   }
1120
1121 #ifdef DEBUG
1122   dump_eventq("initial");
1123 #endif
1124   f &= ~f_write; start = 0;
1125   for (i = 0; i < eventq.n; i++) {
1126     ev = &eventq.v[i];
1127     if (ev->ev == EV_WRITE) { start = ev->pos; f |= f_write; }
1128     if (ev->pos >= limit) break;
1129     if (ev->ev == EV_STOP) { nsectors += ev->pos - start; f &= ~f_write; }
1130     if (f&f_fixup) start = ev->pos;
1131   }
1132   eventq.n = i;
1133 #ifdef DEBUG
1134   dump_eventq("trimmed");
1135 #endif
1136   if (f&f_fixup) {
1137     put_event(EV_WRITE, 0, start);
1138     f |= f_write;
1139   }
1140   if (f&f_write) {
1141     nsectors += limit - start;
1142     put_event(EV_STOP, 0, limit);
1143   }
1144 #ifdef DEBUG
1145   dump_eventq("final");
1146 #endif
1147
1148   copy_progress.render = render_copy_progress;
1149   progress_additem(&progress, &copy_progress);
1150   if (nsectors == limit - start)
1151     { ndone = start; nsectors = limit; }
1152   else {
1153     disc_progress.render = render_disc_progress;
1154     progress_additem(&progress, &disc_progress);
1155   }
1156
1157   if (f&f_stats) gettimeofday(&tv0, 0);
1158
1159 #ifdef DEBUG
1160   printf("\n;; event sweep:\n");
1161 #endif
1162   f &= ~f_write;
1163   for (pos = 0, i = 0; i < eventq.n; i++) {
1164     ev = &eventq.v[i];
1165     if (ev->pos > pos) {
1166       if (f&f_write) emit(pos, ev->pos);
1167       pos = ev->pos;
1168 #ifdef DEBUG
1169       progress_clear(&progress);
1170       printf(";;\n");
1171 #endif
1172     }
1173     switch (ev->ev) {
1174       case EV_BEGIN:
1175         set_live(ev->file);
1176 #ifdef DEBUG
1177         store_filename(fn, filetab.v[ev->file].id);
1178         progress_clear(&progress);
1179         printf(";; %8"PRIuSEC": begin `%s'\n", pos, fn);
1180 #endif
1181         break;
1182       case EV_WRITE:
1183         gettimeofday(&last_time, 0); last_pos = pos;
1184         if (lseek(outfd, (off_t)ev->pos*SECTORSZ, SEEK_SET) < 0)
1185           bail_syserr(errno,
1186                       "failed to seek to resume position "
1187                       "(sector %"PRIuSEC") in output file `%s'",
1188                       ev->pos, outfile);
1189 #ifdef DEBUG
1190         progress_clear(&progress);
1191         printf(";; %8"PRIuSEC": begin write\n", pos);
1192 #endif
1193         f |= f_write;
1194         break;
1195       case EV_STOP:
1196         f &= ~f_write;
1197 #ifdef DEBUG
1198         progress_clear(&progress);
1199         printf(";; %8"PRIuSEC": end write\n", pos);
1200 #endif
1201         break;
1202       case EV_END:
1203         clear_live(ev->file);
1204 #ifdef DEBUG
1205         store_filename(fn, filetab.v[ev->file].id);
1206         progress_clear(&progress);
1207         printf(";; %8"PRIuSEC": end `%s'\n", pos, fn);
1208 #endif
1209         break;
1210       default: abort();
1211     }
1212   }
1213
1214   progress_clear(&progress);
1215
1216   if (ftruncate(outfd, (off_t)limit*SECTORSZ) < 0)
1217     bail_syserr(errno, "failed to set output file `%s' length", outfile);
1218
1219   if (f&f_stats) {
1220     gettimeofday(&tv1, 0); t = tvdiff(&tv0, &tv1);
1221     if (nsectors == limit) { ndone -= start; nsectors -= start; }
1222     tot = scale_bytes((double)nsectors*SECTORSZ, &totunit);
1223     rate = scale_bytes((double)nsectors*SECTORSZ/t, &rateunit);
1224     moan("all done: %.1f %sB in %s -- %.1f %sB/s",
1225          tot, totunit, fmttime(t, timebuf), rate, rateunit);
1226   }
1227
1228   if (dvd) DVDClose(dvd);
1229   if (dvdfd >= 0) close(dvdfd);
1230   if (outfd >= 0) close(outfd);
1231   carefully_fclose(mapfp, "bad-sector region map");
1232   carefully_fclose(errfp, "bad-sector error log");
1233   progress_free(&progress);
1234
1235 #undef f_bogus
1236 #undef f_continue
1237 #undef f_fixup
1238 #undef f_stats
1239 #undef f_write
1240
1241   return (0);
1242 }