Return to parms.c CVS log

Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv / tools

Annotation of coherent/d/kernel/USRSRC/i8086/drv/tools/parms.c, revision 1.1.1.1

1.1       root        1: /* parms.c - display hard drive parameters per "atparm" in kernel */
                      2: 
                      3: #include <stdio.h>
                      4: #include <l.out.h>
                      5: 
                      6: /*
                      7:  * For easy referencing.
                      8:  */
                      9: #define        at_table                nl[0].n_value
                     10: #define        plowner         nl[1].n_value
                     11: #define NDRIVE         2
                     12: 
                     13: struct dparm_s {
                     14:        unsigned short  d_ncyl;         /* number of cylinders */
                     15:        unsigned char   d_nhead;        /* number of heads */
                     16:        unsigned short  d_rwcc;         /* reduced write current cyl */
                     17:        unsigned short  d_wpcc;         /* write pre-compensation cyl */
                     18:        unsigned char   d_eccl;         /* max ecc data length */
                     19:        unsigned char   d_ctrl;         /* control byte */
                     20:        unsigned char   d_fill2[3];
                     21:        unsigned short  d_landc;        /* landing zone cylinder */
                     22:        unsigned char   d_nspt;         /* number of sectors per track */
                     23:        unsigned char   d_fill3;
                     24: 
                     25: }      atparm[ NDRIVE ] = {
                     26:        0                               /* Initialized to allow patching */
                     27: };
                     28: 
                     29: /*
                     30:  * Table for namelist.
                     31:  */
                     32: struct nlist nl[] ={
                     33:        "atparm_",              0,      0,
                     34:        ""
                     35: };
                     36: 
                     37: /*
                     38:  * Symbols.
                     39:  */
                     40: char    *kfile;                        /* Kernel data memory file */
                     41: char    *nfile;                        /* Namelist file */
                     42: int     kfd;                           /* Kernel memory file descriptor */
                     43: 
                     44: main(argc, argv)
                     45: char *argv[];
                     46: {
                     47:        register int i;
                     48:        register char *cp;
                     49: 
                     50:        initialise();
                     51:        for (i=1; i<argc; i++) {
                     52:                for (cp=&argv[i][0]; *cp; cp++) {
                     53:                        switch (*cp) {
                     54:                        case '-':
                     55:                                continue;
                     56:                        case 'c':
                     57:                                if (++i >= argc)
                     58:                                        usage();
                     59:                                nfile = argv[i];
                     60:                                continue;
                     61:                        default:
                     62:                                usage();
                     63:                        }
                     64:                }
                     65:        }
                     66:        execute();
                     67:        exit(0);
                     68: }
                     69: 
                     70: /*
                     71:  * Initialise.
                     72:  */
                     73: initialise()
                     74: {
                     75:        nfile = "/coherent";
                     76:        kfile = "/dev/kmem";
                     77: }
                     78: 
                     79: /*
                     80:  * Print out usage.
                     81:  */
                     82: usage()
                     83: {
                     84:        panic("Usage: parms [-][c kernel_file]");
                     85: }
                     86: 
                     87: /*
                     88:  * Display parameters
                     89:  */
                     90: execute()
                     91: {
                     92:        int dr;
                     93: 
                     94:        nlist(nfile, nl);
                     95:        if (nl[0].n_type == 0)
                     96:                panic("Bad namelist file %s", nfile);
                     97:        if ((kfd = open(kfile, 0)) < 0)
                     98:                panic("Cannot open %s", kfile);
                     99: 
                    100:        kread((long)at_table, atparm, sizeof(atparm));
                    101:        printf("Hard drive parameters as stored in \"at\" driver:\n");
                    102:        for (dr = 0;  dr < NDRIVE;  dr++) {
                    103:                printf("drive %d  cyl=%4d  hd=%2d  spt=%2d  ctrl=%02x\n",
                    104:                        dr, atparm[dr].d_ncyl, atparm[dr].d_nhead,
                    105:                        atparm[dr].d_nspt, atparm[dr].d_ctrl);
                    106:        }
                    107: }
                    108: 
                    109: /*
                    110:  * Read `n' bytes into the buffer `bp' from kernel memory
                    111:  * starting at seek position `s'.
                    112:  */
                    113: kread(s, bp, n)
                    114: long s;
                    115: {
                    116:        lseek(kfd, (long)s, 0);
                    117:        if (read(kfd, bp, n) != n)
                    118:                panic("Kernel memory read error");
                    119: }
                    120: 
                    121: /*
                    122:  * Print out an error message and exit.
                    123:  */
                    124: panic(a1)
                    125: char *a1;
                    126: {
                    127:        fflush(stdout);
                    128:        fprintf(stderr, "%r", &a1);
                    129:        fprintf(stderr, "\n");
                    130:        exit(1);
                    131: }

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