reseal.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303
  1. #include "stdinc.h"
  2. #include "dat.h"
  3. #include "fns.h"
  4. static uchar *data;
  5. static uchar *data1;
  6. static int blocksize;
  7. static int sleepms;
  8. static int fd;
  9. static int force;
  10. static vlong offset0;
  11. void
  12. usage(void)
  13. {
  14. fprint(2, "usage: reseal [-f] [-b blocksize] [-s ms] arenapart1 [name...]]\n");
  15. threadexitsall(0);
  16. }
  17. static int
  18. pwriteblock(uchar *buf, int n, vlong off)
  19. {
  20. int nr, m;
  21. for(nr = 0; nr < n; nr += m){
  22. m = n - nr;
  23. m = pwrite(fd, &buf[nr], m, offset0+off+nr);
  24. if(m <= 0)
  25. return -1;
  26. }
  27. return 0;
  28. }
  29. static int
  30. preadblock(uchar *buf, int n, vlong off)
  31. {
  32. int nr, m;
  33. for(nr = 0; nr < n; nr += m){
  34. m = n - nr;
  35. m = pread(fd, &buf[nr], m, offset0+off+nr);
  36. if(m <= 0){
  37. if(m == 0)
  38. werrstr("early eof");
  39. return -1;
  40. }
  41. }
  42. return 0;
  43. }
  44. static int
  45. loadheader(char *name, ArenaHead *head, Arena *arena, vlong off)
  46. {
  47. if(preadblock(data, head->blocksize, off + head->size - head->blocksize) < 0){
  48. fprint(2, "%s: reading arena tail: %r\n", name);
  49. return -1;
  50. }
  51. memset(arena, 0, sizeof *arena);
  52. if(unpackarena(arena, data) < 0){
  53. fprint(2, "%s: unpack arena tail: %r\n", name);
  54. return -1;
  55. }
  56. arena->blocksize = head->blocksize;
  57. arena->base = off + head->blocksize;
  58. arena->clumpmax = arena->blocksize / ClumpInfoSize;
  59. arena->size = head->size - 2*head->blocksize;
  60. if(arena->diskstats.sealed)
  61. scorecp(arena->score, data + head->blocksize - VtScoreSize);
  62. return 0;
  63. }
  64. uchar zero[VtScoreSize];
  65. static int
  66. verify(Arena *arena, void *data, uchar *newscore)
  67. {
  68. vlong e, bs, n, o;
  69. DigestState ds, ds1;
  70. uchar score[VtScoreSize];
  71. /*
  72. * now we know how much to read
  73. * read everything but the last block, which is special
  74. */
  75. e = arena->size + arena->blocksize;
  76. o = arena->base - arena->blocksize;
  77. bs = arena->blocksize;
  78. memset(&ds, 0, sizeof ds);
  79. for(n = 0; n < e; n += bs){
  80. if(preadblock(data, bs, o + n) < 0){
  81. werrstr("read: %r");
  82. return -1;
  83. }
  84. if(n + bs > e)
  85. bs = e - n;
  86. sha1(data, bs, nil, &ds);
  87. }
  88. /* last block */
  89. if(preadblock(data, arena->blocksize, o + e) < 0){
  90. werrstr("read: %r");
  91. return -1;
  92. }
  93. ds1 = ds;
  94. sha1(data, bs - VtScoreSize, nil, &ds);
  95. sha1(zero, VtScoreSize, score, &ds);
  96. if(scorecmp(score, arena->score) != 0){
  97. if(!force){
  98. werrstr("score mismatch: %V != %V", score, arena->score);
  99. return -1;
  100. }
  101. fprint(2, "warning: score mismatch %V != %V\n", score, arena->score);
  102. }
  103. /* prepare new last block */
  104. memset(data, 0, arena->blocksize);
  105. packarena(arena, data);
  106. sha1(data, bs, newscore, &ds1);
  107. scorecp((uchar*)data + arena->blocksize - VtScoreSize, newscore);
  108. return 0;
  109. }
  110. static void
  111. resealarena(char *name, vlong len)
  112. {
  113. ArenaHead head;
  114. Arena arena;
  115. DigestState s;
  116. u64int off;
  117. uchar newscore[VtScoreSize];
  118. fprint(2, "%s: begin reseal\n", name);
  119. memset(&s, 0, sizeof s);
  120. off = seek(fd, 0, 1);
  121. /*
  122. * read a little bit, which will include the header
  123. */
  124. if(preadblock(data, HeadSize, off) < 0){
  125. fprint(2, "%s: reading header: %r\n", name);
  126. return;
  127. }
  128. if(unpackarenahead(&head, data) < 0){
  129. fprint(2, "%s: corrupt arena header: %r\n", name);
  130. return;
  131. }
  132. if(head.version != ArenaVersion4 && head.version != ArenaVersion5)
  133. fprint(2, "%s: warning: unknown arena version %d\n", name, head.version);
  134. if(len != 0 && len != head.size)
  135. fprint(2, "%s: warning: unexpected length %lld != %lld\n", name, head.size, len);
  136. if(strcmp(name, "<stdin>") != 0 && strcmp(head.name, name) != 0)
  137. fprint(2, "%s: warning: unexpected name %s\n", name, head.name);
  138. if(loadheader(name, &head, &arena, off) < 0)
  139. return;
  140. if(!arena.diskstats.sealed){
  141. fprint(2, "%s: not sealed\n", name);
  142. return;
  143. }
  144. if(verify(&arena, data, newscore) < 0){
  145. fprint(2, "%s: failed to verify before reseal: %r\n", name);
  146. return;
  147. }
  148. if(pwriteblock(data, arena.blocksize, arena.base + arena.size) < 0){
  149. fprint(2, "%s: writing new tail: %r\n", name);
  150. return;
  151. }
  152. scorecp(arena.score, newscore);
  153. fprint(2, "%s: resealed: %V\n", name, newscore);
  154. if(verify(&arena, data, newscore) < 0){
  155. fprint(2, "%s: failed to verify after reseal!: %r\n", name);
  156. return;
  157. }
  158. fprint(2, "%s: verified: %V\n", name, newscore);
  159. }
  160. static int
  161. shouldcheck(char *name, char **s, int n)
  162. {
  163. int i;
  164. if(n == 0)
  165. return 1;
  166. for(i=0; i<n; i++){
  167. if(s[i] && strcmp(name, s[i]) == 0){
  168. s[i] = nil;
  169. return 1;
  170. }
  171. }
  172. return 0;
  173. }
  174. char *
  175. readap(ArenaPart *ap)
  176. {
  177. char *table;
  178. if(preadblock(data, 8192, PartBlank) < 0)
  179. sysfatal("read arena part header: %r");
  180. if(unpackarenapart(ap, data) < 0)
  181. sysfatal("corrupted arena part header: %r");
  182. fprint(2, "# arena part version=%d blocksize=%d arenabase=%d\n",
  183. ap->version, ap->blocksize, ap->arenabase);
  184. ap->tabbase = (PartBlank+HeadSize+ap->blocksize-1)&~(ap->blocksize-1);
  185. ap->tabsize = ap->arenabase - ap->tabbase;
  186. table = malloc(ap->tabsize+1);
  187. if(preadblock((uchar*)table, ap->tabsize, ap->tabbase) < 0)
  188. sysfatal("reading arena part directory: %r");
  189. table[ap->tabsize] = 0;
  190. return table;
  191. }
  192. void
  193. threadmain(int argc, char *argv[])
  194. {
  195. int i, nline;
  196. char *p, *q, *table, *f[10], line[256];
  197. vlong start, stop;
  198. ArenaPart ap;
  199. Part *part;
  200. ventifmtinstall();
  201. blocksize = MaxIoSize;
  202. ARGBEGIN{
  203. case 'b':
  204. blocksize = unittoull(EARGF(usage()));
  205. break;
  206. case 'f':
  207. force = 1;
  208. break;
  209. case 's':
  210. sleepms = atoi(EARGF(usage()));
  211. break;
  212. default:
  213. usage();
  214. break;
  215. }ARGEND
  216. if(argc < 2)
  217. usage();
  218. data = vtmalloc(blocksize);
  219. if((part = initpart(argv[0], ORDWR)) == nil)
  220. sysfatal("open partition %s: %r", argv[0]);
  221. fd = part->fd;
  222. offset0 = part->offset;
  223. table = readap(&ap);
  224. nline = atoi(table);
  225. p = strchr(table, '\n');
  226. if(p)
  227. p++;
  228. for(i=0; i<nline; i++){
  229. if(p == nil){
  230. fprint(2, "warning: unexpected arena table end\n");
  231. break;
  232. }
  233. q = strchr(p, '\n');
  234. if(q)
  235. *q++ = 0;
  236. if(strlen(p) >= sizeof line){
  237. fprint(2, "warning: long arena table line: %s\n", p);
  238. p = q;
  239. continue;
  240. }
  241. strcpy(line, p);
  242. memset(f, 0, sizeof f);
  243. if(tokenize(line, f, nelem(f)) < 3){
  244. fprint(2, "warning: bad arena table line: %s\n", p);
  245. p = q;
  246. continue;
  247. }
  248. p = q;
  249. if(shouldcheck(f[0], argv+1, argc-1)){
  250. start = strtoull(f[1], 0, 0);
  251. stop = strtoull(f[2], 0, 0);
  252. if(stop <= start){
  253. fprint(2, "%s: bad start,stop %lld,%lld\n", f[0], stop, start);
  254. continue;
  255. }
  256. if(seek(fd, start, 0) < 0)
  257. fprint(2, "%s: seek to start: %r\n", f[0]);
  258. resealarena(f[0], stop - start);
  259. }
  260. }
  261. for(i=2; i<argc; i++)
  262. if(argv[i] != 0)
  263. fprint(2, "%s: did not find arena\n", argv[i]);
  264. threadexitsall(nil);
  265. }