dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

net/9p: Convert net/9p protocol dumps to tracepoints 

This helps in more control over debugging.
root@qemu-img-64:~# ls /pass/123
ls: cannot access /pass/123: No such file or directory
root@qemu-img-64:~# cat /sys/kernel/debug/tracing/trace
# tracer: nop
#
#           TASK-PID    CPU#    TIMESTAMP  FUNCTION
#              | |       |          |         |
              ls-1536  [001]    70.928584: 9p_protocol_dump: clnt 18446612132784021504 P9_TWALK(tag = 1)
000: 16 00 00 00 6e 01 00 01 00 00 00 02 00 00 00 01
010: 00 03 00 31 32 33 00 00 00 ff ff ff ff 00 00 00

              ls-1536  [001]    70.928587: <stack trace>
 => trace_9p_protocol_dump
 => p9pdu_finalize
 => p9_client_rpc
 => p9_client_walk
 => v9fs_vfs_lookup
 => d_alloc_and_lookup
 => walk_component
 => path_lookupat
              ls-1536  [000]    70.929696: 9p_protocol_dump: clnt 18446612132784021504 P9_RLERROR(tag = 1)
000: 0b 00 00 00 07 01 00 02 00 00 00 4e 03 00 02 00
010: 00 00 00 00 03 00 02 00 00 00 00 00 ff 43 00 00

              ls-1536  [000]    70.929697: <stack trace>
 => trace_9p_protocol_dump
 => p9_client_rpc
 => p9_client_walk
 => v9fs_vfs_lookup
 => d_alloc_and_lookup
 => walk_component
 => path_lookupat
 => do_path_lookup

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
This commit is contained in:
Aneesh Kumar K.V 2011-08-07 00:46:59 +05:30 committed by Eric Van Hensbergen
parent ef6b0807e2
commit 348b59012e
7 changed files with 238 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
fs/9p/vfs_dir.c
View File

@ -165,9 +165,8 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
}
while (rdir->head < rdir->tail) {
p9stat_init(&st);
err = p9stat_read(rdir->buf + rdir->head,
rdir->tail - rdir->head, &st,
fid->clnt->proto_version);
err = p9stat_read(fid->clnt, rdir->buf + rdir->head,
rdir->tail - rdir->head, &st);
if (err) {
P9_DPRINTK(P9_DEBUG_VFS, "returned %d\n", err);
err = -EIO;
@ -241,10 +240,9 @@ static int v9fs_dir_readdir_dotl(struct file *filp, void *dirent,
while (rdir->head < rdir->tail) {
err = p9dirent_read(rdir->buf + rdir->head,
rdir->tail - rdir->head,
&curdirent,
fid->clnt->proto_version);
err = p9dirent_read(fid->clnt, rdir->buf + rdir->head,
rdir->tail - rdir->head,
&curdirent);
if (err < 0) {
P9_DPRINTK(P9_DEBUG_VFS, "returned %d\n", err);
err = -EIO;

3
include/net/9p/9p.h
View File

@ -76,11 +76,8 @@ do { \
} \
} while (0)
#define P9_DUMP_PKT(way, pdu) p9pdu_dump(way, pdu)
#else
#define P9_DPRINTK(level, format, arg...) do { } while (0)
#define P9_DUMP_PKT(way, pdu) do { } while (0)
#endif

6
include/net/9p/client.h
View File

@ -240,8 +240,8 @@ int p9_client_read(struct p9_fid *fid, char *data, char __user *udata,
int p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
u64 offset, u32 count);
int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset);
int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
int proto_version);
int p9dirent_read(struct p9_client *clnt, char *buf, int len,
struct p9_dirent *dirent);
struct p9_wstat *p9_client_stat(struct p9_fid *fid);
int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst);
int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *attr);
@ -259,7 +259,7 @@ struct p9_req_t *p9_tag_lookup(struct p9_client *, u16);
void p9_client_cb(struct p9_client *c, struct p9_req_t *req);
int p9_parse_header(struct p9_fcall *, int32_t *, int8_t *, int16_t *, int);
int p9stat_read(char *, int, struct p9_wstat *, int);
int p9stat_read(struct p9_client *, char *, int, struct p9_wstat *);
void p9stat_free(struct p9_wstat *);
int p9_is_proto_dotu(struct p9_client *clnt);

176
include/trace/events/9p.h Normal file
View File

@ -0,0 +1,176 @@
#undef TRACE_SYSTEM
#define TRACE_SYSTEM 9p
#if !defined(_TRACE_9P_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_9P_H
#include <linux/tracepoint.h>
#define show_9p_op(type) \
__print_symbolic(type, \
{ P9_TLERROR, "P9_TLERROR" }, \
{ P9_RLERROR, "P9_RLERROR" }, \
{ P9_TSTATFS, "P9_TSTATFS" }, \
{ P9_RSTATFS, "P9_RSTATFS" }, \
{ P9_TLOPEN, "P9_TLOPEN" }, \
{ P9_RLOPEN, "P9_RLOPEN" }, \
{ P9_TLCREATE, "P9_TLCREATE" }, \
{ P9_RLCREATE, "P9_RLCREATE" }, \
{ P9_TSYMLINK, "P9_TSYMLINK" }, \
{ P9_RSYMLINK, "P9_RSYMLINK" }, \
{ P9_TMKNOD, "P9_TMKNOD" }, \
{ P9_RMKNOD, "P9_RMKNOD" }, \
{ P9_TRENAME, "P9_TRENAME" }, \
{ P9_RRENAME, "P9_RRENAME" }, \
{ P9_TREADLINK, "P9_TREADLINK" }, \
{ P9_RREADLINK, "P9_RREADLINK" }, \
{ P9_TGETATTR, "P9_TGETATTR" }, \
{ P9_RGETATTR, "P9_RGETATTR" }, \
{ P9_TSETATTR, "P9_TSETATTR" }, \
{ P9_RSETATTR, "P9_RSETATTR" }, \
{ P9_TXATTRWALK, "P9_TXATTRWALK" }, \
{ P9_RXATTRWALK, "P9_RXATTRWALK" }, \
{ P9_TXATTRCREATE, "P9_TXATTRCREATE" }, \
{ P9_RXATTRCREATE, "P9_RXATTRCREATE" }, \
{ P9_TREADDIR, "P9_TREADDIR" }, \
{ P9_RREADDIR, "P9_RREADDIR" }, \
{ P9_TFSYNC, "P9_TFSYNC" }, \
{ P9_RFSYNC, "P9_RFSYNC" }, \
{ P9_TLOCK, "P9_TLOCK" }, \
{ P9_RLOCK, "P9_RLOCK" }, \
{ P9_TGETLOCK, "P9_TGETLOCK" }, \
{ P9_RGETLOCK, "P9_RGETLOCK" }, \
{ P9_TLINK, "P9_TLINK" }, \
{ P9_RLINK, "P9_RLINK" }, \
{ P9_TMKDIR, "P9_TMKDIR" }, \
{ P9_RMKDIR, "P9_RMKDIR" }, \
{ P9_TRENAMEAT, "P9_TRENAMEAT" }, \
{ P9_RRENAMEAT, "P9_RRENAMEAT" }, \
{ P9_TUNLINKAT, "P9_TUNLINKAT" }, \
{ P9_RUNLINKAT, "P9_RUNLINKAT" }, \
{ P9_TVERSION, "P9_TVERSION" }, \
{ P9_RVERSION, "P9_RVERSION" }, \
{ P9_TAUTH, "P9_TAUTH" }, \
{ P9_RAUTH, "P9_RAUTH" }, \
{ P9_TATTACH, "P9_TATTACH" }, \
{ P9_RATTACH, "P9_RATTACH" }, \
{ P9_TERROR, "P9_TERROR" }, \
{ P9_RERROR, "P9_RERROR" }, \
{ P9_TFLUSH, "P9_TFLUSH" }, \
{ P9_RFLUSH, "P9_RFLUSH" }, \
{ P9_TWALK, "P9_TWALK" }, \
{ P9_RWALK, "P9_RWALK" }, \
{ P9_TOPEN, "P9_TOPEN" }, \
{ P9_ROPEN, "P9_ROPEN" }, \
{ P9_TCREATE, "P9_TCREATE" }, \
{ P9_RCREATE, "P9_RCREATE" }, \
{ P9_TREAD, "P9_TREAD" }, \
{ P9_RREAD, "P9_RREAD" }, \
{ P9_TWRITE, "P9_TWRITE" }, \
{ P9_RWRITE, "P9_RWRITE" }, \
{ P9_TCLUNK, "P9_TCLUNK" }, \
{ P9_RCLUNK, "P9_RCLUNK" }, \
{ P9_TREMOVE, "P9_TREMOVE" }, \
{ P9_RREMOVE, "P9_RREMOVE" }, \
{ P9_TSTAT, "P9_TSTAT" }, \
{ P9_RSTAT, "P9_RSTAT" }, \
{ P9_TWSTAT, "P9_TWSTAT" }, \
{ P9_RWSTAT, "P9_RWSTAT" })
TRACE_EVENT(9p_client_req,
TP_PROTO(struct p9_client *clnt, int8_t type, int tag),
TP_ARGS(clnt, type, tag),
TP_STRUCT__entry(
__field( void *, clnt )
__field( __u8, type )
__field( __u32, tag )
),
TP_fast_assign(
__entry->clnt = clnt;
__entry->type = type;
__entry->tag = tag;
),
TP_printk("client %lu request %s tag %d",
(long)__entry->clnt, show_9p_op(__entry->type),
__entry->tag)
);
TRACE_EVENT(9p_client_res,
TP_PROTO(struct p9_client *clnt, int8_t type, int tag, int err),
TP_ARGS(clnt, type, tag, err),
TP_STRUCT__entry(
__field( void *, clnt )
__field( __u8, type )
__field( __u32, tag )
__field( __u32, err )
),
TP_fast_assign(
__entry->clnt = clnt;
__entry->type = type;
__entry->tag = tag;
__entry->err = err;
),
TP_printk("client %lu response %s tag %d err %d",
(long)__entry->clnt, show_9p_op(__entry->type),
__entry->tag, __entry->err)
);
/* dump 32 bytes of protocol data */
#define P9_PROTO_DUMP_SZ 32
TRACE_EVENT(9p_protocol_dump,
TP_PROTO(struct p9_client *clnt, struct p9_fcall *pdu),
TP_ARGS(clnt, pdu),
TP_STRUCT__entry(
__field( void *, clnt )
__field( __u8, type )
__field( __u16, tag )
__array( unsigned char, line, P9_PROTO_DUMP_SZ )
),
TP_fast_assign(
__entry->clnt = clnt;
__entry->type = pdu->id;
__entry->tag = pdu->tag;
memcpy(__entry->line, pdu->sdata, P9_PROTO_DUMP_SZ);
),
TP_printk("clnt %lu %s(tag = %d)\n%.3x: "
"%02x %02x %02x %02x %02x %02x %02x %02x "
"%02x %02x %02x %02x %02x %02x %02x %02x\n"
"%.3x: "
"%02x %02x %02x %02x %02x %02x %02x %02x "
"%02x %02x %02x %02x %02x %02x %02x %02x\n",
(long)__entry->clnt, show_9p_op(__entry->type),
__entry->tag, 0,
__entry->line[0], __entry->line[1],
__entry->line[2], __entry->line[3],
__entry->line[4], __entry->line[5],
__entry->line[6], __entry->line[7],
__entry->line[8], __entry->line[9],
__entry->line[10], __entry->line[11],
__entry->line[12], __entry->line[13],
__entry->line[14], __entry->line[15],
16,
__entry->line[16], __entry->line[17],
__entry->line[18], __entry->line[19],
__entry->line[20], __entry->line[21],
__entry->line[22], __entry->line[23],
__entry->line[24], __entry->line[25],
__entry->line[26], __entry->line[27],
__entry->line[28], __entry->line[29],
__entry->line[30], __entry->line[31])
);
#endif /* _TRACE_9P_H */
/* This part must be outside protection */
#include <trace/define_trace.h>

77
net/9p/client.c
View File

@ -38,6 +38,9 @@
#include <net/9p/transport.h>
#include "protocol.h"
#define CREATE_TRACE_POINTS
#include <trace/events/9p.h>
/*
* Client Option Parsing (code inspired by NFS code)
* - a little lazy - parse all client options
@ -464,11 +467,15 @@ static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
int ecode;
err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
/*
* dump the response from server
* This should be after check errors which poplulate pdu_fcall.
*/
trace_9p_protocol_dump(c, req->rc);
if (err) {
P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
return err;
}
if (type != P9_RERROR && type != P9_RLERROR)
return 0;
@ -525,6 +532,11 @@ static int p9_check_zc_errors(struct p9_client *c, struct p9_req_t *req,
char *ename = NULL;
err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
/*
* dump the response from server
* This should be after parse_header which poplulate pdu_fcall.
*/
trace_9p_protocol_dump(c, req->rc);
if (err) {
P9_DPRINTK(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
return err;
@ -684,7 +696,8 @@ static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);
if (err)
goto reterr;
p9pdu_finalize(req->tc);
p9pdu_finalize(c, req->tc);
trace_9p_client_req(c, type, tag);
return req;
reterr:
p9_free_req(c, req);
@ -755,13 +768,10 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
goto reterr;
err = p9_check_errors(c, req);
if (!err) {
P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d\n", c, type);
trace_9p_client_res(c, type, req->rc->tag, err);
if (!err)
return req;
}
reterr:
P9_DPRINTK(P9_DEBUG_MUX,
"exit: client %p op %d error: %d\n", c, type, err);
p9_free_req(c, req);
return ERR_PTR(err);
}
@ -841,13 +851,10 @@ static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
goto reterr;
err = p9_check_zc_errors(c, req, uidata, in_hdrlen, kern_buf);
if (!err) {
P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d\n", c, type);
trace_9p_client_res(c, type, req->rc->tag, err);
if (!err)
return req;
}
reterr:
P9_DPRINTK(P9_DEBUG_MUX, "exit: client %p op %d error: %d\n", c, type,
err);
p9_free_req(c, req);
return ERR_PTR(err);
}
@ -935,7 +942,7 @@ static int p9_client_version(struct p9_client *c)
err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
if (err) {
P9_DPRINTK(P9_DEBUG_9P, "version error %d\n", err);
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(c, req->rc);
goto error;
}
@ -1072,15 +1079,14 @@ EXPORT_SYMBOL(p9_client_begin_disconnect);
struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
char *uname, u32 n_uname, char *aname)
{
int err;
int err = 0;
struct p9_req_t *req;
struct p9_fid *fid;
struct p9_qid qid;
P9_DPRINTK(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
afid ? afid->fid : -1, uname, aname);
err = 0;
P9_DPRINTK(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
afid ? afid->fid : -1, uname, aname);
fid = p9_fid_create(clnt);
if (IS_ERR(fid)) {
err = PTR_ERR(fid);
@ -1097,7 +1103,7 @@ struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
p9_free_req(clnt, req);
goto error;
}
@ -1157,7 +1163,7 @@ struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
p9_free_req(clnt, req);
goto clunk_fid;
}
@ -1224,7 +1230,7 @@ int p9_client_open(struct p9_fid *fid, int mode)
err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
@ -1267,7 +1273,7 @@ int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", qid, &iounit);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
@ -1312,7 +1318,7 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
@ -1351,7 +1357,7 @@ int p9_client_symlink(struct p9_fid *dfid, char *name, char *symtgt, gid_t gid,
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
@ -1542,12 +1548,11 @@ p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
P9_DPRINTK(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
P9_DUMP_PKT(1, req->rc);
if (non_zc) {
if (data) {
@ -1617,7 +1622,7 @@ p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
@ -1657,7 +1662,7 @@ struct p9_wstat *p9_client_stat(struct p9_fid *fid)
err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
p9_free_req(clnt, req);
goto error;
}
@ -1708,7 +1713,7 @@ struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
err = p9pdu_readf(req->rc, clnt->proto_version, "A", ret);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
p9_free_req(clnt, req);
goto error;
}
@ -1856,7 +1861,7 @@ int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
&sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
&sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
p9_free_req(clnt, req);
goto error;
}
@ -1963,7 +1968,7 @@ struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
}
err = p9pdu_readf(req->rc, clnt->proto_version, "q", attr_size);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
p9_free_req(clnt, req);
goto clunk_fid;
}
@ -2047,7 +2052,7 @@ int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto free_and_error;
}
@ -2084,7 +2089,7 @@ int p9_client_mknod_dotl(struct p9_fid *fid, char *name, int mode,
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto error;
}
P9_DPRINTK(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
@ -2115,7 +2120,7 @@ int p9_client_mkdir_dotl(struct p9_fid *fid, char *name, int mode,
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto error;
}
P9_DPRINTK(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
@ -2150,7 +2155,7 @@ int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
err = p9pdu_readf(req->rc, clnt->proto_version, "b", status);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto error;
}
P9_DPRINTK(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
@ -2183,7 +2188,7 @@ int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
&glock->start, &glock->length, &glock->proc_id,
&glock->client_id);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto error;
}
P9_DPRINTK(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "
@ -2211,7 +2216,7 @@ int p9_client_readlink(struct p9_fid *fid, char **target)
err = p9pdu_readf(req->rc, clnt->proto_version, "s", target);
if (err) {
P9_DUMP_PKT(1, req->rc);
trace_9p_protocol_dump(clnt, req->rc);
goto error;
}
P9_DPRINTK(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);

53
net/9p/protocol.c
View File

@ -37,40 +37,11 @@
#include <net/9p/client.h>
#include "protocol.h"
#include <trace/events/9p.h>
static int
p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
#ifdef CONFIG_NET_9P_DEBUG
void
p9pdu_dump(int way, struct p9_fcall *pdu)
{
int len = pdu->size;
if ((p9_debug_level & P9_DEBUG_VPKT) != P9_DEBUG_VPKT) {
if ((p9_debug_level & P9_DEBUG_PKT) == P9_DEBUG_PKT) {
if (len > 32)
len = 32;
} else {
/* shouldn't happen */
return;
}
}
if (way)
print_hex_dump_bytes("[9P] ", DUMP_PREFIX_OFFSET, pdu->sdata,
len);
else
print_hex_dump_bytes("]9P[ ", DUMP_PREFIX_OFFSET, pdu->sdata,
len);
}
#else
void
p9pdu_dump(int way, struct p9_fcall *pdu)
{
}
#endif
EXPORT_SYMBOL(p9pdu_dump);
void p9stat_free(struct p9_wstat *stbuf)
{
kfree(stbuf->name);
@ -551,7 +522,7 @@ p9pdu_writef(struct p9_fcall *pdu, int proto_version, const char *fmt, ...)
return ret;
}
int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
int p9stat_read(struct p9_client *clnt, char *buf, int len, struct p9_wstat *st)
{
struct p9_fcall fake_pdu;
int ret;
@ -561,10 +532,10 @@ int p9stat_read(char *buf, int len, struct p9_wstat *st, int proto_version)
fake_pdu.sdata = buf;
fake_pdu.offset = 0;
ret = p9pdu_readf(&fake_pdu, proto_version, "S", st);
ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "S", st);
if (ret) {
P9_DPRINTK(P9_DEBUG_9P, "<<< p9stat_read failed: %d\n", ret);
P9_DUMP_PKT(0, &fake_pdu);
trace_9p_protocol_dump(clnt, &fake_pdu);
}
return ret;
@ -577,7 +548,7 @@ int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type)
return p9pdu_writef(pdu, 0, "dbw", 0, type, tag);
}
int p9pdu_finalize(struct p9_fcall *pdu)
int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu)
{
int size = pdu->size;
int err;
@ -586,7 +557,7 @@ int p9pdu_finalize(struct p9_fcall *pdu)
err = p9pdu_writef(pdu, 0, "d", size);
pdu->size = size;
P9_DUMP_PKT(0, pdu);
trace_9p_protocol_dump(clnt, pdu);
P9_DPRINTK(P9_DEBUG_9P, ">>> size=%d type: %d tag: %d\n", pdu->size,
pdu->id, pdu->tag);
@ -599,8 +570,8 @@ void p9pdu_reset(struct p9_fcall *pdu)
pdu->size = 0;
}
int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
int proto_version)
int p9dirent_read(struct p9_client *clnt, char *buf, int len,
struct p9_dirent *dirent)
{
struct p9_fcall fake_pdu;
int ret;
@ -611,11 +582,11 @@ int p9dirent_read(char *buf, int len, struct p9_dirent *dirent,
fake_pdu.sdata = buf;
fake_pdu.offset = 0;
ret = p9pdu_readf(&fake_pdu, proto_version, "Qqbs", &dirent->qid,
&dirent->d_off, &dirent->d_type, &nameptr);
ret = p9pdu_readf(&fake_pdu, clnt->proto_version, "Qqbs", &dirent->qid,
&dirent->d_off, &dirent->d_type, &nameptr);
if (ret) {
P9_DPRINTK(P9_DEBUG_9P, "<<< p9dirent_read failed: %d\n", ret);
P9_DUMP_PKT(1, &fake_pdu);
trace_9p_protocol_dump(clnt, &fake_pdu);
goto out;
}

3
net/9p/protocol.h
View File

@ -29,7 +29,6 @@ int p9pdu_vwritef(struct p9_fcall *pdu, int proto_version, const char *fmt,
va_list ap);
int p9pdu_readf(struct p9_fcall *pdu, int proto_version, const char *fmt, ...);
int p9pdu_prepare(struct p9_fcall *pdu, int16_t tag, int8_t type);
int p9pdu_finalize(struct p9_fcall *pdu);
void p9pdu_dump(int, struct p9_fcall *);
int p9pdu_finalize(struct p9_client *clnt, struct p9_fcall *pdu);
void p9pdu_reset(struct p9_fcall *pdu);
size_t pdu_read(struct p9_fcall *pdu, void *data, size_t size);