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