9p: rework client code to use new protocol support functions
[linux-2.6.git] / include / net / 9p / 9p.h
1 /*
2  * include/net/9p/9p.h
3  *
4  * 9P protocol definitions.
5  *
6  *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
7  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
8  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License version 2
12  *  as published by the Free Software Foundation.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to:
21  *  Free Software Foundation
22  *  51 Franklin Street, Fifth Floor
23  *  Boston, MA  02111-1301  USA
24  *
25  */
26
27 #ifndef NET_9P_H
28 #define NET_9P_H
29
30 #ifdef CONFIG_NET_9P_DEBUG
31
32 /**
33  * enum p9_debug_flags - bits for mount time debug parameter
34  * @P9_DEBUG_ERROR: more verbose error messages including original error string
35  * @P9_DEBUG_9P: 9P protocol tracing
36  * @P9_DEBUG_VFS: VFS API tracing
37  * @P9_DEBUG_CONV: protocol conversion tracing
38  * @P9_DEBUG_MUX: trace management of concurrent transactions
39  * @P9_DEBUG_TRANS: transport tracing
40  * @P9_DEBUG_SLABS: memory management tracing
41  * @P9_DEBUG_FCALL: verbose dump of protocol messages
42  * @P9_DEBUG_FID: fid allocation/deallocation tracking
43  *
44  * These flags are passed at mount time to turn on various levels of
45  * verbosity and tracing which will be output to the system logs.
46  */
47
48 enum p9_debug_flags {
49         P9_DEBUG_ERROR =        (1<<0),
50         P9_DEBUG_9P =           (1<<2),
51         P9_DEBUG_VFS =          (1<<3),
52         P9_DEBUG_CONV =         (1<<4),
53         P9_DEBUG_MUX =          (1<<5),
54         P9_DEBUG_TRANS =        (1<<6),
55         P9_DEBUG_SLABS =        (1<<7),
56         P9_DEBUG_FCALL =        (1<<8),
57         P9_DEBUG_FID =          (1<<9),
58 };
59
60 extern unsigned int p9_debug_level;
61
62 #define P9_DPRINTK(level, format, arg...) \
63 do {  \
64         if (level == P9_DEBUG_9P) \
65                 printk(KERN_NOTICE "(%8.8d) " \
66                 format , task_pid_nr(current) , ## arg); \
67         else if ((p9_debug_level & level) == level) \
68                 printk(KERN_NOTICE "-- %s (%d): " \
69                 format , __func__, task_pid_nr(current) , ## arg); \
70 } while (0)
71
72 #define PRINT_FCALL_ERROR(s, fcall) P9_DPRINTK(P9_DEBUG_ERROR,   \
73         "%s: %.*s\n", s, fcall?fcall->params.rerror.error.len:0, \
74         fcall?fcall->params.rerror.error.str:"");
75
76 #else
77 #define P9_DPRINTK(level, format, arg...)  do { } while (0)
78 #define PRINT_FCALL_ERROR(s, fcall) do { } while (0)
79 #endif
80
81 #define P9_EPRINTK(level, format, arg...) \
82 do { \
83         printk(level "9p: %s (%d): " \
84                 format , __func__, task_pid_nr(current), ## arg); \
85 } while (0)
86
87 /**
88  * enum p9_msg_t - 9P message types
89  * @P9_TVERSION: version handshake request
90  * @P9_RVERSION: version handshake response
91  * @P9_TAUTH: request to establish authentication channel
92  * @P9_RAUTH: response with authentication information
93  * @P9_TATTACH: establish user access to file service
94  * @P9_RATTACH: response with top level handle to file hierarchy
95  * @P9_TERROR: not used
96  * @P9_RERROR: response for any failed request
97  * @P9_TFLUSH: request to abort a previous request
98  * @P9_RFLUSH: response when previous request has been cancelled
99  * @P9_TWALK: descend a directory hierarchy
100  * @P9_RWALK: response with new handle for position within hierarchy
101  * @P9_TOPEN: prepare a handle for I/O on an existing file
102  * @P9_ROPEN: response with file access information
103  * @P9_TCREATE: prepare a handle for I/O on a new file
104  * @P9_RCREATE: response with file access information
105  * @P9_TREAD: request to transfer data from a file or directory
106  * @P9_RREAD: response with data requested
107  * @P9_TWRITE: reuqest to transfer data to a file
108  * @P9_RWRITE: response with out much data was transfered to file
109  * @P9_TCLUNK: forget about a handle to an entity within the file system
110  * @P9_RCLUNK: response when server has forgotten about the handle
111  * @P9_TREMOVE: request to remove an entity from the hierarchy
112  * @P9_RREMOVE: response when server has removed the entity
113  * @P9_TSTAT: request file entity attributes
114  * @P9_RSTAT: response with file entity attributes
115  * @P9_TWSTAT: request to update file entity attributes
116  * @P9_RWSTAT: response when file entity attributes are updated
117  *
118  * There are 14 basic operations in 9P2000, paired as
119  * requests and responses.  The one special case is ERROR
120  * as there is no @P9_TERROR request for clients to transmit to
121  * the server, but the server may respond to any other request
122  * with an @P9_RERROR.
123  *
124  * See Also: http://plan9.bell-labs.com/sys/man/5/INDEX.html
125  */
126
127 enum p9_msg_t {
128         P9_TVERSION = 100,
129         P9_RVERSION,
130         P9_TAUTH = 102,
131         P9_RAUTH,
132         P9_TATTACH = 104,
133         P9_RATTACH,
134         P9_TERROR = 106,
135         P9_RERROR,
136         P9_TFLUSH = 108,
137         P9_RFLUSH,
138         P9_TWALK = 110,
139         P9_RWALK,
140         P9_TOPEN = 112,
141         P9_ROPEN,
142         P9_TCREATE = 114,
143         P9_RCREATE,
144         P9_TREAD = 116,
145         P9_RREAD,
146         P9_TWRITE = 118,
147         P9_RWRITE,
148         P9_TCLUNK = 120,
149         P9_RCLUNK,
150         P9_TREMOVE = 122,
151         P9_RREMOVE,
152         P9_TSTAT = 124,
153         P9_RSTAT,
154         P9_TWSTAT = 126,
155         P9_RWSTAT,
156 };
157
158 /**
159  * enum p9_open_mode_t - 9P open modes
160  * @P9_OREAD: open file for reading only
161  * @P9_OWRITE: open file for writing only
162  * @P9_ORDWR: open file for reading or writing
163  * @P9_OEXEC: open file for execution
164  * @P9_OTRUNC: truncate file to zero-length before opening it
165  * @P9_OREXEC: close the file when an exec(2) system call is made
166  * @P9_ORCLOSE: remove the file when the file is closed
167  * @P9_OAPPEND: open the file and seek to the end
168  * @P9_OEXCL: only create a file, do not open it
169  *
170  * 9P open modes differ slightly from Posix standard modes.
171  * In particular, there are extra modes which specify different
172  * semantic behaviors than may be available on standard Posix
173  * systems.  For example, @P9_OREXEC and @P9_ORCLOSE are modes that
174  * most likely will not be issued from the Linux VFS client, but may
175  * be supported by servers.
176  *
177  * See Also: http://plan9.bell-labs.com/magic/man2html/2/open
178  */
179
180 enum p9_open_mode_t {
181         P9_OREAD = 0x00,
182         P9_OWRITE = 0x01,
183         P9_ORDWR = 0x02,
184         P9_OEXEC = 0x03,
185         P9_OTRUNC = 0x10,
186         P9_OREXEC = 0x20,
187         P9_ORCLOSE = 0x40,
188         P9_OAPPEND = 0x80,
189         P9_OEXCL = 0x1000,
190 };
191
192 /**
193  * enum p9_perm_t - 9P permissions
194  * @P9_DMDIR: mode bite for directories
195  * @P9_DMAPPEND: mode bit for is append-only
196  * @P9_DMEXCL: mode bit for excluse use (only one open handle allowed)
197  * @P9_DMMOUNT: mode bite for mount points
198  * @P9_DMAUTH: mode bit for authentication file
199  * @P9_DMTMP: mode bit for non-backed-up files
200  * @P9_DMSYMLINK: mode bit for symbolic links (9P2000.u)
201  * @P9_DMLINK: mode bit for hard-link (9P2000.u)
202  * @P9_DMDEVICE: mode bit for device files (9P2000.u)
203  * @P9_DMNAMEDPIPE: mode bit for named pipe (9P2000.u)
204  * @P9_DMSOCKET: mode bit for socket (9P2000.u)
205  * @P9_DMSETUID: mode bit for setuid (9P2000.u)
206  * @P9_DMSETGID: mode bit for setgid (9P2000.u)
207  * @P9_DMSETVTX: mode bit for sticky bit (9P2000.u)
208  *
209  * 9P permissions differ slightly from Posix standard modes.
210  *
211  * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat
212  */
213 enum p9_perm_t {
214         P9_DMDIR = 0x80000000,
215         P9_DMAPPEND = 0x40000000,
216         P9_DMEXCL = 0x20000000,
217         P9_DMMOUNT = 0x10000000,
218         P9_DMAUTH = 0x08000000,
219         P9_DMTMP = 0x04000000,
220 /* 9P2000.u extensions */
221         P9_DMSYMLINK = 0x02000000,
222         P9_DMLINK = 0x01000000,
223         P9_DMDEVICE = 0x00800000,
224         P9_DMNAMEDPIPE = 0x00200000,
225         P9_DMSOCKET = 0x00100000,
226         P9_DMSETUID = 0x00080000,
227         P9_DMSETGID = 0x00040000,
228         P9_DMSETVTX = 0x00010000,
229 };
230
231 /**
232  * enum p9_qid_t - QID types
233  * @P9_QTDIR: directory
234  * @P9_QTAPPEND: append-only
235  * @P9_QTEXCL: excluse use (only one open handle allowed)
236  * @P9_QTMOUNT: mount points
237  * @P9_QTAUTH: authentication file
238  * @P9_QTTMP: non-backed-up files
239  * @P9_QTSYMLINK: symbolic links (9P2000.u)
240  * @P9_QTLINK: hard-link (9P2000.u)
241  * @P9_QTFILE: normal files
242  *
243  * QID types are a subset of permissions - they are primarily
244  * used to differentiate semantics for a file system entity via
245  * a jump-table.  Their value is also the most signifigant 16 bits
246  * of the permission_t
247  *
248  * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat
249  */
250 enum p9_qid_t {
251         P9_QTDIR = 0x80,
252         P9_QTAPPEND = 0x40,
253         P9_QTEXCL = 0x20,
254         P9_QTMOUNT = 0x10,
255         P9_QTAUTH = 0x08,
256         P9_QTTMP = 0x04,
257         P9_QTSYMLINK = 0x02,
258         P9_QTLINK = 0x01,
259         P9_QTFILE = 0x00,
260 };
261
262 /* 9P Magic Numbers */
263 #define P9_NOTAG        (u16)(~0)
264 #define P9_NOFID        (u32)(~0)
265 #define P9_MAXWELEM     16
266
267 /* ample room for Twrite/Rread header */
268 #define P9_IOHDRSZ      24
269
270 /**
271  * struct p9_str - length prefixed string type
272  * @len: length of the string
273  * @str: the string
274  *
275  * The protocol uses length prefixed strings for all
276  * string data, so we replicate that for our internal
277  * string members.
278  */
279
280 struct p9_str {
281         u16 len;
282         char *str;
283 };
284
285 /**
286  * struct p9_qid - file system entity information
287  * @type: 8-bit type &p9_qid_t
288  * @version: 16-bit monotonically incrementing version number
289  * @path: 64-bit per-server-unique ID for a file system element
290  *
291  * qids are identifiers used by 9P servers to track file system
292  * entities.  The type is used to differentiate semantics for operations
293  * on the entity (ie. read means something different on a directory than
294  * on a file).  The path provides a server unique index for an entity
295  * (roughly analogous to an inode number), while the version is updated
296  * every time a file is modified and can be used to maintain cache
297  * coherency between clients and serves.
298  * Servers will often differentiate purely synthetic entities by setting
299  * their version to 0, signaling that they should never be cached and
300  * should be accessed synchronously.
301  *
302  * See Also://plan9.bell-labs.com/magic/man2html/2/stat
303  */
304
305 struct p9_qid {
306         u8 type;
307         u32 version;
308         u64 path;
309 };
310
311 /**
312  * struct p9_stat - file system metadata information
313  * @size: length prefix for this stat structure instance
314  * @type: the type of the server (equivilent to a major number)
315  * @dev: the sub-type of the server (equivilent to a minor number)
316  * @qid: unique id from the server of type &p9_qid
317  * @mode: Plan 9 format permissions of type &p9_perm_t
318  * @atime: Last access/read time
319  * @mtime: Last modify/write time
320  * @length: file length
321  * @name: last element of path (aka filename) in type &p9_str
322  * @uid: owner name in type &p9_str
323  * @gid: group owner in type &p9_str
324  * @muid: last modifier in type &p9_str
325  * @extension: area used to encode extended UNIX support in type &p9_str
326  * @n_uid: numeric user id of owner (part of 9p2000.u extension)
327  * @n_gid: numeric group id (part of 9p2000.u extension)
328  * @n_muid: numeric user id of laster modifier (part of 9p2000.u extension)
329  *
330  * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat
331  */
332
333 struct p9_stat {
334         u16 size;
335         u16 type;
336         u32 dev;
337         struct p9_qid qid;
338         u32 mode;
339         u32 atime;
340         u32 mtime;
341         u64 length;
342         struct p9_str name;
343         struct p9_str uid;
344         struct p9_str gid;
345         struct p9_str muid;
346         struct p9_str extension;        /* 9p2000.u extensions */
347         u32 n_uid;                      /* 9p2000.u extensions */
348         u32 n_gid;                      /* 9p2000.u extensions */
349         u32 n_muid;                     /* 9p2000.u extensions */
350 };
351
352 /*
353  * file metadata (stat) structure used to create Twstat message
354  * The is identical to &p9_stat, but the strings don't point to
355  * the same memory block and should be freed separately
356  *
357  * See Also: http://plan9.bell-labs.com/magic/man2html/2/stat
358  */
359
360 struct p9_wstat {
361         u16 size;
362         u16 type;
363         u32 dev;
364         struct p9_qid qid;
365         u32 mode;
366         u32 atime;
367         u32 mtime;
368         u64 length;
369         char *name;
370         char *uid;
371         char *gid;
372         char *muid;
373         char *extension;        /* 9p2000.u extensions */
374         u32 n_uid;              /* 9p2000.u extensions */
375         u32 n_gid;              /* 9p2000.u extensions */
376         u32 n_muid;             /* 9p2000.u extensions */
377 };
378
379 /* Structures for Protocol Operations */
380 struct p9_tversion {
381         u32 msize;
382         struct p9_str version;
383 };
384
385 struct p9_rversion {
386         u32 msize;
387         struct p9_str version;
388 };
389
390 struct p9_tauth {
391         u32 afid;
392         struct p9_str uname;
393         struct p9_str aname;
394         u32 n_uname;            /* 9P2000.u extensions */
395 };
396
397 struct p9_rauth {
398         struct p9_qid qid;
399 };
400
401 struct p9_rerror {
402         struct p9_str error;
403         u32 errno;              /* 9p2000.u extension */
404 };
405
406 struct p9_tflush {
407         u16 oldtag;
408 };
409
410 struct p9_rflush {
411 };
412
413 struct p9_tattach {
414         u32 fid;
415         u32 afid;
416         struct p9_str uname;
417         struct p9_str aname;
418         u32 n_uname;            /* 9P2000.u extensions */
419 };
420
421 struct p9_rattach {
422         struct p9_qid qid;
423 };
424
425 struct p9_twalk {
426         u32 fid;
427         u32 newfid;
428         u16 nwname;
429         struct p9_str wnames[16];
430 };
431
432 struct p9_rwalk {
433         u16 nwqid;
434         struct p9_qid wqids[16];
435 };
436
437 struct p9_topen {
438         u32 fid;
439         u8 mode;
440 };
441
442 struct p9_ropen {
443         struct p9_qid qid;
444         u32 iounit;
445 };
446
447 struct p9_tcreate {
448         u32 fid;
449         struct p9_str name;
450         u32 perm;
451         u8 mode;
452         struct p9_str extension;
453 };
454
455 struct p9_rcreate {
456         struct p9_qid qid;
457         u32 iounit;
458 };
459
460 struct p9_tread {
461         u32 fid;
462         u64 offset;
463         u32 count;
464 };
465
466 struct p9_rread {
467         u32 count;
468         u8 *data;
469 };
470
471 struct p9_twrite {
472         u32 fid;
473         u64 offset;
474         u32 count;
475         u8 *data;
476 };
477
478 struct p9_rwrite {
479         u32 count;
480 };
481
482 struct p9_tclunk {
483         u32 fid;
484 };
485
486 struct p9_rclunk {
487 };
488
489 struct p9_tremove {
490         u32 fid;
491 };
492
493 struct p9_rremove {
494 };
495
496 struct p9_tstat {
497         u32 fid;
498 };
499
500 struct p9_rstat {
501         struct p9_stat stat;
502 };
503
504 struct p9_twstat {
505         u32 fid;
506         struct p9_stat stat;
507 };
508
509 struct p9_rwstat {
510 };
511
512 /**
513  * struct p9_fcall - primary packet structure
514  * @size: prefixed length of the structure
515  * @id: protocol operating identifier of type &p9_msg_t
516  * @tag: transaction id of the request
517  * @offset: used by marshalling routines to track currentposition in buffer
518  * @capacity: used by marshalling routines to track total capacity
519  * @sdata: payload
520  * @params: per-operation parameters
521  *
522  * &p9_fcall represents the structure for all 9P RPC
523  * transactions.  Requests are packaged into fcalls, and reponses
524  * must be extracted from them.
525  *
526  * See Also: http://plan9.bell-labs.com/magic/man2html/2/fcall
527  */
528
529 struct p9_fcall {
530         u32 size;
531         u8 id;
532         u16 tag;
533
534         size_t offset;
535         size_t capacity;
536
537         uint8_t *sdata;
538
539         union {
540                 struct p9_tversion tversion;
541                 struct p9_rversion rversion;
542                 struct p9_tauth tauth;
543                 struct p9_rauth rauth;
544                 struct p9_rerror rerror;
545                 struct p9_tflush tflush;
546                 struct p9_rflush rflush;
547                 struct p9_tattach tattach;
548                 struct p9_rattach rattach;
549                 struct p9_twalk twalk;
550                 struct p9_rwalk rwalk;
551                 struct p9_topen topen;
552                 struct p9_ropen ropen;
553                 struct p9_tcreate tcreate;
554                 struct p9_rcreate rcreate;
555                 struct p9_tread tread;
556                 struct p9_rread rread;
557                 struct p9_twrite twrite;
558                 struct p9_rwrite rwrite;
559                 struct p9_tclunk tclunk;
560                 struct p9_rclunk rclunk;
561                 struct p9_tremove tremove;
562                 struct p9_rremove rremove;
563                 struct p9_tstat tstat;
564                 struct p9_rstat rstat;
565                 struct p9_twstat twstat;
566                 struct p9_rwstat rwstat;
567         } params;
568 };
569
570 struct p9_idpool;
571
572 int p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat,
573         int dotu);
574 int p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *fc, int dotu);
575 void p9_set_tag(struct p9_fcall *fc, u16 tag);
576 struct p9_fcall *p9_create_tversion(u32 msize, char *version);
577 struct p9_fcall *p9_create_tattach(u32 fid, u32 afid, char *uname,
578         char *aname, u32 n_uname, int dotu);
579 struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname,
580         u32 n_uname, int dotu);
581 struct p9_fcall *p9_create_tflush(u16 oldtag);
582 struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname,
583         char **wnames);
584 struct p9_fcall *p9_create_topen(u32 fid, u8 mode);
585 struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
586         char *extension, int dotu);
587 struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count);
588 struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count,
589         const char *data);
590 struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count,
591         const char __user *data);
592 struct p9_fcall *p9_create_tclunk(u32 fid);
593 struct p9_fcall *p9_create_tremove(u32 fid);
594 struct p9_fcall *p9_create_tstat(u32 fid);
595 struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat,
596         int dotu);
597
598 int p9_errstr2errno(char *errstr, int len);
599
600 struct p9_idpool *p9_idpool_create(void);
601 void p9_idpool_destroy(struct p9_idpool *);
602 int p9_idpool_get(struct p9_idpool *p);
603 void p9_idpool_put(int id, struct p9_idpool *p);
604 int p9_idpool_check(int id, struct p9_idpool *p);
605
606 int p9_error_init(void);
607 int p9_errstr2errno(char *, int);
608 int p9_trans_fd_init(void);
609 void p9_trans_fd_exit(void);
610 #endif /* NET_9P_H */