Annotation of Net2/tests/benchmarks/fstests, revision 1.1

1.1     ! root        1: #! /bin/sh
        !             2: # run this file as a shell script
        !             3: mkdir fstests
        !             4: chdir fstests
        !             5: echo x - existfs
        !             6: sed 's/^X//' >existfs <<'!Funky!Stuff!'
        !             7: #!/bin/csh -f
        !             8: set time=2
        !             9: if ($#argv < 1) then
        !            10:        echo "Usage: existfs name"
        !            11:        exit 1
        !            12: endif
        !            13: echo "tests on $1"
        !            14: /etc/dumpfs $1 | head -14 | tail -11
        !            15: mkdir $1/fststs
        !            16: if (! -e bin) then
        !            17:        mkdir bin
        !            18:        cc -o bin/write_4096 write_4096.c
        !            19:        cc -o bin/write_8192 write_8192.c
        !            20:        cc -o bin/rewrite_8192 rewrite_8192.c
        !            21:        cc -o bin/read_8192 read_8192.c
        !            22: endif
        !            23: cp bin/write_4096 bin/write_8192 bin/rewrite_8192 bin/read_8192 $1/fststs
        !            24: cd $1/fststs
        !            25: echo "write_4096"
        !            26: rm -f tst2
        !            27: X./write_4096 tst2
        !            28: rm -f tst2
        !            29: X./write_4096 tst2
        !            30: rm -f tst2
        !            31: X./write_4096 tst2
        !            32: echo "write_8192"
        !            33: rm -f tst2
        !            34: X./write_8192 tst2
        !            35: rm -f tst2
        !            36: X./write_8192 tst2
        !            37: rm -f tst2
        !            38: X./write_8192 tst2
        !            39: echo "rewrite_8192"
        !            40: X./rewrite_8192 tst2
        !            41: X./rewrite_8192 tst2
        !            42: X./rewrite_8192 tst2
        !            43: echo "read_8192"
        !            44: X./read_8192 tst2
        !            45: X./read_8192 tst2
        !            46: X./read_8192 tst2
        !            47: echo "done"
        !            48: !Funky!Stuff!
        !            49: echo x - newtsts
        !            50: sed 's/^X//' >newtsts <<'!Funky!Stuff!'
        !            51: #!/bin/csh -f
        !            52: set echo
        !            53: set time=2
        !            54: if ($#argv < 2) then
        !            55:        echo "Usage: newtsts special disk-type"
        !            56:        exit 1
        !            57: endif
        !            58: echo "8K/1K file system on $1 type $2"
        !            59: /etc/newfs $1 $2
        !            60: /etc/mount $1 /mnt
        !            61: mkdir /mnt/fststs
        !            62: if (! -e bin) then
        !            63:        mkdir bin
        !            64:        cc -o bin/write_4096 write_4096.c
        !            65:        cc -o bin/write_8192 write_8192.c
        !            66:        cc -o bin/rewrite_8192 rewrite_8192.c
        !            67:        cc -o bin/read_8192 read_8192.c
        !            68: endif
        !            69: echo "write_4096"
        !            70: rm -f /mnt/fststs/tst2
        !            71: bin/write_4096 /mnt/fststs/tst2
        !            72: rm -f /mnt/fststs/tst2
        !            73: bin/write_4096 /mnt/fststs/tst2
        !            74: rm -f /mnt/fststs/tst2
        !            75: bin/write_4096 /mnt/fststs/tst2
        !            76: echo "write_8192"
        !            77: rm -f /mnt/fststs/tst2
        !            78: bin/write_8192 /mnt/fststs/tst2
        !            79: rm -f /mnt/fststs/tst2
        !            80: bin/write_8192 /mnt/fststs/tst2
        !            81: rm -f /mnt/fststs/tst2
        !            82: bin/write_8192 /mnt/fststs/tst2
        !            83: echo "rewrite_8192"
        !            84: bin/rewrite_8192 /mnt/fststs/tst2
        !            85: bin/rewrite_8192 /mnt/fststs/tst2
        !            86: bin/rewrite_8192 /mnt/fststs/tst2
        !            87: echo "read_8192"
        !            88: bin/read_8192 /mnt/fststs/tst2
        !            89: bin/read_8192 /mnt/fststs/tst2
        !            90: bin/read_8192 /mnt/fststs/tst2
        !            91: umount $1
        !            92: sync
        !            93: echo
        !            94: echo "4K/1K file system on $1 type $2"
        !            95: newfs $1 $2
        !            96: mount $1 /mnt
        !            97: mkdir /mnt/fststs
        !            98: rm -f /mnt/fststs/tst2
        !            99: bin/write_4096 /mnt/fststs/tst2
        !           100: rm -f /mnt/fststs/tst2
        !           101: bin/write_4096 /mnt/fststs/tst2
        !           102: rm -f /mnt/fststs/tst2
        !           103: bin/write_4096 /mnt/fststs/tst2
        !           104: echo "write_8192"
        !           105: rm -f /mnt/fststs/tst2
        !           106: bin/write_8192 /mnt/fststs/tst2
        !           107: rm -f /mnt/fststs/tst2
        !           108: bin/write_8192 /mnt/fststs/tst2
        !           109: rm -f /mnt/fststs/tst2
        !           110: bin/write_8192 /mnt/fststs/tst2
        !           111: echo "rewrite_8192"
        !           112: bin/rewrite_8192 /mnt/fststs/tst2
        !           113: bin/rewrite_8192 /mnt/fststs/tst2
        !           114: bin/rewrite_8192 /mnt/fststs/tst2
        !           115: echo "read_8192"
        !           116: bin/read_8192 /mnt/fststs/tst2
        !           117: bin/read_8192 /mnt/fststs/tst2
        !           118: bin/read_8192 /mnt/fststs/tst2
        !           119: echo "done"
        !           120: !Funky!Stuff!
        !           121: echo x - read_8192.c
        !           122: sed 's/^X//' >read_8192.c <<'!Funky!Stuff!'
        !           123: #define        BUFSIZ 8192
        !           124: 
        !           125: main(argc, argv)
        !           126:        int argc;
        !           127:        char *argv[];
        !           128: {
        !           129:        char buf[BUFSIZ];
        !           130:        int i, j;
        !           131: 
        !           132:        if (argc < 2) {
        !           133:                printf("Usage: read_8192 file\n");
        !           134:                exit(1);
        !           135:        }
        !           136:        j = open(argv[1], 0);
        !           137:        if (j < 0) {
        !           138:                perror(argv[1]);
        !           139:                exit(2);
        !           140:        }
        !           141:        for (i = 0; i < 1024; i++)
        !           142:                read(j, buf, BUFSIZ);
        !           143: }
        !           144: !Funky!Stuff!
        !           145: echo x - readchk.c
        !           146: sed 's/^X//' >readchk.c <<'!Funky!Stuff!'
        !           147: #define BUFSIZ 4096
        !           148: 
        !           149: main(argc, argv)
        !           150:        int argc;
        !           151:        char *argv[];
        !           152: {
        !           153:        int buf[BUFSIZ / sizeof(int)];
        !           154:        int i, j, k;
        !           155: 
        !           156:        if (argc != 2) {
        !           157:                printf("Usage: readchk file\n");
        !           158:                exit(1);
        !           159:        }
        !           160:        j = creat(argv[1], 0666);
        !           161:        if (j < 0) {
        !           162:                perror(argv[1]);
        !           163:                exit(2);
        !           164:        }
        !           165:        for (i = 0; i < 2048; i++) {
        !           166:                for (k = 0; k < BUFSIZ / sizeof(int); k++)
        !           167:                        buf[k] = i + k;
        !           168:                if (write(j, buf, BUFSIZ) != BUFSIZ) {
        !           169:                        perror("write");
        !           170:                        exit(3);
        !           171:                }
        !           172:        }
        !           173:        close(j);
        !           174:        j = open(argv[1], 0);
        !           175:        if (j < 0) {
        !           176:                perror(argv[1]);
        !           177:                exit(4);
        !           178:        }
        !           179:        for (i = 0; i < 2048; i++) {
        !           180:                if (read(j, buf, BUFSIZ) != BUFSIZ) {
        !           181:                        perror("read");
        !           182:                        exit(5);
        !           183:                }
        !           184:                for (k = 0; k < BUFSIZ / sizeof(int); k++)
        !           185:                        if (buf[k] != i + k)
        !           186:                                printf("bad data at %d\n",
        !           187:                                        tell(j) - BUFSIZ + 4 * k);
        !           188:        }
        !           189: }
        !           190: !Funky!Stuff!
        !           191: echo x - rewrite_8192.c
        !           192: sed 's/^X//' >rewrite_8192.c <<'!Funky!Stuff!'
        !           193: #define        BUFSIZ 8192
        !           194: 
        !           195: main(argc, argv)
        !           196:        int argc;
        !           197:        char *argv[];
        !           198: {
        !           199:        char buf[BUFSIZ];
        !           200:        int i, j;
        !           201: 
        !           202:        if (argc < 2) {
        !           203:                printf("Usage: rewrite_8192 file\n");
        !           204:                exit(1);
        !           205:        }
        !           206:        j = open(argv[1], 2);
        !           207:        if (j < 0) {
        !           208:                perror(argv[1]);
        !           209:                exit(2);
        !           210:        }
        !           211:        for (i = 0; i < 1024; i++)
        !           212:                write(j, buf, BUFSIZ);
        !           213: }
        !           214: !Funky!Stuff!
        !           215: echo x - write_4096.c
        !           216: sed 's/^X//' >write_4096.c <<'!Funky!Stuff!'
        !           217: #define        BUFSIZ 4096
        !           218: 
        !           219: main(argc, argv)
        !           220:        int argc;
        !           221:        char *argv[];
        !           222: {
        !           223:        char buf[BUFSIZ];
        !           224:        int i, j;
        !           225: 
        !           226:        if (argc < 2) {
        !           227:                printf("Usage: write_4096 file\n");
        !           228:                exit(1);
        !           229:        }
        !           230:        j = creat(argv[1], 0666);
        !           231:        if (j < 0) {
        !           232:                perror(argv[1]);
        !           233:                exit(2);
        !           234:        }
        !           235:        for (i = 0; i < 2048; i++)
        !           236:                write(j, buf, BUFSIZ);
        !           237: }
        !           238: !Funky!Stuff!
        !           239: echo x - write_8192.c
        !           240: sed 's/^X//' >write_8192.c <<'!Funky!Stuff!'
        !           241: #define        BUFSIZ 8192
        !           242: 
        !           243: main(argc, argv)
        !           244:        int argc;
        !           245:        char *argv[];
        !           246: {
        !           247:        char buf[BUFSIZ];
        !           248:        int i, j;
        !           249: 
        !           250:        if (argc < 2) {
        !           251:                printf("Usage: write_8192 file\n");
        !           252:                exit(1);
        !           253:        }
        !           254:        j = creat(argv[1], 0666);
        !           255:        if (j < 0) {
        !           256:                perror(argv[1]);
        !           257:                exit(2);
        !           258:        }
        !           259:        for (i = 0; i < 1024; i++)
        !           260:                write(j, buf, BUFSIZ);
        !           261: }
        !           262: !Funky!Stuff!

unix.superglobalmegacorp.com

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