[Gluster-devel] [PATCH 2/2] vfs_glusterfs: Samba VFS module for glusterfs

Anand Avati avati at redhat.com
Wed Apr 24 08:28:18 UTC 2013


Implement a Samba VFS plugin for glusterfs based on gluster's gfapi.
This is a "bottom" vfs plugin (not something to be stacked on top of
another module), and translates (most) calls into closest actions
on gfapi.

Signed-off-by: Anand Avati <avati at redhat.com>
---
 source3/Makefile.in             |    5 +
 source3/configure.in            |    9 +
 source3/modules/vfs_glusterfs.c | 1186 +++++++++++++++++++++++++++++++++++++++
 source3/modules/wscript_build   |    9 +
 source3/wscript                 |    6 +
 5 files changed, 1215 insertions(+), 0 deletions(-)
 create mode 100644 source3/modules/vfs_glusterfs.c

diff --git a/source3/Makefile.in b/source3/Makefile.in
index a868685..f199300 100644
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -913,6 +913,7 @@ VFS_LINUX_XFS_SGID_OBJ = modules/vfs_linux_xfs_sgid.o
 VFS_TIME_AUDIT_OBJ = modules/vfs_time_audit.o
 VFS_MEDIA_HARMONY_OBJ = modules/vfs_media_harmony.o
 VFS_BTRFS_OBJ = modules/vfs_btrfs.o
+VFS_GLUSTERFS_OBJ = modules/vfs_glusterfs.o
 
 PAM_ERRORS_OBJ = ../libcli/auth/pam_errors.o
 PLAINTEXT_AUTH_OBJ = auth/pampass.o auth/pass_check.o $(PAM_ERRORS_OBJ)
@@ -2965,6 +2966,10 @@ bin/btrfs. at SHLIBEXT@: $(BINARY_PREREQS) $(VFS_BTRFS_OBJ)
 	@echo "Building plugin $@"
 	@$(SHLD_MODULE) $(VFS_BTRFS_OBJ)
 
+bin/glusterfs. at SHLIBEXT@: $(BINARY_PREREQS) $(VFS_GLUSTERFS_OBJ)
+	@echo "Building plugin $@"
+	$(SHLD_MODULE) $(VFS_GLUSTERFS_OBJ)
+
 #########################################################
 ## IdMap NSS plugins
 
diff --git a/source3/configure.in b/source3/configure.in
index 88c71d4..101db89 100644
--- a/source3/configure.in
+++ b/source3/configure.in
@@ -1023,6 +1023,14 @@ if test x"$ac_cv_header_gpfs_gpl_h" = x"yes"; then
     default_shared_modules="$default_shared_modules vfs_gpfs"
 fi
 
+PKG_CHECK_MODULES([GLFS], [glusterfs-api >= 3], glfs_found=yes, glfs_found=no)
+if test "x$glfs_found" = "xyes"; then
+    CFLAGS="$CFLAGS $GLFS_CFLAGS"
+    LDFLAGS="$LDFLAGS $GLFS_LDFLAGS"
+    LIBS="$LIBS $GLFS_LIBS"
+    default_shared_modules="$default_shared_modules vfs_glusterfs"
+fi
+
 # Note that all the libunwind symbols in the API are defined to internal
 # platform-specific version, so we must include libunwind.h before checking
 # any of them.
@@ -6455,6 +6463,7 @@ SMB_MODULE(vfs_linux_xfs_sgid, \$(VFS_LINUX_XFS_SGID_OBJ), "bin/linux_xfs_sgid.$
 SMB_MODULE(vfs_time_audit, \$(VFS_TIME_AUDIT_OBJ), "bin/time_audit.$SHLIBEXT", VFS)
 SMB_MODULE(vfs_media_harmony, \$(VFS_MEDIA_HARMONY_OBJ), "bin/media_harmony.$SHLIBEXT", VFS)
 SMB_MODULE(vfs_btrfs, \$(VFS_BTRFS_OBJ), "bin/btrfs.$SHLIBEXT", VFS)
+SMB_MODULE(vfs_glusterfs, \$(VFS_GLUSTERFS_OBJ), "bin/glusterfs.$SHLIBEXT", VFS)
 
 SMB_SUBSYSTEM(VFS,smbd/vfs.o)
 
diff --git a/source3/modules/vfs_glusterfs.c b/source3/modules/vfs_glusterfs.c
new file mode 100644
index 0000000..1dc9c87
--- /dev/null
+++ b/source3/modules/vfs_glusterfs.c
@@ -0,0 +1,1186 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   Wrap GlusterFS GFAPI calls in vfs functions.
+
+   Copyright (c) 2013 Anand Avati <avati at redhat.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#include "includes.h"
+#include "smbd/smbd.h"
+#include <stdio.h>
+#include <sys/acl.h>
+#include "api/glfs.h"
+#include "modules/vfs_posixacl.h"
+
+#define DEFAULT_VOLFILE_SERVER "localhost"
+
+/*
+  TODO
+  ----
+  Short term:
+  - AIO support
+  - sendfile/recvfile support
+  - vfs_gluster_sys_acl_get_file dynamic xattr size
+  - single glfs_t per volume
+
+  Long term:
+  - Case insensitivity
+*/
+
+/* Helpers to provide 'integer' fds */
+
+/* This is global. gfapi's FD operations do not
+   require filesystem context.
+*/
+static glfs_fd_t **glfd_fd;
+static glfd_fd_size;
+static glfd_fd_used;
+static int
+glfd_fd_store (glfs_fd_t *glfd)
+{
+	int i;
+	void *tmp;
+
+	if (glfd_fd_size == glfd_fd_used) {
+		tmp = realloc (glfd_fd, glfd_fd_size + 1024);
+		if (!tmp) {
+			errno = ENOMEM;
+			return -1;
+		}
+
+		glfd_fd_size += 1024;
+		glfd_fd = tmp;
+	}
+
+	for (i = 0; i < glfd_fd_size; i++)
+		if (!glfd_fd[i])
+			break;
+	glfd_fd_used++;
+	glfd_fd[i] = glfd;
+	return i;
+}
+
+static glfs_fd_t *
+glfd_fd_get (int i)
+{
+	return glfd_fd[i];
+}
+
+static glfs_fd_t *
+glfd_fd_clear (int i)
+{
+	glfs_fd_t *glfd = glfd_fd[i];
+
+	glfd_fd[i] = 0;
+	glfd_fd_used--;
+	return glfd;
+}
+
+
+/* Helper to convert stat to stat_ex */
+
+static void
+smb_stat_ex_from_stat (struct stat_ex *dst, const struct stat *src)
+{
+	memset (dst, 0, sizeof (*dst));
+
+	dst->st_ex_dev = 42;
+	dst->st_ex_ino = src->st_ino;
+	dst->st_ex_mode = src->st_mode;
+	dst->st_ex_nlink = src->st_nlink;
+	dst->st_ex_uid = src->st_uid;
+	dst->st_ex_gid = src->st_gid;
+	dst->st_ex_rdev = src->st_rdev;
+	dst->st_ex_size = src->st_size;
+	dst->st_ex_atime.tv_sec = src->st_atime;
+#ifdef STAT_HAVE_NSEC
+	dst->st_ex_atime.tv_nsec = src->st_atime_nsec;
+#endif
+	dst->st_ex_mtime.tv_sec = src->st_mtime;
+#ifdef STAT_HAVE_NSEC
+	dst->st_ex_mtime.tv_nsec = src->st_mtime_nsec;
+#endif
+	dst->st_ex_ctime.tv_sec = src->st_ctime;
+#ifdef STAT_HAVE_NSEC
+	dst->st_ex_ctime.tv_nsec = src->st_ctime_nsec;
+#endif
+	dst->st_ex_btime.tv_sec = src->st_mtime;
+#ifdef STAT_HAVE_NSEC
+	dst->st_ex_btime.tv_nsec = src->st_mtime_nsec;
+#endif
+	dst->st_ex_blksize = src->st_blksize;
+	dst->st_ex_blocks = src->st_blocks;
+}
+
+
+/* Disk Operations */
+
+static int
+vfs_gluster_connect(struct vfs_handle_struct *handle, const char *service,
+		      const char *user)
+{
+	const char *volfile_server;
+	const char *volume;
+	glfs_t *fs;
+	int ret;
+
+	volfile_server = lp_parm_const_string(SNUM(handle->conn), "glusterfs", "volfile_server", NULL);
+	if (!volfile_server)
+		volfile_server = DEFAULT_VOLFILE_SERVER;
+
+	volume = lp_parm_const_string(SNUM(handle->conn), "glusterfs", "volume", NULL);
+	if (!volume) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	fs = glfs_new(volume);
+	if (!fs)
+		return -1;
+
+	ret = glfs_set_volfile_server(fs, "tcp", volfile_server, 0);
+	if (ret) {
+		glfs_fini(fs);
+		return -1;
+	}
+
+	ret = glfs_init(fs);
+	if (ret) {
+		glfs_fini(fs);
+		return -1;
+	}
+
+	handle->data = fs;
+	return 0;
+}
+
+
+static void
+vfs_gluster_disconnect (struct vfs_handle_struct *handle)
+{
+	glfs_t *fs = NULL;
+
+	fs = handle->data;
+
+	glfs_fini (fs);
+}
+
+
+static uint64_t
+vfs_gluster_disk_free (struct vfs_handle_struct *handle, const char *path,
+		       bool small_query, uint64_t *bsize_p, uint64_t *dfree_p,
+		       uint64_t *dsize_p)
+{
+	struct statvfs statvfs = {0, };
+	uint64_t dfree = 0;
+	int ret;
+
+	ret = glfs_statvfs (handle->data, path, &statvfs);
+	if (ret)
+		return -1;
+
+	dfree = statvfs.f_bsize * statvfs.f_bavail;
+
+	if (bsize_p)
+		*bsize_p = statvfs.f_bsize;
+	if (dfree_p)
+		*dfree_p = dfree;
+	if (dsize_p)
+		*dsize_p = statvfs.f_bsize * statvfs.f_blocks;
+
+	return dfree;
+}
+
+
+static int
+vfs_gluster_get_quota (struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype,
+		       unid_t id, SMB_DISK_QUOTA *qt)
+{
+	errno = ENOSYS;
+	return -1;
+}
+
+
+static int
+vfs_gluster_set_quota (struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype,
+		       unid_t id, SMB_DISK_QUOTA *qt)
+{
+	errno = ENOSYS;
+	return -1;
+}
+
+
+static int
+vfs_gluster_statvfs (struct vfs_handle_struct *handle, const char *path,
+		     struct vfs_statvfs_struct *vfs_statvfs)
+{
+	struct statvfs statvfs = {0, };
+	int ret;
+
+	ret = glfs_statvfs (handle->data, path, &statvfs);
+	if (ret)
+		return -1;
+
+	vfs_statvfs->OptimalTransferSize = statvfs.f_frsize;
+	vfs_statvfs->BlockSize = statvfs.f_bsize;
+	vfs_statvfs->TotalBlocks = statvfs.f_blocks;
+	vfs_statvfs->BlocksAvail = statvfs.f_bfree;
+	vfs_statvfs->UserBlocksAvail = statvfs.f_bavail;
+	vfs_statvfs->TotalFileNodes = statvfs.f_files;
+	vfs_statvfs->FreeFileNodes = statvfs.f_ffree;
+	vfs_statvfs->FsIdentifier = statvfs.f_fsid;
+
+	return ret;
+}
+
+
+static uint32_t
+vfs_gluster_fs_capabilities (struct vfs_handle_struct *handle,
+			     enum timestamp_set_resolution *p_ts_res)
+{
+	uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
+
+#ifdef STAT_HAVE_NSEC
+	*p_ts_res = TIMESTAMP_SET_NT_OR_BETTER;
+#endif
+
+	return caps;
+}
+
+
+static DIR *
+vfs_gluster_opendir (struct vfs_handle_struct *handle, const char *path,
+		     const char *mask, uint32 attributes)
+{
+	glfs_fd_t *fd;
+
+	fd = glfs_opendir (handle->data, path);
+
+	return (DIR *) fd;
+}
+
+
+static DIR *
+vfs_gluster_fdopendir (struct vfs_handle_struct *handle, files_struct *fsp,
+		       const char *mask, uint32 attributes)
+{
+	return (DIR *) glfd_fd_get (fsp->fh->fd);
+}
+
+
+static int
+vfs_gluster_closedir (struct vfs_handle_struct *handle, DIR *dirp)
+{
+	return glfs_closedir ((void *)dirp);
+}
+
+
+static struct dirent *
+vfs_gluster_readdir (struct vfs_handle_struct *handle, DIR *dirp,
+		     SMB_STRUCT_STAT *sbuf)
+{
+	static char direntbuf[512];
+	int ret;
+	struct stat stat;
+	struct dirent *dirent = 0;
+
+	ret = glfs_readdirplus_r ((void *)dirp, &stat, (void *)direntbuf,
+				  &dirent);
+	if (ret)
+		dirent = NULL;
+
+	if (sbuf)
+		smb_stat_ex_from_stat (sbuf, &stat);
+
+	return dirent;
+}
+
+
+static long
+vfs_gluster_telldir (struct vfs_handle_struct *handle, DIR *dirp)
+{
+	return glfs_telldir ((void *) dirp);
+}
+
+
+static void
+vfs_gluster_seekdir (struct vfs_handle_struct *handle, DIR *dirp, long offset)
+{
+	glfs_seekdir ((void *) dirp, offset);
+}
+
+
+static void
+vfs_gluster_rewinddir (struct vfs_handle_struct *handle, DIR *dirp)
+{
+	glfs_seekdir ((void *) dirp, 0);
+}
+
+
+static void
+vfs_gluster_init_search_op (struct vfs_handle_struct *handle, DIR *dirp)
+{
+	return;
+}
+
+
+static int
+vfs_gluster_mkdir (struct vfs_handle_struct *handle, const char *path, mode_t mode)
+{
+	return glfs_mkdir (handle->data, path, mode);
+}
+
+
+static int
+vfs_gluster_rmdir (struct vfs_handle_struct *handle, const char *path)
+{
+	return glfs_rmdir (handle->data, path);
+}
+
+
+static int
+vfs_gluster_open (struct vfs_handle_struct *handle, struct smb_filename *smb_fname,
+		  files_struct *fsp, int flags, mode_t mode)
+{
+	glfs_fd_t *glfd;
+
+	if (flags & O_CREAT)
+		glfd = glfs_creat (handle->data, smb_fname->base_name, flags, mode);
+	else
+		glfd = glfs_open (handle->data, smb_fname->base_name, flags);
+
+	if (!glfd)
+		return -1;
+
+	return glfd_fd_store (glfd);
+}
+
+
+static int
+vfs_gluster_close (struct vfs_handle_struct *handle, files_struct *fsp)
+{
+	return glfs_close (glfd_fd_clear (fsp->fh->fd));
+}
+
+
+static ssize_t
+vfs_gluster_read (struct vfs_handle_struct *handle, files_struct *fsp,
+		  void *data, size_t n)
+{
+	return glfs_read (glfd_fd_get (fsp->fh->fd), data, n, 0);
+}
+
+
+static ssize_t
+vfs_gluster_pread (struct vfs_handle_struct *handle, files_struct *fsp,
+		   void *data, size_t n, off_t offset)
+{
+	return glfs_pread (glfd_fd_get (fsp->fh->fd), data, n, offset, 0);
+}
+
+
+static struct tevent_req *
+vfs_gluster_pread_send(struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
+		       struct tevent_context *ev, files_struct *fsp,
+		       void *data, size_t n, off_t offset)
+{
+	errno = ENOTSUP;
+	return NULL;
+}
+
+
+static ssize_t
+vfs_gluster_pread_recv(struct tevent_req *req, int *err)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+static ssize_t
+vfs_gluster_write (struct vfs_handle_struct *handle, files_struct *fsp,
+		   const void *data, size_t n)
+{
+	return glfs_write (glfd_fd_get (fsp->fh->fd), data, n, 0);
+}
+
+
+static ssize_t
+vfs_gluster_pwrite (struct vfs_handle_struct *handle, files_struct *fsp,
+		    const void *data, size_t n, off_t offset)
+{
+	return glfs_pwrite (glfd_fd_get (fsp->fh->fd), data, n, offset, 0);
+}
+
+
+static struct tevent_req *
+vfs_gluster_pwrite_send(struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
+			struct tevent_context *ev, files_struct *fsp,
+			const void *data, size_t n, off_t offset)
+{
+	errno = ENOTSUP;
+	return NULL;
+}
+
+
+static ssize_t
+vfs_gluster_pwrite_recv(struct tevent_req *req, int *err)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+static off_t
+vfs_gluster_lseek (struct vfs_handle_struct *handle, files_struct *fsp,
+		   off_t offset, int whence)
+{
+	return glfs_lseek (glfd_fd_get (fsp->fh->fd), offset, whence);
+}
+
+
+static ssize_t
+vfs_gluster_sendfile (struct vfs_handle_struct *handle, int tofd,
+		      files_struct *fromfsp, const DATA_BLOB *hdr,
+		      off_t offset, size_t n)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+static ssize_t
+vfs_gluster_recvfile (struct vfs_handle_struct *handle, int fromfd,
+		      files_struct *tofsp, off_t offset, size_t n)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+static int
+vfs_gluster_rename (struct vfs_handle_struct *handle,
+		    const struct smb_filename *smb_fname_src,
+		    const struct smb_filename *smb_fname_dst)
+{
+	return glfs_rename (handle->data, smb_fname_src->base_name,
+			    smb_fname_dst->base_name);
+}
+
+
+static int
+vfs_gluster_fsync (struct vfs_handle_struct *handle, files_struct *fsp)
+{
+	return glfs_fsync (glfd_fd_get (fsp->fh->fd));
+}
+
+
+static struct tevent_req *
+vfs_gluster_fsync_send(struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
+		       struct tevent_context *ev, files_struct *fsp)
+{
+	errno = ENOTSUP;
+	return NULL;
+}
+
+
+static int
+vfs_gluster_fsync_recv(struct tevent_req *req, int *err)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+static int
+vfs_gluster_stat (struct vfs_handle_struct *handle, struct smb_filename *smb_fname)
+{
+	struct stat st;
+	int ret;
+
+	ret = glfs_stat (handle->data, smb_fname->base_name, &st);
+	if (ret == 0)
+		smb_stat_ex_from_stat (&smb_fname->st, &st);
+	return ret;
+}
+
+
+static int
+vfs_gluster_fstat (struct vfs_handle_struct *handle, files_struct *fsp,
+		   SMB_STRUCT_STAT *sbuf)
+{
+	struct stat st;
+	int ret;
+
+	ret = glfs_fstat (glfd_fd_get (fsp->fh->fd), &st);
+	if (ret == 0)
+		smb_stat_ex_from_stat (sbuf, &st);
+	return ret;
+}
+
+
+static int
+vfs_gluster_lstat (struct vfs_handle_struct *handle, struct smb_filename *smb_fname)
+{
+	struct stat st;
+	int ret;
+
+	ret = glfs_lstat (handle->data, smb_fname->base_name, &st);
+	if (ret == 0)
+		smb_stat_ex_from_stat (&smb_fname->st, &st);
+	return ret;
+}
+
+
+static uint64_t
+vfs_gluster_get_alloc_size (struct vfs_handle_struct *handle, files_struct *fsp,
+			    const SMB_STRUCT_STAT *sbuf)
+{
+	return sbuf->st_ex_blocks * 512;
+}
+
+
+static int
+vfs_gluster_unlink (struct vfs_handle_struct *handle,
+		    const struct smb_filename *smb_fname)
+{
+	return glfs_unlink (handle->data, smb_fname->base_name);
+}
+
+
+static int
+vfs_gluster_chmod (struct vfs_handle_struct *handle,
+		   const char *path, mode_t mode)
+{
+	return glfs_chmod (handle->data, path, mode);
+}
+
+
+static int
+vfs_gluster_fchmod (struct vfs_handle_struct *handle,
+		    files_struct *fsp, mode_t mode)
+{
+	return glfs_fchmod (glfd_fd_get (fsp->fh->fd), mode);
+}
+
+
+static int
+vfs_gluster_chown (struct vfs_handle_struct *handle,
+		   const char *path, uid_t uid, gid_t gid)
+{
+	return glfs_chown (handle->data, path, uid, gid);
+}
+
+
+static int
+vfs_gluster_fchown (struct vfs_handle_struct *handle,
+		    files_struct *fsp, uid_t uid, gid_t gid)
+{
+	return glfs_fchown (glfd_fd_get (fsp->fh->fd), uid, gid);
+}
+
+
+static int
+vfs_gluster_lchown (struct vfs_handle_struct *handle,
+		    const char *path, uid_t uid, gid_t gid)
+{
+	return glfs_lchown (handle->data, path, uid, gid);
+}
+
+
+static int
+vfs_gluster_chdir (struct vfs_handle_struct *handle, const char *path)
+{
+	return glfs_chdir (handle->data, path);
+}
+
+
+static char *
+vfs_gluster_getwd (struct vfs_handle_struct *handle)
+{
+	char *cwd;
+	char *ret;
+
+	cwd = malloc(PATH_MAX+1);
+	if (!cwd)
+		return NULL;
+
+	ret = glfs_getcwd (handle->data, cwd, PATH_MAX);
+	if (!ret)
+		free (cwd);
+	return ret;
+}
+
+
+static int
+vfs_gluster_ntimes (struct vfs_handle_struct *handle,
+		    const struct smb_filename *smb_fname,
+		    struct smb_file_time *ft)
+{
+	struct timespec times[2];
+
+	times[0].tv_sec = ft->atime.tv_sec;
+	times[0].tv_nsec = ft->atime.tv_nsec;
+	times[1].tv_sec = ft->mtime.tv_sec;
+	times[1].tv_nsec = ft->mtime.tv_nsec;
+
+	return glfs_utimens (handle->data, smb_fname->base_name, times);
+}
+
+
+static int
+vfs_gluster_ftruncate (struct vfs_handle_struct *handle, files_struct *fsp,
+		       off_t offset)
+{
+	return glfs_ftruncate (glfd_fd_get (fsp->fh->fd), offset);
+}
+
+
+static int
+vfs_gluster_fallocate (struct vfs_handle_struct *handle, struct files_struct *fsp,
+		       enum vfs_fallocate_mode mode, off_t offset, off_t len)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+static char *
+vfs_gluster_realpath (struct vfs_handle_struct *handle, const char *path)
+{
+	return glfs_realpath (handle->data, path, 0);
+}
+
+
+static bool
+vfs_gluster_lock (struct vfs_handle_struct *handle, files_struct *fsp,
+		  int op, off_t offset, off_t count, int type)
+{
+	struct flock flock = {0, };
+	int ret;
+
+	flock.l_type   = type;
+	flock.l_whence = SEEK_SET;
+	flock.l_start  = offset;
+	flock.l_len    = count;
+	flock.l_pid    = 0;
+
+	ret = glfs_posix_lock (glfd_fd_get (fsp->fh->fd), op, &flock);
+
+	if (op == F_GETLK) {
+		/* lock query, true if someone else has locked */
+		if ((ret != -1) &&
+		    (flock.l_type != F_UNLCK) &&
+		    (flock.l_pid != 0) &&
+		    (flock.l_pid != getpid()))
+			return true;
+		/* not me */
+		return false;
+	}
+
+	if (ret == -1)
+		return false;
+
+	return true;
+}
+
+
+static int
+vfs_gluster_kernel_flock (struct vfs_handle_struct *handle, files_struct *fsp,
+			  uint32 share_mode, uint32_t access_mask)
+{
+	return 0;
+}
+
+
+static int
+vfs_gluster_linux_setlease (struct vfs_handle_struct *handle, files_struct *fsp,
+			    int leasetype)
+{
+	errno = ENOSYS;
+	return -1;
+}
+
+
+static bool
+vfs_gluster_getlock (struct vfs_handle_struct *handle, files_struct *fsp,
+		     off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
+{
+	struct flock flock = {0, };
+	int ret;
+
+	flock.l_type = *ptype;
+	flock.l_whence = SEEK_SET;
+	flock.l_start = *poffset;
+	flock.l_len = *pcount;
+	flock.l_pid = 0;
+
+	ret = glfs_posix_lock (glfd_fd_get (fsp->fh->fd), F_GETLK, &flock);
+
+	if (ret == -1)
+		return false;
+
+	*ptype   = flock.l_type;
+	*poffset = flock.l_start;
+	*pcount  = flock.l_len;
+	*ppid    = flock.l_pid;
+
+	return true;
+}
+
+
+static int
+vfs_gluster_symlink (struct vfs_handle_struct *handle, const char *oldpath,
+		     const char *newpath)
+{
+	return glfs_symlink (handle->data, oldpath, newpath);
+}
+
+
+static int
+vfs_gluster_readlink (struct vfs_handle_struct *handle, const char *path,
+		      char *buf, size_t bufsiz)
+{
+	return glfs_readlink (handle->data, path, buf, bufsiz);
+}
+
+
+static int
+vfs_gluster_link (struct vfs_handle_struct *handle, const char *oldpath,
+		  const char *newpath)
+{
+	return glfs_link (handle->data, oldpath, newpath);
+}
+
+
+static int
+vfs_gluster_mknod (struct vfs_handle_struct *handle, const char *path,
+		   mode_t mode, SMB_DEV_T dev)
+{
+	return glfs_mknod (handle->data, path, mode, dev);
+}
+
+
+static NTSTATUS
+vfs_gluster_notify_watch (struct vfs_handle_struct *handle,
+			  struct sys_notify_context *ctx, const char *path,
+			  uint32_t *filter, uint32_t *subdir_filter,
+			  void (*callback)(struct sys_notify_context *ctx,
+					   void *private_data,
+					   struct notify_event *ev),
+			  void *private_data, void *handle_p)
+{
+	return NT_STATUS_OK;
+}
+
+
+static int
+vfs_gluster_chflags (struct vfs_handle_struct *handle, const char *path,
+		     unsigned int flags)
+{
+	errno = ENOSYS;
+	return -1;
+}
+
+
+static int
+vfs_gluster_get_real_filename (struct vfs_handle_struct *handle,
+			       const char *path, const char *name,
+			       TALLOC_CTX *mem_ctx, char **found_name)
+{
+	errno = EOPNOTSUPP;
+	return -1;
+}
+
+
+static const char *
+vfs_gluster_connectpath (struct vfs_handle_struct *handle, const char *filename)
+{
+	return handle->conn->connectpath;
+}
+
+
+/* EA Operations */
+
+static ssize_t
+vfs_gluster_getxattr (struct vfs_handle_struct *handle, const char *path,
+		      const char *name, void *value, size_t size)
+{
+	return glfs_getxattr (handle->data, path, name, value, size);
+}
+
+static ssize_t
+vfs_gluster_fgetxattr (struct vfs_handle_struct *handle, files_struct *fsp,
+		       const char *name, void *value, size_t size)
+{
+	return glfs_fgetxattr (glfd_fd_get (fsp->fh->fd), name, value, size);
+}
+
+
+static ssize_t
+vfs_gluster_listxattr (struct vfs_handle_struct *handle, const char *path,
+		       char *list, size_t size)
+{
+	return glfs_listxattr (handle->data, path, list, size);
+}
+
+
+static ssize_t
+vfs_gluster_flistxattr (struct vfs_handle_struct *handle, files_struct *fsp,
+			char *list, size_t size)
+{
+	return glfs_flistxattr (glfd_fd_get (fsp->fh->fd), list, size);
+}
+
+
+static int
+vfs_gluster_removexattr (struct vfs_handle_struct *handle, const char *path,
+			 const char *name)
+{
+	return glfs_removexattr (handle->data, path, name);
+}
+
+
+static int
+vfs_gluster_fremovexattr (struct vfs_handle_struct *handle, files_struct *fsp,
+			  const char *name)
+{
+	return glfs_fremovexattr (glfd_fd_get (fsp->fh->fd), name);
+}
+
+
+static int
+vfs_gluster_setxattr (struct vfs_handle_struct *handle, const char *path,
+		      const char *name, const void *value, size_t size,
+		      int flags)
+{
+	return glfs_setxattr (handle->data, path, name, value, size, flags);
+}
+
+
+static int
+vfs_gluster_fsetxattr (struct vfs_handle_struct *handle, files_struct *fsp,
+		       const char *name, const void *value, size_t size,
+		       int flags)
+{
+	return glfs_fsetxattr (glfd_fd_get (fsp->fh->fd), name, value, size,
+			       flags);
+}
+
+
+/* AIO Operations */
+
+static bool
+vfs_gluster_aio_force (struct vfs_handle_struct *handle, files_struct *fsp)
+{
+	return false;
+}
+
+
+/* Offline Operations */
+
+static bool
+vfs_gluster_is_offline (struct vfs_handle_struct *handle,
+			const struct smb_filename *fname,
+			SMB_STRUCT_STAT *sbuf)
+{
+	return false;
+}
+
+
+static int
+vfs_gluster_set_offline (struct vfs_handle_struct *handle,
+			 const struct smb_filename *fname)
+{
+	errno = ENOTSUP;
+	return -1;
+}
+
+
+/* Posix ACL Operations */
+
+static SMB_ACL_T
+vfs_gluster_sys_acl_get_file (struct vfs_handle_struct *handle,
+			      const char *path_p, SMB_ACL_TYPE_T type,
+			      TALLOC_CTX *mem_ctx)
+{
+	struct smb_acl_t *result;
+	acl_t acl;
+	char buf[1024];
+	char *key;
+	ssize_t ret;
+
+	switch (type) {
+	case SMB_ACL_TYPE_ACCESS:
+		key = "system.posix_acl_access";
+		break;
+        case SMB_ACL_TYPE_DEFAULT:
+		key = "system.posix_acl_default";
+		break;
+	default:
+		errno = EINVAL;
+		return NULL;
+	}
+
+	ret = glfs_getxattr (handle->data, path_p, key, buf, 1024);
+	if (ret < 0)
+		return NULL;
+
+	acl = acl_copy_int (buf);
+
+	if (!acl)
+		return NULL;
+
+	result = smb_acl_to_internal (acl, mem_ctx);
+	acl_free (acl);
+	return result;
+}
+
+
+static SMB_ACL_T
+vfs_gluster_sys_acl_get_fd (struct vfs_handle_struct *handle,
+			    struct files_struct *fsp, TALLOC_CTX *mem_ctx)
+{
+	struct smb_acl_t *result;
+	acl_t acl;
+	int ret;
+	char buf[1024];
+
+	ret = glfs_fgetxattr (glfd_fd_get (fsp->fh->fd), "system.posix_acl_access",
+			      buf, 1024);
+	if (ret < 0)
+		return NULL;
+
+	acl = acl_copy_int (buf);
+	if (!acl)
+		return NULL;
+
+	result = smb_acl_to_internal (acl, mem_ctx);
+	acl_free (acl);
+	return result;
+}
+
+
+static int
+vfs_gluster_sys_acl_set_file (struct vfs_handle_struct *handle,
+			      const char *name, SMB_ACL_TYPE_T acltype,
+			      SMB_ACL_T theacl)
+{
+	int ret;
+	char *key;
+	char buf[1024];
+	acl_t acl;
+	ssize_t size;
+
+	switch(acltype) {
+	case SMB_ACL_TYPE_ACCESS:
+		key = "system.posix_acl_access";
+		break;
+	case SMB_ACL_TYPE_DEFAULT:
+		key = "system.posix_acl_default";
+		break;
+	default:
+		errno = EINVAL;
+		return -1;
+	}
+
+	acl = smb_acl_to_posix (theacl);
+	if (!acl)
+                return -1;
+	size = acl_copy_ext (buf, acl, 1024);
+	if (size == -1)
+		return -1;
+
+	ret = glfs_setxattr (handle->data, name, key, buf, size, 0);
+
+	acl_free(acl);
+
+	return ret;
+}
+
+
+static int
+vfs_gluster_sys_acl_set_fd (struct vfs_handle_struct *handle,
+			    struct files_struct *fsp, SMB_ACL_T theacl)
+{
+	int ret;
+	char *key;
+	char buf[1024];
+	acl_t acl;
+	ssize_t size;
+
+	acl = smb_acl_to_posix (theacl);
+	if (!acl)
+                return -1;
+
+	size = acl_copy_ext (buf, acl, 1024);
+	if (size == -1)
+		return -1;
+
+	ret = glfs_fsetxattr (glfd_fd_get (fsp->fh->fd),
+			      "system.posix_acl_access", buf, size, 0);
+	acl_free(acl);
+
+	return ret;
+}
+
+
+static int
+vfs_gluster_sys_acl_delete_def_file (struct vfs_handle_struct *handle,
+				     const char *path)
+{
+	return glfs_removexattr (handle->data, path, "system.posix_acl_default");
+}
+
+
+static struct vfs_fn_pointers glusterfs_fns = {
+
+	/* Disk Operations */
+
+	.connect_fn                  = vfs_gluster_connect,
+	.disconnect_fn               = vfs_gluster_disconnect,
+	.disk_free_fn                = vfs_gluster_disk_free,
+	.get_quota_fn                = vfs_gluster_get_quota,
+	.set_quota_fn                = vfs_gluster_set_quota,
+	.statvfs_fn                  = vfs_gluster_statvfs,
+	.fs_capabilities_fn          = vfs_gluster_fs_capabilities,
+
+	.get_dfs_referrals_fn        = NULL,
+
+	/* Directory Operations */
+
+	.opendir_fn                  = vfs_gluster_opendir,
+	.fdopendir_fn                = vfs_gluster_fdopendir,
+	.readdir_fn                  = vfs_gluster_readdir,
+	.seekdir_fn                  = vfs_gluster_seekdir,
+	.telldir_fn                  = vfs_gluster_telldir,
+	.rewind_dir_fn               = vfs_gluster_rewinddir,
+	.mkdir_fn                    = vfs_gluster_mkdir,
+	.rmdir_fn                    = vfs_gluster_rmdir,
+	.closedir_fn                 = vfs_gluster_closedir,
+	.init_search_op_fn           = vfs_gluster_init_search_op,
+
+	/* File Operations */
+
+	.open_fn                     = vfs_gluster_open,
+	.create_file_fn              = NULL,
+	.close_fn                    = vfs_gluster_close,
+	.read_fn                     = vfs_gluster_read,
+	.pread_fn                    = vfs_gluster_pread,
+	.pread_send_fn               = vfs_gluster_pread_send,
+	.pread_recv_fn               = vfs_gluster_pread_recv,
+	.write_fn                    = vfs_gluster_write,
+	.pwrite_fn                   = vfs_gluster_pwrite,
+	.pwrite_send_fn              = vfs_gluster_pwrite_send,
+	.pwrite_recv_fn              = vfs_gluster_pwrite_recv,
+	.lseek_fn                    = vfs_gluster_lseek,
+	.sendfile_fn                 = vfs_gluster_sendfile,
+	.recvfile_fn                 = vfs_gluster_recvfile,
+	.rename_fn                   = vfs_gluster_rename,
+	.fsync_fn                    = vfs_gluster_fsync,
+	.fsync_send_fn               = vfs_gluster_fsync_send,
+	.fsync_recv_fn               = vfs_gluster_fsync_recv,
+
+	.stat_fn                     = vfs_gluster_stat,
+	.fstat_fn                    = vfs_gluster_fstat,
+	.lstat_fn                    = vfs_gluster_lstat,
+	.get_alloc_size_fn           = vfs_gluster_get_alloc_size,
+	.unlink_fn                   = vfs_gluster_unlink,
+
+	.chmod_fn                    = vfs_gluster_chmod,
+	.fchmod_fn                   = vfs_gluster_fchmod,
+	.chown_fn                    = vfs_gluster_chown,
+	.fchown_fn                   = vfs_gluster_fchown,
+	.lchown_fn                   = vfs_gluster_lchown,
+	.chdir_fn                    = vfs_gluster_chdir,
+	.getwd_fn                    = vfs_gluster_getwd,
+	.ntimes_fn                   = vfs_gluster_ntimes,
+	.ftruncate_fn                = vfs_gluster_ftruncate,
+	.fallocate_fn                = vfs_gluster_fallocate,
+	.lock_fn                     = vfs_gluster_lock,
+	.kernel_flock_fn             = vfs_gluster_kernel_flock,
+	.linux_setlease_fn           = vfs_gluster_linux_setlease,
+	.getlock_fn                  = vfs_gluster_getlock,
+	.symlink_fn                  = vfs_gluster_symlink,
+	.readlink_fn                 = vfs_gluster_readlink,
+	.link_fn                     = vfs_gluster_link,
+	.mknod_fn                    = vfs_gluster_mknod,
+	.realpath_fn                 = vfs_gluster_realpath,
+	.notify_watch_fn             = vfs_gluster_notify_watch,
+	.chflags_fn                  = vfs_gluster_chflags,
+	.file_id_create_fn           = NULL,
+	.copy_chunk_send_fn          = NULL,
+	.copy_chunk_recv_fn          = NULL,
+	.streaminfo_fn               = NULL,
+	.get_real_filename_fn        = vfs_gluster_get_real_filename,
+	.connectpath_fn              = vfs_gluster_connectpath,
+
+	.brl_lock_windows_fn         = NULL,
+	.brl_unlock_windows_fn       = NULL,
+	.brl_cancel_windows_fn       = NULL,
+	.strict_lock_fn              = NULL,
+	.strict_unlock_fn            = NULL,
+	.translate_name_fn           = NULL,
+	.fsctl_fn                    = NULL,
+
+	/* NT ACL Operations */
+	.fget_nt_acl_fn              = NULL,
+	.get_nt_acl_fn               = NULL,
+	.fset_nt_acl_fn              = NULL,
+	.audit_file_fn               = NULL,
+
+	/* Posix ACL Operations */
+	.chmod_acl_fn                = NULL, /* passthrough to default */
+	.fchmod_acl_fn               = NULL, /* passthrough to default */
+	.sys_acl_get_file_fn         = vfs_gluster_sys_acl_get_file,
+	.sys_acl_get_fd_fn           = vfs_gluster_sys_acl_get_fd,
+	.sys_acl_blob_get_file_fn    = posix_sys_acl_blob_get_file,
+	.sys_acl_blob_get_fd_fn      = posix_sys_acl_blob_get_fd,
+	.sys_acl_set_file_fn         = vfs_gluster_sys_acl_set_file,
+	.sys_acl_set_fd_fn           = vfs_gluster_sys_acl_set_fd,
+	.sys_acl_delete_def_file_fn  = vfs_gluster_sys_acl_delete_def_file,
+
+	/* EA Operations */
+	.getxattr_fn                 = vfs_gluster_getxattr,
+	.fgetxattr_fn                = vfs_gluster_fgetxattr,
+	.listxattr_fn                = vfs_gluster_listxattr,
+	.flistxattr_fn               = vfs_gluster_flistxattr,
+	.removexattr_fn              = vfs_gluster_removexattr,
+	.fremovexattr_fn             = vfs_gluster_fremovexattr,
+	.setxattr_fn                 = vfs_gluster_setxattr,
+	.fsetxattr_fn                = vfs_gluster_fsetxattr,
+
+        /* AIO Operations */
+	.aio_force_fn                = vfs_gluster_aio_force,
+
+        /* Offline Operations */
+	.is_offline_fn               = vfs_gluster_is_offline,
+	.set_offline_fn              = vfs_gluster_set_offline,
+
+	/* Durable handle Operations */
+	.durable_cookie_fn           = NULL,
+	.durable_disconnect_fn       = NULL,
+	.durable_reconnect_fn        = NULL,
+};
+
+NTSTATUS vfs_glusterfs_init(void);
+NTSTATUS vfs_glusterfs_init(void)
+{
+	return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
+				"glusterfs", &glusterfs_fns);
+}
diff --git a/source3/modules/wscript_build b/source3/modules/wscript_build
index 6726ac3..0017d9b 100644
--- a/source3/modules/wscript_build
+++ b/source3/modules/wscript_build
@@ -50,6 +50,7 @@ VFS_LINUX_XFS_SGID_SRC = 'vfs_linux_xfs_sgid.c'
 VFS_TIME_AUDIT_SRC = 'vfs_time_audit.c'
 VFS_MEDIA_HARMONY_SRC = 'vfs_media_harmony.c'
 VFS_BTRFS_SRC = 'vfs_btrfs.c'
+VFS_GLUSTERFS_SRC = 'vfs_glusterfs.c'
 
 
 bld.SAMBA3_SUBSYSTEM('NFS4_ACLS',
@@ -503,3 +504,11 @@ bld.SAMBA3_MODULE('perfcount_test',
                  init_function='',
                  internal_module=bld.SAMBA3_IS_STATIC_MODULE('perfcount_test'),
                  enabled=bld.SAMBA3_IS_ENABLED_MODULE('perfcount_test'))
+
+bld.SAMBA3_MODULE('vfs_glusterfs',
+                  subsystem='vfs',
+                  source=VFS_GLUSTERFS_SRC,
+                  deps='samba-util',
+                  init_function='',
+                  internal_module=bld.SAMBA3_IS_STATIC_MODULE('vfs_glusterfs'),
+                  enabled=bld.SAMBA3_IS_ENABLED_MODULE('vfs_glusterfs'))
diff --git a/source3/wscript b/source3/wscript
index d687dae..cfbc168 100644
--- a/source3/wscript
+++ b/source3/wscript
@@ -1699,6 +1699,9 @@ main() {
     if conf.CHECK_HEADERS('linux/ioctl.h sys/ioctl.h'):
 	    conf.DEFINE('HAVE_LINUX_IOCTL', '1')
 
+    if conf.CHECK_HEADERS('api/glfs.h'):
+        conf.DEFINE('HAVE_GLUSTERFS', '1')
+
     default_static_modules.extend(TO_LIST('''pdb_smbpasswd pdb_tdbsam pdb_wbc_sam
                                       auth_sam auth_unix auth_winbind auth_wbc
                                       auth_domain auth_builtin vfs_default
@@ -1766,6 +1769,9 @@ main() {
     if conf.CONFIG_SET('SAMBA_FAM_LIBS'):
         default_shared_modules.extend(TO_LIST('vfs_notify_fam'))
 
+    if conf.CONFIG_SET('HAVE_GLUSTERFS'):
+        default_shared_modules.extend(TO_LIST('vfs_glusterfs'))
+
     explicit_shared_modules = TO_LIST(Options.options.shared_modules, delimiter=',')
     explicit_static_modules = TO_LIST(Options.options.static_modules, delimiter=',')
 
-- 
1.7.1


-- 
avati at sdf.lonestar.org
SDF Public Access UNIX System - http://sdf.lonestar.org




More information about the Gluster-devel mailing list