Return to umount.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/umount.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <fstab.h>
                      3: 
                      4: struct mtab *mtab;
                      5: 
                      6: int nmtab;
                      7: int mdirty;
                      8: int errs;
                      9: 
                     10: char mfile[] = MTAB;
                     11: 
                     12: main(argc, argv)
                     13: int argc;
                     14: char **argv;
                     15: {
                     16: 
                     17:        if (argc < 2) {
                     18:                fprintf(stderr, "usage: umount [-a] [file ...]\n");
                     19:                exit(1);
                     20:        }
                     21:        readmtab();
                     22:        sync();
                     23:        if (argc == 2 && strcmp(argv[1], "-a") == 0)
                     24:                umountall();
                     25:        else {
                     26:                while (--argc > 0)
                     27:                        umountone(*++argv);
                     28:        }
                     29:        writmtab();
                     30:        sync();
                     31:        exit(errs);
                     32: }
                     33: 
                     34: /*
                     35:  * unmount everything
                     36:  * in reverse order in case of nesting
                     37:  */
                     38: umountall()
                     39: {
                     40:        register int i;
                     41: 
                     42:        for (i = nmtab - 1; i >= 0; i--) {
                     43:                if (mtab[i].file[0] == 0)
                     44:                        continue;
                     45:                if (funmount(mtab[i].file) < 0) {
                     46:                        perror(mtab[i].file);
                     47:                        errs++;
                     48:                        continue;
                     49:                }
                     50:                mtab[i].file[0] = 0;
                     51:                mdirty++;
                     52:        }
                     53: }
                     54: 
                     55: umountone(f)
                     56: char *f;
                     57: {
                     58:        register int i;
                     59: 
                     60:        if (funmount(f) < 0) {
                     61:                perror(f);
                     62:                errs++;
                     63:                return;
                     64:        }
                     65:        for (i = nmtab - 1; i >= 0; i--)
                     66:                if (strcmp(mtab[i].file, f) == 0) {
                     67:                        mtab[i].file[0] = 0;
                     68:                        mdirty++;
                     69:                        break;
                     70:                }
                     71: }
                     72: 
                     73: #define        CHUNK   (20*sizeof(struct mtab))
                     74: 
                     75: readmtab()
                     76: {
                     77:        char *base, *buf;
                     78:        int n, nr, tot;
                     79:        int fd;
                     80:        char *malloc(), *realloc();
                     81: 
                     82:        if ((base = malloc(CHUNK)) == NULL) {
                     83:                fprintf(stderr, "umount: no mem\n");
                     84:                exit(1);
                     85:        }
                     86:        if ((fd = open(mfile, 0)) < 0) {
                     87:                perror("read /etc/mtab");
                     88:                exit(1);
                     89:        }
                     90:        buf = base;
                     91:        nr = CHUNK;
                     92:        tot = 0;
                     93:        while ((n = read(fd, buf, nr)) > 0) {
                     94:                tot += n;
                     95:                buf += n;
                     96:                if ((nr -= n) <= 0) {
                     97:                        if ((base = realloc(base, CHUNK)) == NULL) {
                     98:                                fprintf(stderr, "umount: no mem\n");
                     99:                                exit(1);
                    100:                        }
                    101:                        buf = base + tot;
                    102:                        nr = CHUNK;
                    103:                }
                    104:        }
                    105:        mtab = (struct mtab *)base;
                    106:        nmtab = tot / sizeof(struct mtab);
                    107:        close(fd);
                    108: }
                    109: 
                    110: writmtab()
                    111: {
                    112:        int fd;
                    113:        register int i;
                    114: 
                    115:        if (mdirty == 0)
                    116:                return;
                    117:        for (i = nmtab - 1; i >= 0; i--)
                    118:                if (mtab[i].file[0])
                    119:                        break;
                    120:        if ((fd = creat(mfile, 0666)) < 0) {
                    121:                perror("write /etc/mtab");
                    122:                errs++;
                    123:                return;
                    124:        }
                    125:        i = (char *)&mtab[i+1] - (char *)mtab;
                    126:        if (write(fd, (char *)mtab, i) != i) {
                    127:                perror("write /etc/mtab");
                    128:                errs++;
                    129:                return;
                    130:        }
                    131:        close(fd);
                    132: }

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