ioproc man page on Plan9

Printed from

IOPROC(2)							     IOPROC(2)

       closeioproc,  iocall,  ioclose,	iointerrupt,  iodial,  ioopen, ioproc,
       ioread, ioreadn, iowrite - slave I/O processes for threaded programs

       #include <u.h>
       #include <libc.h>
       #include <thread.h>

       typedef struct Ioproc Ioproc;

       Ioproc* ioproc(void);
       int     ioopen(Ioproc *io, char *file, int omode);
       int     ioclose(Ioproc *io, int fd);
       long    ioread(Ioproc *io, int fd, void *a, long n);
       long    ioreadn(Ioproc *io, int fd, void *a, long n);
       long    iowrite(Ioproc *io, int fd, void *a, long n);
       int     iodial(Ioproc *io, char *addr, char *local, char *dir, char *cdfp);
       void    iointerrupt(Ioproc *io);
       void    closeioproc(Ioproc *io);
       long    iocall(Ioproc *io, long (*op)(va_list *arg), ...);

       These routines provide access to I/O in slave  procs.   Since  the  I/O
       itself  is  done in a slave proc, other threads in the calling proc can
       run while the calling thread waits for the I/O to complete.

       Ioproc forks a new slave proc and returns a pointer to the Ioproc asso‐
       ciated  with  it.  Ioproc uses mallocz and proccreate; if either fails,
       it calls sysfatal rather than return an error.

       Ioopen, ioclose, ioread, ioreadn, iowrite, and iodial execute the simi‐
       larly named library or system calls (see open(2), read(2), and dial(2))
       in the slave process associated with io.	 It is	an  error  to  execute
       more than one call at a time in an I/O proc.

       Iointerrupt  interrupts	the  call currently executing in the I/O proc.
       If no call is executing, iointerrupt is a no-op.

       Closeioproc terminates the I/O proc and frees the associated Ioproc .

       Iocall is a primitive that may be used to implement more slave I/O rou‐
       tines.	Iocall arranges for op to be called in io's proc, with arg set
       to the variable parameter list, returning the value that op returns.

       Relay messages between two file descriptors, counting the total	number
       of bytes seen:

	      int tot;

	      relaythread(void *v)
		  int *fd, n;
		  char buf[1024];
		  Ioproc *io;

		  fd = v;
		  io = ioproc();
		  while((n = ioread(io, fd[0], buf, sizeof buf)) > 0){
		      if(iowrite(io, fd[1], buf, n) != n)
			  sysfatal("iowrite: %r");
		      tot += n;

	      relay(int fd0, int fd1)
		  int fd[4];

		  fd[0] = fd[3] = fd0;
		  fd[1] = fd[2] = fd1;
		  threadcreate(relaythread, fd, 8192);
		  threadcreate(relaythread, fd+2, 8192);

       If  the	two relaythread instances were running in different procs, the
       common access to tot would be unsafe.

       Implement ioread:

	      static long
	      _ioread(va_list *arg)
		  int fd;
		  void *a;
		  long n;

		  fd = va_arg(*arg, int);
		  a = va_arg(*arg, void*);
		  n = va_arg(*arg, long);
		  return read(fd, a, n);

	      ioread(Ioproc *io, int fd, void *a, long n)
		  return iocall(io, _ioread, fd, a, n);


       dial(2), open(2), read(2), thread(2)

                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Plan9

List of man pages available for Plan9

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net