9p: Documentation updates
[linux-2.6.git] / net / 9p / fcprint.c
1 /*
2  *  net/9p/fcprint.c
3  *
4  *  Print 9P call.
5  *
6  *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License version 2
10  *  as published by the Free Software Foundation.
11  *
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to:
19  *  Free Software Foundation
20  *  51 Franklin Street, Fifth Floor
21  *  Boston, MA  02111-1301  USA
22  *
23  */
24 #include <linux/module.h>
25 #include <linux/errno.h>
26 #include <linux/fs.h>
27 #include <linux/idr.h>
28 #include <net/9p/9p.h>
29
30 #ifdef CONFIG_NET_9P_DEBUG
31
32 static int
33 p9_printqid(char *buf, int buflen, struct p9_qid *q)
34 {
35         int n;
36         char b[10];
37
38         n = 0;
39         if (q->type & P9_QTDIR)
40                 b[n++] = 'd';
41         if (q->type & P9_QTAPPEND)
42                 b[n++] = 'a';
43         if (q->type & P9_QTAUTH)
44                 b[n++] = 'A';
45         if (q->type & P9_QTEXCL)
46                 b[n++] = 'l';
47         if (q->type & P9_QTTMP)
48                 b[n++] = 't';
49         if (q->type & P9_QTSYMLINK)
50                 b[n++] = 'L';
51         b[n] = '\0';
52
53         return scnprintf(buf, buflen, "(%.16llx %x %s)",
54                                         (long long int) q->path, q->version, b);
55 }
56
57 static int
58 p9_printperm(char *buf, int buflen, int perm)
59 {
60         int n;
61         char b[15];
62
63         n = 0;
64         if (perm & P9_DMDIR)
65                 b[n++] = 'd';
66         if (perm & P9_DMAPPEND)
67                 b[n++] = 'a';
68         if (perm & P9_DMAUTH)
69                 b[n++] = 'A';
70         if (perm & P9_DMEXCL)
71                 b[n++] = 'l';
72         if (perm & P9_DMTMP)
73                 b[n++] = 't';
74         if (perm & P9_DMDEVICE)
75                 b[n++] = 'D';
76         if (perm & P9_DMSOCKET)
77                 b[n++] = 'S';
78         if (perm & P9_DMNAMEDPIPE)
79                 b[n++] = 'P';
80         if (perm & P9_DMSYMLINK)
81                 b[n++] = 'L';
82         b[n] = '\0';
83
84         return scnprintf(buf, buflen, "%s%03o", b, perm&077);
85 }
86
87 static int
88 p9_printstat(char *buf, int buflen, struct p9_stat *st, int extended)
89 {
90         int n;
91
92         n = scnprintf(buf, buflen, "'%.*s' '%.*s'", st->name.len,
93                 st->name.str, st->uid.len, st->uid.str);
94         if (extended)
95                 n += scnprintf(buf+n, buflen-n, "(%d)", st->n_uid);
96
97         n += scnprintf(buf+n, buflen-n, " '%.*s'", st->gid.len, st->gid.str);
98         if (extended)
99                 n += scnprintf(buf+n, buflen-n, "(%d)", st->n_gid);
100
101         n += scnprintf(buf+n, buflen-n, " '%.*s'", st->muid.len, st->muid.str);
102         if (extended)
103                 n += scnprintf(buf+n, buflen-n, "(%d)", st->n_muid);
104
105         n += scnprintf(buf+n, buflen-n, " q ");
106         n += p9_printqid(buf+n, buflen-n, &st->qid);
107         n += scnprintf(buf+n, buflen-n, " m ");
108         n += p9_printperm(buf+n, buflen-n, st->mode);
109         n += scnprintf(buf+n, buflen-n, " at %d mt %d l %lld",
110                 st->atime, st->mtime, (long long int) st->length);
111
112         if (extended)
113                 n += scnprintf(buf+n, buflen-n, " ext '%.*s'",
114                         st->extension.len, st->extension.str);
115
116         return n;
117 }
118
119 static int
120 p9_dumpdata(char *buf, int buflen, u8 *data, int datalen)
121 {
122         int i, n;
123
124         i = n = 0;
125         while (i < datalen) {
126                 n += scnprintf(buf + n, buflen - n, "%02x", data[i]);
127                 if (i%4 == 3)
128                         n += scnprintf(buf + n, buflen - n, " ");
129                 if (i%32 == 31)
130                         n += scnprintf(buf + n, buflen - n, "\n");
131
132                 i++;
133         }
134         n += scnprintf(buf + n, buflen - n, "\n");
135
136         return n;
137 }
138
139 static int
140 p9_printdata(char *buf, int buflen, u8 *data, int datalen)
141 {
142         return p9_dumpdata(buf, buflen, data, datalen < 16?datalen:16);
143 }
144
145 /**
146  * p9_printfcall - decode and print a protocol structure into a buffer
147  * @buf: buffer to deposit decoded structure into
148  * @buflen: available space in buffer
149  * @fc: protocol rpc structure of type &p9_fcall
150  * @extended: whether or not session is operating with extended protocol
151  */
152
153 int
154 p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended)
155 {
156         int i, ret, type, tag;
157
158         if (!fc)
159                 return scnprintf(buf, buflen, "<NULL>");
160
161         type = fc->id;
162         tag = fc->tag;
163
164         ret = 0;
165         switch (type) {
166         case P9_TVERSION:
167                 ret += scnprintf(buf+ret, buflen-ret,
168                                 "Tversion tag %u msize %u version '%.*s'", tag,
169                                 fc->params.tversion.msize,
170                                 fc->params.tversion.version.len,
171                                 fc->params.tversion.version.str);
172                 break;
173
174         case P9_RVERSION:
175                 ret += scnprintf(buf+ret, buflen-ret,
176                                 "Rversion tag %u msize %u version '%.*s'", tag,
177                                 fc->params.rversion.msize,
178                                 fc->params.rversion.version.len,
179                                 fc->params.rversion.version.str);
180                 break;
181
182         case P9_TAUTH:
183                 ret += scnprintf(buf+ret, buflen-ret,
184                         "Tauth tag %u afid %d uname '%.*s' aname '%.*s'", tag,
185                         fc->params.tauth.afid, fc->params.tauth.uname.len,
186                         fc->params.tauth.uname.str, fc->params.tauth.aname.len,
187                         fc->params.tauth.aname.str);
188                 break;
189
190         case P9_RAUTH:
191                 ret += scnprintf(buf+ret, buflen-ret, "Rauth tag %u qid ", tag);
192                 p9_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid);
193                 break;
194
195         case P9_TATTACH:
196                 ret += scnprintf(buf+ret, buflen-ret,
197                  "Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'", tag,
198                  fc->params.tattach.fid, fc->params.tattach.afid,
199                  fc->params.tattach.uname.len, fc->params.tattach.uname.str,
200                  fc->params.tattach.aname.len, fc->params.tattach.aname.str);
201                 break;
202
203         case P9_RATTACH:
204                 ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ",
205                                                                         tag);
206                 p9_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid);
207                 break;
208
209         case P9_RERROR:
210                 ret += scnprintf(buf+ret, buflen-ret,
211                                 "Rerror tag %u ename '%.*s'", tag,
212                                 fc->params.rerror.error.len,
213                                 fc->params.rerror.error.str);
214                 if (extended)
215                         ret += scnprintf(buf+ret, buflen-ret, " ecode %d\n",
216                                 fc->params.rerror.errno);
217                 break;
218
219         case P9_TFLUSH:
220                 ret += scnprintf(buf+ret, buflen-ret, "Tflush tag %u oldtag %u",
221                         tag, fc->params.tflush.oldtag);
222                 break;
223
224         case P9_RFLUSH:
225                 ret += scnprintf(buf+ret, buflen-ret, "Rflush tag %u", tag);
226                 break;
227
228         case P9_TWALK:
229                 ret += scnprintf(buf+ret, buflen-ret,
230                         "Twalk tag %u fid %d newfid %d nwname %d", tag,
231                         fc->params.twalk.fid, fc->params.twalk.newfid,
232                         fc->params.twalk.nwname);
233                 for (i = 0; i < fc->params.twalk.nwname; i++)
234                         ret += scnprintf(buf+ret, buflen-ret, " '%.*s'",
235                                 fc->params.twalk.wnames[i].len,
236                                 fc->params.twalk.wnames[i].str);
237                 break;
238
239         case P9_RWALK:
240                 ret += scnprintf(buf+ret, buflen-ret, "Rwalk tag %u nwqid %d",
241                         tag, fc->params.rwalk.nwqid);
242                 for (i = 0; i < fc->params.rwalk.nwqid; i++)
243                         ret += p9_printqid(buf+ret, buflen-ret,
244                                 &fc->params.rwalk.wqids[i]);
245                 break;
246
247         case P9_TOPEN:
248                 ret += scnprintf(buf+ret, buflen-ret,
249                         "Topen tag %u fid %d mode %d", tag,
250                         fc->params.topen.fid, fc->params.topen.mode);
251                 break;
252
253         case P9_ROPEN:
254                 ret += scnprintf(buf+ret, buflen-ret, "Ropen tag %u", tag);
255                 ret += p9_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid);
256                 ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
257                         fc->params.ropen.iounit);
258                 break;
259
260         case P9_TCREATE:
261                 ret += scnprintf(buf+ret, buflen-ret,
262                         "Tcreate tag %u fid %d name '%.*s' perm ", tag,
263                         fc->params.tcreate.fid, fc->params.tcreate.name.len,
264                         fc->params.tcreate.name.str);
265
266                 ret += p9_printperm(buf+ret, buflen-ret,
267                                                 fc->params.tcreate.perm);
268                 ret += scnprintf(buf+ret, buflen-ret, " mode %d",
269                         fc->params.tcreate.mode);
270                 break;
271
272         case P9_RCREATE:
273                 ret += scnprintf(buf+ret, buflen-ret, "Rcreate tag %u", tag);
274                 ret += p9_printqid(buf+ret, buflen-ret,
275                                                 &fc->params.rcreate.qid);
276                 ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
277                         fc->params.rcreate.iounit);
278                 break;
279
280         case P9_TREAD:
281                 ret += scnprintf(buf+ret, buflen-ret,
282                         "Tread tag %u fid %d offset %lld count %u", tag,
283                         fc->params.tread.fid,
284                         (long long int) fc->params.tread.offset,
285                         fc->params.tread.count);
286                 break;
287
288         case P9_RREAD:
289                 ret += scnprintf(buf+ret, buflen-ret,
290                         "Rread tag %u count %u data ", tag,
291                         fc->params.rread.count);
292                 ret += p9_printdata(buf+ret, buflen-ret, fc->params.rread.data,
293                         fc->params.rread.count);
294                 break;
295
296         case P9_TWRITE:
297                 ret += scnprintf(buf+ret, buflen-ret,
298                         "Twrite tag %u fid %d offset %lld count %u data ",
299                         tag, fc->params.twrite.fid,
300                         (long long int) fc->params.twrite.offset,
301                         fc->params.twrite.count);
302                 ret += p9_printdata(buf+ret, buflen-ret, fc->params.twrite.data,
303                         fc->params.twrite.count);
304                 break;
305
306         case P9_RWRITE:
307                 ret += scnprintf(buf+ret, buflen-ret, "Rwrite tag %u count %u",
308                         tag, fc->params.rwrite.count);
309                 break;
310
311         case P9_TCLUNK:
312                 ret += scnprintf(buf+ret, buflen-ret, "Tclunk tag %u fid %d",
313                         tag, fc->params.tclunk.fid);
314                 break;
315
316         case P9_RCLUNK:
317                 ret += scnprintf(buf+ret, buflen-ret, "Rclunk tag %u", tag);
318                 break;
319
320         case P9_TREMOVE:
321                 ret += scnprintf(buf+ret, buflen-ret, "Tremove tag %u fid %d",
322                         tag, fc->params.tremove.fid);
323                 break;
324
325         case P9_RREMOVE:
326                 ret += scnprintf(buf+ret, buflen-ret, "Rremove tag %u", tag);
327                 break;
328
329         case P9_TSTAT:
330                 ret += scnprintf(buf+ret, buflen-ret, "Tstat tag %u fid %d",
331                         tag, fc->params.tstat.fid);
332                 break;
333
334         case P9_RSTAT:
335                 ret += scnprintf(buf+ret, buflen-ret, "Rstat tag %u ", tag);
336                 ret += p9_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat,
337                         extended);
338                 break;
339
340         case P9_TWSTAT:
341                 ret += scnprintf(buf+ret, buflen-ret, "Twstat tag %u fid %d ",
342                         tag, fc->params.twstat.fid);
343                 ret += p9_printstat(buf+ret, buflen-ret,
344                                         &fc->params.twstat.stat, extended);
345                 break;
346
347         case P9_RWSTAT:
348                 ret += scnprintf(buf+ret, buflen-ret, "Rwstat tag %u", tag);
349                 break;
350
351         default:
352                 ret += scnprintf(buf+ret, buflen-ret, "unknown type %d", type);
353                 break;
354         }
355
356         return ret;
357 }
358 #else
359 int
360 p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended)
361 {
362         return 0;
363 }
364 #endif /* CONFIG_NET_9P_DEBUG */
365 EXPORT_SYMBOL(p9_printfcall);
366