[PATCH] v9fs: debug and support routines
Eric Van Hensbergen [Fri, 9 Sep 2005 20:04:24 +0000 (13:04 -0700)]
This part of the patch contains debug and other misc routines.

Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

fs/9p/debug.h [new file with mode: 0644]
fs/9p/error.c [new file with mode: 0644]
fs/9p/error.h [new file with mode: 0644]
fs/9p/fid.c [new file with mode: 0644]
fs/9p/fid.h [new file with mode: 0644]

diff --git a/fs/9p/debug.h b/fs/9p/debug.h
new file mode 100644 (file)
index 0000000..4445f06
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+ *  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 as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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_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, j;
+       int len = datalen;
+
+       printk(KERN_DEBUG "data ");
+       for (i = 0; i < len; i += 4) {
+               for (j = 0; (j < 4) && (i + j < len); j++)
+                       printk(KERN_DEBUG "%02x", data[i + j]);
+               printk(KERN_DEBUG " ");
+       }
+       printk(KERN_DEBUG "\n");
+}
+#else                          /* DEBUG_DUMP_PKT */
+static inline void dump_data(const unsigned char *data, unsigned int datalen)
+{
+
+}
+#endif                         /* DEBUG_DUMP_PKT */
diff --git a/fs/9p/error.c b/fs/9p/error.c
new file mode 100644 (file)
index 0000000..fee5d19
--- /dev/null
@@ -0,0 +1,93 @@
+/*
+ * 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 as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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/config.h>
+#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++) {
+               bucket = jhash(c->name, strlen(c->name), 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 errno = 0;
+       struct hlist_node *p = NULL;
+       struct errormap *c = NULL;
+       int bucket = jhash(errstr, strlen(errstr), 0) % ERRHASHSZ;
+
+       hlist_for_each_entry(c, p, &hash_errmap[bucket], list) {
+               if (!strcmp(c->name, errstr)) {
+                       errno = c->val;
+                       break;
+               }
+       }
+
+       if (errno == 0) {
+               /* TODO: if error isn't found, add it dynamically */
+               printk(KERN_ERR "%s: errstr :%s: not found\n", __FUNCTION__,
+                      errstr);
+               errno = 1;
+       }
+
+       return -errno;
+}
diff --git a/fs/9p/error.h b/fs/9p/error.h
new file mode 100644 (file)
index 0000000..4bf2cf5
--- /dev/null
@@ -0,0 +1,181 @@
+/*
+ * linux/fs/9p/error.h
+ *
+ * Huge Nasty Error Table
+ *
+ * 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.
+ *
+ *  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 as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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/errno.h>
+
+struct errormap {
+       char *name;
+       int val;
+
+       struct hlist_node list;
+};
+
+#define ERRHASHSZ              32
+static struct hlist_head hash_errmap[ERRHASHSZ];
+
+/* FixMe - reduce to a reasonable size */
+static struct errormap errmap[] = {
+       {"Operation not permitted", 1},
+       {"wstat prohibited", 1},
+       {"No such file or directory", 2},
+       {"file not found", 2},
+       {"Interrupted system call", 4},
+       {"Input/output error", 5},
+       {"No such device or address", 6},
+       {"Argument list too long", 7},
+       {"Bad file descriptor", 9},
+       {"Resource temporarily unavailable", 11},
+       {"Cannot allocate memory", 12},
+       {"Permission denied", 13},
+       {"Bad address", 14},
+       {"Block device required", 15},
+       {"Device or resource busy", 16},
+       {"File exists", 17},
+       {"Invalid cross-device link", 18},
+       {"No such device", 19},
+       {"Not a directory", 20},
+       {"Is a directory", 21},
+       {"Invalid argument", 22},
+       {"Too many open files in system", 23},
+       {"Too many open files", 24},
+       {"Text file busy", 26},
+       {"File too large", 27},
+       {"No space left on device", 28},
+       {"Illegal seek", 29},
+       {"Read-only file system", 30},
+       {"Too many links", 31},
+       {"Broken pipe", 32},
+       {"Numerical argument out of domain", 33},
+       {"Numerical result out of range", 34},
+       {"Resource deadlock avoided", 35},
+       {"File name too long", 36},
+       {"No locks available", 37},
+       {"Function not implemented", 38},
+       {"Directory not empty", 39},
+       {"Too many levels of symbolic links", 40},
+       {"Unknown error 41", 41},
+       {"No message of desired type", 42},
+       {"Identifier removed", 43},
+       {"File locking deadlock error", 58},
+       {"No data available", 61},
+       {"Machine is not on the network", 64},
+       {"Package not installed", 65},
+       {"Object is remote", 66},
+       {"Link has been severed", 67},
+       {"Communication error on send", 70},
+       {"Protocol error", 71},
+       {"Bad message", 74},
+       {"File descriptor in bad state", 77},
+       {"Streams pipe error", 86},
+       {"Too many users", 87},
+       {"Socket operation on non-socket", 88},
+       {"Message too long", 90},
+       {"Protocol not available", 92},
+       {"Protocol not supported", 93},
+       {"Socket type not supported", 94},
+       {"Operation not supported", 95},
+       {"Protocol family not supported", 96},
+       {"Network is down", 100},
+       {"Network is unreachable", 101},
+       {"Network dropped connection on reset", 102},
+       {"Software caused connection abort", 103},
+       {"Connection reset by peer", 104},
+       {"No buffer space available", 105},
+       {"Transport endpoint is already connected", 106},
+       {"Transport endpoint is not connected", 107},
+       {"Cannot send after transport endpoint shutdown", 108},
+       {"Connection timed out", 110},
+       {"Connection refused", 111},
+       {"Host is down", 112},
+       {"No route to host", 113},
+       {"Operation already in progress", 114},
+       {"Operation now in progress", 115},
+       {"Is a named type file", 120},
+       {"Remote I/O error", 121},
+       {"Disk quota exceeded", 122},
+       {"Operation canceled", 125},
+       {"Unknown error 126", 126},
+       {"Unknown error 127", 127},
+/* errors from fossil, vacfs, and u9fs */
+       {"fid unknown or out of range", EBADF},
+       {"permission denied", EACCES},
+       {"file does not exist", ENOENT},
+       {"authentication failed", ECONNREFUSED},
+       {"bad offset in directory read", ESPIPE},
+       {"bad use of fid", EBADF},
+       {"wstat can't convert between files and directories", EPERM},
+       {"directory is not empty", ENOTEMPTY},
+       {"file exists", EEXIST},
+       {"file already exists", EEXIST},
+       {"file or directory already exists", EEXIST},
+       {"fid already in use", EBADF},
+       {"file in use", ETXTBSY},
+       {"i/o error", EIO},
+       {"file already open for I/O", ETXTBSY},
+       {"illegal mode", EINVAL},
+       {"illegal name", ENAMETOOLONG},
+       {"not a directory", ENOTDIR},
+       {"not a member of proposed group", EINVAL},
+       {"not owner", EACCES},
+       {"only owner can change group in wstat", EACCES},
+       {"read only file system", EROFS},
+       {"no access to special file", EPERM},
+       {"i/o count too large", EIO},
+       {"unknown group", EINVAL},
+       {"unknown user", EINVAL},
+       {"bogus wstat buffer", EPROTO},
+       {"exclusive use file already open", EAGAIN},
+       {"corrupted directory entry", EIO},
+       {"corrupted file entry", EIO},
+       {"corrupted block label", EIO},
+       {"corrupted meta data", EIO},
+       {"illegal offset", EINVAL},
+       {"illegal path element", ENOENT},
+       {"root of file system is corrupted", EIO},
+       {"corrupted super block", EIO},
+       {"protocol botch", EPROTO},
+       {"file system is full", ENOSPC},
+       {"file is in use", EAGAIN},
+       {"directory entry is not allocated", ENOENT},
+       {"file is read only", EROFS},
+       {"file has been removed", EIDRM},
+       {"only support truncation to zero length", EPERM},
+       {"cannot remove root", EPERM},
+       {"file too big", EFBIG},
+       {"venti i/o error", EIO},
+       /* these are not errors */
+       {"u9fs rhostsauth: no authentication required", 0},
+       {"u9fs authnone: no authentication required", 0},
+       {NULL, -1}
+};
+
+extern int v9fs_error_init(void);
+extern int v9fs_errstr2errno(char *errstr);
diff --git a/fs/9p/fid.c b/fs/9p/fid.c
new file mode 100644 (file)
index 0000000..821c9c4
--- /dev/null
@@ -0,0 +1,241 @@
+/*
+ * V9FS FID Management
+ *
+ *  Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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/config.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/idr.h>
+
+#include "debug.h"
+#include "v9fs.h"
+#include "9p.h"
+#include "v9fs_vfs.h"
+#include "transport.h"
+#include "mux.h"
+#include "conv.h"
+#include "fid.h"
+
+/**
+ * v9fs_fid_insert - add a fid to a dentry
+ * @fid: fid to add
+ * @dentry: dentry that it is being added to
+ *
+ */
+
+static int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry)
+{
+       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");
+                       return -ENOMEM;
+               }
+               fid_list = (struct list_head *)dentry->d_fsdata;
+               INIT_LIST_HEAD(fid_list);       /* Initialize list head */
+       }
+
+       fid->uid = current->uid;
+       fid->pid = current->pid;
+       list_add(&fid->list, fid_list);
+       return 0;
+}
+
+/**
+ * v9fs_fid_create - allocate a FID structure
+ * @dentry - dentry to link newly created fid to
+ *
+ */
+
+struct v9fs_fid *v9fs_fid_create(struct dentry *dentry)
+{
+       struct v9fs_fid *new;
+
+       new = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
+       if (new == NULL) {
+               dprintk(DEBUG_ERROR, "Out of Memory\n");
+               return ERR_PTR(-ENOMEM);
+       }
+
+       new->fid = -1;
+       new->fidopen = 0;
+       new->fidcreate = 0;
+       new->fidclunked = 0;
+       new->iounit = 0;
+
+       if (v9fs_fid_insert(new, dentry) == 0)
+               return new;
+       else {
+               dprintk(DEBUG_ERROR, "Problems inserting to dentry\n");
+               kfree(new);
+               return NULL;
+       }
+}
+
+/**
+ * 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 - retrieve the right fid from a  particular dentry
+ * @dentry: dentry to look for fid in
+ * @type: intent of lookup (operation or traversal)
+ *
+ * search list of fids associated with a dentry for a fid with a matching
+ * thread id or uid.  If that fails, look up the dentry's parents to see if you
+ * can find a matching fid.
+ *
+ */
+
+struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry, int type)
+{
+       struct list_head *fid_list = (struct list_head *)dentry->d_fsdata;
+       struct v9fs_fid *current_fid = NULL;
+       struct v9fs_fid *temp = NULL;
+       struct v9fs_fid *return_fid = NULL;
+       int found_parent = 0;
+       int found_user = 0;
+
+       dprintk(DEBUG_9P, " dentry: %s (%p) type %d\n", dentry->d_iname, dentry,
+               type);
+
+       if (fid_list && !list_empty(fid_list)) {
+               list_for_each_entry_safe(current_fid, temp, fid_list, list) {
+                       if (current_fid->uid == current->uid) {
+                               if (return_fid == NULL) {
+                                       if ((type == FID_OP)
+                                           || (!current_fid->fidopen)) {
+                                               return_fid = current_fid;
+                                               found_user = 1;
+                                       }
+                               }
+                       }
+                       if (current_fid->pid == current->real_parent->pid) {
+                               if ((return_fid == NULL) || (found_parent)
+                                   || (found_user)) {
+                                       if ((type == FID_OP)
+                                           || (!current_fid->fidopen)) {
+                                               return_fid = current_fid;
+                                               found_parent = 1;
+                                               found_user = 0;
+                                       }
+                               }
+                       }
+                       if (current_fid->pid == current->pid) {
+                               if ((type == FID_OP) ||
+                                   (!current_fid->fidopen)) {
+                                       return_fid = current_fid;
+                                       found_parent = 0;
+                                       found_user = 0;
+                               }
+                       }
+               }
+       }
+
+       /* we are at the root but didn't match */
+       if ((!return_fid) && (dentry->d_parent == dentry)) {
+               /* TODO: clone attach with new uid */
+               return_fid = current_fid;
+       }
+
+       if (!return_fid) {
+               struct dentry *par = current->fs->pwd->d_parent;
+               int count = 1;
+               while (par != NULL) {
+                       if (par == dentry)
+                               break;
+                       count++;
+                       if (par == par->d_parent) {
+                               dprintk(DEBUG_ERROR,
+                                       "got to root without finding dentry\n");
+                               break;
+                       }
+                       par = par->d_parent;
+               }
+
+/* XXX - there may be some duplication we can get rid of */
+               if (par == dentry) {
+                       /* we need to fid_lookup the starting point */
+                       int fidnum = -1;
+                       int oldfid = -1;
+                       int result = -1;
+                       struct v9fs_session_info *v9ses =
+                           v9fs_inode2v9ses(current->fs->pwd->d_inode);
+
+                       current_fid =
+                           v9fs_fid_lookup(current->fs->pwd, FID_WALK);
+                       if (current_fid == NULL) {
+                               dprintk(DEBUG_ERROR,
+                                       "process cwd doesn't have a fid\n");
+                               return return_fid;
+                       }
+                       oldfid = current_fid->fid;
+                       par = current->fs->pwd;
+                       /* TODO: take advantage of multiwalk */
+
+                       fidnum = v9fs_get_idpool(&v9ses->fidpool);
+                       if (fidnum < 0) {
+                               dprintk(DEBUG_ERROR,
+                                       "could not get a new fid num\n");
+                               return return_fid;
+                       }
+
+                       while (par != dentry) {
+                               result =
+                                   v9fs_t_walk(v9ses, oldfid, fidnum, "..",
+                                               NULL);
+                               if (result < 0) {
+                                       dprintk(DEBUG_ERROR,
+                                               "problem walking to parent\n");
+
+                                       break;
+                               }
+                               oldfid = fidnum;
+                               if (par == par->d_parent) {
+                                       dprintk(DEBUG_ERROR,
+                                               "can't find dentry\n");
+                                       break;
+                               }
+                               par = par->d_parent;
+                       }
+                       if (par == dentry) {
+                               return_fid = v9fs_fid_create(dentry);
+                               return_fid->fid = fidnum;
+                       }
+               }
+       }
+
+       return return_fid;
+}
diff --git a/fs/9p/fid.h b/fs/9p/fid.h
new file mode 100644 (file)
index 0000000..7db478c
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+ * V9FS FID Management
+ *
+ *  Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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/list.h>
+
+#define FID_OP   0
+#define FID_WALK 1
+
+struct v9fs_fid {
+       struct list_head list;   /* list of fids associated with a dentry */
+       struct list_head active; /* XXX - debug */
+
+       u32 fid;
+       unsigned char fidopen;    /* set when fid is opened */
+       unsigned char fidcreate;  /* set when fid was just created */
+       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 */
+       pid_t pid;              /* thread associated with this fid */
+       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_fid *v9fs_fid_lookup(struct dentry *dentry, int type);
+void v9fs_fid_destroy(struct v9fs_fid *fid);
+struct v9fs_fid *v9fs_fid_create(struct dentry *);