Return to dump.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/dump.c, revision 1.1

1.1     ! root        1: #define        NI      16
        !             2: #define        DIRPB   (BSIZE/sizeof(struct direct))
        !             3: 
        !             4: #include <stdio.h>
        !             5: #include <sys/param.h>
        !             6: #include <sys/inode.h>
        !             7: #include <sys/ino.h>
        !             8: #include <sys/fblk.h>
        !             9: #include <sys/filsys.h>
        !            10: #include <sys/dir.h>
        !            11: #include <dumprestor.h>
        !            12: 
        !            13: #define        MWORD(m,i) (m[(unsigned)(i-1)/MLEN])
        !            14: #define        MBIT(i) (1<<((unsigned)(i-1)%MLEN))
        !            15: #define        BIS(i,w)        (MWORD(w,i) |=  MBIT(i))
        !            16: #define        BIC(i,w)        (MWORD(w,i) &= ~MBIT(i))
        !            17: #define        BIT(i,w)        (MWORD(w,i) & MBIT(i))
        !            18: 
        !            19: struct filsys  sblock;
        !            20: struct dinode  itab[INOPB*NI];
        !            21: short  clrmap[MSIZ];
        !            22: short  dirmap[MSIZ];
        !            23: short  nodmap[MSIZ];
        !            24: 
        !            25: char   *disk;
        !            26: char   *tape;
        !            27: char   *increm;
        !            28: char   incno;
        !            29: int    uflag;
        !            30: int    fi;
        !            31: int    to;
        !            32: ino_t  ino;
        !            33: int    nsubdir;
        !            34: int    ntape;
        !            35: int    nadded;
        !            36: int    dadded;
        !            37: int    density = 160;
        !            38: 
        !            39: char   *ctime();
        !            40: char   *prdate();
        !            41: long   atol();
        !            42: int    fi;
        !            43: long   tsize;
        !            44: long   esize;
        !            45: long   asize;
        !            46: int    mark();
        !            47: int    add();
        !            48: int    dump();
        !            49: int    tapsrec();
        !            50: int    dmpspc();
        !            51: int    dsrch();
        !            52: int    nullf();
        !            53: 
        !            54: #define        HOUR    (60L*60L)
        !            55: #define        DAY     (24L*HOUR)
        !            56: #define        YEAR    (365L*DAY)
        !            57: 
        !            58: main(argc, argv)
        !            59: char *argv[];
        !            60: {
        !            61:        char *arg;
        !            62:        register i;
        !            63: 
        !            64:        time(&spcl.c_date);
        !            65: 
        !            66:        tsize = 2300L*12L*10L;
        !            67:        tape = "/dev/rmt1";
        !            68:        disk = "/dev/rrp1g";
        !            69:        increm = "/etc/ddate";
        !            70:        incno = '9';
        !            71:        uflag = 0;
        !            72:        arg = "u";
        !            73:        if(argc > 1) {
        !            74:                argv++;
        !            75:                argc--;
        !            76:                arg = *argv;
        !            77:        }
        !            78:        while(*arg)
        !            79:        switch (*arg++) {
        !            80: 
        !            81:        case 'f':
        !            82:                if(argc > 1) {
        !            83:                        argv++;
        !            84:                        argc--;
        !            85:                        tape = *argv;
        !            86:                }
        !            87:                break;
        !            88: 
        !            89:        case 'd':
        !            90:                if (argc > 1) {
        !            91:                        argv++;
        !            92:                        argc--;
        !            93:                        density = atoi(*argv);
        !            94:                }
        !            95:                break;
        !            96: 
        !            97:        case 's':
        !            98:                if(argc > 1) {
        !            99:                        argv++;
        !           100:                        argc--;
        !           101:                        tsize = atol(*argv);
        !           102:                        tsize *= 12L*10L;
        !           103:                }
        !           104:                break;
        !           105: 
        !           106:        case '0':
        !           107:        case '1':
        !           108:        case '2':
        !           109:        case '3':
        !           110:        case '4':
        !           111:        case '5':
        !           112:        case '6':
        !           113:        case '7':
        !           114:        case '8':
        !           115:        case '9':
        !           116:                incno = arg[-1];
        !           117:                break;
        !           118: 
        !           119:        case 'u':
        !           120:                uflag++;
        !           121:                break;
        !           122: 
        !           123:        default:
        !           124:                printf("bad key '%c%'\n", arg[-1]);
        !           125:                exit(1);
        !           126:        }
        !           127:        if(argc > 1) {
        !           128:                argv++;
        !           129:                argc--;
        !           130:                disk = *argv;
        !           131:        }
        !           132: 
        !           133:        getitime();
        !           134:        printf("     date = %s\n", prdate(spcl.c_date));
        !           135:        printf("dump date = %s\n", prdate(spcl.c_ddate));
        !           136:        printf("dumping %s to %s\n", disk, tape);
        !           137:        fi = open(disk, 0);
        !           138:        if(fi < 0) {
        !           139:                printf("dump: cannot open %s\n", disk);
        !           140:                exit(1);
        !           141:        }
        !           142:        otape();
        !           143:        printf("I\n");
        !           144:        esize = 0;
        !           145:        CLR(clrmap);
        !           146:        CLR(dirmap);
        !           147:        CLR(nodmap);
        !           148: 
        !           149:        pass(mark, (short *)NULL);
        !           150:        do {
        !           151:                printf("II\n");
        !           152:                nadded = 0;
        !           153:                pass(add, dirmap);
        !           154:        } while(nadded);
        !           155: 
        !           156:        bmapest(clrmap);
        !           157:        bmapest(nodmap);
        !           158:        printf("estimated %ld tape blocks on %d tape(s)\n",
        !           159:                esize, 0);
        !           160: 
        !           161:        printf("III\n");
        !           162:        bitmap(clrmap, TS_CLRI);
        !           163:        pass(dump, dirmap);
        !           164:        printf("IV\n");
        !           165:        pass(dump, nodmap);
        !           166:        putitime();
        !           167:        printf("DONE\n");
        !           168:        spcl.c_type = TS_END;
        !           169:        for(i=0; i<NTREC; i++)
        !           170:                spclrec();
        !           171:        printf("%ld tape blocks on %d tape(s)\n",
        !           172:                spcl.c_tapea, spcl.c_volume);
        !           173: }
        !           174: 
        !           175: pass(fn, map)
        !           176: int (*fn)();
        !           177: short *map;
        !           178: {
        !           179:        register i, j;
        !           180:        int bits;
        !           181:        ino_t mino;
        !           182:        daddr_t d;
        !           183: 
        !           184:        sync();
        !           185:        bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
        !           186:        mino = (sblock.s_isize-2) * INOPB;
        !           187:        ino = 0;
        !           188:        for(i=2;; i+=NI) {
        !           189:                if(ino >= mino)
        !           190:                        break;
        !           191:                d = (unsigned)i;
        !           192:                for(j=0; j<INOPB*NI; j++) {
        !           193:                        if(ino >= mino)
        !           194:                                break;
        !           195:                        if((ino % MLEN) == 0) {
        !           196:                                bits = ~0;
        !           197:                                if(map != NULL)
        !           198:                                        bits = *map++;
        !           199:                        }
        !           200:                        ino++;
        !           201:                        if(bits & 1) {
        !           202:                                if(d != 0) {
        !           203:                                        bread(d, (char *)itab, sizeof(itab));
        !           204:                                        d = 0;
        !           205:                                }
        !           206:                                (*fn)(&itab[j]);
        !           207:                        }
        !           208:                        bits >>= 1;
        !           209:                }
        !           210:        }
        !           211: }
        !           212: 
        !           213: icat(ip, fn1, fn2)
        !           214: struct dinode  *ip;
        !           215: int (*fn1)(), (*fn2)();
        !           216: {
        !           217:        register i;
        !           218:        daddr_t d[NADDR];
        !           219: 
        !           220:        l3tol(&d[0], &ip->di_addr[0], NADDR);
        !           221:        (*fn2)(d, NADDR-3);
        !           222:        for(i=0; i<NADDR; i++) {
        !           223:                if(d[i] != 0) {
        !           224:                        if(i < NADDR-3)
        !           225:                                (*fn1)(d[i]); else
        !           226:                                indir(d[i], fn1, fn2, i-(NADDR-3));
        !           227:                }
        !           228:        }
        !           229: }
        !           230: 
        !           231: indir(d, fn1, fn2, n)
        !           232: daddr_t d;
        !           233: int (*fn1)(), (*fn2)();
        !           234: {
        !           235:        register i;
        !           236:        daddr_t idblk[NINDIR];
        !           237: 
        !           238:        bread(d, (char *)idblk, sizeof(idblk));
        !           239:        if(n <= 0) {
        !           240:                spcl.c_type = TS_ADDR;
        !           241:                (*fn2)(idblk, NINDIR);
        !           242:                for(i=0; i<NINDIR; i++) {
        !           243:                        d = idblk[i];
        !           244:                        if(d != 0)
        !           245:                                (*fn1)(d);
        !           246:                }
        !           247:        } else {
        !           248:                n--;
        !           249:                for(i=0; i<NINDIR; i++) {
        !           250:                        d = idblk[i];
        !           251:                        if(d != 0)
        !           252:                                indir(d, fn1, fn2, n);
        !           253:                }
        !           254:        }
        !           255: }
        !           256: 
        !           257: mark(ip)
        !           258: struct dinode *ip;
        !           259: {
        !           260:        register f;
        !           261: 
        !           262:        f = ip->di_mode & IFMT;
        !           263:        if(f == 0)
        !           264:                return;
        !           265:        BIS(ino, clrmap);
        !           266:        if(f == IFDIR)
        !           267:                BIS(ino, dirmap);
        !           268:        if(ip->di_mtime >= spcl.c_ddate ||
        !           269:           ip->di_ctime >= spcl.c_ddate) {
        !           270:                BIS(ino, nodmap);
        !           271:                if (f != IFREG)
        !           272:                        return;
        !           273:                est(ip);
        !           274:        }
        !           275: }
        !           276: 
        !           277: add(ip)
        !           278: struct dinode *ip;
        !           279: {
        !           280: 
        !           281:        if(BIT(ino, nodmap))
        !           282:                return;
        !           283:        nsubdir = 0;
        !           284:        dadded = 0;
        !           285:        icat(ip, dsrch, nullf);
        !           286:        if(dadded) {
        !           287:                BIS(ino, nodmap);
        !           288:                est(ip);
        !           289:                nadded++;
        !           290:        }
        !           291:        if(nsubdir == 0)
        !           292:                if(!BIT(ino, nodmap))
        !           293:                        BIC(ino, dirmap);
        !           294: }
        !           295: 
        !           296: dump(ip)
        !           297: struct dinode *ip;
        !           298: {
        !           299:        register i;
        !           300: 
        !           301:        if(ntape) {
        !           302:                ntape = 0;
        !           303:                bitmap(nodmap, TS_BITS);
        !           304:        }
        !           305:        BIC(ino, nodmap);
        !           306:        spcl.c_dinode = *ip;
        !           307:        spcl.c_type = TS_INODE;
        !           308:        spcl.c_count = 0;
        !           309:        i = ip->di_mode & IFMT;
        !           310:        if(i != IFDIR && i != IFREG) {
        !           311:                spclrec();
        !           312:                return;
        !           313:        }
        !           314:        icat(ip, tapsrec, dmpspc);
        !           315: }
        !           316: 
        !           317: dmpspc(dp, n)
        !           318: daddr_t *dp;
        !           319: {
        !           320:        register i, t;
        !           321: 
        !           322:        spcl.c_count = n;
        !           323:        for(i=0; i<n; i++) {
        !           324:                t = 0;
        !           325:                if(dp[i] != 0)
        !           326:                        t++;
        !           327:                spcl.c_addr[i] = t;
        !           328:        }
        !           329:        spclrec();
        !           330: }
        !           331: 
        !           332: bitmap(map, typ)
        !           333: short *map;
        !           334: {
        !           335:        register i, n;
        !           336:        char *cp;
        !           337: 
        !           338:        n = -1;
        !           339:        for(i=0; i<MSIZ; i++)
        !           340:                if(map[i])
        !           341:                        n = i;
        !           342:        if(n < 0)
        !           343:                return;
        !           344:        spcl.c_type = typ;
        !           345:        spcl.c_count = (n*sizeof(map[0]) + BSIZE)/BSIZE;
        !           346:        spclrec();
        !           347:        cp = (char *)map;
        !           348:        for(i=0; i<spcl.c_count; i++) {
        !           349:                taprec(cp);
        !           350:                cp += BSIZE;
        !           351:        }
        !           352: }
        !           353: 
        !           354: spclrec()
        !           355: {
        !           356:        register i, *ip, s;
        !           357: 
        !           358:        spcl.c_inumber = ino;
        !           359:        spcl.c_magic = MAGIC;
        !           360:        spcl.c_checksum = 0;
        !           361:        ip = (int *)&spcl;
        !           362:        s = 0;
        !           363:        for(i=0; i<BSIZE/sizeof(*ip); i++)
        !           364:                s += *ip++;
        !           365:        spcl.c_checksum = CHECKSUM - s;
        !           366:        taprec((char *)&spcl);
        !           367: }
        !           368: 
        !           369: dsrch(d)
        !           370: daddr_t d;
        !           371: {
        !           372:        register char *cp;
        !           373:        register i;
        !           374:        register ino_t in;
        !           375:        struct direct dblk[DIRPB];
        !           376: 
        !           377:        if(dadded)
        !           378:                return;
        !           379:        bread(d, (char *)dblk, sizeof(dblk));
        !           380:        for(i=0; i<DIRPB; i++) {
        !           381:                in = dblk[i].d_ino;
        !           382:                if(in == 0)
        !           383:                        continue;
        !           384:                cp = dblk[i].d_name;
        !           385:                if(cp[0] == '.') {
        !           386:                        if(cp[1] == '\0')
        !           387:                                continue;
        !           388:                        if(cp[1] == '.' && cp[2] == '\0')
        !           389:                                continue;
        !           390:                }
        !           391:                if(BIT(in, nodmap)) {
        !           392:                        dadded++;
        !           393:                        return;
        !           394:                }
        !           395:                if(BIT(in, dirmap))
        !           396:                        nsubdir++;
        !           397:        }
        !           398: }
        !           399: 
        !           400: nullf()
        !           401: {
        !           402: }
        !           403: 
        !           404: bread(da, ba, c)
        !           405: daddr_t da;
        !           406: char *ba;
        !           407: {
        !           408:        register n;
        !           409: 
        !           410:        lseek(fi, da*BSIZE, 0);
        !           411:        n = read(fi, ba, c);
        !           412:        if(n != c)
        !           413:                printf("asked %d; got %d\n", c, n);
        !           414: }
        !           415: 
        !           416: CLR(map)
        !           417: register short *map;
        !           418: {
        !           419:        register n;
        !           420: 
        !           421:        n = MSIZ;
        !           422:        do
        !           423:                *map++ = 0;
        !           424:        while(--n);
        !           425: }
        !           426: 
        !           427: 
        !           428: char   tblock[NTREC][BSIZE];
        !           429: daddr_t        tdaddr[NTREC];
        !           430: int    trecno;
        !           431: 
        !           432: taprec(dp)
        !           433: char *dp;
        !           434: {
        !           435:        register i;
        !           436: 
        !           437:        for(i=0; i<BSIZE; i++)
        !           438:                tblock[trecno][i] = *dp++;
        !           439:        tdaddr[trecno] = 0;
        !           440:        trecno++;
        !           441:        spcl.c_tapea++;
        !           442:        if(trecno >= NTREC)
        !           443:                flusht();
        !           444: }
        !           445: 
        !           446: tapsrec(d)
        !           447: daddr_t d;
        !           448: {
        !           449: 
        !           450:        if(d == 0)
        !           451:                return;
        !           452:        tdaddr[trecno] = d;
        !           453:        trecno++;
        !           454:        spcl.c_tapea++;
        !           455:        if(trecno >= NTREC)
        !           456:                flusht();
        !           457: }
        !           458: 
        !           459: flusht()
        !           460: {
        !           461:        char place[100];
        !           462:        register i, si;
        !           463:        daddr_t d;
        !           464: 
        !           465:        while(trecno < NTREC)
        !           466:                tdaddr[trecno++] = 1;
        !           467: 
        !           468: loop:
        !           469:        d = 0;
        !           470:        for(i=0; i<NTREC; i++)
        !           471:                if(tdaddr[i] != 0)
        !           472:                if(d == 0 || tdaddr[i] < d) {
        !           473:                        si = i;
        !           474:                        d = tdaddr[i];
        !           475:                }
        !           476:        if(d != 0) {
        !           477:                bread(d, tblock[si], BSIZE);
        !           478:                tdaddr[si] = 0;
        !           479:                goto loop;
        !           480:        }
        !           481:        trecno = 0;
        !           482:        write(to, tblock[0], sizeof(tblock));
        !           483:        asize += sizeof(tblock)/density;
        !           484:        asize += 7;
        !           485:        if(asize > tsize) {
        !           486:                close(to);
        !           487:                printf("change tapes\n");
        !           488:                read(0, place, sizeof(place));
        !           489:                otape();
        !           490:        }
        !           491: }
        !           492: 
        !           493: otape()
        !           494: {
        !           495:        to = creat(tape, 0666);
        !           496:        if(to < 0) {
        !           497:                printf("dump: cannot create %s\n", tape);
        !           498:                exit(1);
        !           499:        }
        !           500:        asize = 0;
        !           501:        ntape++;
        !           502:        spcl.c_volume++;
        !           503:        spcl.c_type = TS_TAPE;
        !           504:        spclrec();
        !           505: }
        !           506: 
        !           507: char *
        !           508: prdate(d)
        !           509: time_t d;
        !           510: {
        !           511:        char *p;
        !           512: 
        !           513:        if(d == 0)
        !           514:                return("the epoch");
        !           515:        p = ctime(&d);
        !           516:        p[24] = 0;
        !           517:        return(p);
        !           518: }
        !           519: 
        !           520: getitime()
        !           521: {
        !           522:        register i, df;
        !           523:        struct idates idbuf;
        !           524:        char *fname;
        !           525: 
        !           526:        fname = disk;
        !           527: l1:
        !           528:        for(i=0; fname[i]; i++)
        !           529:                if(fname[i] == '/') {
        !           530:                        fname += i+1;
        !           531:                        goto l1;
        !           532:                }
        !           533: 
        !           534:        spcl.c_ddate = 0;
        !           535:        df = open(increm, 0);
        !           536:        if(df < 0) {
        !           537:                printf("cannot open %s\n", increm);
        !           538:                exit(1);
        !           539:        }
        !           540: 
        !           541: l2:
        !           542:        i = read(df, (char *)&idbuf, sizeof(idbuf));
        !           543:        if(i != sizeof(idbuf)) {
        !           544:                close(df);
        !           545:                return;
        !           546:        }
        !           547:        for(i=0;; i++) {
        !           548:                if(fname[i] != idbuf.id_name[i])
        !           549:                        goto l2;
        !           550:                if(fname[i] == '\0')
        !           551:                        break;
        !           552:        }
        !           553:        if(idbuf.id_incno >= incno)
        !           554:                goto l2;
        !           555:        if(idbuf.id_ddate <= spcl.c_ddate)
        !           556:                goto l2;
        !           557:        spcl.c_ddate = idbuf.id_ddate;
        !           558:        goto l2;
        !           559: }
        !           560: 
        !           561: putitime()
        !           562: {
        !           563:        register i, n, df;
        !           564:        struct idates idbuf;
        !           565:        char *fname;
        !           566: 
        !           567:        if(uflag == 0)
        !           568:                return;
        !           569:        fname = disk;
        !           570: l1:
        !           571:        for(i=0; fname[i]; i++)
        !           572:                if(fname[i] == '/') {
        !           573:                        fname += i+1;
        !           574:                        goto l1;
        !           575:                }
        !           576: 
        !           577:        spcl.c_ddate = 0;
        !           578:        df = open(increm, 2);
        !           579:        if(df < 0) {
        !           580:                printf("cannot open %s\n", increm);
        !           581:                exit(1);
        !           582:        }
        !           583:        n = 0;
        !           584: l2:
        !           585:        i = read(df, (char *)&idbuf, sizeof(idbuf));
        !           586:        if(i != sizeof(idbuf))
        !           587:                goto l3;
        !           588:        n++;
        !           589:        for(i=0;; i++) {
        !           590:                if(fname[i] != idbuf.id_name[i])
        !           591:                        goto l2;
        !           592:                if(fname[i] == '\0')
        !           593:                        break;
        !           594:        }
        !           595:        if(idbuf.id_incno != incno)
        !           596:                goto l2;
        !           597: l3:
        !           598:        lseek(df, (long)n*sizeof(idbuf), 0);
        !           599:        for(i=0;; i++) {
        !           600:                idbuf.id_name[i] = fname[i];
        !           601:                if(fname[i] == '\0')
        !           602:                        break;
        !           603:        }
        !           604:        idbuf.id_incno = incno;
        !           605:        idbuf.id_ddate = spcl.c_date;
        !           606:        write(df, (char *)&idbuf, sizeof(idbuf));
        !           607:        close(df);
        !           608:        printf("level %c dump on %s\n", incno, prdate(spcl.c_date));
        !           609: }
        !           610: 
        !           611: est(ip)
        !           612: struct dinode *ip;
        !           613: {
        !           614:        long s;
        !           615: 
        !           616:        esize++;
        !           617:        s = (ip->di_size + BSIZE-1) / BSIZE;
        !           618:        esize += s;
        !           619:        if(s > NADDR-3) {
        !           620:                s -= NADDR-3;
        !           621:                s = (s + (BSIZE/sizeof(daddr_t))-1) / (BSIZE/sizeof(daddr_t));
        !           622:                esize += s;
        !           623:        }
        !           624: }
        !           625: 
        !           626: bmapest(map)
        !           627: short *map;
        !           628: {
        !           629:        register i, n;
        !           630: 
        !           631:        n = -1;
        !           632:        for(i=0; i<MSIZ; i++)
        !           633:                if(map[i])
        !           634:                        n = i;
        !           635:        if(n < 0)
        !           636:                return;
        !           637:        esize++;
        !           638:        esize += (n + (BSIZE/sizeof(short))-1) / (BSIZE/sizeof(short));
        !           639: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.