URI:
       tprintarenapart.c - plan9port - [fork] Plan 9 from user space
  HTML git clone git://src.adamsgaard.dk/plan9port
   DIR Log
   DIR Files
   DIR Refs
   DIR README
   DIR LICENSE
       ---
       tprintarenapart.c (3548B)
       ---
            1 #include "stdinc.h"
            2 #include "dat.h"
            3 #include "fns.h"
            4 
            5 uchar buf[64*1024];
            6 
            7 void
            8 usage(void)
            9 {
           10         fprint(2, "usage: printarenapart arenafile [offset]\n");
           11         threadexitsall("usage");
           12 }
           13 
           14 /* unused */
           15 void
           16 rdarena(Arena *arena, u64int offset)
           17 {
           18         u64int a, aa, e;
           19         u32int magic;
           20         Clump cl;
           21         uchar score[VtScoreSize];
           22         ZBlock *lump;
           23 
           24         printarena(2, arena);
           25 
           26         a = arena->base;
           27         e = arena->base + arena->size;
           28         if(offset != ~(u64int)0) {
           29                 if(offset >= e-a)
           30                         sysfatal("bad offset %llud >= %llud",
           31                                 offset, e-a);
           32                 aa = offset;
           33         } else
           34                 aa = 0;
           35 
           36         for(; aa < e; aa += ClumpSize+cl.info.size) {
           37                 magic = clumpmagic(arena, aa);
           38                 if(magic == ClumpFreeMagic)
           39                         break;
           40                 if(magic != arena->clumpmagic) {
           41                         fprint(2, "illegal clump magic number %#8.8ux offset %llud\n",
           42                                 magic, aa);
           43                         break;
           44                 }
           45                 lump = loadclump(arena, aa, 0, &cl, score, 0);
           46                 if(lump == nil) {
           47                         fprint(2, "clump %llud failed to read: %r\n", aa);
           48                         break;
           49                 }
           50                 if(cl.info.type != VtCorruptType) {
           51                         scoremem(score, lump->data, cl.info.uncsize);
           52                         if(scorecmp(cl.info.score, score) != 0) {
           53                                 fprint(2, "clump %llud has mismatched score\n", aa);
           54                                 break;
           55                         }
           56                         if(vttypevalid(cl.info.type) < 0) {
           57                                 fprint(2, "clump %llud has bad type %d\n", aa, cl.info.type);
           58                                 break;
           59                         }
           60                 }
           61                 print("%22llud %V %3d %5d\n", aa, score, cl.info.type, cl.info.uncsize);
           62                 freezblock(lump);
           63         }
           64         print("end offset %llud\n", aa);
           65 }
           66 
           67 void
           68 threadmain(int argc, char *argv[])
           69 {
           70         char *file, *p, *name;
           71         char *table;
           72         u64int offset;
           73         Part *part;
           74         ArenaPart ap;
           75         ArenaHead head;
           76         Arena tail;
           77         char ct[40], mt[40];
           78 
           79         readonly = 1;        /* for part.c */
           80         ARGBEGIN{
           81         default:
           82                 usage();
           83                 break;
           84         }ARGEND
           85 
           86         switch(argc) {
           87         default:
           88                 usage();
           89         case 1:
           90                 file = argv[0];
           91         }
           92 
           93         ventifmtinstall();
           94         statsinit();
           95 
           96         part = initpart(file, OREAD|ODIRECT);
           97         if(part == nil)
           98                 sysfatal("can't open file %s: %r", file);
           99         if(readpart(part, PartBlank, buf, sizeof buf) < 0)
          100                 sysfatal("can't read file %s: %r", file);
          101 
          102         if(unpackarenapart(&ap, buf) < 0)
          103                 sysfatal("corrupted arena part header: %r");
          104 
          105         print("# arena part version=%d blocksize=%d arenabase=%d\n",
          106                 ap.version, ap.blocksize, ap.arenabase);
          107         ap.tabbase = (PartBlank+HeadSize+ap.blocksize-1)&~(ap.blocksize-1);
          108         ap.tabsize = ap.arenabase - ap.tabbase;
          109 
          110         table = malloc(ap.tabsize+1);
          111         if(readpart(part, ap.tabbase, (uchar*)table, ap.tabsize) < 0)
          112                 sysfatal("read %s: %r", file);
          113         table[ap.tabsize] = 0;
          114 
          115         partblocksize(part, ap.blocksize);
          116         initdcache(8 * MaxDiskBlock);
          117 
          118         for(p=table; p && *p; p=strchr(p, '\n')){
          119                 if(*p == '\n')
          120                         p++;
          121                 name = p;
          122                 p = strpbrk(p, " \t");
          123                 if(p == nil){
          124                         fprint(2, "bad line: %s\n", name);
          125                         break;
          126                 }
          127                 offset = strtoull(p, nil, 0);
          128                 if(readpart(part, offset, buf, sizeof buf) < 0){
          129                         fprint(2, "%s: read %s: %r\n", argv0, file);
          130                         continue;
          131                 }
          132                 if(unpackarenahead(&head, buf) < 0){
          133                         fprint(2, "%s: unpackarenahead: %r\n", argv0);
          134                         continue;
          135                 }
          136                 if(readpart(part, offset+head.size-head.blocksize, buf, head.blocksize) < 0){
          137                         fprint(2, "%s: read %s: %r\n", argv0, file);
          138                         continue;
          139                 }
          140                 if(unpackarena(&tail, buf) < 0){
          141                         fprint(2, "%s: unpackarena: %r\n", argv0);
          142                         continue;
          143                 }
          144                 print("arena %s %lld clumps=%,d cclumps=%,d used=%,lld uncsize=%,lld%s\n",
          145                         tail.name, offset,
          146                         tail.diskstats.clumps, tail.diskstats.cclumps,
          147                         tail.diskstats.used, tail.diskstats.uncsize,
          148                         tail.diskstats.sealed ? " sealed" : "");
          149                 strcpy(ct, ctime(tail.ctime));
          150                 ct[28] = 0;
          151                 strcpy(mt, ctime(tail.wtime));
          152                 mt[28] = 0;
          153                 print("\tctime=%s\n\tmtime=%s\n", ct, mt);
          154         }
          155         threadexitsall(0);
          156 }