Return to unpatch.c CVS log

Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io / tools

Annotation of coherent/d/286_KERNEL/USRSRC/io/tools/unpatch.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * unpatch.c - display value of kernel variable(s)
                      3:  */
                      4: #include <stdio.h>
                      5: #include <l.out.h>
                      6: #include <string.h>
                      7: 
                      8: #define NUMVARS 20     /* number of symbols we can look up */
                      9: 
                     10: /*
                     11:  * Table for namelist.
                     12:  */
                     13: struct nlist nl[NUMVARS+1];
                     14: char suffix[NUMVARS+1][3];     /* keep ":[cils]" for each variable */
                     15: 
                     16: /*
                     17:  * Symbols.
                     18:  */
                     19: char   *kfile;         /* Kernel data memory file */
                     20: char   *nfile;         /* Namelist file */
                     21: int    kfd;            /* Kernel memory file descriptor */
                     22: int    pflag;          /* true if patch-compatible output desired */
                     23: int    var_num;        /* Number of symbols to look up */
                     24: 
                     25: main(argc, argv)
                     26: char *argv[];
                     27: {
                     28:        int argn;
                     29: 
                     30:        initialise();
                     31:        /*
                     32:         * Scan command line.
                     33:         *
                     34:         * "-c nfile" means use alternate map file.
                     35:         * "-p" means output format suitable for patch command
                     36:         *
                     37:         * variable names may have ":[cils]" appended to specify
                     38:         * size of value to be fetched, e.g.
                     39:         *   unpatch foo:l
                     40:         * says foo is a long
                     41:         */
                     42:        for (argn = 1; argn < argc; argn++) {
                     43:                if (strcmp(argv[argn], "-c") == 0) {
                     44:                        if (++argn < argc) {
                     45:                                nfile = argv[argn];
                     46:                        } else {
                     47: fprintf(stderr, "bad kfile spec\n");
                     48:                                usage();
                     49:                        }
                     50:                } else if (strcmp(argv[argn], "-p") == 0) {
                     51:                        pflag = 1;
                     52:                } else {
                     53:                        char p[40], *p2;
                     54: 
                     55:                        strcpy(p, argv[argn]);
                     56:                        if (p2 = strchr(p, ':')){
                     57:                                if (strlen(p2) == 2) {
                     58:                                        strcpy(suffix[var_num], p2);
                     59:                                        *p2 = '\0';
                     60:                                        strncpy(nl[var_num].n_name, p, NCPLN);
                     61:                                } else {
                     62: fprintf(stderr, "bad suffix size\n");
                     63:                                        usage();
                     64:                                }
                     65:                        } else
                     66:                                strncpy(nl[var_num].n_name, p, NCPLN);
                     67:                        var_num++;
                     68:                }
                     69:        } 
                     70:        if (var_num == 0) {
                     71: fprintf(stderr, "no variable to unpatch\n");
                     72:                usage();
                     73:        }
                     74:        execute();
                     75:        exit(0);
                     76: }
                     77: 
                     78: /*
                     79:  * Initialise.
                     80:  */
                     81: initialise()
                     82: {
                     83:        int i;
                     84: 
                     85:        for (i = 0; i < NUMVARS+1; i++) {
                     86:                nl[i].n_name[0] = '\0';
                     87:                nl[i].n_type = 0;
                     88:                suffix[i][0] = '\0';
                     89:                suffix[i][1] = '\0';
                     90:        }
                     91:        nfile = "/coherent";
                     92:        kfile = "/dev/kmem";
                     93: }
                     94: 
                     95: /*
                     96:  * Print out usage.
                     97:  */
                     98: usage()
                     99: {
                    100:        panic("Usage: unpatch [-c map_file] [-p] var_name[:cils]...");
                    101: }
                    102: 
                    103: /*
                    104:  * Display value
                    105:  */
                    106: execute()
                    107: {
                    108:        int v, size;
                    109:        long longval, result;
                    110:        unsigned int intval;
                    111:        unsigned short shortval;
                    112:        unsigned char charval;
                    113: 
                    114:        if ((kfd = open(kfile, 0)) < 0)
                    115:                panic("Cannot open %s", kfile);
                    116:        nlist(nfile, nl);
                    117:        for (v = 0; v < var_num; v++) {
                    118:                if (nl[v].n_type == 0)
                    119: fprintf(stderr, "can't find variable %s in %s\n", nl[v].n_name, nfile);
                    120:                else {
                    121:                        switch (suffix[v][1]) {
                    122:                        case 'c':
                    123:                                size = sizeof(char);
                    124:                                kread((long)nl[v].n_value, &charval, size);
                    125:                                result = (long) charval;
                    126:                                break;
                    127:                        case 'i':
                    128:                        default:
                    129:                                size = sizeof(int);
                    130:                                kread((long)nl[v].n_value, &intval, size);
                    131:                                result = (long) intval;
                    132:                                break;
                    133:                        case 'l':
                    134:                                size = sizeof(long);
                    135:                                kread((long)nl[v].n_value, &longval, size);
                    136:                                result = longval;
                    137:                                break;
                    138:                        case 's':
                    139:                                size = sizeof(short);
                    140:                                kread((long)nl[v].n_value, &shortval, size);
                    141:                                result = (long) shortval;
                    142:                                break;
                    143:                        }
                    144:                        if (pflag)
                    145:                                printf("%s=0x%lx%s ", nl[v].n_name,
                    146:                                  result, suffix[v]);
                    147:                        else
                    148:                                printf("%s=0x%lx\n", nl[v].n_name, result);
                    149:                }
                    150:        }
                    151: }
                    152: 
                    153: /*
                    154:  * Read `n' bytes into the buffer `bp' from kernel memory
                    155:  * starting at seek position `s'.
                    156:  */
                    157: kread(s, bp, n)
                    158: long s;
                    159: {
                    160:        lseek(kfd, (long)s, 0);
                    161:        if (read(kfd, bp, n) != n)
                    162:                panic("Kernel memory read error");
                    163: }
                    164: 
                    165: /*
                    166:  * Print out an error message and exit.
                    167:  */
                    168: panic(a1)
                    169: char *a1;
                    170: {
                    171:        fflush(stdout);
                    172:        fprintf(stderr, "%r", &a1);
                    173:        fprintf(stderr, "\n");
                    174:        exit(1);
                    175: }

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