servers/vfs/pipe.c

   1 /* This file deals with the suspension and revival of processes.  A process can
   2  * be suspended because it wants to read or write from a pipe and can't, or
   3  * because it wants to read or write from a special file and can't.  When a
   4  * process can't continue it is suspended, and revived later when it is able
   5  * to continue.
   6  *
   7  * The entry points into this file are
   8  *   do_pipe2:    perform the PIPE2 system call
   9  *   pipe_check:  check to see that a read or write on a pipe is feasible now
  10  *   suspend:     suspend a process that cannot do a requested read or write
  11  *   release:     check to see if a suspended process can be released and do
  12  *                it
  13  *   revive:      mark a suspended process as able to run again
  14  *   unsuspend_by_endpt: revive all processes blocking on a given process
  15  *   do_unpause:  a signal has been sent to a process; see if it suspended
  16  */
  17
  18 #include "fs.h"
  19 #include <fcntl.h>
  20 #include <signal.h>
  21 #include <string.h>
  22 #include <assert.h>
  23 #include <minix/callnr.h>
  24 #include <minix/endpoint.h>
  25 #include <minix/com.h>
  26 #include <minix/u64.h>
  27 #include <sys/select.h>
  28 #include <sys/time.h>
  29 #include "file.h"
  30 #include "scratchpad.h"
  31 #include <minix/vfsif.h>
  32 #include "vnode.h"
  33 #include "vmnt.h"
  34
  35 static int create_pipe(int fil_des[2], int flags);
  36
  37 /*===========================================================================*
  38  *                              do_pipe2                                     *
  39  *===========================================================================*/
  40 int do_pipe2(void)
  41 {
  42 /* Perform the pipe2(fil_des[2], flags) system call. */
  43   int r, flags;
  44   int fil_des[2];               /* reply goes here */
  45
  46   flags = job_m_in.VFS_PIPE2_FLAGS;
  47
  48   r = create_pipe(fil_des, flags);
  49   if (r == OK) {
  50         job_m_out.VFS_PIPE2_FD0 = fil_des[0];
  51         job_m_out.VFS_PIPE2_FD1 = fil_des[1];
  52   }
  53
  54   return r;
  55 }
  56
  57 /*===========================================================================*
  58  *                              create_pipe                                  *
  59  *===========================================================================*/
  60 static int create_pipe(int fil_des[2], int flags)
  61 {
  62   register struct fproc *rfp;
  63   int r;
  64   struct filp *fil_ptr0, *fil_ptr1;
  65   struct vnode *vp;
  66   struct vmnt *vmp;
  67   struct node_details res;
  68
  69   /* Get a lock on PFS */
  70   if ((vmp = find_vmnt(PFS_PROC_NR)) == NULL) panic("PFS gone");
  71   if ((r = lock_vmnt(vmp, VMNT_READ)) != OK) return(r);
  72
  73   /* See if a free vnode is available */
  74   if ((vp = get_free_vnode()) == NULL) {
  75         unlock_vmnt(vmp);
  76         return(err_code);
  77   }
  78   lock_vnode(vp, VNODE_OPCL);
  79
  80   /* Acquire two file descriptors. */
  81   rfp = fp;
  82   if ((r = get_fd(fp, 0, R_BIT, &fil_des[0], &fil_ptr0)) != OK) {
  83         unlock_vnode(vp);
  84         unlock_vmnt(vmp);
  85         return(r);
  86   }
  87   rfp->fp_filp[fil_des[0]] = fil_ptr0;
  88   fil_ptr0->filp_count = 1;             /* mark filp in use */
  89   if ((r = get_fd(fp, 0, W_BIT, &fil_des[1], &fil_ptr1)) != OK) {
  90         rfp->fp_filp[fil_des[0]] = NULL;
  91         fil_ptr0->filp_count = 0;       /* mark filp free */
  92         unlock_filp(fil_ptr0);
  93         unlock_vnode(vp);
  94         unlock_vmnt(vmp);
  95         return(r);
  96   }
  97   rfp->fp_filp[fil_des[1]] = fil_ptr1;
  98   fil_ptr1->filp_count = 1;
  99
 100   /* Create a named pipe inode on PipeFS */
 101   r = req_newnode(PFS_PROC_NR, fp->fp_effuid, fp->fp_effgid, I_NAMED_PIPE,
 102                   NO_DEV, &res);
 103
 104   if (r != OK) {
 105         rfp->fp_filp[fil_des[0]] = NULL;
 106         fil_ptr0->filp_count = 0;
 107         rfp->fp_filp[fil_des[1]] = NULL;
 108         fil_ptr1->filp_count = 0;
 109         unlock_filp(fil_ptr1);
 110         unlock_filp(fil_ptr0);
 111         unlock_vnode(vp);
 112         unlock_vmnt(vmp);
 113         return(r);
 114   }
 115
 116   /* Fill in vnode */
 117   vp->v_fs_e = res.fs_e;
 118   vp->v_mapfs_e = res.fs_e;
 119   vp->v_inode_nr = res.inode_nr;
 120   vp->v_mapinode_nr = res.inode_nr;
 121   vp->v_mode = res.fmode;
 122   vp->v_fs_count = 1;
 123   vp->v_mapfs_count = 1;
 124   vp->v_ref_count = 1;
 125   vp->v_size = 0;
 126   vp->v_vmnt = NULL;
 127   vp->v_dev = NO_DEV;
 128
 129   /* Fill in filp objects */
 130   fil_ptr0->filp_vno = vp;
 131   dup_vnode(vp);
 132   fil_ptr1->filp_vno = vp;
 133   fil_ptr0->filp_flags = O_RDONLY | (flags & ~O_ACCMODE);
 134   fil_ptr1->filp_flags = O_WRONLY | (flags & ~O_ACCMODE);
 135   if (flags & O_CLOEXEC) {
 136         FD_SET(fil_des[0], &rfp->fp_cloexec_set);
 137         FD_SET(fil_des[1], &rfp->fp_cloexec_set);
 138   }
 139
 140   unlock_filps(fil_ptr0, fil_ptr1);
 141   unlock_vmnt(vmp);
 142
 143   return(OK);
 144 }
 145
 146
 147 /*===========================================================================*
 148  *                              map_vnode                                    *
 149  *===========================================================================*/
 150 int map_vnode(vp, map_to_fs_e)
 151 struct vnode *vp;
 152 endpoint_t map_to_fs_e;
 153 {
 154   int r;
 155   struct vmnt *vmp;
 156   struct node_details res;
 157
 158   if(vp->v_mapfs_e != NONE) return(OK); /* Already mapped; nothing to do. */
 159
 160   if ((vmp = find_vmnt(map_to_fs_e)) == NULL)
 161         panic("Can't map to unknown endpoint");
 162   if ((r = lock_vmnt(vmp, VMNT_WRITE)) != OK) {
 163         if (r == EBUSY)
 164                 vmp = NULL;     /* Already locked, do not unlock */
 165         else
 166                 return(r);
 167
 168   }
 169
 170   /* Create a temporary mapping of this inode to another FS. Read and write
 171    * operations on data will be handled by that FS. The rest by the 'original'
 172    * FS that holds the inode. */
 173   if ((r = req_newnode(map_to_fs_e, fp->fp_effuid, fp->fp_effgid, I_NAMED_PIPE,
 174                        vp->v_dev, &res)) == OK) {
 175         vp->v_mapfs_e = res.fs_e;
 176         vp->v_mapinode_nr = res.inode_nr;
 177         vp->v_mapfs_count = 1;
 178   }
 179
 180   if (vmp) unlock_vmnt(vmp);
 181
 182   return(r);
 183 }
 184
 185 /*===========================================================================*
 186  *                              pipe_check                                   *
 187  *===========================================================================*/
 188 int pipe_check(
 189 struct filp *filp,      /* the filp of the pipe */
 190 int rw_flag,            /* READING or WRITING */
 191 int oflags,             /* flags set by open or fcntl */
 192 int bytes,              /* bytes to be read or written (all chunks) */
 193 int notouch             /* check only */
 194 )
 195 {
 196 /* Pipes are a little different.  If a process reads from an empty pipe for
 197  * which a writer still exists, suspend the reader.  If the pipe is empty
 198  * and there is no writer, return 0 bytes.  If a process is writing to a
 199  * pipe and no one is reading from it, give a broken pipe error.
 200  */
 201   struct vnode *vp;
 202   off_t pos;
 203   int r = OK;
 204
 205   vp = filp->filp_vno;
 206
 207   /* Reads start at the beginning; writes append to pipes */
 208   if (notouch) /* In this case we don't actually care whether data transfer
 209                 * would succeed. See POSIX 1003.1-2008 */
 210         pos = 0;
 211   else if (rw_flag == READING)
 212         pos = 0;
 213   else {
 214         pos = vp->v_size;
 215   }
 216
 217   /* If reading, check for empty pipe. */
 218   if (rw_flag == READING) {
 219         if (vp->v_size == 0) {
 220                 /* Process is reading from an empty pipe. */
 221                 if (find_filp(vp, W_BIT) != NULL) {
 222                         /* Writer exists */
 223                         if (oflags & O_NONBLOCK)
 224                                 r = EAGAIN;
 225                         else
 226                                 r = SUSPEND;
 227
 228                         /* If need be, activate sleeping writers. */
 229                         if (susp_count > 0)
 230                                 release(vp, VFS_WRITE, susp_count);
 231                 }
 232                 return(r);
 233         }
 234         return(bytes);
 235   }
 236
 237   /* Process is writing to a pipe. */
 238   if (find_filp(vp, R_BIT) == NULL) {
 239         return(EPIPE);
 240   }
 241
 242   /* Calculate how many bytes can be written. */
 243   if (pos + bytes > PIPE_BUF) {
 244         if (oflags & O_NONBLOCK) {
 245                 if (bytes <= PIPE_BUF) {
 246                         /* Write has to be atomic */
 247                         return(EAGAIN);
 248                 }
 249
 250                 /* Compute available space */
 251                 bytes = PIPE_BUF - pos;
 252
 253                 if (bytes > 0)  {
 254                         /* Do a partial write. Need to wakeup reader */
 255                         if (!notouch)
 256                                 release(vp, VFS_READ, susp_count);
 257                         return(bytes);
 258                 } else {
 259                         /* Pipe is full */
 260                         return(EAGAIN);
 261                 }
 262         }
 263
 264         if (bytes > PIPE_BUF) {
 265                 /* Compute available space */
 266                 bytes = PIPE_BUF - pos;
 267
 268                 if (bytes > 0) {
 269                         /* Do a partial write. Need to wakeup reader
 270                          * since we'll suspend ourself in read_write()
 271                          */
 272                         if (!notouch)
 273                                 release(vp, VFS_READ, susp_count);
 274                         return(bytes);
 275                 }
 276         }
 277
 278         /* Pipe is full */
 279         return(SUSPEND);
 280   }
 281
 282   /* Writing to an empty pipe.  Search for suspended reader. */
 283   if (pos == 0 && !notouch)
 284         release(vp, VFS_READ, susp_count);
 285
 286   /* Requested amount fits */
 287   return(bytes);
 288 }
 289
 290
 291 /*===========================================================================*
 292  *                              suspend                                      *
 293  *===========================================================================*/
 294 void suspend(int why)
 295 {
 296 /* Take measures to suspend the processing of the present system call.
 297  * Store the parameters to be used upon resuming in the process table.
 298  * (Actually they are not used when a process is waiting for an I/O device,
 299  * but they are needed for pipes, and it is not worth making the distinction.)
 300  * The SUSPEND pseudo error should be returned after calling suspend().
 301  */
 302
 303   if (why == FP_BLOCKED_ON_POPEN || why == FP_BLOCKED_ON_PIPE)
 304         /* #procs susp'ed on pipe*/
 305         susp_count++;
 306
 307   fp->fp_blocked_on = why;
 308   assert(fp->fp_grant == GRANT_INVALID || !GRANT_VALID(fp->fp_grant));
 309   fp->fp_block_callnr = job_call_nr;
 310 }
 311
 312 /*===========================================================================*
 313  *                              wait_for                                     *
 314  *===========================================================================*/
 315 void wait_for(endpoint_t who)
 316 {
 317   if(who == NONE || who == ANY)
 318         panic("suspend on NONE or ANY");
 319   suspend(FP_BLOCKED_ON_OTHER);
 320   fp->fp_task = who;
 321 }
 322
 323
 324 /*===========================================================================*
 325  *                              pipe_suspend                                 *
 326  *===========================================================================*/
 327 void pipe_suspend(filp, buf, size)
 328 struct filp *filp;
 329 char *buf;
 330 size_t size;
 331 {
 332 /* Take measures to suspend the processing of the present system call.
 333  * Store the parameters to be used upon resuming in the process table.
 334  */
 335
 336   scratch(fp).file.filp = filp;
 337   scratch(fp).io.io_buffer = buf;
 338   scratch(fp).io.io_nbytes = size;
 339   suspend(FP_BLOCKED_ON_PIPE);
 340 }
 341
 342
 343 /*===========================================================================*
 344  *                              unsuspend_by_endpt                           *
 345  *===========================================================================*/
 346 void unsuspend_by_endpt(endpoint_t proc_e)
 347 {
 348 /* Revive processes waiting for drivers (SUSPENDed) that have disappeared with
 349  * return code EAGAIN.
 350  */
 351   struct fproc *rp;
 352
 353   for (rp = &fproc[0]; rp < &fproc[NR_PROCS]; rp++) {
 354         if (rp->fp_pid == PID_FREE) continue;
 355         if (rp->fp_blocked_on == FP_BLOCKED_ON_OTHER && rp->fp_task == proc_e)
 356                 revive(rp->fp_endpoint, EIO);
 357   }
 358
 359   /* Revive processes waiting in drivers on select()s with EAGAIN too */
 360   select_unsuspend_by_endpt(proc_e);
 361
 362   return;
 363 }
 364
 365
 366 /*===========================================================================*
 367  *                              release                                      *
 368  *===========================================================================*/
 369 void release(vp, op, count)
 370 register struct vnode *vp;      /* inode of pipe */
 371 int op;                         /* VFS_READ, VFS_WRITE, or VFS_OPEN */
 372 int count;                      /* max number of processes to release */
 373 {
 374 /* Check to see if any process is hanging on vnode 'vp'. If one is, and it
 375  * was trying to perform the call indicated by 'op', release it.
 376  */
 377
 378   register struct fproc *rp;
 379   struct filp *f;
 380   int selop;
 381
 382   /* Trying to perform the call also includes SELECTing on it with that
 383    * operation.
 384    */
 385   if (op == VFS_READ || op == VFS_WRITE) {
 386         if (op == VFS_READ)
 387                 selop = SEL_RD;
 388         else
 389                 selop = SEL_WR;
 390
 391         for (f = &filp[0]; f < &filp[NR_FILPS]; f++) {
 392                 if (f->filp_count < 1 || !(f->filp_pipe_select_ops & selop) ||
 393                     f->filp_vno != vp)
 394                         continue;
 395                 select_callback(f, selop);
 396                 f->filp_pipe_select_ops &= ~selop;
 397         }
 398   }
 399
 400   /* Search the proc table. */
 401   for (rp = &fproc[0]; rp < &fproc[NR_PROCS] && count > 0; rp++) {
 402         if (rp->fp_pid != PID_FREE && fp_is_blocked(rp) &&
 403             !(rp->fp_flags & FP_REVIVED) && rp->fp_block_callnr == op) {
 404                 /* Find the vnode. Depending on the reason the process was
 405                  * suspended, there are different ways of finding it.
 406                  */
 407
 408                 if (rp->fp_blocked_on == FP_BLOCKED_ON_POPEN ||
 409                     rp->fp_blocked_on == FP_BLOCKED_ON_LOCK ||
 410                     rp->fp_blocked_on == FP_BLOCKED_ON_OTHER) {
 411                         f = rp->fp_filp[scratch(rp).file.fd_nr];
 412                         if (f == NULL || f->filp_mode == FILP_CLOSED)
 413                                 continue;
 414                         if (rp->fp_filp[scratch(rp).file.fd_nr]->filp_vno != vp)
 415                                 continue;
 416                 } else if (rp->fp_blocked_on == FP_BLOCKED_ON_PIPE) {
 417                         if (scratch(rp).file.filp == NULL)
 418                                 continue;
 419                         if (scratch(rp).file.filp->filp_vno != vp)
 420                                 continue;
 421                 } else
 422                         continue;
 423
 424                 /* We found the vnode. Revive process. */
 425                 revive(rp->fp_endpoint, 0);
 426                 susp_count--;   /* keep track of who is suspended */
 427                 if(susp_count < 0)
 428                         panic("susp_count now negative: %d", susp_count);
 429                 if (--count == 0) return;
 430         }
 431   }
 432 }
 433
 434
 435 /*===========================================================================*
 436  *                              revive                                       *
 437  *===========================================================================*/
 438 void revive(endpoint_t proc_e, int returned)
 439 {
 440 /* Revive a previously blocked process. When a process hangs on tty, this
 441  * is the way it is eventually released. For processes blocked on _SELECT and
 442  * _OTHER, this function MUST NOT block its calling thread.
 443  */
 444   struct fproc *rfp;
 445   int blocked_on;
 446   int fd_nr, slot;
 447
 448   if (proc_e == NONE || isokendpt(proc_e, &slot) != OK) return;
 449
 450   rfp = &fproc[slot];
 451   if (!fp_is_blocked(rfp) || (rfp->fp_flags & FP_REVIVED)) return;
 452
 453   /* The 'reviving' flag only applies to pipes.  Processes waiting for TTY get
 454    * a message right away.  The revival process is different for TTY and pipes.
 455    * For select and TTY revival, the work is already done, for pipes it is not:
 456    * the proc must be restarted so it can try again.
 457    */
 458   blocked_on = rfp->fp_blocked_on;
 459   fd_nr = scratch(rfp).file.fd_nr;
 460   if (blocked_on == FP_BLOCKED_ON_PIPE || blocked_on == FP_BLOCKED_ON_LOCK) {
 461         /* Revive a process suspended on a pipe or lock. */
 462         rfp->fp_flags |= FP_REVIVED;
 463         reviving++;             /* process was waiting on pipe or lock */
 464   } else {
 465         rfp->fp_blocked_on = FP_BLOCKED_ON_NONE;
 466         scratch(rfp).file.fd_nr = 0;
 467         if (blocked_on == FP_BLOCKED_ON_POPEN) {
 468                 /* process blocked in open or create */
 469                 replycode(proc_e, fd_nr);
 470         } else if (blocked_on == FP_BLOCKED_ON_SELECT) {
 471                 replycode(proc_e, returned);
 472         } else {
 473                 /* Revive a process suspended on TTY or other device.
 474                  * Pretend it wants only what there is.
 475                  */
 476                 scratch(rfp).io.io_nbytes = returned;
 477                 /* If a grant has been issued by FS for this I/O, revoke
 478                  * it again now that I/O is done.
 479                  */
 480                 if (GRANT_VALID(rfp->fp_grant)) {
 481                         if(cpf_revoke(rfp->fp_grant)) {
 482                                 panic("VFS: revoke failed for grant: %d",
 483                                         rfp->fp_grant);
 484                         }
 485                         rfp->fp_grant = GRANT_INVALID;
 486                 }
 487                 replycode(proc_e, returned);/* unblock the process */
 488         }
 489   }
 490 }
 491
 492
 493 /*===========================================================================*
 494  *                              unpause                                      *
 495  *===========================================================================*/
 496 void unpause(void)
 497 {
 498 /* A signal has been sent to a user who is paused on the file system.
 499  * Abort the system call with the EINTR error message.
 500  */
 501   int blocked_on, fild, status = EINTR;
 502   struct filp *f;
 503   dev_t dev;
 504   int wasreviving = 0;
 505
 506   if (!fp_is_blocked(fp)) return;
 507   blocked_on = fp->fp_blocked_on;
 508
 509   /* Clear the block status now. The procedure below might make blocking calls
 510    * and it is imperative that while at least cdev_cancel() is executing, other
 511    * parts of VFS do not perceive this process as blocked on something.
 512    */
 513   fp->fp_blocked_on = FP_BLOCKED_ON_NONE;
 514
 515   if (fp->fp_flags & FP_REVIVED) {
 516         fp->fp_flags &= ~FP_REVIVED;
 517         reviving--;
 518         wasreviving = 1;
 519   }
 520
 521   switch (blocked_on) {
 522         case FP_BLOCKED_ON_PIPE:/* process trying to read or write a pipe */
 523                 /* If the operation succeeded partially, return the bytes
 524                  * processed so far, and clear the remembered state. Otherwise,
 525                  * return EINTR as usual.
 526                  */
 527                 if (fp->fp_cum_io_partial > 0) {
 528                         status = fp->fp_cum_io_partial;
 529
 530                         fp->fp_cum_io_partial = 0;
 531                 }
 532                 break;
 533
 534         case FP_BLOCKED_ON_LOCK:/* process trying to set a lock with FCNTL */
 535                 break;
 536
 537         case FP_BLOCKED_ON_SELECT:/* process blocking on select() */
 538                 select_forget();
 539                 break;
 540
 541         case FP_BLOCKED_ON_POPEN:       /* process trying to open a fifo */
 542                 break;
 543
 544         case FP_BLOCKED_ON_OTHER:/* process trying to do device I/O (e.g. tty)*/
 545                 fild = scratch(fp).file.fd_nr;
 546                 if (fild < 0 || fild >= OPEN_MAX)
 547                         panic("file descriptor out-of-range");
 548                 f = fp->fp_filp[fild];
 549                 if(!f) {
 550                         sys_diagctl_stacktrace(fp->fp_endpoint);
 551                         panic("process %d blocked on empty fd %d",
 552                                 fp->fp_endpoint, fild);
 553                 }
 554                 dev = f->filp_vno->v_sdev;      /* device hung on */
 555
 556                 status = cdev_cancel(dev);
 557
 558                 break;
 559         default :
 560                 panic("VFS: unknown block reason: %d", blocked_on);
 561   }
 562
 563   if ((blocked_on == FP_BLOCKED_ON_PIPE || blocked_on == FP_BLOCKED_ON_POPEN)&&
 564         !wasreviving) {
 565         susp_count--;
 566   }
 567
 568   replycode(fp->fp_endpoint, status);   /* signal interrupted call */
 569 }