Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 348b5901 authored by Aneesh Kumar K.V's avatar Aneesh Kumar K.V Committed by Eric Van Hensbergen
Browse files

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: default avatarAneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: default avatarEric Van Hensbergen <ericvh@gmail.com>
parent ef6b0807

fs/9p/vfs_dir.c

+5 −7
Original line number Diff line number Diff line
@@ -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,

			err = p9dirent_read(fid->clnt, rdir->buf + rdir->head,

					    rdir->tail - rdir->head,

						&curdirent,

						fid->clnt->proto_version);

					    &curdirent);

			if (err < 0) {

				P9_DPRINTK(P9_DEBUG_VFS, "returned %d\n", err);

				err = -EIO;

include/net/9p/9p.h

+0 −3
Original line number Diff line number Diff line
@@ -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

include/net/9p/client.h

+3 −3
Original line number Diff line number Diff line
@@ -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);

include/trace/events/9p.h

0 → 100644
+176 −0
Original line number Diff line number Diff line 
#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>

net/9p/client.c

+41 −36
Original line number Diff line number Diff line
@@ -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;



	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);