Return to x_create.c CVS log

Up to [XINU] / xinu / sys / shell

Annotation of xinu/sys/shell/x_create.c, revision 1.1.1.1

1.1       root        1: /* x_create.c - x_creat, closret */
                      2: 
                      3: #include <conf.h>
                      4: #include <kernel.h>
                      5: #include <mem.h>
                      6: #include <shell.h>
                      7: #include "/usr/include/a.out.h"
                      8: 
                      9: LOCAL  char    symfile[] = "a.out";    /* name of object file to search*/
                     10: 
                     11: #define        SYMBLK  42*sizeof(struct nlist)
                     12: 
                     13: /*------------------------------------------------------------------------
                     14:  *  x_creat  -  (command create) create a process given a starting address
                     15:  *------------------------------------------------------------------------
                     16:  */
                     17: COMMAND        x_creat(stdin, stdout, stderr, nargs, args)
                     18: int    stdin, stdout, stderr, nargs;
                     19: char   *args[];
                     20: {
                     21:        int     ssize, prio;
                     22:        struct  exec   *aoutptr;
                     23:        int     dev,   symdev,   len,    pid;
                     24:        char    *loc,  *symbuf,  *last,  *buf;
                     25:        Bool    found;
                     26:        struct  nlist  *symptr;
                     27:        unsigned stroff, symoff;
                     28:        
                     29:        if (nargs < 4 || nargs > 5) {
                     30:            fprintf(stderr,
                     31:                "usage: create procedure stack-size prio [name]\n");
                     32:            return(SYSERR);
                     33:        }
                     34:        ssize = atoi(args[2]);
                     35:        prio  = atoi(args[3]);
                     36:        symbuf = (char *)(symdev = SYSERR);
                     37:        if ( (dev=open(NAMESPACE, symfile, "ro")) == SYSERR ||
                     38:             (symdev=open(NAMESPACE, symfile, "ro")) == SYSERR ) {
                     39:                fprintf(stderr, "Cannot open %s\n", symfile);
                     40:                close(dev);
                     41:                close(symdev);
                     42:                return(SYSERR);
                     43:        }
                     44:        if ( (buf=(char *)getmem(SHCMDSTK)) == (char *)SYSERR ||
                     45:             (symbuf=(char *)getmem(SHBUFLEN)) == (char *)SYSERR) {
                     46:                fprintf(stderr, "no memory\n");
                     47:                closret(dev, symdev, buf, symbuf);
                     48:                return(SYSERR);
                     49:        }
                     50:        strcpy(args[0], "_");
                     51:        strcat(args[0], args[1]);
                     52:        printf("Looking up %s\n", args[0]);
                     53:        read(dev, buf, sizeof(struct exec));
                     54:        aoutptr = (struct exec *) buf;
                     55:        symoff = N_SYMOFF(*aoutptr);
                     56:        stroff = N_STROFF(*aoutptr);
                     57:        if (N_BADMAG(*aoutptr) || stroff < N_TXTOFF(*aoutptr)) {
                     58:                fprintf(stderr, "bad a.out format\n");
                     59:                closret(dev, symdev, buf, symbuf);
                     60:                return(SYSERR);
                     61:        }
                     62:        seek(dev, symoff);
                     63:        for (found=FALSE ; !found && symoff < stroff ; symoff += SYMBLK) {
                     64:                len = read(dev, buf,
                     65:                        (symoff+SYMBLK <= stroff) ? SYMBLK : stroff-symoff);
                     66:                if (len == SYSERR) {
                     67:                        fprintf(stderr, "error reading %s\n", symfile);
                     68:                        break;
                     69:                }
                     70:                last = &buf[len]; 
                     71:                for (symptr=(struct nlist *)buf;(char *)symptr<last;symptr++){
                     72:                        if ((symptr->n_type == (N_TEXT|N_EXT)) &&
                     73:                             symptr->n_un.n_strx) {
                     74:                                seek(symdev, stroff + symptr->n_un.n_strx);
                     75:                                if (read(symdev, symbuf, SHBUFLEN) <= 0) {
                     76:                                        fprintf(stderr,"can't read strtab\n");
                     77:                                        closret(dev, symdev, buf, symbuf);
                     78:                                        return(SYSERR);
                     79:                                }
                     80:                                if (strcmp(symbuf,args[0]) == 0) {
                     81:                                        loc = (char *)symptr->n_value;
                     82:                                        found = TRUE;
                     83:                                        break;
                     84:                                }
                     85:                        }
                     86:                }
                     87:        }
                     88:        closret(dev, symdev, buf, symbuf);
                     89:        if (found) {
                     90:                pid=create(loc, ssize, prio, nargs==5?args[4]:&args[0][1], 0);
                     91:                fprintf(stderr, "[%d]\n", pid );
                     92:                return(resume(pid));
                     93:        } else {
                     94:                fprintf(stderr, "%s not found\n", args[0]);
                     95:                return (SYSERR);
                     96:        }
                     97: }
                     98: 
                     99: /*------------------------------------------------------------------------
                    100:  *  closret  -  close devices, free memory before returning
                    101:  *------------------------------------------------------------------------
                    102: */
                    103: LOCAL  closret(dev, symdev, buf, symbuf)
                    104: int    dev, symdev;
                    105: char   *buf, *symbuf;
                    106: {
                    107:        close(dev);
                    108:        close(symdev);
                    109:        freemem(buf, SHCMDSTK);
                    110:        freemem(symbuf, SHBUFLEN);
                    111: }

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