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

Anand Avati avati at redhat.com
Thu May 2 18:36:32 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            |   11 +
 source3/modules/vfs_glusterfs.c | 1315 +++++++++++++++++++++++++++++++++++++++
 source3/modules/vfs_posixacl.h  |    2 +
 source3/modules/wscript_build   |    9 +
 source3/wscript                 |    7 +
 6 files changed, 1349 insertions(+), 0 deletions(-)
 create mode 100644 source3/modules/vfs_glusterfs.c

diff --git a/source3/Makefile.in b/source3/Makefile.in
index c701fd1..5eefe79 100644
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -914,6 +914,7 @@ 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_CEPH_OBJ = modules/vfs_ceph.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)
@@ -2970,6 +2971,10 @@ bin/ceph. at SHLIBEXT@: $(BINARY_PREREQS) $(VFS_CEPH_OBJ)
 	@echo "Building plugin $@"
 	@$(SHLD_MODULE) $(VFS_CEPH_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 d2aa215..556d117 100644
--- a/source3/configure.in
+++ b/source3/configure.in
@@ -1053,6 +1053,16 @@ CFLAGS="$save_CFLAGS"
 LDFLAGS="$save_LDFLAGS"
 LIBS="$save_LIBS"
 
+
+###################
+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.
@@ -6486,6 +6496,7 @@ SMB_MODULE(vfs_time_audit, \$(VFS_TIME_AUDIT_OBJ), "bin/time_audit.$SHLIBEXT", V
 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_ceph, \$(VFS_CEPH_OBJ), "bin/ceph.$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..3ab0d75
--- /dev/null
+++ b/source3/modules/vfs_glusterfs.c
@@ -0,0 +1,1315 @@
+/*
+   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
+*/
+
+/* Helpers to provide 'integer' fds */
+
+/* This is global. gfapi's FD operations do not
+   require filesystem context.
+*/
+static glfs_fd_t **glfd_fd;
+static int glfd_fd_size;
+static int 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) * sizeof (glfs_fd_t *));
+		if (!tmp) {
+			errno = ENOMEM;
+			return -1;
+		}
+
+		glfd_fd = tmp;
+		memset(glfd_fd+glfd_fd_size, 0, 1024 * sizeof(glfs_fd_t *));
+		glfd_fd_size += 1024;
+	}
+
+	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)
+{
+	if (i < 0 || i >= glfd_fd_size)
+		return NULL;
+	return glfd_fd[i];
+}
+
+static glfs_fd_t *
+glfd_fd_clear (int i)
+{
+	glfs_fd_t *glfd = NULL;
+
+	if (i < 0 || i >= glfd_fd_size)
+		return NULL;
+
+	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)
+{
+	ZERO_STRUCTP(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;
+}
+
+
+/* pre-opened glfs_t */
+
+static struct {
+	char *volume;
+	glfs_t *fs;
+	int ref;
+} *glfs_preopened;
+static int glfs_preopened_size;
+static int glfs_preopened_used;
+
+
+int
+glfs_set_preopened(const char *volume, glfs_t *fs)
+{
+	int i;
+
+	if (glfs_preopened_size == glfs_preopened_used) {
+		void *tmp;
+		tmp = realloc(glfs_preopened,
+			      (glfs_preopened_size + 16) *
+			      sizeof(*glfs_preopened));
+		if (!tmp) {
+			errno = ENOMEM;
+			return -1;
+		}
+		glfs_preopened = tmp;
+		memset(glfs_preopened+glfs_preopened_size, 0,
+		       16 * sizeof(*glfs_preopened));
+		glfs_preopened_size += 16;
+	}
+
+	for (i = 0; i < glfs_preopened_size; i++)
+		if (!glfs_preopened[i].volume)
+			break;
+
+	glfs_preopened[i].volume = strdup (volume);
+	glfs_preopened[i].fs = fs;
+	glfs_preopened[i].ref = 1;
+
+	return i;
+}
+
+
+static glfs_t *
+glfs_find_preopened(const char *volume)
+{
+	int i;
+
+	for (i = 0; i < glfs_preopened_size; i++) {
+		if (glfs_preopened[i].volume &&
+		    strcmp(glfs_preopened[i].volume, volume) == 0) {
+			glfs_preopened[i].ref++;
+			return glfs_preopened[i].fs;
+		}
+	}
+
+	return NULL;
+}
+
+
+static void
+glfs_clear_preopened(glfs_t *fs)
+{
+	int i;
+
+	for (i = 0; i < glfs_preopened_size; i++) {
+		if (glfs_preopened[i].fs == fs) {
+			if (--glfs_preopened[i].ref)
+				return;
+
+			free (glfs_preopened[i].volume);
+			glfs_fini (glfs_preopened[i].fs);
+			ZERO_STRUCTP(&glfs_preopened[i]);
+			return;
+		}
+	}
+
+	assert(!"filesystem context not found");
+}
+
+/* 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)
+		volume = service;
+
+	fs = glfs_find_preopened(volume);
+	if (fs)
+		goto found;
+
+	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_set_xlator_option(fs, "*-md-cache", "cache-posix-acl", "true");
+	if (ret) {
+		glfs_fini(fs);
+		return -1;
+	}
+
+	ret = glfs_init(fs);
+	if (ret) {
+		glfs_fini(fs);
+		return -1;
+	}
+
+	ret = glfs_set_preopened(volume, fs);
+	if (ret == -1) {
+		glfs_fini(fs);
+		return -1;
+	}
+found:
+	handle->data = fs;
+	return 0;
+}
+
+
+static void
+vfs_gluster_disconnect (struct vfs_handle_struct *handle)
+{
+	glfs_t *fs = NULL;
+
+	fs = handle->data;
+
+	glfs_clear_preopened(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;
+
+	ZERO_STRUCTP(vfs_statvfs);
+
+	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;
+	vfs_statvfs->FsCapabilities = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
+
+	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;
+
+	if (sbuf)
+		ret = glfs_readdirplus_r ((void *)dirp, &stat, (void *)direntbuf,
+					  &dirent);
+	else
+		ret = glfs_readdir_r ((void *)dirp, (void *)direntbuf, &dirent);
+
+	if (ret || !dirent)
+		return 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_DIRECTORY)
+		glfd = glfs_opendir (handle->data, smb_fname->base_name);
+	else 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)
+{
+	int ret;
+	char key_buf[NAME_MAX + 64];
+	char val_buf[NAME_MAX + 1];
+
+	if (strlen (name) >= NAME_MAX) {
+		errno = ENAMETOOLONG;
+		return -1;
+	}
+
+	snprintf (key_buf, NAME_MAX + 64, "trusted.glusterfs.get_real_filename:%s",
+		  name);
+
+	ret = glfs_getxattr (handle->data, path, key_buf, val_buf, NAME_MAX+1);
+	if (ret == -1 && errno == ENODATA) {
+		errno = EOPNOTSUPP;
+		return -1;
+	}
+
+	*found_name = talloc_strdup (mem_ctx, val_buf);
+	if (!*found_name) {
+		errno = ENOMEM;
+		return -1;
+	}
+	return 0;
+}
+
+
+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/vfs_posixacl.h b/source3/modules/vfs_posixacl.h
index 424cfe9..2259912 100644
--- a/source3/modules/vfs_posixacl.h
+++ b/source3/modules/vfs_posixacl.h
@@ -21,6 +21,8 @@
 #ifndef __VFS_POSIXACL_H__
 #define __VFS_POSIXACL_H__
 
+#include <sys/acl.h>
+
 SMB_ACL_T posixacl_sys_acl_get_file(vfs_handle_struct *handle,
 				    const char *path_p,
 				    SMB_ACL_TYPE_T type,
diff --git a/source3/modules/wscript_build b/source3/modules/wscript_build
index df4f59a..45654e7 100644
--- a/source3/modules/wscript_build
+++ b/source3/modules/wscript_build
@@ -51,6 +51,7 @@ VFS_TIME_AUDIT_SRC = 'vfs_time_audit.c'
 VFS_MEDIA_HARMONY_SRC = 'vfs_media_harmony.c'
 VFS_BTRFS_SRC = 'vfs_btrfs.c'
 VFS_CEPH_SRC = 'vfs_ceph.c'
+VFS_GLUSTERFS_SRC = 'vfs_glusterfs.c'
 
 
 bld.SAMBA3_SUBSYSTEM('NFS4_ACLS',
@@ -513,3 +514,11 @@ bld.SAMBA3_MODULE('vfs_ceph',
                  internal_module=bld.SAMBA3_IS_STATIC_MODULE('vfs_ceph'),
                  enabled=bld.SAMBA3_IS_ENABLED_MODULE('vfs_ceph'),
                  cflags=bld.CONFIG_GET('CCFLAGS_CEPHFS'))
+
+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 28fa11f..d7e0234 100644
--- a/source3/wscript
+++ b/source3/wscript
@@ -1713,9 +1713,13 @@ main() {
     if conf.CHECK_HEADERS('cephfs/libcephfs.h', False, False, 'cephfs') and conf.CHECK_LIB('cephfs'):
         conf.DEFINE('HAVE_CEPH', '1')
 
+
     if Options.options.with_regedit:
         conf.PROCESS_SEPARATE_RULE('system_ncurses')
 
+    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
@@ -1786,6 +1790,9 @@ main() {
     if conf.CONFIG_SET("HAVE_CEPH"):
         default_shared_modules.extend(TO_LIST('vfs_ceph'))
 
+    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





More information about the Gluster-devel mailing list