From 96ada4d87b6d8618919c614765f2ec1d706f4f4a Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 13 Jun 2012 09:11:42 +0200
Subject: s4:ntvfs: add '_fn' suffix to all ntvfs_ops function pointers

This hopefully fixes the build on systems where _LARGE_FILES
triggers defines of syscalls e.g. '#define lseek lseek64'
on AIX.

metze

Autobuild-User(master): Stefan Metzmacher <metze@samba.org>
Autobuild-Date(master): Wed Jun 13 11:03:15 CEST 2012 on sn-devel-104
---
 source4/ntvfs/cifs/vfs_cifs.c                 |  64 +++----
 source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c |  60 +++---
 source4/ntvfs/ipc/vfs_ipc.c                   |  60 +++---
 source4/ntvfs/nbench/vfs_nbench.c             |  62 +++----
 source4/ntvfs/ntvfs.h                         |  68 +++----
 source4/ntvfs/ntvfs_generic.c                 |  54 +++---
 source4/ntvfs/ntvfs_interface.c               | 256 +++++++++++++-------------
 source4/ntvfs/posix/vfs_posix.c               |  62 +++----
 source4/ntvfs/print/vfs_print.c               |   8 +-
 source4/ntvfs/simple/vfs_simple.c             |  60 +++---
 source4/ntvfs/smb2/vfs_smb2.c                 |  62 +++----
 source4/ntvfs/unixuid/vfs_unixuid.c           |  62 +++----
 12 files changed, 439 insertions(+), 439 deletions(-)

(limited to 'source4/ntvfs')

diff --git a/source4/ntvfs/cifs/vfs_cifs.c b/source4/ntvfs/cifs/vfs_cifs.c
index fb7a485d49..552f664d8a 100644
--- a/source4/ntvfs/cifs/vfs_cifs.c
+++ b/source4/ntvfs/cifs/vfs_cifs.c
@@ -1191,38 +1191,38 @@ NTSTATUS ntvfs_cifs_init(void)
 	ops.type = NTVFS_DISK;
 	
 	/* fill in all the operations */
-	ops.connect = cvfs_connect;
-	ops.disconnect = cvfs_disconnect;
-	ops.unlink = cvfs_unlink;
-	ops.chkpath = cvfs_chkpath;
-	ops.qpathinfo = cvfs_qpathinfo;
-	ops.setpathinfo = cvfs_setpathinfo;
-	ops.open = cvfs_open;
-	ops.mkdir = cvfs_mkdir;
-	ops.rmdir = cvfs_rmdir;
-	ops.rename = cvfs_rename;
-	ops.copy = cvfs_copy;
-	ops.ioctl = cvfs_ioctl;
-	ops.read = cvfs_read;
-	ops.write = cvfs_write;
-	ops.seek = cvfs_seek;
-	ops.flush = cvfs_flush;	
-	ops.close = cvfs_close;
-	ops.exit = cvfs_exit;
-	ops.lock = cvfs_lock;
-	ops.setfileinfo = cvfs_setfileinfo;
-	ops.qfileinfo = cvfs_qfileinfo;
-	ops.fsinfo = cvfs_fsinfo;
-	ops.lpq = cvfs_lpq;
-	ops.search_first = cvfs_search_first;
-	ops.search_next = cvfs_search_next;
-	ops.search_close = cvfs_search_close;
-	ops.trans = cvfs_trans;
-	ops.logoff = cvfs_logoff;
-	ops.async_setup = cvfs_async_setup;
-	ops.cancel = cvfs_cancel;
-	ops.notify = cvfs_notify;
-	ops.trans2 = cvfs_trans2;
+	ops.connect_fn = cvfs_connect;
+	ops.disconnect_fn = cvfs_disconnect;
+	ops.unlink_fn = cvfs_unlink;
+	ops.chkpath_fn = cvfs_chkpath;
+	ops.qpathinfo_fn = cvfs_qpathinfo;
+	ops.setpathinfo_fn = cvfs_setpathinfo;
+	ops.open_fn = cvfs_open;
+	ops.mkdir_fn = cvfs_mkdir;
+	ops.rmdir_fn = cvfs_rmdir;
+	ops.rename_fn = cvfs_rename;
+	ops.copy_fn = cvfs_copy;
+	ops.ioctl_fn = cvfs_ioctl;
+	ops.read_fn = cvfs_read;
+	ops.write_fn = cvfs_write;
+	ops.seek_fn = cvfs_seek;
+	ops.flush_fn = cvfs_flush;
+	ops.close_fn = cvfs_close;
+	ops.exit_fn = cvfs_exit;
+	ops.lock_fn = cvfs_lock;
+	ops.setfileinfo_fn = cvfs_setfileinfo;
+	ops.qfileinfo_fn = cvfs_qfileinfo;
+	ops.fsinfo_fn = cvfs_fsinfo;
+	ops.lpq_fn = cvfs_lpq;
+	ops.search_first_fn = cvfs_search_first;
+	ops.search_next_fn = cvfs_search_next;
+	ops.search_close_fn = cvfs_search_close;
+	ops.trans_fn = cvfs_trans;
+	ops.logoff_fn = cvfs_logoff;
+	ops.async_setup_fn = cvfs_async_setup;
+	ops.cancel_fn = cvfs_cancel;
+	ops.notify_fn = cvfs_notify;
+	ops.trans2_fn = cvfs_trans2;
 
 	/* register ourselves with the NTVFS subsystem. We register
 	   under the name 'cifs'. */
diff --git a/source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c b/source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c
index 949b6dbbb7..8c5a53b6f8 100644
--- a/source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c
+++ b/source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c
@@ -1061,36 +1061,36 @@ NTSTATUS ntvfs_cifs_posix_init(void)
 	ZERO_STRUCT(ops);
 
 	/* fill in all the operations */
-	ops.connect = cifspsx_connect;
-	ops.disconnect = cifspsx_disconnect;
-	ops.unlink = cifspsx_unlink;
-	ops.chkpath = cifspsx_chkpath;
-	ops.qpathinfo = cifspsx_qpathinfo;
-	ops.setpathinfo = cifspsx_setpathinfo;
-	ops.open = cifspsx_open;
-	ops.mkdir = cifspsx_mkdir;
-	ops.rmdir = cifspsx_rmdir;
-	ops.rename = cifspsx_rename;
-	ops.copy = cifspsx_copy;
-	ops.ioctl = cifspsx_ioctl;
-	ops.read = cifspsx_read;
-	ops.write = cifspsx_write;
-	ops.seek = cifspsx_seek;
-	ops.flush = cifspsx_flush;	
-	ops.close = cifspsx_close;
-	ops.exit = cifspsx_exit;
-	ops.lock = cifspsx_lock;
-	ops.setfileinfo = cifspsx_setfileinfo;
-	ops.qfileinfo = cifspsx_qfileinfo;
-	ops.fsinfo = cifspsx_fsinfo;
-	ops.lpq = cifspsx_lpq;
-	ops.search_first = cifspsx_search_first;
-	ops.search_next = cifspsx_search_next;
-	ops.search_close = cifspsx_search_close;
-	ops.trans = cifspsx_trans;
-	ops.logoff = cifspsx_logoff;
-	ops.async_setup = cifspsx_async_setup;
-	ops.cancel = cifspsx_cancel;
+	ops.connect_fn = cifspsx_connect;
+	ops.disconnect_fn = cifspsx_disconnect;
+	ops.unlink_fn = cifspsx_unlink;
+	ops.chkpath_fn = cifspsx_chkpath;
+	ops.qpathinfo_fn = cifspsx_qpathinfo;
+	ops.setpathinfo_fn = cifspsx_setpathinfo;
+	ops.open_fn = cifspsx_open;
+	ops.mkdir_fn = cifspsx_mkdir;
+	ops.rmdir_fn = cifspsx_rmdir;
+	ops.rename_fn = cifspsx_rename;
+	ops.copy_fn = cifspsx_copy;
+	ops.ioctl_fn = cifspsx_ioctl;
+	ops.read_fn = cifspsx_read;
+	ops.write_fn = cifspsx_write;
+	ops.seek_fn = cifspsx_seek;
+	ops.flush_fn = cifspsx_flush;
+	ops.close_fn = cifspsx_close;
+	ops.exit_fn = cifspsx_exit;
+	ops.lock_fn = cifspsx_lock;
+	ops.setfileinfo_fn = cifspsx_setfileinfo;
+	ops.qfileinfo_fn = cifspsx_qfileinfo;
+	ops.fsinfo_fn = cifspsx_fsinfo;
+	ops.lpq_fn = cifspsx_lpq;
+	ops.search_first_fn = cifspsx_search_first;
+	ops.search_next_fn = cifspsx_search_next;
+	ops.search_close_fn = cifspsx_search_close;
+	ops.trans_fn = cifspsx_trans;
+	ops.logoff_fn = cifspsx_logoff;
+	ops.async_setup_fn = cifspsx_async_setup;
+	ops.cancel_fn = cifspsx_cancel;
 
 	/* register ourselves with the NTVFS subsystem. We register
 	   under names 'cifsposix'
diff --git a/source4/ntvfs/ipc/vfs_ipc.c b/source4/ntvfs/ipc/vfs_ipc.c
index 7fc3b14884..50f0e5995c 100644
--- a/source4/ntvfs/ipc/vfs_ipc.c
+++ b/source4/ntvfs/ipc/vfs_ipc.c
@@ -1308,36 +1308,36 @@ NTSTATUS ntvfs_ipc_init(void)
 	ops.type = NTVFS_IPC;
 
 	/* fill in all the operations */
-	ops.connect = ipc_connect;
-	ops.disconnect = ipc_disconnect;
-	ops.unlink = ipc_unlink;
-	ops.chkpath = ipc_chkpath;
-	ops.qpathinfo = ipc_qpathinfo;
-	ops.setpathinfo = ipc_setpathinfo;
-	ops.open = ipc_open;
-	ops.mkdir = ipc_mkdir;
-	ops.rmdir = ipc_rmdir;
-	ops.rename = ipc_rename;
-	ops.copy = ipc_copy;
-	ops.ioctl = ipc_ioctl;
-	ops.read = ipc_read;
-	ops.write = ipc_write;
-	ops.seek = ipc_seek;
-	ops.flush = ipc_flush;	
-	ops.close = ipc_close;
-	ops.exit = ipc_exit;
-	ops.lock = ipc_lock;
-	ops.setfileinfo = ipc_setfileinfo;
-	ops.qfileinfo = ipc_qfileinfo;
-	ops.fsinfo = ipc_fsinfo;
-	ops.lpq = ipc_lpq;
-	ops.search_first = ipc_search_first;
-	ops.search_next = ipc_search_next;
-	ops.search_close = ipc_search_close;
-	ops.trans = ipc_trans;
-	ops.logoff = ipc_logoff;
-	ops.async_setup = ipc_async_setup;
-	ops.cancel = ipc_cancel;
+	ops.connect_fn = ipc_connect;
+	ops.disconnect_fn = ipc_disconnect;
+	ops.unlink_fn = ipc_unlink;
+	ops.chkpath_fn = ipc_chkpath;
+	ops.qpathinfo_fn = ipc_qpathinfo;
+	ops.setpathinfo_fn = ipc_setpathinfo;
+	ops.open_fn = ipc_open;
+	ops.mkdir_fn = ipc_mkdir;
+	ops.rmdir_fn = ipc_rmdir;
+	ops.rename_fn = ipc_rename;
+	ops.copy_fn = ipc_copy;
+	ops.ioctl_fn = ipc_ioctl;
+	ops.read_fn = ipc_read;
+	ops.write_fn = ipc_write;
+	ops.seek_fn = ipc_seek;
+	ops.flush_fn = ipc_flush;
+	ops.close_fn = ipc_close;
+	ops.exit_fn = ipc_exit;
+	ops.lock_fn = ipc_lock;
+	ops.setfileinfo_fn = ipc_setfileinfo;
+	ops.qfileinfo_fn = ipc_qfileinfo;
+	ops.fsinfo_fn = ipc_fsinfo;
+	ops.lpq_fn = ipc_lpq;
+	ops.search_first_fn = ipc_search_first;
+	ops.search_next_fn = ipc_search_next;
+	ops.search_close_fn = ipc_search_close;
+	ops.trans_fn = ipc_trans;
+	ops.logoff_fn = ipc_logoff;
+	ops.async_setup_fn = ipc_async_setup;
+	ops.cancel_fn = ipc_cancel;
 
 	/* register ourselves with the NTVFS subsystem. */
 	ret = ntvfs_register(&ops, &vers);
diff --git a/source4/ntvfs/nbench/vfs_nbench.c b/source4/ntvfs/nbench/vfs_nbench.c
index 565f2dafed..74a9e43b6a 100644
--- a/source4/ntvfs/nbench/vfs_nbench.c
+++ b/source4/ntvfs/nbench/vfs_nbench.c
@@ -930,40 +930,40 @@ NTSTATUS ntvfs_nbench_init(void)
 	ops.type = NTVFS_DISK;
 	
 	/* fill in all the operations */
-	ops.connect = nbench_connect;
-	ops.disconnect = nbench_disconnect;
-	ops.unlink = nbench_unlink;
-	ops.chkpath = nbench_chkpath;
-	ops.qpathinfo = nbench_qpathinfo;
-	ops.setpathinfo = nbench_setpathinfo;
-	ops.open = nbench_open;
-	ops.mkdir = nbench_mkdir;
-	ops.rmdir = nbench_rmdir;
-	ops.rename = nbench_rename;
-	ops.copy = nbench_copy;
-	ops.ioctl = nbench_ioctl;
-	ops.read = nbench_read;
-	ops.write = nbench_write;
-	ops.seek = nbench_seek;
-	ops.flush = nbench_flush;	
-	ops.close = nbench_close;
-	ops.exit = nbench_exit;
-	ops.lock = nbench_lock;
-	ops.setfileinfo = nbench_setfileinfo;
-	ops.qfileinfo = nbench_qfileinfo;
-	ops.fsinfo = nbench_fsinfo;
-	ops.lpq = nbench_lpq;
-	ops.search_first = nbench_search_first;
-	ops.search_next = nbench_search_next;
-	ops.search_close = nbench_search_close;
-	ops.trans = nbench_trans;
-	ops.logoff = nbench_logoff;
-	ops.async_setup = nbench_async_setup;
-	ops.cancel = nbench_cancel;
+	ops.connect_fn = nbench_connect;
+	ops.disconnect_fn = nbench_disconnect;
+	ops.unlink_fn = nbench_unlink;
+	ops.chkpath_fn = nbench_chkpath;
+	ops.qpathinfo_fn = nbench_qpathinfo;
+	ops.setpathinfo_fn = nbench_setpathinfo;
+	ops.open_fn = nbench_open;
+	ops.mkdir_fn = nbench_mkdir;
+	ops.rmdir_fn = nbench_rmdir;
+	ops.rename_fn = nbench_rename;
+	ops.copy_fn = nbench_copy;
+	ops.ioctl_fn = nbench_ioctl;
+	ops.read_fn = nbench_read;
+	ops.write_fn = nbench_write;
+	ops.seek_fn = nbench_seek;
+	ops.flush_fn = nbench_flush;
+	ops.close_fn = nbench_close;
+	ops.exit_fn = nbench_exit;
+	ops.lock_fn = nbench_lock;
+	ops.setfileinfo_fn = nbench_setfileinfo;
+	ops.qfileinfo_fn = nbench_qfileinfo;
+	ops.fsinfo_fn = nbench_fsinfo;
+	ops.lpq_fn = nbench_lpq;
+	ops.search_first_fn = nbench_search_first;
+	ops.search_next_fn = nbench_search_next;
+	ops.search_close_fn = nbench_search_close;
+	ops.trans_fn = nbench_trans;
+	ops.logoff_fn = nbench_logoff;
+	ops.async_setup_fn = nbench_async_setup;
+	ops.cancel_fn = nbench_cancel;
 
 	/* we don't register a trans2 handler as we want to be able to
 	   log individual trans2 requests */
-	ops.trans2 = NULL;
+	ops.trans2_fn = NULL;
 
 	/* register ourselves with the NTVFS subsystem. */
 	ret = ntvfs_register(&ops, &vers);
diff --git a/source4/ntvfs/ntvfs.h b/source4/ntvfs/ntvfs.h
index 463acc3c80..02dc191f10 100644
--- a/source4/ntvfs/ntvfs.h
+++ b/source4/ntvfs/ntvfs.h
@@ -47,120 +47,120 @@ struct ntvfs_ops {
 	enum ntvfs_type type;
 
 	/* initial setup */
-	NTSTATUS (*connect)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*connect_fn)(struct ntvfs_module_context *ntvfs,
 			    struct ntvfs_request *req,
 			    union smb_tcon *tcon);
-	NTSTATUS (*disconnect)(struct ntvfs_module_context *ntvfs);
+	NTSTATUS (*disconnect_fn)(struct ntvfs_module_context *ntvfs);
 
 	/* async_setup - called when a backend is processing a async request */
-	NTSTATUS (*async_setup)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*async_setup_fn)(struct ntvfs_module_context *ntvfs,
 				struct ntvfs_request *req,
 				void *private_data);
 
 	/* filesystem operations */
-	NTSTATUS (*fsinfo)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*fsinfo_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req,
 			   union smb_fsinfo *fs);
 
 	/* path operations */
-	NTSTATUS (*unlink)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*unlink_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req,
 			   union smb_unlink *unl);
-	NTSTATUS (*chkpath)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*chkpath_fn)(struct ntvfs_module_context *ntvfs,
 			    struct ntvfs_request *req,
 			    union smb_chkpath *cp);
-	NTSTATUS (*qpathinfo)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*qpathinfo_fn)(struct ntvfs_module_context *ntvfs,
 			      struct ntvfs_request *req,
 			      union smb_fileinfo *st);
-	NTSTATUS (*setpathinfo)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*setpathinfo_fn)(struct ntvfs_module_context *ntvfs,
 				struct ntvfs_request *req,
 				union smb_setfileinfo *st);
-	NTSTATUS (*mkdir)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*mkdir_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  union smb_mkdir *md);
-	NTSTATUS (*rmdir)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*rmdir_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  struct smb_rmdir *rd);
-	NTSTATUS (*rename)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*rename_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req,
 			   union smb_rename *ren);
-	NTSTATUS (*copy)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*copy_fn)(struct ntvfs_module_context *ntvfs,
 			 struct ntvfs_request *req,
 			 struct smb_copy *cp);
-	NTSTATUS (*open)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*open_fn)(struct ntvfs_module_context *ntvfs,
 			 struct ntvfs_request *req,
 			 union smb_open *oi);
 
 	/* directory search */
-	NTSTATUS (*search_first)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*search_first_fn)(struct ntvfs_module_context *ntvfs,
 				 struct ntvfs_request *req,
 				 union smb_search_first *io, void *private_data,
-				 bool (*callback)(void *private_data, const union smb_search_data *file));
-	NTSTATUS (*search_next)(struct ntvfs_module_context *ntvfs,
+				 bool (*callback_fn)(void *private_data, const union smb_search_data *file));
+	NTSTATUS (*search_next_fn)(struct ntvfs_module_context *ntvfs,
 				struct ntvfs_request *req,
 				union smb_search_next *io, void *private_data,
-				bool (*callback)(void *private_data, const union smb_search_data *file));
-	NTSTATUS (*search_close)(struct ntvfs_module_context *ntvfs,
+				bool (*callback_fn)(void *private_data, const union smb_search_data *file));
+	NTSTATUS (*search_close_fn)(struct ntvfs_module_context *ntvfs,
 				 struct ntvfs_request *req,
 				 union smb_search_close *io);
 
 	/* operations on open files */
-	NTSTATUS (*ioctl)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*ioctl_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  union smb_ioctl *io);
-	NTSTATUS (*read)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*read_fn)(struct ntvfs_module_context *ntvfs,
 			 struct ntvfs_request *req,
 			 union smb_read *io);
-	NTSTATUS (*write)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*write_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  union smb_write *io);
-	NTSTATUS (*seek)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*seek_fn)(struct ntvfs_module_context *ntvfs,
 			 struct ntvfs_request *req,
 			 union smb_seek *io);
-	NTSTATUS (*flush)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*flush_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  union smb_flush *flush);
-	NTSTATUS (*lock)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*lock_fn)(struct ntvfs_module_context *ntvfs,
 			 struct ntvfs_request *req,
 			 union smb_lock *lck);
-	NTSTATUS (*qfileinfo)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*qfileinfo_fn)(struct ntvfs_module_context *ntvfs,
 			      struct ntvfs_request *req,
 			      union smb_fileinfo *info);
-	NTSTATUS (*setfileinfo)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*setfileinfo_fn)(struct ntvfs_module_context *ntvfs,
 				struct ntvfs_request *req,
 				union smb_setfileinfo *info);
-	NTSTATUS (*close)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*close_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  union smb_close *io);
 
 	/* trans interface - used by IPC backend for pipes and RAP calls */
-	NTSTATUS (*trans)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*trans_fn)(struct ntvfs_module_context *ntvfs,
 			  struct ntvfs_request *req,
 			  struct smb_trans2 *trans);
 
 	/* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
-	NTSTATUS (*trans2)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*trans2_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req,
 			   struct smb_trans2 *trans2);
 
 	/* change notify request */
-	NTSTATUS (*notify)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*notify_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req,
 			   union smb_notify *info);
 
 	/* cancel - cancels any pending async request */
-	NTSTATUS (*cancel)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*cancel_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req);
 
 	/* printing specific operations */
-	NTSTATUS (*lpq)(struct ntvfs_module_context *ntvfs, 
+	NTSTATUS (*lpq_fn)(struct ntvfs_module_context *ntvfs,
 			struct ntvfs_request *req,
 			union smb_lpq *lpq);
 
 	/* logoff - called when a vuid is closed */
-	NTSTATUS (*logoff)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*logoff_fn)(struct ntvfs_module_context *ntvfs,
 			   struct ntvfs_request *req);
-	NTSTATUS (*exit)(struct ntvfs_module_context *ntvfs,
+	NTSTATUS (*exit_fn)(struct ntvfs_module_context *ntvfs,
 			 struct ntvfs_request *req);
 };
 
diff --git a/source4/ntvfs/ntvfs_generic.c b/source4/ntvfs/ntvfs_generic.c
index bed9c9c755..0854aa30d3 100644
--- a/source4/ntvfs/ntvfs_generic.c
+++ b/source4/ntvfs/ntvfs_generic.c
@@ -255,7 +255,7 @@ static NTSTATUS ntvfs_map_open_finish(struct ntvfs_module_context *ntvfs,
 		sf->standard.in.create_time = 0;
 		sf->standard.in.write_time  = write_time;
 		sf->standard.in.access_time = 0;
-		status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
+		status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
 	}
 
 	if (set_size != 0) {
@@ -264,7 +264,7 @@ static NTSTATUS ntvfs_map_open_finish(struct ntvfs_module_context *ntvfs,
 		sf->generic.level            = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
 		sf->generic.in.file.ntvfs    = io2->generic.out.file.ntvfs;
 		sf->end_of_file_info.in.size = set_size;
-		status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
+		status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
 		if (NT_STATUS_IS_OK(status)) {
 			io->openx.out.size = io->openx.in.size;
 		}
@@ -416,7 +416,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.file_attr = io->openx.in.file_attrs;
 		io2->generic.in.fname = io->openx.in.fname;
 		
-		status = ntvfs->ops->open(ntvfs, req, io2);
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 		
 		
@@ -433,7 +433,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.file_attr = io->openold.in.search_attrs;
 		io2->generic.in.fname = io->openold.in.fname;
 
-		status = ntvfs->ops->open(ntvfs, req, io2);
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 
 	case RAW_OPEN_T2OPEN:
@@ -459,7 +459,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.ea_list->num_eas = io->t2open.in.num_eas;
 		io2->generic.in.ea_list->eas     = io->t2open.in.eas;
 
-		status = ntvfs->ops->open(ntvfs, req, io2);
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 
 	case RAW_OPEN_MKNEW:
@@ -472,7 +472,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.share_access = 
 			NTCREATEX_SHARE_ACCESS_READ | 
 			NTCREATEX_SHARE_ACCESS_WRITE;
-		status = ntvfs->ops->open(ntvfs, req, io2);
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 
 	case RAW_OPEN_CREATE:
@@ -485,7 +485,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.share_access = 
 			NTCREATEX_SHARE_ACCESS_READ | 
 			NTCREATEX_SHARE_ACCESS_WRITE;
-		status = ntvfs->ops->open(ntvfs, req, io2);
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 
 	case RAW_OPEN_CTEMP:
@@ -501,7 +501,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.share_access = 
 			NTCREATEX_SHARE_ACCESS_READ | 
 			NTCREATEX_SHARE_ACCESS_WRITE;
-		status = ntvfs->ops->open(ntvfs, req, io2);
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 	case RAW_OPEN_SMB2:
 		switch (io->smb2.in.oplock_level) {
@@ -549,7 +549,7 @@ NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
 		io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_SYNC_ALERT;
 		io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_ASYNC_ALERT;
 
-		status = ntvfs->ops->open(ntvfs, req, io2);		
+		status = ntvfs->ops->open_fn(ntvfs, req, io2);
 		break;
 
 	default:
@@ -700,7 +700,7 @@ NTSTATUS ntvfs_map_fsinfo(struct ntvfs_module_context *ntvfs,
 	/* ask the backend for the generic info */
 	fs2->generic.level = RAW_QFS_GENERIC;
 
-	status = ntvfs->ops->fsinfo(ntvfs, req, fs2);
+	status = ntvfs->ops->fsinfo_fn(ntvfs, req, fs2);
 	return ntvfs_map_async_finish(req, status);
 }
 
@@ -986,7 +986,7 @@ NTSTATUS ntvfs_map_qfileinfo(struct ntvfs_module_context *ntvfs,
 	info2->generic.level = RAW_FILEINFO_GENERIC;
 	info2->generic.in.file.ntvfs= info->generic.in.file.ntvfs;
 
-	status = ntvfs->ops->qfileinfo(ntvfs, req, info2);
+	status = ntvfs->ops->qfileinfo_fn(ntvfs, req, info2);
 	return ntvfs_map_async_finish(req, status);
 }
 
@@ -1035,7 +1035,7 @@ NTSTATUS ntvfs_map_qpathinfo(struct ntvfs_module_context *ntvfs,
 	info2->generic.level		= RAW_FILEINFO_GENERIC;
 	info2->generic.in.file.path	= info->generic.in.file.path;
 
-	status = ntvfs->ops->qpathinfo(ntvfs, req, info2);
+	status = ntvfs->ops->qpathinfo_fn(ntvfs, req, info2);
 	return ntvfs_map_async_finish(req, status);
 }
 
@@ -1179,7 +1179,7 @@ NTSTATUS ntvfs_map_lock(struct ntvfs_module_context *ntvfs,
 	 * as lock() doesn't have any output fields
 	 */
 
-	return ntvfs->ops->lock(ntvfs, req, lck2);
+	return ntvfs->ops->lock_fn(ntvfs, req, lck2);
 }
 
 
@@ -1222,7 +1222,7 @@ static NTSTATUS ntvfs_map_write_finish(struct ntvfs_module_context *ntvfs,
 			/* do the lock sync for now */
 			state = req->async_states->state;
 			req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
-			status = ntvfs->ops->lock(ntvfs, req, lck);
+			status = ntvfs->ops->lock_fn(ntvfs, req, lck);
 			req->async_states->state = state;
 		}
 		break;
@@ -1243,7 +1243,7 @@ static NTSTATUS ntvfs_map_write_finish(struct ntvfs_module_context *ntvfs,
 			/* do the close sync for now */
 			state = req->async_states->state;
 			req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
-			status = ntvfs->ops->close(ntvfs, req, cl);
+			status = ntvfs->ops->close_fn(ntvfs, req, cl);
 			req->async_states->state = state;
 		}
 		break;
@@ -1300,7 +1300,7 @@ NTSTATUS ntvfs_map_write(struct ntvfs_module_context *ntvfs,
 		wr2->writex.in.remaining = wr->write.in.remaining;
 		wr2->writex.in.count     = wr->write.in.count;
 		wr2->writex.in.data      = wr->write.in.data;
-		status = ntvfs->ops->write(ntvfs, req, wr2);
+		status = ntvfs->ops->write_fn(ntvfs, req, wr2);
 		break;
 
 	case RAW_WRITE_WRITEUNLOCK:
@@ -1310,7 +1310,7 @@ NTSTATUS ntvfs_map_write(struct ntvfs_module_context *ntvfs,
 		wr2->writex.in.remaining = wr->writeunlock.in.remaining;
 		wr2->writex.in.count     = wr->writeunlock.in.count;
 		wr2->writex.in.data      = wr->writeunlock.in.data;
-		status = ntvfs->ops->write(ntvfs, req, wr2);
+		status = ntvfs->ops->write_fn(ntvfs, req, wr2);
 		break;
 
 	case RAW_WRITE_WRITECLOSE:
@@ -1320,7 +1320,7 @@ NTSTATUS ntvfs_map_write(struct ntvfs_module_context *ntvfs,
 		wr2->writex.in.remaining = 0;
 		wr2->writex.in.count     = wr->writeclose.in.count;
 		wr2->writex.in.data      = wr->writeclose.in.data;
-		status = ntvfs->ops->write(ntvfs, req, wr2);
+		status = ntvfs->ops->write_fn(ntvfs, req, wr2);
 		break;
 
 	case RAW_WRITE_SPLWRITE:
@@ -1330,7 +1330,7 @@ NTSTATUS ntvfs_map_write(struct ntvfs_module_context *ntvfs,
 		wr2->writex.in.remaining = 0;
 		wr2->writex.in.count     = wr->splwrite.in.count;
 		wr2->writex.in.data      = wr->splwrite.in.data;
-		status = ntvfs->ops->write(ntvfs, req, wr2);
+		status = ntvfs->ops->write_fn(ntvfs, req, wr2);
 		break;
 
 	case RAW_WRITE_SMB2:
@@ -1340,7 +1340,7 @@ NTSTATUS ntvfs_map_write(struct ntvfs_module_context *ntvfs,
 		wr2->writex.in.remaining = 0;
 		wr2->writex.in.count     = wr->smb2.in.data.length;
 		wr2->writex.in.data      = wr->smb2.in.data.data;
-		status = ntvfs->ops->write(ntvfs, req, wr2);
+		status = ntvfs->ops->write_fn(ntvfs, req, wr2);
 	}
 
 	return ntvfs_map_async_finish(req, status);
@@ -1416,7 +1416,7 @@ NTSTATUS ntvfs_map_read(struct ntvfs_module_context *ntvfs,
 		rd2->readx.in.maxcnt    = rd->read.in.count;
 		rd2->readx.in.remaining = rd->read.in.remaining;
 		rd2->readx.out.data     = rd->read.out.data;
-		status = ntvfs->ops->read(ntvfs, req, rd2);
+		status = ntvfs->ops->read_fn(ntvfs, req, rd2);
 		break;
 
 	case RAW_READ_READBRAW:
@@ -1426,7 +1426,7 @@ NTSTATUS ntvfs_map_read(struct ntvfs_module_context *ntvfs,
 		rd2->readx.in.maxcnt    = rd->readbraw.in.maxcnt;
 		rd2->readx.in.remaining = 0;
 		rd2->readx.out.data     = rd->readbraw.out.data;
-		status = ntvfs->ops->read(ntvfs, req, rd2);
+		status = ntvfs->ops->read_fn(ntvfs, req, rd2);
 		break;
 
 	case RAW_READ_LOCKREAD:
@@ -1443,7 +1443,7 @@ NTSTATUS ntvfs_map_read(struct ntvfs_module_context *ntvfs,
 		lck->lock.in.file.ntvfs	= rd->lockread.in.file.ntvfs;
 		lck->lock.in.count	= rd->lockread.in.count;
 		lck->lock.in.offset	= rd->lockread.in.offset;
-		status = ntvfs->ops->lock(ntvfs, req, lck);
+		status = ntvfs->ops->lock_fn(ntvfs, req, lck);
 		req->async_states->state = state;
 
 		rd2->readx.in.file.ntvfs= rd->lockread.in.file.ntvfs;
@@ -1454,7 +1454,7 @@ NTSTATUS ntvfs_map_read(struct ntvfs_module_context *ntvfs,
 		rd2->readx.out.data     = rd->lockread.out.data;
 
 		if (NT_STATUS_IS_OK(status)) {
-			status = ntvfs->ops->read(ntvfs, req, rd2);
+			status = ntvfs->ops->read_fn(ntvfs, req, rd2);
 		}
 		break;
 
@@ -1465,7 +1465,7 @@ NTSTATUS ntvfs_map_read(struct ntvfs_module_context *ntvfs,
 		rd2->readx.in.maxcnt    = rd->smb2.in.length;
 		rd2->readx.in.remaining = 0;
 		rd2->readx.out.data     = rd->smb2.out.data.data;
-		status = ntvfs->ops->read(ntvfs, req, rd2);
+		status = ntvfs->ops->read_fn(ntvfs, req, rd2);
 		break;
 	}
 
@@ -1549,7 +1549,7 @@ NTSTATUS ntvfs_map_close(struct ntvfs_module_context *ntvfs,
 				       (second_stage_t)ntvfs_map_close_finish);
 	NT_STATUS_NOT_OK_RETURN(status);
 
-	status = ntvfs->ops->close(ntvfs, req, cl2);
+	status = ntvfs->ops->close_fn(ntvfs, req, cl2);
 
 	return ntvfs_map_async_finish(req, status);
 }
@@ -1611,7 +1611,7 @@ NTSTATUS ntvfs_map_notify(struct ntvfs_module_context *ntvfs,
 		nt2->nttrans.in.buffer_size		= nt->smb2.in.buffer_size;
 		nt2->nttrans.in.completion_filter	= nt->smb2.in.completion_filter;
 		nt2->nttrans.in.recursive		= nt->smb2.in.recursive;
-		status = ntvfs->ops->notify(ntvfs, req, nt2);
+		status = ntvfs->ops->notify_fn(ntvfs, req, nt2);
 		break;
 	}
 
diff --git a/source4/ntvfs/ntvfs_interface.c b/source4/ntvfs/ntvfs_interface.c
index 608db13417..005da0b8e2 100644
--- a/source4/ntvfs/ntvfs_interface.c
+++ b/source4/ntvfs/ntvfs_interface.c
@@ -26,10 +26,10 @@
 NTSTATUS ntvfs_connect(struct ntvfs_request *req, union smb_tcon *tcon)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->connect) {
+	if (!ntvfs->ops->connect_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->connect(ntvfs, req, tcon);
+	return ntvfs->ops->connect_fn(ntvfs, req, tcon);
 }
 
 NTSTATUS ntvfs_disconnect(struct ntvfs_context *ntvfs_ctx)
@@ -39,10 +39,10 @@ NTSTATUS ntvfs_disconnect(struct ntvfs_context *ntvfs_ctx)
 		return NT_STATUS_INVALID_CONNECTION;
 	}
 	ntvfs = ntvfs_ctx->modules;
-	if (!ntvfs->ops->disconnect) {
+	if (!ntvfs->ops->disconnect_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->disconnect(ntvfs);
+	return ntvfs->ops->disconnect_fn(ntvfs);
 }
 
 /* async setup - called by a backend that wants to setup any state for
@@ -50,102 +50,102 @@ NTSTATUS ntvfs_disconnect(struct ntvfs_context *ntvfs_ctx)
 NTSTATUS ntvfs_async_setup(struct ntvfs_request *req, void *private_data)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->async_setup) {
+	if (!ntvfs->ops->async_setup_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->async_setup(ntvfs, req, private_data);
+	return ntvfs->ops->async_setup_fn(ntvfs, req, private_data);
 }
 
 /* filesystem operations */
 NTSTATUS ntvfs_fsinfo(struct ntvfs_request *req, union smb_fsinfo *fs)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->fsinfo) {
+	if (!ntvfs->ops->fsinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->fsinfo(ntvfs, req, fs);
+	return ntvfs->ops->fsinfo_fn(ntvfs, req, fs);
 }
 
 /* path operations */
 NTSTATUS ntvfs_unlink(struct ntvfs_request *req, union smb_unlink *unl)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->unlink) {
+	if (!ntvfs->ops->unlink_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->unlink(ntvfs, req, unl);
+	return ntvfs->ops->unlink_fn(ntvfs, req, unl);
 }
 
 NTSTATUS ntvfs_chkpath(struct ntvfs_request *req, union smb_chkpath *cp)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->chkpath) {
+	if (!ntvfs->ops->chkpath_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->chkpath(ntvfs, req, cp);
+	return ntvfs->ops->chkpath_fn(ntvfs, req, cp);
 }
 
 NTSTATUS ntvfs_qpathinfo(struct ntvfs_request *req, union smb_fileinfo *st)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->qpathinfo) {
+	if (!ntvfs->ops->qpathinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->qpathinfo(ntvfs, req, st);
+	return ntvfs->ops->qpathinfo_fn(ntvfs, req, st);
 }
 
 NTSTATUS ntvfs_setpathinfo(struct ntvfs_request *req, union smb_setfileinfo *st)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->setpathinfo) {
+	if (!ntvfs->ops->setpathinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->setpathinfo(ntvfs, req, st);
+	return ntvfs->ops->setpathinfo_fn(ntvfs, req, st);
 }
 
 NTSTATUS ntvfs_open(struct ntvfs_request *req, union smb_open *oi)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->open) {
+	if (!ntvfs->ops->open_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->open(ntvfs, req, oi);
+	return ntvfs->ops->open_fn(ntvfs, req, oi);
 }
 
 NTSTATUS ntvfs_mkdir(struct ntvfs_request *req, union smb_mkdir *md)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->mkdir) {
+	if (!ntvfs->ops->mkdir_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->mkdir(ntvfs, req, md);
+	return ntvfs->ops->mkdir_fn(ntvfs, req, md);
 }
 
 NTSTATUS ntvfs_rmdir(struct ntvfs_request *req, struct smb_rmdir *rd)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->rmdir) {
+	if (!ntvfs->ops->rmdir_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->rmdir(ntvfs, req, rd);
+	return ntvfs->ops->rmdir_fn(ntvfs, req, rd);
 }
 
 NTSTATUS ntvfs_rename(struct ntvfs_request *req, union smb_rename *ren)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->rename) {
+	if (!ntvfs->ops->rename_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->rename(ntvfs, req, ren);
+	return ntvfs->ops->rename_fn(ntvfs, req, ren);
 }
 
 NTSTATUS ntvfs_copy(struct ntvfs_request *req, struct smb_copy *cp)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->copy) {
+	if (!ntvfs->ops->copy_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->copy(ntvfs, req, cp);
+	return ntvfs->ops->copy_fn(ntvfs, req, cp);
 }
 
 /* directory search */
@@ -153,161 +153,161 @@ NTSTATUS ntvfs_search_first(struct ntvfs_request *req, union smb_search_first *i
 				     bool ntvfs_callback(void *private_data, const union smb_search_data *file))
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->search_first) {
+	if (!ntvfs->ops->search_first_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->search_first(ntvfs, req, io, private_data, ntvfs_callback);
+	return ntvfs->ops->search_first_fn(ntvfs, req, io, private_data, ntvfs_callback);
 }
 
 NTSTATUS ntvfs_search_next(struct ntvfs_request *req, union smb_search_next *io, void *private_data,
 				    bool ntvfs_callback(void *private_data, const union smb_search_data *file))
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->search_next) {
+	if (!ntvfs->ops->search_next_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->search_next(ntvfs, req, io, private_data, ntvfs_callback);
+	return ntvfs->ops->search_next_fn(ntvfs, req, io, private_data, ntvfs_callback);
 }
 
 NTSTATUS ntvfs_search_close(struct ntvfs_request *req, union smb_search_close *io)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->search_close) {
+	if (!ntvfs->ops->search_close_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->search_close(ntvfs, req, io);
+	return ntvfs->ops->search_close_fn(ntvfs, req, io);
 }
 
 /* operations on open files */
 NTSTATUS ntvfs_ioctl(struct ntvfs_request *req, union smb_ioctl *io)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->ioctl) {
+	if (!ntvfs->ops->ioctl_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->ioctl(ntvfs, req, io);
+	return ntvfs->ops->ioctl_fn(ntvfs, req, io);
 }
 
 NTSTATUS ntvfs_read(struct ntvfs_request *req, union smb_read *io)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->read) {
+	if (!ntvfs->ops->read_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->read(ntvfs, req, io);
+	return ntvfs->ops->read_fn(ntvfs, req, io);
 }
 
 NTSTATUS ntvfs_write(struct ntvfs_request *req, union smb_write *io)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->write) {
+	if (!ntvfs->ops->write_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->write(ntvfs, req, io);
+	return ntvfs->ops->write_fn(ntvfs, req, io);
 }
 
 NTSTATUS ntvfs_seek(struct ntvfs_request *req, union smb_seek *io)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->seek) {
+	if (!ntvfs->ops->seek_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->seek(ntvfs, req, io);
+	return ntvfs->ops->seek_fn(ntvfs, req, io);
 }
 
 NTSTATUS ntvfs_flush(struct ntvfs_request *req,
 			      union smb_flush *flush)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->flush) {
+	if (!ntvfs->ops->flush_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->flush(ntvfs, req, flush);
+	return ntvfs->ops->flush_fn(ntvfs, req, flush);
 }
 
 NTSTATUS ntvfs_lock(struct ntvfs_request *req, union smb_lock *lck)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->lock) {
+	if (!ntvfs->ops->lock_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->lock(ntvfs, req, lck);
+	return ntvfs->ops->lock_fn(ntvfs, req, lck);
 }
 
 NTSTATUS ntvfs_qfileinfo(struct ntvfs_request *req, union smb_fileinfo *info)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->qfileinfo) {
+	if (!ntvfs->ops->qfileinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->qfileinfo(ntvfs, req, info);
+	return ntvfs->ops->qfileinfo_fn(ntvfs, req, info);
 }
 
 NTSTATUS ntvfs_setfileinfo(struct ntvfs_request *req, union smb_setfileinfo *info)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->setfileinfo) {
+	if (!ntvfs->ops->setfileinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->setfileinfo(ntvfs, req, info);
+	return ntvfs->ops->setfileinfo_fn(ntvfs, req, info);
 }
 
 NTSTATUS ntvfs_close(struct ntvfs_request *req, union smb_close *io)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->close) {
+	if (!ntvfs->ops->close_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->close(ntvfs, req, io);
+	return ntvfs->ops->close_fn(ntvfs, req, io);
 }
 
 /* trans interface - used by IPC backend for pipes and RAP calls */
 NTSTATUS ntvfs_trans(struct ntvfs_request *req, struct smb_trans2 *trans)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->trans) {
+	if (!ntvfs->ops->trans_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->trans(ntvfs, req, trans);
+	return ntvfs->ops->trans_fn(ntvfs, req, trans);
 }
 
 /* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
 NTSTATUS ntvfs_trans2(struct ntvfs_request *req, struct smb_trans2 *trans2)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->trans2) {
+	if (!ntvfs->ops->trans2_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->trans2(ntvfs, req, trans2);
+	return ntvfs->ops->trans2_fn(ntvfs, req, trans2);
 }
 
 /* printing specific operations */
 NTSTATUS ntvfs_lpq(struct ntvfs_request *req, union smb_lpq *lpq)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->lpq) {
+	if (!ntvfs->ops->lpq_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->lpq(ntvfs, req, lpq);
+	return ntvfs->ops->lpq_fn(ntvfs, req, lpq);
 }
 
 /* logoff - called when a vuid is closed */
 NTSTATUS ntvfs_logoff(struct ntvfs_request *req)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->logoff) {
+	if (!ntvfs->ops->logoff_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->logoff(ntvfs, req);
+	return ntvfs->ops->logoff_fn(ntvfs, req);
 }
 
 NTSTATUS ntvfs_exit(struct ntvfs_request *req)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->exit) {
+	if (!ntvfs->ops->exit_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->exit(ntvfs, req);
+	return ntvfs->ops->exit_fn(ntvfs, req);
 }
 
 /*
@@ -316,10 +316,10 @@ NTSTATUS ntvfs_exit(struct ntvfs_request *req)
 NTSTATUS ntvfs_notify(struct ntvfs_request *req, union smb_notify *info)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->notify) {
+	if (!ntvfs->ops->notify_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->notify(ntvfs, req, info);
+	return ntvfs->ops->notify_fn(ntvfs, req, info);
 }
 
 /*
@@ -328,10 +328,10 @@ NTSTATUS ntvfs_notify(struct ntvfs_request *req, union smb_notify *info)
 NTSTATUS ntvfs_cancel(struct ntvfs_request *req)
 {
 	struct ntvfs_module_context *ntvfs = req->ctx->modules;
-	if (!ntvfs->ops->cancel) {
+	if (!ntvfs->ops->cancel_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->ops->cancel(ntvfs, req);
+	return ntvfs->ops->cancel_fn(ntvfs, req);
 }
 
 /* initial setup */
@@ -339,18 +339,18 @@ NTSTATUS ntvfs_next_connect(struct ntvfs_module_context *ntvfs,
 				     struct ntvfs_request *req,
 				     union smb_tcon *tcon)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->connect) {
+	if (!ntvfs->next || !ntvfs->next->ops->connect_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->connect(ntvfs->next, req, tcon);
+	return ntvfs->next->ops->connect_fn(ntvfs->next, req, tcon);
 }
 
 NTSTATUS ntvfs_next_disconnect(struct ntvfs_module_context *ntvfs)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->disconnect) {
+	if (!ntvfs->next || !ntvfs->next->ops->disconnect_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->disconnect(ntvfs->next);
+	return ntvfs->next->ops->disconnect_fn(ntvfs->next);
 }
 
 /* async_setup - called when setting up for a async request */
@@ -358,10 +358,10 @@ NTSTATUS ntvfs_next_async_setup(struct ntvfs_module_context *ntvfs,
 					 struct ntvfs_request *req, 
 					 void *private_data)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->async_setup) {
+	if (!ntvfs->next || !ntvfs->next->ops->async_setup_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->async_setup(ntvfs->next, req, private_data);
+	return ntvfs->next->ops->async_setup_fn(ntvfs->next, req, private_data);
 }
 
 /* filesystem operations */
@@ -369,10 +369,10 @@ NTSTATUS ntvfs_next_fsinfo(struct ntvfs_module_context *ntvfs,
 				    struct ntvfs_request *req,
 				    union smb_fsinfo *fs)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->fsinfo) {
+	if (!ntvfs->next || !ntvfs->next->ops->fsinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->fsinfo(ntvfs->next, req, fs);
+	return ntvfs->next->ops->fsinfo_fn(ntvfs->next, req, fs);
 }
 
 /* path operations */
@@ -380,90 +380,90 @@ NTSTATUS ntvfs_next_unlink(struct ntvfs_module_context *ntvfs,
 				    struct ntvfs_request *req,
 				    union smb_unlink *unl)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->unlink) {
+	if (!ntvfs->next || !ntvfs->next->ops->unlink_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->unlink(ntvfs->next, req, unl);
+	return ntvfs->next->ops->unlink_fn(ntvfs->next, req, unl);
 }
 
 NTSTATUS ntvfs_next_chkpath(struct ntvfs_module_context *ntvfs, 
 				     struct ntvfs_request *req,
 				     union smb_chkpath *cp)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->chkpath) {
+	if (!ntvfs->next || !ntvfs->next->ops->chkpath_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->chkpath(ntvfs->next, req, cp);
+	return ntvfs->next->ops->chkpath_fn(ntvfs->next, req, cp);
 }
 
 NTSTATUS ntvfs_next_qpathinfo(struct ntvfs_module_context *ntvfs, 
 				       struct ntvfs_request *req,
 				       union smb_fileinfo *st)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->qpathinfo) {
+	if (!ntvfs->next || !ntvfs->next->ops->qpathinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->qpathinfo(ntvfs->next, req, st);
+	return ntvfs->next->ops->qpathinfo_fn(ntvfs->next, req, st);
 }
 
 NTSTATUS ntvfs_next_setpathinfo(struct ntvfs_module_context *ntvfs, 
 					 struct ntvfs_request *req,
 					 union smb_setfileinfo *st)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->setpathinfo) {
+	if (!ntvfs->next || !ntvfs->next->ops->setpathinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->setpathinfo(ntvfs->next, req, st);
+	return ntvfs->next->ops->setpathinfo_fn(ntvfs->next, req, st);
 }
 
 NTSTATUS ntvfs_next_mkdir(struct ntvfs_module_context *ntvfs, 
 				   struct ntvfs_request *req,
 				   union smb_mkdir *md)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->mkdir) {
+	if (!ntvfs->next || !ntvfs->next->ops->mkdir_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->mkdir(ntvfs->next, req, md);
+	return ntvfs->next->ops->mkdir_fn(ntvfs->next, req, md);
 }
 
 NTSTATUS ntvfs_next_rmdir(struct ntvfs_module_context *ntvfs, 
 				   struct ntvfs_request *req,
 				   struct smb_rmdir *rd)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->rmdir) {
+	if (!ntvfs->next || !ntvfs->next->ops->rmdir_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->rmdir(ntvfs->next, req, rd);
+	return ntvfs->next->ops->rmdir_fn(ntvfs->next, req, rd);
 }
 
 NTSTATUS ntvfs_next_rename(struct ntvfs_module_context *ntvfs, 
 				    struct ntvfs_request *req,
 				    union smb_rename *ren)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->rename) {
+	if (!ntvfs->next || !ntvfs->next->ops->rename_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->rename(ntvfs->next, req, ren);
+	return ntvfs->next->ops->rename_fn(ntvfs->next, req, ren);
 }
 
 NTSTATUS ntvfs_next_copy(struct ntvfs_module_context *ntvfs, 
 				  struct ntvfs_request *req,
 				  struct smb_copy *cp)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->copy) {
+	if (!ntvfs->next || !ntvfs->next->ops->copy_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->copy(ntvfs->next, req, cp);
+	return ntvfs->next->ops->copy_fn(ntvfs->next, req, cp);
 }
 
 NTSTATUS ntvfs_next_open(struct ntvfs_module_context *ntvfs, 
 				  struct ntvfs_request *req,
 				  union smb_open *oi)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->open) {
+	if (!ntvfs->next || !ntvfs->next->ops->open_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->open(ntvfs->next, req, oi);
+	return ntvfs->next->ops->open_fn(ntvfs->next, req, oi);
 }
 
 
@@ -473,10 +473,10 @@ NTSTATUS ntvfs_next_search_first(struct ntvfs_module_context *ntvfs,
 					  union smb_search_first *io, void *private_data,
 					  bool (*callback)(void *private_data, const union smb_search_data *file))
 {
-	if (!ntvfs->next || !ntvfs->next->ops->search_first) {
+	if (!ntvfs->next || !ntvfs->next->ops->search_first_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->search_first(ntvfs->next, req, io, private_data, callback);
+	return ntvfs->next->ops->search_first_fn(ntvfs->next, req, io, private_data, callback);
 }
 
 NTSTATUS ntvfs_next_search_next(struct ntvfs_module_context *ntvfs, 
@@ -484,20 +484,20 @@ NTSTATUS ntvfs_next_search_next(struct ntvfs_module_context *ntvfs,
 					 union smb_search_next *io, void *private_data,
 					 bool (*callback)(void *private_data, const union smb_search_data *file))
 {
-	if (!ntvfs->next || !ntvfs->next->ops->search_next) {
+	if (!ntvfs->next || !ntvfs->next->ops->search_next_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->search_next(ntvfs->next, req, io, private_data, callback);
+	return ntvfs->next->ops->search_next_fn(ntvfs->next, req, io, private_data, callback);
 }
 
 NTSTATUS ntvfs_next_search_close(struct ntvfs_module_context *ntvfs, 
 					  struct ntvfs_request *req,
 					  union smb_search_close *io)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->search_close) {
+	if (!ntvfs->next || !ntvfs->next->ops->search_close_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->search_close(ntvfs->next, req, io);
+	return ntvfs->next->ops->search_close_fn(ntvfs->next, req, io);
 }
 
 /* operations on open files */
@@ -505,90 +505,90 @@ NTSTATUS ntvfs_next_ioctl(struct ntvfs_module_context *ntvfs,
 				   struct ntvfs_request *req,
 				   union smb_ioctl *io)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->ioctl) {
+	if (!ntvfs->next || !ntvfs->next->ops->ioctl_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->ioctl(ntvfs->next, req, io);
+	return ntvfs->next->ops->ioctl_fn(ntvfs->next, req, io);
 }
 
 NTSTATUS ntvfs_next_read(struct ntvfs_module_context *ntvfs, 
 				  struct ntvfs_request *req,
 				  union smb_read *io)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->read) {
+	if (!ntvfs->next || !ntvfs->next->ops->read_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->read(ntvfs->next, req, io);
+	return ntvfs->next->ops->read_fn(ntvfs->next, req, io);
 }
 
 NTSTATUS ntvfs_next_write(struct ntvfs_module_context *ntvfs, 
 				   struct ntvfs_request *req,
 				   union smb_write *io)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->write) {
+	if (!ntvfs->next || !ntvfs->next->ops->write_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->write(ntvfs->next, req, io);
+	return ntvfs->next->ops->write_fn(ntvfs->next, req, io);
 }
 
 NTSTATUS ntvfs_next_seek(struct ntvfs_module_context *ntvfs, 
 				  struct ntvfs_request *req,
 				  union smb_seek *io)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->seek) {
+	if (!ntvfs->next || !ntvfs->next->ops->seek_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->seek(ntvfs->next, req, io);
+	return ntvfs->next->ops->seek_fn(ntvfs->next, req, io);
 }
 
 NTSTATUS ntvfs_next_flush(struct ntvfs_module_context *ntvfs, 
 				   struct ntvfs_request *req,
 				   union smb_flush *flush)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->flush) {
+	if (!ntvfs->next || !ntvfs->next->ops->flush_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->flush(ntvfs->next, req, flush);
+	return ntvfs->next->ops->flush_fn(ntvfs->next, req, flush);
 }
 
 NTSTATUS ntvfs_next_lock(struct ntvfs_module_context *ntvfs, 
 				  struct ntvfs_request *req,
 				  union smb_lock *lck)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->lock) {
+	if (!ntvfs->next || !ntvfs->next->ops->lock_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->lock(ntvfs->next, req, lck);
+	return ntvfs->next->ops->lock_fn(ntvfs->next, req, lck);
 }
 
 NTSTATUS ntvfs_next_qfileinfo(struct ntvfs_module_context *ntvfs, 
 				       struct ntvfs_request *req,
 				       union smb_fileinfo *info)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->qfileinfo) {
+	if (!ntvfs->next || !ntvfs->next->ops->qfileinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->qfileinfo(ntvfs->next, req, info);
+	return ntvfs->next->ops->qfileinfo_fn(ntvfs->next, req, info);
 }
 
 NTSTATUS ntvfs_next_setfileinfo(struct ntvfs_module_context *ntvfs, 
 					 struct ntvfs_request *req,
 					 union smb_setfileinfo *info)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->setfileinfo) {
+	if (!ntvfs->next || !ntvfs->next->ops->setfileinfo_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->setfileinfo(ntvfs->next, req, info);
+	return ntvfs->next->ops->setfileinfo_fn(ntvfs->next, req, info);
 }
 
 NTSTATUS ntvfs_next_close(struct ntvfs_module_context *ntvfs, 
 				   struct ntvfs_request *req,
 				   union smb_close *io)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->close) {
+	if (!ntvfs->next || !ntvfs->next->ops->close_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->close(ntvfs->next, req, io);
+	return ntvfs->next->ops->close_fn(ntvfs->next, req, io);
 }
 
 /* trans interface - used by IPC backend for pipes and RAP calls */
@@ -596,10 +596,10 @@ NTSTATUS ntvfs_next_trans(struct ntvfs_module_context *ntvfs,
 				   struct ntvfs_request *req,
 				   struct smb_trans2 *trans)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->trans) {
+	if (!ntvfs->next || !ntvfs->next->ops->trans_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->trans(ntvfs->next, req, trans);
+	return ntvfs->next->ops->trans_fn(ntvfs->next, req, trans);
 }
 
 /* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
@@ -607,10 +607,10 @@ NTSTATUS ntvfs_next_trans2(struct ntvfs_module_context *ntvfs,
 				    struct ntvfs_request *req,
 				    struct smb_trans2 *trans2)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->trans2) {
+	if (!ntvfs->next || !ntvfs->next->ops->trans2_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->trans2(ntvfs->next, req, trans2);
+	return ntvfs->next->ops->trans2_fn(ntvfs->next, req, trans2);
 }
 
 /*
@@ -620,20 +620,20 @@ NTSTATUS ntvfs_next_notify(struct ntvfs_module_context *ntvfs,
 				    struct ntvfs_request *req,
 				    union smb_notify *info)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->notify) {
+	if (!ntvfs->next || !ntvfs->next->ops->notify_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->notify(ntvfs->next, req, info);
+	return ntvfs->next->ops->notify_fn(ntvfs->next, req, info);
 }
 
 /* cancel - called to cancel an outstanding async request */
 NTSTATUS ntvfs_next_cancel(struct ntvfs_module_context *ntvfs, 
 				    struct ntvfs_request *req)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->cancel) {
+	if (!ntvfs->next || !ntvfs->next->ops->cancel_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->cancel(ntvfs->next, req);
+	return ntvfs->next->ops->cancel_fn(ntvfs->next, req);
 }
 
 /* printing specific operations */
@@ -641,10 +641,10 @@ NTSTATUS ntvfs_next_lpq(struct ntvfs_module_context *ntvfs,
 				 struct ntvfs_request *req,
 				 union smb_lpq *lpq)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->lpq) {
+	if (!ntvfs->next || !ntvfs->next->ops->lpq_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->lpq(ntvfs->next, req, lpq);
+	return ntvfs->next->ops->lpq_fn(ntvfs->next, req, lpq);
 }
 
 
@@ -652,19 +652,19 @@ NTSTATUS ntvfs_next_lpq(struct ntvfs_module_context *ntvfs,
 NTSTATUS ntvfs_next_logoff(struct ntvfs_module_context *ntvfs, 
 				    struct ntvfs_request *req)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->logoff) {
+	if (!ntvfs->next || !ntvfs->next->ops->logoff_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->logoff(ntvfs->next, req);
+	return ntvfs->next->ops->logoff_fn(ntvfs->next, req);
 }
 
 NTSTATUS ntvfs_next_exit(struct ntvfs_module_context *ntvfs, 
 				  struct ntvfs_request *req)
 {
-	if (!ntvfs->next || !ntvfs->next->ops->exit) {
+	if (!ntvfs->next || !ntvfs->next->ops->exit_fn) {
 		return NT_STATUS_NOT_IMPLEMENTED;
 	}
-	return ntvfs->next->ops->exit(ntvfs->next, req);
+	return ntvfs->next->ops->exit_fn(ntvfs->next, req);
 }
 
 /* client connection callback */
diff --git a/source4/ntvfs/posix/vfs_posix.c b/source4/ntvfs/posix/vfs_posix.c
index 3a3d1ea1c5..2ca024b618 100644
--- a/source4/ntvfs/posix/vfs_posix.c
+++ b/source4/ntvfs/posix/vfs_posix.c
@@ -373,37 +373,37 @@ NTSTATUS ntvfs_posix_init(void)
 	ops.type = NTVFS_DISK;
 	
 	/* fill in all the operations */
-	ops.connect = pvfs_connect;
-	ops.disconnect = pvfs_disconnect;
-	ops.unlink = pvfs_unlink;
-	ops.chkpath = pvfs_chkpath;
-	ops.qpathinfo = pvfs_qpathinfo;
-	ops.setpathinfo = pvfs_setpathinfo;
-	ops.open = pvfs_open;
-	ops.mkdir = pvfs_mkdir;
-	ops.rmdir = pvfs_rmdir;
-	ops.rename = pvfs_rename;
-	ops.copy = pvfs_copy;
-	ops.ioctl = pvfs_ioctl;
-	ops.read = pvfs_read;
-	ops.write = pvfs_write;
-	ops.seek = pvfs_seek;
-	ops.flush = pvfs_flush;	
-	ops.close = pvfs_close;
-	ops.exit = pvfs_exit;
-	ops.lock = pvfs_lock;
-	ops.setfileinfo = pvfs_setfileinfo;
-	ops.qfileinfo = pvfs_qfileinfo;
-	ops.fsinfo = pvfs_fsinfo;
-	ops.lpq = pvfs_lpq;
-	ops.search_first = pvfs_search_first;
-	ops.search_next = pvfs_search_next;
-	ops.search_close = pvfs_search_close;
-	ops.trans = pvfs_trans;
-	ops.logoff = pvfs_logoff;
-	ops.async_setup = pvfs_async_setup;
-	ops.cancel = pvfs_cancel;
-	ops.notify = pvfs_notify;
+	ops.connect_fn = pvfs_connect;
+	ops.disconnect_fn = pvfs_disconnect;
+	ops.unlink_fn = pvfs_unlink;
+	ops.chkpath_fn = pvfs_chkpath;
+	ops.qpathinfo_fn = pvfs_qpathinfo;
+	ops.setpathinfo_fn = pvfs_setpathinfo;
+	ops.open_fn = pvfs_open;
+	ops.mkdir_fn = pvfs_mkdir;
+	ops.rmdir_fn = pvfs_rmdir;
+	ops.rename_fn = pvfs_rename;
+	ops.copy_fn = pvfs_copy;
+	ops.ioctl_fn = pvfs_ioctl;
+	ops.read_fn = pvfs_read;
+	ops.write_fn = pvfs_write;
+	ops.seek_fn = pvfs_seek;
+	ops.flush_fn = pvfs_flush;
+	ops.close_fn = pvfs_close;
+	ops.exit_fn = pvfs_exit;
+	ops.lock_fn = pvfs_lock;
+	ops.setfileinfo_fn = pvfs_setfileinfo;
+	ops.qfileinfo_fn = pvfs_qfileinfo;
+	ops.fsinfo_fn = pvfs_fsinfo;
+	ops.lpq_fn = pvfs_lpq;
+	ops.search_first_fn = pvfs_search_first;
+	ops.search_next_fn = pvfs_search_next;
+	ops.search_close_fn = pvfs_search_close;
+	ops.trans_fn = pvfs_trans;
+	ops.logoff_fn = pvfs_logoff;
+	ops.async_setup_fn = pvfs_async_setup;
+	ops.cancel_fn = pvfs_cancel;
+	ops.notify_fn = pvfs_notify;
 
 	/* register ourselves with the NTVFS subsystem. We register
 	   under the name 'default' as we wish to be the default
diff --git a/source4/ntvfs/print/vfs_print.c b/source4/ntvfs/print/vfs_print.c
index 6019e44132..829fa7877e 100644
--- a/source4/ntvfs/print/vfs_print.c
+++ b/source4/ntvfs/print/vfs_print.c
@@ -115,10 +115,10 @@ NTSTATUS ntvfs_print_init(void)
 	ops.type = NTVFS_PRINT;
 	
 	/* fill in all the operations */
-	ops.connect = print_connect;
-	ops.disconnect = print_disconnect;
-	ops.unlink = print_unlink;
-	ops.ioctl = print_ioctl;
+	ops.connect_fn = print_connect;
+	ops.disconnect_fn = print_disconnect;
+	ops.unlink_fn = print_unlink;
+	ops.ioctl_fn = print_ioctl;
 
 	/* register ourselves with the NTVFS subsystem. We register under the name 'default'
 	   as we wish to be the default backend */
diff --git a/source4/ntvfs/simple/vfs_simple.c b/source4/ntvfs/simple/vfs_simple.c
index 7ae41db521..58c8df8dd5 100644
--- a/source4/ntvfs/simple/vfs_simple.c
+++ b/source4/ntvfs/simple/vfs_simple.c
@@ -1058,36 +1058,36 @@ NTSTATUS ntvfs_simple_init(void)
 	ZERO_STRUCT(ops);
 
 	/* fill in all the operations */
-	ops.connect = svfs_connect;
-	ops.disconnect = svfs_disconnect;
-	ops.unlink = svfs_unlink;
-	ops.chkpath = svfs_chkpath;
-	ops.qpathinfo = svfs_qpathinfo;
-	ops.setpathinfo = svfs_setpathinfo;
-	ops.open = svfs_open;
-	ops.mkdir = svfs_mkdir;
-	ops.rmdir = svfs_rmdir;
-	ops.rename = svfs_rename;
-	ops.copy = svfs_copy;
-	ops.ioctl = svfs_ioctl;
-	ops.read = svfs_read;
-	ops.write = svfs_write;
-	ops.seek = svfs_seek;
-	ops.flush = svfs_flush;	
-	ops.close = svfs_close;
-	ops.exit = svfs_exit;
-	ops.lock = svfs_lock;
-	ops.setfileinfo = svfs_setfileinfo;
-	ops.qfileinfo = svfs_qfileinfo;
-	ops.fsinfo = svfs_fsinfo;
-	ops.lpq = svfs_lpq;
-	ops.search_first = svfs_search_first;
-	ops.search_next = svfs_search_next;
-	ops.search_close = svfs_search_close;
-	ops.trans = svfs_trans;
-	ops.logoff = svfs_logoff;
-	ops.async_setup = svfs_async_setup;
-	ops.cancel = svfs_cancel;
+	ops.connect_fn = svfs_connect;
+	ops.disconnect_fn = svfs_disconnect;
+	ops.unlink_fn = svfs_unlink;
+	ops.chkpath_fn = svfs_chkpath;
+	ops.qpathinfo_fn = svfs_qpathinfo;
+	ops.setpathinfo_fn = svfs_setpathinfo;
+	ops.open_fn = svfs_open;
+	ops.mkdir_fn = svfs_mkdir;
+	ops.rmdir_fn = svfs_rmdir;
+	ops.rename_fn = svfs_rename;
+	ops.copy_fn = svfs_copy;
+	ops.ioctl_fn = svfs_ioctl;
+	ops.read_fn = svfs_read;
+	ops.write_fn = svfs_write;
+	ops.seek_fn = svfs_seek;
+	ops.flush_fn = svfs_flush;
+	ops.close_fn = svfs_close;
+	ops.exit_fn = svfs_exit;
+	ops.lock_fn = svfs_lock;
+	ops.setfileinfo_fn = svfs_setfileinfo;
+	ops.qfileinfo_fn = svfs_qfileinfo;
+	ops.fsinfo_fn = svfs_fsinfo;
+	ops.lpq_fn = svfs_lpq;
+	ops.search_first_fn = svfs_search_first;
+	ops.search_next_fn = svfs_search_next;
+	ops.search_close_fn = svfs_search_close;
+	ops.trans_fn = svfs_trans;
+	ops.logoff_fn = svfs_logoff;
+	ops.async_setup_fn = svfs_async_setup;
+	ops.cancel_fn = svfs_cancel;
 
 	/* register ourselves with the NTVFS subsystem. We register
 	   under names 'simple'
diff --git a/source4/ntvfs/smb2/vfs_smb2.c b/source4/ntvfs/smb2/vfs_smb2.c
index 67a8449569..9447b2478c 100644
--- a/source4/ntvfs/smb2/vfs_smb2.c
+++ b/source4/ntvfs/smb2/vfs_smb2.c
@@ -832,37 +832,37 @@ NTSTATUS ntvfs_smb2_init(void)
 	ops.type = NTVFS_DISK;
 	
 	/* fill in all the operations */
-	ops.connect = cvfs_connect;
-	ops.disconnect = cvfs_disconnect;
-	ops.unlink = cvfs_unlink;
-	ops.chkpath = cvfs_chkpath;
-	ops.qpathinfo = cvfs_qpathinfo;
-	ops.setpathinfo = cvfs_setpathinfo;
-	ops.open = cvfs_open;
-	ops.mkdir = cvfs_mkdir;
-	ops.rmdir = cvfs_rmdir;
-	ops.rename = cvfs_rename;
-	ops.copy = cvfs_copy;
-	ops.ioctl = cvfs_ioctl;
-	ops.read = cvfs_read;
-	ops.write = cvfs_write;
-	ops.seek = cvfs_seek;
-	ops.flush = cvfs_flush;	
-	ops.close = cvfs_close;
-	ops.exit = cvfs_exit;
-	ops.lock = cvfs_lock;
-	ops.setfileinfo = cvfs_setfileinfo;
-	ops.qfileinfo = cvfs_qfileinfo;
-	ops.fsinfo = cvfs_fsinfo;
-	ops.lpq = cvfs_lpq;
-	ops.search_first = cvfs_search_first;
-	ops.search_next = cvfs_search_next;
-	ops.search_close = cvfs_search_close;
-	ops.trans = cvfs_trans;
-	ops.logoff = cvfs_logoff;
-	ops.async_setup = cvfs_async_setup;
-	ops.cancel = cvfs_cancel;
-	ops.notify = cvfs_notify;
+	ops.connect_fn = cvfs_connect;
+	ops.disconnect_fn = cvfs_disconnect;
+	ops.unlink_fn = cvfs_unlink;
+	ops.chkpath_fn = cvfs_chkpath;
+	ops.qpathinfo_fn = cvfs_qpathinfo;
+	ops.setpathinfo_fn = cvfs_setpathinfo;
+	ops.open_fn = cvfs_open;
+	ops.mkdir_fn = cvfs_mkdir;
+	ops.rmdir_fn = cvfs_rmdir;
+	ops.rename_fn = cvfs_rename;
+	ops.copy_fn = cvfs_copy;
+	ops.ioctl_fn = cvfs_ioctl;
+	ops.read_fn = cvfs_read;
+	ops.write_fn = cvfs_write;
+	ops.seek_fn = cvfs_seek;
+	ops.flush_fn = cvfs_flush;
+	ops.close_fn = cvfs_close;
+	ops.exit_fn = cvfs_exit;
+	ops.lock_fn = cvfs_lock;
+	ops.setfileinfo_fn = cvfs_setfileinfo;
+	ops.qfileinfo_fn = cvfs_qfileinfo;
+	ops.fsinfo_fn = cvfs_fsinfo;
+	ops.lpq_fn = cvfs_lpq;
+	ops.search_first_fn = cvfs_search_first;
+	ops.search_next_fn = cvfs_search_next;
+	ops.search_close_fn = cvfs_search_close;
+	ops.trans_fn = cvfs_trans;
+	ops.logoff_fn = cvfs_logoff;
+	ops.async_setup_fn = cvfs_async_setup;
+	ops.cancel_fn = cvfs_cancel;
+	ops.notify_fn = cvfs_notify;
 
 	/* register ourselves with the NTVFS subsystem. We register
 	   under the name 'smb2'. */
diff --git a/source4/ntvfs/unixuid/vfs_unixuid.c b/source4/ntvfs/unixuid/vfs_unixuid.c
index 7e7fd443d5..c98d3867c9 100644
--- a/source4/ntvfs/unixuid/vfs_unixuid.c
+++ b/source4/ntvfs/unixuid/vfs_unixuid.c
@@ -680,37 +680,37 @@ NTSTATUS ntvfs_unixuid_init(void)
 	ZERO_STRUCT(ops);
 
 	/* fill in all the operations */
-	ops.connect = unixuid_connect;
-	ops.disconnect = unixuid_disconnect;
-	ops.unlink = unixuid_unlink;
-	ops.chkpath = unixuid_chkpath;
-	ops.qpathinfo = unixuid_qpathinfo;
-	ops.setpathinfo = unixuid_setpathinfo;
-	ops.open = unixuid_open;
-	ops.mkdir = unixuid_mkdir;
-	ops.rmdir = unixuid_rmdir;
-	ops.rename = unixuid_rename;
-	ops.copy = unixuid_copy;
-	ops.ioctl = unixuid_ioctl;
-	ops.read = unixuid_read;
-	ops.write = unixuid_write;
-	ops.seek = unixuid_seek;
-	ops.flush = unixuid_flush;	
-	ops.close = unixuid_close;
-	ops.exit = unixuid_exit;
-	ops.lock = unixuid_lock;
-	ops.setfileinfo = unixuid_setfileinfo;
-	ops.qfileinfo = unixuid_qfileinfo;
-	ops.fsinfo = unixuid_fsinfo;
-	ops.lpq = unixuid_lpq;
-	ops.search_first = unixuid_search_first;
-	ops.search_next = unixuid_search_next;
-	ops.search_close = unixuid_search_close;
-	ops.trans = unixuid_trans;
-	ops.logoff = unixuid_logoff;
-	ops.async_setup = unixuid_async_setup;
-	ops.cancel = unixuid_cancel;
-	ops.notify = unixuid_notify;
+	ops.connect_fn = unixuid_connect;
+	ops.disconnect_fn = unixuid_disconnect;
+	ops.unlink_fn = unixuid_unlink;
+	ops.chkpath_fn = unixuid_chkpath;
+	ops.qpathinfo_fn = unixuid_qpathinfo;
+	ops.setpathinfo_fn = unixuid_setpathinfo;
+	ops.open_fn = unixuid_open;
+	ops.mkdir_fn = unixuid_mkdir;
+	ops.rmdir_fn = unixuid_rmdir;
+	ops.rename_fn = unixuid_rename;
+	ops.copy_fn = unixuid_copy;
+	ops.ioctl_fn = unixuid_ioctl;
+	ops.read_fn = unixuid_read;
+	ops.write_fn = unixuid_write;
+	ops.seek_fn = unixuid_seek;
+	ops.flush_fn = unixuid_flush;
+	ops.close_fn = unixuid_close;
+	ops.exit_fn = unixuid_exit;
+	ops.lock_fn = unixuid_lock;
+	ops.setfileinfo_fn = unixuid_setfileinfo;
+	ops.qfileinfo_fn = unixuid_qfileinfo;
+	ops.fsinfo_fn = unixuid_fsinfo;
+	ops.lpq_fn = unixuid_lpq;
+	ops.search_first_fn = unixuid_search_first;
+	ops.search_next_fn = unixuid_search_next;
+	ops.search_close_fn = unixuid_search_close;
+	ops.trans_fn = unixuid_trans;
+	ops.logoff_fn = unixuid_logoff;
+	ops.async_setup_fn = unixuid_async_setup;
+	ops.cancel_fn = unixuid_cancel;
+	ops.notify_fn = unixuid_notify;
 
 	ops.name = "unixuid";
 
-- 
cgit