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:
parent
8d9107e8c5
commit
bd238fb431
36 changed files with 3422 additions and 3130 deletions
375
fs/9p/9p.h
375
fs/9p/9p.h
|
@ -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);
|
|
@ -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
50
fs/9p/conv.h
|
@ -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);
|
|
@ -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 */
|
|
@ -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
427
fs/9p/fcall.c
|
@ -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;
|
||||
}
|
||||
|
166
fs/9p/fid.c
166
fs/9p/fid.c
|
@ -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,27 +76,39 @@ 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);
|
||||
|
||||
if (!return_fid) {
|
||||
dprintk(DEBUG_ERROR, "Couldn't find a fid in dentry\n");
|
||||
return_fid = ERR_PTR(-EBADF);
|
||||
P9_DPRINTK(P9_DEBUG_VFS, " fid: %p\n", fid);
|
||||
return fid;
|
||||
}
|
||||
|
||||
if(down_interruptible(&return_fid->lock))
|
||||
return ERR_PTR(-EINTR);
|
||||
struct p9_fid *v9fs_fid_lookup_remove(struct dentry *dentry)
|
||||
{
|
||||
struct p9_fid *fid;
|
||||
struct v9fs_dentry *dent;
|
||||
|
||||
return return_fid;
|
||||
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);
|
||||
}
|
||||
|
||||
return fid;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* v9fs_fid_clone - lookup the fid for a dentry, clone a private copy and
|
||||
* release it
|
||||
|
@ -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
43
fs/9p/fid.h
|
@ -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
308
fs/9p/trans_fd.c
|
@ -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
288
fs/9p/v9fs.c
|
@ -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
32
fs/9p/v9fs.h
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
147
fs/9p/vfs_dir.c
147
fs/9p/vfs_dir.c
|
@ -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,105 +68,35 @@ 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;
|
||||
filp->f_pos += st->size;
|
||||
kfree(st);
|
||||
st = NULL;
|
||||
}
|
||||
|
||||
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;
|
||||
kfree(st);
|
||||
return 0;
|
||||
}
|
||||
|
||||
i += s;
|
||||
filp->f_pos += s;
|
||||
}
|
||||
|
||||
kfree(fcall);
|
||||
}
|
||||
|
||||
FreeStructs:
|
||||
kfree(fcall);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* v9fs_dir_release - close a 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
160
fs/9p/vfs_file.c
|
@ -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 = {
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -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);
|
||||
|
||||
put_back_sb:
|
||||
/* deactivate_super calls v9fs_kill_super which will frees the rest */
|
||||
if (v9ses) {
|
||||
v9fs_session_close(v9ses);
|
||||
kfree(v9ses);
|
||||
}
|
||||
|
||||
if (sb) {
|
||||
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");
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -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
417
include/net/9p/9p.h
Normal 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
80
include/net/9p/client.h
Normal 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 */
|
|
@ -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 */
|
|
@ -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
21
net/9p/Kconfig
Normal 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
13
net/9p/Makefile
Normal 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
965
net/9p/client.c
Normal 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);
|
||||
}
|
|
@ -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,73 +469,74 @@ 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);
|
||||
|
@ -534,23 +545,24 @@ struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version)
|
|||
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);
|
||||
|
@ -559,43 +571,45 @@ struct v9fs_fcall *v9fs_create_tauth(u32 afid, char *uname, char *aname)
|
|||
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:
|
||||
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);
|
||||
|
@ -604,17 +618,18 @@ struct v9fs_fcall *v9fs_create_tflush(u16 oldtag)
|
|||
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,15 +638,15 @@ 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)) {
|
||||
|
@ -641,21 +656,22 @@ struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
|
|||
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);
|
||||
|
@ -664,31 +680,33 @@ struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode)
|
|||
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);
|
||||
|
@ -697,22 +715,23 @@ struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
|
|||
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);
|
||||
|
@ -721,24 +740,26 @@ struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count)
|
|||
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);
|
||||
|
@ -751,20 +772,30 @@ struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
|
|||
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);
|
||||
|
@ -773,20 +804,21 @@ struct v9fs_fcall *v9fs_create_tclunk(u32 fid)
|
|||
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);
|
||||
|
@ -795,20 +827,21 @@ struct v9fs_fcall *v9fs_create_tremove(u32 fid)
|
|||
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);
|
||||
|
@ -817,24 +850,48 @@ struct v9fs_fcall *v9fs_create_tstat(u32 fid)
|
|||
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);
|
||||
|
@ -843,3 +900,4 @@ struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
|
|||
error:
|
||||
return fc;
|
||||
}
|
||||
EXPORT_SYMBOL(p9_create_twstat);
|
|
@ -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);
|
|
@ -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.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.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,43 +179,45 @@ 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,
|
||||
"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,
|
||||
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,
|
||||
|
@ -226,46 +228,48 @@ v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
|
|||
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,
|
||||
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 += 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
85
net/9p/mod.c
Normal 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");
|
File diff suppressed because it is too large
Load diff
86
net/9p/sysctl.c
Normal file
86
net/9p/sysctl.c
Normal 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
363
net/9p/trans_fd.c
Normal 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
125
net/9p/util.c
Normal 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);
|
|
@ -227,6 +227,7 @@ source "net/ieee80211/Kconfig"
|
|||
endmenu
|
||||
|
||||
source "net/rfkill/Kconfig"
|
||||
source "net/9p/Kconfig"
|
||||
|
||||
endif # if NET
|
||||
endmenu # Networking
|
||||
|
|
|
@ -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
|
||||
|
|
Loading…
Reference in a new issue