gluster-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

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


From: Anand Avati
Subject: [Gluster-devel] [PATCH 2/2] vfs_glusterfs: Samba VFS module for glusterfs
Date: Wed, 24 Apr 2013 04:07:16 -0400
User-agent: Mutt/1.4.2.2i

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 <address@hidden>
---
 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/address@hidden@: $(BINARY_PREREQS) $(VFS_BTRFS_OBJ)
        @echo "Building plugin $@"
        @$(SHLD_MODULE) $(VFS_BTRFS_OBJ)
 
+bin/address@hidden@: $(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 <address@hidden>
+
+   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




reply via email to

[Prev in Thread] Current Thread [Next in Thread]