OpenCores
URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [net/] [9p/] [fcprint.c] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 3 xianfeng 
/*
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 
int
146 
p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended)
147 
{
148 
        int i, ret, type, tag;
149 
 
150 
        if (!fc)
151 
                return scnprintf(buf, buflen, "<NULL>");
152 
 
153 
        type = fc->id;
154 
        tag = fc->tag;
155 
 
156 
        ret = 0;
157 
        switch (type) {
158 
        case P9_TVERSION:
159 
                ret += scnprintf(buf+ret, buflen-ret,
160 
                                "Tversion tag %u msize %u version '%.*s'", tag,
161 
                                fc->params.tversion.msize,
162 
                                fc->params.tversion.version.len,
163 
                                fc->params.tversion.version.str);
164 
                break;
165 
 
166 
        case P9_RVERSION:
167 
                ret += scnprintf(buf+ret, buflen-ret,
168 
                                "Rversion tag %u msize %u version '%.*s'", tag,
169 
                                fc->params.rversion.msize,
170 
                                fc->params.rversion.version.len,
171 
                                fc->params.rversion.version.str);
172 
                break;
173 
 
174 
        case P9_TAUTH:
175 
                ret += scnprintf(buf+ret, buflen-ret,
176 
                        "Tauth tag %u afid %d uname '%.*s' aname '%.*s'", tag,
177 
                        fc->params.tauth.afid, fc->params.tauth.uname.len,
178 
                        fc->params.tauth.uname.str, fc->params.tauth.aname.len,
179 
                        fc->params.tauth.aname.str);
180 
                break;
181 
 
182 
        case P9_RAUTH:
183 
                ret += scnprintf(buf+ret, buflen-ret, "Rauth tag %u qid ", tag);
184 
                p9_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid);
185 
                break;
186 
 
187 
        case P9_TATTACH:
188 
                ret += scnprintf(buf+ret, buflen-ret,
189 
                 "Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'", tag,
190 
                 fc->params.tattach.fid, fc->params.tattach.afid,
191 
                 fc->params.tattach.uname.len, fc->params.tattach.uname.str,
192 
                 fc->params.tattach.aname.len, fc->params.tattach.aname.str);
193 
                break;
194 
 
195 
        case P9_RATTACH:
196 
                ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ",
197 
                                                                        tag);
198 
                p9_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid);
199 
                break;
200 
 
201 
        case P9_RERROR:
202 
                ret += scnprintf(buf+ret, buflen-ret,
203 
                                "Rerror tag %u ename '%.*s'", tag,
204 
                                fc->params.rerror.error.len,
205 
                                fc->params.rerror.error.str);
206 
                if (extended)
207 
                        ret += scnprintf(buf+ret, buflen-ret, " ecode %d\n",
208 
                                fc->params.rerror.errno);
209 
                break;
210 
 
211 
        case P9_TFLUSH:
212 
                ret += scnprintf(buf+ret, buflen-ret, "Tflush tag %u oldtag %u",
213 
                        tag, fc->params.tflush.oldtag);
214 
                break;
215 
 
216 
        case P9_RFLUSH:
217 
                ret += scnprintf(buf+ret, buflen-ret, "Rflush tag %u", tag);
218 
                break;
219 
 
220 
        case P9_TWALK:
221 
                ret += scnprintf(buf+ret, buflen-ret,
222 
                        "Twalk tag %u fid %d newfid %d nwname %d", tag,
223 
                        fc->params.twalk.fid, fc->params.twalk.newfid,
224 
                        fc->params.twalk.nwname);
225 
                for (i = 0; i < fc->params.twalk.nwname; i++)
226 
                        ret += scnprintf(buf+ret, buflen-ret, " '%.*s'",
227 
                                fc->params.twalk.wnames[i].len,
228 
                                fc->params.twalk.wnames[i].str);
229 
                break;
230 
 
231 
        case P9_RWALK:
232 
                ret += scnprintf(buf+ret, buflen-ret, "Rwalk tag %u nwqid %d",
233 
                        tag, fc->params.rwalk.nwqid);
234 
                for (i = 0; i < fc->params.rwalk.nwqid; i++)
235 
                        ret += p9_printqid(buf+ret, buflen-ret,
236 
                                &fc->params.rwalk.wqids[i]);
237 
                break;
238 
 
239 
        case P9_TOPEN:
240 
                ret += scnprintf(buf+ret, buflen-ret,
241 
                        "Topen tag %u fid %d mode %d", tag,
242 
                        fc->params.topen.fid, fc->params.topen.mode);
243 
                break;
244 
 
245 
        case P9_ROPEN:
246 
                ret += scnprintf(buf+ret, buflen-ret, "Ropen tag %u", tag);
247 
                ret += p9_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid);
248 
                ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
249 
                        fc->params.ropen.iounit);
250 
                break;
251 
 
252 
        case P9_TCREATE:
253 
                ret += scnprintf(buf+ret, buflen-ret,
254 
                        "Tcreate tag %u fid %d name '%.*s' perm ", tag,
255 
                        fc->params.tcreate.fid, fc->params.tcreate.name.len,
256 
                        fc->params.tcreate.name.str);
257 
 
258 
                ret += p9_printperm(buf+ret, buflen-ret,
259 
                                                fc->params.tcreate.perm);
260 
                ret += scnprintf(buf+ret, buflen-ret, " mode %d",
261 
                        fc->params.tcreate.mode);
262 
                break;
263 
 
264 
        case P9_RCREATE:
265 
                ret += scnprintf(buf+ret, buflen-ret, "Rcreate tag %u", tag);
266 
                ret += p9_printqid(buf+ret, buflen-ret,
267 
                                                &fc->params.rcreate.qid);
268 
                ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
269 
                        fc->params.rcreate.iounit);
270 
                break;
271 
 
272 
        case P9_TREAD:
273 
                ret += scnprintf(buf+ret, buflen-ret,
274 
                        "Tread tag %u fid %d offset %lld count %u", tag,
275 
                        fc->params.tread.fid,
276 
                        (long long int) fc->params.tread.offset,
277 
                        fc->params.tread.count);
278 
                break;
279 
 
280 
        case P9_RREAD:
281 
                ret += scnprintf(buf+ret, buflen-ret,
282 
                        "Rread tag %u count %u data ", tag,
283 
                        fc->params.rread.count);
284 
                ret += p9_printdata(buf+ret, buflen-ret, fc->params.rread.data,
285 
                        fc->params.rread.count);
286 
                break;
287 
 
288 
        case P9_TWRITE:
289 
                ret += scnprintf(buf+ret, buflen-ret,
290 
                        "Twrite tag %u fid %d offset %lld count %u data ",
291 
                        tag, fc->params.twrite.fid,
292 
                        (long long int) fc->params.twrite.offset,
293 
                        fc->params.twrite.count);
294 
                ret += p9_printdata(buf+ret, buflen-ret, fc->params.twrite.data,
295 
                        fc->params.twrite.count);
296 
                break;
297 
 
298 
        case P9_RWRITE:
299 
                ret += scnprintf(buf+ret, buflen-ret, "Rwrite tag %u count %u",
300 
                        tag, fc->params.rwrite.count);
301 
                break;
302 
 
303 
        case P9_TCLUNK:
304 
                ret += scnprintf(buf+ret, buflen-ret, "Tclunk tag %u fid %d",
305 
                        tag, fc->params.tclunk.fid);
306 
                break;
307 
 
308 
        case P9_RCLUNK:
309 
                ret += scnprintf(buf+ret, buflen-ret, "Rclunk tag %u", tag);
310 
                break;
311 
 
312 
        case P9_TREMOVE:
313 
                ret += scnprintf(buf+ret, buflen-ret, "Tremove tag %u fid %d",
314 
                        tag, fc->params.tremove.fid);
315 
                break;
316 
 
317 
        case P9_RREMOVE:
318 
                ret += scnprintf(buf+ret, buflen-ret, "Rremove tag %u", tag);
319 
                break;
320 
 
321 
        case P9_TSTAT:
322 
                ret += scnprintf(buf+ret, buflen-ret, "Tstat tag %u fid %d",
323 
                        tag, fc->params.tstat.fid);
324 
                break;
325 
 
326 
        case P9_RSTAT:
327 
                ret += scnprintf(buf+ret, buflen-ret, "Rstat tag %u ", tag);
328 
                ret += p9_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat,
329 
                        extended);
330 
                break;
331 
 
332 
        case P9_TWSTAT:
333 
                ret += scnprintf(buf+ret, buflen-ret, "Twstat tag %u fid %d ",
334 
                        tag, fc->params.twstat.fid);
335 
                ret += p9_printstat(buf+ret, buflen-ret,
336 
                                        &fc->params.twstat.stat, extended);
337 
                break;
338 
 
339 
        case P9_RWSTAT:
340 
                ret += scnprintf(buf+ret, buflen-ret, "Rwstat tag %u", tag);
341 
                break;
342 
 
343 
        default:
344 
                ret += scnprintf(buf+ret, buflen-ret, "unknown type %d", type);
345 
                break;
346 
        }
347 
 
348 
        return ret;
349 
}
350 
 
351 
#else
352 
int
353 
p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended)
354 
{
355 
        return 0;
356 
}
357 
EXPORT_SYMBOL(p9_printfcall);
358 
#endif /* CONFIG_NET_9P_DEBUG */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.