sys/src/cmd/cwfs/net.c

   1 /* network i/o */
   2
   3 #include "all.h"
   4 #include "io.h"
   5
   6 /*
   7  * the kernel file server read packets directly from
   8  * its ethernet(s) and did all the protocol processing.
   9  * if the incoming packets were 9p (over il/ip), they
  10  * were queued for the server processes to operate upon.
  11  *
  12  * in user mode, we have one process per incoming connection
  13  * instead, and those processes get just the data, minus
  14  * tcp and ip headers, so they just see a stream of 9p messages,
  15  * which they then queue for the server processes.
  16  *
  17  * there used to be more queueing (in the kernel), with separate
  18  * processes for ethernet input, il input, 9p processing, il output
  19  * and ethernet output, and queues connecting them.  we now let
  20  * the kernel's network queues, protocol stacks and processes do
  21  * much of this work.
  22  *
  23  * partly as a result of this, we can now process 9p messages
  24  * transported via tcp, exploit multiple x86 processors, and
  25  * were able to shed 70% of the file server's source, by line count.
  26  *
  27  * the upshot is that Ether (now Network) is no longer a perfect fit for
  28  * the way network i/o is done now.  the notion of `connection'
  29  * is being introduced to complement it.
  30  */
  31
  32 typedef struct Network Network;
  33
  34 /* a network, not necessarily an ethernet */
  35 struct Network {
  36         int     ctlrno;
  37         char    name[NAMELEN];
  38
  39         char    *dialstr;
  40         char    anndir[40];
  41         char    lisdir[40];
  42         int     annfd;                  /* fd from announce */
  43 };
  44
  45 static Network netif[Maxnets];
  46
  47 char *annstrs[Maxnets] = {
  48         "tcp!*!9fs",
  49 };
  50
  51 static void
  52 neti(void *v)
  53 {
  54         int lisfd, accfd;
  55         Network *net;
  56         NetConnInfo *nci;
  57
  58         net = v;
  59         print("net%di\n", net->ctlrno);
  60         for(;;) {
  61                 lisfd = listen(net->anndir, net->lisdir);
  62                 if (lisfd < 0) {
  63                         print("listen %s failed: %r\n", net->anndir);
  64                         continue;
  65                 }
  66
  67                 /* got new call on lisfd */
  68                 accfd = accept(lisfd, net->lisdir);
  69                 if (accfd < 0) {
  70                         print("accept %d (from %s) failed: %r\n",
  71                                 lisfd, net->lisdir);
  72                         continue;
  73                 }
  74
  75                 nci = getnetconninfo(net->lisdir, accfd);
  76                 srvchan(accfd, nci->raddr);
  77                 freenetconninfo(nci);
  78                 close(lisfd);
  79         }
  80 }
  81
  82 void
  83 netstart(void)
  84 {
  85         Network *net;
  86
  87         for(net = &netif[0]; net < &netif[Maxnets]; net++){
  88                 if(net->dialstr == nil)
  89                         continue;
  90                 sprint(net->name, "net%di", net->ctlrno);
  91                 newproc(neti, net, net->name);
  92         }
  93 }
  94
  95 void
  96 netinit(void)
  97 {
  98         Network *net;
  99
 100         for (net = netif; net < netif + Maxnets; net++) {
 101                 net->dialstr = annstrs[net - netif];
 102                 if (net->dialstr == nil)
 103                         continue;
 104                 net->annfd = announce(net->dialstr, net->anndir);
 105                 /* /bin/service/tcp564 may already have grabbed the port */
 106                 if (net->annfd < 0)
 107                         sysfatal("can't announce %s: %r", net->dialstr);
 108                 print("netinit: announced on %s\n", net->dialstr);
 109         }
 110 }