Return to wwrite.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm

Annotation of researchv10no/cmd/worm/wwrite.c, revision 1.1.1.1

1.1       root        1: #include       <libc.h>
                      2: #include       <fio.h>
                      3: #include       <sys/types.h>
                      4: #include       <sys/stat.h>
                      5: #include       <signal.h>
                      6: #include       "worm.h"
                      7: 
                      8: main(argc, argv)
                      9:        char **argv;
                     10: {
                     11:        Superblock s;
                     12:        char *e;
                     13:        char buf[4096];
                     14:        int n;
                     15:        int c;
                     16:        char *dev = "/dev/worm0";
                     17:        extern char *optarg;
                     18:        extern int optind;
                     19: 
                     20:        argout = argv[0];
                     21:        while((c = getopt(argc, argv, "f:")) != -1)
                     22:                switch(c)
                     23:                {
                     24:                case 'f':       dev = optarg; break;
                     25:                case '?':       usage();
                     26:                }
                     27: 
                     28:        if(optind >= argc)
                     29:                usage();
                     30:        dev = mapdev(dev);
                     31:        if((s.fd = open(dev, 2)) < 0){
                     32:                perror(*argv);
                     33:                exit(1);
                     34:        }
                     35:        if(e = openinode(&s, SPIN_DOWN)){
                     36:                fprint(2, "%s: %s\n", *argv, e);
                     37:                exit(1);
                     38:        }
                     39:        if(strcmp(s.vol_id, argv[optind])){
                     40:                fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id);
                     41:                exit(1);
                     42:        }
                     43:        if(s.nfree == 0){
                     44:                fprint(2, "%s: can't write any more!\n", dev);
                     45:                exit(1);
                     46:        }
                     47:        if(s.version != VLINK){
                     48:                fprint(2, "%s: can't write on a b-tree disk\n", s.vol_id);
                     49:                exit(1);
                     50:        }
                     51:        for(n = 1; n <= NSIG; n++)
                     52:                signal(n, SIG_IGN);
                     53:        ininit();
                     54:        if(++optind < argc)
                     55:                while(optind < argc)
                     56:                        proc(&s, argv[optind++]);
                     57:        else
                     58:                while(e = Frdline(0))
                     59:                        proc(&s, e);
                     60:        if(bad)
                     61:                exit(1);
                     62:        nfiles = nbytes = 0;
                     63:        inwrite(&s, (void *)0);
                     64:        if(bad)
                     65:                exit(1);
                     66:        fprint(1, "%d files, %.6fMb\n", nfiles, nbytes/1e6);
                     67:        exit(0);
                     68: }
                     69: 
                     70: usage()
                     71: {
                     72:        fprint(2, "Usage: worm write [-fdevice] vol_id [files]\n");
                     73:        exit(1);
                     74: }
                     75: 
                     76: proc(s, file)
                     77:        Superblock *s;
                     78:        char *file;
                     79: {
                     80:        struct stat sbuf;
                     81:        unsigned short mode;
                     82:        Inode i;
                     83: 
                     84:        memset((char *)&i, 0, sizeof(i));
                     85:        if(stat(file, &sbuf) < 0){
                     86:                perror(file);
                     87:                return;
                     88:        }
                     89:        mode = sbuf.st_mode&S_IFMT;
                     90:        if((mode == S_IFREG) || (mode == S_IFDIR)){
                     91:                i.magic = DMAGIC;
                     92:                i.block = 0;
                     93:                i.nbytes = sbuf.st_size;
                     94:                nbytes += i.nbytes;
                     95:                i.ctime = sbuf.st_ctime;
                     96:                i.name.n = file;
                     97:                i.mode = sbuf.st_mode;
                     98:                i.uid = sbuf.st_uid;
                     99:                i.gid = sbuf.st_gid;
                    100:                if(inadd(s, &i))
                    101:                        bad = 1;
                    102:        } else
                    103:                fprint(2, "%s is not a file\n", file);
                    104: }
                    105: 
                    106: writeout(s, i, blk)
                    107:        Superblock *s;
                    108:        Inode *i;
                    109:        long *blk;
                    110: {
                    111:        char b[63*1024L];
                    112:        int fd;
                    113:        long n, len, blen;
                    114:        char *name;
                    115: 
                    116:        n = (i->nbytes+s->blocksize-1)/s->blocksize;
                    117:        *blk += n;
                    118:        blkdone += n;
                    119:        blen = sizeof b/s->blocksize;
                    120:        len = blen*s->blocksize;
                    121:        nbytes += i->nbytes;
                    122:        nfiles++;
                    123:        name = i->name.n;
                    124:        if((fd = open(name, 0)) < 0)
                    125:                goto out;
                    126:        for(n = i->nbytes; n > len; n -= len){
                    127:                if(read(fd, (char *)b, (int)len) != len){
                    128:        out:
                    129:                        perror(name);
                    130:                        bad = 1;
                    131:                        return;
                    132:                }
                    133:                if(Write(s, b, blen)){
                    134: fprint(2, "nb=%d, n=%d len=%d blen=%d\n", i->nbytes, n, len, blen);
                    135:                        perror("data write");
                    136:                        exit(1);
                    137:                }
                    138:        }
                    139:        if(n){
                    140:                memset(b, 0, sizeof b);
                    141:                if(read(fd, (char *)b, (int)n) != n)
                    142:                        goto out;
                    143:                n += s->blocksize-1;
                    144:                n /= s->blocksize;
                    145:                if(Write(s, b, n)){
                    146:                        perror("data write");
                    147:                        exit(1);
                    148:                }
                    149:        }
                    150:        close(fd);
                    151: }

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