In child.c : For all commands such as "CreateX,..." check if the backend
authorRonnie Sahlberg <ronniesahlberg@gmail.com>
Fri, 25 Jul 2008 05:06:57 +0000 (15:06 +1000)
committerRonnie Sahlberg <ronniesahlberg@gmail.com>
Fri, 25 Jul 2008 05:06:57 +0000 (15:06 +1000)
supports this command or not.

Create a structure of function pointers to hold all possible operations dbench
can manage.
Add all NFSv3 specific operations to this structure.

Let sockio, nfsio and fileio provide this structure to dbench telling
dbench which command they can handle and which they do not understand.

Add three new commandline parameters specific to nfsbench :
--server  --export and --protocol

child.c
dbench.c
dbench.h
fileio.c
proto.h
sockio.c

diff --git a/child.c b/child.c
index 315c709..9a3b91c 100644 (file)
--- a/child.c
+++ b/child.c
@@ -92,64 +92,241 @@ static void child_op(struct child_struct *child, char **params,
        child->lasttime = timeval_current();
 
        if (!strcmp(params[0],"NTCreateX")) {
-               nb_createx(child, fname, ival(params[2]), ival(params[3]), 
-                          ival(params[4]), status);
-               OP_LATENCY(NTCreateX);
+               if (nb_ops.createx) {
+                       nb_ops.createx(child, fname, ival(params[2]), ival(params[3]), 
+                                  ival(params[4]), status);
+                       OP_LATENCY(NTCreateX);
+               } else {
+                       printf("Operation NTCREATEX is not supported\n");
+               }
        } else if (!strcmp(params[0],"Close")) {
-               nb_close(child, ival(params[1]), status);
-               OP_LATENCY(Close);
+               if (nb_ops.close) {
+                       nb_ops.close(child, ival(params[1]), status);
+                       OP_LATENCY(Close);
+               } else {
+                       printf("Operation CLOSE is not supported\n");
+               }
        } else if (!strcmp(params[0],"Rename")) {
-               nb_rename(child, fname, fname2, status);
-               OP_LATENCY(Rename);
+               if (nb_ops.rename) {
+                       nb_ops.rename(child, fname, fname2, status);
+                       OP_LATENCY(Rename);
+               } else {
+                       printf("Operation RENAME is not supported\n");
+               }
        } else if (!strcmp(params[0],"Unlink")) {
-               nb_unlink(child, fname, ival(params[2]), status);
-               OP_LATENCY(Unlink);
+               if (nb_ops.unlink) {
+                       nb_ops.unlink(child, fname, ival(params[2]), status);
+                       OP_LATENCY(Unlink);
+               } else {
+                       printf("Operation UNLINK is not supported\n");
+               }
        } else if (!strcmp(params[0],"Deltree")) {
-               nb_deltree(child, fname);
-               OP_LATENCY(Deltree);
+               if (nb_ops.deltree) {
+                       nb_ops.deltree(child, fname);
+                       OP_LATENCY(Deltree);
+               } else {
+                       printf("Operation DELTREE is not supported\n");
+               }
        } else if (!strcmp(params[0],"Rmdir")) {
-               nb_rmdir(child, fname, status);
-               OP_LATENCY(Rmdir);
+               if (nb_ops.rmdir) {
+                       nb_ops.rmdir(child, fname, status);
+                       OP_LATENCY(Rmdir);
+               } else {
+                       printf("Operation RMDIR is not supported\n");
+               }
        } else if (!strcmp(params[0],"Mkdir")) {
-               nb_mkdir(child, fname, status);
-               OP_LATENCY(Mkdir);
+               if (nb_ops.mkdir) {
+                       nb_ops.mkdir(child, fname, status);
+                       OP_LATENCY(Mkdir);
+               } else {
+                       printf("Operation MKDIR is not supported\n");
+               }
        } else if (!strcmp(params[0],"QUERY_PATH_INFORMATION")) {
-               nb_qpathinfo(child, fname, ival(params[2]), status);
-               OP_LATENCY(Qpathinfo);
+               if (nb_ops.qpathinfo) {
+                       nb_ops.qpathinfo(child, fname, ival(params[2]), status);
+                       OP_LATENCY(Qpathinfo);
+               } else {
+                       printf("Operation QUERY_PATH_INFORMATION is not supported\n");
+               }
        } else if (!strcmp(params[0],"QUERY_FILE_INFORMATION")) {
-               nb_qfileinfo(child, ival(params[1]), ival(params[2]), status);
-               OP_LATENCY(Qfileinfo);
+               if (nb_ops.qfileinfo) {
+                       nb_ops.qfileinfo(child, ival(params[1]), ival(params[2]), status);
+                       OP_LATENCY(Qfileinfo);
+               } else {
+                       printf("Operation QUERY_FILE_INFORMATION is not supported\n");
+               }
        } else if (!strcmp(params[0],"QUERY_FS_INFORMATION")) {
-               nb_qfsinfo(child, ival(params[1]), status);
-               OP_LATENCY(Qfsinfo);
+               if (nb_ops.qfsinfo) {
+                       nb_ops.qfsinfo(child, ival(params[1]), status);
+                       OP_LATENCY(Qfsinfo);
+               } else {
+                       printf("Operation QUERY_FS_INFORMATION is not supported\n");
+               }
        } else if (!strcmp(params[0],"SET_FILE_INFORMATION")) {
-               nb_sfileinfo(child, ival(params[1]), ival(params[2]), status);
-               OP_LATENCY(Sfileinfo);
+               if (nb_ops.sfileinfo) {
+                       nb_ops.sfileinfo(child, ival(params[1]), ival(params[2]), status);
+                       OP_LATENCY(Sfileinfo);
+               } else {
+                       printf("Operation SET_FILE_INFORMATION is not supported\n");
+               }
        } else if (!strcmp(params[0],"FIND_FIRST")) {
-               nb_findfirst(child, fname, ival(params[2]), 
-                            ival(params[3]), ival(params[4]), status);
-               OP_LATENCY(Find);
+               if (nb_ops.findfirst) {
+                       nb_ops.findfirst(child, fname, ival(params[2]), 
+                                    ival(params[3]), ival(params[4]), status);
+                       OP_LATENCY(Find);
+               } else {
+                       printf("Operation FINDFIRST is not supported\n");
+               }
        } else if (!strcmp(params[0],"WriteX")) {
-               nb_writex(child, ival(params[1]), 
-                         ival(params[2]), ival(params[3]), ival(params[4]),
-                         status);
-               OP_LATENCY(WriteX);
+               if (nb_ops.writex) {
+                       nb_ops.writex(child, ival(params[1]), 
+                                 ival(params[2]), ival(params[3]), ival(params[4]),
+                                 status);
+                       OP_LATENCY(WriteX);
+               } else {
+                       printf("Operation WRITEX is not supported\n");
+               }
        } else if (!strcmp(params[0],"LockX")) {
-               nb_lockx(child, ival(params[1]), 
-                        ival(params[2]), ival(params[3]), status);
-               OP_LATENCY(LockX);
+               if (nb_ops.lockx) {
+                       nb_ops.lockx(child, ival(params[1]), 
+                                ival(params[2]), ival(params[3]), status);
+                       OP_LATENCY(LockX);
+               } else {
+                       printf("Operation LOCKX is not supported\n");
+               }
        } else if (!strcmp(params[0],"UnlockX")) {
-               nb_unlockx(child, ival(params[1]), 
-                          ival(params[2]), ival(params[3]), status);
-               OP_LATENCY(UnlockX);
+               if (nb_ops.unlockx) {
+                       nb_ops.unlockx(child, ival(params[1]), 
+                                  ival(params[2]), ival(params[3]), status);
+                       OP_LATENCY(UnlockX);
+               } else {
+                       printf("Operation UNLOCKX is not supported\n");
+               }
        } else if (!strcmp(params[0],"ReadX")) {
-               nb_readx(child, ival(params[1]), 
-                        ival(params[2]), ival(params[3]), ival(params[4]),
-                        status);
-               OP_LATENCY(ReadX);
+               if (nb_ops.readx) {
+                       nb_ops.readx(child, ival(params[1]), 
+                                ival(params[2]), ival(params[3]), ival(params[4]),
+                                status);
+                       OP_LATENCY(ReadX);
+               } else {
+                       printf("Operation READX is not supported\n");
+               }
        } else if (!strcmp(params[0],"Flush")) {
-               nb_flush(child, ival(params[1]), status);
-               OP_LATENCY(Flush);
+               if (nb_ops.flush) {
+                       nb_ops.flush(child, ival(params[1]), status);
+                       OP_LATENCY(Flush);
+               } else {
+                       printf("Operation FLUSH is not supported\n");
+               }
+       } else if (!strcmp(params[0],"GETATTR3")) {
+               if (nb_ops.getattr3) {
+                       nb_ops.getattr3(child, fname, status);
+                       OP_LATENCY(GETATTR3);
+               } else {
+                       printf("Operation GETATTR3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"LOOKUP3")) {
+               if (nb_ops.getattr3) {
+                       nb_ops.lookup3(child, fname, status);
+                       OP_LATENCY(LOOKUP3);
+               } else {
+                       printf("Operation LOOKUP3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"CREATE3")) {
+               if (nb_ops.create3) {
+                       nb_ops.create3(child, fname, status);
+                       OP_LATENCY(CREATE3);
+               } else {
+                       printf("Operation CREATE3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"WRITE3")) {
+               if (nb_ops.write3) {
+                       nb_ops.write3(child, fname, ival(params[2]),
+                               ival(params[3]),
+                               ival(params[4]), status);
+                       OP_LATENCY(WRITE3);
+               } else {
+                       printf("Operation WRITE3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"COMMIT3")) {
+               if (nb_ops.commit3) {
+                       nb_ops.commit3(child, fname, status);
+                       OP_LATENCY(COMMIT3);
+               } else {
+                       printf("Operation COMMIT3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"READ3")) {
+               if (nb_ops.read3) {
+                       nb_ops.read3(child, fname, ival(params[2]),
+                               ival(params[3]), status);
+                       OP_LATENCY(READ3);
+               } else {
+                       printf("Operation READ3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"ACCESS3")) {
+               if (nb_ops.access3) {
+                       nb_ops.access3(child, fname, ival(params[2]),
+                               ival(params[3]), status);
+                       OP_LATENCY(ACCESS3);
+               } else {
+                       printf("Operation ACCESS3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"MKDIR3")) {
+               if (nb_ops.mkdir3) {
+                       nb_ops.mkdir3(child, fname, status);
+                       OP_LATENCY(MKDIR3);
+               } else {
+                       printf("Operation MKDIR3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"RMDIR3")) {
+               if (nb_ops.rmdir3) {
+                       nb_ops.rmdir3(child, fname, status);
+                       OP_LATENCY(RMDIR3);
+               } else {
+                       printf("Operation RMDIR3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"FSSTAT3")) {
+               if (nb_ops.fsstat3) {
+                       nb_ops.fsstat3(child, status);
+                       OP_LATENCY(FSSTAT3);
+               } else {
+                       printf("Operation FSSTAT3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"FSINFO3")) {
+               if (nb_ops.fsinfo3) {
+                       nb_ops.fsinfo3(child, status);
+                       OP_LATENCY(FSINFO3);
+               } else {
+                       printf("Operation FSINFO3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"SYMLINK3")) {
+               if (nb_ops.symlink3) {
+                       nb_ops.symlink3(child, fname, fname2, status);
+                       OP_LATENCY(SYMLINK3);
+               } else {
+                       printf("Operation SYMLINK3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"LINK3")) {
+               if (nb_ops.link3) {
+                       nb_ops.link3(child, fname, fname2, status);
+                       OP_LATENCY(LINK3);
+               } else {
+                       printf("Operation LINK3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"REMOVE3")) {
+               if (nb_ops.remove3) {
+                       nb_ops.remove3(child, fname, status);
+                       OP_LATENCY(REMOVE3);
+               } else {
+                       printf("Operation REMOVE3 is not supported\n");
+               }
+       } else if (!strcmp(params[0],"READDIRPLUS3")) {
+               if (nb_ops.readdirplus3) {
+                       nb_ops.readdirplus3(child, fname, status);
+                       OP_LATENCY(READDIRPLUS3);
+               } else {
+                       printf("Operation READDIRPLUS3 is not supported\n");
+               }
        } else if (!strcmp(params[0],"Sleep")) {
                nb_sleep(child, ival(params[1]), status);
        } else {
@@ -271,7 +448,7 @@ done:
                child->cleanup = 1;
                fflush(stdout);
                if (!options.skip_cleanup) {
-                       nb_cleanup(child);
+                       nb_ops.cleanup(child);
                }
                child->cleanup_finished = 1;
        }
index 10bb613..41c9f3c 100644 (file)
--- a/dbench.c
+++ b/dbench.c
@@ -41,6 +41,8 @@ struct options options = {
        .ea_enable           = 0,
        .clients_per_process = 1,
        .server              = "localhost",
+       .export              = "/tmp",
+       .protocol            = "tcp",
 };
 
 static struct timeval tv_start;
@@ -179,6 +181,22 @@ static const struct {
        OP_NAME(LockX),
        OP_NAME(UnlockX),
        OP_NAME(Flush),
+       /* NFSv3 commands */
+       OP_NAME(GETATTR3),
+       OP_NAME(LOOKUP3),
+       OP_NAME(CREATE3),
+       OP_NAME(WRITE3),
+       OP_NAME(COMMIT3),
+       OP_NAME(READ3),
+       OP_NAME(ACCESS3),
+       OP_NAME(MKDIR3),
+       OP_NAME(RMDIR3),
+       OP_NAME(FSSTAT3),
+       OP_NAME(FSINFO3),
+       OP_NAME(SYMLINK3),
+       OP_NAME(REMOVE3),
+       OP_NAME(READDIRPLUS3),
+       OP_NAME(LINK3),
 };
 
 static void show_one_latency(struct opnames *ops, struct opnames *ops_all)
@@ -295,7 +313,7 @@ static void create_procs(int nprocs, void (*fn)(struct child_struct *, const cha
                        setlinebuf(stdout);
 
                        for (j=0;j<options.clients_per_process;j++) {
-                               nb_setup(&children[i*options.clients_per_process + j]);
+                               nb_ops.setup(&children[i*options.clients_per_process + j]);
                        }
 
                        sbuf.sem_op = 0;
@@ -416,6 +434,12 @@ static int process_opts(int argc, const char **argv)
                  "skip cleanup operations", NULL },
                { "per-client-results", 0, POPT_ARG_NONE, &options.per_client_results, 0, 
                  "show results per client", NULL },
+               { "server",  'S', POPT_ARG_STRING, &options.server, 0, 
+                 "server", NULL },
+               { "export",  'E', POPT_ARG_STRING, &options.export, 0, 
+                 "export", NULL },
+               { "protocol",  'P', POPT_ARG_STRING, &options.protocol, 0, 
+                 "protocol", NULL },
                POPT_TABLEEND
        };
        poptContext pc;
index 0d68c62..8a6f5e8 100644 (file)
--- a/dbench.h
+++ b/dbench.h
@@ -136,6 +136,21 @@ struct child_struct {
                struct op op_LockX;
                struct op op_UnlockX;
                struct op op_Flush;
+               struct op op_GETATTR3;
+               struct op op_MKDIR3;
+               struct op op_RMDIR3;
+               struct op op_LOOKUP3;
+               struct op op_CREATE3;
+               struct op op_WRITE3;
+               struct op op_COMMIT3;
+               struct op op_READ3;
+               struct op op_ACCESS3;
+               struct op op_FSSTAT3;
+               struct op op_FSINFO3;
+               struct op op_SYMLINK3;
+               struct op op_REMOVE3;
+               struct op op_READDIRPLUS3;
+               struct op op_LINK3;
        } op;
        void *private;
 };
@@ -161,8 +176,53 @@ struct options {
        int fake_io;
        int skip_cleanup;
        int per_client_results;
+       const char *export;
+       const char *protocol;
 };
 
+struct nb_operations {
+       void (*setup)(struct child_struct *);
+       void (*deltree)(struct child_struct *, const char *dname);
+       void (*cleanup)(struct child_struct *child);
+
+       /* CIFS operations */
+       void (*flush)(struct child_struct *, int handle, const char *status);
+       void (*close)(struct child_struct *, int handle, const char *status);
+       void (*lockx)(struct child_struct *, int handle, uint32_t offset, int size, const char *status);
+       void (*rmdir)(struct child_struct *, const char *fname, const char *status);
+       void (*mkdir)(struct child_struct *, const char *dname, const char *status);
+       void (*rename)(struct child_struct *, const char *old, const char *new, const char *status);
+       void (*readx)(struct child_struct *, int handle, int offset, int size, int ret_size, const char *status);
+       void (*writex)(struct child_struct *, int handle, int offset, int size, int ret_size, const char *status);
+       void (*unlink)(struct child_struct *, const char *fname, int attr, const char *status);
+       void (*unlockx)(struct child_struct *child,int handle, uint32_t offset, int size, const char *status);
+       void (*findfirst)(struct child_struct *child, const char *fname, int level, int maxcnt, int count, const char *status);
+       void (*sfileinfo)(struct child_struct *child, int handle, int level, const char *status);
+       void (*qfileinfo)(struct child_struct *child, int handle, int level, const char *status);
+       void (*qpathinfo)(struct child_struct *child, const char *fname, int level, const char *status);
+       void (*qfsinfo)(struct child_struct *child, int level, const char *status);
+       void (*createx)(struct child_struct *child, const char *fname, uint32_t create_options, uint32_t create_disposition, int fnum, const char *status);
+
+       /* NFSv3 operations */
+       void (*getattr3)(struct child_struct *child, const char *fname, const char *status);
+       void (*lookup3)(struct child_struct *child, const char *fname, const char *status);
+       void (*create3)(struct child_struct *child, const char *fname, const char *status);
+       void (*write3)(struct child_struct *child, const char *fname, int offset, int len, int stable, const char *status);
+       void (*commit3)(struct child_struct *child, const char *fname, const char *status);
+       void (*read3)(struct child_struct *child, const char *fname, int offset, int len, const char *status);
+       void (*access3)(struct child_struct *child, const char *fname, int desired, int granted, const char *status);
+       void (*mkdir3)(struct child_struct *child, const char *fname, const char *status);
+       void (*rmdir3)(struct child_struct *child, const char *fname, const char *status);
+       void (*fsstat3)(struct child_struct *child, const char *status);
+       void (*fsinfo3)(struct child_struct *child, const char *status);
+       void (*symlink3)(struct child_struct *child, const char *fname, const char *fname2, const char *status);
+       void (*remove3)(struct child_struct *child, const char *fname, const char *status);
+       void (*readdirplus3)(struct child_struct *child, const char *fname, const char *status);
+       void (*link3)(struct child_struct *child, const char *fname, const char *fname2, const char *status);
+       void (*rename3)(struct child_struct *child, const char *fname, const char *fname2, const char *status);
+};
+extern struct nb_operations nb_ops;
+
 /* CreateDisposition field. */
 #define FILE_SUPERSEDE 0
 #define FILE_OPEN 1
index 22a79b1..02b734f 100644 (file)
--- a/fileio.c
+++ b/fileio.c
@@ -193,7 +193,7 @@ static void failed(struct child_struct *child)
        exit(1);
 }
 
-void nb_setup(struct child_struct *child)
+static void fio_setup(struct child_struct *child)
 {
        struct ftable *ftable;
        ftable = calloc(MAX_FILES, sizeof(struct ftable));
@@ -202,7 +202,7 @@ void nb_setup(struct child_struct *child)
        child->rate.last_bytes = 0;
 }
 
-void nb_unlink(struct child_struct *child, const char *fname, int attr, const char *status)
+static void fio_unlink(struct child_struct *child, const char *fname, int attr, const char *status)
 {
        (void)attr;
 
@@ -216,7 +216,7 @@ void nb_unlink(struct child_struct *child, const char *fname, int attr, const ch
        if (options.sync_dirs) sync_parent(child, fname);
 }
 
-void nb_mkdir(struct child_struct *child, const char *dname, const char *status)
+static void fio_mkdir(struct child_struct *child, const char *dname, const char *status)
 {
        struct stat st;
        (void)child;
@@ -228,7 +228,7 @@ void nb_mkdir(struct child_struct *child, const char *dname, const char *status)
        mkdir(dname, 0777);
 }
 
-void nb_rmdir(struct child_struct *child, const char *fname, const char *status)
+static void fio_rmdir(struct child_struct *child, const char *fname, const char *status)
 {
        struct stat st;
        resolve_name(child, fname);
@@ -246,7 +246,7 @@ void nb_rmdir(struct child_struct *child, const char *fname, const char *status)
        if (options.sync_dirs) sync_parent(child, fname);
 }
 
-void nb_createx(struct child_struct *child, const char *fname, 
+static void fio_createx(struct child_struct *child, const char *fname, 
                uint32_t create_options, uint32_t create_disposition, int fnum,
                const char *status)
 {
@@ -318,7 +318,7 @@ void nb_createx(struct child_struct *child, const char *fname,
        }
 }
 
-void nb_writex(struct child_struct *child, int handle, int offset, 
+static void fio_writex(struct child_struct *child, int handle, int offset, 
               int size, int ret_size, const char *status)
 {
        int i = find_handle(child, handle);
@@ -375,7 +375,7 @@ void nb_writex(struct child_struct *child, int handle, int offset,
        child->bytes_since_fsync += size;
 }
 
-void nb_readx(struct child_struct *child, int handle, int offset, 
+static void fio_readx(struct child_struct *child, int handle, int offset, 
              int size, int ret_size, const char *status)
 {
        int i = find_handle(child, handle);
@@ -401,7 +401,7 @@ void nb_readx(struct child_struct *child, int handle, int offset,
        child->bytes += size;
 }
 
-void nb_close(struct child_struct *child, int handle, const char *status)
+static void fio_close(struct child_struct *child, int handle, const char *status)
 {
        struct ftable *ftable = (struct ftable *)child->private;
        int i = find_handle(child, handle);
@@ -412,7 +412,7 @@ void nb_close(struct child_struct *child, int handle, const char *status)
        ftable[i].name = NULL;
 }
 
-void nb_rename(struct child_struct *child, const char *old, const char *new, const char *status)
+static void fio_rename(struct child_struct *child, const char *old, const char *new, const char *status)
 {
        resolve_name(child, old);
        resolve_name(child, new);
@@ -435,7 +435,7 @@ void nb_rename(struct child_struct *child, const char *old, const char *new, con
        if (options.sync_dirs) sync_parent(child, new);
 }
 
-void nb_flush(struct child_struct *child, int handle, const char *status)
+static void fio_flush(struct child_struct *child, int handle, const char *status)
 {
        struct ftable *ftable = (struct ftable *)child->private;
        int i = find_handle(child, handle);
@@ -443,7 +443,7 @@ void nb_flush(struct child_struct *child, int handle, const char *status)
        fsync(ftable[i].fd);
 }
 
-void nb_qpathinfo(struct child_struct *child, const char *fname, int level, 
+static void fio_qpathinfo(struct child_struct *child, const char *fname, int level, 
                  const char *status)
 {
        (void)child;
@@ -452,7 +452,7 @@ void nb_qpathinfo(struct child_struct *child, const char *fname, int level,
        resolve_name(child, fname);
 }
 
-void nb_qfileinfo(struct child_struct *child, int handle, int level, const char *status)
+static void fio_qfileinfo(struct child_struct *child, int handle, int level, const char *status)
 {
        struct ftable *ftable = (struct ftable *)child->private;
        struct stat st;
@@ -464,7 +464,7 @@ void nb_qfileinfo(struct child_struct *child, int handle, int level, const char
        xattr_fd_read_hook(child, ftable[i].fd);
 }
 
-void nb_qfsinfo(struct child_struct *child, int level, const char *status)
+static void fio_qfsinfo(struct child_struct *child, int level, const char *status)
 {
        struct statvfs st;
 
@@ -474,7 +474,7 @@ void nb_qfsinfo(struct child_struct *child, int level, const char *status)
        statvfs(child->directory, &st);
 }
 
-void nb_findfirst(struct child_struct *child, const char *fname, int level, int maxcnt, 
+static void fio_findfirst(struct child_struct *child, const char *fname, int level, int maxcnt, 
                  int count, const char *status)
 {
        DIR *dir;
@@ -501,20 +501,7 @@ void nb_findfirst(struct child_struct *child, const char *fname, int level, int
        closedir(dir);
 }
 
-void nb_cleanup(struct child_struct *child)
-{
-       char *dname;
-
-       asprintf(&dname, "%s/clients/client%d", child->directory, child->id);
-       nb_deltree(child, dname);
-       free(dname);
-
-       asprintf(&dname, "%s%s", child->directory, "/clients");
-       rmdir(dname);
-       free(dname);
-}
-
-void nb_deltree(struct child_struct *child, const char *dname)
+void fio_deltree(struct child_struct *child, const char *dname)
 {
        DIR *d;
        struct dirent *de;
@@ -539,7 +526,7 @@ void nb_deltree(struct child_struct *child, const char *dname)
                        continue;
                }
                if (S_ISDIR(st.st_mode)) {
-                       nb_deltree(child, fname);
+                       fio_deltree(child, fname);
                } else {
                        if (unlink(fname) != 0) {
                                printf("[%d] unlink '%s' failed - %s\n",
@@ -551,7 +538,21 @@ void nb_deltree(struct child_struct *child, const char *dname)
        closedir(d);
 }
 
-void nb_sfileinfo(struct child_struct *child, int handle, int level, const char *status)
+static void fio_cleanup(struct child_struct *child)
+{
+       char *dname;
+
+       asprintf(&dname, "%s/clients/client%d", child->directory, child->id);
+       fio_deltree(child, dname);
+       free(dname);
+
+       asprintf(&dname, "%s%s", child->directory, "/clients");
+       rmdir(dname);
+       free(dname);
+}
+
+
+static void fio_sfileinfo(struct child_struct *child, int handle, int level, const char *status)
 {
        struct ftable *ftable = (struct ftable *)child->private;
        int i = find_handle(child, handle);
@@ -575,7 +576,7 @@ void nb_sfileinfo(struct child_struct *child, int handle, int level, const char
        }
 }
 
-void nb_lockx(struct child_struct *child, int handle, uint32_t offset, int size, 
+static void fio_lockx(struct child_struct *child, int handle, uint32_t offset, int size, 
              const char *status)
 {
        struct ftable *ftable = (struct ftable *)child->private;
@@ -594,7 +595,7 @@ void nb_lockx(struct child_struct *child, int handle, uint32_t offset, int size,
        fcntl(ftable[i].fd, F_SETLKW, &lock);
 }
 
-void nb_unlockx(struct child_struct *child,
+static void fio_unlockx(struct child_struct *child,
                int handle, uint32_t offset, int size, const char *status)
 {
        struct ftable *ftable = (struct ftable *)child->private;
@@ -620,3 +621,26 @@ void nb_sleep(struct child_struct *child, int usec, const char *status)
        (void)status;
        usleep(usec);
 }
+
+struct nb_operations nb_ops = {
+       .setup          = fio_setup,
+       .deltree        = fio_deltree,
+       .cleanup        = fio_cleanup,
+
+       .flush          = fio_flush,
+       .close          = fio_close,
+       .lockx          = fio_lockx,
+       .rmdir          = fio_rmdir,
+       .mkdir          = fio_mkdir,
+       .rename         = fio_rename,
+       .readx          = fio_readx,
+       .writex         = fio_writex,
+       .unlink         = fio_unlink,
+       .unlockx        = fio_unlockx,
+       .findfirst      = fio_findfirst,
+       .sfileinfo      = fio_sfileinfo,
+       .qfileinfo      = fio_qfileinfo,
+       .qpathinfo      = fio_qpathinfo,
+       .qfsinfo        = fio_qfsinfo,
+       .createx        = fio_createx,
+};
diff --git a/proto.h b/proto.h
index 5e4c73b..336b98d 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -13,7 +13,6 @@ void child_run(struct child_struct *child0, const char *loadfile);
 
 /* The following definitions come from fileio.c  */
 
-void nb_setup(struct child_struct *child);
 void nb_unlink(struct child_struct *child, const char *fname, int attr, const char *status);
 void nb_mkdir(struct child_struct *child, const char *dname, const char *status);
 void nb_rmdir(struct child_struct *child, const char *fname, const char *status);
@@ -56,12 +55,33 @@ void do_rename(char *old, char *new);
 void do_stat(char *fname, int size);
 void do_create(char *fname, int size);
 
+/* The following definitions come from libnfs.c  */
+
+
+/* The following definitions come from mount_client.c  */
+
+
+/* The following definitions come from mount_xdr.c  */
+
+
+/* The following definitions come from nfs_client.c  */
+
+
+/* The following definitions come from nfs_xdr.c  */
+
+
+/* The following definitions come from nfsio.c  */
+
+void nb_sleep(struct child_struct *child, int usec, const char *status);
+void nb_deltree(struct child_struct *child, const char *dname);
+void nb_cleanup(struct child_struct *child);
+void nb_sfileinfo(struct child_struct *child, int handle, int level, const char *status);
+
 /* The following definitions come from snprintf.c  */
 
 
 /* The following definitions come from sockio.c  */
 
-void nb_setup(struct child_struct *child);
 void nb_unlink(struct child_struct *child, const char *fname, int attr, const char *status);
 void nb_mkdir(struct child_struct *child, const char *dname, const char *status);
 void nb_rmdir(struct child_struct *child, const char *fname, const char *status);
index b01ccc7..8ed6334 100644 (file)
--- a/sockio.c
+++ b/sockio.c
@@ -63,7 +63,7 @@ static void do_packets(struct child_struct *child, int send_size, int recv_size)
 }
 
 
-void nb_setup(struct child_struct *child)
+static void sio_setup(struct child_struct *child)
 {
        struct sockio *sockio;
        sockio = calloc(1, sizeof(struct sockio));
@@ -82,7 +82,7 @@ void nb_setup(struct child_struct *child)
 }
 
 
-void nb_unlink(struct child_struct *child, const char *fname, int attr, const char *status)
+static void sio_unlink(struct child_struct *child, const char *fname, int attr, const char *status)
 {
        (void)child;
        (void)attr;
@@ -90,21 +90,21 @@ void nb_unlink(struct child_struct *child, const char *fname, int attr, const ch
         do_packets(child, 39+2+strlen(fname)*2+2, 39);
 }
 
-void nb_mkdir(struct child_struct *child, const char *dname, const char *status)
+static void sio_mkdir(struct child_struct *child, const char *dname, const char *status)
 {
        (void)child;
        (void)status;
         do_packets(child, 39+2+strlen(dname)*2+2, 39);
 }
 
-void nb_rmdir(struct child_struct *child, const char *fname, const char *status)
+static void sio_rmdir(struct child_struct *child, const char *fname, const char *status)
 {
        (void)child;
        (void)status;
         do_packets(child, 39+2+strlen(fname)*2+2, 39);
 }
 
-void nb_createx(struct child_struct *child, const char *fname, 
+static void sio_createx(struct child_struct *child, const char *fname, 
                uint32_t create_options, uint32_t create_disposition, int fnum,
                const char *status)
 {
@@ -116,7 +116,7 @@ void nb_createx(struct child_struct *child, const char *fname,
         do_packets(child, 70+2+strlen(fname)*2+2, 39+12*4);
 }
 
-void nb_writex(struct child_struct *child, int handle, int offset, 
+static void sio_writex(struct child_struct *child, int handle, int offset, 
               int size, int ret_size, const char *status)
 {
        (void)child;
@@ -128,7 +128,7 @@ void nb_writex(struct child_struct *child, int handle, int offset,
        child->bytes += size;
 }
 
-void nb_readx(struct child_struct *child, int handle, int offset, 
+static void sio_readx(struct child_struct *child, int handle, int offset, 
              int size, int ret_size, const char *status)
 {
        (void)child;
@@ -140,7 +140,7 @@ void nb_readx(struct child_struct *child, int handle, int offset,
        child->bytes += ret_size;
 }
 
-void nb_close(struct child_struct *child, int handle, const char *status)
+static void sio_close(struct child_struct *child, int handle, const char *status)
 {
        (void)child;
        (void)handle;
@@ -148,14 +148,14 @@ void nb_close(struct child_struct *child, int handle, const char *status)
         do_packets(child, 39+8, 39);
 }
 
-void nb_rename(struct child_struct *child, const char *old, const char *new, const char *status)
+static void sio_rename(struct child_struct *child, const char *old, const char *new, const char *status)
 {
        (void)child;
        (void)status;
         do_packets(child, 39+8+2*strlen(old)+2*strlen(new), 39);
 }
 
-void nb_flush(struct child_struct *child, int handle, const char *status)
+static void sio_flush(struct child_struct *child, int handle, const char *status)
 {
        (void)child;
        (void)handle;
@@ -163,7 +163,7 @@ void nb_flush(struct child_struct *child, int handle, const char *status)
         do_packets(child, 39+2, 39);
 }
 
-void nb_qpathinfo(struct child_struct *child, const char *fname, int level, 
+static void sio_qpathinfo(struct child_struct *child, const char *fname, int level, 
                  const char *status)
 {
        (void)child;
@@ -172,7 +172,7 @@ void nb_qpathinfo(struct child_struct *child, const char *fname, int level,
         do_packets(child, 39+16+2*strlen(fname), 39+32);
 }
 
-void nb_qfileinfo(struct child_struct *child, int handle, int level, const char *status)
+static void sio_qfileinfo(struct child_struct *child, int handle, int level, const char *status)
 {
        (void)child;
        (void)level;
@@ -181,7 +181,7 @@ void nb_qfileinfo(struct child_struct *child, int handle, int level, const char
         do_packets(child, 39+20, 39+32);
 }
 
-void nb_qfsinfo(struct child_struct *child, int level, const char *status)
+static void sio_qfsinfo(struct child_struct *child, int level, const char *status)
 {
        (void)child;
        (void)level;
@@ -189,7 +189,7 @@ void nb_qfsinfo(struct child_struct *child, int level, const char *status)
         do_packets(child, 39+20, 39+32);
 }
 
-void nb_findfirst(struct child_struct *child, const char *fname, int level, int maxcnt, 
+static void sio_findfirst(struct child_struct *child, const char *fname, int level, int maxcnt, 
                  int count, const char *status)
 {
        (void)child;
@@ -199,18 +199,18 @@ void nb_findfirst(struct child_struct *child, const char *fname, int level, int
         do_packets(child, 39+20+strlen(fname)*2, 39+90*count);
 }
 
-void nb_cleanup(struct child_struct *child)
+static void sio_cleanup(struct child_struct *child)
 {
        (void)child;
 }
 
-void nb_deltree(struct child_struct *child, const char *dname)
+static void sio_deltree(struct child_struct *child, const char *dname)
 {
        (void)child;
        (void)dname;
 }
 
-void nb_sfileinfo(struct child_struct *child, int handle, int level, const char *status)
+static void sio_sfileinfo(struct child_struct *child, int handle, int level, const char *status)
 {
        (void)child;
        (void)handle;
@@ -219,7 +219,7 @@ void nb_sfileinfo(struct child_struct *child, int handle, int level, const char
         do_packets(child, 39+32, 39+8);
 }
 
-void nb_lockx(struct child_struct *child, int handle, uint32_t offset, int size, 
+static void sio_lockx(struct child_struct *child, int handle, uint32_t offset, int size, 
              const char *status)
 {
        (void)child;
@@ -230,7 +230,7 @@ void nb_lockx(struct child_struct *child, int handle, uint32_t offset, int size,
         do_packets(child, 39+12, 39);
 }
 
-void nb_unlockx(struct child_struct *child,
+static void sio_unlockx(struct child_struct *child,
                int handle, uint32_t offset, int size, const char *status)
 {
        (void)child;
@@ -248,3 +248,26 @@ void nb_sleep(struct child_struct *child, int usec, const char *status)
        (void)status;
        usleep(usec);
 }
+
+struct nb_operations nb_ops = {
+       .setup          = sio_setup,
+       .deltree        = sio_deltree,
+       .cleanup        = sio_cleanup,
+
+       .flush          = sio_flush,
+       .close          = sio_close,
+       .lockx          = sio_lockx,
+       .rmdir          = sio_rmdir,
+       .mkdir          = sio_mkdir,
+       .rename         = sio_rename,
+       .readx          = sio_readx,
+       .writex         = sio_writex,
+       .unlink         = sio_unlink,
+       .unlockx        = sio_unlockx,
+       .findfirst      = sio_findfirst,
+       .sfileinfo      = sio_sfileinfo,
+       .qfileinfo      = sio_qfileinfo,
+       .qpathinfo      = sio_qpathinfo,
+       .qfsinfo        = sio_qfsinfo,
+       .createx        = sio_createx,
+};