~mdw / dvdrip / blob
? search:


8c4ba1fcdab3ca79bc8c3926237297521bae1d32
[dvdrip] / 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
340 done = 0; errno = 0;
341 while (want) {
342 if (vob)
343 { errno = 0; n = DVDReadBlocks(vob, pos - file->start, want, p); }
344 else if (file) {
345 if (lseek(dvdfd, (off_t)pos*SECTORSZ, SEEK_SET) < 0)
346 bail_syserr(errno, "failed to seek to sector %"PRIuSEC"", pos);
347 errno = 0; n = read(dvdfd, p, want*SECTORSZ);
348 if (n >= 0) n /= SECTORSZ;
349 } else {
350 memset(p, 0, want*SECTORSZ);
351 n = want;
352 }
353
354 if (n > 0) { done += n; pos += n; p += n*SECTORSZ; want -= n; }
355 else if (!n) break;
356 else if (errno == EIO && errfile) {
357 open_file_on_demand(errfile, &errfp, "bad-sector error log");
358 fprintf(errfp, "%"PRIuSEC" %"PRIuSEC"\n", pos, pos + 1);
359 check_write(errfp, "bad-sector error log");
360 break;
361 } else if (errno != EINTR) break;
362 }
363 if (fakeerr && !errno) errno = fakeerr;
364 else if (done > 0 && good_block_delay) sit(done*good_block_delay);
365 return (!done && errno ? -1 : done);
366 }
367
368 static void recovered(secaddr bad_lo, secaddr bad_hi)
369 {
370 char fn[MAXFNSZ];
371
372 progress_clear(&progress);
373
374 if (!file || id_kind(file->id) == RAW)
375 moan("skipping %"PRIuSEC" bad sectors (%"PRIuSEC" .. %"PRIuSEC")",
376 bad_hi - bad_lo, bad_lo, bad_hi);
377 else {
378 store_filename(fn, file->id);
379 moan("skipping %"PRIuSEC" bad sectors (%"PRIuSEC" .. %"PRIuSEC"; "
380 "`%s' %"PRIuSEC" .. %"PRIuSEC" of %"PRIuSEC")",
381 bad_hi - bad_lo, bad_lo, bad_hi,
382 fn, bad_lo - file->start, bad_hi - file->start,
383 file->end - file->start);
384 }
385
386 if (mapfile) {
387 open_file_on_demand(mapfile, &mapfp, "bad-sector region map");
388 fprintf(mapfp, "%"PRIuSEC" %"PRIuSEC" # %"PRIuSEC" sectors",
389 bad_lo, bad_hi, bad_hi - bad_lo);
390
391 if (file && id_kind(file->id) != RAW)
392 fprintf(mapfp, "; `%s' %"PRIuSEC" .. %"PRIuSEC" of %"PRIuSEC"",
393 fn, bad_lo - file->start, bad_hi - file->start,
394 file->end - file->start);
395
396 fputc('\n', mapfp);
397 check_write(mapfp, "bad-sector region map");
398 }
399
400 if (lseek(outfd, (off_t)(bad_hi - bad_lo)*SECTORSZ, SEEK_CUR) < 0)
401 bail_syserr(errno, "failed to seek past bad sectors");
402
403 progress_removeitem(&progress, &badblock_progress);
404 progress_update(&progress);
405 }
406
407 struct recoverybuf {
408 unsigned char *buf;
409 secaddr sz, pos, start, end;
410 secaddr good_lo, good_hi;
411 };
412
413 static void rearrange_sectors(struct recoverybuf *r,
414 secaddr dest, secaddr src, secaddr len)
415 {
416 assert(dest + len <= r->sz);
417 assert(src + len <= r->sz);
418 memmove(r->buf + dest*SECTORSZ, r->buf + src*SECTORSZ, len*SECTORSZ);
419 }
420
421 #ifdef DEBUG
422 static PRINTF_LIKE(2, 3)
423 void show_recovery_buffer_map(const struct recoverybuf *r,
424 const char *what, ...)
425 {
426 va_list ap;
427
428 va_start(ap, what);
429 progress_clear(&progress);
430 printf(";; recovery buffer (");
431 vprintf(what, ap);
432 printf("): "
433 "(%"PRIuSEC") ..%"PRIuSEC".. "
434 "[%"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC"] "
435 "..%"PRIuSEC".. (%"PRIuSEC")\n",
436 r->pos, r->start,
437 r->pos + r->start, r->end - r->start, r->pos + r->end,
438 r->sz - r->end, r->pos + r->sz);
439 va_end(ap);
440 assert(r->start <= r->end);
441 assert(r->end <= r->sz);
442 }
443 #endif
444
445 static ssize_t recovery_read_sectors(struct recoverybuf *r,
446 secaddr pos, secaddr off, secaddr want)
447 {
448 ssize_t n;
449
450 assert(off <= r->sz); assert(want <= r->sz - off);
451 assert(pos == r->pos + off);
452 n = read_sectors(pos, r->buf + off*SECTORSZ, want);
453 return (n);
454 }
455
456 static ssize_t recovery_read_buffer(struct recoverybuf *r,
457 secaddr pos, secaddr want)
458 {
459 secaddr diff, pp, nn;
460 ssize_t n;
461
462 #ifdef DEBUG
463 progress_clear(&progress);
464 show_recovery_buffer_map(r, "begin(%"PRIuSEC", %"PRIuSEC")", pos, want);
465 #endif
466
467 if (pos < r->pos) {
468 diff = r->pos - pos;
469 if (r->start + diff >= r->sz) {
470 r->pos = pos; r->start = r->end = 0;
471 #ifdef DEBUG
472 show_recovery_buffer_map(r, "cleared; shift up by %"PRIuSEC"", diff);
473 #endif
474 } else {
475 if (r->end + diff > r->sz) r->end = r->sz - diff;
476 rearrange_sectors(r, r->start + diff, r->start, r->end - r->start);
477 r->pos -= diff; r->start += diff; r->end += diff;
478 #ifdef DEBUG
479 show_recovery_buffer_map(r, "shifted up by %"PRIuSEC"", diff);
480 #endif
481 }
482 } else if (pos > r->pos + r->end) {
483 r->pos = pos; r->start = r->end = 0;
484 #ifdef DEBUG
485 show_recovery_buffer_map(r, "cleared; beyond previous region");
486 #endif
487 } else if (pos + want > r->pos + r->sz) {
488 diff = (pos + want) - (r->pos + r->sz);
489 if (r->end <= diff) {
490 r->pos = pos; r->start = r->end = 0;
491 #ifdef DEBUG
492 show_recovery_buffer_map(r, "cleared; shift down by %"PRIuSEC"", diff);
493 #endif
494 } else {
495 if (r->start < diff) r->start = diff;
496 rearrange_sectors(r, r->start - diff, r->start, r->end - r->start);
497 r->pos += diff; r->start -= diff; r->end -= diff;
498 #ifdef DEBUG
499 show_recovery_buffer_map(r, "shifted down by %"PRIuSEC"", diff);
500 #endif
501 }
502 }
503
504 if (pos < r->pos + r->start) {
505 pp = pos - r->pos; nn = r->start - pp;
506 #ifdef DEBUG
507 printf(";; read low (%"PRIuSEC"@%"PRIuSEC", %"PRIuSEC")", pos, pp, nn);
508 fflush(stdout);
509 #endif
510 n = recovery_read_sectors(r, pos, pp, nn);
511 #ifdef DEBUG
512 printf(" -> %zd\n", n);
513 #endif
514 if (n != nn) {
515 if (n >= 0 && n > want) n = want;
516 goto end;
517 }
518 r->start = pp;
519 #ifdef DEBUG
520 show_recovery_buffer_map(r, "joined new region");
521 #endif
522 }
523
524 if (pos + want > r->pos + r->end) {
525 pp = r->end; nn = (pos + want) - (r->pos + r->end);
526 #ifdef DEBUG
527 printf(";; read high (%"PRIuSEC"@%"PRIuSEC", %"PRIuSEC")",
528 r->pos + pp, pp, nn);
529 fflush(stdout);
530 #endif
531 n = recovery_read_sectors(r, r->pos + pp, pp, nn);
532 #ifdef DEBUG
533 printf(" -> %zd\n", n);
534 #endif
535 if (n > 0) {
536 r->end += n;
537 #ifdef DEBUG
538 show_recovery_buffer_map(r, "joined new region");
539 #endif
540 }
541 }
542
543 n = r->pos + r->end - pos;
544 if (!n && want) n = -1;
545 else if (n > want) n = want;
546
547 end:
548 #ifdef DEBUG
549 show_recovery_buffer_map(r, "done; return %zd", n);
550 #endif
551 return (n);
552 }
553
554 static ssize_t recovery_read_multiple(struct recoverybuf *r,
555 secaddr pos, secaddr want)
556 {
557 ssize_t n;
558 secaddr skip, want0 = want;
559
560 while (want > r->sz) {
561 skip = want - r->sz;
562 n = recovery_read_buffer(r, pos + skip, r->sz);
563 if (n < r->sz) return (skip + (n >= 0 ? n : 0));
564 want -= r->sz;
565 }
566 n = recovery_read_buffer(r, pos, want);
567 if (n < 0 || n < want) return (n);
568 return (want0);
569 }
570
571 static ssize_t recovery_read(struct recoverybuf *r,
572 secaddr pos, secaddr want)
573 {
574 secaddr lo = pos, hi = pos + want, span;
575 ssize_t n;
576
577 if (hi < r->good_lo || lo > r->good_hi) {
578 n = recovery_read_multiple(r, lo, hi - lo);
579 if (n > 0) { r->good_lo = lo; r->good_hi = lo + n; }
580 return (n);
581 }
582
583 if (hi > r->good_hi) {
584 span = hi - r->good_hi;
585 n = recovery_read_multiple(r, r->good_hi, span);
586 if (n > 0) r->good_hi += n;
587 if (n < 0 || n < span) return (r->good_hi - lo);
588 }
589
590 if (lo < r->good_lo) {
591 span = r->good_lo - lo;
592 n = recovery_read_multiple(r, lo, span);
593 if (n == span) r->good_lo = lo;
594 else return (n);
595 }
596
597 n = r->good_hi - pos; if (n > want) n = want;
598 if (!n) { errno = EIO; n = -1; }
599 return (n);
600 }
601
602 static double clear_factor = 1.5;
603 static secaddr clear_min = 1, clear_max = SECLIMIT;
604 static double step_factor = 2.0;
605 static secaddr step_min = 1, step_max = 0;
606
607 static secaddr run_length_wanted(secaddr pos, secaddr badlen, secaddr end)
608 {
609 secaddr want;
610
611 want = ceil(clear_factor*badlen);
612 if (want < clear_min) want = clear_min;
613 if (want > end - pos) want = end - pos;
614 if (clear_max && want > clear_max) want = clear_max;
615 return (want);
616 }
617
618 static void report_bad_blocks_progress(secaddr bad_hi, int err)
619 { bad_err = err; report_progress(bad_hi); }
620
621 static ssize_t find_good_sector(secaddr *pos_inout, secaddr end,
622 unsigned char *buf, secaddr sz)
623 {
624 secaddr pos = *pos_inout, bad_lo, bad_hi, good, step, want;
625 struct recoverybuf r;
626 ssize_t n;
627
628 bad_start = pos; bad_err = errno;
629 badblock_progress.render = render_badblock_progress;
630 progress_additem(&progress, &badblock_progress);
631
632 want = sz; if (want > end - pos) want = end - pos;
633 for (retry = 0; retry < max_retries; retry++) {
634 report_bad_blocks_progress(pos, errno);
635 n = read_sectors(pos, buf, want);
636 #ifdef DEBUG
637 progress_clear(&progress);
638 printf(";; [retry] try reading %"PRIuSEC" .. %"PRIuSEC" -> %zd\n",
639 pos, pos + want, n);
640 #endif
641 if (n > 0) {
642 progress_clear(&progress);
643 moan("sector %"PRIuSEC" read ok after retry", pos);
644 progress_removeitem(&progress, &badblock_progress);
645 progress_update(&progress);
646 return (n);
647 }
648 }
649
650 r.buf = buf; r.sz = sz; r.pos = r.start = r.end = 0;
651 r.good_lo = r.good_hi = 0;
652
653 bad_lo = pos; bad_hi = pos + 1;
654 for (;;) {
655 report_bad_blocks_progress(bad_hi, errno);
656 #ifdef DEBUG
657 progress_clear(&progress);
658 printf(";; bounding bad-block region: "
659 "%"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC"\n",
660 bad_lo, bad_hi - bad_lo, bad_hi);
661 #endif
662 if (bad_hi >= end) {
663 progress_clear(&progress);
664 moan("giving up on this extent");
665 recovered(bad_lo, end); *pos_inout = end;
666 return (0);
667 }
668 step = (step_factor - 1)*(bad_hi - bad_lo);
669 if (step < step_min) step = step_min;
670 if (step_max && step > step_max) step = step_max;
671 if (step > end - bad_hi) step = end - bad_hi;
672 pos = bad_hi + step - 1;
673 want = run_length_wanted(pos, step, end);
674 n = recovery_read(&r, pos, want);
675 #ifdef DEBUG
676 printf(";; [bound] try reading %"PRIuSEC" .. %"PRIuSEC" -> %zd\n",
677 pos, pos + want, n);
678 #endif
679 if (n == want) break;
680 if (n < 0) n = 0;
681 bad_hi = pos + n + 1;
682 }
683
684 good = pos;
685 while (good > bad_hi) {
686 report_bad_blocks_progress(bad_hi, errno);
687 #ifdef DEBUG
688 progress_clear(&progress);
689 printf(";; limiting bad-block region: "
690 "%"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC" ..%"PRIuSEC".. %"PRIuSEC"\n",
691 bad_lo, bad_hi - bad_lo, bad_hi, good - bad_hi, good);
692 #endif
693 pos = bad_hi + (good - bad_hi)/2;
694 step = pos - bad_lo;
695 want = run_length_wanted(pos, step, end);
696 n = recovery_read(&r, pos, want);
697 #ifdef DEBUG
698 printf(";; [limit] try reading %"PRIuSEC" .. %"PRIuSEC" -> %zd\n",
699 pos, pos + want, n);
700 #endif
701 if (n < 0) n = 0;
702 if (n == want) good = pos;
703 else bad_hi = pos + n + 1;
704 }
705 recovered(bad_lo, bad_hi); *pos_inout = bad_hi;
706 if (bad_hi < r.pos + r.start || r.pos + r.end <= bad_hi)
707 n = 0;
708 else {
709 n = r.pos + r.end - bad_hi;
710 rearrange_sectors(&r, 0, bad_hi - r.pos, n);
711 }
712 #ifdef DEBUG
713 show_recovery_buffer_map(&r, "returning %zd good sectors at %"PRIuSEC"",
714 n, bad_hi);
715 #endif
716 return (n);
717 }
718
719 static void emit(secaddr start, secaddr end)
720 {
721 #define BUFSECTORS 512
722
723 int least;
724 unsigned char buf[BUFSECTORS*SECTORSZ];
725 secaddr pos;
726 size_t want;
727 ssize_t n;
728 static int first_time = 1;
729 #ifdef DEBUG
730 struct file *f;
731 char fn[MAXFNSZ];
732 int act = -1;
733 int i;
734 #endif
735
736 least = least_live();
737
738 #ifdef DEBUG
739 printf(";; %8"PRIuSEC" .. %"PRIuSEC"\n", start, end);
740
741 for (i = 0; i < filetab.n; i++) {
742 if (!livep(i)) continue;
743 if (act == -1) act = i;
744 f = &filetab.v[i]; store_filename(fn, f->id);
745 printf(";;\t\t%8"PRIuSEC" .. %-8"PRIuSEC" %s\n",
746 start - f->start, end - f->start, fn);
747 }
748 if (act == -1) printf(";;\t\t#<no live source>\n");
749 assert(act == least);
750 #endif
751
752 if (least == -1)
753 { file = 0; vob = 0; }
754 else {
755 file = &filetab.v[least];
756 switch (id_kind(file->id)) {
757 case RAW:
758 vob = 0;
759 break;
760 case VOB:
761 if (first_time) { progress_clear(&progress); first_time = 0; }
762 vob = DVDOpenFile(dvd, id_title(file->id),
763 id_part(file->id)
764 ? DVD_READ_TITLE_VOBS
765 : DVD_READ_MENU_VOBS);
766 if (!vob)
767 bail("failed to open %s %u",
768 id_part(file->id) ? "title" : "menu",
769 id_title(file->id));
770 progress_update(&progress);
771 break;
772 default:
773 abort();
774 }
775 }
776
777 if (file && id_kind(file->id) != RAW) {
778 file_progress.render = render_file_progress;
779 progress_additem(&progress, &file_progress);
780 }
781
782 pos = start;
783 while (pos < end) {
784 want = end - pos; if (want > BUFSECTORS) want = BUFSECTORS;
785 n = read_sectors(pos, buf, want);
786
787 if (n <= 0) n = find_good_sector(&pos, end, buf, BUFSECTORS);
788 if (n > 0) { carefully_write(outfd, buf, n*SECTORSZ); pos += n; }
789 report_progress(pos);
790 }
791
792 if (vob) { DVDCloseFile(vob); vob = 0; }
793
794 if (file && id_kind(file->id) != RAW)
795 progress_removeitem(&progress, &file_progress);
796 progress_update(&progress);
797
798 #undef BUFSECTORS
799 }
800
801 #define PRF_HYPHEN 1u
802 static int parse_range(const char *p, unsigned f,
803 secaddr *start_out, secaddr *end_out)
804 {
805 char *q;
806 int err, rc;
807 unsigned long start, end;
808
809 err = errno;
810
811 if (ISDIGIT(*p)) {
812 start = strtoul(p, &q, 0);
813 if (errno || start >= SECLIMIT) { rc = -1; goto end; }
814 *start_out = start; p = q;
815 } else if (!(f&PRF_HYPHEN))
816 { rc = -1; goto end; }
817 else
818 start = 0;
819
820 if (f&PRF_HYPHEN) {
821 if (*p != '-') { rc = -1; goto end; }
822 p++;
823 } else {
824 if (!ISSPACE(*p)) { rc = -1; goto end; }
825 do p++; while (ISSPACE(*p));
826 }
827
828 if (ISDIGIT(*p)) {
829 end = strtoul(p, &q, 0);
830 if (errno || end > SECLIMIT || end < start) { rc = -1; goto end; }
831 *end_out = end; p = q;
832 } else if (!(f&PRF_HYPHEN))
833 { rc = -1; goto end; }
834
835 if (!(f&PRF_HYPHEN)) while (ISSPACE(*p)) p++;
836 if (*p && ((f&PRF_HYPHEN) || *p != '#')) { rc = -1; goto end; }
837
838 rc = 0;
839 end:
840 errno = err;
841 return (rc);
842 }
843
844 #ifdef DEBUG
845 static void dump_eventq(const char *what)
846 {
847 unsigned i;
848 const struct event *ev;
849 char fn[MAXFNSZ];
850
851 printf("\n;; event dump (%s):\n", what);
852 for (i = 0; i < eventq.n; i++) {
853 ev = &eventq.v[i];
854 switch (ev->ev) {
855 case EV_BEGIN:
856 store_filename(fn, filetab.v[ev->file].id);
857 printf(";; %8"PRIuSEC": begin %s\n", ev->pos, fn);
858 break;
859 case EV_END:
860 store_filename(fn, filetab.v[ev->file].id);
861 printf(";; %8"PRIuSEC": end %s\n", ev->pos, fn);
862 break;
863 case EV_WRITE:
864 printf(";; %8"PRIuSEC": write\n", ev->pos);
865 break;
866 case EV_STOP:
867 printf(";; %8"PRIuSEC": stop\n", ev->pos);
868 break;
869 default:
870 printf(";; %8"PRIuSEC": ?%u\n", ev->pos, ev->ev);
871 break;
872 }
873 }
874 }
875 #endif
876
877 int main(int argc, char *argv[])
878 {
879 unsigned f = 0;
880 const char *p;
881 off_t volsz;
882 secaddr pos;
883 off_t off;
884 secaddr start, end, last;
885 const struct event *ev;
886 const char *device, *outfile;
887 struct badblock *bad;
888 int opt, blksz;
889 size_t i;
890 FILE *fp;
891 struct buf buf = BUF_INIT;
892 struct timeval tv0, tv1;
893 double t, rate, tot;
894 const char *rateunit, *totunit;
895 char timebuf[TIMESTRMAX], id_in[MAXIDSZ], id_out[MAXIDSZ];
896 dvd_reader_t *dvd_out;
897 #ifdef DEBUG
898 const struct file *file;
899 char fn[MAXFNSZ];
900 #endif
901
902 #define f_bogus 1u
903 #define f_continue 2u
904 #define f_fixup 4u
905 #define f_stats 8u
906 #define f_checkid 16u
907 #define f_write 256u
908
909 set_prog(argv[0]);
910 for (;;) {
911 opt = getopt(argc, argv, "hB:E:FR:X:b:cir:s"); if (opt < 0) break;
912 switch (opt) {
913 case 'h': usage(stderr); exit(0);
914 case 'B':
915 p = optarg;
916 #define SKIP_PREFIX(s) \
917 (STRNCMP(p, ==, s "=", sizeof(s)) && (p += sizeof(s), 1))
918 for (;;) {
919 if (SKIP_PREFIX("cf"))
920 clear_factor = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
921 "clear factor");
922 else if (SKIP_PREFIX("cmin"))
923 clear_min = parse_int(&p, PNF_JUNK, 1, SECLIMIT,
924 "clear minimum");
925 else if (SKIP_PREFIX("cmax"))
926 clear_max = parse_int(&p, PNF_JUNK, 1, SECLIMIT,
927 "clear maximum");
928 else if (SKIP_PREFIX("sf"))
929 step_factor = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
930 "step factor");
931 else if (SKIP_PREFIX("smin"))
932 step_min = parse_int(&p, PNF_JUNK, 1, SECLIMIT - 1,
933 "step minimum");
934 else if (SKIP_PREFIX("smax"))
935 step_max = parse_int(&p, PNF_JUNK, 1, SECLIMIT - 1,
936 "step maximum");
937 else if (SKIP_PREFIX("retry"))
938 max_retries = parse_int(&p, PNF_JUNK, 0, INT_MAX, "retries");
939 else if (SKIP_PREFIX("alpha"))
940 alpha = parse_float(&p, PNF_JUNK, 0, 1, "average decay factor");
941 else if (SKIP_PREFIX("_badwait"))
942 bad_block_delay = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
943 "bad-block delay");
944 else if (SKIP_PREFIX("_blkwait"))
945 good_block_delay = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
946 "good block delay");
947 else
948 bail("unknown bad blocks parameter `%s'", p);
949 if (!*p) break;
950 else if (*p != ',') bail("unexpected junk in parameters");
951 p++;
952 }
953 #undef SKIP_PREFIX
954 break;
955 case 'E': errfile = optarg; break;
956 case 'F': f |= f_fixup; break;
957 case 'R':
958 fp = fopen(optarg, "r");
959 if (!fp)
960 bail_syserr(errno, "failed to open ranges file `%s'", optarg);
961 i = 0; last = -1;
962 for (;;) {
963 buf_rewind(&buf); if (read_line(fp, &buf)) break;
964 p = buf.p; i++;
965 while (ISSPACE(*p)) p++;
966 if (!*p || *p == '#') continue;
967 if (parse_range(p, 0, &start, &end) ||
968 (last <= SECLIMIT && start < last))
969 bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
970 if (start < end) {
971 if (start == last)
972 eventq.v[eventq.n - 1].pos = end;
973 else {
974 put_event(EV_WRITE, 0, start);
975 put_event(EV_STOP, 0, end);
976 }
977 last = end;
978 }
979 }
980 if (ferror(fp))
981 bail_syserr(errno, "failed to read ranges file `%s'", optarg);
982 break;
983 case 'X':
984 fp = fopen(optarg, "r");
985 if (!fp)
986 bail_syserr(errno, "failed to open bad-blocks file `%s'", optarg);
987 i = 0; last = -1;
988 for (;;) {
989 buf_rewind(&buf); if (read_line(fp, &buf)) break;
990 p = buf.p; i++;
991 while (ISSPACE(*p)) p++;
992 if (!*p || *p == '#') continue;
993 if (parse_range(p, 0, &start, &end) ||
994 (last <= SECLIMIT && start < last))
995 bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
996 if (start < end)
997 { VEC_PUSH(bad, &badblocks); bad->start = start; bad->end = end; }
998 }
999 if (ferror(fp))
1000 bail_syserr(errno, "failed to read bad-blocks file `%s'", optarg);
1001 break;
1002 case 'b':
1003 if (mapfile) bail("can't have multiple map files");
1004 mapfile = optarg;
1005 break;
1006 case 'c': f |= f_continue; break;
1007 case 'i': f |= f_checkid; break;
1008 case 'r':
1009 start = 0; end = -1;
1010 if (parse_range(optarg, PRF_HYPHEN, &start, &end))
1011 bail("bad range `%s'", optarg);
1012 if (start < end) {
1013 put_event(EV_WRITE, 0, start);
1014 if (end <= SECLIMIT) put_event(EV_STOP, 0, end);
1015 }
1016 break;
1017 case 's': f |= f_stats; break;
1018 default: f |= f_bogus; break;
1019 }
1020 }
1021 if (argc - optind != 2) f |= f_bogus;
1022 if (f&f_bogus) { usage(stderr); exit(2); }
1023
1024 setlocale(LC_ALL, "");
1025 progress_init(&progress);
1026 device = argv[optind]; outfile = argv[optind + 1];
1027
1028 if (badblocks.n) {
1029 qsort(badblocks.v, badblocks.n, sizeof(struct badblock),
1030 compare_badblock);
1031 #ifdef DEBUG
1032 printf(";; fake bad blocks:\n");
1033 for (i = 0; i < badblocks.n; i++)
1034 printf(";;\t%8"PRIuSEC" .. %"PRIuSEC"\n",
1035 badblocks.v[i].start, badblocks.v[i].end);
1036 #endif
1037 }
1038
1039 if (open_dvd(device, O_RDONLY, &dvdfd, &dvd)) exit(2);
1040
1041 blksz = SECTORSZ; volsz = device_size(dvdfd, device, &blksz);
1042 if (blksz != SECTORSZ)
1043 bail("device `%s' block size %d /= %d", device, blksz, SECTORSZ);
1044 if (volsz%SECTORSZ)
1045 bail("device `%s' volume size %"PRIu64" not a multiple of %d",
1046 device, volsz, SECTORSZ);
1047
1048 if (f&f_checkid) {
1049 if (open_dvd(outfile, O_RDONLY, 0, &dvd_out)) exit(2);
1050 if (dvd_id(id_in, dvd, DIF_MUSTIFOHASH, device) ||
1051 dvd_id(id_out, dvd_out, DIF_MUSTIFOHASH, device))
1052 exit(2);
1053 if (STRCMP(id_in, !=, id_out))
1054 bail("DVD id mismatch: input `%s' is `%s'; output `%s' is `%s'",
1055 device, id_in, outfile, id_out);
1056 }
1057
1058 outfd = open(outfile, O_WRONLY | O_CREAT, 0666);
1059 if (outfd < 0)
1060 bail_syserr(errno, "failed to create output file `%s'", outfile);
1061
1062 if (f&f_continue) {
1063 off = lseek(outfd, 0, SEEK_END);
1064 if (off < 0)
1065 bail_syserr(errno, "failed to seek to end of output file `%s'",
1066 outfile);
1067 put_event(EV_WRITE, 0, off/SECTORSZ);
1068 } else if (!eventq.n && !(f&f_fixup))
1069 put_event(EV_WRITE, 0, 0);
1070
1071 /* It's fast enough just to check everything. */
1072 put_menu(dvd, 0);
1073 for (i = 1; i < 100; i++) {
1074 put_menu(dvd, i);
1075 put_title(dvd, i);
1076 }
1077 put_file(mkident(RAW, 0, 0), 0, volsz/SECTORSZ);
1078 assert(filetab.n <= MAXFILES);
1079
1080 for (i = 0, limit = 0; i < filetab.n; i++)
1081 if (filetab.v[i].end > limit) limit = filetab.v[i].end;
1082
1083 if (end > limit) end = limit;
1084
1085 #ifdef DEBUG
1086 printf("\n;; files:\n");
1087 for (i = 0; i < filetab.n; i++) {
1088 file = &filetab.v[i];
1089 store_filename(fn, file->id);
1090 printf(";;\t%8"PRIuSEC" .. %-8"PRIuSEC" %s\n",
1091 file->start, file->end, fn);
1092 }
1093 #endif
1094
1095 qsort(eventq.v, eventq.n, sizeof(struct event), compare_event);
1096
1097 f &= ~f_write; start = 0;
1098 for (i = 0; i < eventq.n; i++) {
1099 ev = &eventq.v[i];
1100 switch (ev->ev) {
1101 case EV_WRITE:
1102 if (f&f_write)
1103 bail("overlapping ranges: range from %"PRIuSEC" "
1104 "still open at %"PRIuSEC"",
1105 start, ev->pos);
1106 f |= f_write; start = ev->pos;
1107 break;
1108 case EV_STOP:
1109 f &= ~f_write;
1110 break;
1111 }
1112 }
1113
1114 #ifdef DEBUG
1115 dump_eventq("initial");
1116 #endif
1117 f &= ~f_write; start = 0;
1118 for (i = 0; i < eventq.n; i++) {
1119 ev = &eventq.v[i];
1120 if (ev->ev == EV_WRITE) { start = ev->pos; f |= f_write; }
1121 if (ev->pos >= limit) break;
1122 if (ev->ev == EV_STOP) { nsectors += ev->pos - start; f &= ~f_write; }
1123 if (f&f_fixup) start = ev->pos;
1124 }
1125 eventq.n = i;
1126 #ifdef DEBUG
1127 dump_eventq("trimmed");
1128 #endif
1129 if (f&f_fixup) {
1130 put_event(EV_WRITE, 0, start);
1131 f |= f_write;
1132 }
1133 if (f&f_write) {
1134 nsectors += limit - start;
1135 put_event(EV_STOP, 0, limit);
1136 }
1137 #ifdef DEBUG
1138 dump_eventq("final");
1139 #endif
1140
1141 copy_progress.render = render_copy_progress;
1142 progress_additem(&progress, &copy_progress);
1143 if (nsectors == limit - start)
1144 { ndone = start; nsectors = limit; }
1145 else {
1146 disc_progress.render = render_disc_progress;
1147 progress_additem(&progress, &disc_progress);
1148 }
1149
1150 if (f&f_stats) gettimeofday(&tv0, 0);
1151
1152 #ifdef DEBUG
1153 printf("\n;; event sweep:\n");
1154 #endif
1155 f &= ~f_write;
1156 for (pos = 0, i = 0; i < eventq.n; i++) {
1157 ev = &eventq.v[i];
1158 if (ev->pos > pos) {
1159 if (f&f_write) emit(pos, ev->pos);
1160 pos = ev->pos;
1161 #ifdef DEBUG
1162 progress_clear(&progress);
1163 printf(";;\n");
1164 #endif
1165 }
1166 switch (ev->ev) {
1167 case EV_BEGIN:
1168 set_live(ev->file);
1169 #ifdef DEBUG
1170 store_filename(fn, filetab.v[ev->file].id);
1171 progress_clear(&progress);
1172 printf(";; %8"PRIuSEC": begin `%s'\n", pos, fn);
1173 #endif
1174 break;
1175 case EV_WRITE:
1176 gettimeofday(&last_time, 0); last_pos = pos;
1177 if (lseek(outfd, (off_t)ev->pos*SECTORSZ, SEEK_SET) < 0)
1178 bail_syserr(errno,
1179 "failed to seek to resume position "
1180 "(sector %"PRIuSEC") in output file `%s'",
1181 ev->pos, outfile);
1182 #ifdef DEBUG
1183 progress_clear(&progress);
1184 printf(";; %8"PRIuSEC": begin write\n", pos);
1185 #endif
1186 f |= f_write;
1187 break;
1188 case EV_STOP:
1189 f &= ~f_write;
1190 #ifdef DEBUG
1191 progress_clear(&progress);
1192 printf(";; %8"PRIuSEC": end write\n", pos);
1193 #endif
1194 break;
1195 case EV_END:
1196 clear_live(ev->file);
1197 #ifdef DEBUG
1198 store_filename(fn, filetab.v[ev->file].id);
1199 progress_clear(&progress);
1200 printf(";; %8"PRIuSEC": end `%s'\n", pos, fn);
1201 #endif
1202 break;
1203 default: abort();
1204 }
1205 }
1206
1207 progress_clear(&progress);
1208
1209 if (ftruncate(outfd, (off_t)limit*SECTORSZ) < 0)
1210 bail_syserr(errno, "failed to set output file `%s' length", outfile);
1211
1212 if (f&f_stats) {
1213 gettimeofday(&tv1, 0); t = tvdiff(&tv0, &tv1);
1214 if (nsectors == limit) { ndone -= start; nsectors -= start; }
1215 tot = scale_bytes((double)nsectors*SECTORSZ, &totunit);
1216 rate = scale_bytes((double)nsectors*SECTORSZ/t, &rateunit);
1217 moan("all done: %.1f %sB in %s -- %.1f %sB/s",
1218 tot, totunit, fmttime(t, timebuf), rate, rateunit);
1219 }
1220
1221 if (dvd) DVDClose(dvd);
1222 if (dvdfd >= 0) close(dvdfd);
1223 if (outfd >= 0) close(outfd);
1224 carefully_fclose(mapfp, "bad-sector region map");
1225 carefully_fclose(errfp, "bad-sector error log");
1226 progress_free(&progress);
1227
1228 #undef f_bogus
1229 #undef f_continue
1230 #undef f_fixup
1231 #undef f_stats
1232 #undef f_write
1233
1234 return (0);
1235 }
Symbiosisware hack for copying DVDs.