Piteball
/
android_kernel_samsung_msm8976
mirror of https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git
1
1
Fork 0
Code Issues Projects Releases Wiki Activity

9p: Reorganization of 9p file system code 

This patchset moves non-filesystem interfaces of v9fs from fs/9p to net/9p.
It moves the transport, packet marshalling and connection layers to net/9p
leaving only the VFS related files in fs/9p.  This work is being done in
preparation for in-kernel 9p servers as well as alternate 9p clients (other
than VFS).

Signed-off-by: Latchesar Ionkov <lucho@ionkov.net>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
This commit is contained in:
Latchesar Ionkov 2007-07-10 17:57:28 -05:00 committed by Eric Van Hensbergen
parent 8d9107e8c5
commit bd238fb431
36 changed files with 3422 additions and 3130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

375
fs/9p/9p.h
View File

@ -1,375 +0,0 @@
/*
* linux/fs/9p/9p.h
*
* 9P protocol definitions.
*
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
/* Message Types */
enum {
TVERSION = 100,
RVERSION,
TAUTH = 102,
RAUTH,
TATTACH = 104,
RATTACH,
TERROR = 106,
RERROR,
TFLUSH = 108,
RFLUSH,
TWALK = 110,
RWALK,
TOPEN = 112,
ROPEN,
TCREATE = 114,
RCREATE,
TREAD = 116,
RREAD,
TWRITE = 118,
RWRITE,
TCLUNK = 120,
RCLUNK,
TREMOVE = 122,
RREMOVE,
TSTAT = 124,
RSTAT,
TWSTAT = 126,
RWSTAT,
};
/* modes */
enum {
V9FS_OREAD = 0x00,
V9FS_OWRITE = 0x01,
V9FS_ORDWR = 0x02,
V9FS_OEXEC = 0x03,
V9FS_OEXCL = 0x04,
V9FS_OTRUNC = 0x10,
V9FS_OREXEC = 0x20,
V9FS_ORCLOSE = 0x40,
V9FS_OAPPEND = 0x80,
};
/* permissions */
enum {
V9FS_DMDIR = 0x80000000,
V9FS_DMAPPEND = 0x40000000,
V9FS_DMEXCL = 0x20000000,
V9FS_DMMOUNT = 0x10000000,
V9FS_DMAUTH = 0x08000000,
V9FS_DMTMP = 0x04000000,
V9FS_DMSYMLINK = 0x02000000,
V9FS_DMLINK = 0x01000000,
/* 9P2000.u extensions */
V9FS_DMDEVICE = 0x00800000,
V9FS_DMNAMEDPIPE = 0x00200000,
V9FS_DMSOCKET = 0x00100000,
V9FS_DMSETUID = 0x00080000,
V9FS_DMSETGID = 0x00040000,
};
/* qid.types */
enum {
V9FS_QTDIR = 0x80,
V9FS_QTAPPEND = 0x40,
V9FS_QTEXCL = 0x20,
V9FS_QTMOUNT = 0x10,
V9FS_QTAUTH = 0x08,
V9FS_QTTMP = 0x04,
V9FS_QTSYMLINK = 0x02,
V9FS_QTLINK = 0x01,
V9FS_QTFILE = 0x00,
};
#define V9FS_NOTAG (u16)(~0)
#define V9FS_NOFID (u32)(~0)
#define V9FS_MAXWELEM 16
/* ample room for Twrite/Rread header (iounit) */
#define V9FS_IOHDRSZ 24
struct v9fs_str {
u16 len;
char *str;
};
/* qids are the unique ID for a file (like an inode */
struct v9fs_qid {
u8 type;
u32 version;
u64 path;
};
/* Plan 9 file metadata (stat) structure */
struct v9fs_stat {
u16 size;
u16 type;
u32 dev;
struct v9fs_qid qid;
u32 mode;
u32 atime;
u32 mtime;
u64 length;
struct v9fs_str name;
struct v9fs_str uid;
struct v9fs_str gid;
struct v9fs_str muid;
struct v9fs_str extension; /* 9p2000.u extensions */
u32 n_uid; /* 9p2000.u extensions */
u32 n_gid; /* 9p2000.u extensions */
u32 n_muid; /* 9p2000.u extensions */
};
/* file metadata (stat) structure used to create Twstat message
The is similar to v9fs_stat, but the strings don't point to
the same memory block and should be freed separately
*/
struct v9fs_wstat {
u16 size;
u16 type;
u32 dev;
struct v9fs_qid qid;
u32 mode;
u32 atime;
u32 mtime;
u64 length;
char *name;
char *uid;
char *gid;
char *muid;
char *extension; /* 9p2000.u extensions */
u32 n_uid; /* 9p2000.u extensions */
u32 n_gid; /* 9p2000.u extensions */
u32 n_muid; /* 9p2000.u extensions */
};
/* Structures for Protocol Operations */
struct Tversion {
u32 msize;
struct v9fs_str version;
};
struct Rversion {
u32 msize;
struct v9fs_str version;
};
struct Tauth {
u32 afid;
struct v9fs_str uname;
struct v9fs_str aname;
};
struct Rauth {
struct v9fs_qid qid;
};
struct Rerror {
struct v9fs_str error;
u32 errno; /* 9p2000.u extension */
};
struct Tflush {
u16 oldtag;
};
struct Rflush {
};
struct Tattach {
u32 fid;
u32 afid;
struct v9fs_str uname;
struct v9fs_str aname;
};
struct Rattach {
struct v9fs_qid qid;
};
struct Twalk {
u32 fid;
u32 newfid;
u16 nwname;
struct v9fs_str wnames[16];
};
struct Rwalk {
u16 nwqid;
struct v9fs_qid wqids[16];
};
struct Topen {
u32 fid;
u8 mode;
};
struct Ropen {
struct v9fs_qid qid;
u32 iounit;
};
struct Tcreate {
u32 fid;
struct v9fs_str name;
u32 perm;
u8 mode;
struct v9fs_str extension;
};
struct Rcreate {
struct v9fs_qid qid;
u32 iounit;
};
struct Tread {
u32 fid;
u64 offset;
u32 count;
};
struct Rread {
u32 count;
u8 *data;
};
struct Twrite {
u32 fid;
u64 offset;
u32 count;
u8 *data;
};
struct Rwrite {
u32 count;
};
struct Tclunk {
u32 fid;
};
struct Rclunk {
};
struct Tremove {
u32 fid;
};
struct Rremove {
};
struct Tstat {
u32 fid;
};
struct Rstat {
struct v9fs_stat stat;
};
struct Twstat {
u32 fid;
struct v9fs_stat stat;
};
struct Rwstat {
};
/*
* fcall is the primary packet structure
*
*/
struct v9fs_fcall {
u32 size;
u8 id;
u16 tag;
void *sdata;
union {
struct Tversion tversion;
struct Rversion rversion;
struct Tauth tauth;
struct Rauth rauth;
struct Rerror rerror;
struct Tflush tflush;
struct Rflush rflush;
struct Tattach tattach;
struct Rattach rattach;
struct Twalk twalk;
struct Rwalk rwalk;
struct Topen topen;
struct Ropen ropen;
struct Tcreate tcreate;
struct Rcreate rcreate;
struct Tread tread;
struct Rread rread;
struct Twrite twrite;
struct Rwrite rwrite;
struct Tclunk tclunk;
struct Rclunk rclunk;
struct Tremove tremove;
struct Rremove rremove;
struct Tstat tstat;
struct Rstat rstat;
struct Twstat twstat;
struct Rwstat rwstat;
} params;
};
#define PRINT_FCALL_ERROR(s, fcall) dprintk(DEBUG_ERROR, "%s: %.*s\n", s, \
fcall?fcall->params.rerror.error.len:0, \
fcall?fcall->params.rerror.error.str:"");
int v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
char *version, struct v9fs_fcall **rcall);
int v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
u32 fid, u32 afid, struct v9fs_fcall **rcall);
int v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid);
int v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_fcall **rcall);
int v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_wstat *wstat, struct v9fs_fcall **rcall);
int v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
char *name, struct v9fs_fcall **rcall);
int v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
struct v9fs_fcall **rcall);
int v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_fcall **rcall);
int v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
u32 perm, u8 mode, char *extension, struct v9fs_fcall **rcall);
int v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid,
u64 offset, u32 count, struct v9fs_fcall **rcall);
int v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
u32 count, const char __user * data,
struct v9fs_fcall **rcall);
int v9fs_printfcall(char *, int, struct v9fs_fcall *, int);

6
fs/9p/Makefile
View File

@ -1,18 +1,12 @@
obj-$(CONFIG_9P_FS) := 9p.o
9p-objs := \
trans_fd.o \
mux.o \
fcall.o \
conv.o \
vfs_super.o \
vfs_inode.o \
vfs_addr.o \
vfs_file.o \
vfs_dir.o \
vfs_dentry.o \
error.o \
v9fs.o \
fid.o \
fcprint.o

50
fs/9p/conv.h
View File

@ -1,50 +0,0 @@
/*
* linux/fs/9p/conv.h
*
* 9P protocol conversion definitions.
*
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
int extended);
int v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
int extended);
void v9fs_set_tag(struct v9fs_fcall *fc, u16 tag);
struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version);
struct v9fs_fcall *v9fs_create_tattach(u32 fid, u32 afid, char *uname,
char *aname);
struct v9fs_fcall *v9fs_create_tflush(u16 oldtag);
struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
char **wnames);
struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode);
struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
char *extension, int extended);
struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count);
struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
const char __user *data);
struct v9fs_fcall *v9fs_create_tclunk(u32 fid);
struct v9fs_fcall *v9fs_create_tremove(u32 fid);
struct v9fs_fcall *v9fs_create_tstat(u32 fid);
struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
int extended);

77
fs/9p/debug.h
View File

@ -1,77 +0,0 @@
/*
* linux/fs/9p/debug.h - V9FS Debug Definitions
*
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
#define DEBUG_ERROR (1<<0)
#define DEBUG_CURRENT (1<<1)
#define DEBUG_9P (1<<2)
#define DEBUG_VFS (1<<3)
#define DEBUG_CONV (1<<4)
#define DEBUG_MUX (1<<5)
#define DEBUG_TRANS (1<<6)
#define DEBUG_SLABS (1<<7)
#define DEBUG_FCALL (1<<8)
#define DEBUG_DUMP_PKT 0
extern int v9fs_debug_level;
#define dprintk(level, format, arg...) \
do { \
if((v9fs_debug_level & level)==level) \
printk(KERN_NOTICE "-- %s (%d): " \
format , __FUNCTION__, current->pid , ## arg); \
} while(0)
#define eprintk(level, format, arg...) \
do { \
printk(level "v9fs: %s (%d): " \
format , __FUNCTION__, current->pid , ## arg); \
} while(0)
#if DEBUG_DUMP_PKT
static inline void dump_data(const unsigned char *data, unsigned int datalen)
{
int i, n;
char buf[5*8];
n = 0;
i = 0;
while (i < datalen) {
n += snprintf(buf+n, sizeof(buf)-n, "%02x", data[i++]);
if (i%4 == 0)
n += snprintf(buf+n, sizeof(buf)-n, " ");
if (i%16 == 0) {
dprintk(DEBUG_ERROR, "%s\n", buf);
n = 0;
}
}
dprintk(DEBUG_ERROR, "%s\n", buf);
}
#else /* DEBUG_DUMP_PKT */
static inline void dump_data(const unsigned char *data, unsigned int datalen)
{
}
#endif /* DEBUG_DUMP_PKT */

93
fs/9p/error.c
View File

@ -1,93 +0,0 @@
/*
* linux/fs/9p/error.c
*
* Error string handling
*
* Plan 9 uses error strings, Unix uses error numbers. These functions
* try to help manage that and provide for dynamically adding error
* mappings.
*
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
#include <linux/module.h>
#include <linux/list.h>
#include <linux/jhash.h>
#include "debug.h"
#include "error.h"
/**
* v9fs_error_init - preload
* @errstr: error string
*
*/
int v9fs_error_init(void)
{
struct errormap *c;
int bucket;
/* initialize hash table */
for (bucket = 0; bucket < ERRHASHSZ; bucket++)
INIT_HLIST_HEAD(&hash_errmap[bucket]);
/* load initial error map into hash table */
for (c = errmap; c->name != NULL; c++) {
c->namelen = strlen(c->name);
bucket = jhash(c->name, c->namelen, 0) % ERRHASHSZ;
INIT_HLIST_NODE(&c->list);
hlist_add_head(&c->list, &hash_errmap[bucket]);
}
return 1;
}
/**
* errstr2errno - convert error string to error number
* @errstr: error string
*
*/
int v9fs_errstr2errno(char *errstr, int len)
{
int errno = 0;
struct hlist_node *p = NULL;
struct errormap *c = NULL;
int bucket = jhash(errstr, len, 0) % ERRHASHSZ;
hlist_for_each_entry(c, p, &hash_errmap[bucket], list) {
if (c->namelen==len && !memcmp(c->name, errstr, len)) {
errno = c->val;
break;
}
}
if (errno == 0) {
/* TODO: if error isn't found, add it dynamically */
errstr[len] = 0;
printk(KERN_ERR "%s: errstr :%s: not found\n", __FUNCTION__,
errstr);
errno = 1;
}
return -errno;
}

427
fs/9p/fcall.c
View File

@ -1,427 +0,0 @@
/*
* linux/fs/9p/fcall.c
*
* This file contains functions to perform synchronous 9P calls
*
* Copyright (C) 2004 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/idr.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
#include "mux.h"
/**
* v9fs_t_version - negotiate protocol parameters with sever
* @v9ses: 9P2000 session information
* @msize: requested max size packet
* @version: requested version.extension string
* @fcall: pointer to response fcall pointer
*
*/
int
v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
char *version, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
tc = v9fs_create_tversion(msize, version);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_attach - mount the server
* @v9ses: 9P2000 session information
* @uname: user name doing the attach
* @aname: remote name being attached to
* @fid: mount fid to attatch to root node
* @afid: authentication fid (in this case result key)
* @fcall: pointer to response fcall pointer
*
*/
int
v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
u32 fid, u32 afid, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall* tc;
dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
aname, fid, afid);
tc = v9fs_create_tattach(fid, afid, uname, aname);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
static void v9fs_t_clunk_cb(void *a, struct v9fs_fcall *tc,
struct v9fs_fcall *rc, int err)
{
int fid, id;
struct v9fs_session_info *v9ses;
id = 0;
fid = tc->params.tclunk.fid;
if (rc)
id = rc->id;
kfree(tc);
kfree(rc);
if (id == RCLUNK) {
v9ses = a;
v9fs_put_idpool(fid, &v9ses->fidpool);
}
}
/**
* v9fs_t_clunk - release a fid (finish a transaction)
* @v9ses: 9P2000 session information
* @fid: fid to release
* @fcall: pointer to response fcall pointer
*
*/
int
v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
{
int ret;
struct v9fs_fcall *tc, *rc;
dprintk(DEBUG_9P, "fid %d\n", fid);
rc = NULL;
tc = v9fs_create_tclunk(fid);
if (!IS_ERR(tc))
ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
else
ret = PTR_ERR(tc);
if (ret)
dprintk(DEBUG_ERROR, "failed fid %d err %d\n", fid, ret);
v9fs_t_clunk_cb(v9ses, tc, rc, ret);
return ret;
}
#if 0
/**
* v9fs_v9fs_t_flush - flush a pending transaction
* @v9ses: 9P2000 session information
* @tag: tag to release
*
*/
int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "oldtag %d\n", oldtag);
tc = v9fs_create_tflush(oldtag);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, NULL);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
#endif
/**
* v9fs_t_stat - read a file's meta-data
* @v9ses: 9P2000 session information
* @fid: fid pointing to file or directory to get info about
* @fcall: pointer to response fcall
*
*/
int
v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d\n", fid);
ret = -ENOMEM;
tc = v9fs_create_tstat(fid);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_wstat - write a file's meta-data
* @v9ses: 9P2000 session information
* @fid: fid pointing to file or directory to write info about
* @stat: metadata
* @fcall: pointer to response fcall
*
*/
int
v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_wstat *wstat, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d\n", fid);
tc = v9fs_create_twstat(fid, wstat, v9ses->extended);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_walk - walk a fid to a new file or directory
* @v9ses: 9P2000 session information
* @fid: fid to walk
* @newfid: new fid (for clone operations)
* @name: path to walk fid to
* @fcall: pointer to response fcall
*
*/
/* TODO: support multiple walk */
int
v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
char *name, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
int nwname;
dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
if (name)
nwname = 1;
else
nwname = 0;
tc = v9fs_create_twalk(fid, newfid, nwname, &name);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_open - open a file
*
* @v9ses - 9P2000 session information
* @fid - fid to open
* @mode - mode to open file (R, RW, etc)
* @fcall - pointer to response fcall
*
*/
int
v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
tc = v9fs_create_topen(fid, mode);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_remove - remove a file or directory
* @v9ses: 9P2000 session information
* @fid: fid to remove
* @fcall: pointer to response fcall
*
*/
int
v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d\n", fid);
tc = v9fs_create_tremove(fid);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_create - create a file or directory
* @v9ses: 9P2000 session information
* @fid: fid to create
* @name: name of the file or directory to create
* @perm: permissions to create with
* @mode: mode to open file (R, RW, etc)
* @fcall: pointer to response fcall
*
*/
int
v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name, u32 perm,
u8 mode, char *extension, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc;
dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
fid, name, perm, mode);
tc = v9fs_create_tcreate(fid, name, perm, mode, extension,
v9ses->extended);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_read - read data
* @v9ses: 9P2000 session information
* @fid: fid to read from
* @offset: offset to start read at
* @count: how many bytes to read
* @fcall: pointer to response fcall (with data)
*
*/
int
v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
u32 count, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc, *rc;
dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
(long long unsigned) offset, count);
tc = v9fs_create_tread(fid, offset, count);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
if (!ret)
ret = rc->params.rread.count;
if (rcp)
*rcp = rc;
else
kfree(rc);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}
/**
* v9fs_t_write - write data
* @v9ses: 9P2000 session information
* @fid: fid to write to
* @offset: offset to start write at
* @count: how many bytes to write
* @fcall: pointer to response fcall
*
*/
int
v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
const char __user *data, struct v9fs_fcall **rcp)
{
int ret;
struct v9fs_fcall *tc, *rc;
dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
(long long unsigned) offset, count);
tc = v9fs_create_twrite(fid, offset, count, data);
if (!IS_ERR(tc)) {
ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
if (!ret)
ret = rc->params.rwrite.count;
if (rcp)
*rcp = rc;
else
kfree(rc);
kfree(tc);
} else
ret = PTR_ERR(tc);
return ret;
}

168
fs/9p/fid.c
View File

@ -26,10 +26,10 @@
#include <linux/sched.h>
#include <linux/idr.h>
#include <asm/semaphore.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "fid.h"
@ -40,69 +40,31 @@
*
*/
int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry)
int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid)
{
struct list_head *fid_list = (struct list_head *)dentry->d_fsdata;
dprintk(DEBUG_9P, "fid %d (%p) dentry %s (%p)\n", fid->fid, fid,
dentry->d_iname, dentry);
if (dentry->d_fsdata == NULL) {
dentry->d_fsdata =
kmalloc(sizeof(struct list_head), GFP_KERNEL);
if (dentry->d_fsdata == NULL) {
dprintk(DEBUG_ERROR, "Out of memory\n");
struct v9fs_dentry *dent;
P9_DPRINTK(P9_DEBUG_VFS, "fid %d dentry %s\n",
fid->fid, dentry->d_iname);
dent = dentry->d_fsdata;
if (!dent) {
dent = kmalloc(sizeof(struct v9fs_dentry), GFP_KERNEL);
if (!dent)
return -ENOMEM;
}
fid_list = (struct list_head *)dentry->d_fsdata;
INIT_LIST_HEAD(fid_list); /* Initialize list head */
spin_lock_init(&dent->lock);
INIT_LIST_HEAD(&dent->fidlist);
dentry->d_fsdata = dent;
}
fid->uid = current->uid;
list_add(&fid->list, fid_list);
spin_lock(&dent->lock);
list_add(&fid->dlist, &dent->fidlist);
spin_unlock(&dent->lock);
return 0;
}
/**
* v9fs_fid_create - allocate a FID structure
* @dentry - dentry to link newly created fid to
*
*/
struct v9fs_fid *v9fs_fid_create(struct v9fs_session_info *v9ses, int fid)
{
struct v9fs_fid *new;
dprintk(DEBUG_9P, "fid create fid %d\n", fid);
new = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
if (new == NULL) {
dprintk(DEBUG_ERROR, "Out of Memory\n");
return ERR_PTR(-ENOMEM);
}
new->fid = fid;
new->v9ses = v9ses;
new->fidopen = 0;
new->fidclunked = 0;
new->iounit = 0;
new->rdir_pos = 0;
new->rdir_fcall = NULL;
init_MUTEX(&new->lock);
INIT_LIST_HEAD(&new->list);
return new;
}
/**
* v9fs_fid_destroy - deallocate a FID structure
* @fid: fid to destroy
*
*/
void v9fs_fid_destroy(struct v9fs_fid *fid)
{
list_del(&fid->list);
kfree(fid);
}
/**
* v9fs_fid_lookup - return a locked fid from a dentry
* @dentry: dentry to look for fid in
@ -114,30 +76,42 @@ void v9fs_fid_destroy(struct v9fs_fid *fid)
*
*/
struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry)
struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)
{
struct list_head *fid_list = (struct list_head *)dentry->d_fsdata;
struct v9fs_fid *return_fid = NULL;
struct v9fs_dentry *dent;
struct p9_fid *fid;
dprintk(DEBUG_9P, " dentry: %s (%p)\n", dentry->d_iname, dentry);
P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
dent = dentry->d_fsdata;
if (dent)
fid = list_entry(dent->fidlist.next, struct p9_fid, dlist);
else
fid = ERR_PTR(-EBADF);
if (fid_list)
return_fid = list_entry(fid_list->next, struct v9fs_fid, list);
P9_DPRINTK(P9_DEBUG_VFS, " fid: %p\n", fid);
return fid;
}
if (!return_fid) {
dprintk(DEBUG_ERROR, "Couldn't find a fid in dentry\n");
return_fid = ERR_PTR(-EBADF);
struct p9_fid *v9fs_fid_lookup_remove(struct dentry *dentry)
{
struct p9_fid *fid;
struct v9fs_dentry *dent;
dent = dentry->d_fsdata;
fid = v9fs_fid_lookup(dentry);
if (!IS_ERR(fid)) {
spin_lock(&dent->lock);
list_del(&fid->dlist);
spin_unlock(&dent->lock);
}
if(down_interruptible(&return_fid->lock))
return ERR_PTR(-EINTR);
return return_fid;
return fid;
}
/**
* v9fs_fid_clone - lookup the fid for a dentry, clone a private copy and
* release it
* release it
* @dentry: dentry to look for fid in
*
* find a fid in the dentry and then clone to a new private fid
@ -146,49 +120,15 @@ struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry)
*
*/
struct v9fs_fid *v9fs_fid_clone(struct dentry *dentry)
struct p9_fid *v9fs_fid_clone(struct dentry *dentry)
{
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
struct v9fs_fid *base_fid, *new_fid = ERR_PTR(-EBADF);
struct v9fs_fcall *fcall = NULL;
int fid, err;
struct p9_fid *ofid, *fid;
base_fid = v9fs_fid_lookup(dentry);
P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
ofid = v9fs_fid_lookup(dentry);
if (IS_ERR(ofid))
return ofid;
if(IS_ERR(base_fid))
return base_fid;
if(base_fid) { /* clone fid */
fid = v9fs_get_idpool(&v9ses->fidpool);
if (fid < 0) {
eprintk(KERN_WARNING, "newfid fails!\n");
new_fid = ERR_PTR(-ENOSPC);
goto Release_Fid;
}
err = v9fs_t_walk(v9ses, base_fid->fid, fid, NULL, &fcall);
if (err < 0) {
dprintk(DEBUG_ERROR, "clone walk didn't work\n");
v9fs_put_idpool(fid, &v9ses->fidpool);
new_fid = ERR_PTR(err);
goto Free_Fcall;
}
new_fid = v9fs_fid_create(v9ses, fid);
if (new_fid == NULL) {
dprintk(DEBUG_ERROR, "out of memory\n");
new_fid = ERR_PTR(-ENOMEM);
}
Free_Fcall:
kfree(fcall);
}
Release_Fid:
up(&base_fid->lock);
return new_fid;
}
void v9fs_fid_clunk(struct v9fs_session_info *v9ses, struct v9fs_fid *fid)
{
v9fs_t_clunk(v9ses, fid->fid);
v9fs_fid_destroy(fid);
fid = p9_client_walk(ofid, 0, NULL, 1);
return fid;
}

43
fs/9p/fid.h
View File

@ -22,41 +22,12 @@
#include <linux/list.h>
#define FID_OP 0
#define FID_WALK 1
#define FID_CREATE 2
struct v9fs_fid {
struct list_head list; /* list of fids associated with a dentry */
struct list_head active; /* XXX - debug */
struct semaphore lock;
u32 fid;
unsigned char fidopen; /* set when fid is opened */
unsigned char fidclunked; /* set when fid has already been clunked */
struct v9fs_qid qid;
u32 iounit;
/* readdir stuff */
int rdir_fpos;
loff_t rdir_pos;
struct v9fs_fcall *rdir_fcall;
/* management stuff */
uid_t uid; /* user associated with this fid */
/* private data */
struct file *filp; /* backpointer to File struct for open files */
struct v9fs_session_info *v9ses; /* session info for this FID */
struct v9fs_dentry {
spinlock_t lock; /* protect fidlist */
struct list_head fidlist;
};
struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry);
struct v9fs_fid *v9fs_fid_get_created(struct dentry *);
void v9fs_fid_destroy(struct v9fs_fid *fid);
struct v9fs_fid *v9fs_fid_create(struct v9fs_session_info *, int fid);
int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry);
struct v9fs_fid *v9fs_fid_clone(struct dentry *dentry);
void v9fs_fid_clunk(struct v9fs_session_info *v9ses, struct v9fs_fid *fid);
struct p9_fid *v9fs_fid_lookup(struct dentry *dentry);
struct p9_fid *v9fs_fid_lookup_remove(struct dentry *dentry);
struct p9_fid *v9fs_fid_clone(struct dentry *dentry);
int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid);

308
fs/9p/trans_fd.c
View File

@ -1,308 +0,0 @@
/*
* linux/fs/9p/trans_fd.c
*
* Fd transport layer. Includes deprecated socket layer.
*
* Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
* Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004-2005 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
*
* 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
*
*/
#include <linux/in.h>
#include <linux/module.h>
#include <linux/net.h>
#include <linux/ipv6.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/un.h>
#include <asm/uaccess.h>
#include <linux/inet.h>
#include <linux/idr.h>
#include <linux/file.h>
#include "debug.h"
#include "v9fs.h"
#include "transport.h"
#define V9FS_PORT 564
struct v9fs_trans_fd {
struct file *rd;
struct file *wr;
};
/**
* v9fs_fd_read- read from a fd
* @v9ses: session information
* @v: buffer to receive data into
* @len: size of receive buffer
*
*/
static int v9fs_fd_read(struct v9fs_transport *trans, void *v, int len)
{
int ret;
struct v9fs_trans_fd *ts;
if (!trans || trans->status == Disconnected || !(ts = trans->priv))
return -EREMOTEIO;
if (!(ts->rd->f_flags & O_NONBLOCK))
dprintk(DEBUG_ERROR, "blocking read ...\n");
ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
trans->status = Disconnected;
return ret;
}
/**
* v9fs_fd_write - write to a socket
* @v9ses: session information
* @v: buffer to send data from
* @len: size of send buffer
*
*/
static int v9fs_fd_write(struct v9fs_transport *trans, void *v, int len)
{
int ret;
mm_segment_t oldfs;
struct v9fs_trans_fd *ts;
if (!trans || trans->status == Disconnected || !(ts = trans->priv))
return -EREMOTEIO;
if (!(ts->wr->f_flags & O_NONBLOCK))
dprintk(DEBUG_ERROR, "blocking write ...\n");
oldfs = get_fs();
set_fs(get_ds());
/* The cast to a user pointer is valid due to the set_fs() */
ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
set_fs(oldfs);
if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
trans->status = Disconnected;
return ret;
}
static unsigned int
v9fs_fd_poll(struct v9fs_transport *trans, struct poll_table_struct *pt)
{
int ret, n;
struct v9fs_trans_fd *ts;
mm_segment_t oldfs;
if (!trans || trans->status != Connected || !(ts = trans->priv))
return -EREMOTEIO;
if (!ts->rd->f_op || !ts->rd->f_op->poll)
return -EIO;
if (!ts->wr->f_op || !ts->wr->f_op->poll)
return -EIO;
oldfs = get_fs();
set_fs(get_ds());
ret = ts->rd->f_op->poll(ts->rd, pt);
if (ret < 0)
goto end;
if (ts->rd != ts->wr) {
n = ts->wr->f_op->poll(ts->wr, pt);
if (n < 0) {
ret = n;
goto end;
}
ret = (ret & ~POLLOUT) | (n & ~POLLIN);
}
end:
set_fs(oldfs);
return ret;
}
static int v9fs_fd_open(struct v9fs_session_info *v9ses, int rfd, int wfd)
{
struct v9fs_transport *trans = v9ses->transport;
struct v9fs_trans_fd *ts = kmalloc(sizeof(struct v9fs_trans_fd),
GFP_KERNEL);
if (!ts)
return -ENOMEM;
ts->rd = fget(rfd);
ts->wr = fget(wfd);
if (!ts->rd || !ts->wr) {
if (ts->rd)
fput(ts->rd);
if (ts->wr)
fput(ts->wr);
kfree(ts);
return -EIO;
}
trans->priv = ts;
trans->status = Connected;
return 0;
}
static int v9fs_fd_init(struct v9fs_session_info *v9ses, const char *addr,
char *data)
{
if (v9ses->rfdno == ~0 || v9ses->wfdno == ~0) {
printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
return -ENOPROTOOPT;
}
return v9fs_fd_open(v9ses, v9ses->rfdno, v9ses->wfdno);
}
static int v9fs_socket_open(struct v9fs_session_info *v9ses,
struct socket *csocket)
{
int fd, ret;
csocket->sk->sk_allocation = GFP_NOIO;
if ((fd = sock_map_fd(csocket)) < 0) {
eprintk(KERN_ERR, "v9fs_socket_open: failed to map fd\n");
ret = fd;
release_csocket:
sock_release(csocket);
return ret;
}
if ((ret = v9fs_fd_open(v9ses, fd, fd)) < 0) {
sockfd_put(csocket);
eprintk(KERN_ERR, "v9fs_socket_open: failed to open fd\n");
goto release_csocket;
}
((struct v9fs_trans_fd *)v9ses->transport->priv)->rd->f_flags |=
O_NONBLOCK;
return 0;
}
static int v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr,
char *data)
{
int ret;
struct socket *csocket = NULL;
struct sockaddr_in sin_server;
sin_server.sin_family = AF_INET;
sin_server.sin_addr.s_addr = in_aton(addr);
sin_server.sin_port = htons(v9ses->port);
sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
if (!csocket) {
eprintk(KERN_ERR, "v9fs_trans_tcp: problem creating socket\n");
return -1;
}
ret = csocket->ops->connect(csocket,
(struct sockaddr *)&sin_server,
sizeof(struct sockaddr_in), 0);
if (ret < 0) {
eprintk(KERN_ERR,
"v9fs_trans_tcp: problem connecting socket to %s\n",
addr);
return ret;
}
return v9fs_socket_open(v9ses, csocket);
}
static int
v9fs_unix_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
{
int ret;
struct socket *csocket;
struct sockaddr_un sun_server;
if (strlen(addr) > UNIX_PATH_MAX) {
eprintk(KERN_ERR, "v9fs_trans_unix: address too long: %s\n",
addr);
return -ENAMETOOLONG;
}
sun_server.sun_family = PF_UNIX;
strcpy(sun_server.sun_path, addr);
sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
ret = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
sizeof(struct sockaddr_un) - 1, 0);
if (ret < 0) {
eprintk(KERN_ERR,
"v9fs_trans_unix: problem connecting socket: %s: %d\n",
addr, ret);
return ret;
}
return v9fs_socket_open(v9ses, csocket);
}
/**
* v9fs_sock_close - shutdown socket
* @trans: private socket structure
*
*/
static void v9fs_fd_close(struct v9fs_transport *trans)
{
struct v9fs_trans_fd *ts;
if (!trans)
return;
ts = xchg(&trans->priv, NULL);
if (!ts)
return;
trans->status = Disconnected;
if (ts->rd)
fput(ts->rd);
if (ts->wr)
fput(ts->wr);
kfree(ts);
}
struct v9fs_transport v9fs_trans_fd = {
.init = v9fs_fd_init,
.write = v9fs_fd_write,
.read = v9fs_fd_read,
.close = v9fs_fd_close,
.poll = v9fs_fd_poll,
};
struct v9fs_transport v9fs_trans_tcp = {
.init = v9fs_tcp_init,
.write = v9fs_fd_write,
.read = v9fs_fd_read,
.close = v9fs_fd_close,
.poll = v9fs_fd_poll,
};
struct v9fs_transport v9fs_trans_unix = {
.init = v9fs_unix_init,
.write = v9fs_fd_write,
.read = v9fs_fd_read,
.close = v9fs_fd_close,
.poll = v9fs_fd_poll,
};

288
fs/9p/v9fs.c
View File

@ -29,16 +29,12 @@
#include <linux/sched.h>
#include <linux/parser.h>
#include <linux/idr.h>
#include "debug.h"
#include <net/9p/9p.h>
#include <net/9p/transport.h>
#include <net/9p/conn.h>
#include <net/9p/client.h>
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "transport.h"
#include "mux.h"
/* TODO: sysfs or debugfs interface */
int v9fs_debug_level = 0; /* feature-rific global debug level */
/*
* Option Parsing (code inspired by NFS code)
@ -47,12 +43,12 @@ int v9fs_debug_level = 0; /* feature-rific global debug level */
enum {
/* Options that take integer arguments */
Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid, Opt_debug,
Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid,
Opt_rfdno, Opt_wfdno,
/* String options */
Opt_uname, Opt_remotename,
/* Options that take no arguments */
Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd,
Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd, Opt_pci,
/* Cache options */
Opt_cache_loose,
/* Error token */
@ -67,12 +63,14 @@ static match_table_t tokens = {
{Opt_afid, "afid=%u"},
{Opt_rfdno, "rfdno=%u"},
{Opt_wfdno, "wfdno=%u"},
{Opt_debug, "debug=%x"},
{Opt_uname, "uname=%s"},
{Opt_remotename, "aname=%s"},
{Opt_unix, "proto=unix"},
{Opt_tcp, "proto=tcp"},
{Opt_fd, "proto=fd"},
#ifdef CONFIG_PCI_9P
{Opt_pci, "proto=pci"},
#endif
{Opt_tcp, "tcp"},
{Opt_unix, "unix"},
{Opt_fd, "fd"},
@ -83,6 +81,8 @@ static match_table_t tokens = {
{Opt_err, NULL}
};
extern struct p9_transport *p9pci_trans_create(void);
/*
* Parse option string.
*/
@ -122,7 +122,7 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
token = match_token(p, tokens, args);
if (token < Opt_uname) {
if ((ret = match_int(&args[0], &option)) < 0) {
dprintk(DEBUG_ERROR,
P9_DPRINTK(P9_DEBUG_ERROR,
"integer field, but no integer?\n");
continue;
}
@ -149,15 +149,15 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
case Opt_wfdno:
v9ses->wfdno = option;
break;
case Opt_debug:
v9ses->debug = option;
break;
case Opt_tcp:
v9ses->proto = PROTO_TCP;
break;
case Opt_unix:
v9ses->proto = PROTO_UNIX;
break;
case Opt_pci:
v9ses->proto = PROTO_PCI;
break;
case Opt_fd:
v9ses->proto = PROTO_FD;
break;
@ -182,82 +182,6 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
}
}
/**
* v9fs_inode2v9ses - safely extract v9fs session info from super block
* @inode: inode to extract information from
*
* Paranoid function to extract v9ses information from superblock,
* if anything is missing it will report an error.
*
*/
struct v9fs_session_info *v9fs_inode2v9ses(struct inode *inode)
{
return (inode->i_sb->s_fs_info);
}
/**
* v9fs_get_idpool - allocate numeric id from pool
* @p - pool to allocate from
*
* XXX - This seems to be an awful generic function, should it be in idr.c with
* the lock included in struct idr?
*/
int v9fs_get_idpool(struct v9fs_idpool *p)
{
int i = 0;
int error;
retry:
if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
return 0;
if (down_interruptible(&p->lock) == -EINTR) {
eprintk(KERN_WARNING, "Interrupted while locking\n");
return -1;
}
/* no need to store exactly p, we just need something non-null */
error = idr_get_new(&p->pool, p, &i);
up(&p->lock);
if (error == -EAGAIN)
goto retry;
else if (error)
return -1;
return i;
}
/**
* v9fs_put_idpool - release numeric id from pool
* @p - pool to allocate from
*
* XXX - This seems to be an awful generic function, should it be in idr.c with
* the lock included in struct idr?
*/
void v9fs_put_idpool(int id, struct v9fs_idpool *p)
{
if (down_interruptible(&p->lock) == -EINTR) {
eprintk(KERN_WARNING, "Interrupted while locking\n");
return;
}
idr_remove(&p->pool, id);
up(&p->lock);
}
/**
* v9fs_check_idpool - check if the specified id is available
* @id - id to check
* @p - pool
*/
int v9fs_check_idpool(int id, struct v9fs_idpool *p)
{
return idr_find(&p->pool, id) != NULL;
}
/**
* v9fs_session_init - initialize session
* @v9ses: session information structure
@ -266,25 +190,21 @@ int v9fs_check_idpool(int id, struct v9fs_idpool *p)
*
*/
int
v9fs_session_init(struct v9fs_session_info *v9ses,
struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
const char *dev_name, char *data)
{
struct v9fs_fcall *fcall = NULL;
struct v9fs_transport *trans_proto;
int n = 0;
int newfid = -1;
int retval = -EINVAL;
struct v9fs_str *version;
struct p9_transport *trans;
struct p9_fid *fid;
v9ses->name = __getname();
if (!v9ses->name)
return -ENOMEM;
return ERR_PTR(-ENOMEM);
v9ses->remotename = __getname();
if (!v9ses->remotename) {
__putname(v9ses->name);
return -ENOMEM;
return ERR_PTR(-ENOMEM);
}
strcpy(v9ses->name, V9FS_DEFUSER);
@ -292,130 +212,60 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
v9fs_parse_options(data, v9ses);
/* set global debug level */
v9fs_debug_level = v9ses->debug;
/* id pools that are session-dependent: fids and tags */
idr_init(&v9ses->fidpool.pool);
init_MUTEX(&v9ses->fidpool.lock);
switch (v9ses->proto) {
case PROTO_TCP:
trans_proto = &v9fs_trans_tcp;
trans = p9_trans_create_tcp(dev_name, v9ses->port);
break;
case PROTO_UNIX:
trans_proto = &v9fs_trans_unix;
trans = p9_trans_create_unix(dev_name);
*v9ses->remotename = 0;
break;
case PROTO_FD:
trans_proto = &v9fs_trans_fd;
trans = p9_trans_create_fd(v9ses->rfdno, v9ses->wfdno);
*v9ses->remotename = 0;
break;
#ifdef CONFIG_PCI_9P
case PROTO_PCI:
trans = p9pci_trans_create();
*v9ses->remotename = 0;
break;
#endif
default:
printk(KERN_ERR "v9fs: Bad mount protocol %d\n", v9ses->proto);
retval = -ENOPROTOOPT;
goto SessCleanUp;
goto error;
};
v9ses->transport = kmalloc(sizeof(*v9ses->transport), GFP_KERNEL);
if (!v9ses->transport) {
retval = -ENOMEM;
goto SessCleanUp;
if (IS_ERR(trans)) {
retval = PTR_ERR(trans);
trans = NULL;
goto error;
}
memmove(v9ses->transport, trans_proto, sizeof(*v9ses->transport));
v9ses->clnt = p9_client_create(trans, v9ses->maxdata + P9_IOHDRSZ,
v9ses->extended);
if ((retval = v9ses->transport->init(v9ses, dev_name, data)) < 0) {
eprintk(KERN_ERR, "problem initializing transport\n");
goto SessCleanUp;
if (IS_ERR(v9ses->clnt)) {
retval = PTR_ERR(v9ses->clnt);
v9ses->clnt = NULL;
P9_DPRINTK(P9_DEBUG_ERROR, "problem initializing 9p client\n");
goto error;
}
v9ses->inprogress = 0;
v9ses->shutdown = 0;
v9ses->session_hung = 0;
v9ses->mux = v9fs_mux_init(v9ses->transport, v9ses->maxdata + V9FS_IOHDRSZ,
&v9ses->extended);
if (IS_ERR(v9ses->mux)) {
retval = PTR_ERR(v9ses->mux);
v9ses->mux = NULL;
dprintk(DEBUG_ERROR, "problem initializing mux\n");
goto SessCleanUp;
fid = p9_client_attach(v9ses->clnt, NULL, v9ses->name,
v9ses->remotename);
if (IS_ERR(fid)) {
retval = PTR_ERR(fid);
fid = NULL;
P9_DPRINTK(P9_DEBUG_ERROR, "cannot attach\n");
goto error;
}
if (v9ses->afid == ~0) {
if (v9ses->extended)
retval =
v9fs_t_version(v9ses, v9ses->maxdata, "9P2000.u",
&fcall);
else
retval = v9fs_t_version(v9ses, v9ses->maxdata, "9P2000",
&fcall);
return fid;
if (retval < 0) {
dprintk(DEBUG_ERROR, "v9fs_t_version failed\n");
goto FreeFcall;
}
version = &fcall->params.rversion.version;
if (version->len==8 && !memcmp(version->str, "9P2000.u", 8)) {
dprintk(DEBUG_9P, "9P2000 UNIX extensions enabled\n");
v9ses->extended = 1;
} else if (version->len==6 && !memcmp(version->str, "9P2000", 6)) {
dprintk(DEBUG_9P, "9P2000 legacy mode enabled\n");
v9ses->extended = 0;
} else {
retval = -EREMOTEIO;
goto FreeFcall;
}
n = fcall->params.rversion.msize;
kfree(fcall);
if (n < v9ses->maxdata)
v9ses->maxdata = n;
}
newfid = v9fs_get_idpool(&v9ses->fidpool);
if (newfid < 0) {
eprintk(KERN_WARNING, "couldn't allocate FID\n");
retval = -ENOMEM;
goto SessCleanUp;
}
/* it is a little bit ugly, but we have to prevent newfid */
/* being the same as afid, so if it is, get a new fid */
if (v9ses->afid != ~0 && newfid == v9ses->afid) {
newfid = v9fs_get_idpool(&v9ses->fidpool);
if (newfid < 0) {
eprintk(KERN_WARNING, "couldn't allocate FID\n");
retval = -ENOMEM;
goto SessCleanUp;
}
}
if ((retval =
v9fs_t_attach(v9ses, v9ses->name, v9ses->remotename, newfid,
v9ses->afid, NULL))
< 0) {
dprintk(DEBUG_ERROR, "cannot attach\n");
goto SessCleanUp;
}
if (v9ses->afid != ~0) {
dprintk(DEBUG_ERROR, "afid not equal to ~0\n");
if (v9fs_t_clunk(v9ses, v9ses->afid))
dprintk(DEBUG_ERROR, "clunk failed\n");
}
return newfid;
FreeFcall:
kfree(fcall);
SessCleanUp:
error:
v9fs_session_close(v9ses);
return retval;
return ERR_PTR(retval);
}
/**
@ -426,15 +276,9 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
void v9fs_session_close(struct v9fs_session_info *v9ses)
{
if (v9ses->mux) {
v9fs_mux_destroy(v9ses->mux);
v9ses->mux = NULL;
}
if (v9ses->transport) {
v9ses->transport->close(v9ses->transport);
kfree(v9ses->transport);
v9ses->transport = NULL;
if (v9ses->clnt) {
p9_client_destroy(v9ses->clnt);
v9ses->clnt = NULL;
}
__putname(v9ses->name);
@ -446,9 +290,8 @@ void v9fs_session_close(struct v9fs_session_info *v9ses)
* and cancel all pending requests.
*/
void v9fs_session_cancel(struct v9fs_session_info *v9ses) {
dprintk(DEBUG_ERROR, "cancel session %p\n", v9ses);
v9ses->transport->status = Disconnected;
v9fs_mux_cancel(v9ses->mux, -EIO);
P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses);
p9_client_disconnect(v9ses->clnt);
}
extern int v9fs_error_init(void);
@ -460,24 +303,9 @@ extern int v9fs_error_init(void);
static int __init init_v9fs(void)
{
int ret;
v9fs_error_init();
printk(KERN_INFO "Installing v9fs 9p2000 file system support\n");
ret = v9fs_mux_global_init();
if (ret) {
printk(KERN_WARNING "v9fs: starting mux failed\n");
return ret;
}
ret = register_filesystem(&v9fs_fs_type);
if (ret) {
printk(KERN_WARNING "v9fs: registering file system failed\n");
v9fs_mux_global_exit();
}
return ret;
return register_filesystem(&v9fs_fs_type);
}
/**
@ -487,13 +315,13 @@ static int __init init_v9fs(void)
static void __exit exit_v9fs(void)
{
v9fs_mux_global_exit();
unregister_filesystem(&v9fs_fs_type);
}
module_init(init_v9fs)
module_exit(exit_v9fs)
MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
MODULE_LICENSE("GPL");

32
fs/9p/v9fs.h
View File

@ -21,16 +21,6 @@
*
*/
/*
* Idpool structure provides lock and id management
*
*/
struct v9fs_idpool {
struct semaphore lock;
struct idr pool;
};
/*
* Session structure provides information for an opened session
*
@ -54,15 +44,7 @@ struct v9fs_session_info {
unsigned int uid; /* default uid/muid for legacy support */
unsigned int gid; /* default gid for legacy support */
/* book keeping */
struct v9fs_idpool fidpool; /* The FID pool for file descriptors */
struct v9fs_transport *transport;
struct v9fs_mux_data *mux;
int inprogress; /* session in progress => true */
int shutdown; /* session shutting down. no more attaches. */
unsigned char session_hung;
struct p9_client *clnt; /* 9p client */
struct dentry *debugfs_dir;
};
@ -71,6 +53,7 @@ enum {
PROTO_TCP,
PROTO_UNIX,
PROTO_FD,
PROTO_PCI,
};
/* possible values of ->cache */
@ -82,12 +65,9 @@ enum {
extern struct dentry *v9fs_debugfs_root;
int v9fs_session_init(struct v9fs_session_info *, const char *, char *);
struct v9fs_session_info *v9fs_inode2v9ses(struct inode *);
struct p9_fid *v9fs_session_init(struct v9fs_session_info *, const char *,
char *);
void v9fs_session_close(struct v9fs_session_info *v9ses);
int v9fs_get_idpool(struct v9fs_idpool *p);
void v9fs_put_idpool(int id, struct v9fs_idpool *p);
int v9fs_check_idpool(int id, struct v9fs_idpool *p);
void v9fs_session_cancel(struct v9fs_session_info *v9ses);
#define V9FS_MAGIC 0x01021997
@ -97,3 +77,7 @@ void v9fs_session_cancel(struct v9fs_session_info *v9ses);
#define V9FS_DEFUSER "nobody"
#define V9FS_DEFANAME ""
static inline struct v9fs_session_info *v9fs_inode2v9ses(struct inode *inode)
{
return (inode->i_sb->s_fs_info);
}

6
fs/9p/v9fs_vfs.h
View File

@ -45,10 +45,10 @@ extern struct dentry_operations v9fs_dentry_operations;
extern struct dentry_operations v9fs_cached_dentry_operations;
struct inode *v9fs_get_inode(struct super_block *sb, int mode);
ino_t v9fs_qid2ino(struct v9fs_qid *qid);
void v9fs_stat2inode(struct v9fs_stat *, struct inode *, struct super_block *);
ino_t v9fs_qid2ino(struct p9_qid *qid);
void v9fs_stat2inode(struct p9_stat *, struct inode *, struct super_block *);
int v9fs_dir_release(struct inode *inode, struct file *filp);
int v9fs_file_open(struct inode *inode, struct file *file);
void v9fs_inode2stat(struct inode *inode, struct v9fs_stat *stat);
void v9fs_inode2stat(struct inode *inode, struct p9_stat *stat);
void v9fs_dentry_release(struct dentry *);
int v9fs_uflags2omode(int uflags);

57
fs/9p/vfs_addr.c
View File

@ -33,10 +33,10 @@
#include <linux/pagemap.h>
#include <linux/idr.h>
#include <linux/sched.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "fid.h"
@ -50,55 +50,26 @@
static int v9fs_vfs_readpage(struct file *filp, struct page *page)
{
char *buffer = NULL;
int retval = -EIO;
loff_t offset = page_offset(page);
int count = PAGE_CACHE_SIZE;
struct inode *inode = filp->f_path.dentry->d_inode;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
int rsize = v9ses->maxdata - V9FS_IOHDRSZ;
struct v9fs_fid *v9f = filp->private_data;
struct v9fs_fcall *fcall = NULL;
int fid = v9f->fid;
int total = 0;
int result = 0;
dprintk(DEBUG_VFS, "\n");
int retval;
loff_t offset;
char *buffer;
struct p9_fid *fid;
P9_DPRINTK(P9_DEBUG_VFS, "\n");
fid = filp->private_data;
buffer = kmap(page);
do {
if (count < rsize)
rsize = count;
offset = page_offset(page);
result = v9fs_t_read(v9ses, fid, offset, rsize, &fcall);
retval = p9_client_readn(fid, buffer, offset, PAGE_CACHE_SIZE);
if (retval < 0)
goto done;
if (result < 0) {
printk(KERN_ERR "v9fs_t_read returned %d\n",
result);
kfree(fcall);
goto UnmapAndUnlock;
} else
offset += result;
memcpy(buffer, fcall->params.rread.data, result);
count -= result;
buffer += result;
total += result;
kfree(fcall);
if (result < rsize)
break;
} while (count);
memset(buffer, 0, count);
memset(buffer + retval, 0, PAGE_CACHE_SIZE - retval);
flush_dcache_page(page);
SetPageUptodate(page);
retval = 0;
UnmapAndUnlock:
done:
kunmap(page);
unlock_page(page);
return retval;

35
fs/9p/vfs_dentry.c
View File

@ -34,10 +34,10 @@
#include <linux/namei.h>
#include <linux/idr.h>
#include <linux/sched.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "fid.h"
@ -52,7 +52,7 @@
static int v9fs_dentry_delete(struct dentry *dentry)
{
dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
return 1;
}
@ -69,7 +69,7 @@ static int v9fs_dentry_delete(struct dentry *dentry)
static int v9fs_cached_dentry_delete(struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
if(!inode)
return 1;
@ -85,26 +85,19 @@ static int v9fs_cached_dentry_delete(struct dentry *dentry)
void v9fs_dentry_release(struct dentry *dentry)
{
int err;
struct v9fs_dentry *dent;
struct p9_fid *temp, *current_fid;
dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
if (dentry->d_fsdata != NULL) {
struct list_head *fid_list = dentry->d_fsdata;
struct v9fs_fid *temp = NULL;
struct v9fs_fid *current_fid = NULL;
list_for_each_entry_safe(current_fid, temp, fid_list, list) {
err = v9fs_t_clunk(current_fid->v9ses, current_fid->fid);
if (err < 0)
dprintk(DEBUG_ERROR, "clunk failed: %d name %s\n",
err, dentry->d_iname);
v9fs_fid_destroy(current_fid);
P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
dent = dentry->d_fsdata;
if (dent) {
list_for_each_entry_safe(current_fid, temp, &dent->fidlist,
dlist) {
p9_client_clunk(current_fid);
}
kfree(dentry->d_fsdata); /* free the list_head */
kfree(dent);
dentry->d_fsdata = NULL;
}
}

149
fs/9p/vfs_dir.c
View File

@ -32,11 +32,10 @@
#include <linux/sched.h>
#include <linux/inet.h>
#include <linux/idr.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
#include "v9fs_vfs.h"
#include "fid.h"
@ -46,14 +45,14 @@
*
*/
static inline int dt_type(struct v9fs_stat *mistat)
static inline int dt_type(struct p9_stat *mistat)
{
unsigned long perm = mistat->mode;
int rettype = DT_REG;
if (perm & V9FS_DMDIR)
if (perm & P9_DMDIR)
rettype = DT_DIR;
if (perm & V9FS_DMSYMLINK)
if (perm & P9_DMSYMLINK)
rettype = DT_LNK;
return rettype;
@ -69,106 +68,36 @@ static inline int dt_type(struct v9fs_stat *mistat)
static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
struct v9fs_fcall *fcall = NULL;
struct inode *inode = filp->f_path.dentry->d_inode;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
struct v9fs_fid *file = filp->private_data;
unsigned int i, n, s;
int fid = -1;
int ret = 0;
struct v9fs_stat stat;
int over = 0;
int over;
struct p9_fid *fid;
struct v9fs_session_info *v9ses;
struct inode *inode;
struct p9_stat *st;
dprintk(DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name);
P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name);
inode = filp->f_path.dentry->d_inode;
v9ses = v9fs_inode2v9ses(inode);
fid = filp->private_data;
while ((st = p9_client_dirread(fid, filp->f_pos)) != NULL) {
if (IS_ERR(st))
return PTR_ERR(st);
fid = file->fid;
over = filldir(dirent, st->name.str, st->name.len, filp->f_pos,
v9fs_qid2ino(&st->qid), dt_type(st));
if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
kfree(file->rdir_fcall);
file->rdir_fcall = NULL;
}
if (file->rdir_fcall) {
n = file->rdir_fcall->params.rread.count;
i = file->rdir_fpos;
while (i < n) {
s = v9fs_deserialize_stat(
file->rdir_fcall->params.rread.data + i,
n - i, &stat, v9ses->extended);
if (s == 0) {
dprintk(DEBUG_ERROR,
"error while deserializing stat\n");
ret = -EIO;
goto FreeStructs;
}
over = filldir(dirent, stat.name.str, stat.name.len,
filp->f_pos, v9fs_qid2ino(&stat.qid),
dt_type(&stat));
if (over) {
file->rdir_fpos = i;
file->rdir_pos = filp->f_pos;
break;
}
i += s;
filp->f_pos += s;
}
if (!over) {
kfree(file->rdir_fcall);
file->rdir_fcall = NULL;
}
}
while (!over) {
ret = v9fs_t_read(v9ses, fid, filp->f_pos,
v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
if (ret < 0) {
dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
ret, fcall);
goto FreeStructs;
} else if (ret == 0)
if (over)
break;
n = ret;
i = 0;
while (i < n) {
s = v9fs_deserialize_stat(fcall->params.rread.data + i,
n - i, &stat, v9ses->extended);
if (s == 0) {
dprintk(DEBUG_ERROR,
"error while deserializing stat\n");
return -EIO;
}
over = filldir(dirent, stat.name.str, stat.name.len,
filp->f_pos, v9fs_qid2ino(&stat.qid),
dt_type(&stat));
if (over) {
file->rdir_fcall = fcall;
file->rdir_fpos = i;
file->rdir_pos = filp->f_pos;
fcall = NULL;
break;
}
i += s;
filp->f_pos += s;
}
kfree(fcall);
filp->f_pos += st->size;
kfree(st);
st = NULL;
}
FreeStructs:
kfree(fcall);
return ret;
kfree(st);
return 0;
}
/**
* v9fs_dir_release - close a directory
* @inode: inode of the directory
@ -178,29 +107,13 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
int v9fs_dir_release(struct inode *inode, struct file *filp)
{
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
struct v9fs_fid *fid = filp->private_data;
int fidnum = -1;
dprintk(DEBUG_VFS, "inode: %p filp: %p fid: %d\n", inode, filp,
fid->fid);
fidnum = fid->fid;
struct p9_fid *fid;
fid = filp->private_data;
P9_DPRINTK(P9_DEBUG_VFS,
"inode: %p filp: %p fid: %d\n", inode, filp, fid->fid);
filemap_write_and_wait(inode->i_mapping);
if (fidnum >= 0) {
dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
fid->fid);
if (v9fs_t_clunk(v9ses, fidnum))
dprintk(DEBUG_ERROR, "clunk failed\n");
kfree(fid->rdir_fcall);
kfree(fid);
filp->private_data = NULL;
}
p9_client_clunk(fid);
return 0;
}

160
fs/9p/vfs_file.c
View File

@ -34,10 +34,10 @@
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/idr.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "fid.h"
@ -52,48 +52,36 @@ static const struct file_operations v9fs_cached_file_operations;
int v9fs_file_open(struct inode *inode, struct file *file)
{
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
struct v9fs_fid *vfid;
struct v9fs_fcall *fcall = NULL;
int omode;
int err;
struct v9fs_session_info *v9ses;
struct p9_fid *fid;
int omode;
dprintk(DEBUG_VFS, "inode: %p file: %p \n", inode, file);
vfid = v9fs_fid_clone(file->f_path.dentry);
if (IS_ERR(vfid))
return PTR_ERR(vfid);
P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p \n", inode, file);
v9ses = v9fs_inode2v9ses(inode);
omode = v9fs_uflags2omode(file->f_flags);
err = v9fs_t_open(v9ses, vfid->fid, omode, &fcall);
fid = file->private_data;
if (!fid) {
fid = v9fs_fid_clone(file->f_path.dentry);
if (IS_ERR(fid))
return PTR_ERR(fid);
err = p9_client_open(fid, omode);
if (err < 0) {
PRINT_FCALL_ERROR("open failed", fcall);
goto Clunk_Fid;
p9_client_clunk(fid);
return err;
}
}
file->private_data = vfid;
vfid->fidopen = 1;
vfid->fidclunked = 0;
vfid->iounit = fcall->params.ropen.iounit;
vfid->rdir_pos = 0;
vfid->rdir_fcall = NULL;
vfid->filp = file;
kfree(fcall);
if((vfid->qid.version) && (v9ses->cache)) {
dprintk(DEBUG_VFS, "cached");
file->private_data = fid;
if ((fid->qid.version) && (v9ses->cache)) {
P9_DPRINTK(P9_DEBUG_VFS, "cached");
/* enable cached file options */
if(file->f_op == &v9fs_file_operations)
file->f_op = &v9fs_cached_file_operations;
}
return 0;
Clunk_Fid:
v9fs_fid_clunk(v9ses, vfid);
kfree(fcall);
return err;
}
/**
@ -110,7 +98,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
int res = 0;
struct inode *inode = filp->f_path.dentry->d_inode;
dprintk(DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
/* No mandatory locks */
if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
@ -136,55 +124,16 @@ static ssize_t
v9fs_file_read(struct file *filp, char __user * data, size_t count,
loff_t * offset)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
struct v9fs_fid *v9f = filp->private_data;
struct v9fs_fcall *fcall = NULL;
int fid = v9f->fid;
int rsize = 0;
int result = 0;
int total = 0;
int n;
int ret;
struct p9_fid *fid;
dprintk(DEBUG_VFS, "\n");
P9_DPRINTK(P9_DEBUG_VFS, "\n");
fid = filp->private_data;
ret = p9_client_uread(fid, data, *offset, count);
if (ret > 0)
*offset += ret;
rsize = v9ses->maxdata - V9FS_IOHDRSZ;
if (v9f->iounit != 0 && rsize > v9f->iounit)
rsize = v9f->iounit;
do {
if (count < rsize)
rsize = count;
result = v9fs_t_read(v9ses, fid, *offset, rsize, &fcall);
if (result < 0) {
printk(KERN_ERR "9P2000: v9fs_t_read returned %d\n",
result);
kfree(fcall);
return total;
} else
*offset += result;
n = copy_to_user(data, fcall->params.rread.data, result);
if (n) {
dprintk(DEBUG_ERROR, "Problem copying to user %d\n", n);
kfree(fcall);
return -EFAULT;
}
count -= result;
data += result;
total += result;
kfree(fcall);
if (result < rsize)
break;
} while (count);
return total;
return ret;
}
/**
@ -200,50 +149,19 @@ static ssize_t
v9fs_file_write(struct file *filp, const char __user * data,
size_t count, loff_t * offset)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
struct v9fs_fid *v9fid = filp->private_data;
struct v9fs_fcall *fcall;
int fid = v9fid->fid;
int result = -EIO;
int rsize = 0;
int total = 0;
int ret;
struct p9_fid *fid;
dprintk(DEBUG_VFS, "data %p count %d offset %x\n", data, (int)count,
(int)*offset);
rsize = v9ses->maxdata - V9FS_IOHDRSZ;
if (v9fid->iounit != 0 && rsize > v9fid->iounit)
rsize = v9fid->iounit;
P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
(int)count, (int)*offset);
do {
if (count < rsize)
rsize = count;
fid = filp->private_data;
ret = p9_client_uwrite(fid, data, *offset, count);
if (ret > 0)
*offset += ret;
result = v9fs_t_write(v9ses, fid, *offset, rsize, data, &fcall);
if (result < 0) {
PRINT_FCALL_ERROR("error while writing", fcall);
kfree(fcall);
return result;
} else
*offset += result;
kfree(fcall);
fcall = NULL;
if (result != rsize) {
eprintk(KERN_ERR,
"short write: v9fs_t_write returned %d\n",
result);
break;
}
count -= result;
data += result;
total += result;
} while (count);
invalidate_inode_pages2(inode->i_mapping);
return total;
invalidate_inode_pages2(filp->f_path.dentry->d_inode->i_mapping);
return ret;
}
static const struct file_operations v9fs_cached_file_operations = {

751
fs/9p/vfs_inode.c
View File

File diff suppressed because it is too large Load Diff

95
fs/9p/vfs_super.c
View File

@ -37,10 +37,10 @@
#include <linux/mount.h>
#include <linux/idr.h>
#include <linux/sched.h>
#include <net/9p/9p.h>
#include <net/9p/client.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "v9fs_vfs.h"
#include "fid.h"
@ -107,41 +107,48 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
struct vfsmount *mnt)
{
struct super_block *sb = NULL;
struct v9fs_fcall *fcall = NULL;
struct inode *inode = NULL;
struct dentry *root = NULL;
struct v9fs_session_info *v9ses = NULL;
struct v9fs_fid *root_fid = NULL;
struct p9_stat *st = NULL;
int mode = S_IRWXUGO | S_ISVTX;
uid_t uid = current->fsuid;
gid_t gid = current->fsgid;
int stat_result = 0;
int newfid = 0;
struct p9_fid *fid;
int retval = 0;
dprintk(DEBUG_VFS, " \n");
P9_DPRINTK(P9_DEBUG_VFS, " \n");
v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
if (!v9ses)
return -ENOMEM;
if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) {
dprintk(DEBUG_ERROR, "problem initiating session\n");
retval = newfid;
goto out_free_session;
fid = v9fs_session_init(v9ses, dev_name, data);
if (IS_ERR(fid)) {
retval = PTR_ERR(fid);
fid = NULL;
kfree(v9ses);
v9ses = NULL;
goto error;
}
st = p9_client_stat(fid);
if (IS_ERR(st)) {
retval = PTR_ERR(st);
goto error;
}
sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
if (IS_ERR(sb)) {
retval = PTR_ERR(sb);
goto out_close_session;
goto error;
}
v9fs_fill_super(sb, v9ses, flags);
inode = v9fs_get_inode(sb, S_IFDIR | mode);
if (IS_ERR(inode)) {
retval = PTR_ERR(inode);
goto put_back_sb;
goto error;
}
inode->i_uid = uid;
@ -150,54 +157,30 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
root = d_alloc_root(inode);
if (!root) {
retval = -ENOMEM;
goto put_back_sb;
goto error;
}
sb->s_root = root;
stat_result = v9fs_t_stat(v9ses, newfid, &fcall);
if (stat_result < 0) {
dprintk(DEBUG_ERROR, "stat error\n");
v9fs_t_clunk(v9ses, newfid);
} else {
/* Setup the Root Inode */
root_fid = v9fs_fid_create(v9ses, newfid);
if (root_fid == NULL) {
retval = -ENOMEM;
goto put_back_sb;
}
retval = v9fs_fid_insert(root_fid, root);
if (retval < 0) {
kfree(fcall);
goto put_back_sb;
}
root_fid->qid = fcall->params.rstat.stat.qid;
root->d_inode->i_ino =
v9fs_qid2ino(&fcall->params.rstat.stat.qid);
v9fs_stat2inode(&fcall->params.rstat.stat, root->d_inode, sb);
}
kfree(fcall);
if (stat_result < 0) {
retval = stat_result;
goto put_back_sb;
}
root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
v9fs_stat2inode(st, root->d_inode, sb);
v9fs_fid_add(root, fid);
return simple_set_mnt(mnt, sb);
out_close_session:
v9fs_session_close(v9ses);
out_free_session:
kfree(v9ses);
return retval;
error:
if (fid)
p9_client_clunk(fid);
if (v9ses) {
v9fs_session_close(v9ses);
kfree(v9ses);
}
if (sb) {
up_write(&sb->s_umount);
deactivate_super(sb);
}
put_back_sb:
/* deactivate_super calls v9fs_kill_super which will frees the rest */
up_write(&sb->s_umount);
deactivate_super(sb);
return retval;
}
@ -211,7 +194,7 @@ static void v9fs_kill_super(struct super_block *s)
{
struct v9fs_session_info *v9ses = s->s_fs_info;
dprintk(DEBUG_VFS, " %p\n", s);
P9_DPRINTK(P9_DEBUG_VFS, " %p\n", s);
v9fs_dentry_release(s->s_root); /* clunk root */
@ -219,7 +202,7 @@ static void v9fs_kill_super(struct super_block *s)
v9fs_session_close(v9ses);
kfree(v9ses);
dprintk(DEBUG_VFS, "exiting kill_super\n");
P9_DPRINTK(P9_DEBUG_VFS, "exiting kill_super\n");
}
/**

2
fs/Kconfig
View File

@ -2048,7 +2048,7 @@ config AFS_DEBUG
config 9P_FS
tristate "Plan 9 Resource Sharing Support (9P2000) (Experimental)"
depends on INET && EXPERIMENTAL
depends on INET && NET_9P && EXPERIMENTAL
help
If you say Y here, you will get experimental support for
Plan 9 resource sharing via the 9P2000 protocol.

417
include/net/9p/9p.h Normal file
View File

@ -0,0 +1,417 @@
/*
* include/net/9p/9p.h
*
* 9P protocol definitions.
*
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
#ifndef NET_9P_H
#define NET_9P_H
#ifdef CONFIG_NET_9P_DEBUG
#define P9_DEBUG_ERROR (1<<0)
#define P9_DEBUG_9P (1<<2)
#define P9_DEBUG_VFS (1<<3)
#define P9_DEBUG_CONV (1<<4)
#define P9_DEBUG_MUX (1<<5)
#define P9_DEBUG_TRANS (1<<6)
#define P9_DEBUG_SLABS (1<<7)
#define P9_DEBUG_FCALL (1<<8)
extern unsigned int p9_debug_level;
#define P9_DPRINTK(level, format, arg...) \
do { \
if ((p9_debug_level & level) == level) \
printk(KERN_NOTICE "-- %s (%d): " \
format , __FUNCTION__, current->pid , ## arg); \
} while (0)
#define PRINT_FCALL_ERROR(s, fcall) P9_DPRINTK(P9_DEBUG_ERROR, \
"%s: %.*s\n", s, fcall?fcall->params.rerror.error.len:0, \
fcall?fcall->params.rerror.error.str:"");
#else
#define P9_DPRINTK(level, format, arg...) do { } while (0)
#define PRINT_FCALL_ERROR(s, fcall) do { } while (0)
#endif
#define P9_EPRINTK(level, format, arg...) \
do { \
printk(level "9p: %s (%d): " \
format , __FUNCTION__, current->pid , ## arg); \
} while (0)
/* Message Types */
enum {
P9_TVERSION = 100,
P9_RVERSION,
P9_TAUTH = 102,
P9_RAUTH,
P9_TATTACH = 104,
P9_RATTACH,
P9_TERROR = 106,
P9_RERROR,
P9_TFLUSH = 108,
P9_RFLUSH,
P9_TWALK = 110,
P9_RWALK,
P9_TOPEN = 112,
P9_ROPEN,
P9_TCREATE = 114,
P9_RCREATE,
P9_TREAD = 116,
P9_RREAD,
P9_TWRITE = 118,
P9_RWRITE,
P9_TCLUNK = 120,
P9_RCLUNK,
P9_TREMOVE = 122,
P9_RREMOVE,
P9_TSTAT = 124,
P9_RSTAT,
P9_TWSTAT = 126,
P9_RWSTAT,
};
/* open modes */
enum {
P9_OREAD = 0x00,
P9_OWRITE = 0x01,
P9_ORDWR = 0x02,
P9_OEXEC = 0x03,
P9_OEXCL = 0x04,
P9_OTRUNC = 0x10,
P9_OREXEC = 0x20,
P9_ORCLOSE = 0x40,
P9_OAPPEND = 0x80,
};
/* permissions */
enum {
P9_DMDIR = 0x80000000,
P9_DMAPPEND = 0x40000000,
P9_DMEXCL = 0x20000000,
P9_DMMOUNT = 0x10000000,
P9_DMAUTH = 0x08000000,
P9_DMTMP = 0x04000000,
P9_DMSYMLINK = 0x02000000,
P9_DMLINK = 0x01000000,
/* 9P2000.u extensions */
P9_DMDEVICE = 0x00800000,
P9_DMNAMEDPIPE = 0x00200000,
P9_DMSOCKET = 0x00100000,
P9_DMSETUID = 0x00080000,
P9_DMSETGID = 0x00040000,
};
/* qid.types */
enum {
P9_QTDIR = 0x80,
P9_QTAPPEND = 0x40,
P9_QTEXCL = 0x20,
P9_QTMOUNT = 0x10,
P9_QTAUTH = 0x08,
P9_QTTMP = 0x04,
P9_QTSYMLINK = 0x02,
P9_QTLINK = 0x01,
P9_QTFILE = 0x00,
};
#define P9_NOTAG (u16)(~0)
#define P9_NOFID (u32)(~0)
#define P9_MAXWELEM 16
/* ample room for Twrite/Rread header */
#define P9_IOHDRSZ 24
struct p9_str {
u16 len;
char *str;
};
/* qids are the unique ID for a file (like an inode */
struct p9_qid {
u8 type;
u32 version;
u64 path;
};
/* Plan 9 file metadata (stat) structure */
struct p9_stat {
u16 size;
u16 type;
u32 dev;
struct p9_qid qid;
u32 mode;
u32 atime;
u32 mtime;
u64 length;
struct p9_str name;
struct p9_str uid;
struct p9_str gid;
struct p9_str muid;
struct p9_str extension; /* 9p2000.u extensions */
u32 n_uid; /* 9p2000.u extensions */
u32 n_gid; /* 9p2000.u extensions */
u32 n_muid; /* 9p2000.u extensions */
};
/* file metadata (stat) structure used to create Twstat message
The is similar to p9_stat, but the strings don't point to
the same memory block and should be freed separately
*/
struct p9_wstat {
u16 size;
u16 type;
u32 dev;
struct p9_qid qid;
u32 mode;
u32 atime;
u32 mtime;
u64 length;
char *name;
char *uid;
char *gid;
char *muid;
char *extension; /* 9p2000.u extensions */
u32 n_uid; /* 9p2000.u extensions */
u32 n_gid; /* 9p2000.u extensions */
u32 n_muid; /* 9p2000.u extensions */
};
/* Structures for Protocol Operations */
struct p9_tversion {
u32 msize;
struct p9_str version;
};
struct p9_rversion {
u32 msize;
struct p9_str version;
};
struct p9_tauth {
u32 afid;
struct p9_str uname;
struct p9_str aname;
};
struct p9_rauth {
struct p9_qid qid;
};
struct p9_rerror {
struct p9_str error;
u32 errno; /* 9p2000.u extension */
};
struct p9_tflush {
u16 oldtag;
};
struct p9_rflush {
};
struct p9_tattach {
u32 fid;
u32 afid;
struct p9_str uname;
struct p9_str aname;
};
struct p9_rattach {
struct p9_qid qid;
};
struct p9_twalk {
u32 fid;
u32 newfid;
u16 nwname;
struct p9_str wnames[16];
};
struct p9_rwalk {
u16 nwqid;
struct p9_qid wqids[16];
};
struct p9_topen {
u32 fid;
u8 mode;
};
struct p9_ropen {
struct p9_qid qid;
u32 iounit;
};
struct p9_tcreate {
u32 fid;
struct p9_str name;
u32 perm;
u8 mode;
struct p9_str extension;
};
struct p9_rcreate {
struct p9_qid qid;
u32 iounit;
};
struct p9_tread {
u32 fid;
u64 offset;
u32 count;
};
struct p9_rread {
u32 count;
u8 *data;
};
struct p9_twrite {
u32 fid;
u64 offset;
u32 count;
u8 *data;
};
struct p9_rwrite {
u32 count;
};
struct p9_tclunk {
u32 fid;
};
struct p9_rclunk {
};
struct p9_tremove {
u32 fid;
};
struct p9_rremove {
};
struct p9_tstat {
u32 fid;
};
struct p9_rstat {
struct p9_stat stat;
};
struct p9_twstat {
u32 fid;
struct p9_stat stat;
};
struct p9_rwstat {
};
/*
* fcall is the primary packet structure
*
*/
struct p9_fcall {
u32 size;
u8 id;
u16 tag;
void *sdata;
union {
struct p9_tversion tversion;
struct p9_rversion rversion;
struct p9_tauth tauth;
struct p9_rauth rauth;
struct p9_rerror rerror;
struct p9_tflush tflush;
struct p9_rflush rflush;
struct p9_tattach tattach;
struct p9_rattach rattach;
struct p9_twalk twalk;
struct p9_rwalk rwalk;
struct p9_topen topen;
struct p9_ropen ropen;
struct p9_tcreate tcreate;
struct p9_rcreate rcreate;
struct p9_tread tread;
struct p9_rread rread;
struct p9_twrite twrite;
struct p9_rwrite rwrite;
struct p9_tclunk tclunk;
struct p9_rclunk rclunk;
struct p9_tremove tremove;
struct p9_rremove rremove;
struct p9_tstat tstat;
struct p9_rstat rstat;
struct p9_twstat twstat;
struct p9_rwstat rwstat;
} params;
};
struct p9_idpool;
int p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat,
int dotu);
int p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *fc, int dotu);
void p9_set_tag(struct p9_fcall *fc, u16 tag);
struct p9_fcall *p9_create_tversion(u32 msize, char *version);
struct p9_fcall *p9_create_tattach(u32 fid, u32 afid, char *uname,
char *aname);
struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname);
struct p9_fcall *p9_create_tflush(u16 oldtag);
struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname,
char **wnames);
struct p9_fcall *p9_create_topen(u32 fid, u8 mode);
struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
char *extension, int dotu);
struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count);
struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count,
const char *data);
struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count,
const char __user *data);
struct p9_fcall *p9_create_tclunk(u32 fid);
struct p9_fcall *p9_create_tremove(u32 fid);
struct p9_fcall *p9_create_tstat(u32 fid);
struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat,
int dotu);
int p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int dotu);
int p9_errstr2errno(char *errstr, int len);
struct p9_idpool *p9_idpool_create(void);
void p9_idpool_destroy(struct p9_idpool *);
int p9_idpool_get(struct p9_idpool *p);
void p9_idpool_put(int id, struct p9_idpool *p);
int p9_idpool_check(int id, struct p9_idpool *p);
int p9_error_init(void);
int p9_errstr2errno(char *, int);
int __init p9_sysctl_register(void);
void __exit p9_sysctl_unregister(void);
#endif /* NET_9P_H */

80
include/net/9p/client.h Normal file
View File

@ -0,0 +1,80 @@
/*
* include/net/9p/client.h
*
* 9P Client Definitions
*
* 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
*
*/
#ifndef NET_9P_CLIENT_H
#define NET_9P_CLIENT_H
struct p9_client {
spinlock_t lock; /* protect client structure */
int msize;
unsigned char dotu;
struct p9_transport *trans;
struct p9_conn *conn;
struct p9_idpool *fidpool;
struct list_head fidlist;
};
struct p9_fid {
struct p9_client *clnt;
u32 fid;
int mode;
struct p9_qid qid;
u32 iounit;
uid_t uid;
void *aux;
int rdir_fpos;
int rdir_pos;
struct p9_fcall *rdir_fcall;
struct list_head flist;
struct list_head dlist; /* list of all fids attached to a dentry */
};
struct p9_client *p9_client_create(struct p9_transport *trans, int msize,
int dotu);
void p9_client_destroy(struct p9_client *clnt);
void p9_client_disconnect(struct p9_client *clnt);
struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
char *uname, char *aname);
struct p9_fid *p9_client_auth(struct p9_client *clnt, char *uname, char *aname);
struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
int clone);
int p9_client_open(struct p9_fid *fid, int mode);
int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
char *extension);
int p9_client_clunk(struct p9_fid *fid);
int p9_client_remove(struct p9_fid *fid);
int p9_client_read(struct p9_fid *fid, char *data, u64 offset, u32 count);
int p9_client_readn(struct p9_fid *fid, char *data, u64 offset, u32 count);
int p9_client_write(struct p9_fid *fid, char *data, u64 offset, u32 count);
int p9_client_uread(struct p9_fid *fid, char __user *data, u64 offset,
u32 count);
int p9_client_uwrite(struct p9_fid *fid, const char __user *data, u64 offset,
u32 count);
struct p9_stat *p9_client_stat(struct p9_fid *fid);
int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst);
struct p9_stat *p9_client_dirread(struct p9_fid *fid, u64 offset);
#endif /* NET_9P_CLIENT_H */

42
fs/9p/mux.h → include/net/9p/conn.h
View File

@ -1,7 +1,7 @@
/*
* linux/fs/9p/mux.h
* include/net/9p/conn.h
*
* Multiplexer Definitions
* Connection Definitions
*
* Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
@ -23,33 +23,35 @@
*
*/
struct v9fs_mux_data;
struct v9fs_req;
#ifndef NET_9P_CONN_H
#define NET_9P_CONN_H
#undef P9_NONBLOCK
struct p9_conn;
struct p9_req;
/**
* v9fs_mux_req_callback - callback function that is called when the
* p9_mux_req_callback - callback function that is called when the
* response of a request is received. The callback is called from
* a workqueue and shouldn't block.
*
* @req - request
* @a - the pointer that was specified when the request was send to be
* passed to the callback
* @tc - request call
* @rc - response call
* @err - error code (non-zero if error occured)
*/
typedef void (*v9fs_mux_req_callback)(struct v9fs_req *req, void *a);
typedef void (*p9_conn_req_callback)(struct p9_req *req, void *a);
int v9fs_mux_global_init(void);
void v9fs_mux_global_exit(void);
struct p9_conn *p9_conn_create(struct p9_transport *trans, int msize,
unsigned char *dotu);
void p9_conn_destroy(struct p9_conn *);
int p9_conn_rpc(struct p9_conn *m, struct p9_fcall *tc, struct p9_fcall **rc);
struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
unsigned char *extended);
void v9fs_mux_destroy(struct v9fs_mux_data *);
#ifdef P9_NONBLOCK
int p9_conn_rpcnb(struct p9_conn *m, struct p9_fcall *tc,
p9_conn_req_callback cb, void *a);
#endif /* P9_NONBLOCK */
int v9fs_mux_send(struct v9fs_mux_data *m, struct v9fs_fcall *tc);
struct v9fs_fcall *v9fs_mux_recv(struct v9fs_mux_data *m);
int v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc, struct v9fs_fcall **rc);
void p9_conn_cancel(struct p9_conn *m, int err);
void v9fs_mux_flush(struct v9fs_mux_data *m, int sendflush);
void v9fs_mux_cancel(struct v9fs_mux_data *m, int err);
int v9fs_errstr2errno(char *errstr, int len);
#endif /* NET_9P_CONN_H */

28
fs/9p/transport.h → include/net/9p/transport.h
View File

@ -1,5 +1,5 @@
/*
* linux/fs/9p/transport.h
* include/net/9p/transport.h
*
* Transport Definition
*
@ -23,23 +23,27 @@
*
*/
enum v9fs_transport_status {
#ifndef NET_9P_TRANSPORT_H
#define NET_9P_TRANSPORT_H
enum p9_transport_status {
Connected,
Disconnected,
Hung,
};
struct v9fs_transport {
enum v9fs_transport_status status;
struct p9_transport {
enum p9_transport_status status;
void *priv;
int (*init) (struct v9fs_session_info *, const char *, char *);
int (*write) (struct v9fs_transport *, void *, int);
int (*read) (struct v9fs_transport *, void *, int);
void (*close) (struct v9fs_transport *);
unsigned int (*poll)(struct v9fs_transport *, struct poll_table_struct *);
int (*write) (struct p9_transport *, void *, int);
int (*read) (struct p9_transport *, void *, int);
void (*close) (struct p9_transport *);
unsigned int (*poll)(struct p9_transport *, struct poll_table_struct *);
};
extern struct v9fs_transport v9fs_trans_tcp;
extern struct v9fs_transport v9fs_trans_unix;
extern struct v9fs_transport v9fs_trans_fd;
struct p9_transport *p9_trans_create_tcp(const char *addr, int port);
struct p9_transport *p9_trans_create_unix(const char *addr);
struct p9_transport *p9_trans_create_fd(int rfd, int wfd);
#endif /* NET_9P_TRANSPORT_H */

21
net/9p/Kconfig Normal file
View File

@ -0,0 +1,21 @@
#
# 9P protocol configuration
#
menuconfig NET_9P
depends on NET && EXPERIMENTAL
tristate "Plan 9 Resource Sharing Support (9P2000) (Experimental)"
help
If you say Y here, you will get experimental support for
Plan 9 resource sharing via the 9P2000 protocol.
See <http://v9fs.sf.net> for more information.
If unsure, say N.
config NET_9P_DEBUG
bool "Debug information"
depends on NET_9P
help
Say Y if you want the 9P subsistem to log debug information.

13
net/9p/Makefile Normal file
View File

@ -0,0 +1,13 @@
obj-$(CONFIG_NET_9P) := 9p.o
9p-objs := \
mod.o \
trans_fd.o \
mux.o \
client.o \
conv.o \
error.o \
fcprint.o \
util.o \
9p-$(CONFIG_SYSCTL) += sysctl.o

965
net/9p/client.c Normal file
View File

@ -0,0 +1,965 @@
/*
* net/9p/clnt.c
*
* 9P Client
*
* 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
*
*/
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <net/9p/9p.h>
#include <net/9p/transport.h>
#include <net/9p/conn.h>
#include <net/9p/client.h>
static struct p9_fid *p9_fid_create(struct p9_client *clnt);
static void p9_fid_destroy(struct p9_fid *fid);
static struct p9_stat *p9_clone_stat(struct p9_stat *st, int dotu);
struct p9_client *p9_client_create(struct p9_transport *trans, int msize,
int dotu)
{
int err, n;
struct p9_client *clnt;
struct p9_fcall *tc, *rc;
struct p9_str *version;
err = 0;
tc = NULL;
rc = NULL;
clnt = kmalloc(sizeof(struct p9_client), GFP_KERNEL);
if (!clnt)
return ERR_PTR(-ENOMEM);
P9_DPRINTK(P9_DEBUG_9P, "clnt %p trans %p msize %d dotu %d\n",
clnt, trans, msize, dotu);
spin_lock_init(&clnt->lock);
clnt->trans = trans;
clnt->msize = msize;
clnt->dotu = dotu;
INIT_LIST_HEAD(&clnt->fidlist);
clnt->fidpool = p9_idpool_create();
if (!clnt->fidpool) {
err = PTR_ERR(clnt->fidpool);
clnt->fidpool = NULL;
goto error;
}
clnt->conn = p9_conn_create(clnt->trans, clnt->msize, &clnt->dotu);
if (IS_ERR(clnt->conn)) {
err = PTR_ERR(clnt->conn);
clnt->conn = NULL;
goto error;
}
tc = p9_create_tversion(clnt->msize, clnt->dotu?"9P2000.u":"9P2000");
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
version = &rc->params.rversion.version;
if (version->len == 8 && !memcmp(version->str, "9P2000.u", 8))
clnt->dotu = 1;
else if (version->len == 6 && !memcmp(version->str, "9P2000", 6))
clnt->dotu = 0;
else {
err = -EREMOTEIO;
goto error;
}
n = rc->params.rversion.msize;
if (n < clnt->msize)
clnt->msize = n;
kfree(tc);
kfree(rc);
return clnt;
error:
kfree(tc);
kfree(rc);
p9_client_destroy(clnt);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_create);
void p9_client_destroy(struct p9_client *clnt)
{
struct p9_fid *fid, *fidptr;
P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
if (clnt->conn) {
p9_conn_destroy(clnt->conn);
clnt->conn = NULL;
}
if (clnt->trans) {
clnt->trans->close(clnt->trans);
kfree(clnt->trans);
clnt->trans = NULL;
}
if (clnt->fidpool)
p9_idpool_destroy(clnt->fidpool);
list_for_each_entry_safe(fid, fidptr, &clnt->fidlist, flist)
p9_fid_destroy(fid);
kfree(clnt);
}
EXPORT_SYMBOL(p9_client_destroy);
void p9_client_disconnect(struct p9_client *clnt)
{
P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
clnt->trans->status = Disconnected;
p9_conn_cancel(clnt->conn, -EIO);
}
EXPORT_SYMBOL(p9_client_disconnect);
struct p9_fid *p9_client_attach(struct p9_client *clnt, struct p9_fid *afid,
char *uname, char *aname)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_fid *fid;
P9_DPRINTK(P9_DEBUG_9P, "clnt %p afid %d uname %s aname %s\n",
clnt, afid?afid->fid:-1, uname, aname);
err = 0;
tc = NULL;
rc = NULL;
fid = p9_fid_create(clnt);
if (IS_ERR(fid)) {
err = PTR_ERR(fid);
fid = NULL;
goto error;
}
tc = p9_create_tattach(fid->fid, afid?afid->fid:P9_NOFID, uname, aname);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
memmove(&fid->qid, &rc->params.rattach.qid, sizeof(struct p9_qid));
kfree(tc);
kfree(rc);
return fid;
error:
kfree(tc);
kfree(rc);
if (fid)
p9_fid_destroy(fid);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_attach);
struct p9_fid *p9_client_auth(struct p9_client *clnt, char *uname, char *aname)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_fid *fid;
P9_DPRINTK(P9_DEBUG_9P, "clnt %p uname %s aname %s\n", clnt, uname,
aname);
err = 0;
tc = NULL;
rc = NULL;
fid = p9_fid_create(clnt);
if (IS_ERR(fid)) {
err = PTR_ERR(fid);
fid = NULL;
goto error;
}
tc = p9_create_tauth(fid->fid, uname, aname);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
memmove(&fid->qid, &rc->params.rauth.qid, sizeof(struct p9_qid));
kfree(tc);
kfree(rc);
return fid;
error:
kfree(tc);
kfree(rc);
if (fid)
p9_fid_destroy(fid);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_auth);
struct p9_fid *p9_client_walk(struct p9_fid *oldfid, int nwname, char **wnames,
int clone)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
struct p9_fid *fid;
P9_DPRINTK(P9_DEBUG_9P, "fid %d nwname %d wname[0] %s\n",
oldfid->fid, nwname, wnames?wnames[0]:NULL);
err = 0;
tc = NULL;
rc = NULL;
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;
tc = p9_create_twalk(oldfid->fid, fid->fid, nwname, wnames);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err) {
if (rc && rc->id == P9_RWALK)
goto clunk_fid;
else
goto error;
}
if (rc->params.rwalk.nwqid != nwname) {
err = -ENOENT;
goto clunk_fid;
}
if (nwname)
memmove(&fid->qid,
&rc->params.rwalk.wqids[rc->params.rwalk.nwqid - 1],
sizeof(struct p9_qid));
else
fid->qid = oldfid->qid;
kfree(tc);
kfree(rc);
return fid;
clunk_fid:
kfree(tc);
kfree(rc);
rc = NULL;
tc = p9_create_tclunk(fid->fid);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
p9_conn_rpc(clnt->conn, tc, &rc);
error:
kfree(tc);
kfree(rc);
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_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d mode %d\n", fid->fid, mode);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
if (fid->mode != -1)
return -EINVAL;
tc = p9_create_topen(fid->fid, mode);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto done;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto done;
fid->mode = mode;
fid->iounit = rc->params.ropen.iounit;
done:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_open);
int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
char *extension)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d name %s perm %d mode %d\n", fid->fid,
name, perm, mode);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
if (fid->mode != -1)
return -EINVAL;
tc = p9_create_tcreate(fid->fid, name, perm, mode, extension,
clnt->dotu);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto done;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto done;
fid->mode = mode;
fid->iounit = rc->params.ropen.iounit;
done:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_fcreate);
int p9_client_clunk(struct p9_fid *fid)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
tc = p9_create_tclunk(fid->fid);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto done;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto done;
p9_fid_destroy(fid);
done:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_clunk);
int p9_client_remove(struct p9_fid *fid)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
tc = p9_create_tremove(fid->fid);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto done;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto done;
p9_fid_destroy(fid);
done:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_remove);
int p9_client_read(struct p9_fid *fid, char *data, u64 offset, u32 count)
{
int err, n, rsize, total;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu %d\n", fid->fid,
(long long unsigned) offset, count);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
total = 0;
rsize = fid->iounit;
if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
rsize = clnt->msize - P9_IOHDRSZ;
do {
if (count < rsize)
rsize = count;
tc = p9_create_tread(fid->fid, offset, rsize);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
n = rc->params.rread.count;
if (n > count)
n = count;
memmove(data, rc->params.rread.data, n);
count -= n;
data += n;
offset += n;
total += n;
kfree(tc);
tc = NULL;
kfree(rc);
rc = NULL;
} while (count > 0 && n == rsize);
return total;
error:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_read);
int p9_client_write(struct p9_fid *fid, char *data, u64 offset, u32 count)
{
int err, n, rsize, total;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
(long long unsigned) offset, count);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
total = 0;
rsize = fid->iounit;
if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
rsize = clnt->msize - P9_IOHDRSZ;
do {
if (count < rsize)
rsize = count;
tc = p9_create_twrite(fid->fid, offset, rsize, data);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
n = rc->params.rread.count;
count -= n;
data += n;
offset += n;
total += n;
kfree(tc);
tc = NULL;
kfree(rc);
rc = NULL;
} while (count > 0);
return total;
error:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_write);
int
p9_client_uread(struct p9_fid *fid, char __user *data, u64 offset, u32 count)
{
int err, n, rsize, total;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
(long long unsigned) offset, count);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
total = 0;
rsize = fid->iounit;
if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
rsize = clnt->msize - P9_IOHDRSZ;
do {
if (count < rsize)
rsize = count;
tc = p9_create_tread(fid->fid, offset, rsize);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
n = rc->params.rread.count;
if (n > count)
n = count;
err = copy_to_user(data, rc->params.rread.data, n);
if (err) {
err = -EFAULT;
goto error;
}
count -= n;
data += n;
offset += n;
total += n;
kfree(tc);
tc = NULL;
kfree(rc);
rc = NULL;
} while (count > 0 && n == rsize);
return total;
error:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_uread);
int
p9_client_uwrite(struct p9_fid *fid, const char __user *data, u64 offset,
u32 count)
{
int err, n, rsize, total;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
(long long unsigned) offset, count);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
total = 0;
rsize = fid->iounit;
if (!rsize || rsize > clnt->msize-P9_IOHDRSZ)
rsize = clnt->msize - P9_IOHDRSZ;
do {
if (count < rsize)
rsize = count;
tc = p9_create_twrite_u(fid->fid, offset, rsize, data);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
n = rc->params.rread.count;
count -= n;
data += n;
offset += n;
total += n;
kfree(tc);
tc = NULL;
kfree(rc);
rc = NULL;
} while (count > 0);
return total;
error:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_uwrite);
int p9_client_readn(struct p9_fid *fid, char *data, u64 offset, u32 count)
{
int n, total;
P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu count %d\n", fid->fid,
(long long unsigned) offset, count);
n = 0;
total = 0;
while (count) {
n = p9_client_read(fid, data, offset, count);
if (n <= 0)
break;
data += n;
offset += n;
count -= n;
total += n;
}
if (n < 0)
total = n;
return total;
}
EXPORT_SYMBOL(p9_client_readn);
struct p9_stat *p9_client_stat(struct p9_fid *fid)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
struct p9_stat *ret;
P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
err = 0;
tc = NULL;
rc = NULL;
ret = NULL;
clnt = fid->clnt;
tc = p9_create_tstat(fid->fid);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
ret = p9_clone_stat(&rc->params.rstat.stat, clnt->dotu);
if (IS_ERR(ret)) {
err = PTR_ERR(ret);
ret = NULL;
goto error;
}
kfree(tc);
kfree(rc);
return ret;
error:
kfree(tc);
kfree(rc);
kfree(ret);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_stat);
int p9_client_wstat(struct p9_fid *fid, struct p9_wstat *wst)
{
int err;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
err = 0;
tc = NULL;
rc = NULL;
clnt = fid->clnt;
tc = p9_create_twstat(fid->fid, wst, clnt->dotu);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto done;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
done:
kfree(tc);
kfree(rc);
return err;
}
EXPORT_SYMBOL(p9_client_wstat);
struct p9_stat *p9_client_dirread(struct p9_fid *fid, u64 offset)
{
int err, n, m;
struct p9_fcall *tc, *rc;
struct p9_client *clnt;
struct p9_stat st, *ret;
P9_DPRINTK(P9_DEBUG_9P, "fid %d offset %llu\n", fid->fid,
(long long unsigned) offset);
err = 0;
tc = NULL;
rc = NULL;
ret = NULL;
clnt = fid->clnt;
/* if the offset is below or above the current response, free it */
if (offset < fid->rdir_fpos || (fid->rdir_fcall &&
offset >= fid->rdir_fpos+fid->rdir_fcall->params.rread.count)) {
fid->rdir_pos = 0;
if (fid->rdir_fcall)
fid->rdir_fpos += fid->rdir_fcall->params.rread.count;
kfree(fid->rdir_fcall);
fid->rdir_fcall = NULL;
if (offset < fid->rdir_fpos)
fid->rdir_fpos = 0;
}
if (!fid->rdir_fcall) {
n = fid->iounit;
if (!n || n > clnt->msize-P9_IOHDRSZ)
n = clnt->msize - P9_IOHDRSZ;
while (1) {
if (fid->rdir_fcall) {
fid->rdir_fpos +=
fid->rdir_fcall->params.rread.count;
kfree(fid->rdir_fcall);
fid->rdir_fcall = NULL;
}
tc = p9_create_tread(fid->fid, fid->rdir_fpos, n);
if (IS_ERR(tc)) {
err = PTR_ERR(tc);
tc = NULL;
goto error;
}
err = p9_conn_rpc(clnt->conn, tc, &rc);
if (err)
goto error;
n = rc->params.rread.count;
if (n == 0)
goto done;
fid->rdir_fcall = rc;
rc = NULL;
if (offset >= fid->rdir_fpos &&
offset < fid->rdir_fpos+n)
break;
}
fid->rdir_pos = 0;
}
m = offset - fid->rdir_fpos;
if (m < 0)
goto done;
n = p9_deserialize_stat(fid->rdir_fcall->params.rread.data + m,
fid->rdir_fcall->params.rread.count - m, &st, clnt->dotu);
if (!n) {
err = -EIO;
goto error;
}
fid->rdir_pos += n;
st.size = n;
ret = p9_clone_stat(&st, clnt->dotu);
if (IS_ERR(ret)) {
err = PTR_ERR(ret);
ret = NULL;
goto error;
}
done:
kfree(tc);
kfree(rc);
return ret;
error:
kfree(tc);
kfree(rc);
kfree(ret);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_client_dirread);
static struct p9_stat *p9_clone_stat(struct p9_stat *st, int dotu)
{
int n;
char *p;
struct p9_stat *ret;
n = sizeof(struct p9_stat) + st->name.len + st->uid.len + st->gid.len +
st->muid.len;
if (dotu)
n += st->extension.len;
ret = kmalloc(n, GFP_KERNEL);
if (!ret)
return ERR_PTR(-ENOMEM);
memmove(ret, st, sizeof(struct p9_stat));
p = ((char *) ret) + sizeof(struct p9_stat);
memmove(p, st->name.str, st->name.len);
p += st->name.len;
memmove(p, st->uid.str, st->uid.len);
p += st->uid.len;
memmove(p, st->gid.str, st->gid.len);
p += st->gid.len;
memmove(p, st->muid.str, st->muid.len);
p += st->muid.len;
if (dotu) {
memmove(p, st->extension.str, st->extension.len);
p += st->extension.len;
}
return ret;
}
static struct p9_fid *p9_fid_create(struct p9_client *clnt)
{
int err;
struct p9_fid *fid;
P9_DPRINTK(P9_DEBUG_9P, "clnt %p\n", clnt);
fid = kmalloc(sizeof(struct p9_fid), GFP_KERNEL);
if (!fid)
return ERR_PTR(-ENOMEM);
fid->fid = p9_idpool_get(clnt->fidpool);
if (fid->fid < 0) {
err = -ENOSPC;
goto error;
}
memset(&fid->qid, 0, sizeof(struct p9_qid));
fid->mode = -1;
fid->rdir_fpos = 0;
fid->rdir_pos = 0;
fid->rdir_fcall = NULL;
fid->uid = current->fsuid;
fid->clnt = clnt;
fid->aux = NULL;
spin_lock(&clnt->lock);
list_add(&fid->flist, &clnt->fidlist);
spin_unlock(&clnt->lock);
return fid;
error:
kfree(fid);
return ERR_PTR(err);
}
static void p9_fid_destroy(struct p9_fid *fid)
{
struct p9_client *clnt;
P9_DPRINTK(P9_DEBUG_9P, "fid %d\n", fid->fid);
clnt = fid->clnt;
p9_idpool_put(fid->fid, clnt->fidpool);
spin_lock(&clnt->lock);
list_del(&fid->flist);
spin_unlock(&clnt->lock);
kfree(fid->rdir_fcall);
kfree(fid);
}

428
fs/9p/conv.c → net/9p/conv.c
View File

@ -1,5 +1,5 @@
/*
* linux/fs/9p/conv.c
* net/9p/conv.c
*
* 9P protocol conversion functions
*
@ -29,11 +29,8 @@
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/idr.h>
#include <asm/uaccess.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "conv.h"
#include <linux/uaccess.h>
#include <net/9p/9p.h>
/*
* Buffer to help with string parsing
@ -59,8 +56,9 @@ static int buf_check_size(struct cbuf *buf, int len)
{
if (buf->p + len > buf->ep) {
if (buf->p < buf->ep) {
eprintk(KERN_ERR, "buffer overflow: want %d has %d\n",
len, (int)(buf->ep - buf->p));
P9_EPRINTK(KERN_ERR,
"buffer overflow: want %d has %d\n", len,
(int)(buf->ep - buf->p));
dump_stack();
buf->p = buf->ep + 1;
}
@ -183,7 +181,7 @@ static u64 buf_get_int64(struct cbuf *buf)
return ret;
}
static void buf_get_str(struct cbuf *buf, struct v9fs_str *vstr)
static void buf_get_str(struct cbuf *buf, struct p9_str *vstr)
{
vstr->len = buf_get_int16(buf);
if (!buf_check_overflow(buf) && buf_check_size(buf, vstr->len)) {
@ -195,7 +193,7 @@ static void buf_get_str(struct cbuf *buf, struct v9fs_str *vstr)
}
}
static void buf_get_qid(struct cbuf *bufp, struct v9fs_qid *qid)
static void buf_get_qid(struct cbuf *bufp, struct p9_qid *qid)
{
qid->type = buf_get_int8(bufp);
qid->version = buf_get_int32(bufp);
@ -203,18 +201,18 @@ static void buf_get_qid(struct cbuf *bufp, struct v9fs_qid *qid)
}
/**
* v9fs_size_wstat - calculate the size of a variable length stat struct
* p9_size_wstat - calculate the size of a variable length stat struct
* @stat: metadata (stat) structure
* @extended: non-zero if 9P2000.u
* @dotu: non-zero if 9P2000.u
*
*/
static int v9fs_size_wstat(struct v9fs_wstat *wstat, int extended)
static int p9_size_wstat(struct p9_wstat *wstat, int dotu)
{
int size = 0;
if (wstat == NULL) {
eprintk(KERN_ERR, "v9fs_size_stat: got a NULL stat pointer\n");
P9_EPRINTK(KERN_ERR, "p9_size_stat: got a NULL stat pointer\n");
return 0;
}
@ -239,7 +237,7 @@ static int v9fs_size_wstat(struct v9fs_wstat *wstat, int extended)
if (wstat->muid)
size += strlen(wstat->muid);
if (extended) {
if (dotu) {
size += 4 + /* n_uid[4] */
4 + /* n_gid[4] */
4 + /* n_muid[4] */
@ -255,12 +253,12 @@ static int v9fs_size_wstat(struct v9fs_wstat *wstat, int extended)
* buf_get_stat - safely decode a recieved metadata (stat) structure
* @bufp: buffer to deserialize
* @stat: metadata (stat) structure
* @extended: non-zero if 9P2000.u
* @dotu: non-zero if 9P2000.u
*
*/
static void
buf_get_stat(struct cbuf *bufp, struct v9fs_stat *stat, int extended)
buf_get_stat(struct cbuf *bufp, struct p9_stat *stat, int dotu)
{
stat->size = buf_get_int16(bufp);
stat->type = buf_get_int16(bufp);
@ -277,7 +275,7 @@ buf_get_stat(struct cbuf *bufp, struct v9fs_stat *stat, int extended)
buf_get_str(bufp, &stat->gid);
buf_get_str(bufp, &stat->muid);
if (extended) {
if (dotu) {
buf_get_str(bufp, &stat->extension);
stat->n_uid = buf_get_int32(bufp);
stat->n_gid = buf_get_int32(bufp);
@ -286,18 +284,18 @@ buf_get_stat(struct cbuf *bufp, struct v9fs_stat *stat, int extended)
}
/**
* v9fs_deserialize_stat - decode a received metadata structure
* p9_deserialize_stat - decode a received metadata structure
* @buf: buffer to deserialize
* @buflen: length of received buffer
* @stat: metadata structure to decode into
* @extended: non-zero if 9P2000.u
* @dotu: non-zero if 9P2000.u
*
* Note: stat will point to the buf region.
*/
int
v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
int extended)
p9_deserialize_stat(void *buf, u32 buflen, struct p9_stat *stat,
int dotu)
{
struct cbuf buffer;
struct cbuf *bufp = &buffer;
@ -305,13 +303,14 @@ v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
buf_init(bufp, buf, buflen);
p = bufp->p;
buf_get_stat(bufp, stat, extended);
buf_get_stat(bufp, stat, dotu);
if (buf_check_overflow(bufp))
return 0;
else
return bufp->p - p;
}
EXPORT_SYMBOL(p9_deserialize_stat);
/**
* deserialize_fcall - unmarshal a response
@ -319,13 +318,13 @@ v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
* @buflen: length of received buffer
* @rcall: fcall structure to populate
* @rcalllen: length of fcall structure to populate
* @extended: non-zero if 9P2000.u
* @dotu: non-zero if 9P2000.u
*
*/
int
v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
int extended)
p9_deserialize_fcall(void *buf, u32 buflen, struct p9_fcall *rcall,
int dotu)
{
struct cbuf buffer;
@ -338,102 +337,104 @@ v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
rcall->id = buf_get_int8(bufp);
rcall->tag = buf_get_int16(bufp);
dprintk(DEBUG_CONV, "size %d id %d tag %d\n", rcall->size, rcall->id,
rcall->tag);
P9_DPRINTK(P9_DEBUG_CONV, "size %d id %d tag %d\n", rcall->size,
rcall->id, rcall->tag);
switch (rcall->id) {
default:
eprintk(KERN_ERR, "unknown message type: %d\n", rcall->id);
P9_EPRINTK(KERN_ERR, "unknown message type: %d\n", rcall->id);
return -EPROTO;
case RVERSION:
case P9_RVERSION:
rcall->params.rversion.msize = buf_get_int32(bufp);
buf_get_str(bufp, &rcall->params.rversion.version);
break;
case RFLUSH:
case P9_RFLUSH:
break;
case RATTACH:
case P9_RATTACH:
rcall->params.rattach.qid.type = buf_get_int8(bufp);
rcall->params.rattach.qid.version = buf_get_int32(bufp);
rcall->params.rattach.qid.path = buf_get_int64(bufp);
break;
case RWALK:
case P9_RWALK:
rcall->params.rwalk.nwqid = buf_get_int16(bufp);
if (rcall->params.rwalk.nwqid > V9FS_MAXWELEM) {
eprintk(KERN_ERR, "Rwalk with more than %d qids: %d\n",
V9FS_MAXWELEM, rcall->params.rwalk.nwqid);
if (rcall->params.rwalk.nwqid > P9_MAXWELEM) {
P9_EPRINTK(KERN_ERR,
"Rwalk with more than %d qids: %d\n",
P9_MAXWELEM, rcall->params.rwalk.nwqid);
return -EPROTO;
}
for (i = 0; i < rcall->params.rwalk.nwqid; i++)
buf_get_qid(bufp, &rcall->params.rwalk.wqids[i]);
break;
case ROPEN:
case P9_ROPEN:
buf_get_qid(bufp, &rcall->params.ropen.qid);
rcall->params.ropen.iounit = buf_get_int32(bufp);
break;
case RCREATE:
case P9_RCREATE:
buf_get_qid(bufp, &rcall->params.rcreate.qid);
rcall->params.rcreate.iounit = buf_get_int32(bufp);
break;
case RREAD:
case P9_RREAD:
rcall->params.rread.count = buf_get_int32(bufp);
rcall->params.rread.data = bufp->p;
buf_check_size(bufp, rcall->params.rread.count);
break;
case RWRITE:
case P9_RWRITE:
rcall->params.rwrite.count = buf_get_int32(bufp);
break;
case RCLUNK:
case P9_RCLUNK:
break;
case RREMOVE:
case P9_RREMOVE:
break;
case RSTAT:
case P9_RSTAT:
buf_get_int16(bufp);
buf_get_stat(bufp, &rcall->params.rstat.stat, extended);
buf_get_stat(bufp, &rcall->params.rstat.stat, dotu);
break;
case RWSTAT:
case P9_RWSTAT:
break;
case RERROR:
case P9_RERROR:
buf_get_str(bufp, &rcall->params.rerror.error);
if (extended)
if (dotu)
rcall->params.rerror.errno = buf_get_int16(bufp);
break;
}
if (buf_check_overflow(bufp)) {
dprintk(DEBUG_ERROR, "buffer overflow\n");
P9_DPRINTK(P9_DEBUG_ERROR, "buffer overflow\n");
return -EIO;
}
return bufp->p - bufp->sp;
}
EXPORT_SYMBOL(p9_deserialize_fcall);
static inline void v9fs_put_int8(struct cbuf *bufp, u8 val, u8 * p)
static inline void p9_put_int8(struct cbuf *bufp, u8 val, u8 * p)
{
*p = val;
buf_put_int8(bufp, val);
}
static inline void v9fs_put_int16(struct cbuf *bufp, u16 val, u16 * p)
static inline void p9_put_int16(struct cbuf *bufp, u16 val, u16 * p)
{
*p = val;
buf_put_int16(bufp, val);
}
static inline void v9fs_put_int32(struct cbuf *bufp, u32 val, u32 * p)
static inline void p9_put_int32(struct cbuf *bufp, u32 val, u32 * p)
{
*p = val;
buf_put_int32(bufp, val);
}
static inline void v9fs_put_int64(struct cbuf *bufp, u64 val, u64 * p)
static inline void p9_put_int64(struct cbuf *bufp, u64 val, u64 * p)
{
*p = val;
buf_put_int64(bufp, val);
}
static void
v9fs_put_str(struct cbuf *bufp, char *data, struct v9fs_str *str)
p9_put_str(struct cbuf *bufp, char *data, struct p9_str *str)
{
int len;
char *s;
@ -451,7 +452,16 @@ v9fs_put_str(struct cbuf *bufp, char *data, struct v9fs_str *str)
}
static int
v9fs_put_user_data(struct cbuf *bufp, const char __user * data, int count,
p9_put_data(struct cbuf *bufp, const char *data, int count,
unsigned char **pdata)
{
*pdata = buf_alloc(bufp, count);
memmove(*pdata, data, count);
return count;
}
static int
p9_put_user_data(struct cbuf *bufp, const char __user *data, int count,
unsigned char **pdata)
{
*pdata = buf_alloc(bufp, count);
@ -459,162 +469,167 @@ v9fs_put_user_data(struct cbuf *bufp, const char __user * data, int count,
}
static void
v9fs_put_wstat(struct cbuf *bufp, struct v9fs_wstat *wstat,
struct v9fs_stat *stat, int statsz, int extended)
p9_put_wstat(struct cbuf *bufp, struct p9_wstat *wstat,
struct p9_stat *stat, int statsz, int dotu)
{
v9fs_put_int16(bufp, statsz, &stat->size);
v9fs_put_int16(bufp, wstat->type, &stat->type);
v9fs_put_int32(bufp, wstat->dev, &stat->dev);
v9fs_put_int8(bufp, wstat->qid.type, &stat->qid.type);
v9fs_put_int32(bufp, wstat->qid.version, &stat->qid.version);
v9fs_put_int64(bufp, wstat->qid.path, &stat->qid.path);
v9fs_put_int32(bufp, wstat->mode, &stat->mode);
v9fs_put_int32(bufp, wstat->atime, &stat->atime);
v9fs_put_int32(bufp, wstat->mtime, &stat->mtime);
v9fs_put_int64(bufp, wstat->length, &stat->length);
p9_put_int16(bufp, statsz, &stat->size);
p9_put_int16(bufp, wstat->type, &stat->type);
p9_put_int32(bufp, wstat->dev, &stat->dev);
p9_put_int8(bufp, wstat->qid.type, &stat->qid.type);
p9_put_int32(bufp, wstat->qid.version, &stat->qid.version);
p9_put_int64(bufp, wstat->qid.path, &stat->qid.path);
p9_put_int32(bufp, wstat->mode, &stat->mode);
p9_put_int32(bufp, wstat->atime, &stat->atime);
p9_put_int32(bufp, wstat->mtime, &stat->mtime);
p9_put_int64(bufp, wstat->length, &stat->length);
v9fs_put_str(bufp, wstat->name, &stat->name);
v9fs_put_str(bufp, wstat->uid, &stat->uid);
v9fs_put_str(bufp, wstat->gid, &stat->gid);
v9fs_put_str(bufp, wstat->muid, &stat->muid);
p9_put_str(bufp, wstat->name, &stat->name);
p9_put_str(bufp, wstat->uid, &stat->uid);
p9_put_str(bufp, wstat->gid, &stat->gid);
p9_put_str(bufp, wstat->muid, &stat->muid);
if (extended) {
v9fs_put_str(bufp, wstat->extension, &stat->extension);
v9fs_put_int32(bufp, wstat->n_uid, &stat->n_uid);
v9fs_put_int32(bufp, wstat->n_gid, &stat->n_gid);
v9fs_put_int32(bufp, wstat->n_muid, &stat->n_muid);
if (dotu) {
p9_put_str(bufp, wstat->extension, &stat->extension);
p9_put_int32(bufp, wstat->n_uid, &stat->n_uid);
p9_put_int32(bufp, wstat->n_gid, &stat->n_gid);
p9_put_int32(bufp, wstat->n_muid, &stat->n_muid);
}
}
static struct v9fs_fcall *
v9fs_create_common(struct cbuf *bufp, u32 size, u8 id)
static struct p9_fcall *
p9_create_common(struct cbuf *bufp, u32 size, u8 id)
{
struct v9fs_fcall *fc;
struct p9_fcall *fc;
size += 4 + 1 + 2; /* size[4] id[1] tag[2] */
fc = kmalloc(sizeof(struct v9fs_fcall) + size, GFP_KERNEL);
fc = kmalloc(sizeof(struct p9_fcall) + size, GFP_KERNEL);
if (!fc)
return ERR_PTR(-ENOMEM);
fc->sdata = (char *)fc + sizeof(*fc);
buf_init(bufp, (char *)fc->sdata, size);
v9fs_put_int32(bufp, size, &fc->size);
v9fs_put_int8(bufp, id, &fc->id);
v9fs_put_int16(bufp, V9FS_NOTAG, &fc->tag);
p9_put_int32(bufp, size, &fc->size);
p9_put_int8(bufp, id, &fc->id);
p9_put_int16(bufp, P9_NOTAG, &fc->tag);
return fc;
}
void v9fs_set_tag(struct v9fs_fcall *fc, u16 tag)
void p9_set_tag(struct p9_fcall *fc, u16 tag)
{
fc->tag = tag;
*(__le16 *) (fc->sdata + 5) = cpu_to_le16(tag);
}
EXPORT_SYMBOL(p9_set_tag);
struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version)
struct p9_fcall *p9_create_tversion(u32 msize, char *version)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 2 + strlen(version); /* msize[4] version[s] */
fc = v9fs_create_common(bufp, size, TVERSION);
fc = p9_create_common(bufp, size, P9_TVERSION);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, msize, &fc->params.tversion.msize);
v9fs_put_str(bufp, version, &fc->params.tversion.version);
p9_put_int32(bufp, msize, &fc->params.tversion.msize);
p9_put_str(bufp, version, &fc->params.tversion.version);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tversion);
#if 0
struct v9fs_fcall *v9fs_create_tauth(u32 afid, char *uname, char *aname)
struct p9_fcall *p9_create_tauth(u32 afid, char *uname, char *aname)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 2 + strlen(uname) + 2 + strlen(aname); /* afid[4] uname[s] aname[s] */
fc = v9fs_create_common(bufp, size, TAUTH);
/* afid[4] uname[s] aname[s] */
size = 4 + 2 + strlen(uname) + 2 + strlen(aname);
fc = p9_create_common(bufp, size, P9_TAUTH);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, afid, &fc->params.tauth.afid);
v9fs_put_str(bufp, uname, &fc->params.tauth.uname);
v9fs_put_str(bufp, aname, &fc->params.tauth.aname);
p9_put_int32(bufp, afid, &fc->params.tauth.afid);
p9_put_str(bufp, uname, &fc->params.tauth.uname);
p9_put_str(bufp, aname, &fc->params.tauth.aname);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
#endif /* 0 */
EXPORT_SYMBOL(p9_create_tauth);
struct v9fs_fcall *
v9fs_create_tattach(u32 fid, u32 afid, char *uname, char *aname)
struct p9_fcall *
p9_create_tattach(u32 fid, u32 afid, char *uname, char *aname)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 4 + 2 + strlen(uname) + 2 + strlen(aname); /* fid[4] afid[4] uname[s] aname[s] */
fc = v9fs_create_common(bufp, size, TATTACH);
/* fid[4] afid[4] uname[s] aname[s] */
size = 4 + 4 + 2 + strlen(uname) + 2 + strlen(aname);
fc = p9_create_common(bufp, size, P9_TATTACH);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tattach.fid);
v9fs_put_int32(bufp, afid, &fc->params.tattach.afid);
v9fs_put_str(bufp, uname, &fc->params.tattach.uname);
v9fs_put_str(bufp, aname, &fc->params.tattach.aname);
p9_put_int32(bufp, fid, &fc->params.tattach.fid);
p9_put_int32(bufp, afid, &fc->params.tattach.afid);
p9_put_str(bufp, uname, &fc->params.tattach.uname);
p9_put_str(bufp, aname, &fc->params.tattach.aname);
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tattach);
struct v9fs_fcall *v9fs_create_tflush(u16 oldtag)
struct p9_fcall *p9_create_tflush(u16 oldtag)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 2; /* oldtag[2] */
fc = v9fs_create_common(bufp, size, TFLUSH);
fc = p9_create_common(bufp, size, P9_TFLUSH);
if (IS_ERR(fc))
goto error;
v9fs_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
p9_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tflush);
struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
struct p9_fcall *p9_create_twalk(u32 fid, u32 newfid, u16 nwname,
char **wnames)
{
int i, size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
if (nwname > V9FS_MAXWELEM) {
dprintk(DEBUG_ERROR, "nwname > %d\n", V9FS_MAXWELEM);
if (nwname > P9_MAXWELEM) {
P9_DPRINTK(P9_DEBUG_ERROR, "nwname > %d\n", P9_MAXWELEM);
return NULL;
}
@ -623,122 +638,128 @@ struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
size += 2 + strlen(wnames[i]); /* wname[s] */
}
fc = v9fs_create_common(bufp, size, TWALK);
fc = p9_create_common(bufp, size, P9_TWALK);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.twalk.fid);
v9fs_put_int32(bufp, newfid, &fc->params.twalk.newfid);
v9fs_put_int16(bufp, nwname, &fc->params.twalk.nwname);
p9_put_int32(bufp, fid, &fc->params.twalk.fid);
p9_put_int32(bufp, newfid, &fc->params.twalk.newfid);
p9_put_int16(bufp, nwname, &fc->params.twalk.nwname);
for (i = 0; i < nwname; i++) {
v9fs_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
p9_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
}
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_twalk);
struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode)
struct p9_fcall *p9_create_topen(u32 fid, u8 mode)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 1; /* fid[4] mode[1] */
fc = v9fs_create_common(bufp, size, TOPEN);
fc = p9_create_common(bufp, size, P9_TOPEN);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.topen.fid);
v9fs_put_int8(bufp, mode, &fc->params.topen.mode);
p9_put_int32(bufp, fid, &fc->params.topen.fid);
p9_put_int8(bufp, mode, &fc->params.topen.mode);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_topen);
struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
char *extension, int extended)
struct p9_fcall *p9_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
char *extension, int dotu)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 2 + strlen(name) + 4 + 1; /* fid[4] name[s] perm[4] mode[1] */
if (extended) {
/* fid[4] name[s] perm[4] mode[1] */
size = 4 + 2 + strlen(name) + 4 + 1;
if (dotu) {
size += 2 + /* extension[s] */
(extension == NULL ? 0 : strlen(extension));
}
fc = v9fs_create_common(bufp, size, TCREATE);
fc = p9_create_common(bufp, size, P9_TCREATE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tcreate.fid);
v9fs_put_str(bufp, name, &fc->params.tcreate.name);
v9fs_put_int32(bufp, perm, &fc->params.tcreate.perm);
v9fs_put_int8(bufp, mode, &fc->params.tcreate.mode);
if (extended)
v9fs_put_str(bufp, extension, &fc->params.tcreate.extension);
p9_put_int32(bufp, fid, &fc->params.tcreate.fid);
p9_put_str(bufp, name, &fc->params.tcreate.name);
p9_put_int32(bufp, perm, &fc->params.tcreate.perm);
p9_put_int8(bufp, mode, &fc->params.tcreate.mode);
if (dotu)
p9_put_str(bufp, extension, &fc->params.tcreate.extension);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tcreate);
struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count)
struct p9_fcall *p9_create_tread(u32 fid, u64 offset, u32 count)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 8 + 4; /* fid[4] offset[8] count[4] */
fc = v9fs_create_common(bufp, size, TREAD);
fc = p9_create_common(bufp, size, P9_TREAD);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tread.fid);
v9fs_put_int64(bufp, offset, &fc->params.tread.offset);
v9fs_put_int32(bufp, count, &fc->params.tread.count);
p9_put_int32(bufp, fid, &fc->params.tread.fid);
p9_put_int64(bufp, offset, &fc->params.tread.offset);
p9_put_int32(bufp, count, &fc->params.tread.count);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tread);
struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
const char __user * data)
struct p9_fcall *p9_create_twrite(u32 fid, u64 offset, u32 count,
const char *data)
{
int size, err;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4 + 8 + 4 + count; /* fid[4] offset[8] count[4] data[count] */
fc = v9fs_create_common(bufp, size, TWRITE);
/* fid[4] offset[8] count[4] data[count] */
size = 4 + 8 + 4 + count;
fc = p9_create_common(bufp, size, P9_TWRITE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.twrite.fid);
v9fs_put_int64(bufp, offset, &fc->params.twrite.offset);
v9fs_put_int32(bufp, count, &fc->params.twrite.count);
err = v9fs_put_user_data(bufp, data, count, &fc->params.twrite.data);
p9_put_int32(bufp, fid, &fc->params.twrite.fid);
p9_put_int64(bufp, offset, &fc->params.twrite.offset);
p9_put_int32(bufp, count, &fc->params.twrite.count);
err = p9_put_data(bufp, data, count, &fc->params.twrite.data);
if (err) {
kfree(fc);
fc = ERR_PTR(err);
@ -748,98 +769,135 @@ struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_twrite);
struct v9fs_fcall *v9fs_create_tclunk(u32 fid)
struct p9_fcall *p9_create_twrite_u(u32 fid, u64 offset, u32 count,
const char __user *data)
{
int size;
struct v9fs_fcall *fc;
int size, err;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = v9fs_create_common(bufp, size, TCLUNK);
/* fid[4] offset[8] count[4] data[count] */
size = 4 + 8 + 4 + count;
fc = p9_create_common(bufp, size, P9_TWRITE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tclunk.fid);
p9_put_int32(bufp, fid, &fc->params.twrite.fid);
p9_put_int64(bufp, offset, &fc->params.twrite.offset);
p9_put_int32(bufp, count, &fc->params.twrite.count);
err = p9_put_user_data(bufp, data, count, &fc->params.twrite.data);
if (err) {
kfree(fc);
fc = ERR_PTR(err);
}
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_twrite_u);
struct v9fs_fcall *v9fs_create_tremove(u32 fid)
struct p9_fcall *p9_create_tclunk(u32 fid)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = v9fs_create_common(bufp, size, TREMOVE);
fc = p9_create_common(bufp, size, P9_TCLUNK);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tremove.fid);
p9_put_int32(bufp, fid, &fc->params.tclunk.fid);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tclunk);
struct v9fs_fcall *v9fs_create_tstat(u32 fid)
struct p9_fcall *p9_create_tremove(u32 fid)
{
int size;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = v9fs_create_common(bufp, size, TSTAT);
fc = p9_create_common(bufp, size, P9_TREMOVE);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.tstat.fid);
p9_put_int32(bufp, fid, &fc->params.tremove.fid);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tremove);
struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
int extended)
struct p9_fcall *p9_create_tstat(u32 fid)
{
int size;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
size = 4; /* fid[4] */
fc = p9_create_common(bufp, size, P9_TSTAT);
if (IS_ERR(fc))
goto error;
p9_put_int32(bufp, fid, &fc->params.tstat.fid);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
return fc;
}
EXPORT_SYMBOL(p9_create_tstat);
struct p9_fcall *p9_create_twstat(u32 fid, struct p9_wstat *wstat,
int dotu)
{
int size, statsz;
struct v9fs_fcall *fc;
struct p9_fcall *fc;
struct cbuf buffer;
struct cbuf *bufp = &buffer;
statsz = v9fs_size_wstat(wstat, extended);
statsz = p9_size_wstat(wstat, dotu);
size = 4 + 2 + 2 + statsz; /* fid[4] stat[n] */
fc = v9fs_create_common(bufp, size, TWSTAT);
fc = p9_create_common(bufp, size, P9_TWSTAT);
if (IS_ERR(fc))
goto error;
v9fs_put_int32(bufp, fid, &fc->params.twstat.fid);
p9_put_int32(bufp, fid, &fc->params.twstat.fid);
buf_put_int16(bufp, statsz + 2);
v9fs_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, extended);
p9_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, dotu);
if (buf_check_overflow(bufp)) {
kfree(fc);
fc = ERR_PTR(-ENOMEM);
}
error:
error:
return fc;
}
EXPORT_SYMBOL(p9_create_twstat);

79
fs/9p/error.h → net/9p/error.c
View File

@ -1,12 +1,11 @@
/*
* linux/fs/9p/error.h
* linux/fs/9p/error.c
*
* Huge Nasty Error Table
* Error string handling
*
* Plan 9 uses error strings, Unix uses error numbers. This table tries to
* match UNIX strings and Plan 9 strings to unix error numbers. It is used
* to preload the dynamic error table which can also track user-specific error
* strings.
* Plan 9 uses error strings, Unix uses error numbers. These functions
* try to help manage that and provide for dynamically adding error
* mappings.
*
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
@ -28,8 +27,11 @@
*
*/
#include <linux/module.h>
#include <linux/list.h>
#include <linux/jhash.h>
#include <linux/errno.h>
#include <asm/errno.h>
#include <net/9p/9p.h>
struct errormap {
char *name;
@ -174,4 +176,65 @@ static struct errormap errmap[] = {
{NULL, -1}
};
extern int v9fs_error_init(void);
/**
* p9_error_init - preload
* @errstr: error string
*
*/
int p9_error_init(void)
{
struct errormap *c;
int bucket;
/* initialize hash table */
for (bucket = 0; bucket < ERRHASHSZ; bucket++)
INIT_HLIST_HEAD(&hash_errmap[bucket]);
/* load initial error map into hash table */
for (c = errmap; c->name != NULL; c++) {
c->namelen = strlen(c->name);
bucket = jhash(c->name, c->namelen, 0) % ERRHASHSZ;
INIT_HLIST_NODE(&c->list);
hlist_add_head(&c->list, &hash_errmap[bucket]);
}
return 1;
}
EXPORT_SYMBOL(p9_error_init);
/**
* errstr2errno - convert error string to error number
* @errstr: error string
*
*/
int p9_errstr2errno(char *errstr, int len)
{
int errno;
struct hlist_node *p;
struct errormap *c;
int bucket;
errno = 0;
p = NULL;
c = NULL;
bucket = jhash(errstr, len, 0) % ERRHASHSZ;
hlist_for_each_entry(c, p, &hash_errmap[bucket], list) {
if (c->namelen == len && !memcmp(c->name, errstr, len)) {
errno = c->val;
break;
}
}
if (errno == 0) {
/* TODO: if error isn't found, add it dynamically */
errstr[len] = 0;
printk(KERN_ERR "%s: errstr :%s: not found\n", __FUNCTION__,
errstr);
errno = 1;
}
return -errno;
}
EXPORT_SYMBOL(p9_errstr2errno);

187
fs/9p/fcprint.c → net/9p/fcprint.c
View File

@ -1,5 +1,5 @@
/*
* linux/fs/9p/fcprint.c
* net/9p/fcprint.c
*
* Print 9P call.
*
@ -25,61 +25,59 @@
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <net/9p/9p.h>
#include "debug.h"
#include "v9fs.h"
#include "9p.h"
#include "mux.h"
#ifdef CONFIG_NET_9P_DEBUG
static int
v9fs_printqid(char *buf, int buflen, struct v9fs_qid *q)
p9_printqid(char *buf, int buflen, struct p9_qid *q)
{
int n;
char b[10];
n = 0;
if (q->type & V9FS_QTDIR)
if (q->type & P9_QTDIR)
b[n++] = 'd';
if (q->type & V9FS_QTAPPEND)
if (q->type & P9_QTAPPEND)
b[n++] = 'a';
if (q->type & V9FS_QTAUTH)
if (q->type & P9_QTAUTH)
b[n++] = 'A';
if (q->type & V9FS_QTEXCL)
if (q->type & P9_QTEXCL)
b[n++] = 'l';
if (q->type & V9FS_QTTMP)
if (q->type & P9_QTTMP)
b[n++] = 't';
if (q->type & V9FS_QTSYMLINK)
if (q->type & P9_QTSYMLINK)
b[n++] = 'L';
b[n] = '\0';
return scnprintf(buf, buflen, "(%.16llx %x %s)", (long long int) q->path,
q->version, b);
return scnprintf(buf, buflen, "(%.16llx %x %s)",
(long long int) q->path, q->version, b);
}
static int
v9fs_printperm(char *buf, int buflen, int perm)
p9_printperm(char *buf, int buflen, int perm)
{
int n;
char b[15];
n = 0;
if (perm & V9FS_DMDIR)
if (perm & P9_DMDIR)
b[n++] = 'd';
if (perm & V9FS_DMAPPEND)
if (perm & P9_DMAPPEND)
b[n++] = 'a';
if (perm & V9FS_DMAUTH)
if (perm & P9_DMAUTH)
b[n++] = 'A';
if (perm & V9FS_DMEXCL)
if (perm & P9_DMEXCL)
b[n++] = 'l';
if (perm & V9FS_DMTMP)
if (perm & P9_DMTMP)
b[n++] = 't';
if (perm & V9FS_DMDEVICE)
if (perm & P9_DMDEVICE)
b[n++] = 'D';
if (perm & V9FS_DMSOCKET)
if (perm & P9_DMSOCKET)
b[n++] = 'S';
if (perm & V9FS_DMNAMEDPIPE)
if (perm & P9_DMNAMEDPIPE)
b[n++] = 'P';
if (perm & V9FS_DMSYMLINK)
if (perm & P9_DMSYMLINK)
b[n++] = 'L';
b[n] = '\0';
@ -87,7 +85,7 @@ v9fs_printperm(char *buf, int buflen, int perm)
}
static int
v9fs_printstat(char *buf, int buflen, struct v9fs_stat *st, int extended)
p9_printstat(char *buf, int buflen, struct p9_stat *st, int extended)
{
int n;
@ -105,9 +103,9 @@ v9fs_printstat(char *buf, int buflen, struct v9fs_stat *st, int extended)
n += scnprintf(buf+n, buflen-n, "(%d)", st->n_muid);
n += scnprintf(buf+n, buflen-n, " q ");
n += v9fs_printqid(buf+n, buflen-n, &st->qid);
n += p9_printqid(buf+n, buflen-n, &st->qid);
n += scnprintf(buf+n, buflen-n, " m ");
n += v9fs_printperm(buf+n, buflen-n, st->mode);
n += p9_printperm(buf+n, buflen-n, st->mode);
n += scnprintf(buf+n, buflen-n, " at %d mt %d l %lld",
st->atime, st->mtime, (long long int) st->length);
@ -119,7 +117,7 @@ v9fs_printstat(char *buf, int buflen, struct v9fs_stat *st, int extended)
}
static int
v9fs_dumpdata(char *buf, int buflen, u8 *data, int datalen)
p9_dumpdata(char *buf, int buflen, u8 *data, int datalen)
{
int i, n;
@ -139,13 +137,13 @@ v9fs_dumpdata(char *buf, int buflen, u8 *data, int datalen)
}
static int
v9fs_printdata(char *buf, int buflen, u8 *data, int datalen)
p9_printdata(char *buf, int buflen, u8 *data, int datalen)
{
return v9fs_dumpdata(buf, buflen, data, datalen<16?datalen:16);
return p9_dumpdata(buf, buflen, data, datalen < 16?datalen:16);
}
int
v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended)
{
int i, ret, type, tag;
@ -157,21 +155,23 @@ v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
ret = 0;
switch (type) {
case TVERSION:
case P9_TVERSION:
ret += scnprintf(buf+ret, buflen-ret,
"Tversion tag %u msize %u version '%.*s'", tag,
fc->params.tversion.msize, fc->params.tversion.version.len,
fc->params.tversion.version.str);
"Tversion tag %u msize %u version '%.*s'", tag,
fc->params.tversion.msize,
fc->params.tversion.version.len,
fc->params.tversion.version.str);
break;
case RVERSION:
case P9_RVERSION:
ret += scnprintf(buf+ret, buflen-ret,
"Rversion tag %u msize %u version '%.*s'", tag,
fc->params.rversion.msize, fc->params.rversion.version.len,
fc->params.rversion.version.str);
"Rversion tag %u msize %u version '%.*s'", tag,
fc->params.rversion.msize,
fc->params.rversion.version.len,
fc->params.rversion.version.str);
break;
case TAUTH:
case P9_TAUTH:
ret += scnprintf(buf+ret, buflen-ret,
"Tauth tag %u afid %d uname '%.*s' aname '%.*s'", tag,
fc->params.tauth.afid, fc->params.tauth.uname.len,
@ -179,93 +179,97 @@ v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
fc->params.tauth.aname.str);
break;
case RAUTH:
case P9_RAUTH:
ret += scnprintf(buf+ret, buflen-ret, "Rauth tag %u qid ", tag);
v9fs_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid);
p9_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid);
break;
case TATTACH:
case P9_TATTACH:
ret += scnprintf(buf+ret, buflen-ret,
"Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'",
tag, fc->params.tattach.fid, fc->params.tattach.afid,
fc->params.tattach.uname.len, fc->params.tattach.uname.str,
fc->params.tattach.aname.len, fc->params.tattach.aname.str);
"Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'", tag,
fc->params.tattach.fid, fc->params.tattach.afid,
fc->params.tattach.uname.len, fc->params.tattach.uname.str,
fc->params.tattach.aname.len, fc->params.tattach.aname.str);
break;
case RATTACH:
ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ", tag);
v9fs_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid);
case P9_RATTACH:
ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ",
tag);
p9_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid);
break;
case RERROR:
ret += scnprintf(buf+ret, buflen-ret, "Rerror tag %u ename '%.*s'",
tag, fc->params.rerror.error.len,
fc->params.rerror.error.str);
case P9_RERROR:
ret += scnprintf(buf+ret, buflen-ret,
"Rerror tag %u ename '%.*s'", tag,
fc->params.rerror.error.len,
fc->params.rerror.error.str);
if (extended)
ret += scnprintf(buf+ret, buflen-ret, " ecode %d\n",
fc->params.rerror.errno);
break;
case TFLUSH:
case P9_TFLUSH:
ret += scnprintf(buf+ret, buflen-ret, "Tflush tag %u oldtag %u",
tag, fc->params.tflush.oldtag);
break;
case RFLUSH:
case P9_RFLUSH:
ret += scnprintf(buf+ret, buflen-ret, "Rflush tag %u", tag);
break;
case TWALK:
case P9_TWALK:
ret += scnprintf(buf+ret, buflen-ret,
"Twalk tag %u fid %d newfid %d nwname %d", tag,
fc->params.twalk.fid, fc->params.twalk.newfid,
fc->params.twalk.nwname);
for(i = 0; i < fc->params.twalk.nwname; i++)
ret += scnprintf(buf+ret, buflen-ret," '%.*s'",
for (i = 0; i < fc->params.twalk.nwname; i++)
ret += scnprintf(buf+ret, buflen-ret, " '%.*s'",
fc->params.twalk.wnames[i].len,
fc->params.twalk.wnames[i].str);
break;
case RWALK:
case P9_RWALK:
ret += scnprintf(buf+ret, buflen-ret, "Rwalk tag %u nwqid %d",
tag, fc->params.rwalk.nwqid);
for(i = 0; i < fc->params.rwalk.nwqid; i++)
ret += v9fs_printqid(buf+ret, buflen-ret,
for (i = 0; i < fc->params.rwalk.nwqid; i++)
ret += p9_printqid(buf+ret, buflen-ret,
&fc->params.rwalk.wqids[i]);
break;
case TOPEN:
case P9_TOPEN:
ret += scnprintf(buf+ret, buflen-ret,
"Topen tag %u fid %d mode %d", tag,
fc->params.topen.fid, fc->params.topen.mode);
break;
case ROPEN:
case P9_ROPEN:
ret += scnprintf(buf+ret, buflen-ret, "Ropen tag %u", tag);
ret += v9fs_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid);
ret += scnprintf(buf+ret, buflen-ret," iounit %d",
ret += p9_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid);
ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
fc->params.ropen.iounit);
break;
case TCREATE:
case P9_TCREATE:
ret += scnprintf(buf+ret, buflen-ret,
"Tcreate tag %u fid %d name '%.*s' perm ", tag,
fc->params.tcreate.fid, fc->params.tcreate.name.len,
fc->params.tcreate.name.str);
ret += v9fs_printperm(buf+ret, buflen-ret, fc->params.tcreate.perm);
ret += p9_printperm(buf+ret, buflen-ret,
fc->params.tcreate.perm);
ret += scnprintf(buf+ret, buflen-ret, " mode %d",
fc->params.tcreate.mode);
break;
case RCREATE:
case P9_RCREATE:
ret += scnprintf(buf+ret, buflen-ret, "Rcreate tag %u", tag);
ret += v9fs_printqid(buf+ret, buflen-ret, &fc->params.rcreate.qid);
ret += p9_printqid(buf+ret, buflen-ret,
&fc->params.rcreate.qid);
ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
fc->params.rcreate.iounit);
break;
case TREAD:
case P9_TREAD:
ret += scnprintf(buf+ret, buflen-ret,
"Tread tag %u fid %d offset %lld count %u", tag,
fc->params.tread.fid,
@ -273,66 +277,66 @@ v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
fc->params.tread.count);
break;
case RREAD:
case P9_RREAD:
ret += scnprintf(buf+ret, buflen-ret,
"Rread tag %u count %u data ", tag,
fc->params.rread.count);
ret += v9fs_printdata(buf+ret, buflen-ret, fc->params.rread.data,
ret += p9_printdata(buf+ret, buflen-ret, fc->params.rread.data,
fc->params.rread.count);
break;
case TWRITE:
case P9_TWRITE:
ret += scnprintf(buf+ret, buflen-ret,
"Twrite tag %u fid %d offset %lld count %u data ",
tag, fc->params.twrite.fid,
(long long int) fc->params.twrite.offset,
fc->params.twrite.count);
ret += v9fs_printdata(buf+ret, buflen-ret, fc->params.twrite.data,
ret += p9_printdata(buf+ret, buflen-ret, fc->params.twrite.data,
fc->params.twrite.count);
break;
case RWRITE:
case P9_RWRITE:
ret += scnprintf(buf+ret, buflen-ret, "Rwrite tag %u count %u",
tag, fc->params.rwrite.count);
break;
case TCLUNK:
case P9_TCLUNK:
ret += scnprintf(buf+ret, buflen-ret, "Tclunk tag %u fid %d",
tag, fc->params.tclunk.fid);
break;
case RCLUNK:
case P9_RCLUNK:
ret += scnprintf(buf+ret, buflen-ret, "Rclunk tag %u", tag);
break;
case TREMOVE:
case P9_TREMOVE:
ret += scnprintf(buf+ret, buflen-ret, "Tremove tag %u fid %d",
tag, fc->params.tremove.fid);
break;
case RREMOVE:
case P9_RREMOVE:
ret += scnprintf(buf+ret, buflen-ret, "Rremove tag %u", tag);
break;
case TSTAT:
case P9_TSTAT:
ret += scnprintf(buf+ret, buflen-ret, "Tstat tag %u fid %d",
tag, fc->params.tstat.fid);
break;
case RSTAT:
case P9_RSTAT:
ret += scnprintf(buf+ret, buflen-ret, "Rstat tag %u ", tag);
ret += v9fs_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat,
ret += p9_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat,
extended);
break;
case TWSTAT:
case P9_TWSTAT:
ret += scnprintf(buf+ret, buflen-ret, "Twstat tag %u fid %d ",
tag, fc->params.twstat.fid);
ret += v9fs_printstat(buf+ret, buflen-ret, &fc->params.twstat.stat,
extended);
ret += p9_printstat(buf+ret, buflen-ret,
&fc->params.twstat.stat, extended);
break;
case RWSTAT:
case P9_RWSTAT:
ret += scnprintf(buf+ret, buflen-ret, "Rwstat tag %u", tag);
break;
@ -343,3 +347,12 @@ v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
return ret;
}
#else
int
p9_printfcall(char *buf, int buflen, struct p9_fcall *fc, int extended)
{
return 0;
}
EXPORT_SYMBOL(p9_printfcall);
#endif /* CONFIG_NET_9P_DEBUG */

85
net/9p/mod.c Normal file
View File

@ -0,0 +1,85 @@
/*
* net/9p/9p.c
*
* 9P entry point
*
* Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <net/9p/9p.h>
#ifdef CONFIG_NET_9P_DEBUG
unsigned int p9_debug_level = 0; /* feature-rific global debug level */
EXPORT_SYMBOL(p9_debug_level);
module_param_named(debug, p9_debug_level, uint, 0);
MODULE_PARM_DESC(debug, "9P debugging level");
#endif
extern int p9_mux_global_init(void);
extern void p9_mux_global_exit(void);
extern int p9_sysctl_register(void);
extern void p9_sysctl_unregister(void);
/**
* v9fs_init - Initialize module
*
*/
static int __init init_p9(void)
{
int ret;
p9_error_init();
printk(KERN_INFO "Installing 9P2000 support\n");
ret = p9_mux_global_init();
if (ret) {
printk(KERN_WARNING "9p: starting mux failed\n");
return ret;
}
ret = p9_sysctl_register();
if (ret) {
printk(KERN_WARNING "9p: registering sysctl failed\n");
return ret;
}
return ret;
}
/**
* v9fs_init - shutdown module
*
*/
static void __exit exit_p9(void)
{
p9_sysctl_unregister();
p9_mux_global_exit();
}
module_init(init_p9)
module_exit(exit_p9)
MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
MODULE_LICENSE("GPL");

509
fs/9p/mux.c → net/9p/mux.c
View File

File diff suppressed because it is too large Load Diff

86
net/9p/sysctl.c Normal file
View File

@ -0,0 +1,86 @@
/*
* net/9p/sysctl.c
*
* 9P sysctl interface
*
* 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
*
*/
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/sysctl.h>
#include <linux/init.h>
#include <net/9p/9p.h>
enum {
P9_SYSCTL_NET = 487,
P9_SYSCTL_DEBUG = 1,
};
static ctl_table p9_table[] = {
#ifdef CONFIG_NET_9P_DEBUG
{
.ctl_name = P9_SYSCTL_DEBUG,
.procname = "debug",
.data = &p9_debug_level,
.maxlen = sizeof(int),
.mode = 0644,
.proc_handler = &proc_dointvec
},
#endif
{ .ctl_name = 0 },
};
static ctl_table p9_net_table[] = {
{
.ctl_name = P9_SYSCTL_NET,
.procname = "9p",
.maxlen = 0,
.mode = 0555,
.child = p9_table,
},
{ .ctl_name = 0 },
};
static ctl_table p9_ctl_table[] = {
{
.ctl_name = CTL_NET,
.procname = "net",
.maxlen = 0,
.mode = 0555,
.child = p9_net_table,
},
{ .ctl_name = 0 },
};
static struct ctl_table_header *p9_table_header;
int __init p9_sysctl_register(void)
{
p9_table_header = register_sysctl_table(p9_ctl_table);
if (!p9_table_header)
return -ENOMEM;
return 0;
}
void __exit p9_sysctl_unregister(void)
{
unregister_sysctl_table(p9_table_header);
}

363
net/9p/trans_fd.c Normal file
View File

@ -0,0 +1,363 @@
/*
* linux/fs/9p/trans_fd.c
*
* Fd transport layer. Includes deprecated socket layer.
*
* Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
* Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004-2005 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
*
* 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
*
*/
#include <linux/in.h>
#include <linux/module.h>
#include <linux/net.h>
#include <linux/ipv6.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/un.h>
#include <linux/uaccess.h>
#include <linux/inet.h>
#include <linux/idr.h>
#include <linux/file.h>
#include <net/9p/9p.h>
#include <net/9p/transport.h>
#define P9_PORT 564
struct p9_trans_fd {
struct file *rd;
struct file *wr;
};
static int p9_socket_open(struct p9_transport *trans, struct socket *csocket);
static int p9_fd_open(struct p9_transport *trans, int rfd, int wfd);
static int p9_fd_read(struct p9_transport *trans, void *v, int len);
static int p9_fd_write(struct p9_transport *trans, void *v, int len);
static unsigned int p9_fd_poll(struct p9_transport *trans,
struct poll_table_struct *pt);
static void p9_fd_close(struct p9_transport *trans);
struct p9_transport *p9_trans_create_tcp(const char *addr, int port)
{
int err;
struct p9_transport *trans;
struct socket *csocket;
struct sockaddr_in sin_server;
csocket = NULL;
trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
if (!trans)
return ERR_PTR(-ENOMEM);
trans->write = p9_fd_write;
trans->read = p9_fd_read;
trans->close = p9_fd_close;
trans->poll = p9_fd_poll;
sin_server.sin_family = AF_INET;
sin_server.sin_addr.s_addr = in_aton(addr);
sin_server.sin_port = htons(port);
sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
if (!csocket) {
P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
err = -EIO;
goto error;
}
err = csocket->ops->connect(csocket,
(struct sockaddr *)&sin_server,
sizeof(struct sockaddr_in), 0);
if (err < 0) {
P9_EPRINTK(KERN_ERR,
"p9_trans_tcp: problem connecting socket to %s\n",
addr);
goto error;
}
err = p9_socket_open(trans, csocket);
if (err < 0)
goto error;
return trans;
error:
if (csocket)
sock_release(csocket);
kfree(trans);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_trans_create_tcp);
struct p9_transport *p9_trans_create_unix(const char *addr)
{
int err;
struct socket *csocket;
struct sockaddr_un sun_server;
struct p9_transport *trans;
csocket = NULL;
trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
if (!trans)
return ERR_PTR(-ENOMEM);
trans->write = p9_fd_write;
trans->read = p9_fd_read;
trans->close = p9_fd_close;
trans->poll = p9_fd_poll;
if (strlen(addr) > UNIX_PATH_MAX) {
P9_EPRINTK(KERN_ERR, "p9_trans_unix: address too long: %s\n",
addr);
err = -ENAMETOOLONG;
goto error;
}
sun_server.sun_family = PF_UNIX;
strcpy(sun_server.sun_path, addr);
sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
err = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
sizeof(struct sockaddr_un) - 1, 0);
if (err < 0) {
P9_EPRINTK(KERN_ERR,
"p9_trans_unix: problem connecting socket: %s: %d\n",
addr, err);
goto error;
}
err = p9_socket_open(trans, csocket);
if (err < 0)
goto error;
return trans;
error:
if (csocket)
sock_release(csocket);
kfree(trans);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_trans_create_unix);
struct p9_transport *p9_trans_create_fd(int rfd, int wfd)
{
int err;
struct p9_transport *trans;
if (rfd == ~0 || wfd == ~0) {
printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
return ERR_PTR(-ENOPROTOOPT);
}
trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
if (!trans)
return ERR_PTR(-ENOMEM);
trans->write = p9_fd_write;
trans->read = p9_fd_read;
trans->close = p9_fd_close;
trans->poll = p9_fd_poll;
err = p9_fd_open(trans, rfd, wfd);
if (err < 0)
goto error;
return trans;
error:
kfree(trans);
return ERR_PTR(err);
}
EXPORT_SYMBOL(p9_trans_create_fd);
static int p9_socket_open(struct p9_transport *trans, struct socket *csocket)
{
int fd, ret;
csocket->sk->sk_allocation = GFP_NOIO;
fd = sock_map_fd(csocket);
if (fd < 0) {
P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
return fd;
}
ret = p9_fd_open(trans, fd, fd);
if (ret < 0) {
P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to open fd\n");
sockfd_put(csocket);
return ret;
}
((struct p9_trans_fd *)trans->priv)->rd->f_flags |= O_NONBLOCK;
return 0;
}
static int p9_fd_open(struct p9_transport *trans, int rfd, int wfd)
{
struct p9_trans_fd *ts = kmalloc(sizeof(struct p9_trans_fd),
GFP_KERNEL);
if (!ts)
return -ENOMEM;
ts->rd = fget(rfd);
ts->wr = fget(wfd);
if (!ts->rd || !ts->wr) {
if (ts->rd)
fput(ts->rd);
if (ts->wr)
fput(ts->wr);
kfree(ts);
return -EIO;
}
trans->priv = ts;
trans->status = Connected;
return 0;
}
/**
* p9_fd_read- read from a fd
* @v9ses: session information
* @v: buffer to receive data into
* @len: size of receive buffer
*
*/
static int p9_fd_read(struct p9_transport *trans, void *v, int len)
{
int ret;
struct p9_trans_fd *ts = NULL;
if (trans && trans->status != Disconnected)
ts = trans->priv;
if (!ts)
return -EREMOTEIO;
if (!(ts->rd->f_flags & O_NONBLOCK))
P9_DPRINTK(P9_DEBUG_ERROR, "blocking read ...\n");
ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
trans->status = Disconnected;
return ret;
}
/**
* p9_fd_write - write to a socket
* @v9ses: session information
* @v: buffer to send data from
* @len: size of send buffer
*
*/
static int p9_fd_write(struct p9_transport *trans, void *v, int len)
{
int ret;
mm_segment_t oldfs;
struct p9_trans_fd *ts = NULL;
if (trans && trans->status != Disconnected)
ts = trans->priv;
if (!ts)
return -EREMOTEIO;
if (!(ts->wr->f_flags & O_NONBLOCK))
P9_DPRINTK(P9_DEBUG_ERROR, "blocking write ...\n");
oldfs = get_fs();
set_fs(get_ds());
/* The cast to a user pointer is valid due to the set_fs() */
ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
set_fs(oldfs);
if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
trans->status = Disconnected;
return ret;
}
static unsigned int
p9_fd_poll(struct p9_transport *trans, struct poll_table_struct *pt)
{
int ret, n;
struct p9_trans_fd *ts = NULL;
mm_segment_t oldfs;
if (trans && trans->status == Connected)
ts = trans->priv;
if (!ts)
return -EREMOTEIO;
if (!ts->rd->f_op || !ts->rd->f_op->poll)
return -EIO;
if (!ts->wr->f_op || !ts->wr->f_op->poll)
return -EIO;
oldfs = get_fs();
set_fs(get_ds());
ret = ts->rd->f_op->poll(ts->rd, pt);
if (ret < 0)
goto end;
if (ts->rd != ts->wr) {
n = ts->wr->f_op->poll(ts->wr, pt);
if (n < 0) {
ret = n;
goto end;
}
ret = (ret & ~POLLOUT) | (n & ~POLLIN);
}
end:
set_fs(oldfs);
return ret;
}
/**
* p9_sock_close - shutdown socket
* @trans: private socket structure
*
*/
static void p9_fd_close(struct p9_transport *trans)
{
struct p9_trans_fd *ts;
if (!trans)
return;
ts = xchg(&trans->priv, NULL);
if (!ts)
return;
trans->status = Disconnected;
if (ts->rd)
fput(ts->rd);
if (ts->wr)
fput(ts->wr);
kfree(ts);
}

125
net/9p/util.c Normal file
View File

@ -0,0 +1,125 @@
/*
* net/9p/util.c
*
* This file contains some helper functions
*
* Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
*
* 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
*
*/
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/parser.h>
#include <linux/idr.h>
#include <net/9p/9p.h>
struct p9_idpool {
struct semaphore lock;
struct idr pool;
};
struct p9_idpool *p9_idpool_create(void)
{
struct p9_idpool *p;
p = kmalloc(sizeof(struct p9_idpool), GFP_KERNEL);
if (!p)
return ERR_PTR(-ENOMEM);
init_MUTEX(&p->lock);
idr_init(&p->pool);
return p;
}
EXPORT_SYMBOL(p9_idpool_create);
void p9_idpool_destroy(struct p9_idpool *p)
{
idr_destroy(&p->pool);
kfree(p);
}
EXPORT_SYMBOL(p9_idpool_destroy);
/**
* p9_idpool_get - allocate numeric id from pool
* @p - pool to allocate from
*
* XXX - This seems to be an awful generic function, should it be in idr.c with
* the lock included in struct idr?
*/
int p9_idpool_get(struct p9_idpool *p)
{
int i = 0;
int error;
retry:
if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
return 0;
if (down_interruptible(&p->lock) == -EINTR) {
P9_EPRINTK(KERN_WARNING, "Interrupted while locking\n");
return -1;
}
/* no need to store exactly p, we just need something non-null */
error = idr_get_new(&p->pool, p, &i);
up(&p->lock);
if (error == -EAGAIN)
goto retry;
else if (error)
return -1;
return i;
}
EXPORT_SYMBOL(p9_idpool_get);
/**
* p9_idpool_put - release numeric id from pool
* @p - pool to allocate from
*
* XXX - This seems to be an awful generic function, should it be in idr.c with
* the lock included in struct idr?
*/
void p9_idpool_put(int id, struct p9_idpool *p)
{
if (down_interruptible(&p->lock) == -EINTR) {
P9_EPRINTK(KERN_WARNING, "Interrupted while locking\n");
return;
}
idr_remove(&p->pool, id);
up(&p->lock);
}
EXPORT_SYMBOL(p9_idpool_put);
/**
* p9_idpool_check - check if the specified id is available
* @id - id to check
* @p - pool
*/
int p9_idpool_check(int id, struct p9_idpool *p)
{
return idr_find(&p->pool, id) != NULL;
}
EXPORT_SYMBOL(p9_idpool_check);

1
net/Kconfig
View File

@ -227,6 +227,7 @@ source "net/ieee80211/Kconfig"
endmenu
source "net/rfkill/Kconfig"
source "net/9p/Kconfig"
endif # if NET
endmenu # Networking

1
net/Makefile
View File

@ -51,6 +51,7 @@ obj-$(CONFIG_TIPC) += tipc/
obj-$(CONFIG_NETLABEL) += netlabel/
obj-$(CONFIG_IUCV) += iucv/
obj-$(CONFIG_RFKILL) += rfkill/
obj-$(CONFIG_NET_9P) += 9p/
ifeq ($(CONFIG_NET),y)
obj-$(CONFIG_SYSCTL) += sysctl_net.o