hdisk.c (16445B)
1 #include "stdinc.h" 2 #include "dat.h" 3 #include "fns.h" 4 #include "whack.h" 5 6 static int disksummary(HConnect*); 7 static int diskarenapart(HConnect*, char*, Part*); 8 static int diskbloom(HConnect*, char*, Part*); 9 static int diskisect(HConnect*, char*, Part*); 10 11 int 12 hdisk(HConnect *c) 13 { 14 char *disk, *type; 15 Part *p; 16 int ret; 17 18 if(hsethtml(c) < 0) 19 return -1; 20 21 disk = hargstr(c, "disk", ""); 22 if(!disk[0]) 23 return disksummary(c); 24 if((p = initpart(disk, OREAD)) == nil){ 25 hprint(&c->hout, "open %s: %r", disk); 26 return 0; 27 } 28 29 type = hargstr(c, "type", ""); 30 switch(type[0]){ 31 case 'a': 32 ret = diskarenapart(c, disk, p); 33 break; 34 case 'b': 35 ret = diskbloom(c, disk, p); 36 break; 37 case 'i': 38 ret = diskisect(c, disk, p); 39 break; 40 default: 41 hprint(&c->hout, "unknown disk type %s", type); 42 return 0; 43 } 44 freepart(p); 45 return ret; 46 } 47 48 static int 49 disksummary(HConnect *c) 50 { 51 int i; 52 Index *ix; 53 Part *p; 54 55 hprint(&c->hout, "<h1>venti disks</h1>\n"); 56 hprint(&c->hout, "<pre>\n"); 57 ix = mainindex; 58 p = nil; 59 for(i=0; i<ix->narenas; i++){ 60 if(ix->arenas[i]->part == p) 61 continue; 62 p = ix->arenas[i]->part; 63 hprint(&c->hout, "<a href=\"/disk?disk=%s&type=a\">%s</a> %s\n", p->name, p->name, ix->arenas[i]->name); 64 } 65 hprint(&c->hout, "\n"); 66 p = nil; 67 for(i=0; i<ix->nsects; i++){ 68 if(ix->sects[i]->part == p) 69 continue; 70 p = ix->sects[i]->part; 71 hprint(&c->hout, "<a href=\"/disk?disk=%s&type=i\">%s</a> %s\n", p->name, p->name, ix->sects[i]->name); 72 } 73 hprint(&c->hout, "\n"); 74 if(ix->bloom){ 75 p = ix->bloom->part; 76 hprint(&c->hout, "<a href=\"/disk?disk=%s&type=b\">%s</a> %s\n", p->name, p->name, "bloom filter"); 77 } 78 return 0; 79 } 80 81 static char* 82 readap(Part *p, ArenaPart *ap) 83 { 84 uchar *blk; 85 char *table; 86 87 blk = vtmalloc(8192); 88 if(readpart(p, PartBlank, blk, 8192) != 8192) 89 return nil; 90 if(unpackarenapart(ap, blk) < 0){ 91 werrstr("corrupt arena part header: %r"); 92 return nil; 93 } 94 vtfree(blk); 95 ap->tabbase = (PartBlank+HeadSize+ap->blocksize-1)&~(ap->blocksize-1); 96 ap->tabsize = ap->arenabase - ap->tabbase; 97 table = vtmalloc(ap->tabsize+1); 98 if(readpart(p, ap->tabbase, (uchar*)table, ap->tabsize) != ap->tabsize){ 99 werrstr("reading arena part directory: %r"); 100 return nil; 101 } 102 table[ap->tabsize] = 0; 103 return table; 104 } 105 106 static int 107 xfindarena(char *table, char *name, vlong *start, vlong *end) 108 { 109 int i, nline; 110 char *p, *q, *f[4], line[256]; 111 112 nline = atoi(table); 113 p = strchr(table, '\n'); 114 if(p) 115 p++; 116 for(i=0; i<nline; i++){ 117 if(p == nil) 118 break; 119 q = strchr(p, '\n'); 120 if(q) 121 *q++ = 0; 122 if(strlen(p) >= sizeof line){ 123 p = q; 124 continue; 125 } 126 strcpy(line, p); 127 memset(f, 0, sizeof f); 128 if(tokenize(line, f, nelem(f)) < 3){ 129 p = q; 130 continue; 131 } 132 if(strcmp(f[0], name) == 0){ 133 *start = strtoull(f[1], 0, 0); 134 *end = strtoull(f[2], 0, 0); 135 return 0; 136 } 137 p = q; 138 } 139 return -1; 140 } 141 142 static void 143 diskarenatable(HConnect *c, char *disk, char *table) 144 { 145 char *p, *q; 146 int i, nline; 147 char *f[4], line[256], base[256]; 148 149 hprint(&c->hout, "<h2>table</h2>\n"); 150 hprint(&c->hout, "<pre>\n"); 151 nline = atoi(table); 152 snprint(base, sizeof base, "/disk?disk=%s&type=a", disk); 153 p = strchr(table, '\n'); 154 if(p) 155 p++; 156 for(i=0; i<nline; i++){ 157 if(p == nil){ 158 hprint(&c->hout, "<b><i>unexpected end of table</i></b>\n"); 159 break; 160 } 161 q = strchr(p, '\n'); 162 if(q) 163 *q++ = 0; 164 if(strlen(p) >= sizeof line){ 165 hprint(&c->hout, "%s\n", p); 166 p = q; 167 continue; 168 } 169 strcpy(line, p); 170 memset(f, 0, sizeof f); 171 if(tokenize(line, f, 3) < 3){ 172 hprint(&c->hout, "%s\n", p); 173 p = q; 174 continue; 175 } 176 p = q; 177 hprint(&c->hout, "<a href=\"%s&arena=%s\">%s</a> %s %s\n", 178 base, f[0], f[0], f[1], f[2]); 179 } 180 hprint(&c->hout, "</pre>\n"); 181 } 182 183 static char* 184 fmttime(char *buf, ulong time) 185 { 186 strcpy(buf, ctime(time)); 187 buf[28] = 0; 188 return buf; 189 } 190 191 192 static int diskarenaclump(HConnect*, Arena*, vlong, char*); 193 static int diskarenatoc(HConnect*, Arena*); 194 195 static int 196 diskarenapart(HConnect *c, char *disk, Part *p) 197 { 198 char *arenaname; 199 ArenaPart ap; 200 ArenaHead head; 201 Arena arena; 202 char *table; 203 char *score; 204 char *clump; 205 uchar *blk; 206 vlong start, end, off; 207 char tbuf[60]; 208 209 hprint(&c->hout, "<h1>arena partition %s</h1>\n", disk); 210 211 if((table = readap(p, &ap)) == nil){ 212 hprint(&c->hout, "%r\n"); 213 goto out; 214 } 215 216 hprint(&c->hout, "<pre>\n"); 217 hprint(&c->hout, "version=%d blocksize=%d base=%d\n", 218 ap.version, ap.blocksize, ap.arenabase); 219 hprint(&c->hout, "</pre>\n"); 220 221 arenaname = hargstr(c, "arena", ""); 222 if(arenaname[0] == 0){ 223 diskarenatable(c, disk, table); 224 goto out; 225 } 226 227 if(xfindarena(table, arenaname, &start, &end) < 0){ 228 hprint(&c->hout, "no such arena %s\n", arenaname); 229 goto out; 230 } 231 232 hprint(&c->hout, "<h2>arena %s</h2>\n", arenaname); 233 hprint(&c->hout, "<pre>start=%#llx end=%#llx<pre>\n", start, end); 234 if(end < start || end - start < HeadSize){ 235 hprint(&c->hout, "bad size %#llx\n", end - start); 236 goto out; 237 } 238 239 // read arena header, tail 240 blk = vtmalloc(HeadSize); 241 if(readpart(p, start, blk, HeadSize) != HeadSize){ 242 hprint(&c->hout, "reading header: %r\n"); 243 vtfree(blk); 244 goto out; 245 } 246 if(unpackarenahead(&head, blk) < 0){ 247 hprint(&c->hout, "corrupt arena header: %r\n"); 248 // hhex(blk, HeadSize); 249 vtfree(blk); 250 goto out; 251 } 252 vtfree(blk); 253 254 hprint(&c->hout, "head:\n<pre>\n"); 255 hprint(&c->hout, "version=%d name=%s blocksize=%d size=%#llx clumpmagic=%#ux\n", 256 head.version, head.name, head.blocksize, head.size, 257 head.clumpmagic); 258 hprint(&c->hout, "</pre><br><br>\n"); 259 260 if(head.blocksize > MaxIoSize || head.blocksize >= end - start){ 261 hprint(&c->hout, "corrupt block size %d\n", head.blocksize); 262 goto out; 263 } 264 265 blk = vtmalloc(head.blocksize); 266 if(readpart(p, end - head.blocksize, blk, head.blocksize) < 0){ 267 hprint(&c->hout, "reading tail: %r\n"); 268 vtfree(blk); 269 goto out; 270 } 271 memset(&arena, 0, sizeof arena); 272 arena.part = p; 273 arena.blocksize = head.blocksize; 274 arena.clumpmax = head.blocksize / ClumpInfoSize; 275 arena.base = start + head.blocksize; 276 arena.size = end - start - 2 * head.blocksize; 277 if(unpackarena(&arena, blk) < 0){ 278 vtfree(blk); 279 goto out; 280 } 281 scorecp(arena.score, blk+head.blocksize - VtScoreSize); 282 283 vtfree(blk); 284 285 hprint(&c->hout, "tail:\n<pre>\n"); 286 hprint(&c->hout, "version=%d name=%s\n", arena.version, arena.name); 287 hprint(&c->hout, "ctime=%d %s\n", arena.ctime, fmttime(tbuf, arena.ctime)); 288 hprint(&c->hout, "wtime=%d %s\n", arena.wtime, fmttime(tbuf, arena.wtime)); 289 hprint(&c->hout, "clumpmagic=%#ux\n", arena.clumpmagic); 290 hprint(&c->hout, "score %V\n", arena.score); 291 hprint(&c->hout, "diskstats:\n"); 292 hprint(&c->hout, "\tclumps=%,d cclumps=%,d used=%,lld uncsize=%,lld sealed=%d\n", 293 arena.diskstats.clumps, arena.diskstats.cclumps, 294 arena.diskstats.used, arena.diskstats.uncsize, 295 arena.diskstats.sealed); 296 hprint(&c->hout, "memstats:\n"); 297 hprint(&c->hout, "\tclumps=%,d cclumps=%,d used=%,lld uncsize=%,lld sealed=%d\n", 298 arena.memstats.clumps, arena.memstats.cclumps, 299 arena.memstats.used, arena.memstats.uncsize, 300 arena.memstats.sealed); 301 if(arena.clumpmax == 0){ 302 hprint(&c->hout, "bad clumpmax\n"); 303 goto out; 304 } 305 306 score = hargstr(c, "score", ""); 307 clump = hargstr(c, "clump", ""); 308 309 if(clump[0]){ 310 off = strtoull(clump, 0, 0); 311 diskarenaclump(c, &arena, off, score[0] ? score : nil); 312 }else if(score[0]){ 313 diskarenaclump(c, &arena, -1, score); 314 }else{ 315 diskarenatoc(c, &arena); 316 } 317 318 out: 319 free(table); 320 return 0; 321 } 322 323 static vlong 324 findintoc(HConnect *c, Arena *arena, uchar *score) 325 { 326 uchar *blk; 327 int i; 328 vlong off; 329 vlong coff; 330 ClumpInfo ci; 331 332 blk = vtmalloc(arena->blocksize); 333 off = arena->base + arena->size; 334 coff = 0; 335 for(i=0; i<arena->memstats.clumps; i++){ 336 if(i%arena->clumpmax == 0){ 337 off -= arena->blocksize; 338 if(readpart(arena->part, off, blk, arena->blocksize) != arena->blocksize){ 339 if(c) 340 hprint(&c->hout, "<i>clump info directory at %#llx: %r</i>\n<br>\n", 341 off); 342 break; 343 } 344 } 345 unpackclumpinfo(&ci, blk+(i%arena->clumpmax)*ClumpInfoSize); 346 if(scorecmp(ci.score, score) == 0){ 347 vtfree(blk); 348 return coff; 349 } 350 coff += ClumpSize + ci.size; 351 } 352 vtfree(blk); 353 return -1; 354 } 355 356 357 static int 358 diskarenatoc(HConnect *c, Arena *arena) 359 { 360 uchar *blk; 361 int i; 362 vlong off; 363 vlong coff; 364 ClumpInfo ci; 365 char base[512]; 366 int cib; 367 368 snprint(base, sizeof base, "/disk?disk=%s&type=a&arena=%s", 369 arena->part->name, arena->name); 370 371 blk = vtmalloc(arena->blocksize); 372 off = arena->base + arena->size; 373 hprint(&c->hout, "<h2>table of contents</h2>\n"); 374 hprint(&c->hout, "<pre>\n"); 375 hprint(&c->hout, "%5s %6s %7s %s\n", "type", "size", "uncsize", "score"); 376 coff = 0; 377 cib = hargint(c, "cib", 0); 378 379 for(i=0; i<arena->memstats.clumps; i++){ 380 if(i%arena->clumpmax == 0){ 381 off -= arena->blocksize; 382 if(readpart(arena->part, off, blk, arena->blocksize) != arena->blocksize){ 383 hprint(&c->hout, "<i>clump info directory at %#llx: %r</i>\n<br>\n", 384 off); 385 i += arena->clumpmax-1; 386 coff = -1; 387 continue; 388 } 389 } 390 unpackclumpinfo(&ci, blk+(i%arena->clumpmax)*ClumpInfoSize); 391 if(i/arena->clumpmax == cib || i%arena->clumpmax == 0){ 392 hprint(&c->hout, "%5d %6d %7d %V", 393 ci.type, ci.size, ci.uncsize, ci.score); 394 if(coff >= 0) 395 hprint(&c->hout, " at <a href=\"%s&clump=%#llx&score=%V\">%#llx</a>", 396 base, coff, ci.score, coff); 397 if(i/arena->clumpmax != cib) 398 hprint(&c->hout, " <font size=-1><a href=\"%s&cib=%d\">more</a></font>", base, i/arena->clumpmax); 399 hprint(&c->hout, "\n"); 400 } 401 if(coff >= 0) 402 coff += ClumpSize + ci.size; 403 } 404 hprint(&c->hout, "</pre>\n"); 405 return 0; 406 } 407 408 #define U32GET(p) ((u32int)(((p)[0]<<24)|((p)[1]<<16)|((p)[2]<<8)|(p)[3])) 409 static int 410 diskarenaclump(HConnect *c, Arena *arena, vlong off, char *scorestr) 411 { 412 uchar *blk, *blk2; 413 Clump cl; 414 char err[ERRMAX]; 415 uchar xscore[VtScoreSize], score[VtScoreSize]; 416 Unwhack uw; 417 int n; 418 419 if(scorestr){ 420 if(vtparsescore(scorestr, nil, score) < 0){ 421 hprint(&c->hout, "bad score %s: %r\n", scorestr); 422 return -1; 423 } 424 if(off < 0){ 425 off = findintoc(c, arena, score); 426 if(off < 0){ 427 hprint(&c->hout, "score %V not found in arena %s\n", score, arena->name); 428 return -1; 429 } 430 hprint(&c->hout, "score %V at %#llx\n", score, off); 431 } 432 }else 433 memset(score, 0, sizeof score); 434 435 if(off < 0){ 436 hprint(&c->hout, "bad offset %#llx\n", off); 437 return -1; 438 } 439 440 off += arena->base; 441 442 blk = vtmalloc(ClumpSize + VtMaxLumpSize); 443 if(readpart(arena->part, off, blk, ClumpSize + VtMaxLumpSize) != ClumpSize + VtMaxLumpSize){ 444 hprint(&c->hout, "reading at %#llx: %r\n", off); 445 vtfree(blk); 446 return -1; 447 } 448 449 if(unpackclump(&cl, blk, arena->clumpmagic) < 0){ 450 hprint(&c->hout, "unpackclump: %r\n<br>"); 451 rerrstr(err, sizeof err); 452 if(strstr(err, "magic")){ 453 hprint(&c->hout, "trying again with magic=%#ux<br>\n", U32GET(blk)); 454 if(unpackclump(&cl, blk, U32GET(blk)) < 0){ 455 hprint(&c->hout, "unpackclump: %r\n<br>\n"); 456 goto error; 457 } 458 }else 459 goto error; 460 } 461 462 hprint(&c->hout, "<pre>type=%d size=%d uncsize=%d score=%V\n", cl.info.type, cl.info.size, cl.info.uncsize, cl.info.score); 463 hprint(&c->hout, "encoding=%d creator=%d time=%d %s</pre>\n", cl.encoding, cl.creator, cl.time, fmttime(err, cl.time)); 464 465 if(cl.info.type == VtCorruptType) 466 hprint(&c->hout, "clump is marked corrupt<br>\n"); 467 468 if(cl.info.size >= VtMaxLumpSize){ 469 hprint(&c->hout, "clump too big\n"); 470 goto error; 471 } 472 473 switch(cl.encoding){ 474 case ClumpECompress: 475 blk2 = vtmalloc(VtMaxLumpSize); 476 unwhackinit(&uw); 477 n = unwhack(&uw, blk2, cl.info.uncsize, blk+ClumpSize, cl.info.size); 478 if(n < 0){ 479 hprint(&c->hout, "decompression failed\n"); 480 vtfree(blk2); 481 goto error; 482 } 483 if(n != cl.info.uncsize){ 484 hprint(&c->hout, "got wrong amount: %d wanted %d\n", n, cl.info.uncsize); 485 // hhex(blk2, n); 486 vtfree(blk2); 487 goto error; 488 } 489 scoremem(xscore, blk2, cl.info.uncsize); 490 vtfree(blk2); 491 break; 492 case ClumpENone: 493 scoremem(xscore, blk+ClumpSize, cl.info.size); 494 break; 495 } 496 497 hprint(&c->hout, "score=%V<br>\n", xscore); 498 if(scorestr && scorecmp(score, xscore) != 0) 499 hprint(&c->hout, "score does NOT match expected %V\n", score); 500 501 vtfree(blk); 502 return 0; 503 504 error: 505 // hhex(blk, ClumpSize + VtMaxLumpSize); 506 vtfree(blk); 507 return -1; 508 } 509 510 static int 511 diskbloom(HConnect *c, char *disk, Part *p) 512 { 513 USED(c); 514 USED(disk); 515 USED(p); 516 return 0; 517 } 518 519 static int 520 diskisect(HConnect *c, char *disk, Part *p) 521 { 522 USED(c); 523 USED(disk); 524 USED(p); 525 return 0; 526 } 527 528 static void 529 debugamap(HConnect *c) 530 { 531 int i; 532 AMap *amap; 533 534 hprint(&c->hout, "<h2>arena map</h2>\n"); 535 hprint(&c->hout, "<pre>\n"); 536 537 amap = mainindex->amap; 538 for(i=0; i<mainindex->narenas; i++) 539 hprint(&c->hout, "%s %#llx %#llx\n", 540 amap[i].name, amap[i].start, amap[i].stop); 541 } 542 543 static void 544 debugread(HConnect *c, u8int *score) 545 { 546 int type; 547 Lump *u; 548 IAddr ia; 549 IEntry ie; 550 int i; 551 Arena *arena; 552 u64int aa; 553 ZBlock *zb; 554 Clump cl; 555 vlong off; 556 u8int sc[VtScoreSize]; 557 558 if(scorecmp(score, zeroscore) == 0){ 559 hprint(&c->hout, "zero score\n"); 560 return; 561 } 562 563 hprint(&c->hout, "<h2>index search %V</h2><pre>\n", score); 564 if(icachelookup(score, -1, &ia) < 0) 565 hprint(&c->hout, " icache: not found\n"); 566 else 567 hprint(&c->hout, " icache: addr=%#llx size=%d type=%d blocks=%d\n", 568 ia.addr, ia.size, ia.type, ia.blocks); 569 570 if(loadientry(mainindex, score, -1, &ie) < 0) 571 hprint(&c->hout, " idisk: not found\n"); 572 else 573 hprint(&c->hout, " idisk: addr=%#llx size=%d type=%d blocks=%d\n", 574 ie.ia.addr, ie.ia.size, ie.ia.type, ie.ia.blocks); 575 576 hprint(&c->hout, "</pre><h2>lookup %V</h2>\n", score); 577 hprint(&c->hout, "<pre>\n"); 578 579 for(type=0; type < VtMaxType; type++){ 580 hprint(&c->hout, "%V type %d:", score, type); 581 u = lookuplump(score, type); 582 if(u->data != nil) 583 hprint(&c->hout, " +cache"); 584 else 585 hprint(&c->hout, " -cache"); 586 putlump(u); 587 588 if(lookupscore(score, type, &ia) < 0){ 589 hprint(&c->hout, " -lookup\n"); 590 continue; 591 } 592 hprint(&c->hout, "\n lookupscore: addr=%#llx size=%d blocks=%d\n", 593 ia.addr, ia.size, ia.blocks); 594 595 arena = amapitoa(mainindex, ia.addr, &aa); 596 if(arena == nil){ 597 hprint(&c->hout, " amapitoa failed: %r\n"); 598 continue; 599 } 600 601 hprint(&c->hout, " amapitoa: aa=%#llx arena=" 602 "<a href=\"/disk?disk=%s&type=a&arena=%s&score=%V\">%s</a>\n", 603 aa, arena->part->name, arena->name, score, arena->name); 604 zb = loadclump(arena, aa, ia.blocks, &cl, sc, 1); 605 if(zb == nil){ 606 hprint(&c->hout, " loadclump failed: %r\n"); 607 continue; 608 } 609 610 hprint(&c->hout, " loadclump: uncsize=%d type=%d score=%V\n", 611 cl.info.uncsize, cl.info.type, sc); 612 if(ia.size != cl.info.uncsize || ia.type != cl.info.type || scorecmp(score, sc) != 0){ 613 hprint(&c->hout, " clump info mismatch\n"); 614 continue; 615 } 616 } 617 618 if(hargstr(c, "brute", "")[0] == 'y'){ 619 hprint(&c->hout, "</pre>\n"); 620 hprint(&c->hout, "<h2>brute force arena search %V</h2>\n", score); 621 hprint(&c->hout, "<pre>\n"); 622 623 for(i=0; i<mainindex->narenas; i++){ 624 arena = mainindex->arenas[i]; 625 hprint(&c->hout, "%s...\n", arena->name); 626 hflush(&c->hout); 627 off = findintoc(nil, arena, score); 628 if(off >= 0) 629 hprint(&c->hout, "%s %#llx (%#llx)\n", arena->name, off, mainindex->amap[i].start + off); 630 } 631 } 632 633 hprint(&c->hout, "</pre>\n"); 634 } 635 636 static void 637 debugmem(HConnect *c) 638 { 639 Index *ix; 640 641 ix = mainindex; 642 hprint(&c->hout, "<h2>memory</h2>\n"); 643 644 hprint(&c->hout, "<pre>\n"); 645 hprint(&c->hout, "ix=%p\n", ix); 646 hprint(&c->hout, "\tarenas=%p\n", ix->arenas); 647 if(ix->narenas > 0) 648 hprint(&c->hout, "\tarenas[...] = %p...%p\n", ix->arenas[0], ix->arenas[ix->narenas-1]); 649 hprint(&c->hout, "\tsmap=%p\n", ix->smap); 650 hprint(&c->hout, "\tamap=%p\n", ix->amap); 651 hprint(&c->hout, "\tbloom=%p\n", ix->bloom); 652 hprint(&c->hout, "\tbloom->data=%p\n", ix->bloom ? ix->bloom->data : nil); 653 hprint(&c->hout, "\tisects=%p\n", ix->sects); 654 if(ix->nsects > 0) 655 hprint(&c->hout, "\tsects[...] = %p...%p\n", ix->sects[0], ix->sects[ix->nsects-1]); 656 } 657 658 int 659 hdebug(HConnect *c) 660 { 661 char *scorestr, *op; 662 u8int score[VtScoreSize]; 663 664 if(hsethtml(c) < 0) 665 return -1; 666 hprint(&c->hout, "<h1>venti debug</h1>\n"); 667 668 op = hargstr(c, "op", ""); 669 if(!op[0]){ 670 hprint(&c->hout, "no op\n"); 671 return 0; 672 } 673 674 if(strcmp(op, "amap") == 0){ 675 debugamap(c); 676 return 0; 677 } 678 679 if(strcmp(op, "mem") == 0){ 680 debugmem(c); 681 return 0; 682 } 683 684 if(strcmp(op, "read") == 0){ 685 scorestr = hargstr(c, "score", ""); 686 if(vtparsescore(scorestr, nil, score) < 0){ 687 hprint(&c->hout, "bad score %s: %r\n", scorestr); 688 return 0; 689 } 690 debugread(c, score); 691 return 0; 692 } 693 694 hprint(&c->hout, "unknown op %s", op); 695 return 0; 696 }