~mdw / dvdrip / blob
? search:


e699741cdcd1c6d1cc6052fe819b2894b622fdf6
[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 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 static int read_line(FILE *fp, struct buf *b)
809 {
810 int ch;
811
812 ch = getc(fp);
813 if (ch == EOF)
814 return (-1);
815 else if (ch != '\n')
816 do { buf_putc(b, ch); ch = getc(fp); } while (ch != EOF && ch != '\n');
817 buf_putz(b);
818 return (0);
819 }
820
821 #define PRF_HYPHEN 1u
822 static int parse_range(const char *p, unsigned f,
823 secaddr *start_out, secaddr *end_out)
824 {
825 char *q;
826 int err, rc;
827 unsigned long start, end;
828
829 err = errno;
830
831 if (ISDIGIT(*p)) {
832 start = strtoul(p, &q, 0);
833 if (errno || start >= SECLIMIT) { rc = -1; goto end; }
834 *start_out = start; p = q;
835 } else if (!(f&PRF_HYPHEN))
836 { rc = -1; goto end; }
837 else
838 start = 0;
839
840 if (f&PRF_HYPHEN) {
841 if (*p != '-') { rc = -1; goto end; }
842 p++;
843 } else {
844 if (!ISSPACE(*p)) { rc = -1; goto end; }
845 do p++; while (ISSPACE(*p));
846 }
847
848 if (ISDIGIT(*p)) {
849 end = strtoul(p, &q, 0);
850 if (errno || end > SECLIMIT || end < start) { rc = -1; goto end; }
851 *end_out = end; p = q;
852 } else if (!(f&PRF_HYPHEN))
853 { rc = -1; goto end; }
854
855 if (!(f&PRF_HYPHEN)) while (ISSPACE(*p)) p++;
856 if (*p && ((f&PRF_HYPHEN) || *p != '#')) { rc = -1; goto end; }
857
858 rc = 0;
859 end:
860 errno = err;
861 return (rc);
862 }
863
864 #ifdef DEBUG
865 static void dump_eventq(const char *what)
866 {
867 unsigned i;
868 const struct event *ev;
869 char fn[MAXFNSZ];
870
871 printf("\n;; event dump (%s):\n", what);
872 for (i = 0; i < eventq.n; i++) {
873 ev = &eventq.v[i];
874 switch (ev->ev) {
875 case EV_BEGIN:
876 store_filename(fn, filetab.v[ev->file].id);
877 printf(";; %8"PRIuSEC": begin %s\n", ev->pos, fn);
878 break;
879 case EV_END:
880 store_filename(fn, filetab.v[ev->file].id);
881 printf(";; %8"PRIuSEC": end %s\n", ev->pos, fn);
882 break;
883 case EV_WRITE:
884 printf(";; %8"PRIuSEC": write\n", ev->pos);
885 break;
886 case EV_STOP:
887 printf(";; %8"PRIuSEC": stop\n", ev->pos);
888 break;
889 default:
890 printf(";; %8"PRIuSEC": ?%u\n", ev->pos, ev->ev);
891 break;
892 }
893 }
894 }
895 #endif
896
897 int main(int argc, char *argv[])
898 {
899 unsigned f = 0;
900 const char *p;
901 off_t volsz;
902 secaddr pos;
903 off_t off;
904 secaddr start, end, last;
905 const struct event *ev;
906 const char *device, *outfile;
907 struct badblock *bad;
908 int opt, blksz;
909 size_t i;
910 FILE *fp;
911 struct buf buf = BUF_INIT;
912 struct timeval tv0, tv1;
913 double t, rate, tot;
914 const char *rateunit, *totunit;
915 char timebuf[TIMESTRMAX], id_in[MAXIDSZ], id_out[MAXIDSZ];
916 dvd_reader_t *dvd_out;
917 #ifdef DEBUG
918 const struct file *file;
919 char fn[MAXFNSZ];
920 #endif
921
922 #define f_bogus 1u
923 #define f_continue 2u
924 #define f_fixup 4u
925 #define f_stats 8u
926 #define f_checkid 16u
927 #define f_write 256u
928
929 set_prog(argv[0]);
930 for (;;) {
931 opt = getopt(argc, argv, "hB:E:FR:X:b:cir:s"); if (opt < 0) break;
932 switch (opt) {
933 case 'h': usage(stderr); exit(0);
934 case 'B':
935 p = optarg;
936 #define SKIP_PREFIX(s) \
937 (STRNCMP(p, ==, s "=", sizeof(s)) && (p += sizeof(s), 1))
938 for (;;) {
939 if (SKIP_PREFIX("cf"))
940 clear_factor = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
941 "clear factor");
942 else if (SKIP_PREFIX("cmin"))
943 clear_min = parse_int(&p, PNF_JUNK, 1, SECLIMIT,
944 "clear minimum");
945 else if (SKIP_PREFIX("cmax"))
946 clear_max = parse_int(&p, PNF_JUNK, 1, SECLIMIT,
947 "clear maximum");
948 else if (SKIP_PREFIX("sf"))
949 step_factor = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
950 "step factor");
951 else if (SKIP_PREFIX("smin"))
952 step_min = parse_int(&p, PNF_JUNK, 1, SECLIMIT - 1,
953 "step minimum");
954 else if (SKIP_PREFIX("smax"))
955 step_max = parse_int(&p, PNF_JUNK, 1, SECLIMIT - 1,
956 "step maximum");
957 else if (SKIP_PREFIX("retry"))
958 max_retries = parse_int(&p, PNF_JUNK, 0, INT_MAX, "retries");
959 else if (SKIP_PREFIX("alpha"))
960 alpha = parse_float(&p, PNF_JUNK, 0, 1, "average decay factor");
961 else if (SKIP_PREFIX("_badwait"))
962 bad_block_delay = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
963 "bad-block delay");
964 else if (SKIP_PREFIX("_blkwait"))
965 good_block_delay = parse_float(&p, PNF_JUNK, 0, DBL_MAX,
966 "good block delay");
967 else
968 bail("unknown bad blocks parameter `%s'", p);
969 if (!*p) break;
970 else if (*p != ',') bail("unexpected junk in parameters");
971 p++;
972 }
973 #undef SKIP_PREFIX
974 break;
975 case 'E': errfile = optarg; break;
976 case 'F': f |= f_fixup; break;
977 case 'R':
978 fp = fopen(optarg, "r");
979 if (!fp)
980 bail_syserr(errno, "failed to open ranges file `%s'", optarg);
981 i = 0; last = -1;
982 for (;;) {
983 buf_rewind(&buf); if (read_line(fp, &buf)) break;
984 p = buf.p; i++;
985 while (ISSPACE(*p)) p++;
986 if (!*p || *p == '#') continue;
987 if (parse_range(p, 0, &start, &end) ||
988 (last <= SECLIMIT && start < last))
989 bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
990 if (start < end) {
991 if (start == last)
992 eventq.v[eventq.n - 1].pos = end;
993 else {
994 put_event(EV_WRITE, 0, start);
995 put_event(EV_STOP, 0, end);
996 }
997 last = end;
998 }
999 }
1000 if (ferror(fp))
1001 bail_syserr(errno, "failed to read ranges file `%s'", optarg);
1002 break;
1003 case 'X':
1004 fp = fopen(optarg, "r");
1005 if (!fp)
1006 bail_syserr(errno, "failed to open bad-blocks file `%s'", optarg);
1007 i = 0; last = -1;
1008 for (;;) {
1009 buf_rewind(&buf); if (read_line(fp, &buf)) break;
1010 p = buf.p; i++;
1011 while (ISSPACE(*p)) p++;
1012 if (!*p || *p == '#') continue;
1013 if (parse_range(p, 0, &start, &end) ||
1014 (last <= SECLIMIT && start < last))
1015 bail("bad range `%s' at `%s' line %zu", buf.p, optarg, i);
1016 if (start < end)
1017 { VEC_PUSH(bad, &badblocks); bad->start = start; bad->end = end; }
1018 }
1019 if (ferror(fp))
1020 bail_syserr(errno, "failed to read bad-blocks file `%s'", optarg);
1021 break;
1022 case 'b':
1023 if (mapfile) bail("can't have multiple map files");
1024 mapfile = optarg;
1025 break;
1026 case 'c': f |= f_continue; break;
1027 case 'i': f |= f_checkid; break;
1028 case 'r':
1029 start = 0; end = -1;
1030 if (parse_range(optarg, PRF_HYPHEN, &start, &end))
1031 bail("bad range `%s'", optarg);
1032 if (start < end) {
1033 put_event(EV_WRITE, 0, start);
1034 if (end <= SECLIMIT) put_event(EV_STOP, 0, end);
1035 }
1036 break;
1037 case 's': f |= f_stats; break;
1038 default: f |= f_bogus; break;
1039 }
1040 }
1041 if (argc - optind != 2) f |= f_bogus;
1042 if (f&f_bogus) { usage(stderr); exit(2); }
1043
1044 setlocale(LC_ALL, "");
1045 progress_init(&progress);
1046 device = argv[optind]; outfile = argv[optind + 1];
1047
1048 if (badblocks.n) {
1049 qsort(badblocks.v, badblocks.n, sizeof(struct badblock),
1050 compare_badblock);
1051 #ifdef DEBUG
1052 printf(";; fake bad blocks:\n");
1053 for (i = 0; i < badblocks.n; i++)
1054 printf(";;\t%8"PRIuSEC" .. %"PRIuSEC"\n",
1055 badblocks.v[i].start, badblocks.v[i].end);
1056 #endif
1057 }
1058
1059 open_dvd(device, O_RDONLY, &dvdfd, &dvd);
1060
1061 blksz = SECTORSZ; volsz = device_size(dvdfd, device, &blksz);
1062 if (blksz != SECTORSZ)
1063 bail("device `%s' block size %d /= %d", device, blksz, SECTORSZ);
1064 if (volsz%SECTORSZ)
1065 bail("device `%s' volume size %"PRIu64" not a multiple of %d",
1066 device, volsz, SECTORSZ);
1067
1068 if (f&f_checkid) {
1069 open_dvd(outfile, O_RDONLY, 0, &dvd_out);
1070 if (dvd_id(id_in, dvd, DIF_MUSTIFOHASH, device) ||
1071 dvd_id(id_out, dvd_out, DIF_MUSTIFOHASH, device))
1072 exit(2);
1073 if (STRCMP(id_in, !=, id_out))
1074 bail("DVD id mismatch: input `%s' is `%s'; output `%s' is `%s'",
1075 device, id_in, outfile, id_out);
1076 }
1077
1078 outfd = open(outfile, O_WRONLY | O_CREAT, 0666);
1079 if (outfd < 0)
1080 bail_syserr(errno, "failed to create output file `%s'", outfile);
1081
1082 if (f&f_continue) {
1083 off = lseek(outfd, 0, SEEK_END);
1084 if (off < 0)
1085 bail_syserr(errno, "failed to seek to end of output file `%s'",
1086 outfile);
1087 put_event(EV_WRITE, 0, off/SECTORSZ);
1088 } else if (!eventq.n && !(f&f_fixup))
1089 put_event(EV_WRITE, 0, 0);
1090
1091 /* It's fast enough just to check everything. */
1092 put_menu(dvd, 0);
1093 for (i = 1; i < 100; i++) {
1094 put_menu(dvd, i);
1095 put_title(dvd, i);
1096 }
1097 put_file(mkident(RAW, 0, 0), 0, volsz/SECTORSZ);
1098 assert(filetab.n <= MAXFILES);
1099
1100 for (i = 0, limit = 0; i < filetab.n; i++)
1101 if (filetab.v[i].end > limit) limit = filetab.v[i].end;
1102
1103 if (end > limit) end = limit;
1104
1105 #ifdef DEBUG
1106 printf("\n;; files:\n");
1107 for (i = 0; i < filetab.n; i++) {
1108 file = &filetab.v[i];
1109 store_filename(fn, file->id);
1110 printf(";;\t%8"PRIuSEC" .. %-8"PRIuSEC" %s\n",
1111 file->start, file->end, fn);
1112 }
1113 #endif
1114
1115 qsort(eventq.v, eventq.n, sizeof(struct event), compare_event);
1116
1117 f &= ~f_write; start = 0;
1118 for (i = 0; i < eventq.n; i++) {
1119 ev = &eventq.v[i];
1120 switch (ev->ev) {
1121 case EV_WRITE:
1122 if (f&f_write)
1123 bail("overlapping ranges: range from %"PRIuSEC" "
1124 "still open at %"PRIuSEC"",
1125 start, ev->pos);
1126 f |= f_write; start = ev->pos;
1127 break;
1128 case EV_STOP:
1129 f &= ~f_write;
1130 break;
1131 }
1132 }
1133
1134 #ifdef DEBUG
1135 dump_eventq("initial");
1136 #endif
1137 f &= ~f_write; start = 0;
1138 for (i = 0; i < eventq.n; i++) {
1139 ev = &eventq.v[i];
1140 if (ev->ev == EV_WRITE) { start = ev->pos; f |= f_write; }
1141 if (ev->pos >= limit) break;
1142 if (ev->ev == EV_STOP) { nsectors += ev->pos - start; f &= ~f_write; }
1143 if (f&f_fixup) start = ev->pos;
1144 }
1145 eventq.n = i;
1146 #ifdef DEBUG
1147 dump_eventq("trimmed");
1148 #endif
1149 if (f&f_fixup) {
1150 put_event(EV_WRITE, 0, start);
1151 f |= f_write;
1152 }
1153 if (f&f_write) {
1154 nsectors += limit - start;
1155 put_event(EV_STOP, 0, limit);
1156 }
1157 #ifdef DEBUG
1158 dump_eventq("final");
1159 #endif
1160
1161 copy_progress.render = render_copy_progress;
1162 progress_additem(&progress, &copy_progress);
1163 if (nsectors == limit - start)
1164 { ndone = start; nsectors = limit; }
1165 else {
1166 disc_progress.render = render_disc_progress;
1167 progress_additem(&progress, &disc_progress);
1168 }
1169
1170 if (f&f_stats) gettimeofday(&tv0, 0);
1171
1172 #ifdef DEBUG
1173 printf("\n;; event sweep:\n");
1174 #endif
1175 f &= ~f_write;
1176 for (pos = 0, i = 0; i < eventq.n; i++) {
1177 ev = &eventq.v[i];
1178 if (ev->pos > pos) {
1179 if (f&f_write) emit(pos, ev->pos);
1180 pos = ev->pos;
1181 #ifdef DEBUG
1182 progress_clear(&progress);
1183 printf(";;\n");
1184 #endif
1185 }
1186 switch (ev->ev) {
1187 case EV_BEGIN:
1188 set_live(ev->file);
1189 #ifdef DEBUG
1190 store_filename(fn, filetab.v[ev->file].id);
1191 progress_clear(&progress);
1192 printf(";; %8"PRIuSEC": begin `%s'\n", pos, fn);
1193 #endif
1194 break;
1195 case EV_WRITE:
1196 gettimeofday(&last_time, 0); last_pos = pos;
1197 if (lseek(outfd, (off_t)ev->pos*SECTORSZ, SEEK_SET) < 0)
1198 bail_syserr(errno,
1199 "failed to seek to resume position "
1200 "(sector %"PRIuSEC") in output file `%s'",
1201 ev->pos, outfile);
1202 #ifdef DEBUG
1203 progress_clear(&progress);
1204 printf(";; %8"PRIuSEC": begin write\n", pos);
1205 #endif
1206 f |= f_write;
1207 break;
1208 case EV_STOP:
1209 f &= ~f_write;
1210 #ifdef DEBUG
1211 progress_clear(&progress);
1212 printf(";; %8"PRIuSEC": end write\n", pos);
1213 #endif
1214 break;
1215 case EV_END:
1216 clear_live(ev->file);
1217 #ifdef DEBUG
1218 store_filename(fn, filetab.v[ev->file].id);
1219 progress_clear(&progress);
1220 printf(";; %8"PRIuSEC": end `%s'\n", pos, fn);
1221 #endif
1222 break;
1223 default: abort();
1224 }
1225 }
1226
1227 progress_clear(&progress);
1228
1229 if (ftruncate(outfd, (off_t)limit*SECTORSZ) < 0)
1230 bail_syserr(errno, "failed to set output file `%s' length", outfile);
1231
1232 if (f&f_stats) {
1233 gettimeofday(&tv1, 0); t = tvdiff(&tv0, &tv1);
1234 if (nsectors == limit) { ndone -= start; nsectors -= start; }
1235 tot = scale_bytes((double)nsectors*SECTORSZ, &totunit);
1236 rate = scale_bytes((double)nsectors*SECTORSZ/t, &rateunit);
1237 moan("all done: %.1f %sB in %s -- %.1f %sB/s",
1238 tot, totunit, fmttime(t, timebuf), rate, rateunit);
1239 }
1240
1241 if (dvd) DVDClose(dvd);
1242 if (dvdfd >= 0) close(dvdfd);
1243 if (outfd >= 0) close(outfd);
1244 carefully_fclose(mapfp, "bad-sector region map");
1245 carefully_fclose(errfp, "bad-sector error log");
1246 progress_free(&progress);
1247
1248 #undef f_bogus
1249 #undef f_continue
1250 #undef f_fixup
1251 #undef f_stats
1252 #undef f_write
1253
1254 return (0);
1255 }
Symbiosisware hack for copying DVDs.