2007-07-11 00:57:28 +02:00
|
|
|
/*
|
|
|
|
* net/9p/clnt.c
|
|
|
|
*
|
|
|
|
* 9P Client
|
|
|
|
*
|
2008-02-07 02:25:03 +01:00
|
|
|
* Copyright (C) 2008 by Eric Van Hensbergen <ericvh@gmail.com>
|
2007-07-11 00:57:28 +02:00
|
|
|
* Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2
|
|
|
|
* as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to:
|
|
|
|
* Free Software Foundation
|
|
|
|
* 51 Franklin Street, Fifth Floor
|
|
|
|
* Boston, MA 02111-1301 USA
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/fs.h>
|
2008-02-07 02:25:03 +01:00
|
|
|
#include <linux/poll.h>
|
2007-07-11 00:57:28 +02:00
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/mutex.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2007-07-11 00:57:28 +02:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <net/9p/9p.h>
|
2007-10-17 21:31:07 +02:00
|
|
|
#include <linux/parser.h>
|
2007-07-11 00:57:28 +02:00
|
|
|
#include <net/9p/client.h>
|
2008-10-14 01:45:25 +02:00
|
|
|
#include <net/9p/transport.h>
|
2008-10-16 15:30:07 +02:00
|
|
|
#include "protocol.h"
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-08-06 21:16:59 +02:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/9p.h>
|
|
|
|
|
2008-02-07 02:25:03 +01:00
|
|
|
/*
|
|
|
|
* Client Option Parsing (code inspired by NFS code)
|
|
|
|
* - a little lazy - parse all client options
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum {
|
|
|
|
Opt_msize,
|
|
|
|
Opt_trans,
|
|
|
|
Opt_legacy,
|
2010-03-05 19:49:11 +01:00
|
|
|
Opt_version,
|
2008-02-07 02:25:03 +01:00
|
|
|
Opt_err,
|
|
|
|
};
|
|
|
|
|
2008-10-13 11:46:57 +02:00
|
|
|
static const match_table_t tokens = {
|
2008-02-07 02:25:03 +01:00
|
|
|
{Opt_msize, "msize=%u"},
|
|
|
|
{Opt_legacy, "noextend"},
|
|
|
|
{Opt_trans, "trans=%s"},
|
2010-03-05 19:49:11 +01:00
|
|
|
{Opt_version, "version=%s"},
|
2008-02-07 02:25:03 +01:00
|
|
|
{Opt_err, NULL},
|
|
|
|
};
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
inline int p9_is_proto_dotl(struct p9_client *clnt)
|
|
|
|
{
|
2010-09-22 22:43:57 +02:00
|
|
|
return clnt->proto_version == p9_proto_2000L;
|
2010-03-05 19:50:14 +01:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_is_proto_dotl);
|
|
|
|
|
|
|
|
inline int p9_is_proto_dotu(struct p9_client *clnt)
|
|
|
|
{
|
2010-09-22 22:43:57 +02:00
|
|
|
return clnt->proto_version == p9_proto_2000u;
|
2010-03-05 19:50:14 +01:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_is_proto_dotu);
|
|
|
|
|
2012-08-10 15:52:06 +02:00
|
|
|
/*
|
|
|
|
* Some error codes are taken directly from the server replies,
|
|
|
|
* make sure they are valid.
|
|
|
|
*/
|
|
|
|
static int safe_errno(int err)
|
|
|
|
{
|
|
|
|
if ((err > 0) || (err < -MAX_ERRNO)) {
|
|
|
|
p9_debug(P9_DEBUG_ERROR, "Invalid error code %d\n", err);
|
|
|
|
return -EPROTO;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-05 19:49:11 +01:00
|
|
|
/* Interpret mount option for protocol version */
|
2011-05-06 15:05:32 +02:00
|
|
|
static int get_protocol_version(char *s)
|
2010-03-05 19:49:11 +01:00
|
|
|
{
|
2010-04-05 21:37:28 +02:00
|
|
|
int version = -EINVAL;
|
|
|
|
|
2011-05-06 15:05:32 +02:00
|
|
|
if (!strcmp(s, "9p2000")) {
|
2010-03-05 19:49:11 +01:00
|
|
|
version = p9_proto_legacy;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "Protocol version: Legacy\n");
|
2011-05-06 15:05:32 +02:00
|
|
|
} else if (!strcmp(s, "9p2000.u")) {
|
2010-03-05 19:49:11 +01:00
|
|
|
version = p9_proto_2000u;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.u\n");
|
2011-05-06 15:05:32 +02:00
|
|
|
} else if (!strcmp(s, "9p2000.L")) {
|
2010-03-08 18:33:04 +01:00
|
|
|
version = p9_proto_2000L;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "Protocol version: 9P2000.L\n");
|
2011-05-06 15:05:32 +02:00
|
|
|
} else
|
2011-11-28 19:40:46 +01:00
|
|
|
pr_info("Unknown protocol version %s\n", s);
|
2011-05-06 15:05:32 +02:00
|
|
|
|
2010-03-05 19:49:11 +01:00
|
|
|
return version;
|
|
|
|
}
|
|
|
|
|
2008-02-07 02:25:03 +01:00
|
|
|
/**
|
2009-07-19 21:41:55 +02:00
|
|
|
* parse_options - parse mount options into client structure
|
|
|
|
* @opts: options string passed from mount
|
|
|
|
* @clnt: existing v9fs client information
|
2008-02-07 02:25:03 +01:00
|
|
|
*
|
2008-03-07 17:53:53 +01:00
|
|
|
* Return 0 upon success, -ERRNO upon failure
|
2008-02-07 02:25:03 +01:00
|
|
|
*/
|
|
|
|
|
2008-03-07 17:53:53 +01:00
|
|
|
static int parse_opts(char *opts, struct p9_client *clnt)
|
2008-02-07 02:25:03 +01:00
|
|
|
{
|
2010-02-08 23:23:23 +01:00
|
|
|
char *options, *tmp_options;
|
2008-02-07 02:25:03 +01:00
|
|
|
char *p;
|
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
int option;
|
2011-05-06 15:05:32 +02:00
|
|
|
char *s;
|
2008-03-07 17:53:53 +01:00
|
|
|
int ret = 0;
|
2008-02-07 02:25:03 +01:00
|
|
|
|
2013-05-20 08:50:54 +02:00
|
|
|
clnt->proto_version = p9_proto_2000L;
|
2008-02-07 02:25:03 +01:00
|
|
|
clnt->msize = 8192;
|
|
|
|
|
2008-03-07 17:53:53 +01:00
|
|
|
if (!opts)
|
|
|
|
return 0;
|
|
|
|
|
2010-02-08 23:23:23 +01:00
|
|
|
tmp_options = kstrdup(opts, GFP_KERNEL);
|
|
|
|
if (!tmp_options) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"failed to allocate copy of option string\n");
|
2008-03-07 17:53:53 +01:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2010-02-08 23:23:23 +01:00
|
|
|
options = tmp_options;
|
2008-02-07 02:25:03 +01:00
|
|
|
|
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
2011-08-30 08:49:34 +02:00
|
|
|
int token, r;
|
2008-02-07 02:25:03 +01:00
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
token = match_token(p, tokens, args);
|
2011-08-30 08:49:34 +02:00
|
|
|
switch (token) {
|
|
|
|
case Opt_msize:
|
|
|
|
r = match_int(&args[0], &option);
|
2008-03-07 17:53:53 +01:00
|
|
|
if (r < 0) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"integer field, but no integer?\n");
|
2008-03-07 17:53:53 +01:00
|
|
|
ret = r;
|
2008-02-07 02:25:03 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
clnt->msize = option;
|
|
|
|
break;
|
|
|
|
case Opt_trans:
|
2011-05-06 15:05:32 +02:00
|
|
|
s = match_strdup(&args[0]);
|
|
|
|
if (!s) {
|
|
|
|
ret = -ENOMEM;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"problem allocating copy of trans arg\n");
|
2011-05-06 15:05:32 +02:00
|
|
|
goto free_and_return;
|
|
|
|
}
|
|
|
|
clnt->trans_mod = v9fs_get_trans_by_name(s);
|
|
|
|
if (clnt->trans_mod == NULL) {
|
2011-11-28 19:40:46 +01:00
|
|
|
pr_info("Could not find request transport: %s\n",
|
|
|
|
s);
|
2010-01-16 02:01:10 +01:00
|
|
|
ret = -EINVAL;
|
2011-05-06 15:05:32 +02:00
|
|
|
kfree(s);
|
2010-01-16 02:01:10 +01:00
|
|
|
goto free_and_return;
|
|
|
|
}
|
2011-05-06 15:05:32 +02:00
|
|
|
kfree(s);
|
2008-02-07 02:25:03 +01:00
|
|
|
break;
|
|
|
|
case Opt_legacy:
|
2010-03-05 19:50:14 +01:00
|
|
|
clnt->proto_version = p9_proto_legacy;
|
2008-02-07 02:25:03 +01:00
|
|
|
break;
|
2010-03-05 19:49:11 +01:00
|
|
|
case Opt_version:
|
2011-05-06 15:05:32 +02:00
|
|
|
s = match_strdup(&args[0]);
|
|
|
|
if (!s) {
|
|
|
|
ret = -ENOMEM;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"problem allocating copy of version arg\n");
|
2010-03-05 19:49:11 +01:00
|
|
|
goto free_and_return;
|
2011-05-06 15:05:32 +02:00
|
|
|
}
|
|
|
|
ret = get_protocol_version(s);
|
|
|
|
if (ret == -EINVAL) {
|
|
|
|
kfree(s);
|
|
|
|
goto free_and_return;
|
|
|
|
}
|
|
|
|
kfree(s);
|
2010-03-05 19:49:11 +01:00
|
|
|
clnt->proto_version = ret;
|
|
|
|
break;
|
2008-02-07 02:25:03 +01:00
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2008-09-24 23:22:23 +02:00
|
|
|
|
2010-01-16 02:01:10 +01:00
|
|
|
free_and_return:
|
2010-02-08 23:23:23 +01:00
|
|
|
kfree(tmp_options);
|
2008-03-07 17:53:53 +01:00
|
|
|
return ret;
|
2008-02-07 02:25:03 +01:00
|
|
|
}
|
|
|
|
|
2013-06-21 15:32:36 +02:00
|
|
|
struct p9_fcall *p9_fcall_alloc(int alloc_msize)
|
|
|
|
{
|
|
|
|
struct p9_fcall *fc;
|
|
|
|
fc = kmalloc(sizeof(struct p9_fcall) + alloc_msize, GFP_NOFS);
|
|
|
|
if (!fc)
|
|
|
|
return NULL;
|
|
|
|
fc->capacity = alloc_msize;
|
|
|
|
fc->sdata = (char *) fc + sizeof(struct p9_fcall);
|
|
|
|
return fc;
|
|
|
|
}
|
|
|
|
|
2008-10-14 01:45:23 +02:00
|
|
|
/**
|
|
|
|
* p9_tag_alloc - lookup/allocate a request by tag
|
|
|
|
* @c: client session to lookup tag within
|
|
|
|
* @tag: numeric id for transaction
|
|
|
|
*
|
|
|
|
* this is a simple array lookup, but will grow the
|
2011-03-31 03:57:33 +02:00
|
|
|
* request_slots as necessary to accommodate transaction
|
2008-10-14 01:45:23 +02:00
|
|
|
* ids which did not previously have a slot.
|
|
|
|
*
|
|
|
|
* this code relies on the client spinlock to manage locks, its
|
|
|
|
* possible we should switch to something else, but I'd rather
|
|
|
|
* stick with something low-overhead for the common case.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-08-26 18:57:40 +02:00
|
|
|
static struct p9_req_t *
|
|
|
|
p9_tag_alloc(struct p9_client *c, u16 tag, unsigned int max_size)
|
2008-10-14 01:45:23 +02:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int row, col;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
2011-08-16 07:20:10 +02:00
|
|
|
int alloc_msize = min(c->msize, max_size);
|
2008-10-14 01:45:23 +02:00
|
|
|
|
|
|
|
/* This looks up the original request by tag so we know which
|
|
|
|
* buffer to read the data into */
|
|
|
|
tag++;
|
|
|
|
|
|
|
|
if (tag >= c->max_tag) {
|
|
|
|
spin_lock_irqsave(&c->lock, flags);
|
|
|
|
/* check again since original check was outside of lock */
|
|
|
|
while (tag >= c->max_tag) {
|
|
|
|
row = (tag / P9_ROW_MAXTAG);
|
|
|
|
c->reqs[row] = kcalloc(P9_ROW_MAXTAG,
|
|
|
|
sizeof(struct p9_req_t), GFP_ATOMIC);
|
|
|
|
|
|
|
|
if (!c->reqs[row]) {
|
2011-11-28 19:40:46 +01:00
|
|
|
pr_err("Couldn't grow tag array\n");
|
2008-10-23 01:54:47 +02:00
|
|
|
spin_unlock_irqrestore(&c->lock, flags);
|
2008-10-16 15:30:07 +02:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-10-14 01:45:23 +02:00
|
|
|
}
|
|
|
|
for (col = 0; col < P9_ROW_MAXTAG; col++) {
|
|
|
|
c->reqs[row][col].status = REQ_STATUS_IDLE;
|
2008-10-16 15:30:07 +02:00
|
|
|
c->reqs[row][col].tc = NULL;
|
2008-10-14 01:45:23 +02:00
|
|
|
}
|
|
|
|
c->max_tag += P9_ROW_MAXTAG;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&c->lock, flags);
|
|
|
|
}
|
|
|
|
row = tag / P9_ROW_MAXTAG;
|
|
|
|
col = tag % P9_ROW_MAXTAG;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
req = &c->reqs[row][col];
|
2013-06-21 15:32:36 +02:00
|
|
|
if (!req->wq) {
|
2011-03-08 12:09:47 +01:00
|
|
|
req->wq = kmalloc(sizeof(wait_queue_head_t), GFP_NOFS);
|
2013-06-21 15:32:34 +02:00
|
|
|
if (!req->wq)
|
|
|
|
goto grow_failed;
|
2008-10-16 15:30:07 +02:00
|
|
|
init_waitqueue_head(req->wq);
|
2013-06-21 15:32:34 +02:00
|
|
|
}
|
|
|
|
|
2013-06-21 15:32:36 +02:00
|
|
|
if (!req->tc)
|
|
|
|
req->tc = p9_fcall_alloc(alloc_msize);
|
|
|
|
if (!req->rc)
|
|
|
|
req->rc = p9_fcall_alloc(alloc_msize);
|
|
|
|
if (!req->tc || !req->rc)
|
|
|
|
goto grow_failed;
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
p9pdu_reset(req->tc);
|
|
|
|
p9pdu_reset(req->rc);
|
|
|
|
|
|
|
|
req->tc->tag = tag-1;
|
|
|
|
req->status = REQ_STATUS_ALLOC;
|
2008-10-14 01:45:23 +02:00
|
|
|
|
2013-06-21 15:32:34 +02:00
|
|
|
return req;
|
|
|
|
|
|
|
|
grow_failed:
|
|
|
|
pr_err("Couldn't grow tag array\n");
|
|
|
|
kfree(req->tc);
|
|
|
|
kfree(req->rc);
|
|
|
|
kfree(req->wq);
|
|
|
|
req->tc = req->rc = NULL;
|
|
|
|
req->wq = NULL;
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-10-14 01:45:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p9_tag_lookup - lookup a request by tag
|
|
|
|
* @c: client session to lookup tag within
|
|
|
|
* @tag: numeric id for transaction
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct p9_req_t *p9_tag_lookup(struct p9_client *c, u16 tag)
|
|
|
|
{
|
|
|
|
int row, col;
|
|
|
|
|
|
|
|
/* This looks up the original request by tag so we know which
|
|
|
|
* buffer to read the data into */
|
|
|
|
tag++;
|
|
|
|
|
2011-07-14 02:12:18 +02:00
|
|
|
if(tag >= c->max_tag)
|
|
|
|
return NULL;
|
2008-10-14 01:45:23 +02:00
|
|
|
|
|
|
|
row = tag / P9_ROW_MAXTAG;
|
|
|
|
col = tag % P9_ROW_MAXTAG;
|
|
|
|
|
|
|
|
return &c->reqs[row][col];
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_tag_lookup);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p9_tag_init - setup tags structure and contents
|
2009-07-19 21:41:55 +02:00
|
|
|
* @c: v9fs client struct
|
2008-10-14 01:45:23 +02:00
|
|
|
*
|
|
|
|
* This initializes the tags structure for each client instance.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int p9_tag_init(struct p9_client *c)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
c->tagpool = p9_idpool_create();
|
|
|
|
if (IS_ERR(c->tagpool)) {
|
|
|
|
err = PTR_ERR(c->tagpool);
|
|
|
|
goto error;
|
|
|
|
}
|
2011-05-20 20:55:52 +02:00
|
|
|
err = p9_idpool_get(c->tagpool); /* reserve tag 0 */
|
|
|
|
if (err < 0) {
|
|
|
|
p9_idpool_destroy(c->tagpool);
|
|
|
|
goto error;
|
|
|
|
}
|
2008-10-14 01:45:23 +02:00
|
|
|
c->max_tag = 0;
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p9_tag_cleanup - cleans up tags structure and reclaims resources
|
2009-07-19 21:41:55 +02:00
|
|
|
* @c: v9fs client struct
|
2008-10-14 01:45:23 +02:00
|
|
|
*
|
|
|
|
* This frees resources associated with the tags structure
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void p9_tag_cleanup(struct p9_client *c)
|
|
|
|
{
|
|
|
|
int row, col;
|
|
|
|
|
|
|
|
/* check to insure all requests are idle */
|
|
|
|
for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
|
|
|
|
for (col = 0; col < P9_ROW_MAXTAG; col++) {
|
|
|
|
if (c->reqs[row][col].status != REQ_STATUS_IDLE) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX,
|
|
|
|
"Attempting to cleanup non-free tag %d,%d\n",
|
|
|
|
row, col);
|
2008-10-14 01:45:23 +02:00
|
|
|
/* TODO: delay execution of cleanup */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-24 20:13:59 +02:00
|
|
|
if (c->tagpool) {
|
|
|
|
p9_idpool_put(0, c->tagpool); /* free reserved tag 0 */
|
2008-10-14 01:45:23 +02:00
|
|
|
p9_idpool_destroy(c->tagpool);
|
2010-08-24 20:13:59 +02:00
|
|
|
}
|
2008-10-14 01:45:23 +02:00
|
|
|
|
|
|
|
/* free requests associated with tags */
|
|
|
|
for (row = 0; row < (c->max_tag/P9_ROW_MAXTAG); row++) {
|
2008-10-16 15:30:07 +02:00
|
|
|
for (col = 0; col < P9_ROW_MAXTAG; col++) {
|
2008-10-14 01:45:23 +02:00
|
|
|
kfree(c->reqs[row][col].wq);
|
2008-10-16 15:30:07 +02:00
|
|
|
kfree(c->reqs[row][col].tc);
|
|
|
|
kfree(c->reqs[row][col].rc);
|
|
|
|
}
|
2008-10-14 01:45:23 +02:00
|
|
|
kfree(c->reqs[row]);
|
|
|
|
}
|
|
|
|
c->max_tag = 0;
|
|
|
|
}
|
|
|
|
|
2008-10-14 01:45:22 +02:00
|
|
|
/**
|
|
|
|
* p9_free_req - free a request and clean-up as necessary
|
|
|
|
* c: client state
|
|
|
|
* r: request to release
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
static void p9_free_req(struct p9_client *c, struct p9_req_t *r)
|
2008-10-14 01:45:22 +02:00
|
|
|
{
|
2008-10-16 15:30:07 +02:00
|
|
|
int tag = r->tc->tag;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "clnt %p req %p tag: %d\n", c, r, tag);
|
2008-10-16 15:30:07 +02:00
|
|
|
|
2008-10-14 01:45:22 +02:00
|
|
|
r->status = REQ_STATUS_IDLE;
|
2008-10-16 15:30:07 +02:00
|
|
|
if (tag != P9_NOTAG && p9_idpool_check(tag, c->tagpool))
|
|
|
|
p9_idpool_put(tag, c->tagpool);
|
2008-10-14 01:45:22 +02:00
|
|
|
}
|
|
|
|
|
2008-10-14 01:45:21 +02:00
|
|
|
/**
|
|
|
|
* p9_client_cb - call back from transport to client
|
|
|
|
* c: client state
|
|
|
|
* req: request received
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void p9_client_cb(struct p9_client *c, struct p9_req_t *req)
|
|
|
|
{
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, " tag %d\n", req->tc->tag);
|
2009-04-05 23:28:59 +02:00
|
|
|
wake_up(req->wq);
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "wakeup: %d\n", req->tc->tag);
|
2008-10-14 01:45:21 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_cb);
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
/**
|
|
|
|
* p9_parse_header - parse header arguments out of a packet
|
|
|
|
* @pdu: packet to parse
|
|
|
|
* @size: size of packet
|
|
|
|
* @type: type of request
|
|
|
|
* @tag: tag of packet
|
|
|
|
* @rewind: set if we need to rewind offset afterwards
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
p9_parse_header(struct p9_fcall *pdu, int32_t *size, int8_t *type, int16_t *tag,
|
|
|
|
int rewind)
|
|
|
|
{
|
|
|
|
int8_t r_type;
|
|
|
|
int16_t r_tag;
|
|
|
|
int32_t r_size;
|
|
|
|
int offset = pdu->offset;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
pdu->offset = 0;
|
|
|
|
if (pdu->size == 0)
|
|
|
|
pdu->size = 7;
|
|
|
|
|
|
|
|
err = p9pdu_readf(pdu, 0, "dbw", &r_size, &r_type, &r_tag);
|
|
|
|
if (err)
|
|
|
|
goto rewind_and_exit;
|
|
|
|
|
|
|
|
pdu->size = r_size;
|
|
|
|
pdu->id = r_type;
|
|
|
|
pdu->tag = r_tag;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< size=%d type: %d tag: %d\n",
|
|
|
|
pdu->size, pdu->id, pdu->tag);
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
if (type)
|
|
|
|
*type = r_type;
|
|
|
|
if (tag)
|
|
|
|
*tag = r_tag;
|
|
|
|
if (size)
|
|
|
|
*size = r_size;
|
|
|
|
|
|
|
|
|
|
|
|
rewind_and_exit:
|
|
|
|
if (rewind)
|
|
|
|
pdu->offset = offset;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_parse_header);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p9_check_errors - check 9p packet for error return and process it
|
|
|
|
* @c: current client instance
|
|
|
|
* @req: request to parse and check for error conditions
|
|
|
|
*
|
|
|
|
* returns error code if one is discovered, otherwise returns 0
|
|
|
|
*
|
|
|
|
* this will have to be more complicated if we have multiple
|
|
|
|
* error packet types
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int p9_check_errors(struct p9_client *c, struct p9_req_t *req)
|
|
|
|
{
|
|
|
|
int8_t type;
|
|
|
|
int err;
|
2011-02-02 05:04:59 +01:00
|
|
|
int ecode;
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
|
2011-08-06 21:16:59 +02:00
|
|
|
/*
|
|
|
|
* dump the response from server
|
|
|
|
* This should be after check errors which poplulate pdu_fcall.
|
|
|
|
*/
|
|
|
|
trace_9p_protocol_dump(c, req->rc);
|
2008-10-16 15:30:07 +02:00
|
|
|
if (err) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
|
2008-10-16 15:30:07 +02:00
|
|
|
return err;
|
|
|
|
}
|
2011-02-02 05:04:59 +01:00
|
|
|
if (type != P9_RERROR && type != P9_RLERROR)
|
|
|
|
return 0;
|
2010-07-28 10:47:26 +02:00
|
|
|
|
2011-02-02 05:04:59 +01:00
|
|
|
if (!p9_is_proto_dotl(c)) {
|
|
|
|
char *ename;
|
|
|
|
err = p9pdu_readf(req->rc, c->proto_version, "s?d",
|
2011-08-16 07:20:10 +02:00
|
|
|
&ename, &ecode);
|
2011-02-02 05:04:59 +01:00
|
|
|
if (err)
|
|
|
|
goto out_err;
|
2010-07-28 10:47:26 +02:00
|
|
|
|
2011-02-02 05:04:59 +01:00
|
|
|
if (p9_is_proto_dotu(c))
|
|
|
|
err = -ecode;
|
2010-07-28 10:47:26 +02:00
|
|
|
|
2011-02-02 05:04:59 +01:00
|
|
|
if (!err || !IS_ERR_VALUE(err)) {
|
|
|
|
err = p9_errstr2errno(ename, strlen(ename));
|
2010-07-28 10:47:26 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
|
|
|
|
-ecode, ename);
|
2010-07-28 10:47:26 +02:00
|
|
|
}
|
2011-08-16 07:20:10 +02:00
|
|
|
kfree(ename);
|
2011-02-02 05:04:59 +01:00
|
|
|
} else {
|
|
|
|
err = p9pdu_readf(req->rc, c->proto_version, "d", &ecode);
|
|
|
|
err = -ecode;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
|
2011-02-02 05:04:59 +01:00
|
|
|
}
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
return err;
|
2010-07-28 10:47:26 +02:00
|
|
|
|
|
|
|
out_err:
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
|
2010-07-28 10:47:26 +02:00
|
|
|
|
|
|
|
return err;
|
2008-10-16 15:30:07 +02:00
|
|
|
}
|
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
/**
|
|
|
|
* p9_check_zc_errors - check 9p packet for error return and process it
|
|
|
|
* @c: current client instance
|
|
|
|
* @req: request to parse and check for error conditions
|
|
|
|
* @in_hdrlen: Size of response protocol buffer.
|
|
|
|
*
|
|
|
|
* returns error code if one is discovered, otherwise returns 0
|
|
|
|
*
|
|
|
|
* this will have to be more complicated if we have multiple
|
|
|
|
* error packet types
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int p9_check_zc_errors(struct p9_client *c, struct p9_req_t *req,
|
|
|
|
char *uidata, int in_hdrlen, int kern_buf)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int ecode;
|
|
|
|
int8_t type;
|
|
|
|
char *ename = NULL;
|
|
|
|
|
|
|
|
err = p9_parse_header(req->rc, NULL, &type, NULL, 0);
|
2011-08-06 21:16:59 +02:00
|
|
|
/*
|
|
|
|
* dump the response from server
|
|
|
|
* This should be after parse_header which poplulate pdu_fcall.
|
|
|
|
*/
|
|
|
|
trace_9p_protocol_dump(c, req->rc);
|
2011-08-16 07:20:10 +02:00
|
|
|
if (err) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "couldn't parse header %d\n", err);
|
2011-08-16 07:20:10 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type != P9_RERROR && type != P9_RLERROR)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!p9_is_proto_dotl(c)) {
|
|
|
|
/* Error is reported in string format */
|
2013-05-20 19:35:15 +02:00
|
|
|
int len;
|
|
|
|
/* 7 = header size for RERROR; */
|
|
|
|
int inline_len = in_hdrlen - 7;
|
2011-08-16 07:20:10 +02:00
|
|
|
|
2013-05-20 19:35:15 +02:00
|
|
|
len = req->rc->size - req->rc->offset;
|
|
|
|
if (len > (P9_ZC_HDR_SZ - 7)) {
|
|
|
|
err = -EFAULT;
|
2011-08-16 07:20:10 +02:00
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
|
2013-05-20 19:35:15 +02:00
|
|
|
ename = &req->rc->sdata[req->rc->offset];
|
|
|
|
if (len > inline_len) {
|
|
|
|
/* We have error in external buffer */
|
2011-08-16 07:20:10 +02:00
|
|
|
if (kern_buf) {
|
|
|
|
memcpy(ename + inline_len, uidata,
|
|
|
|
len - inline_len);
|
|
|
|
} else {
|
|
|
|
err = copy_from_user(ename + inline_len,
|
|
|
|
uidata, len - inline_len);
|
|
|
|
if (err) {
|
|
|
|
err = -EFAULT;
|
2013-05-20 19:35:15 +02:00
|
|
|
goto out_err;
|
2011-08-16 07:20:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-05-20 19:35:15 +02:00
|
|
|
ename = NULL;
|
|
|
|
err = p9pdu_readf(req->rc, c->proto_version, "s?d",
|
|
|
|
&ename, &ecode);
|
|
|
|
if (err)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
if (p9_is_proto_dotu(c))
|
2011-08-16 07:20:10 +02:00
|
|
|
err = -ecode;
|
2013-05-20 19:35:15 +02:00
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
if (!err || !IS_ERR_VALUE(err)) {
|
|
|
|
err = p9_errstr2errno(ename, strlen(ename));
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RERROR (%d) %s\n",
|
|
|
|
-ecode, ename);
|
2011-08-16 07:20:10 +02:00
|
|
|
}
|
|
|
|
kfree(ename);
|
|
|
|
} else {
|
|
|
|
err = p9pdu_readf(req->rc, c->proto_version, "d", &ecode);
|
|
|
|
err = -ecode;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RLERROR (%d)\n", -ecode);
|
2011-08-16 07:20:10 +02:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
|
|
|
|
out_err:
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "couldn't parse error%d\n", err);
|
2011-08-16 07:20:10 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-05-08 20:46:38 +02:00
|
|
|
static struct p9_req_t *
|
|
|
|
p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...);
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
/**
|
|
|
|
* p9_client_flush - flush (cancel) a request
|
2009-07-19 21:41:55 +02:00
|
|
|
* @c: client state
|
|
|
|
* @oldreq: request to cancel
|
2008-10-16 15:30:07 +02:00
|
|
|
*
|
2011-05-08 20:46:38 +02:00
|
|
|
* This sents a flush for a particular request and links
|
2008-10-16 15:30:07 +02:00
|
|
|
* the flush request to the original request. The current
|
|
|
|
* code only supports a single flush request although the protocol
|
|
|
|
* allows for multiple flush requests to be sent for a single request.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int p9_client_flush(struct p9_client *c, struct p9_req_t *oldreq)
|
|
|
|
{
|
|
|
|
struct p9_req_t *req;
|
|
|
|
int16_t oldtag;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = p9_parse_header(oldreq->tc, NULL, NULL, &oldtag, 1);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TFLUSH tag %d\n", oldtag);
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
req = p9_client_rpc(c, P9_TFLUSH, "w", oldtag);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
|
|
|
|
2013-06-21 15:32:42 +02:00
|
|
|
/*
|
|
|
|
* if we haven't received a response for oldreq,
|
2013-06-21 15:32:43 +02:00
|
|
|
* remove it from the list, and notify the transport
|
|
|
|
* layer that the reply will never arrive.
|
2013-06-21 15:32:42 +02:00
|
|
|
*/
|
2009-04-05 23:28:59 +02:00
|
|
|
spin_lock(&c->lock);
|
2013-06-21 15:32:43 +02:00
|
|
|
if (oldreq->status == REQ_STATUS_FLSH) {
|
2009-04-05 23:28:59 +02:00
|
|
|
list_del(&oldreq->req_list);
|
2013-06-21 15:32:43 +02:00
|
|
|
spin_unlock(&c->lock);
|
|
|
|
if (c->trans_mod->cancelled)
|
|
|
|
c->trans_mod->cancelled(c, req);
|
|
|
|
} else {
|
|
|
|
spin_unlock(&c->lock);
|
|
|
|
}
|
2009-04-05 23:28:59 +02:00
|
|
|
|
|
|
|
p9_free_req(c, req);
|
2008-10-16 15:30:07 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
static struct p9_req_t *p9_client_prepare_req(struct p9_client *c,
|
|
|
|
int8_t type, int req_size,
|
|
|
|
const char *fmt, va_list ap)
|
2008-10-14 01:45:21 +02:00
|
|
|
{
|
2008-10-16 15:30:07 +02:00
|
|
|
int tag, err;
|
2008-10-14 01:45:21 +02:00
|
|
|
struct p9_req_t *req;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "client %p op %d\n", c, type);
|
2008-10-14 01:45:21 +02:00
|
|
|
|
2010-03-30 01:13:59 +02:00
|
|
|
/* we allow for any status other than disconnected */
|
|
|
|
if (c->status == Disconnected)
|
|
|
|
return ERR_PTR(-EIO);
|
|
|
|
|
|
|
|
/* if status is begin_disconnected we allow only clunk request */
|
|
|
|
if ((c->status == BeginDisconnect) && (type != P9_TCLUNK))
|
2008-10-16 15:30:07 +02:00
|
|
|
return ERR_PTR(-EIO);
|
2008-10-14 01:45:21 +02:00
|
|
|
|
|
|
|
tag = P9_NOTAG;
|
2008-10-16 15:30:07 +02:00
|
|
|
if (type != P9_TVERSION) {
|
2008-10-14 01:45:21 +02:00
|
|
|
tag = p9_idpool_get(c->tagpool);
|
|
|
|
if (tag < 0)
|
2008-10-16 15:30:07 +02:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-10-14 01:45:21 +02:00
|
|
|
}
|
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
req = p9_tag_alloc(c, tag, req_size);
|
2008-10-16 15:30:07 +02:00
|
|
|
if (IS_ERR(req))
|
|
|
|
return req;
|
2008-10-14 01:45:21 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
/* marshall the data */
|
|
|
|
p9pdu_prepare(req->tc, tag, type);
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_vwritef(req->tc, c->proto_version, fmt, ap);
|
2010-10-19 05:47:02 +02:00
|
|
|
if (err)
|
|
|
|
goto reterr;
|
2011-08-06 21:16:59 +02:00
|
|
|
p9pdu_finalize(c, req->tc);
|
|
|
|
trace_9p_client_req(c, type, tag);
|
2011-08-16 07:20:10 +02:00
|
|
|
return req;
|
|
|
|
reterr:
|
|
|
|
p9_free_req(c, req);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p9_client_rpc - issue a request and wait for a response
|
|
|
|
* @c: client session
|
|
|
|
* @type: type of request
|
|
|
|
* @fmt: protocol format string (see protocol.c)
|
|
|
|
*
|
|
|
|
* Returns request structure (which client must free using p9_free_req)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct p9_req_t *
|
|
|
|
p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int sigpending, err;
|
|
|
|
unsigned long flags;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
req = p9_client_prepare_req(c, type, c->msize, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return req;
|
|
|
|
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
sigpending = 1;
|
|
|
|
clear_thread_flag(TIF_SIGPENDING);
|
|
|
|
} else
|
|
|
|
sigpending = 0;
|
2008-10-14 01:45:21 +02:00
|
|
|
|
|
|
|
err = c->trans_mod->request(c, req);
|
|
|
|
if (err < 0) {
|
2011-04-15 10:29:33 +02:00
|
|
|
if (err != -ERESTARTSYS && err != -EFAULT)
|
2010-09-30 03:33:41 +02:00
|
|
|
c->status = Disconnected;
|
2008-10-14 01:45:21 +02:00
|
|
|
goto reterr;
|
|
|
|
}
|
2012-02-01 21:48:53 +01:00
|
|
|
again:
|
2011-08-16 07:20:10 +02:00
|
|
|
/* Wait for the response */
|
2008-10-14 01:45:21 +02:00
|
|
|
err = wait_event_interruptible(*req->wq,
|
2011-08-16 07:20:10 +02:00
|
|
|
req->status >= REQ_STATUS_RCVD);
|
2008-10-14 01:45:21 +02:00
|
|
|
|
2012-02-01 21:48:53 +01:00
|
|
|
if ((err == -ERESTARTSYS) && (c->status == Connected)
|
|
|
|
&& (type == P9_TFLUSH)) {
|
|
|
|
sigpending = 1;
|
|
|
|
clear_thread_flag(TIF_SIGPENDING);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2008-10-14 01:45:21 +02:00
|
|
|
if (req->status == REQ_STATUS_ERROR) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
|
2008-10-14 01:45:21 +02:00
|
|
|
err = req->t_err;
|
|
|
|
}
|
2009-04-05 23:28:59 +02:00
|
|
|
if ((err == -ERESTARTSYS) && (c->status == Connected)) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "flushing\n");
|
2008-10-14 01:45:21 +02:00
|
|
|
sigpending = 1;
|
|
|
|
clear_thread_flag(TIF_SIGPENDING);
|
|
|
|
|
2009-04-05 23:28:59 +02:00
|
|
|
if (c->trans_mod->cancel(c, req))
|
|
|
|
p9_client_flush(c, req);
|
|
|
|
|
|
|
|
/* if we received the response anyway, don't signal error */
|
|
|
|
if (req->status == REQ_STATUS_RCVD)
|
|
|
|
err = 0;
|
2008-10-14 01:45:21 +02:00
|
|
|
}
|
|
|
|
if (sigpending) {
|
|
|
|
spin_lock_irqsave(¤t->sighand->siglock, flags);
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
|
|
|
|
}
|
|
|
|
if (err < 0)
|
|
|
|
goto reterr;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
err = p9_check_errors(c, req);
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_client_res(c, type, req->rc->tag, err);
|
|
|
|
if (!err)
|
2008-10-16 15:30:07 +02:00
|
|
|
return req;
|
2011-08-16 07:20:10 +02:00
|
|
|
reterr:
|
|
|
|
p9_free_req(c, req);
|
2012-08-10 15:52:06 +02:00
|
|
|
return ERR_PTR(safe_errno(err));
|
2011-08-16 07:20:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* p9_client_zc_rpc - issue a request and wait for a response
|
|
|
|
* @c: client session
|
|
|
|
* @type: type of request
|
|
|
|
* @uidata: user bffer that should be ued for zero copy read
|
|
|
|
* @uodata: user buffer that shoud be user for zero copy write
|
|
|
|
* @inlen: read buffer size
|
|
|
|
* @olen: write buffer size
|
|
|
|
* @hdrlen: reader header size, This is the size of response protocol data
|
|
|
|
* @fmt: protocol format string (see protocol.c)
|
|
|
|
*
|
|
|
|
* Returns request structure (which client must free using p9_free_req)
|
|
|
|
*/
|
|
|
|
static struct p9_req_t *p9_client_zc_rpc(struct p9_client *c, int8_t type,
|
|
|
|
char *uidata, char *uodata,
|
|
|
|
int inlen, int olen, int in_hdrlen,
|
|
|
|
int kern_buf, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
int sigpending, err;
|
|
|
|
unsigned long flags;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
/*
|
|
|
|
* We allocate a inline protocol data of only 4k bytes.
|
|
|
|
* The actual content is passed in zero-copy fashion.
|
|
|
|
*/
|
|
|
|
req = p9_client_prepare_req(c, type, P9_ZC_HDR_SZ, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return req;
|
|
|
|
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
sigpending = 1;
|
|
|
|
clear_thread_flag(TIF_SIGPENDING);
|
|
|
|
} else
|
|
|
|
sigpending = 0;
|
|
|
|
|
|
|
|
/* If we are called with KERNEL_DS force kern_buf */
|
|
|
|
if (segment_eq(get_fs(), KERNEL_DS))
|
|
|
|
kern_buf = 1;
|
|
|
|
|
|
|
|
err = c->trans_mod->zc_request(c, req, uidata, uodata,
|
|
|
|
inlen, olen, in_hdrlen, kern_buf);
|
|
|
|
if (err < 0) {
|
|
|
|
if (err == -EIO)
|
|
|
|
c->status = Disconnected;
|
|
|
|
goto reterr;
|
|
|
|
}
|
|
|
|
if (req->status == REQ_STATUS_ERROR) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "req_status error %d\n", req->t_err);
|
2011-08-16 07:20:10 +02:00
|
|
|
err = req->t_err;
|
|
|
|
}
|
|
|
|
if ((err == -ERESTARTSYS) && (c->status == Connected)) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "flushing\n");
|
2011-08-16 07:20:10 +02:00
|
|
|
sigpending = 1;
|
|
|
|
clear_thread_flag(TIF_SIGPENDING);
|
2008-10-14 01:45:21 +02:00
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
if (c->trans_mod->cancel(c, req))
|
|
|
|
p9_client_flush(c, req);
|
|
|
|
|
|
|
|
/* if we received the response anyway, don't signal error */
|
|
|
|
if (req->status == REQ_STATUS_RCVD)
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
if (sigpending) {
|
|
|
|
spin_lock_irqsave(¤t->sighand->siglock, flags);
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
|
|
|
|
}
|
|
|
|
if (err < 0)
|
|
|
|
goto reterr;
|
|
|
|
|
|
|
|
err = p9_check_zc_errors(c, req, uidata, in_hdrlen, kern_buf);
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_client_res(c, type, req->rc->tag, err);
|
|
|
|
if (!err)
|
2011-08-16 07:20:10 +02:00
|
|
|
return req;
|
2008-10-14 01:45:21 +02:00
|
|
|
reterr:
|
|
|
|
p9_free_req(c, req);
|
2012-08-10 15:52:06 +02:00
|
|
|
return ERR_PTR(safe_errno(err));
|
2008-10-14 01:45:21 +02:00
|
|
|
}
|
|
|
|
|
2008-10-14 01:45:24 +02:00
|
|
|
static struct p9_fid *p9_fid_create(struct p9_client *clnt)
|
|
|
|
{
|
2008-10-28 20:22:43 +01:00
|
|
|
int ret;
|
2008-10-14 01:45:24 +02:00
|
|
|
struct p9_fid *fid;
|
2008-10-23 23:31:02 +02:00
|
|
|
unsigned long flags;
|
2008-10-14 01:45:24 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_FID, "clnt %p\n", clnt);
|
2008-10-14 01:45:24 +02:00
|
|
|
fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
|
|
|
|
if (!fid)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2008-10-28 20:22:43 +01:00
|
|
|
ret = p9_idpool_get(clnt->fidpool);
|
2009-01-19 06:32:11 +01:00
|
|
|
if (ret < 0) {
|
2008-10-28 20:22:43 +01:00
|
|
|
ret = -ENOSPC;
|
2008-10-14 01:45:24 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2008-10-28 20:22:43 +01:00
|
|
|
fid->fid = ret;
|
2008-10-14 01:45:24 +02:00
|
|
|
|
|
|
|
memset(&fid->qid, 0, sizeof(struct p9_qid));
|
|
|
|
fid->mode = -1;
|
2008-11-14 00:38:44 +01:00
|
|
|
fid->uid = current_fsuid();
|
2008-10-14 01:45:24 +02:00
|
|
|
fid->clnt = clnt;
|
2009-11-02 15:39:28 +01:00
|
|
|
fid->rdir = NULL;
|
2008-10-23 23:31:02 +02:00
|
|
|
spin_lock_irqsave(&clnt->lock, flags);
|
2008-10-14 01:45:24 +02:00
|
|
|
list_add(&fid->flist, &clnt->fidlist);
|
2008-10-23 23:31:02 +02:00
|
|
|
spin_unlock_irqrestore(&clnt->lock, flags);
|
2008-10-14 01:45:24 +02:00
|
|
|
|
|
|
|
return fid;
|
|
|
|
|
|
|
|
error:
|
|
|
|
kfree(fid);
|
2008-10-28 20:22:43 +01:00
|
|
|
return ERR_PTR(ret);
|
2008-10-14 01:45:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void p9_fid_destroy(struct p9_fid *fid)
|
|
|
|
{
|
|
|
|
struct p9_client *clnt;
|
2008-10-23 23:31:02 +02:00
|
|
|
unsigned long flags;
|
2008-10-14 01:45:24 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_FID, "fid %d\n", fid->fid);
|
2008-10-14 01:45:24 +02:00
|
|
|
clnt = fid->clnt;
|
|
|
|
p9_idpool_put(fid->fid, clnt->fidpool);
|
2008-10-23 23:31:02 +02:00
|
|
|
spin_lock_irqsave(&clnt->lock, flags);
|
2008-10-14 01:45:24 +02:00
|
|
|
list_del(&fid->flist);
|
2008-10-23 23:31:02 +02:00
|
|
|
spin_unlock_irqrestore(&clnt->lock, flags);
|
2009-11-02 15:39:28 +01:00
|
|
|
kfree(fid->rdir);
|
2008-10-14 01:45:24 +02:00
|
|
|
kfree(fid);
|
|
|
|
}
|
2008-02-07 02:25:03 +01:00
|
|
|
|
2010-10-19 08:48:16 +02:00
|
|
|
static int p9_client_version(struct p9_client *c)
|
2007-07-11 00:57:28 +02:00
|
|
|
{
|
2008-10-14 03:36:14 +02:00
|
|
|
int err = 0;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
|
|
|
char *version;
|
|
|
|
int msize;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TVERSION msize %d protocol %d\n",
|
|
|
|
c->msize, c->proto_version);
|
2010-03-05 19:51:04 +01:00
|
|
|
|
|
|
|
switch (c->proto_version) {
|
2010-03-08 18:33:04 +01:00
|
|
|
case p9_proto_2000L:
|
2010-03-05 19:51:04 +01:00
|
|
|
req = p9_client_rpc(c, P9_TVERSION, "ds",
|
2010-03-08 18:33:04 +01:00
|
|
|
c->msize, "9P2000.L");
|
2010-03-05 19:51:04 +01:00
|
|
|
break;
|
|
|
|
case p9_proto_2000u:
|
|
|
|
req = p9_client_rpc(c, P9_TVERSION, "ds",
|
|
|
|
c->msize, "9P2000.u");
|
|
|
|
break;
|
|
|
|
case p9_proto_legacy:
|
|
|
|
req = p9_client_rpc(c, P9_TVERSION, "ds",
|
|
|
|
c->msize, "9P2000");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
2008-10-14 03:36:14 +02:00
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, c->proto_version, "ds", &msize, &version);
|
2008-10-16 15:30:07 +02:00
|
|
|
if (err) {
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "version error %d\n", err);
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(c, req->rc);
|
2008-10-14 03:36:14 +02:00
|
|
|
goto error;
|
2008-10-16 15:30:07 +02:00
|
|
|
}
|
2008-10-14 03:36:14 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RVERSION msize %d %s\n", msize, version);
|
2010-03-08 18:33:04 +01:00
|
|
|
if (!strncmp(version, "9P2000.L", 8))
|
|
|
|
c->proto_version = p9_proto_2000L;
|
2010-03-05 19:51:04 +01:00
|
|
|
else if (!strncmp(version, "9P2000.u", 8))
|
2010-03-05 19:50:14 +01:00
|
|
|
c->proto_version = p9_proto_2000u;
|
|
|
|
else if (!strncmp(version, "9P2000", 6))
|
|
|
|
c->proto_version = p9_proto_legacy;
|
2008-10-14 03:36:14 +02:00
|
|
|
else {
|
|
|
|
err = -EREMOTEIO;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
if (msize < c->msize)
|
|
|
|
c->msize = msize;
|
2008-10-14 03:36:14 +02:00
|
|
|
|
|
|
|
error:
|
2008-10-16 15:30:07 +02:00
|
|
|
kfree(version);
|
|
|
|
p9_free_req(c, req);
|
2008-10-14 03:36:14 +02:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct p9_client *p9_client_create(const char *dev_name, char *options)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
2013-08-21 19:24:47 +02:00
|
|
|
char *client_id;
|
2008-10-14 03:36:14 +02:00
|
|
|
|
|
|
|
err = 0;
|
2007-07-11 00:57:28 +02:00
|
|
|
clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
|
|
|
|
if (!clnt)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2008-09-24 23:22:23 +02:00
|
|
|
clnt->trans_mod = NULL;
|
2008-03-07 17:53:53 +01:00
|
|
|
clnt->trans = NULL;
|
2013-08-21 19:24:47 +02:00
|
|
|
|
|
|
|
client_id = utsname()->nodename;
|
|
|
|
memcpy(clnt->name, client_id, strlen(client_id) + 1);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
spin_lock_init(&clnt->lock);
|
|
|
|
INIT_LIST_HEAD(&clnt->fidlist);
|
|
|
|
|
2011-05-20 20:55:52 +02:00
|
|
|
err = p9_tag_init(clnt);
|
|
|
|
if (err < 0)
|
|
|
|
goto free_client;
|
2008-10-14 01:45:23 +02:00
|
|
|
|
2008-03-07 17:53:53 +01:00
|
|
|
err = parse_opts(options, clnt);
|
|
|
|
if (err < 0)
|
2011-05-20 20:55:52 +02:00
|
|
|
goto destroy_tagpool;
|
2008-03-07 17:53:53 +01:00
|
|
|
|
2013-05-20 08:50:55 +02:00
|
|
|
if (!clnt->trans_mod)
|
|
|
|
clnt->trans_mod = v9fs_get_trans_by_name("virtio");
|
|
|
|
|
2009-07-14 20:24:10 +02:00
|
|
|
if (!clnt->trans_mod)
|
|
|
|
clnt->trans_mod = v9fs_get_default_trans();
|
|
|
|
|
2008-02-07 02:25:03 +01:00
|
|
|
if (clnt->trans_mod == NULL) {
|
|
|
|
err = -EPROTONOSUPPORT;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"No transport defined or default transport\n");
|
2011-05-20 20:55:52 +02:00
|
|
|
goto destroy_tagpool;
|
2010-02-09 01:18:34 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
clnt->fidpool = p9_idpool_create();
|
|
|
|
if (IS_ERR(clnt->fidpool)) {
|
|
|
|
err = PTR_ERR(clnt->fidpool);
|
|
|
|
goto put_trans;
|
2008-02-07 02:25:03 +01:00
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "clnt %p trans %p msize %d protocol %d\n",
|
|
|
|
clnt, clnt->trans_mod, clnt->msize, clnt->proto_version);
|
2008-02-07 02:25:03 +01:00
|
|
|
|
2008-10-14 01:45:25 +02:00
|
|
|
err = clnt->trans_mod->create(clnt, dev_name, options);
|
|
|
|
if (err)
|
2010-02-09 01:18:34 +01:00
|
|
|
goto destroy_fidpool;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-06-30 03:06:33 +02:00
|
|
|
if (clnt->msize > clnt->trans_mod->maxsize)
|
|
|
|
clnt->msize = clnt->trans_mod->maxsize;
|
2008-02-07 02:25:03 +01:00
|
|
|
|
2008-10-14 03:36:14 +02:00
|
|
|
err = p9_client_version(clnt);
|
2007-07-11 00:57:28 +02:00
|
|
|
if (err)
|
2010-02-09 01:18:34 +01:00
|
|
|
goto close_trans;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
return clnt;
|
|
|
|
|
2010-02-09 01:18:34 +01:00
|
|
|
close_trans:
|
|
|
|
clnt->trans_mod->close(clnt);
|
|
|
|
destroy_fidpool:
|
|
|
|
p9_idpool_destroy(clnt->fidpool);
|
|
|
|
put_trans:
|
|
|
|
v9fs_put_trans(clnt->trans_mod);
|
2011-05-20 20:55:52 +02:00
|
|
|
destroy_tagpool:
|
|
|
|
p9_idpool_destroy(clnt->tagpool);
|
2010-02-09 01:18:34 +01:00
|
|
|
free_client:
|
|
|
|
kfree(clnt);
|
2007-07-11 00:57:28 +02:00
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_create);
|
|
|
|
|
|
|
|
void p9_client_destroy(struct p9_client *clnt)
|
|
|
|
{
|
|
|
|
struct p9_fid *fid, *fidptr;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_MUX, "clnt %p\n", clnt);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-14 01:45:25 +02:00
|
|
|
if (clnt->trans_mod)
|
|
|
|
clnt->trans_mod->close(clnt);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-09-24 23:22:23 +02:00
|
|
|
v9fs_put_trans(clnt->trans_mod);
|
|
|
|
|
2010-03-30 01:13:59 +02:00
|
|
|
list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist) {
|
2011-11-28 19:40:46 +01:00
|
|
|
pr_info("Found fid %d not clunked\n", fid->fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
p9_fid_destroy(fid);
|
2010-03-30 01:13:59 +02:00
|
|
|
}
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2007-07-13 23:47:58 +02:00
|
|
|
if (clnt->fidpool)
|
|
|
|
p9_idpool_destroy(clnt->fidpool);
|
|
|
|
|
2008-10-14 01:45:23 +02:00
|
|
|
p9_tag_cleanup(clnt);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
kfree(clnt);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_destroy);
|
|
|
|
|
|
|
|
void p9_client_disconnect(struct p9_client *clnt)
|
|
|
|
{
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
|
2008-10-14 01:45:25 +02:00
|
|
|
clnt->status = Disconnected;
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_disconnect);
|
|
|
|
|
2010-03-30 01:13:59 +02:00
|
|
|
void p9_client_begin_disconnect(struct p9_client *clnt)
|
|
|
|
{
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "clnt %p\n", clnt);
|
2010-03-30 01:13:59 +02:00
|
|
|
clnt->status = BeginDisconnect;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_begin_disconnect);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
|
2013-01-30 01:09:41 +01:00
|
|
|
char *uname, kuid_t n_uname, char *aname)
|
2007-07-11 00:57:28 +02:00
|
|
|
{
|
2011-08-06 21:16:59 +02:00
|
|
|
int err = 0;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
2007-07-11 00:57:28 +02:00
|
|
|
struct p9_fid *fid;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_qid qid;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TATTACH afid %d uname %s aname %s\n",
|
|
|
|
afid ? afid->fid : -1, uname, aname);
|
2007-07-11 00:57:28 +02:00
|
|
|
fid = p9_fid_create(clnt);
|
|
|
|
if (IS_ERR(fid)) {
|
|
|
|
err = PTR_ERR(fid);
|
|
|
|
fid = NULL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2013-01-30 01:09:41 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TATTACH, "ddss?u", fid->fid,
|
2008-10-16 15:30:07 +02:00
|
|
|
afid ? afid->fid : P9_NOFID, uname, aname, n_uname);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
2007-07-11 00:57:28 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", &qid);
|
2008-10-16 15:30:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2008-10-16 15:30:07 +02:00
|
|
|
p9_free_req(clnt, req);
|
2007-07-11 00:57:28 +02:00
|
|
|
goto error;
|
2008-10-16 15:30:07 +02:00
|
|
|
}
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RATTACH qid %x.%llx.%x\n",
|
|
|
|
qid.type, (unsigned long long)qid.path, qid.version);
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
memmove(&fid->qid, &qid, sizeof(struct p9_qid));
|
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
2007-07-11 00:57:28 +02:00
|
|
|
return fid;
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (fid)
|
|
|
|
p9_fid_destroy(fid);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_attach);
|
|
|
|
|
2011-03-31 12:19:39 +02:00
|
|
|
struct p9_fid *p9_client_walk(struct p9_fid *oldfid, uint16_t nwname,
|
|
|
|
char **wnames, int clone)
|
2007-07-11 00:57:28 +02:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_fid *fid;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_qid *wqids;
|
|
|
|
struct p9_req_t *req;
|
2011-03-31 12:19:39 +02:00
|
|
|
uint16_t nwqids, count;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
err = 0;
|
2010-08-24 20:13:59 +02:00
|
|
|
wqids = NULL;
|
2007-07-11 00:57:28 +02:00
|
|
|
clnt = oldfid->clnt;
|
|
|
|
if (clone) {
|
|
|
|
fid = p9_fid_create(clnt);
|
|
|
|
if (IS_ERR(fid)) {
|
|
|
|
err = PTR_ERR(fid);
|
|
|
|
fid = NULL;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
fid->uid = oldfid->uid;
|
|
|
|
} else
|
|
|
|
fid = oldfid;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TWALK fids %d,%d nwname %ud wname[0] %s\n",
|
|
|
|
oldfid->fid, fid->fid, nwname, wnames ? wnames[0] : NULL);
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TWALK, "ddT", oldfid->fid, fid->fid,
|
|
|
|
nwname, wnames);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
2007-07-11 00:57:28 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "R", &nwqids, &wqids);
|
2008-10-17 23:20:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2008-10-17 23:20:07 +02:00
|
|
|
p9_free_req(clnt, req);
|
2008-10-16 15:30:07 +02:00
|
|
|
goto clunk_fid;
|
2008-10-17 23:20:07 +02:00
|
|
|
}
|
|
|
|
p9_free_req(clnt, req);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RWALK nwqid %d:\n", nwqids);
|
2008-10-16 15:30:07 +02:00
|
|
|
|
|
|
|
if (nwqids != nwname) {
|
2007-07-11 00:57:28 +02:00
|
|
|
err = -ENOENT;
|
|
|
|
goto clunk_fid;
|
|
|
|
}
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
for (count = 0; count < nwqids; count++)
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< [%d] %x.%llx.%x\n",
|
net/9p: fix printk format warnings
Fix printk format warnings in net/9p.
Built cleanly on 7 arches.
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 6 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2008-11-05 05:46:46 +01:00
|
|
|
count, wqids[count].type,
|
|
|
|
(unsigned long long)wqids[count].path,
|
2008-10-16 15:30:07 +02:00
|
|
|
wqids[count].version);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
if (nwname)
|
2008-10-16 15:30:07 +02:00
|
|
|
memmove(&fid->qid, &wqids[nwqids - 1], sizeof(struct p9_qid));
|
2007-07-11 00:57:28 +02:00
|
|
|
else
|
|
|
|
fid->qid = oldfid->qid;
|
|
|
|
|
2010-08-24 20:13:59 +02:00
|
|
|
kfree(wqids);
|
2007-07-11 00:57:28 +02:00
|
|
|
return fid;
|
|
|
|
|
|
|
|
clunk_fid:
|
2010-08-24 20:13:59 +02:00
|
|
|
kfree(wqids);
|
2008-10-16 15:30:07 +02:00
|
|
|
p9_client_clunk(fid);
|
|
|
|
fid = NULL;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
error:
|
|
|
|
if (fid && (fid != oldfid))
|
|
|
|
p9_fid_destroy(fid);
|
|
|
|
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_walk);
|
|
|
|
|
|
|
|
int p9_client_open(struct p9_fid *fid, int mode)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_qid qid;
|
|
|
|
int iounit;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> %s fid %d mode %d\n",
|
2010-06-22 16:17:50 +02:00
|
|
|
p9_is_proto_dotl(clnt) ? "TLOPEN" : "TOPEN", fid->fid, mode);
|
|
|
|
err = 0;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
if (fid->mode != -1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-06-22 16:17:50 +02:00
|
|
|
if (p9_is_proto_dotl(clnt))
|
|
|
|
req = p9_client_rpc(clnt, P9_TLOPEN, "dd", fid->fid, mode);
|
|
|
|
else
|
|
|
|
req = p9_client_rpc(clnt, P9_TOPEN, "db", fid->fid, mode);
|
2008-10-16 15:30:07 +02:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
|
2008-10-17 23:20:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2008-10-17 23:20:07 +02:00
|
|
|
goto free_and_error;
|
|
|
|
}
|
2008-10-16 15:30:07 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< %s qid %x.%llx.%x iounit %x\n",
|
2010-06-22 16:17:50 +02:00
|
|
|
p9_is_proto_dotl(clnt) ? "RLOPEN" : "ROPEN", qid.type,
|
|
|
|
(unsigned long long)qid.path, qid.version, iounit);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
fid->mode = mode;
|
2008-10-16 15:30:07 +02:00
|
|
|
fid->iounit = iounit;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-17 23:20:07 +02:00
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
2008-10-16 15:30:07 +02:00
|
|
|
error:
|
2007-07-11 00:57:28 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_open);
|
|
|
|
|
2010-06-18 03:27:46 +02:00
|
|
|
int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
|
2013-01-30 01:09:41 +01:00
|
|
|
kgid_t gid, struct p9_qid *qid)
|
2010-06-18 03:27:46 +02:00
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
int iounit;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P,
|
2010-06-18 03:27:46 +02:00
|
|
|
">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
|
2013-01-30 01:09:41 +01:00
|
|
|
ofid->fid, name, flags, mode,
|
|
|
|
from_kgid(&init_user_ns, gid));
|
2010-06-18 03:27:46 +02:00
|
|
|
clnt = ofid->clnt;
|
|
|
|
|
|
|
|
if (ofid->mode != -1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-01-30 01:09:41 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TLCREATE, "dsddg", ofid->fid, name, flags,
|
2010-06-18 03:27:46 +02:00
|
|
|
mode, gid);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", qid, &iounit);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-06-18 03:27:46 +02:00
|
|
|
goto free_and_error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
|
2010-06-18 03:27:46 +02:00
|
|
|
qid->type,
|
|
|
|
(unsigned long long)qid->path,
|
|
|
|
qid->version, iounit);
|
|
|
|
|
|
|
|
ofid->mode = mode;
|
|
|
|
ofid->iounit = iounit;
|
|
|
|
|
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_create_dotl);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
|
|
|
|
char *extension)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_qid qid;
|
|
|
|
int iounit;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TCREATE fid %d name %s perm %d mode %d\n",
|
2008-10-16 15:30:07 +02:00
|
|
|
fid->fid, name, perm, mode);
|
2007-07-11 00:57:28 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
|
|
|
if (fid->mode != -1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
req = p9_client_rpc(clnt, P9_TCREATE, "dsdb?s", fid->fid, name, perm,
|
|
|
|
mode, extension);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", &qid, &iounit);
|
2008-10-17 23:20:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2008-10-17 23:20:07 +02:00
|
|
|
goto free_and_error;
|
|
|
|
}
|
2008-10-16 15:30:07 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RCREATE qid %x.%llx.%x iounit %x\n",
|
net/9p: fix printk format warnings
Fix printk format warnings in net/9p.
Built cleanly on 7 arches.
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 6 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2008-11-05 05:46:46 +01:00
|
|
|
qid.type,
|
|
|
|
(unsigned long long)qid.path,
|
|
|
|
qid.version, iounit);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
fid->mode = mode;
|
2008-10-16 15:30:07 +02:00
|
|
|
fid->iounit = iounit;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-17 23:20:07 +02:00
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
2008-10-16 15:30:07 +02:00
|
|
|
error:
|
2007-07-11 00:57:28 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_fcreate);
|
|
|
|
|
2013-01-30 01:09:41 +01:00
|
|
|
int p9_client_symlink(struct p9_fid *dfid, char *name, char *symtgt, kgid_t gid,
|
2010-06-10 00:59:31 +02:00
|
|
|
struct p9_qid *qid)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TSYMLINK dfid %d name %s symtgt %s\n",
|
2010-06-10 00:59:31 +02:00
|
|
|
dfid->fid, name, symtgt);
|
|
|
|
clnt = dfid->clnt;
|
|
|
|
|
2013-01-30 01:09:41 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TSYMLINK, "dssg", dfid->fid, name, symtgt,
|
2010-06-10 00:59:31 +02:00
|
|
|
gid);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-06-10 00:59:31 +02:00
|
|
|
goto free_and_error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RSYMLINK qid %x.%llx.%x\n",
|
2010-06-10 00:59:31 +02:00
|
|
|
qid->type, (unsigned long long)qid->path, qid->version);
|
|
|
|
|
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_symlink);
|
|
|
|
|
2010-06-04 00:16:59 +02:00
|
|
|
int p9_client_link(struct p9_fid *dfid, struct p9_fid *oldfid, char *newname)
|
|
|
|
{
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TLINK dfid %d oldfid %d newname %s\n",
|
2010-06-04 00:16:59 +02:00
|
|
|
dfid->fid, oldfid->fid, newname);
|
|
|
|
clnt = dfid->clnt;
|
|
|
|
req = p9_client_rpc(clnt, P9_TLINK, "dds", dfid->fid, oldfid->fid,
|
|
|
|
newname);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RLINK\n");
|
2010-06-04 00:16:59 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_link);
|
|
|
|
|
2010-10-22 19:13:12 +02:00
|
|
|
int p9_client_fsync(struct p9_fid *fid, int datasync)
|
2010-09-23 02:19:19 +02:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TFSYNC fid %d datasync:%d\n",
|
2010-10-22 19:13:12 +02:00
|
|
|
fid->fid, datasync);
|
2010-09-23 02:19:19 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
2010-10-22 19:13:12 +02:00
|
|
|
req = p9_client_rpc(clnt, P9_TFSYNC, "dd", fid->fid, datasync);
|
2010-09-23 02:19:19 +02:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RFSYNC fid %d\n", fid->fid);
|
2010-09-23 02:19:19 +02:00
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_fsync);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
int p9_client_clunk(struct p9_fid *fid)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
2012-02-26 21:49:57 +01:00
|
|
|
int retries = 0;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2010-08-25 18:27:06 +02:00
|
|
|
if (!fid) {
|
2011-11-28 19:40:46 +01:00
|
|
|
pr_warn("%s (%d): Trying to clunk with NULL fid\n",
|
|
|
|
__func__, task_pid_nr(current));
|
2010-08-25 18:27:06 +02:00
|
|
|
dump_stack();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-26 21:49:57 +01:00
|
|
|
again:
|
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TCLUNK fid %d (try %d)\n", fid->fid,
|
|
|
|
retries);
|
2007-07-11 00:57:28 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
req = p9_client_rpc(clnt, P9_TCLUNK, "d", fid->fid);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RCLUNK fid %d\n", fid->fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
2011-07-11 18:40:58 +02:00
|
|
|
/*
|
|
|
|
* Fid is not valid even after a failed clunk
|
2012-02-26 21:49:57 +01:00
|
|
|
* If interrupted, retry once then give up and
|
|
|
|
* leak fid until umount.
|
2011-07-11 18:40:58 +02:00
|
|
|
*/
|
2012-02-26 21:49:57 +01:00
|
|
|
if (err == -ERESTARTSYS) {
|
|
|
|
if (retries++ == 0)
|
|
|
|
goto again;
|
|
|
|
} else
|
|
|
|
p9_fid_destroy(fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_clunk);
|
|
|
|
|
|
|
|
int p9_client_remove(struct p9_fid *fid)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TREMOVE fid %d\n", fid->fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
req = p9_client_rpc(clnt, P9_TREMOVE, "d", fid->fid);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RREMOVE fid %d\n", fid->fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
2012-02-26 21:49:57 +01:00
|
|
|
if (err == -ERESTARTSYS)
|
|
|
|
p9_client_clunk(fid);
|
|
|
|
else
|
|
|
|
p9_fid_destroy(fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_remove);
|
|
|
|
|
2011-06-28 12:11:18 +02:00
|
|
|
int p9_client_unlinkat(struct p9_fid *dfid, const char *name, int flags)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TUNLINKAT fid %d %s %d\n",
|
2011-06-28 12:11:18 +02:00
|
|
|
dfid->fid, name, flags);
|
|
|
|
|
|
|
|
clnt = dfid->clnt;
|
|
|
|
req = p9_client_rpc(clnt, P9_TUNLINKAT, "dsd", dfid->fid, name, flags);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RUNLINKAT fid %d %s\n", dfid->fid, name);
|
2011-06-28 12:11:18 +02:00
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_unlinkat);
|
|
|
|
|
2008-10-14 03:36:17 +02:00
|
|
|
int
|
|
|
|
p9_client_read(struct p9_fid *fid, char *data, char __user *udata, u64 offset,
|
|
|
|
u32 count)
|
2007-07-11 00:57:28 +02:00
|
|
|
{
|
2008-10-16 15:30:07 +02:00
|
|
|
char *dataptr;
|
2011-08-16 07:20:10 +02:00
|
|
|
int kernel_buf = 0;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
int err, rsize, non_zc = 0;
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TREAD fid %d offset %llu %d\n",
|
2012-04-15 07:58:06 +02:00
|
|
|
fid->fid, (unsigned long long) offset, count);
|
2007-07-11 00:57:28 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
|
|
|
rsize = fid->iounit;
|
|
|
|
if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
|
|
|
|
rsize = clnt->msize - P9_IOHDRSZ;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
if (count < rsize)
|
|
|
|
rsize = count;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-05-08 20:46:38 +02:00
|
|
|
/* Don't bother zerocopy for small IO (< 1024) */
|
2011-08-16 07:20:10 +02:00
|
|
|
if (clnt->trans_mod->zc_request && rsize > 1024) {
|
|
|
|
char *indata;
|
|
|
|
if (data) {
|
|
|
|
kernel_buf = 1;
|
|
|
|
indata = data;
|
|
|
|
} else
|
2012-06-04 09:16:14 +02:00
|
|
|
indata = (__force char *)udata;
|
2011-08-16 07:20:10 +02:00
|
|
|
/*
|
|
|
|
* response header len is 11
|
|
|
|
* PDU Header(7) + IO Size (4)
|
|
|
|
*/
|
|
|
|
req = p9_client_zc_rpc(clnt, P9_TREAD, indata, NULL, rsize, 0,
|
|
|
|
11, kernel_buf, "dqd", fid->fid,
|
|
|
|
offset, rsize);
|
2011-01-29 02:05:59 +01:00
|
|
|
} else {
|
2011-08-16 07:20:10 +02:00
|
|
|
non_zc = 1;
|
2011-01-29 02:05:59 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TREAD, "dqd", fid->fid, offset,
|
2011-08-16 07:20:10 +02:00
|
|
|
rsize);
|
2011-01-29 02:05:59 +01:00
|
|
|
}
|
2008-10-16 15:30:07 +02:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
|
2008-10-17 23:20:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2008-10-16 15:30:07 +02:00
|
|
|
goto free_and_error;
|
2008-10-17 23:20:07 +02:00
|
|
|
}
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RREAD count %d\n", count);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
if (non_zc) {
|
2011-01-29 02:05:59 +01:00
|
|
|
if (data) {
|
|
|
|
memmove(data, dataptr, count);
|
|
|
|
} else {
|
|
|
|
err = copy_to_user(udata, dataptr, count);
|
|
|
|
if (err) {
|
|
|
|
err = -EFAULT;
|
|
|
|
goto free_and_error;
|
|
|
|
}
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
2008-10-16 15:30:07 +02:00
|
|
|
}
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return count;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
2007-07-11 00:57:28 +02:00
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
2008-10-14 03:36:17 +02:00
|
|
|
EXPORT_SYMBOL(p9_client_read);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
|
|
|
int
|
2008-10-14 03:36:17 +02:00
|
|
|
p9_client_write(struct p9_fid *fid, char *data, const char __user *udata,
|
|
|
|
u64 offset, u32 count)
|
2007-07-11 00:57:28 +02:00
|
|
|
{
|
2011-04-13 00:58:41 +02:00
|
|
|
int err, rsize;
|
2011-08-16 07:20:10 +02:00
|
|
|
int kernel_buf = 0;
|
2007-07-11 00:57:28 +02:00
|
|
|
struct p9_client *clnt;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TWRITE fid %d offset %llu count %d\n",
|
2012-04-15 07:58:06 +02:00
|
|
|
fid->fid, (unsigned long long) offset, count);
|
2007-07-11 00:57:28 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
|
|
|
rsize = fid->iounit;
|
|
|
|
if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
|
|
|
|
rsize = clnt->msize - P9_IOHDRSZ;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
if (count < rsize)
|
|
|
|
rsize = count;
|
2011-02-14 01:23:59 +01:00
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
/* Don't bother zerocopy for small IO (< 1024) */
|
|
|
|
if (clnt->trans_mod->zc_request && rsize > 1024) {
|
|
|
|
char *odata;
|
|
|
|
if (data) {
|
|
|
|
kernel_buf = 1;
|
|
|
|
odata = data;
|
|
|
|
} else
|
|
|
|
odata = (char *)udata;
|
|
|
|
req = p9_client_zc_rpc(clnt, P9_TWRITE, NULL, odata, 0, rsize,
|
|
|
|
P9_ZC_HDR_SZ, kernel_buf, "dqd",
|
|
|
|
fid->fid, offset, rsize);
|
2011-02-14 01:23:59 +01:00
|
|
|
} else {
|
|
|
|
if (data)
|
|
|
|
req = p9_client_rpc(clnt, P9_TWRITE, "dqD", fid->fid,
|
2011-08-16 07:20:10 +02:00
|
|
|
offset, rsize, data);
|
2011-02-14 01:23:59 +01:00
|
|
|
else
|
|
|
|
req = p9_client_rpc(clnt, P9_TWRITE, "dqU", fid->fid,
|
2011-08-16 07:20:10 +02:00
|
|
|
offset, rsize, udata);
|
2011-02-14 01:23:59 +01:00
|
|
|
}
|
2008-10-16 15:30:07 +02:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
2008-10-14 03:36:17 +02:00
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "d", &count);
|
2008-10-17 23:20:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2008-10-16 15:30:07 +02:00
|
|
|
goto free_and_error;
|
2008-10-17 23:20:07 +02:00
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RWRITE count %d\n", count);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return count;
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
2007-07-11 00:57:28 +02:00
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
2008-10-14 03:36:17 +02:00
|
|
|
EXPORT_SYMBOL(p9_client_write);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_wstat *p9_client_stat(struct p9_fid *fid)
|
2008-10-14 01:45:24 +02:00
|
|
|
{
|
2008-10-16 15:30:07 +02:00
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_wstat *ret = kmalloc(sizeof(struct p9_wstat), GFP_KERNEL);
|
|
|
|
struct p9_req_t *req;
|
|
|
|
u16 ignored;
|
2008-10-14 01:45:24 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TSTAT fid %d\n", fid->fid);
|
2008-10-14 01:45:24 +02:00
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
req = p9_client_rpc(clnt, P9_TSTAT, "d", fid->fid);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
2007-07-11 00:57:28 +02:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "wS", &ignored, ret);
|
2008-10-17 23:20:07 +02:00
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2009-07-14 20:25:41 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
goto error;
|
2008-10-17 23:20:07 +02:00
|
|
|
}
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P,
|
2008-10-17 23:20:07 +02:00
|
|
|
"<<< RSTAT sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
|
|
|
|
"<<< mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
|
|
|
|
"<<< name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
|
|
|
|
"<<< uid=%d gid=%d n_muid=%d\n",
|
2008-10-16 15:30:07 +02:00
|
|
|
ret->size, ret->type, ret->dev, ret->qid.type,
|
net/9p: fix printk format warnings
Fix printk format warnings in net/9p.
Built cleanly on 7 arches.
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 6 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2008-11-05 05:46:46 +01:00
|
|
|
(unsigned long long)ret->qid.path, ret->qid.version, ret->mode,
|
|
|
|
ret->atime, ret->mtime, (unsigned long long)ret->length,
|
|
|
|
ret->name, ret->uid, ret->gid, ret->muid, ret->extension,
|
2013-01-30 01:18:50 +01:00
|
|
|
from_kuid(&init_user_ns, ret->n_uid),
|
|
|
|
from_kgid(&init_user_ns, ret->n_gid),
|
|
|
|
from_kuid(&init_user_ns, ret->n_muid));
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2009-04-05 23:26:41 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return ret;
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
error:
|
2009-04-05 23:26:41 +02:00
|
|
|
kfree(ret);
|
|
|
|
return ERR_PTR(err);
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_stat);
|
|
|
|
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 16:37:23 +02:00
|
|
|
struct p9_stat_dotl *p9_client_getattr_dotl(struct p9_fid *fid,
|
|
|
|
u64 request_mask)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_stat_dotl *ret = kmalloc(sizeof(struct p9_stat_dotl),
|
|
|
|
GFP_KERNEL);
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TGETATTR fid %d, request_mask %lld\n",
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 16:37:23 +02:00
|
|
|
fid->fid, request_mask);
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TGETATTR, "dq", fid->fid, request_mask);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "A", ret);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 16:37:23 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P,
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 16:37:23 +02:00
|
|
|
"<<< RGETATTR st_result_mask=%lld\n"
|
|
|
|
"<<< qid=%x.%llx.%x\n"
|
|
|
|
"<<< st_mode=%8.8x st_nlink=%llu\n"
|
|
|
|
"<<< st_uid=%d st_gid=%d\n"
|
|
|
|
"<<< st_rdev=%llx st_size=%llx st_blksize=%llu st_blocks=%llu\n"
|
|
|
|
"<<< st_atime_sec=%lld st_atime_nsec=%lld\n"
|
|
|
|
"<<< st_mtime_sec=%lld st_mtime_nsec=%lld\n"
|
|
|
|
"<<< st_ctime_sec=%lld st_ctime_nsec=%lld\n"
|
|
|
|
"<<< st_btime_sec=%lld st_btime_nsec=%lld\n"
|
|
|
|
"<<< st_gen=%lld st_data_version=%lld",
|
|
|
|
ret->st_result_mask, ret->qid.type, ret->qid.path,
|
2013-01-30 01:18:50 +01:00
|
|
|
ret->qid.version, ret->st_mode, ret->st_nlink,
|
|
|
|
from_kuid(&init_user_ns, ret->st_uid),
|
|
|
|
from_kgid(&init_user_ns, ret->st_gid),
|
|
|
|
ret->st_rdev, ret->st_size, ret->st_blksize,
|
9p: getattr client implementation for 9P2000.L protocol.
SYNOPSIS
size[4] Tgetattr tag[2] fid[4] request_mask[8]
size[4] Rgetattr tag[2] lstat[n]
DESCRIPTION
The getattr transaction inquires about the file identified by fid.
request_mask is a bit mask that specifies which fields of the
stat structure is the client interested in.
The reply will contain a machine-independent directory entry,
laid out as follows:
st_result_mask[8]
Bit mask that indicates which fields in the stat structure
have been populated by the server
qid.type[1]
the type of the file (directory, etc.), represented as a bit
vector corresponding to the high 8 bits of the file's mode
word.
qid.vers[4]
version number for given path
qid.path[8]
the file server's unique identification for the file
st_mode[4]
Permission and flags
st_uid[4]
User id of owner
st_gid[4]
Group ID of owner
st_nlink[8]
Number of hard links
st_rdev[8]
Device ID (if special file)
st_size[8]
Size, in bytes
st_blksize[8]
Block size for file system IO
st_blocks[8]
Number of file system blocks allocated
st_atime_sec[8]
Time of last access, seconds
st_atime_nsec[8]
Time of last access, nanoseconds
st_mtime_sec[8]
Time of last modification, seconds
st_mtime_nsec[8]
Time of last modification, nanoseconds
st_ctime_sec[8]
Time of last status change, seconds
st_ctime_nsec[8]
Time of last status change, nanoseconds
st_btime_sec[8]
Time of creation (birth) of file, seconds
st_btime_nsec[8]
Time of creation (birth) of file, nanoseconds
st_gen[8]
Inode generation
st_data_version[8]
Data version number
request_mask and result_mask bit masks contain the following bits
#define P9_STATS_MODE 0x00000001ULL
#define P9_STATS_NLINK 0x00000002ULL
#define P9_STATS_UID 0x00000004ULL
#define P9_STATS_GID 0x00000008ULL
#define P9_STATS_RDEV 0x00000010ULL
#define P9_STATS_ATIME 0x00000020ULL
#define P9_STATS_MTIME 0x00000040ULL
#define P9_STATS_CTIME 0x00000080ULL
#define P9_STATS_INO 0x00000100ULL
#define P9_STATS_SIZE 0x00000200ULL
#define P9_STATS_BLOCKS 0x00000400ULL
#define P9_STATS_BTIME 0x00000800ULL
#define P9_STATS_GEN 0x00001000ULL
#define P9_STATS_DATA_VERSION 0x00002000ULL
#define P9_STATS_BASIC 0x000007ffULL
#define P9_STATS_ALL 0x00003fffULL
This patch implements the client side of getattr implementation for
9P2000.L. It introduces a new structure p9_stat_dotl for getting
Linux stat information along with QID. The data layout is similar to
stat structure in Linux user space with the following major
differences:
inode (st_ino) is not part of data. Instead qid is.
device (st_dev) is not part of data because this doesn't make sense
on the client.
All time variables are 64 bit wide on the wire. The kernel seems to use
32 bit variables for these variables. However, some of the architectures
have used 64 bit variables and glibc exposes 64 bit variables to user
space on some architectures. Hence to be on the safer side we have made
these 64 bit in the protocol. Refer to the comments in
include/asm-generic/stat.h
There are some additional fields: st_btime_sec, st_btime_nsec, st_gen,
st_data_version apart from the bitmask, st_result_mask. The bit mask
is filled by the server to indicate which stat fields have been
populated by the server. Currently there is no clean way for the
server to obtain these additional fields, so it sends back just the
basic fields.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Eric Van Hensbegren <ericvh@gmail.com>
2010-07-12 16:37:23 +02:00
|
|
|
ret->st_blocks, ret->st_atime_sec, ret->st_atime_nsec,
|
|
|
|
ret->st_mtime_sec, ret->st_mtime_nsec, ret->st_ctime_sec,
|
|
|
|
ret->st_ctime_nsec, ret->st_btime_sec, ret->st_btime_nsec,
|
|
|
|
ret->st_gen, ret->st_data_version);
|
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
error:
|
|
|
|
kfree(ret);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_getattr_dotl);
|
|
|
|
|
2010-03-05 19:50:14 +01:00
|
|
|
static int p9_client_statsize(struct p9_wstat *wst, int proto_version)
|
2009-04-05 23:22:16 +02:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2010-01-16 02:01:56 +01:00
|
|
|
/* NOTE: size shouldn't include its own length */
|
2009-04-05 23:22:16 +02:00
|
|
|
/* size[2] type[2] dev[4] qid[13] */
|
|
|
|
/* mode[4] atime[4] mtime[4] length[8]*/
|
|
|
|
/* name[s] uid[s] gid[s] muid[s] */
|
2010-01-16 02:01:56 +01:00
|
|
|
ret = 2+4+13+4+4+4+8+2+2+2+2;
|
2009-04-05 23:22:16 +02:00
|
|
|
|
|
|
|
if (wst->name)
|
|
|
|
ret += strlen(wst->name);
|
|
|
|
if (wst->uid)
|
|
|
|
ret += strlen(wst->uid);
|
|
|
|
if (wst->gid)
|
|
|
|
ret += strlen(wst->gid);
|
|
|
|
if (wst->muid)
|
|
|
|
ret += strlen(wst->muid);
|
|
|
|
|
2010-03-25 13:40:35 +01:00
|
|
|
if ((proto_version == p9_proto_2000u) ||
|
|
|
|
(proto_version == p9_proto_2000L)) {
|
2009-04-05 23:22:16 +02:00
|
|
|
ret += 2+4+4+4; /* extension[s] n_uid[4] n_gid[4] n_muid[4] */
|
|
|
|
if (wst->extension)
|
|
|
|
ret += strlen(wst->extension);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-07-11 00:57:28 +02:00
|
|
|
int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
|
|
|
|
{
|
|
|
|
int err;
|
2008-10-16 15:30:07 +02:00
|
|
|
struct p9_req_t *req;
|
2007-07-11 00:57:28 +02:00
|
|
|
struct p9_client *clnt;
|
|
|
|
|
2009-04-05 23:22:16 +02:00
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2010-03-05 19:50:14 +01:00
|
|
|
wst->size = p9_client_statsize(wst, clnt->proto_version);
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TWSTAT fid %d\n", fid->fid);
|
|
|
|
p9_debug(P9_DEBUG_9P,
|
2008-10-17 23:20:07 +02:00
|
|
|
" sz=%x type=%x dev=%x qid=%x.%llx.%x\n"
|
|
|
|
" mode=%8.8x atime=%8.8x mtime=%8.8x length=%llx\n"
|
|
|
|
" name=%s uid=%s gid=%s muid=%s extension=(%s)\n"
|
|
|
|
" uid=%d gid=%d n_muid=%d\n",
|
|
|
|
wst->size, wst->type, wst->dev, wst->qid.type,
|
net/9p: fix printk format warnings
Fix printk format warnings in net/9p.
Built cleanly on 7 arches.
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:820: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:867: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:932: warning: format '%llx' expects type 'long long unsigned int', but argument 6 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:982: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 4 has type 'u64'
net/9p/client.c:1025: warning: format '%llx' expects type 'long long unsigned int', but argument 5 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 7 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 8 has type 'u64'
net/9p/client.c:1252: warning: format '%llx' expects type 'long long unsigned int', but argument 13 has type 'u64'
Signed-off-by: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2008-11-05 05:46:46 +01:00
|
|
|
(unsigned long long)wst->qid.path, wst->qid.version, wst->mode,
|
|
|
|
wst->atime, wst->mtime, (unsigned long long)wst->length,
|
|
|
|
wst->name, wst->uid, wst->gid, wst->muid, wst->extension,
|
2013-01-30 01:18:50 +01:00
|
|
|
from_kuid(&init_user_ns, wst->n_uid),
|
|
|
|
from_kgid(&init_user_ns, wst->n_gid),
|
|
|
|
from_kuid(&init_user_ns, wst->n_muid));
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2010-01-16 02:01:56 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TWSTAT, "dwS", fid->fid, wst->size+2, wst);
|
2008-10-16 15:30:07 +02:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
2007-07-11 00:57:28 +02:00
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RWSTAT fid %d\n", fid->fid);
|
2007-07-11 00:57:28 +02:00
|
|
|
|
2008-10-16 15:30:07 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
2007-07-11 00:57:28 +02:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_wstat);
|
2010-03-25 13:45:30 +01:00
|
|
|
|
9p: Implement client side of setattr for 9P2000.L protocol.
SYNOPSIS
size[4] Tsetattr tag[2] attr[n]
size[4] Rsetattr tag[2]
DESCRIPTION
The setattr command changes some of the file status information.
attr resembles the iattr structure used in Linux kernel. It
specifies which status parameter is to be changed and to what
value. It is laid out as follows:
valid[4]
specifies which status information is to be changed. Possible
values are:
ATTR_MODE (1 << 0)
ATTR_UID (1 << 1)
ATTR_GID (1 << 2)
ATTR_SIZE (1 << 3)
ATTR_ATIME (1 << 4)
ATTR_MTIME (1 << 5)
ATTR_ATIME_SET (1 << 7)
ATTR_MTIME_SET (1 << 8)
The last two bits represent whether the time information
is being sent by the client's user space. In the absense
of these bits the server always uses server's time.
mode[4]
File permission bits
uid[4]
Owner id of file
gid[4]
Group id of the file
size[8]
File size
atime_sec[8]
Time of last file access, seconds
atime_nsec[8]
Time of last file access, nanoseconds
mtime_sec[8]
Time of last file modification, seconds
mtime_nsec[8]
Time of last file modification, nanoseconds
Explanation of the patches:
--------------------------
*) The kernel just copies relevent contents of iattr structure to
p9_iattr_dotl structure and passes it down to the client. The
only check it has is calling inode_change_ok()
*) The p9_iattr_dotl structure does not have ctime and ia_file
parameters because I don't think these are needed in our case.
The client user space can request updating just ctime by calling
chown(fd, -1, -1). This is handled on server side without a need
for putting ctime on the wire.
*) The server currently supports changing mode, time, ownership and
size of the file.
*) 9P RFC says "Either all the changes in wstat request happen, or
none of them does: if the request succeeds, all changes were made;
if it fails, none were."
I have not done anything to implement this specifically because I
don't see a reason.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-06-18 08:20:10 +02:00
|
|
|
int p9_client_setattr(struct p9_fid *fid, struct p9_iattr_dotl *p9attr)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TSETATTR fid %d\n", fid->fid);
|
|
|
|
p9_debug(P9_DEBUG_9P,
|
9p: Implement client side of setattr for 9P2000.L protocol.
SYNOPSIS
size[4] Tsetattr tag[2] attr[n]
size[4] Rsetattr tag[2]
DESCRIPTION
The setattr command changes some of the file status information.
attr resembles the iattr structure used in Linux kernel. It
specifies which status parameter is to be changed and to what
value. It is laid out as follows:
valid[4]
specifies which status information is to be changed. Possible
values are:
ATTR_MODE (1 << 0)
ATTR_UID (1 << 1)
ATTR_GID (1 << 2)
ATTR_SIZE (1 << 3)
ATTR_ATIME (1 << 4)
ATTR_MTIME (1 << 5)
ATTR_ATIME_SET (1 << 7)
ATTR_MTIME_SET (1 << 8)
The last two bits represent whether the time information
is being sent by the client's user space. In the absense
of these bits the server always uses server's time.
mode[4]
File permission bits
uid[4]
Owner id of file
gid[4]
Group id of the file
size[8]
File size
atime_sec[8]
Time of last file access, seconds
atime_nsec[8]
Time of last file access, nanoseconds
mtime_sec[8]
Time of last file modification, seconds
mtime_nsec[8]
Time of last file modification, nanoseconds
Explanation of the patches:
--------------------------
*) The kernel just copies relevent contents of iattr structure to
p9_iattr_dotl structure and passes it down to the client. The
only check it has is calling inode_change_ok()
*) The p9_iattr_dotl structure does not have ctime and ia_file
parameters because I don't think these are needed in our case.
The client user space can request updating just ctime by calling
chown(fd, -1, -1). This is handled on server side without a need
for putting ctime on the wire.
*) The server currently supports changing mode, time, ownership and
size of the file.
*) 9P RFC says "Either all the changes in wstat request happen, or
none of them does: if the request succeeds, all changes were made;
if it fails, none were."
I have not done anything to implement this specifically because I
don't see a reason.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-06-18 08:20:10 +02:00
|
|
|
" valid=%x mode=%x uid=%d gid=%d size=%lld\n"
|
|
|
|
" atime_sec=%lld atime_nsec=%lld\n"
|
|
|
|
" mtime_sec=%lld mtime_nsec=%lld\n",
|
2013-01-30 01:18:50 +01:00
|
|
|
p9attr->valid, p9attr->mode,
|
|
|
|
from_kuid(&init_user_ns, p9attr->uid),
|
|
|
|
from_kgid(&init_user_ns, p9attr->gid),
|
9p: Implement client side of setattr for 9P2000.L protocol.
SYNOPSIS
size[4] Tsetattr tag[2] attr[n]
size[4] Rsetattr tag[2]
DESCRIPTION
The setattr command changes some of the file status information.
attr resembles the iattr structure used in Linux kernel. It
specifies which status parameter is to be changed and to what
value. It is laid out as follows:
valid[4]
specifies which status information is to be changed. Possible
values are:
ATTR_MODE (1 << 0)
ATTR_UID (1 << 1)
ATTR_GID (1 << 2)
ATTR_SIZE (1 << 3)
ATTR_ATIME (1 << 4)
ATTR_MTIME (1 << 5)
ATTR_ATIME_SET (1 << 7)
ATTR_MTIME_SET (1 << 8)
The last two bits represent whether the time information
is being sent by the client's user space. In the absense
of these bits the server always uses server's time.
mode[4]
File permission bits
uid[4]
Owner id of file
gid[4]
Group id of the file
size[8]
File size
atime_sec[8]
Time of last file access, seconds
atime_nsec[8]
Time of last file access, nanoseconds
mtime_sec[8]
Time of last file modification, seconds
mtime_nsec[8]
Time of last file modification, nanoseconds
Explanation of the patches:
--------------------------
*) The kernel just copies relevent contents of iattr structure to
p9_iattr_dotl structure and passes it down to the client. The
only check it has is calling inode_change_ok()
*) The p9_iattr_dotl structure does not have ctime and ia_file
parameters because I don't think these are needed in our case.
The client user space can request updating just ctime by calling
chown(fd, -1, -1). This is handled on server side without a need
for putting ctime on the wire.
*) The server currently supports changing mode, time, ownership and
size of the file.
*) 9P RFC says "Either all the changes in wstat request happen, or
none of them does: if the request succeeds, all changes were made;
if it fails, none were."
I have not done anything to implement this specifically because I
don't see a reason.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-06-18 08:20:10 +02:00
|
|
|
p9attr->size, p9attr->atime_sec, p9attr->atime_nsec,
|
|
|
|
p9attr->mtime_sec, p9attr->mtime_nsec);
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TSETATTR, "dI", fid->fid, p9attr);
|
|
|
|
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RSETATTR fid %d\n", fid->fid);
|
9p: Implement client side of setattr for 9P2000.L protocol.
SYNOPSIS
size[4] Tsetattr tag[2] attr[n]
size[4] Rsetattr tag[2]
DESCRIPTION
The setattr command changes some of the file status information.
attr resembles the iattr structure used in Linux kernel. It
specifies which status parameter is to be changed and to what
value. It is laid out as follows:
valid[4]
specifies which status information is to be changed. Possible
values are:
ATTR_MODE (1 << 0)
ATTR_UID (1 << 1)
ATTR_GID (1 << 2)
ATTR_SIZE (1 << 3)
ATTR_ATIME (1 << 4)
ATTR_MTIME (1 << 5)
ATTR_ATIME_SET (1 << 7)
ATTR_MTIME_SET (1 << 8)
The last two bits represent whether the time information
is being sent by the client's user space. In the absense
of these bits the server always uses server's time.
mode[4]
File permission bits
uid[4]
Owner id of file
gid[4]
Group id of the file
size[8]
File size
atime_sec[8]
Time of last file access, seconds
atime_nsec[8]
Time of last file access, nanoseconds
mtime_sec[8]
Time of last file modification, seconds
mtime_nsec[8]
Time of last file modification, nanoseconds
Explanation of the patches:
--------------------------
*) The kernel just copies relevent contents of iattr structure to
p9_iattr_dotl structure and passes it down to the client. The
only check it has is calling inode_change_ok()
*) The p9_iattr_dotl structure does not have ctime and ia_file
parameters because I don't think these are needed in our case.
The client user space can request updating just ctime by calling
chown(fd, -1, -1). This is handled on server side without a need
for putting ctime on the wire.
*) The server currently supports changing mode, time, ownership and
size of the file.
*) 9P RFC says "Either all the changes in wstat request happen, or
none of them does: if the request succeeds, all changes were made;
if it fails, none were."
I have not done anything to implement this specifically because I
don't see a reason.
Signed-off-by: Sripathi Kodi <sripathik@in.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-06-18 08:20:10 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_setattr);
|
|
|
|
|
2010-03-25 13:45:30 +01:00
|
|
|
int p9_client_statfs(struct p9_fid *fid, struct p9_rstatfs *sb)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TSTATFS fid %d\n", fid->fid);
|
2010-03-25 13:45:30 +01:00
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TSTATFS, "d", fid->fid);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "ddqqqqqqd", &sb->type,
|
|
|
|
&sb->bsize, &sb->blocks, &sb->bfree, &sb->bavail,
|
|
|
|
&sb->files, &sb->ffree, &sb->fsid, &sb->namelen);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-03-25 13:45:30 +01:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RSTATFS fid %d type 0x%lx bsize %ld "
|
2010-03-25 13:45:30 +01:00
|
|
|
"blocks %llu bfree %llu bavail %llu files %llu ffree %llu "
|
|
|
|
"fsid %llu namelen %ld\n",
|
|
|
|
fid->fid, (long unsigned int)sb->type, (long int)sb->bsize,
|
|
|
|
sb->blocks, sb->bfree, sb->bavail, sb->files, sb->ffree,
|
|
|
|
sb->fsid, (long int)sb->namelen);
|
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_statfs);
|
2010-03-25 13:47:26 +01:00
|
|
|
|
2011-06-28 12:11:16 +02:00
|
|
|
int p9_client_rename(struct p9_fid *fid,
|
|
|
|
struct p9_fid *newdirfid, const char *name)
|
2010-03-25 13:47:26 +01:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TRENAME fid %d newdirfid %d name %s\n",
|
2010-03-25 13:47:26 +01:00
|
|
|
fid->fid, newdirfid->fid, name);
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TRENAME, "dds", fid->fid,
|
|
|
|
newdirfid->fid, name);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RRENAME fid %d\n", fid->fid);
|
2010-03-25 13:47:26 +01:00
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_rename);
|
|
|
|
|
2011-06-28 12:11:16 +02:00
|
|
|
int p9_client_renameat(struct p9_fid *olddirfid, const char *old_name,
|
|
|
|
struct p9_fid *newdirfid, const char *new_name)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = olddirfid->clnt;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TRENAMEAT olddirfid %d old name %s"
|
2011-06-28 12:11:16 +02:00
|
|
|
" newdirfid %d new name %s\n", olddirfid->fid, old_name,
|
|
|
|
newdirfid->fid, new_name);
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TRENAMEAT, "dsds", olddirfid->fid,
|
|
|
|
old_name, newdirfid->fid, new_name);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RRENAMEAT newdirfid %d new name %s\n",
|
2011-06-28 12:11:16 +02:00
|
|
|
newdirfid->fid, new_name);
|
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_renameat);
|
|
|
|
|
2010-05-31 09:52:45 +02:00
|
|
|
/*
|
|
|
|
* An xattrwalk without @attr_name gives the fid for the lisxattr namespace
|
|
|
|
*/
|
|
|
|
struct p9_fid *p9_client_xattrwalk(struct p9_fid *file_fid,
|
|
|
|
const char *attr_name, u64 *attr_size)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_fid *attr_fid;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = file_fid->clnt;
|
|
|
|
attr_fid = p9_fid_create(clnt);
|
|
|
|
if (IS_ERR(attr_fid)) {
|
|
|
|
err = PTR_ERR(attr_fid);
|
|
|
|
attr_fid = NULL;
|
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P,
|
2010-05-31 09:52:45 +02:00
|
|
|
">>> TXATTRWALK file_fid %d, attr_fid %d name %s\n",
|
|
|
|
file_fid->fid, attr_fid->fid, attr_name);
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TXATTRWALK, "dds",
|
|
|
|
file_fid->fid, attr_fid->fid, attr_name);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "q", attr_size);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-05-31 09:52:45 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
goto clunk_fid;
|
|
|
|
}
|
|
|
|
p9_free_req(clnt, req);
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RXATTRWALK fid %d size %llu\n",
|
2010-05-31 09:52:45 +02:00
|
|
|
attr_fid->fid, *attr_size);
|
|
|
|
return attr_fid;
|
|
|
|
clunk_fid:
|
|
|
|
p9_client_clunk(attr_fid);
|
|
|
|
attr_fid = NULL;
|
|
|
|
error:
|
|
|
|
if (attr_fid && (attr_fid != file_fid))
|
|
|
|
p9_fid_destroy(attr_fid);
|
|
|
|
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(p9_client_xattrwalk);
|
|
|
|
|
2010-05-31 09:52:50 +02:00
|
|
|
int p9_client_xattrcreate(struct p9_fid *fid, const char *name,
|
|
|
|
u64 attr_size, int flags)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P,
|
2010-05-31 09:52:50 +02:00
|
|
|
">>> TXATTRCREATE fid %d name %s size %lld flag %d\n",
|
|
|
|
fid->fid, name, (long long)attr_size, flags);
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
req = p9_client_rpc(clnt, P9_TXATTRCREATE, "dsqd",
|
|
|
|
fid->fid, name, attr_size, flags);
|
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RXATTRCREATE fid %d\n", fid->fid);
|
2010-05-31 09:52:50 +02:00
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(p9_client_xattrcreate);
|
|
|
|
|
2010-06-04 15:41:26 +02:00
|
|
|
int p9_client_readdir(struct p9_fid *fid, char *data, u32 count, u64 offset)
|
|
|
|
{
|
2011-08-16 07:20:10 +02:00
|
|
|
int err, rsize, non_zc = 0;
|
2010-06-04 15:41:26 +02:00
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
char *dataptr;
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TREADDIR fid %d offset %llu count %d\n",
|
2012-04-15 07:58:06 +02:00
|
|
|
fid->fid, (unsigned long long) offset, count);
|
2010-06-04 15:41:26 +02:00
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
|
|
|
|
|
|
|
rsize = fid->iounit;
|
|
|
|
if (!rsize || rsize > clnt->msize-P9_READDIRHDRSZ)
|
|
|
|
rsize = clnt->msize - P9_READDIRHDRSZ;
|
|
|
|
|
|
|
|
if (count < rsize)
|
|
|
|
rsize = count;
|
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
/* Don't bother zerocopy for small IO (< 1024) */
|
|
|
|
if (clnt->trans_mod->zc_request && rsize > 1024) {
|
|
|
|
/*
|
|
|
|
* response header len is 11
|
|
|
|
* PDU Header(7) + IO Size (4)
|
|
|
|
*/
|
|
|
|
req = p9_client_zc_rpc(clnt, P9_TREADDIR, data, NULL, rsize, 0,
|
|
|
|
11, 1, "dqd", fid->fid, offset, rsize);
|
2011-02-17 03:43:20 +01:00
|
|
|
} else {
|
2011-08-16 07:20:10 +02:00
|
|
|
non_zc = 1;
|
2011-02-17 03:43:20 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TREADDIR, "dqd", fid->fid,
|
2011-08-16 07:20:10 +02:00
|
|
|
offset, rsize);
|
2011-02-17 03:43:20 +01:00
|
|
|
}
|
2010-06-04 15:41:26 +02:00
|
|
|
if (IS_ERR(req)) {
|
|
|
|
err = PTR_ERR(req);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "D", &count, &dataptr);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-06-04 15:41:26 +02:00
|
|
|
goto free_and_error;
|
|
|
|
}
|
|
|
|
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RREADDIR count %d\n", count);
|
2010-06-04 15:41:26 +02:00
|
|
|
|
2011-08-16 07:20:10 +02:00
|
|
|
if (non_zc)
|
2010-06-04 15:41:26 +02:00
|
|
|
memmove(data, dataptr, count);
|
|
|
|
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return count;
|
|
|
|
|
|
|
|
free_and_error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
error:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_readdir);
|
2010-06-16 10:57:01 +02:00
|
|
|
|
|
|
|
int p9_client_mknod_dotl(struct p9_fid *fid, char *name, int mode,
|
2013-01-30 01:09:41 +01:00
|
|
|
dev_t rdev, kgid_t gid, struct p9_qid *qid)
|
2010-06-16 10:57:01 +02:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TMKNOD fid %d name %s mode %d major %d "
|
2010-06-16 10:57:01 +02:00
|
|
|
"minor %d\n", fid->fid, name, mode, MAJOR(rdev), MINOR(rdev));
|
2013-01-30 01:09:41 +01:00
|
|
|
req = p9_client_rpc(clnt, P9_TMKNOD, "dsdddg", fid->fid, name, mode,
|
2010-06-16 10:57:01 +02:00
|
|
|
MAJOR(rdev), MINOR(rdev), gid);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-06-16 10:57:01 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RMKNOD qid %x.%llx.%x\n", qid->type,
|
2010-06-16 10:57:01 +02:00
|
|
|
(unsigned long long)qid->path, qid->version);
|
|
|
|
|
|
|
|
error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_mknod_dotl);
|
2010-06-16 10:57:22 +02:00
|
|
|
|
|
|
|
int p9_client_mkdir_dotl(struct p9_fid *fid, char *name, int mode,
|
2013-01-30 01:09:41 +01:00
|
|
|
kgid_t gid, struct p9_qid *qid)
|
2010-06-16 10:57:22 +02:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TMKDIR fid %d name %s mode %d gid %d\n",
|
2013-01-30 01:09:41 +01:00
|
|
|
fid->fid, name, mode, from_kgid(&init_user_ns, gid));
|
|
|
|
req = p9_client_rpc(clnt, P9_TMKDIR, "dsdg", fid->fid, name, mode,
|
2010-06-16 10:57:22 +02:00
|
|
|
gid);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "Q", qid);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-06-16 10:57:22 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RMKDIR qid %x.%llx.%x\n", qid->type,
|
2010-06-16 10:57:22 +02:00
|
|
|
(unsigned long long)qid->path, qid->version);
|
|
|
|
|
|
|
|
error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_mkdir_dotl);
|
9p: Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-09-27 08:04:24 +02:00
|
|
|
|
|
|
|
int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TLOCK fid %d type %i flags %d "
|
9p: Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-09-27 08:04:24 +02:00
|
|
|
"start %lld length %lld proc_id %d client_id %s\n",
|
|
|
|
fid->fid, flock->type, flock->flags, flock->start,
|
|
|
|
flock->length, flock->proc_id, flock->client_id);
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,
|
|
|
|
flock->flags, flock->start, flock->length,
|
|
|
|
flock->proc_id, flock->client_id);
|
|
|
|
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "b", status);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
9p: Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-09-27 08:04:24 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);
|
9p: Implement TLOCK
Synopsis
size[4] TLock tag[2] fid[4] flock[n]
size[4] RLock tag[2] status[1]
Description
Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request
flock structure:
type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
flags[4] - Flags could be either of
P9_LOCK_FLAGS_BLOCK - Blocked lock request, if there is a
conflicting lock exists, wait for that lock to be released.
P9_LOCK_FLAGS_RECLAIM - Reclaim lock request, used when client is
trying to reclaim a lock after a server restrart (due to crash)
start[8] - Starting offset for lock
length[8] - Number of bytes to lock
If length is 0, lock all bytes starting at the location 'start'
through to the end of file
pid[4] - PID of the process that wants to take lock
client_id[4] - Unique client id
status[1] - Status of the lock request, can be
P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
P9_LOCK_GRACE(3)
P9_LOCK_SUCCESS - Request was successful
P9_LOCK_BLOCKED - A conflicting lock is held by another process
P9_LOCK_ERROR - Error while processing the lock request
P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
requests in this period (except locks with
P9_LOCK_FLAGS_RECLAIM flag set)
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
2010-09-27 08:04:24 +02:00
|
|
|
error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_lock_dotl);
|
2010-09-27 08:52:13 +02:00
|
|
|
|
|
|
|
int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TGETLOCK fid %d, type %i start %lld "
|
2010-09-27 08:52:13 +02:00
|
|
|
"length %lld proc_id %d client_id %s\n", fid->fid, glock->type,
|
|
|
|
glock->start, glock->length, glock->proc_id, glock->client_id);
|
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid, glock->type,
|
|
|
|
glock->start, glock->length, glock->proc_id, glock->client_id);
|
|
|
|
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "bqqds", &glock->type,
|
|
|
|
&glock->start, &glock->length, &glock->proc_id,
|
|
|
|
&glock->client_id);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-09-27 08:52:13 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "
|
2010-09-27 08:52:13 +02:00
|
|
|
"proc_id %d client_id %s\n", glock->type, glock->start,
|
|
|
|
glock->length, glock->proc_id, glock->client_id);
|
|
|
|
error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_getlock_dotl);
|
2010-09-28 16:29:25 +02:00
|
|
|
|
|
|
|
int p9_client_readlink(struct p9_fid *fid, char **target)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct p9_client *clnt;
|
|
|
|
struct p9_req_t *req;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
clnt = fid->clnt;
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, ">>> TREADLINK fid %d\n", fid->fid);
|
2010-09-28 16:29:25 +02:00
|
|
|
|
|
|
|
req = p9_client_rpc(clnt, P9_TREADLINK, "d", fid->fid);
|
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
|
|
|
|
|
|
|
err = p9pdu_readf(req->rc, clnt->proto_version, "s", target);
|
|
|
|
if (err) {
|
2011-08-06 21:16:59 +02:00
|
|
|
trace_9p_protocol_dump(clnt, req->rc);
|
2010-09-28 16:29:25 +02:00
|
|
|
goto error;
|
|
|
|
}
|
2011-11-28 19:40:46 +01:00
|
|
|
p9_debug(P9_DEBUG_9P, "<<< RREADLINK target %s\n", *target);
|
2010-09-28 16:29:25 +02:00
|
|
|
error:
|
|
|
|
p9_free_req(clnt, req);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(p9_client_readlink);
|