home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / mint / mint095s / pipefs.c < prev    next >
C/C++ Source or Header  |  1993-08-03  |  23KB  |  1,001 lines
  1. /*
  2. Copyright 1991,1992 Eric R. Smith. All rights reserved.
  3.  */
  4.  
  5. /* simple pipefs.c */
  6.  
  7. #include "mint.h"
  8.  
  9. static int pipetime, pipedate;    /* root directory time/date stamp */
  10.  
  11. static long    pipe_root    P_((int drv, fcookie *fc));
  12. static long    pipe_lookup    P_((fcookie *dir, const char *name, fcookie *fc));
  13. static long    pipe_getxattr    P_((fcookie *file, XATTR *xattr));
  14. static long    pipe_chattr    P_((fcookie *file, int attrib));
  15. static long    pipe_chown    P_((fcookie *file, int uid, int gid));
  16. static long    pipe_chmode    P_((fcookie *file, unsigned mode));
  17. static long    pipe_rmdir    P_((fcookie *dir, const char *name));
  18. static long    pipe_remove    P_((fcookie *dir, const char *name));
  19. static long    pipe_getname    P_((fcookie *root, fcookie *dir, char *pathname));
  20. static long    pipe_rename    P_((fcookie *olddir, char *oldname,
  21.                     fcookie *newdir, const char *newname));
  22. static long    pipe_opendir    P_((DIR *dirh, int flags));
  23. static long    pipe_readdir    P_((DIR *dirh, char *nm, int nmlen, fcookie *));
  24. static long    pipe_rewinddir    P_((DIR *dirh));
  25. static long    pipe_closedir    P_((DIR *dirh));
  26. static long    pipe_pathconf    P_((fcookie *dir, int which));
  27. static long    pipe_dfree    P_((fcookie *dir, long *buf));
  28. static long    pipe_creat    P_((fcookie *dir, const char *name, unsigned mode,
  29.                     int attrib, fcookie *fc));
  30. static DEVDRV *    pipe_getdev    P_((fcookie *fc, long *devsp));
  31.  
  32. static long    pipe_open    P_((FILEPTR *f));
  33. static long    pipe_write    P_((FILEPTR *f, const char *buf, long bytes));
  34. static long    pipe_read    P_((FILEPTR *f, char *buf, long bytes));
  35. static long    pipe_lseek    P_((FILEPTR *f, long where, int whence));
  36. static long    pipe_ioctl    P_((FILEPTR *f, int mode, void *buf));
  37. static long    pipe_datime    P_((FILEPTR *f, short *time, int rwflag));
  38. static long    pipe_close    P_((FILEPTR *f, int pid));
  39. static long    pipe_select    P_((FILEPTR *f, long p, int mode));
  40. static void    pipe_unselect    P_((FILEPTR *f, long p, int mode));
  41.  
  42. DEVDRV pipe_device = {
  43.     pipe_open, pipe_write, pipe_read, pipe_lseek, pipe_ioctl, pipe_datime,
  44.     pipe_close, pipe_select, pipe_unselect
  45. };
  46.  
  47. /* ptys and pipes can share the same driver, for now */
  48. #define pty_device pipe_device
  49.  
  50. FILESYS pipe_filesys = {
  51.     (FILESYS *)0,
  52.     0,
  53.     pipe_root,
  54.     pipe_lookup, pipe_creat, pipe_getdev, pipe_getxattr,
  55.     pipe_chattr, pipe_chown, pipe_chmode,
  56.     nomkdir, pipe_rmdir, pipe_remove, pipe_getname, pipe_rename,
  57.     pipe_opendir, pipe_readdir, pipe_rewinddir, pipe_closedir,
  58.     pipe_pathconf, pipe_dfree,
  59.     nowritelabel, noreadlabel, nosymlink, noreadlink,
  60.     nohardlink, nofscntl, nodskchng
  61. };
  62.  
  63. /* size of pipes */
  64. #define PIPESIZ    4096        /* MUST be a multiple of 4 */
  65.  
  66. /* writes smaller than this are atomic */
  67. #define PIPE_BUF 1024        /* should be a multiple of 4 */
  68.  
  69. /* magic flag: indicates that nobody but the creator has opened this pipe */
  70. /* note: if this many processes open the pipe, we lose :-( */
  71. #define VIRGIN_PIPE    0x7fff
  72.  
  73. struct pipe {
  74.     int    readers;    /* number of readers of this pipe */
  75.     int    writers;    /* number of writers of this pipe */
  76.     int    head, tail;    /* pipe head, tail (head == tail for empty) */
  77.     long    rsel;        /* process that did select() for reads */
  78.     long    wsel;        /* process that did select() for writes */
  79.     char    buf[PIPESIZ];    /* pipe data */
  80. };
  81.  
  82. struct fifo {
  83.     char    name[NAME_MAX+1]; /* FIFO's name */
  84.     short    date, time;    /* date & time of last write */
  85.     short    dosflags;    /* DOS flags, e.g. FA_RDONLY, FA_HIDDEN */
  86.     ushort    mode;        /* file access mode, for XATTR */
  87.     ushort    uid, gid;    /* file owner; uid and gid */
  88.     short    flags;        /* various other flags (e.g. O_TTY) */
  89.     short    lockpid;    /* pid of locking process */
  90.     struct tty *tty;    /* tty struct for pseudo TTY's */
  91.     struct pipe *inp;    /* pipe for reads */
  92.     struct pipe *outp;    /* pipe for writes (0 if unidirectional) */
  93.     struct fifo *next;    /* link to next FIFO in list */
  94.     FILEPTR *open;        /* open file pointers for this fifo */
  95. } *rootlist;
  96.  
  97.  
  98. static long
  99. pipe_root(drv, fc)
  100.     int drv;
  101.     fcookie *fc;
  102. {
  103.     if (drv == PIPEDRV) {
  104.         fc->fs = &pipe_filesys;
  105.         fc->dev = drv;
  106.         fc->index = 0L;
  107.         return 0;
  108.     }
  109.     fc->fs = 0;
  110.     return EINTRN;
  111. }
  112.  
  113. static long
  114. pipe_lookup(dir, name, fc)
  115.     fcookie *dir;
  116.     const char *name;
  117.     fcookie *fc;
  118. {
  119.     struct fifo *b;
  120.  
  121.     TRACE("pipe_lookup(%s)", name);
  122.  
  123.     if (dir->index != 0) {
  124.         DEBUG("pipe_lookup(%s): bad directory", name);
  125.         return EPTHNF;
  126.     }
  127. /* special case: an empty name in a directory means that directory */
  128. /* so does "." */
  129.     if (!*name || (name[0] == '.' && name[1] == 0)) {
  130.         *fc = *dir;
  131.         return 0;
  132.     }
  133.  
  134. /* another special case: ".." could be a mount point */
  135.     if (!strcmp(name, "..")) {
  136.         *fc = *dir;
  137.         return EMOUNT;
  138.     }
  139.  
  140.     for (b = rootlist; b; b = b->next) {
  141.         if (!strnicmp(b->name, name, 14)) {
  142.             fc->fs = &pipe_filesys;
  143.             fc->index = (long)b;
  144.             fc->dev = dir->dev;
  145.             return 0;
  146.         }
  147.     }
  148.     DEBUG("pipe_lookup: name `%s' not found", name);
  149.     return EFILNF;
  150. }
  151.  
  152. static long
  153. pipe_getxattr(fc, xattr)
  154.     fcookie *fc;
  155.     XATTR *xattr;
  156. {
  157.     struct fifo *this;
  158.  
  159.     xattr->index = fc->index;
  160.     xattr->dev = fc->dev;
  161.     xattr->nlink = 1;
  162.     xattr->blksize = 1;
  163.  
  164.     if (fc->index == 0) {        /* root directory? */
  165.         xattr->uid = xattr->gid = 0;
  166.         xattr->mtime = xattr->atime = xattr->ctime = pipetime;
  167.         xattr->mdate = xattr->adate = xattr->cdate = pipedate;
  168.         xattr->mode = S_IFDIR | DEFAULT_DIRMODE;
  169.         xattr->attr = FA_DIR;
  170.         xattr->size = xattr->nblocks = 0;
  171.     } else {
  172.         this = (struct fifo *)fc->index;
  173.         xattr->uid = this->uid;
  174.         xattr->gid = this->gid;
  175.         xattr->mtime = xattr->atime = xattr->ctime = this->time;
  176.         xattr->mdate = xattr->adate = xattr->cdate = this->date;
  177.         xattr->mode = this->mode;
  178.         xattr->attr = this->dosflags;
  179.     /* note: fifo's that haven't been opened yet can be written to */
  180.         if (this->flags & O_HEAD) {
  181.             xattr->attr &= ~FA_RDONLY;
  182.         }
  183.  
  184.         xattr->nblocks = PIPESIZ;
  185.         if (this->dosflags & FA_SYSTEM) {    /* pseudo-tty */
  186.             xattr->size = PIPESIZ/4;
  187.         } else {
  188.             xattr->size = PIPESIZ;
  189.         }
  190.     }
  191.     return 0;
  192. }
  193.  
  194. static long
  195. pipe_chattr(fc, attrib)
  196.     fcookie *fc;
  197.     int attrib;
  198. {
  199.     return EACCDN;
  200. }
  201.  
  202. static long
  203. pipe_chown(fc, uid, gid)
  204.     fcookie *fc;
  205.     int uid, gid;
  206. {
  207.     struct fifo *this;
  208.  
  209.     if (!(this = (struct fifo *)fc->index)) return EACCDN;
  210.  
  211.     this->uid = uid;
  212.     this->gid = gid;
  213.     return 0;
  214. }
  215.  
  216. static long
  217. pipe_chmode(fc, mode)
  218.     fcookie *fc;
  219.     unsigned mode;
  220. {
  221.     struct fifo *this;
  222.  
  223.     if (!(this = (struct fifo *)fc->index)) return EACCDN;
  224.  
  225.     this->mode = (this->mode & S_IFMT) | (mode & ~S_IFMT);
  226.     return 0;
  227. }
  228.  
  229. static long
  230. pipe_rmdir(dir, name)
  231.     fcookie *dir;
  232.     const char *name;
  233. {
  234. /* the kernel already checked to see if the file exists */
  235.     return EACCDN;
  236. }
  237.  
  238. static long
  239. pipe_remove(dir, name)
  240.     fcookie *dir;
  241.     const char *name;
  242. {
  243. /* the kernel already checked to see if the file exists */
  244.     return EACCDN;
  245. }
  246.  
  247. static long
  248. pipe_getname(root, dir, pathname)
  249.     fcookie *root, *dir; char *pathname;
  250. {
  251.     if (dir->index == 0)
  252.         *pathname = 0;
  253.     else
  254.         strcpy(pathname, ((struct fifo *)dir->index)->name);
  255.     return 0;
  256. }
  257.  
  258. static long
  259. pipe_rename(olddir, oldname, newdir, newname)
  260.     fcookie *olddir;
  261.     char *oldname;
  262.     fcookie *newdir;
  263.     const char *newname;
  264. {
  265.     return EACCDN;
  266. }
  267.  
  268. static long
  269. pipe_opendir(dirh, flags)
  270.     DIR *dirh;
  271.     int flags;
  272. {
  273.     if (dirh->fc.index != 0) {
  274.         DEBUG("pipe_opendir: bad directory");
  275.         return EPTHNF;
  276.     }
  277.     dirh->index = 0;
  278.     return 0;
  279. }
  280.  
  281. static long
  282. pipe_readdir(dirh, name, namelen, fc)
  283.     DIR *dirh;
  284.     char *name;
  285.     int namelen;
  286.     fcookie *fc;
  287. {
  288.     struct fifo *this;
  289.     int i;
  290.     int giveindex = dirh->flags == 0;
  291.  
  292.     i = dirh->index++;
  293.     this = rootlist;
  294.     while (i > 0 && this) {
  295.         --i; this = this->next;
  296.     }
  297.     if (!this)
  298.         return ENMFIL;
  299.  
  300.     fc->fs = &pipe_filesys;
  301.     fc->index = (long)this;
  302.     fc->dev = dirh->fc.dev;
  303.     if (giveindex) {
  304.         namelen -= sizeof(long);
  305.         if (namelen <= 0) return ERANGE;
  306.         *((long *)name) = (long)this;
  307.         name += sizeof(long);
  308.     }
  309.     strncpy(name, this->name, namelen-1);
  310.     if (strlen(this->name) >= namelen)
  311.         return ENAMETOOLONG;
  312.     return 0;
  313. }
  314.  
  315. static long
  316. pipe_rewinddir(dirh)
  317.     DIR *dirh;
  318. {
  319.     dirh->index = 0;
  320.     return 0;
  321. }
  322.  
  323. static long
  324. pipe_closedir(dirh)
  325.     DIR *dirh;
  326. {
  327.     return 0;
  328. }
  329.  
  330. static long
  331. pipe_pathconf(dir, which)
  332.     fcookie *dir;
  333.     int which;
  334. {
  335.     switch(which) {
  336.     case -1:
  337.         return DP_MAXREQ;
  338.     case DP_IOPEN:
  339.         return UNLIMITED;    /* no internal limit on open files */
  340.     case DP_MAXLINKS:
  341.         return 1;        /* no hard links */
  342.     case DP_PATHMAX:
  343.         return PATH_MAX;
  344.     case DP_NAMEMAX:
  345.         return NAME_MAX;
  346.     case DP_ATOMIC:
  347.     /* BUG: for pty's, this should actually be PIPE_BUF/4 */
  348.         return PIPE_BUF;
  349.     case DP_TRUNC:
  350.         return DP_AUTOTRUNC;
  351.     case DP_CASE:
  352.         return DP_CASEINSENS;
  353.     default:
  354.         return EINVFN;
  355.     }
  356. }
  357.  
  358. static long
  359. pipe_dfree(dir, buf)
  360.     fcookie *dir;
  361.     long *buf;
  362. {
  363.     int i;
  364.     struct fifo *b;
  365.     long freemem;
  366.  
  367. /* the "sector" size is the number of bytes per pipe */
  368. /* so we get the total number of sectors used by counting pipes */
  369.  
  370.     i = 0;
  371.     for (b = rootlist; b; b = b->next) {
  372.         if (b->inp) i++;
  373.         if (b->outp) i++;
  374.     }
  375.  
  376.     freemem = tot_rsize(core, 0) + tot_rsize(alt, 0);
  377.  
  378. /* note: the "free clusters" isn't quite accurate, since there's overhead
  379.  * in the fifo structure; but we're not looking for 100% accuracy here
  380.  */
  381.     buf[0] = freemem/PIPESIZ;    /* number of free clusters */
  382.     buf[1] = buf[0]+i;        /* total number of clusters */
  383.     buf[2] = PIPESIZ;        /* sector size (bytes) */
  384.     buf[3] = 1;            /* cluster size (sectors) */
  385.     return 0;
  386. }
  387.  
  388. /* create a new pipe.
  389.  * this only gets called by the kernel if a lookup already failed,
  390.  * so we know that the new pipe creation is OK
  391.  */
  392.  
  393. static long
  394. pipe_creat(dir, name, mode, attrib, fc)
  395.     fcookie *dir;
  396.     const char *name;
  397.     unsigned mode;
  398.     int attrib;
  399.     fcookie *fc;
  400. {
  401.     struct pipe *inp, *outp;
  402.     struct tty *tty;
  403.     struct fifo *b;
  404. /* selfread == 1 if we want reads to wait even if no other processes
  405.    have currently opened the file, and writes to succeed in the same
  406.    event. This is useful for servers who want to wait for requests.
  407.    Pipes should always have selfread == 0.
  408. */
  409.     int selfread = (attrib & FA_HIDDEN) ? 0 : 1;
  410.  
  411.  
  412.     /* create the new pipe */
  413.     if (!(inp = (struct pipe *)kmalloc(SIZEOF(struct pipe)))) {
  414.         return ENSMEM;
  415.     }
  416.     if (attrib & FA_RDONLY) {    /* read only FIFOs are unidirectional */
  417.         outp = 0;
  418.     } else {
  419.         outp = (struct pipe *)kmalloc(SIZEOF(struct pipe));
  420.         if (!outp) {
  421.             kfree(inp);
  422.             return ENSMEM;
  423.         }
  424.     }
  425.     b = (struct fifo *)kmalloc(SIZEOF(struct fifo));
  426.     if (!b) {
  427.         kfree(inp);
  428.         if (outp) kfree(outp);
  429.         return ENSMEM;
  430.     }
  431.     if (attrib & FA_SYSTEM) {    /* pseudo-tty */
  432.         tty = (struct tty *)kmalloc(SIZEOF(struct tty));
  433.         if (!tty) {
  434.             kfree(inp);
  435.             kfree(b);
  436.             if (outp) kfree(outp);
  437.             return ENSMEM;
  438.         }
  439.         tty->use_cnt = 0;
  440.             /* do_open does the rest of tty initialization */
  441.     } else tty = 0;
  442.  
  443. /* set up the pipes appropriately */
  444.     inp->head = inp->tail = 0;
  445.     inp->readers = selfread ? 1 : VIRGIN_PIPE; inp->writers = 1;
  446.     inp->rsel = inp->wsel = 0;
  447.     if (outp) {
  448.         outp->head = outp->tail = 0;
  449.         outp->readers = 1; outp->writers = selfread ? 1 : VIRGIN_PIPE;
  450.         outp->wsel = outp->rsel = 0;
  451.     }
  452.     strncpy(b->name, name, NAME_MAX);
  453.     b->time = timestamp;
  454.     b->date = datestamp;
  455.     b->dosflags = attrib;
  456.     b->mode = ((attrib & FA_SYSTEM) ? S_IFCHR : S_IFIFO) | mode;
  457.     b->uid = curproc->ruid;
  458.     b->gid = curproc->rgid;
  459.  
  460. /* the O_HEAD flag indicates that the file hasn't actually been opened
  461.  * yet; the next open gets to be the pty master. pipe_open will
  462.  * clear the flag when this happens.
  463.  */
  464.     b->flags = ((attrib & FA_SYSTEM) ? O_TTY : 0) | O_HEAD;
  465.     b->inp = inp; b->outp = outp; b->tty = tty;
  466.  
  467.     b->next = rootlist;
  468.     b->open = (FILEPTR *)0;
  469.     rootlist = b;
  470.  
  471. /* we have to return a file cookie as well */
  472.     fc->fs = &pipe_filesys;
  473.     fc->index = (long)b;
  474.     fc->dev = dir->dev;
  475.  
  476. /* update time/date stamps for u:\pipe */
  477.     pipetime = timestamp;
  478.     pipedate = datestamp;
  479.  
  480.     return 0;
  481. }
  482.  
  483. static DEVDRV *
  484. pipe_getdev(fc, devsp)
  485.     fcookie *fc;
  486.     long *devsp;
  487. {
  488.     struct fifo *b = (struct fifo *)fc->index;
  489.  
  490.     return (b->flags & O_TTY) ? &pty_device : &pipe_device;
  491. }
  492.  
  493. /*
  494.  * PIPE device driver
  495.  */
  496.  
  497. static long
  498. pipe_open(f)
  499.     FILEPTR *f;
  500. {
  501.     struct fifo *p;
  502.     int rwmode = f->flags & O_RWMODE;
  503.  
  504.     p = (struct fifo *)f->fc.index;
  505.     f->flags |= p->flags;
  506. /*
  507.  * if this is the first open for this file, then the O_HEAD flag is
  508.  * set in p->flags. If not, and someone was trying to create the file,
  509.  * return an error
  510.  */
  511.     if (p->flags & O_HEAD) {
  512.         if (!(f->flags & O_CREAT)) {
  513.             DEBUG("pipe_open: file hasn't been created yet");
  514.             return EINTRN;
  515.         }
  516.         p->flags &= ~O_HEAD;
  517.     } else {
  518.         if (f->flags & O_CREAT) {
  519.             DEBUG("pipe_open: fifo already exists");
  520.             return EACCDN;
  521.         }
  522.     }
  523. /*
  524.  * check for file sharing compatibility. note that O_COMPAT gets mutated
  525.  * into O_DENYNONE, because any old programs that know about pipes will
  526.  * already handle multitasking correctly
  527.  */
  528.     if ( (f->flags & O_SHMODE) == O_COMPAT ) {
  529.         f->flags = (f->flags & ~O_SHMODE) | O_DENYNONE;
  530.     }
  531.     if (denyshare(p->open, f))
  532.         return EACCDN;
  533.     f->next = p->open;        /* add this open fileptr to the list */
  534.     p->open = f;
  535.  
  536. /*
  537.  * add readers/writers to the list
  538.  */
  539.     if (!(f->flags & O_HEAD)) {
  540.         if (rwmode == O_RDONLY || rwmode == O_RDWR) {
  541.             if (p->inp->readers == VIRGIN_PIPE)
  542.                 p->inp->readers = 1;
  543.             else
  544.                 p->inp->readers++;
  545.         }
  546.         if ((rwmode == O_WRONLY || rwmode == O_RDWR) && p->outp) {
  547.             if (p->outp->writers == VIRGIN_PIPE)
  548.                 p->outp->writers = 1;
  549.             else
  550.                 p->outp->writers++;
  551.         }
  552.     }
  553.  
  554. /* TTY devices need a tty structure in f->devinfo */
  555.     f->devinfo = (long)p->tty;
  556.  
  557.     return 0;
  558. }
  559.  
  560. static long
  561. pipe_write(f, buf, nbytes)
  562.     FILEPTR *f; const char *buf; long nbytes;
  563. {
  564.     int ptail, phead, j;
  565.     char *pbuf;
  566.     struct pipe *p;
  567.     struct fifo *this;
  568.     long bytes_written = 0;
  569.     long r;
  570.  
  571.     this = (struct fifo *)f->fc.index;
  572.     p = (f->flags & O_HEAD) ? this->inp : this->outp;
  573.     if (!p) {
  574.         DEBUG("pipe_write: write on wrong end of pipe");
  575.         return EACCDN;
  576.     }
  577.  
  578.     if (nbytes > 0 && nbytes <= PIPE_BUF) {
  579. check_atomicity:
  580.         r = p->tail - p->head;
  581.         if (r < 0) r += PIPESIZ;
  582.         r = (PIPESIZ-1) - r; /* r is the number of bytes we can write */
  583.         if (r < nbytes) {
  584.     /* check for broken pipes */
  585.             if (p->readers == 0 || p->readers == VIRGIN_PIPE) {
  586.                 check_sigs();
  587.                 DEBUG("pipe_write: broken pipe");
  588.                 raise(SIGPIPE);
  589.                 return -1;
  590.             }
  591. /* wake up any readers, and wait for them to gobble some data */
  592.             if (p->rsel) {
  593.                 wakeselect(p->rsel);
  594.                 p->rsel = 0;
  595.             }
  596.             wake(IO_Q, (long)p);
  597.             sleep(IO_Q, (long)p);
  598.             goto check_atomicity;
  599.         }
  600.     }
  601.  
  602.     while (nbytes > 0) {
  603.         ptail = p->tail; phead = p->head;
  604.         j = ptail+1;
  605.         if (j >= PIPESIZ) j = 0;
  606.         if (j != phead) {
  607.             pbuf = &p->buf[ptail];
  608.             do {
  609.                 *pbuf++ = *buf++;
  610.                 nbytes--; bytes_written++;
  611.                 if ( (ptail = j) == 0 )
  612.                     pbuf = &p->buf[0];
  613.                 j++;
  614.                 if (j >= PIPESIZ) j = 0;
  615.             } while ( (nbytes > 0) && (j != phead) );
  616.             p->tail = ptail;
  617.         } else {        /* pipe full */
  618.             if (p->readers == 0 || p->readers == VIRGIN_PIPE) {
  619.             /* maybe some other signal is waiting for us? */
  620.                 check_sigs();
  621.                 DEBUG("pipe_write: broken pipe");
  622.                 raise(SIGPIPE);
  623.                 return -1;
  624.             }
  625.             if (f->flags & O_NDELAY) {
  626.                 break;
  627.             }
  628.     /* is someone select()ing the other end of the pipe for reading? */
  629.             if (p->rsel) {
  630.                 wakeselect(p->rsel);
  631.                 p->rsel = 0;
  632.             }
  633.             wake(IO_Q, (long)p);    /* readers may continue */
  634. DEBUG("pipe_write: sleep on %lx", p);
  635.             sleep(IO_Q, (long)p);
  636.         }
  637.     }
  638.     this->time = timestamp;
  639.     this->date = datestamp;
  640.     if (bytes_written > 0) {
  641.         if (p->rsel) {
  642.             wakeselect(p->rsel);
  643.             p->rsel = 0;
  644.         }
  645.         wake(IO_Q, (long)p);    /* maybe someone wants this data */
  646.     }
  647.  
  648.     return bytes_written;
  649. }
  650.  
  651. static long
  652. pipe_read(f, buf, nbytes)
  653.     FILEPTR *f; char *buf; long nbytes;
  654. {
  655.     int phead, ptail;
  656.     struct fifo *this;
  657.     struct pipe *p;
  658.     long bytes_read = 0;
  659.     char *pbuf;
  660.  
  661.     this = (struct fifo *)f->fc.index;
  662.     p = (f->flags & O_HEAD) ? this->outp : this->inp;
  663.     if (!p) {
  664.         DEBUG("pipe_read: read on the wrong end of a pipe");
  665.         return EACCDN;
  666.     }
  667.  
  668.     while (nbytes > 0) {
  669.         phead = p->head; ptail = p->tail;
  670.         if (ptail != phead) {
  671.             pbuf = &p->buf[phead];
  672.             do {
  673.                 *buf++ = *pbuf++;
  674.                 nbytes--; bytes_read++;
  675.                 phead++;
  676.                 if (phead >= PIPESIZ) {
  677.                     phead = 0;
  678.                     pbuf = &p->buf[phead];
  679.                 }
  680.             } while ( (nbytes > 0) && (phead != ptail) );
  681.             p->head = phead;
  682.         }
  683.         else if (p->writers <= 0 || p->writers == VIRGIN_PIPE) {
  684.             TRACE("pipe_read: no more writers");
  685.             break;
  686.         }
  687.         else if (f->flags & O_NDELAY) {
  688.             break;
  689.         }
  690.         else {
  691.     /* is someone select()ing the other end of the pipe for writing? */
  692.             if (p->wsel) {
  693.                 wakeselect(p->wsel);
  694.                 p->wsel = 0;
  695.             }
  696.             wake(IO_Q, (long)p);    /* writers may continue */
  697.             sleep(IO_Q, (long)p);
  698.         }
  699.     }
  700.     if (bytes_read > 0) {
  701.         if (p->wsel) {
  702.             wakeselect(p->wsel);
  703.             p->wsel = 0;
  704.         }
  705.         wake(IO_Q, (long)p);    /* wake writers */
  706.     }
  707.     return bytes_read;
  708. }
  709.  
  710. static long
  711. pipe_ioctl(f, mode, buf)
  712.     FILEPTR *f; int mode; void *buf;
  713. {
  714.     struct pipe *p;
  715.     struct fifo *this;
  716.     struct flock *lck;
  717.  
  718.     long r;
  719.  
  720.     this = (struct fifo *)f->fc.index;
  721.  
  722.     if (mode == FIONREAD) {
  723.             p = (f->flags & O_HEAD) ? this->outp : this->inp;
  724.             assert(p != 0);
  725.             if (p->writers <= 0 || p->writers == VIRGIN_PIPE) {
  726.                 DEBUG("pipe FIONREAD: no writers");
  727.                 r = -1;
  728.             } else {
  729.                 r = p->tail - p->head;
  730.                 if (r < 0) r += PIPESIZ;
  731.                 if (is_terminal(f))
  732.                     r = r >> 2;    /* r /= 4 */
  733.             }
  734.             *((long *) buf) = r;
  735.     }
  736.     else if (mode == FIONWRITE) {
  737.             p = (f->flags & O_HEAD) ? this->inp : this->outp;
  738.             assert(p != 0);
  739.             if (p->readers <= 0) {
  740.                 r = -1;
  741.             } else {
  742.                 r = p->tail - p->head;
  743.                 if (r < 0) r += PIPESIZ;
  744.                 r = (PIPESIZ-1) - r;
  745.                 if (is_terminal(f))
  746.                     r = r >> 2;    /* r /= 4 */
  747.             }
  748.             *((long *) buf) = r;
  749.     }
  750.     else if (mode == F_SETLK) {
  751.         lck = (struct flock *)buf;
  752.         if (this->flags & O_LOCK) {
  753.             if (this->lockpid != curproc->pid) {
  754.                 DEBUG("pipe_ioctl: pipe already locked");
  755.                 return ELOCKED;
  756.             }
  757.         }
  758.         if (lck->l_type == F_UNLCK) {
  759.             if (!(f->flags & O_LOCK)) {
  760.                 DEBUG("pipe_ioctl: wrong file descriptor for UNLCK");
  761.                 return ENSLOCK;
  762.             }
  763.             this->flags &= ~O_LOCK;
  764.             this->lockpid = 0;
  765.             f->flags &= ~O_LOCK;
  766.         }
  767.         else {
  768.             this->flags |= O_LOCK;
  769.             this->lockpid = curproc->pid;
  770.             f->flags |= O_LOCK;
  771.         }
  772.     }
  773.     else if (mode == F_GETLK) {
  774.         lck = (struct flock *)buf;
  775.         if (this->flags & O_LOCK) {
  776.             lck->l_type = F_WRLCK;
  777.             lck->l_start = lck->l_len = 0;
  778.             lck->l_pid = this->lockpid;
  779.         }
  780.         else
  781.             lck->l_type = F_UNLCK;
  782.     }
  783.     else if (mode == TIOCFLUSH) {
  784.         if (this->inp) {
  785.             this->inp->head = this->inp->tail;
  786.             wake(IO_Q, (long)this->inp);
  787.         }
  788.         if (this->outp) {
  789.             this->outp->head = this->outp->tail;
  790.             wake(IO_Q, (long)this->outp);
  791.         }
  792.     } else if (mode == TIOCIBAUD || mode == TIOCOBAUD) {
  793.         *(long *)buf = -1L;
  794.     } else if (mode == TIOCGFLAGS) {
  795.         *((unsigned short *)buf) = 0;
  796.     } else {
  797.     /* if the file is a terminal, Fcntl will automatically
  798.      * call tty_ioctl for us to handle 'generic' terminal
  799.      * functions
  800.      */
  801.         return EINVFN;
  802.     }
  803.  
  804.     return 0;
  805. }
  806.  
  807. static long
  808. pipe_lseek(f, where, whence)
  809.     FILEPTR *f; long where; int whence;
  810. {
  811.     return EACCDN;
  812. }
  813.  
  814. static long
  815. pipe_datime(f, timeptr, rwflag)
  816.     FILEPTR *f;
  817.     short *timeptr;
  818.     int rwflag;
  819. {
  820.     struct fifo *this;
  821.  
  822.     this = (struct fifo *)f->fc.index;
  823.     if (rwflag) {
  824.         this->time = timeptr[0];
  825.         this->date = timeptr[1];
  826.     }
  827.     else {
  828.         timeptr[0] = this->time;
  829.         timeptr[1] = this->date;
  830.     }
  831.     return 0;
  832. }
  833.  
  834. static long
  835. pipe_close(f, pid)
  836.     FILEPTR *f;
  837.     int pid;
  838. {
  839.     struct fifo *this, *old;
  840.     struct pipe *p;
  841.     int rwmode;
  842.     FILEPTR **old_x, *x;
  843.  
  844.     this = (struct fifo *)f->fc.index;
  845.  
  846. /* wake any processes waiting on this pipe */
  847.     wake(IO_Q, (long)this->inp);
  848.     if (this->inp->rsel)
  849.         wakeselect(this->inp->rsel);
  850.     if (this->inp->wsel)
  851.         wakeselect(this->inp->wsel);
  852.  
  853.     if (this->outp) {
  854.         wake(IO_Q, (long)this->outp);
  855.         if (this->outp->wsel)
  856.             wakeselect(this->outp->wsel);
  857.         if (this->outp->rsel)
  858.             wakeselect(this->outp->rsel);
  859.     }
  860.  
  861.     if (f->links <= 0) {
  862. /* remove the file pointer from the list of open file pointers 
  863.  * of this pipe
  864.  */
  865.         old_x = &this->open;
  866.         x = this->open;
  867.         while (x && x != f) {
  868.                 old_x = &x->next;
  869.                 x = x->next;
  870.         }
  871.         assert(x);
  872.         *old_x = f->next;
  873.         /* f->next = 0; */
  874.  
  875.         rwmode = f->flags & O_RWMODE;
  876.         if (rwmode == O_RDONLY || rwmode == O_RDWR) {
  877.             p = (f->flags & O_HEAD) ? this->outp : this->inp;
  878. /* note that this can never be a virgin pipe, since we had a handle
  879.  * on it!
  880.  */            if (p)
  881.                 p->readers--;
  882.         }
  883.         if (rwmode == O_WRONLY || rwmode == O_RDWR) {
  884.             p = (f->flags & O_HEAD) ? this->inp : this->outp;
  885.             if (p) p->writers--;
  886.         }
  887.  
  888. /* correct for the "selfread" flag (see pipe_creat) */
  889.         if ((f->flags & O_HEAD) && !(this->dosflags & 0x02))
  890.             this->inp->readers--;
  891.  
  892. /* check for locks */
  893.         if ((f->flags & O_LOCK) && (this->lockpid == pid)) {
  894.             this->flags &= ~O_LOCK;
  895.         }
  896.     }
  897.  
  898. /* see if we're finished with the pipe */
  899.     if (this->inp->readers == VIRGIN_PIPE)
  900.         this->inp->readers = 0;
  901.     if (this->inp->writers == VIRGIN_PIPE)
  902.         this->inp->writers = 0;
  903.  
  904.     if (this->inp->readers <= 0 && this->inp->writers <= 0) {
  905.         TRACE("disposing of closed fifo");
  906. /* unlink from list of FIFOs */
  907.         if (rootlist == this)
  908.             rootlist = this->next;
  909.         else {
  910.             for (old = rootlist; old->next != this;
  911.                     old = old->next) {
  912.                 if (!old) {
  913.                     ALERT("fifo not on list???");
  914.                     return EINTRN;
  915.                 }
  916.             }
  917.             old->next = this->next;
  918.         }
  919.         kfree(this->inp);
  920.         if (this->outp) kfree(this->outp);
  921.         kfree(this);
  922.         pipetime = timestamp;
  923.         pipedate = datestamp;
  924.     }
  925.  
  926.     return 0;
  927. }
  928.  
  929. static long
  930. pipe_select(f, proc, mode)
  931.     FILEPTR *f;
  932.     long proc;
  933.     int mode;
  934. {
  935.     struct fifo *this;
  936.     struct pipe *p;
  937.     int j;
  938.  
  939.     this = (struct fifo *)f->fc.index;
  940.  
  941.     if (mode == O_RDONLY) {
  942.         p = (f->flags & O_HEAD) ? this->outp : this->inp;
  943.         if (!p) {
  944.             DEBUG("read select on wrong end of pipe");
  945.             return 0;
  946.         }
  947.  
  948. /* NOTE: if p->writers <= 0 then reads won't block (they'll fail) */
  949.         if (p->tail != p->head || p->writers <= 0) {
  950.             return 1;
  951.         }
  952.  
  953. /* BUG: multiple selects fail, only the first one works */
  954.         if (!p->rsel)
  955.             p->rsel = proc;
  956.         return 0;
  957.     } else if (mode == O_WRONLY) {
  958.         p = (f->flags & O_HEAD) ? this->inp : this->outp;
  959.         if (!p) {
  960.             DEBUG("write select on wrong end of pipe");
  961.             return 0;
  962.         }
  963.         j = p->tail+1;
  964.         if (j >= PIPESIZ) j = 0;
  965.         if (j != p->head || p->readers <= 0)
  966.             return 1;    /* data may be written */
  967.         if (!p->wsel)
  968.             p->wsel = proc;
  969.         return 0;
  970.     }
  971.     return 0;
  972. }
  973.  
  974. static void
  975. pipe_unselect(f, proc, mode)
  976.     FILEPTR *f;
  977.     long proc;
  978.     int mode;
  979. {
  980.     struct fifo *this;
  981.     struct pipe *p;
  982.  
  983.     this = (struct fifo *)f->fc.index;
  984.  
  985.     if (mode == O_RDONLY) {
  986.         p = (f->flags & O_HEAD) ? this->outp : this->inp;
  987.         if (!p) {
  988.             return;
  989.         }
  990.         if (p->rsel == proc)
  991.             p->rsel = 0;
  992.     } else if (mode == O_WRONLY) {
  993.         p = (f->flags & O_HEAD) ? this->inp : this->outp;
  994.         if (!p) {
  995.             return;
  996.         }
  997.         if (p->wsel == proc)
  998.             p->wsel = 0;
  999.     }
  1000. }
  1001.