Ejemplo n.º 1
0
/*
 * pipe(2) system call.
 * Create a pipe by connecting two streams together. Associate
 * each end of the pipe with a vnode, a file descriptor and
 * one of the streams.
 */
longlong_t
pipe()
{
	vnode_t *vp1, *vp2;
	struct file *fp1, *fp2;
	int error = 0;
	int fd1, fd2;
	rval_t	r;

	/*
	 * Allocate and initialize two vnodes.
	 */
	makepipe(&vp1, &vp2);

	/*
	 * Allocate and initialize two file table entries and two
	 * file pointers. Each file pointer is open for read and
	 * write.
	 */
	if (error = falloc(vp1, FWRITE|FREAD, &fp1, &fd1)) {
		VN_RELE(vp1);
		VN_RELE(vp2);
		return ((longlong_t)set_errno(error));
	}

	if (error = falloc(vp2, FWRITE|FREAD, &fp2, &fd2))
		goto out2;

	/*
	 * Create two stream heads and attach to each vnode.
	 */
	if (error = fifo_stropen(&vp1, FWRITE|FREAD, fp1->f_cred, 0, 0))
		goto out;

	if (error = fifo_stropen(&vp2, FWRITE|FREAD, fp2->f_cred, 0, 0)) {
		(void) VOP_CLOSE(vp1, FWRITE|FREAD, 1, (offset_t)0,
		    fp1->f_cred);
		goto out;
	}

	strmate(vp1, vp2);

	VTOF(vp1)->fn_ino = VTOF(vp2)->fn_ino = fifogetid();

	/*
	 * Now fill in the entries that falloc reserved
	 */
	mutex_exit(&fp1->f_tlock);
	mutex_exit(&fp2->f_tlock);
	setf(fd1, fp1);
	setf(fd2, fp2);

	/*
	 * Return the file descriptors to the user. They now
	 * point to two different vnodes which have different
	 * stream heads.
	 */
	r.r_val1 = fd1;
	r.r_val2 = fd2;
	return (r.r_vals);
out:
	unfalloc(fp2);
	setf(fd2, NULL);
out2:
	unfalloc(fp1);
	setf(fd1, NULL);
	VN_RELE(vp1);
	VN_RELE(vp2);
	return ((longlong_t)set_errno(error));
}
Ejemplo n.º 2
0
int main(int argc, char *argv[])

{
  speed_t baud = B57600;  // default baudrate
  stdinfd = fileno(stdin);
  stdoutfd = fileno(stdout);
  serialfd = -1;
  erlpipefd = -1;
  struct termios oldserial, oldstdin;
 
 
 //saveterminal(stdinfd,oldstdin);
 // check(tcgetattr(stdinfd,&oldstdin) == 0, "Failed to backup stdin");

 // if erlang mode is set then redirect stderr to erlerr.txt

   

  //read command line arguments
  check(parsecmdargs(argc, argv) != -1,"Command Line Argument Failure");


  if(erlang == TRUE)
     {
       freopen("erlerr.txt", "w", stderr);
     }  
 debug("pid is %d", getpid());
  //setup pipe if require doesn't work yet 
   if(pipedebug == 1) //
   {
  
     check(makepipe(ERLPIPE) == 0, "Pipe creation or opening failed for: ");
     debug("Pipe created:");
     debug("Process %d opening erlpipe", getpid());
     erlpipefd = open(ERLPIPE, O_WRONLY|O_NONBLOCK); 
     check(erlpipefd > 0, "Erlpipe failed to open pipe: %s\nSetup reader in second terminal\n tail -f erlpipe",ERLPIPE);
     debug("Erlpipe opened");
     /*
     check(makepipe(ERLPIPEIN) == 0, "Erlpipein  creation or opening failed for: "); 
     debug("Pipe created:");
     debug("Process %d opening erlpipein", getpid());
     erlpipeinfd = open(ERLPIPEIN);
     check(erlpipeinfd > 0, "Erlpipein: Failed to open pipe: %s\nSetup reader in second terminal\n tail -f erlpipe",ERLPIPEIN);
     debug("Erlpipe opened"); */
    }
    
   // save terminal settings
 
 
  //get baud rate from command line arguments
  baud = getbaud(baudrate);
  check(baud != B0, "Illegal baud rate"); 
  
  if(serial == TRUE){

  //open serial port
  serialfd = open(serialport, O_RDWR);
  check(serialfd > 0,"Can't open serial port\n Try dmesg | grep tty from shell \n");    
  debug("Opened serial port: %s",serialport);
 
  //set serial port to raw mode
  check(makeraw(serialfd)==0,"Failed to set serial port raw mode");
 //set baudrate serial
  check(setspeed(serialfd,baud)==0,"Failed to set baud rate");
  debug("Baud rate set to: %d", baudrate);
  }

  //set stdin to raw mode
  // check(makeraw(stdinfd)==0, "Failed to set stdin to raw mode");
  // debug("Not Entered raw mode:");

 
  
  //send acknowledge to erlang???

 /* Watch stdinfd and serialfd
       if input is available process then output
       Serial -> Erlang
       Erlang -> Serial
    */ 
  
  /*
  int numbytes;
  while(1){
  numbytes = read_erlang(erlmesg.mesg);
  check(numbytes > 0, "Read error from erlang");
	debug("Read %d bytes from Erlang", numbytes);
	write_serial(numbytes, erlmesg.mesg);
	debug("Wrote %d bytes to serial:", numbytes);
  }
  //main loop
  */
	
  {
    fd_set readfds;
    int maxfd;
    int is, numbytes;
    FD_ZERO(&readfds);
    
    maxfd = (stdinfd > serialfd) ? stdinfd : serialfd;
    maxfd = (maxfd > erlpipeinfd) ? maxfd : erlpipeinfd;

      
    while(1){
      if(serial){
      FD_SET(serialfd, &readfds);
      }
      
      if(pipedebug){
	  FD_SET(erlpipeinfd, &readfds);
	}

      FD_SET(stdinfd, &readfds);
      
      
      is = select(maxfd+1, &readfds, NULLFDS, NULLFDS, NULLTV);
      check(is>0,"Select error -"); 
      
      if (serial && FD_ISSET(serialfd,&readfds)){ // Serial porth ready to read
	FD_CLR(serialfd,&readfds);
	

	numbytes = read(serialfd, erlmesg.mesg, MAXMESG);
	check(numbytes > 0, "Read error from serial port");
	write_erlang(numbytes, erlmesg.mesg);

      }

      if (FD_ISSET(stdinfd,&readfds)){  //Stdin-Erlang ready to read
 	FD_CLR(stdinfd, &readfds);
	
        numbytes = read_erlang(erlmesg.mesg);
	check(numbytes > 0, "Read error from erlang");
	debug("Read %d bytes from Erlang", numbytes);
	write_serial(numbytes, erlmesg.mesg);
	debug("Wrote %d bytes to serial:", numbytes);

      }
      // input pipe
      /*
      if (pipedebug && (FD_ISSET(erlpipeinfd,&readfds)){  
	FD_CLR(erlpipeinfd, &readfds);

    }
      */
    }
  
}	  
  //hanldle input from erlang
  //handle input from serial port
  // restoreterminal(stdinfd,&oldstdin);

	//  tcsetattr(stdinfd,TCSANOW,&oldstdin);
    return 0;

 error:
    //restoreterminal(stdinfd,&oldstdin);
    //    tcsetattr(stdinfd,TCSANOW,&oldstdin);;
    debug("Restored terminal");
    exit(1);
   
    }
Ejemplo n.º 3
0
/*
 * Note:  This routine is single threaded
 *  Protected by FIFOOPEN flag (i.e. flk_lock is not held)
 *  Upon successful completion, the original fifo is unlocked
 *  and FIFOOPEN is cleared for the original vpp.
 *  The new fifo returned has FIFOOPEN set.
 */
static int
fifo_connld(struct vnode **vpp, int flag, cred_t *crp)
{
	struct vnode *vp1;
	struct vnode *vp2;
	struct fifonode *oldfnp;
	struct fifonode *fn_dest;
	int error;
	struct file *filep;
	struct fifolock *fn_lock;
	cred_t *c;

	/*
	 * Get two vnodes that will represent the pipe ends for the new pipe.
	 */
	makepipe(&vp1, &vp2);

	/*
	 * Allocate a file descriptor and file pointer for one of the pipe
	 * ends. The file descriptor will be used to send that pipe end to
	 * the process on the other end of this stream. Note that we get
	 * the file structure only, there is no file list entry allocated.
	 */
	if (error = falloc(vp1, FWRITE|FREAD, &filep, NULL)) {
		VN_RELE(vp1);
		VN_RELE(vp2);
		return (error);
	}
	mutex_exit(&filep->f_tlock);
	oldfnp = VTOF(*vpp);
	fn_lock = oldfnp->fn_lock;
	fn_dest = oldfnp->fn_dest;

	/*
	 * Create two new stream heads and attach them to the two vnodes for
	 * the new pipe.
	 */
	if ((error = fifo_stropen(&vp1, FREAD|FWRITE, filep->f_cred, 0, 0)) !=
	    0 ||
	    (error = fifo_stropen(&vp2, flag, filep->f_cred, 0, 0)) != 0) {
#if DEBUG
		cmn_err(CE_NOTE, "fifo stropen failed error 0x%x", error);
#endif
		/*
		 * this will call fifo_close and VN_RELE on vp1
		 */
		(void) closef(filep);
		VN_RELE(vp2);
		return (error);
	}

	/*
	 * twist the ends of the pipe together
	 */
	strmate(vp1, vp2);

	/*
	 * Set our end to busy in open
	 * Note: Don't need lock around this because we're the only
	 * one who knows about it
	 */
	VTOF(vp2)->fn_flag |= FIFOOPEN;

	mutex_enter(&fn_lock->flk_lock);

	fn_dest->fn_flag |= FIFOSEND;
	/*
	 * check to make sure neither end of pipe has gone away
	 */
	if (!(fn_dest->fn_flag & FIFOISOPEN)) {
		error = ENXIO;
		fn_dest->fn_flag &= ~FIFOSEND;
		mutex_exit(&fn_lock->flk_lock);
		/*
		 * this will call fifo_close and VN_RELE on vp1
		 */
		goto out;
	}
	mutex_exit(&fn_lock->flk_lock);

	/*
	 * Tag the sender's credential on the pipe descriptor.
	 */
	crhold(VTOF(vp1)->fn_pcredp = crp);
	VTOF(vp1)->fn_cpid = curproc->p_pid;

	/*
	 * send the file descriptor to other end of pipe
	 */
	if (error = do_sendfp((*vpp)->v_stream, filep, crp)) {
		mutex_enter(&fn_lock->flk_lock);
		fn_dest->fn_flag &= ~FIFOSEND;
		mutex_exit(&fn_lock->flk_lock);
		/*
		 * this will call fifo_close and VN_RELE on vp1
		 */
		goto out;
	}

	mutex_enter(&fn_lock->flk_lock);
	/*
	 * Wait for other end to receive file descriptor
	 * FIFOCLOSE indicates that one or both sides of the pipe
	 * have gone away.
	 */
	while ((fn_dest->fn_flag & (FIFOCLOSE | FIFOSEND)) == FIFOSEND) {
		if (!cv_wait_sig(&oldfnp->fn_wait_cv, &fn_lock->flk_lock)) {
			error = EINTR;
			fn_dest->fn_flag &= ~FIFOSEND;
			mutex_exit(&fn_lock->flk_lock);
			goto out;
		}
	}
	/*
	 * If either end of pipe has gone away and the other end did not
	 * receive pipe, reject the connld open
	 */
	if ((fn_dest->fn_flag & FIFOSEND)) {
		error = ENXIO;
		fn_dest->fn_flag &= ~FIFOSEND;
		mutex_exit(&fn_lock->flk_lock);
		goto out;
	}

	oldfnp->fn_flag &= ~FIFOOPEN;
	cv_broadcast(&oldfnp->fn_wait_cv);
	mutex_exit(&fn_lock->flk_lock);

	VN_RELE(*vpp);
	*vpp = vp2;
	(void) closef(filep);
	return (0);
out:
	c = filep->f_cred;
	crhold(c);
	(void) closef(filep);
	VTOF(vp2)->fn_flag &= ~FIFOOPEN;
	(void) fifo_close(vp2, flag, 1, (offset_t)0, c, NULL);
	crfree(c);
	VN_RELE(vp2);
	return (error);
}