diff options
Diffstat (limited to 'net/9p/fcprint.c')
-rw-r--r-- | net/9p/fcprint.c | 366 |
1 files changed, 0 insertions, 366 deletions
diff --git a/net/9p/fcprint.c b/net/9p/fcprint.c deleted file mode 100644 index 53dd8e28dd8a..000000000000 --- a/net/9p/fcprint.c +++ /dev/null | |||
@@ -1,366 +0,0 @@ | |||
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 | |||