sys/include/9p.h

   1 #pragma src "/sys/src/lib9p"
   2 #pragma lib "lib9p.a"
   3
   4 /*
   5  * Maps from ulongs to void*s.
   6  */
   7 typedef struct Intmap   Intmap;
   8
   9 #pragma incomplete Intmap
  10
  11 Intmap* allocmap(void (*inc)(void*));
  12 void            freemap(Intmap*, void (*destroy)(void*));
  13 void*   lookupkey(Intmap*, ulong);
  14 void*   insertkey(Intmap*, ulong, void*);
  15 int             caninsertkey(Intmap*, ulong, void*);
  16 void*   deletekey(Intmap*, ulong);
  17
  18 /*
  19  * Fid and Request structures.
  20  */
  21 typedef struct Fid              Fid;
  22 typedef struct Req              Req;
  23 typedef struct Fidpool  Fidpool;
  24 typedef struct Reqpool  Reqpool;
  25 typedef struct File             File;
  26 typedef struct Filelist Filelist;
  27 typedef struct Tree             Tree;
  28 typedef struct Readdir  Readdir;
  29 typedef struct Srv Srv;
  30 typedef struct Reqqueue Reqqueue;
  31 typedef struct Queueelem Queueelem;
  32
  33 #pragma incomplete Filelist
  34 #pragma incomplete Readdir
  35
  36 struct Queueelem
  37 {
  38         Queueelem *prev, *next;
  39         void (*f)(Req *);
  40 };
  41
  42 struct Reqqueue
  43 {
  44         QLock;
  45         Rendez;
  46         Queueelem;
  47         int pid;
  48         Req *cur;
  49 };
  50
  51 struct Fid
  52 {
  53         ulong   fid;
  54         char            omode;  /* -1 = not open */
  55         File*           file;
  56         char*   uid;
  57         Qid             qid;
  58         void*   aux;
  59
  60 /* below is implementation-specific; don't use */
  61         Readdir*        rdir;
  62         Ref             ref;
  63         Fidpool*        pool;
  64         vlong   diroffset;
  65         long            dirindex;
  66 };
  67
  68 struct Req
  69 {
  70         ulong   tag;
  71         void*   aux;
  72         Fcall           ifcall;
  73         Fcall           ofcall;
  74         Dir             d;
  75         Req*            oldreq;
  76         Fid*            fid;
  77         Fid*            afid;
  78         Fid*            newfid;
  79         Srv*            srv;
  80
  81         Queueelem qu;
  82
  83 /* below is implementation-specific; don't use */
  84         QLock   lk;
  85         Ref             ref;
  86         Reqpool*        pool;
  87         uchar*  buf;
  88         uchar   type;
  89         uchar   responded;
  90         char*   error;
  91         void*   rbuf;
  92         Req**   flush;
  93         int             nflush;
  94 };
  95
  96 /*
  97  * Pools to maintain Fid <-> fid and Req <-> tag maps.
  98  */
  99
 100 struct Fidpool {
 101         Intmap  *map;
 102         void            (*destroy)(Fid*);
 103         Srv             *srv;
 104 };
 105
 106 struct Reqpool {
 107         Intmap  *map;
 108         void            (*destroy)(Req*);
 109         Srv             *srv;
 110 };
 111
 112 Fidpool*        allocfidpool(void (*destroy)(Fid*));
 113 void            freefidpool(Fidpool*);
 114 Fid*            allocfid(Fidpool*, ulong);
 115 Fid*            lookupfid(Fidpool*, ulong);
 116 void            closefid(Fid*);
 117 Fid*            removefid(Fidpool*, ulong);
 118
 119 Reqpool*        allocreqpool(void (*destroy)(Req*));
 120 void            freereqpool(Reqpool*);
 121 Req*            allocreq(Reqpool*, ulong);
 122 Req*            lookupreq(Reqpool*, ulong);
 123 void            closereq(Req*);
 124 Req*            removereq(Reqpool*, ulong);
 125
 126 typedef int     Dirgen(int, Dir*, void*);
 127 void            dirread9p(Req*, Dirgen*, void*);
 128
 129 /*
 130  * File trees.
 131  */
 132 struct File {
 133         Ref;
 134         Dir;
 135         File *parent;
 136         void *aux;
 137
 138 /* below is implementation-specific; don't use */
 139         RWLock;
 140         Filelist *filelist;
 141         Tree *tree;
 142         int nchild;
 143         int allocd;
 144         int nxchild;
 145         Ref readers;
 146 };
 147
 148 struct Tree {
 149         File *root;
 150         void    (*destroy)(File *file);
 151
 152 /* below is implementation-specific; don't use */
 153         Lock genlock;
 154         ulong qidgen;
 155         ulong dirqidgen;
 156 };
 157
 158 Tree*   alloctree(char*, char*, ulong, void(*destroy)(File*));
 159 void            freetree(Tree*);
 160 File*           createfile(File*, char*, char*, ulong, void*);
 161 int             removefile(File*);
 162 void            closefile(File*);
 163 File*           walkfile(File*, char*);
 164 Readdir*        opendirfile(File*);
 165 long            readdirfile(Readdir*, uchar*, long);
 166 void            closedirfile(Readdir*);
 167
 168 /*
 169  * Kernel-style command parser
 170  */
 171 typedef struct Cmdbuf Cmdbuf;
 172 typedef struct Cmdtab Cmdtab;
 173 Cmdbuf*         parsecmd(char *a, int n);
 174 void            respondcmderror(Req*, Cmdbuf*, char*, ...);
 175 Cmdtab* lookupcmd(Cmdbuf*, Cmdtab*, int);
 176 #pragma varargck argpos respondcmderr 3
 177 struct Cmdbuf
 178 {
 179         char    *buf;
 180         char    **f;
 181         int     nf;
 182 };
 183
 184 struct Cmdtab
 185 {
 186         int     index;  /* used by client to switch on result */
 187         char    *cmd;   /* command name */
 188         int     narg;   /* expected #args; 0 ==> variadic */
 189 };
 190
 191 /*
 192  * File service loop.
 193  */
 194 struct Srv {
 195         Tree*   tree;
 196         void            (*destroyfid)(Fid*);
 197         void            (*destroyreq)(Req*);
 198         void            (*end)(Srv*);
 199         void*   aux;
 200
 201         void            (*attach)(Req*);
 202         void            (*auth)(Req*);
 203         void            (*open)(Req*);
 204         void            (*create)(Req*);
 205         void            (*read)(Req*);
 206         void            (*write)(Req*);
 207         void            (*remove)(Req*);
 208         void            (*flush)(Req*);
 209         void            (*stat)(Req*);
 210         void            (*wstat)(Req*);
 211         void            (*walk)(Req*);
 212         char*   (*clone)(Fid*, Fid*);
 213         char*   (*walk1)(Fid*, char*, Qid*);
 214
 215         int             infd;
 216         int             outfd;
 217         int             nopipe;
 218         int             srvfd;
 219         int             leavefdsopen;   /* magic for acme win */
 220         char*   keyspec;
 221
 222 /* below is implementation-specific; don't use */
 223         Fidpool*        fpool;
 224         Reqpool*        rpool;
 225         uint            msize;
 226
 227         uchar*  rbuf;
 228         QLock   rlock;
 229         uchar*  wbuf;
 230         QLock   wlock;
 231
 232         char*   addr;
 233
 234         QLock   slock;
 235         Ref     sref;
 236 };
 237
 238 void            srv(Srv*);
 239 void            postmountsrv(Srv*, char*, char*, int);
 240 void            _postmountsrv(Srv*, char*, char*, int);
 241 void            postsharesrv(Srv*, char*, char*, char*);
 242 void            _postsharesrv(Srv*, char*, char*, char*);
 243 void            listensrv(Srv*, char*);
 244 void            _listensrv(Srv*, char*);
 245 int             postfd(char*, int);
 246 int             sharefd(char*, char*, int);
 247 int             chatty9p;
 248 void            respond(Req*, char*);
 249 void            responderror(Req*);
 250 void            threadpostmountsrv(Srv*, char*, char*, int);
 251 void            threadpostsharesrv(Srv*, char*, char*, char*);
 252 void            threadlistensrv(Srv *s, char *addr);
 253
 254 /*
 255  * Helper.  Assumes user is same as group.
 256  */
 257 int             hasperm(File*, char*, int);
 258
 259 void*   emalloc9p(ulong);
 260 void*   erealloc9p(void*, ulong);
 261 char*   estrdup9p(char*);
 262
 263 enum {
 264         OMASK = 3
 265 };
 266
 267 void            readstr(Req*, char*);
 268 void            readbuf(Req*, void*, long);
 269 void            walkandclone(Req*, char*(*walk1)(Fid*,char*,void*),
 270                         char*(*clone)(Fid*,Fid*,void*), void*);
 271
 272 void            auth9p(Req*);
 273 void            authread(Req*);
 274 void            authwrite(Req*);
 275 void            authdestroy(Fid*);
 276 int             authattach(Req*);
 277
 278 extern void (*_forker)(void (*)(void*), void*, int);
 279
 280 void            srvacquire(Srv *);
 281 void            srvrelease(Srv *);
 282
 283 Reqqueue*       reqqueuecreate(void);
 284 void            reqqueuepush(Reqqueue*, Req*, void (*)(Req *));
 285 void            reqqueueflush(Reqqueue*, Req*);
 286 int             reqqueueflushed(void);