[PATCH 1/2, RESEND] s3/modules: New vfs module: cephfs
Sam Lang
slang at inktank.com
Mon Apr 29 11:06:06 MDT 2013
Hi Jeremy,
Did this updated patch fix the build issues you were seeing?
Thanks,
-sam
On Mon, Apr 22, 2013 at 10:23 AM, <samlang at gmail.com> wrote:
> From: Sam Lang <sam.lang at inktank.com>
>
> Implements a vfs module for cephfs, a distributed file system
> with posix semantics, built on the ceph distributed object
> storage layer. The ceph vfs module interfaces to the libcephfs
> userspace API, and is primarily a lightweight wrapper around
> libcephfs, translating error codes and parameters as necessary.
>
> Signed-off-by: Sam Lang <sam.lang at inktank.com>
> ---
> source3/Makefile.in | 5 +
> source3/configure.in | 31 +
> source3/modules/vfs_ceph.c | 1261 +++++++++++++++++++++++++++++++++++++++++
> source3/modules/wscript_build | 10 +
> source3/wscript | 15 +
> 5 files changed, 1322 insertions(+)
> create mode 100644 source3/modules/vfs_ceph.c
>
> diff --git a/source3/Makefile.in b/source3/Makefile.in
> index a868685..c701fd1 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_CEPH_OBJ = modules/vfs_ceph.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/ceph. at SHLIBEXT@: $(BINARY_PREREQS) $(VFS_CEPH_OBJ)
> + @echo "Building plugin $@"
> + @$(SHLD_MODULE) $(VFS_CEPH_OBJ)
> +
> #########################################################
> ## IdMap NSS plugins
>
> diff --git a/source3/configure.in b/source3/configure.in
> index 88c71d4..d2aa215 100644
> --- a/source3/configure.in
> +++ b/source3/configure.in
> @@ -1023,6 +1023,36 @@ if test x"$ac_cv_header_gpfs_gpl_h" = x"yes"; then
> default_shared_modules="$default_shared_modules vfs_gpfs"
> fi
>
> +#############################
> +# check if building with libcephfs
> +# fail if --with-libcephfs specified but no headers found
> +printf "%s" "checking for CephFS... "
> +AC_CHECK_HEADERS(cephfs/libcephfs.h)
> +
> +save_LIBS="$LIBS"
> +LIBS="$LIBS -lcephfs"
> +AC_TRY_LINK([#include <cephfs/libcephfs.h>],
> + [ceph_version(0, 0, 0)],
> + samba_cv_HAVE_CEPHFS=yes,
> + samba_cv_HAVE_CEPHFS=no
> + )
> +
> +if test x"$ac_cv_header_cephfs_libcephfs_h" = x"yes" && test x"$samba_cv_HAVE_CEPHFS" = x"yes"; then
> + AC_DEFINE(HAVE_CEPH, 1, [Whether CEPH headers are available])
> + default_shared_modules="$default_shared_modules vfs_ceph"
> + save_CFLAGS="$CFLAGS"
> + save_LDFLAGS="$LDFLAGS"
> + save_LIBS="$save_LIBS -lcephfs"
> +else
> + if test x"$CEPHFS_PATH_SPEC" = x"yes"; then
> + AC_MSG_ERROR([No valid libcephfs found in ${CEPHFS_PATH}])
> + fi
> +fi
> +
> +CFLAGS="$save_CFLAGS"
> +LDFLAGS="$save_LDFLAGS"
> +LIBS="$save_LIBS"
> +
> # 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 +6485,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_ceph, \$(VFS_CEPH_OBJ), "bin/ceph.$SHLIBEXT", VFS)
>
> SMB_SUBSYSTEM(VFS,smbd/vfs.o)
>
> diff --git a/source3/modules/vfs_ceph.c b/source3/modules/vfs_ceph.c
> new file mode 100644
> index 0000000..fdb7feb
> --- /dev/null
> +++ b/source3/modules/vfs_ceph.c
> @@ -0,0 +1,1261 @@
> +/*
> + Unix SMB/CIFS implementation.
> + Wrap disk only vfs functions to sidestep dodgy compilers.
> + Copyright (C) Tim Potter 1998
> + Copyright (C) Jeremy Allison 2007
> + Copyright (C) Brian Chrisman 2011 <bchrisman at gmail.com>
> + Copyright (C) Richard Sharpe 2011 <realrichardsharpe at gmail.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/>.
> +*/
> +
> +/*
> + * This VFS only works with the libceph.so user-space client. It is not needed
> + * if you are using the kernel client or the FUSE client.
> + *
> + * Add the following smb.conf parameter to each share that will be hosted on
> + * Ceph:
> + *
> + * vfs objects = ceph [any others you need go here]
> + */
> +
> +#include "includes.h"
> +#include "smbd/smbd.h"
> +#include <dirent.h>
> +#include <sys/statvfs.h>
> +#include "cephfs/libcephfs.h"
> +#include "smbprofile.h"
> +
> +#undef DBGC_CLASS
> +#define DBGC_CLASS DBGC_VFS
> +
> +/*
> + * Use %llu whenever we have a 64bit unsigned int, and cast to (long long unsigned)
> + */
> +#define llu(_var) ((long long unsigned)_var)
> +
> +/*
> + * Note, libceph's return code model is to return -errno! So we have to convert
> + * to what Samba expects, with is set errno to -return and return -1
> + */
> +#define WRAP_RETURN(_res) \
> + errno = 0; \
> + if (_res < 0) { \
> + errno = -_res; \
> + return -1; \
> + } \
> + return _res \
> +
> +/*
> + * We mount only one file system and then all shares are assumed to be in that.
> + * FIXME: If we want to support more than one FS, then we have to deal with
> + * this differently.
> + *
> + * So, cmount tells us if we have been this way before and whether
> + * we need to mount ceph and cmount_cnt tells us how many times we have
> + * connected
> + */
> +static struct ceph_mount_info * cmount = NULL;
> +static uint32_t cmount_cnt = 0;
> +
> +/* Check for NULL pointer parameters in cephwrap_* functions */
> +
> +/* We don't want to have NULL function pointers lying around. Someone
> + is sure to try and execute them. These stubs are used to prevent
> + this possibility. */
> +
> +static int cephwrap_connect(struct vfs_handle_struct *handle, const char *service, const char *user)
> +{
> + int ret;
> + char buf[256];
> +
> + const char * conf_file;
> +
> + if (cmount) {
> + handle->data = cmount; /* We have been here before */
> + cmount_cnt++;
> + return 0;
> + }
> +
> + conf_file = lp_parm_const_string(SNUM(handle->conn), "ceph", "config_file", NULL);
> +
> + DEBUG(2, ( "[CEPH] calling: ceph_create\n" ));
> + ret = ceph_create(&cmount, NULL);
> + if (ret)
> + goto err_out;
> +
> + if (conf_file) {
> + /* Override the config file */
> + DEBUG(2, ( "[CEPH] calling: ceph_conf_read_file\n" ));
> + ret = ceph_conf_read_file(cmount, conf_file);
> + } else {
> +
> + DEBUG(2, ( "[CEPH] calling: ceph_conf_read_file with %s\n", conf_file));
> + ret = ceph_conf_read_file(cmount, NULL);
> + }
> +
> + if (ret)
> + goto err_out;
> +
> + DEBUG(2, ( "[CEPH] calling: ceph_conf_get\n" ));
> + ret = ceph_conf_get(cmount, "log file", buf, sizeof(buf));
> + if (ret < 0)
> + goto err_out;
> +
> + DEBUG(2, ("[CEPH] calling: ceph_mount\n"));
> + ret = ceph_mount(cmount, NULL);
> + if (ret < 0)
> + goto err_out;
> +
> +
> + /*
> + * encode mount context/state into our vfs/connection holding structure
> + * cmount is a ceph_mount_t*
> + */
> + handle->data = cmount;
> + cmount_cnt++;
> +
> + return 0;
> +
> +err_out:
> + /*
> + * Handle the error correctly. Ceph returns -errno.
> + */
> + DEBUG(2, ("[CEPH] Error return: %s\n", strerror(-ret)));
> + WRAP_RETURN(ret);
> +}
> +
> +static void cephwrap_disconnect(struct vfs_handle_struct *handle)
> +{
> + if (!cmount) {
> + DEBUG(0, ("[CEPH] Error, ceph not mounted\n"));
> + return;
> + }
> +
> + /* Should we unmount/shutdown? Only if the last disconnect? */
> + if (--cmount_cnt) {
> + DEBUG(10, ("[CEPH] Not shuting down CEPH because still more connections\n"));
> + return;
> + }
> +
> + ceph_shutdown(cmount);
> +
> + cmount = NULL; /* Make it safe */
> +}
> +
> +/* Disk operations */
> +
> +static uint64_t cephwrap_disk_free(struct vfs_handle_struct *handle, const char *path, bool small_query, uint64_t *bsize,
> + uint64_t *dfree, uint64_t *dsize)
> +{
> + struct statvfs statvfs_buf;
> + int ret;
> +
> + if (!(ret = ceph_statfs(handle->data, path, &statvfs_buf))) {
> + /*
> + * Provide all the correct values.
> + */
> + *bsize = statvfs_buf.f_bsize;
> + *dfree = statvfs_buf.f_bsize * statvfs_buf.f_bavail;
> + *dsize = statvfs_buf.f_bsize * statvfs_buf.f_blocks;
> + DEBUG(10, ("[CEPH] bsize: %llu, dfree: %llu, dsize: %llu\n",
> + llu(*bsize), llu(*dfree), llu(*dsize)));
> + return *dfree;
> + } else {
> + DEBUG(10, ("[CEPH] ceph_statfs returned %d\n", ret));
> + WRAP_RETURN(ret);
> + }
> +}
> +
> +static int cephwrap_get_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
> +{
> + /* libceph: Ceph does not implement this */
> +#if 0
> +/* was ifdef HAVE_SYS_QUOTAS */
> + int ret;
> +
> + ret = ceph_get_quota(handle->conn->connectpath, qtype, id, qt);
> +
> + if (ret) {
> + errno = -ret;
> + ret = -1;
> + }
> +
> + return ret;
> +#else
> + errno = ENOSYS;
> + return -1;
> +#endif
> +}
> +
> +static int cephwrap_set_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
> +{
> + /* libceph: Ceph does not implement this */
> +#if 0
> +/* was ifdef HAVE_SYS_QUOTAS */
> + int ret;
> +
> + ret = ceph_set_quota(handle->conn->connectpath, qtype, id, qt);
> + if (ret) {
> + errno = -ret;
> + ret = -1;
> + }
> +
> + return ret;
> +#else
> + WRAP_RETURN(-ENOSYS);
> +#endif
> +}
> +
> +static int cephwrap_statvfs(struct vfs_handle_struct *handle, const char *path, vfs_statvfs_struct *statbuf)
> +{
> + struct statvfs statvfs_buf;
> + int ret;
> +
> + ret = ceph_statfs(handle->data, path, &statvfs_buf);
> + if (ret < 0) {
> + WRAP_RETURN(ret);
> + } else {
> + statbuf->OptimalTransferSize = statvfs_buf.f_frsize;
> + statbuf->BlockSize = statvfs_buf.f_bsize;
> + statbuf->TotalBlocks = statvfs_buf.f_blocks;
> + statbuf->BlocksAvail = statvfs_buf.f_bfree;
> + statbuf->UserBlocksAvail = statvfs_buf.f_bavail;
> + statbuf->TotalFileNodes = statvfs_buf.f_files;
> + statbuf->FreeFileNodes = statvfs_buf.f_ffree;
> + statbuf->FsIdentifier = statvfs_buf.f_fsid;
> + DEBUG(10, ("[CEPH] f_bsize: %ld, f_blocks: %ld, f_bfree: %ld, f_bavail: %ld\n",
> + statvfs_buf.f_bsize, statvfs_buf.f_blocks,
> + statvfs_buf.f_bfree, statvfs_buf.f_bavail));
> + }
> + return ret;
> +}
> +
> +/* Directory operations */
> +
> +static DIR *cephwrap_opendir(struct vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attr)
> +{
> + int ret = 0;
> + struct ceph_dir_result *result;
> + DEBUG(10, ("[CEPH] opendir(%p, %s)\n", handle, fname));
> +
> + /* Returns NULL if it does not exist or there are problems ? */
> + ret = ceph_opendir(handle->data, fname, &result);
> + if (ret < 0) {
> + result = NULL;
> + errno = -ret; /* We return result which is NULL in this case */
> + }
> +
> + DEBUG(10, ("[CEPH] opendir(...) = %d\n", ret));
> + return (DIR *) result;
> +}
> +
> +static DIR *cephwrap_fdopendir(struct vfs_handle_struct *handle,
> + struct files_struct *fsp,
> + const char *mask,
> + uint32 attributes)
> +{
> + int ret = 0;
> + struct ceph_dir_result *result;
> + DEBUG(10, ("[CEPH] fdopendir(%p, %p)\n", handle, fsp));
> +
> + ret = ceph_opendir(handle->data, fsp->fsp_name->base_name, &result);
> + if (ret < 0) {
> + result = NULL;
> + errno = -ret; /* We return result which is NULL in this case */
> + }
> +
> + DEBUG(10, ("[CEPH] fdopendir(...) = %d\n", ret));
> + return (DIR *) result;
> +}
> +
> +static struct dirent *cephwrap_readdir(struct vfs_handle_struct *handle,
> + DIR *dirp,
> + SMB_STRUCT_STAT *sbuf)
> +{
> + struct dirent *result;
> +
> + DEBUG(10, ("[CEPH] readdir(%p, %p)\n", handle, dirp));
> + result = ceph_readdir(handle->data, (struct ceph_dir_result *) dirp);
> + DEBUG(10, ("[CEPH] readdir(...) = %p\n", result));
> +
> + /* Default Posix readdir() does not give us stat info.
> + * Set to invalid to indicate we didn't return this info. */
> + if (sbuf)
> + SET_STAT_INVALID(*sbuf);
> + return result;
> +}
> +
> +static void cephwrap_seekdir(struct vfs_handle_struct *handle, DIR *dirp, long offset)
> +{
> + DEBUG(10, ("[CEPH] seekdir(%p, %p, %ld)\n", handle, dirp, offset));
> + ceph_seekdir(handle->data, (struct ceph_dir_result *) dirp, offset);
> +}
> +
> +static long cephwrap_telldir(struct vfs_handle_struct *handle, DIR *dirp)
> +{
> + long ret;
> + DEBUG(10, ("[CEPH] telldir(%p, %p)\n", handle, dirp));
> + ret = ceph_telldir(handle->data, (struct ceph_dir_result *) dirp);
> + DEBUG(10, ("[CEPH] telldir(...) = %ld\n", ret));
> + WRAP_RETURN(ret);
> +}
> +
> +static void cephwrap_rewinddir(struct vfs_handle_struct *handle, DIR *dirp)
> +{
> + DEBUG(10, ("[CEPH] rewinddir(%p, %p)\n", handle, dirp));
> + ceph_rewinddir(handle->data, (struct ceph_dir_result *) dirp);
> +}
> +
> +static int cephwrap_mkdir(struct vfs_handle_struct *handle, const char *path, mode_t mode)
> +{
> + int result;
> + bool has_dacl = False;
> + char *parent = NULL;
> +
> + DEBUG(10, ("[CEPH] mkdir(%p, %s)\n", handle, path));
> +
> + if (lp_inherit_acls(SNUM(handle->conn))
> + && parent_dirname(talloc_tos(), path, &parent, NULL)
> + && (has_dacl = directory_has_default_acl(handle->conn, parent)))
> + mode = 0777;
> +
> + TALLOC_FREE(parent);
> +
> + result = ceph_mkdir(handle->data, path, mode);
> +
> + /*
> + * Note. This order is important
> + */
> + if (result) {
> + WRAP_RETURN(result);
> + } else if (result == 0 && !has_dacl) {
> + /*
> + * We need to do this as the default behavior of POSIX ACLs
> + * is to set the mask to be the requested group permission
> + * bits, not the group permission bits to be the requested
> + * group permission bits. This is not what we want, as it will
> + * mess up any inherited ACL bits that were set. JRA.
> + */
> + int saved_errno = errno; /* We may get ENOSYS */
> + if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
> + errno = saved_errno;
> + }
> +
> + return result;
> +}
> +
> +static int cephwrap_rmdir(struct vfs_handle_struct *handle, const char *path)
> +{
> + int result;
> +
> + DEBUG(10, ("[CEPH] rmdir(%p, %s)\n", handle, path));
> + result = ceph_rmdir(handle->data, path);
> + DEBUG(10, ("[CEPH] rmdir(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_closedir(struct vfs_handle_struct *handle, DIR *dirp)
> +{
> + int result;
> +
> + DEBUG(10, ("[CEPH] closedir(%p, %p)\n", handle, dirp));
> + result = ceph_closedir(handle->data, (struct ceph_dir_result *) dirp);
> + DEBUG(10, ("[CEPH] closedir(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +/* File operations */
> +
> +static int cephwrap_open(struct vfs_handle_struct *handle,
> + struct smb_filename *smb_fname,
> + files_struct *fsp, int flags, mode_t mode)
> +{
> + int result = -ENOENT;
> + DEBUG(10, ("[CEPH] open(%p, %s, %p, %d, %d)\n", handle, smb_fname_str_dbg(smb_fname), fsp, flags, mode));
> +
> + if (smb_fname->stream_name) {
> + goto out;
> + }
> +
> + result = ceph_open(handle->data, smb_fname->base_name, flags, mode);
> +out:
> + DEBUG(10, ("[CEPH] open(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_close(struct vfs_handle_struct *handle, files_struct *fsp)
> +{
> + int result;
> +
> + DEBUG(10, ("[CEPH] close(%p, %p)\n", handle, fsp));
> + result = ceph_close(handle->data, fsp->fh->fd);
> + DEBUG(10, ("[CEPH] close(...) = %d\n", result));
> +
> + WRAP_RETURN(result);
> +}
> +
> +static ssize_t cephwrap_read(struct vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
> +{
> + ssize_t result;
> +
> + DEBUG(10, ("[CEPH] read(%p, %p, %p, %llu)\n", handle, fsp, data, llu(n)));
> +
> + /* Using -1 for the offset means read/write rather than pread/pwrite */
> + result = ceph_read(handle->data, fsp->fh->fd, data, n, -1);
> + DEBUG(10, ("[CEPH] read(...) = %llu\n", llu(result)));
> + WRAP_RETURN(result);
> +}
> +
> +static ssize_t cephwrap_pread(struct vfs_handle_struct *handle, files_struct *fsp, void *data,
> + size_t n, off_t offset)
> +{
> + ssize_t result;
> +
> + DEBUG(10, ("[CEPH] pread(%p, %p, %p, %llu, %llu)\n", handle, fsp, data, llu(n), llu(offset)));
> +
> + result = ceph_read(handle->data, fsp->fh->fd, data, n, offset);
> + DEBUG(10, ("[CEPH] pread(...) = %llu\n", llu(result)));
> + WRAP_RETURN(result);
> +}
> +
> +
> +static ssize_t cephwrap_write(struct vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
> +{
> + ssize_t result;
> +
> + DEBUG(10, ("[CEPH] write(%p, %p, %p, %llu)\n", handle, fsp, data, llu(n)));
> +
> + result = ceph_write(handle->data, fsp->fh->fd, data, n, -1);
> +
> + DEBUG(10, ("[CEPH] write(...) = %llu\n", llu(result)));
> + if (result < 0) {
> + WRAP_RETURN(result);
> + }
> + fsp->fh->pos += result;
> + return result;
> +}
> +
> +static ssize_t cephwrap_pwrite(struct vfs_handle_struct *handle, files_struct *fsp, const void *data,
> + size_t n, off_t offset)
> +{
> + ssize_t result;
> +
> + DEBUG(10, ("[CEPH] pwrite(%p, %p, %p, %llu, %llu)\n", handle, fsp, data, llu(n), llu(offset)));
> + result = ceph_write(handle->data, fsp->fh->fd, data, n, offset);
> + DEBUG(10, ("[CEPH] pwrite(...) = %llu\n", llu(result)));
> + WRAP_RETURN(result);
> +}
> +
> +static off_t cephwrap_lseek(struct vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
> +{
> + off_t result = 0;
> +
> + DEBUG(10, ("[CEPH] cephwrap_lseek\n"));
> + /* Cope with 'stat' file opens. */
> + if (fsp->fh->fd != -1) {
> + result = ceph_lseek(handle->data, fsp->fh->fd, offset, whence);
> + }
> + WRAP_RETURN(result);
> +}
> +
> +static ssize_t cephwrap_sendfile(struct vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
> + off_t offset, size_t n)
> +{
> + /*
> + * We cannot support sendfile because libceph is in user space.
> + */
> + DEBUG(10, ("[CEPH] cephwrap_sendfile\n"));
> + errno = ENOTSUP;
> + return -1;
> +}
> +
> +static ssize_t cephwrap_recvfile(struct vfs_handle_struct *handle,
> + int fromfd,
> + files_struct *tofsp,
> + off_t offset,
> + size_t n)
> +{
> + /*
> + * We cannot support recvfile because libceph is in user space.
> + */
> + DEBUG(10, ("[CEPH] cephwrap_recvfile\n"));
> + errno=ENOTSUP;
> + return -1;
> +}
> +
> +static int cephwrap_rename(struct vfs_handle_struct *handle,
> + const struct smb_filename *smb_fname_src,
> + const struct smb_filename *smb_fname_dst)
> +{
> + int result = -1;
> + DEBUG(10, ("[CEPH] cephwrap_rename\n"));
> + if (smb_fname_src->stream_name || smb_fname_dst->stream_name) {
> + errno = ENOENT;
> + return result;
> + }
> +
> + result = ceph_rename(handle->data, smb_fname_src->base_name, smb_fname_dst->base_name);
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_fsync(struct vfs_handle_struct *handle, files_struct *fsp)
> +{
> + int result;
> + DEBUG(10, ("[CEPH] cephwrap_fsync\n"));
> + result = ceph_fsync(handle->data, fsp->fh->fd, false);
> + WRAP_RETURN(result);
> +}
> +
> +static void cephwrap_init_stat_ex_from_stat(struct stat_ex *dst, const struct stat *src)
> +{
> + ZERO_STRUCT(*dst);
> +
> + dst->st_ex_dev = src->st_dev;
> + 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;
> + dst->st_ex_mtime.tv_sec = src->st_mtime;
> + dst->st_ex_ctime.tv_sec = src->st_ctime;
> + dst->st_ex_btime.tv_sec = src->st_mtime;
> + dst->st_ex_blksize = src->st_blksize;
> + dst->st_ex_blocks = src->st_blocks;
> +}
> +
> +static int cephwrap_stat(struct vfs_handle_struct *handle,
> + struct smb_filename *smb_fname)
> +{
> + int result = -1;
> + struct stat stbuf;
> +
> + DEBUG(10, ("[CEPH] stat(%p, %s)\n", handle, smb_fname_str_dbg(smb_fname)));
> +
> + if (smb_fname->stream_name) {
> + errno = ENOENT;
> + return result;
> + }
> +
> + result = ceph_stat(handle->data, smb_fname->base_name, (struct stat *) &stbuf);
> + DEBUG(10, ("[CEPH] stat(...) = %d\n", result));
> + if (result < 0) {
> + WRAP_RETURN(result);
> + } else {
> + DEBUG(10, ("[CEPH]\tstbuf = {dev = %llu, ino = %llu, mode = 0x%x, nlink = %llu, "
> + "uid = %d, gid = %d, rdev = %llu, size = %llu, blksize = %llu, "
> + "blocks = %llu, atime = %llu, mtime = %llu, ctime = %llu}\n",
> + llu(stbuf.st_dev), llu(stbuf.st_ino), stbuf.st_mode, llu(stbuf.st_nlink),
> + stbuf.st_uid, stbuf.st_gid, llu(stbuf.st_rdev), llu(stbuf.st_size), llu(stbuf.st_blksize),
> + llu(stbuf.st_blocks), llu(stbuf.st_atime), llu(stbuf.st_mtime), llu(stbuf.st_ctime)));
> + }
> + cephwrap_init_stat_ex_from_stat(&(smb_fname->st), &stbuf);
> + DEBUG(10, ("[CEPH] mode = 0x%x\n", smb_fname->st.st_ex_mode));
> + return result;
> +}
> +
> +static int cephwrap_fstat(struct vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
> +{
> + int result = -1;
> + struct stat stbuf;
> +
> + DEBUG(10, ("[CEPH] fstat(%p, %d)\n", handle, fsp->fh->fd));
> + result = ceph_fstat(handle->data, fsp->fh->fd, (struct stat *) &stbuf);
> + DEBUG(10, ("[CEPH] fstat(...) = %d\n", result));
> + if (result < 0) {
> + WRAP_RETURN(result);
> + } else {
> + DEBUG(10, ("[CEPH]\tstbuf = {dev = %llu, ino = %llu, mode = 0x%x, nlink = %llu, "
> + "uid = %d, gid = %d, rdev = %llu, size = %llu, blksize = %llu, "
> + "blocks = %llu, atime = %llu, mtime = %llu, ctime = %llu}\n",
> + llu(stbuf.st_dev), llu(stbuf.st_ino), stbuf.st_mode, llu(stbuf.st_nlink),
> + stbuf.st_uid, stbuf.st_gid, llu(stbuf.st_rdev), llu(stbuf.st_size), llu(stbuf.st_blksize),
> + llu(stbuf.st_blocks), llu(stbuf.st_atime), llu(stbuf.st_mtime), llu(stbuf.st_ctime)));
> + }
> +
> + cephwrap_init_stat_ex_from_stat(sbuf, &stbuf);
> + DEBUG(10, ("[CEPH] mode = 0x%x\n", sbuf->st_ex_mode));
> + return result;
> +}
> +
> +static int cephwrap_lstat(struct vfs_handle_struct *handle,
> + struct smb_filename *smb_fname)
> +{
> + int result = -1;
> + struct stat stbuf;
> +
> + DEBUG(10, ("[CEPH] lstat(%p, %s)\n", handle, smb_fname_str_dbg(smb_fname)));
> +
> + if (smb_fname->stream_name) {
> + errno = ENOENT;
> + return result;
> + }
> +
> + result = ceph_lstat(handle->data, smb_fname->base_name, &stbuf);
> + DEBUG(10, ("[CEPH] lstat(...) = %d\n", result));
> + if (result < 0) {
> + WRAP_RETURN(result);
> + }
> + cephwrap_init_stat_ex_from_stat(&(smb_fname->st), &stbuf);
> + return result;
> +}
> +
> +static int cephwrap_unlink(struct vfs_handle_struct *handle,
> + const struct smb_filename *smb_fname)
> +{
> + int result = -1;
> +
> + DEBUG(10, ("[CEPH] unlink(%p, %s)\n", handle, smb_fname_str_dbg(smb_fname)));
> + if (smb_fname->stream_name) {
> + errno = ENOENT;
> + return result;
> + }
> + result = ceph_unlink(handle->data, smb_fname->base_name);
> + DEBUG(10, ("[CEPH] unlink(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_chmod(struct vfs_handle_struct *handle, const char *path, mode_t mode)
> +{
> + int result;
> +
> + DEBUG(10, ("[CEPH] chmod(%p, %s, %d)\n", handle, path, mode));
> +
> + /*
> + * We need to do this due to the fact that the default POSIX ACL
> + * chmod modifies the ACL *mask* for the group owner, not the
> + * group owner bits directly. JRA.
> + */
> +
> +
> + {
> + int saved_errno = errno; /* We might get ENOSYS */
> + if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
> + return result;
> + }
> + /* Error - return the old errno. */
> + errno = saved_errno;
> + }
> +
> + result = ceph_chmod(handle->data, path, mode);
> + DEBUG(10, ("[CEPH] chmod(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_fchmod(struct vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
> +{
> + int result;
> +
> + DEBUG(10, ("[CEPH] fchmod(%p, %p, %d)\n", handle, fsp, mode));
> +
> + /*
> + * We need to do this due to the fact that the default POSIX ACL
> + * chmod modifies the ACL *mask* for the group owner, not the
> + * group owner bits directly. JRA.
> + */
> +
> + {
> + int saved_errno = errno; /* We might get ENOSYS */
> + if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
> + return result;
> + }
> + /* Error - return the old errno. */
> + errno = saved_errno;
> + }
> +
> +#if defined(HAVE_FCHMOD)
> + result = ceph_fchmod(handle->data, fsp->fh->fd, mode);
> + DEBUG(10, ("[CEPH] fchmod(...) = %d\n", result));
> + WRAP_RETURN(result);
> +#else
> + errno = ENOSYS;
> +#endif
> + return -1;
> +}
> +
> +static int cephwrap_chown(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
> +{
> + int result;
> + DEBUG(10, ("[CEPH] chown(%p, %s, %d, %d)\n", handle, path, uid, gid));
> + result = ceph_chown(handle->data, path, uid, gid);
> + DEBUG(10, ("[CEPH] chown(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_fchown(struct vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
> +{
> + int result;
> +#ifdef HAVE_FCHOWN
> +
> + DEBUG(10, ("[CEPH] fchown(%p, %p, %d, %d)\n", handle, fsp, uid, gid));
> + result = ceph_fchown(handle->data, fsp->fh->fd, uid, gid);
> + DEBUG(10, ("[CEPH] fchown(...) = %d\n", result));
> + WRAP_RETURN(result);
> +#else
> + errno = ENOSYS;
> + result = -1;
> +#endif
> + return result;
> +}
> +
> +static int cephwrap_lchown(struct vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
> +{
> + int result;
> +
> + DEBUG(10, ("[CEPH] lchown(%p, %s, %d, %d)\n", handle, path, uid, gid));
> + result = ceph_lchown(handle->data, path, uid, gid);
> + DEBUG(10, ("[CEPH] lchown(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_chdir(struct vfs_handle_struct *handle, const char *path)
> +{
> + int result = -1;
> + DEBUG(10, ("[CEPH] chdir(%p, %s)\n", handle, path));
> + /*
> + * If the path is just / use chdir because Ceph is below / and
> + * cannot deal with changing directory above its mount point
> + */
> + if (path && !strcmp(path, "/"))
> + return chdir(path);
> +
> + result = ceph_chdir(handle->data, path);
> + DEBUG(10, ("[CEPH] chdir(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static char *cephwrap_getwd(struct vfs_handle_struct *handle)
> +{
> + const char *cwd = ceph_getcwd(handle->data);
> + DEBUG(10, ("[CEPH] getwd(%p) = %s\n", handle, cwd));
> + return SMB_STRDUP(cwd);
> +}
> +
> +static int cephwrap_ntimes(struct vfs_handle_struct *handle,
> + const struct smb_filename *smb_fname,
> + struct smb_file_time *ft)
> +{
> + struct utimbuf buf;
> + buf.actime = ft->atime.tv_sec;
> + buf.modtime = ft->mtime.tv_sec;
> + int result = ceph_utime(handle->data, smb_fname->base_name, &buf);
> + DEBUG(10, ("[CEPH] ntimes(%p, %s, {%ld, %ld, %ld, %ld}) = %d\n", handle, smb_fname_str_dbg(smb_fname),
> + ft->mtime.tv_sec, ft->atime.tv_sec, ft->ctime.tv_sec,
> + ft->create_time.tv_sec, result));
> + return result;
> +}
> +
> +static int strict_allocate_ftruncate(struct vfs_handle_struct *handle, files_struct *fsp, off_t len)
> +{
> + off_t space_to_write;
> + uint64_t space_avail;
> + uint64_t bsize,dfree,dsize;
> + int ret;
> + NTSTATUS status;
> + SMB_STRUCT_STAT *pst;
> +
> + status = vfs_stat_fsp(fsp);
> + if (!NT_STATUS_IS_OK(status)) {
> + return -1;
> + }
> + pst = &fsp->fsp_name->st;
> +
> +#ifdef S_ISFIFO
> + if (S_ISFIFO(pst->st_ex_mode))
> + return 0;
> +#endif
> +
> + if (pst->st_ex_size == len)
> + return 0;
> +
> + /* Shrink - just ftruncate. */
> + if (pst->st_ex_size > len)
> + return ftruncate(fsp->fh->fd, len);
> +
> + space_to_write = len - pst->st_ex_size;
> +
> + /* for allocation try fallocate first. This can fail on some
> + platforms e.g. when the filesystem doesn't support it and no
> + emulation is being done by the libc (like on AIX with JFS1). In that
> + case we do our own emulation. fallocate implementations can
> + return ENOTSUP or EINVAL in cases like that. */
> + ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_EXTEND_SIZE,
> + pst->st_ex_size, space_to_write);
> + if (ret == ENOSPC) {
> + errno = ENOSPC;
> + return -1;
> + }
> + if (ret == 0) {
> + return 0;
> + }
> + DEBUG(10,("[CEPH] strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
> + "error %d. Falling back to slow manual allocation\n", ret));
> +
> + /* available disk space is enough or not? */
> + space_avail = get_dfree_info(fsp->conn,
> + fsp->fsp_name->base_name, false,
> + &bsize,&dfree,&dsize);
> + /* space_avail is 1k blocks */
> + if (space_avail == (uint64_t)-1 ||
> + ((uint64_t)space_to_write/1024 > space_avail) ) {
> + errno = ENOSPC;
> + return -1;
> + }
> +
> + /* Write out the real space on disk. */
> + ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
> + if (ret != 0) {
> + errno = ret;
> + ret = -1;
> + }
> +
> + return 0;
> +}
> +
> +static int cephwrap_ftruncate(struct vfs_handle_struct *handle, files_struct *fsp, off_t len)
> +{
> + int result = -1;
> + SMB_STRUCT_STAT st;
> + char c = 0;
> + off_t currpos;
> +
> + DEBUG(10, ("[CEPH] ftruncate(%p, %p, %llu\n", handle, fsp, llu(len)));
> +
> + if (lp_strict_allocate(SNUM(fsp->conn))) {
> + result = strict_allocate_ftruncate(handle, fsp, len);
> + return result;
> + }
> +
> + /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
> + sys_ftruncate if the system supports it. Then I discovered that
> + you can have some filesystems that support ftruncate
> + expansion and some that don't! On Linux fat can't do
> + ftruncate extend but ext2 can. */
> +
> + result = ceph_ftruncate(handle->data, fsp->fh->fd, len);
> + if (result == 0)
> + goto done;
> +
> + /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
> + extend a file with ftruncate. Provide alternate implementation
> + for this */
> + currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
> + if (currpos == -1) {
> + goto done;
> + }
> +
> + /* Do an fstat to see if the file is longer than the requested
> + size in which case the ftruncate above should have
> + succeeded or shorter, in which case seek to len - 1 and
> + write 1 byte of zero */
> + if (SMB_VFS_FSTAT(fsp, &st) == -1) {
> + goto done;
> + }
> +
> +#ifdef S_ISFIFO
> + if (S_ISFIFO(st.st_ex_mode)) {
> + result = 0;
> + goto done;
> + }
> +#endif
> +
> + if (st.st_ex_size == len) {
> + result = 0;
> + goto done;
> + }
> +
> + if (st.st_ex_size > len) {
> + /* the sys_ftruncate should have worked */
> + goto done;
> + }
> +
> + if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
> + goto done;
> +
> + if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
> + goto done;
> +
> + /* Seek to where we were */
> + if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
> + goto done;
> + result = 0;
> +
> + done:
> +
> + return result;
> +}
> +
> +static bool cephwrap_lock(struct vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
> +{
> + DEBUG(10, ("[CEPH] lock\n"));
> + return true;
> +}
> +
> +static int cephwrap_kernel_flock(struct vfs_handle_struct *handle, files_struct *fsp,
> + uint32 share_mode, uint32 access_mask)
> +{
> + DEBUG(10, ("[CEPH] kernel_flock\n"));
> + /*
> + * We must return zero here and pretend all is good.
> + * One day we might have this in CEPH.
> + */
> + return 0;
> +}
> +
> +static bool cephwrap_getlock(struct vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
> +{
> + DEBUG(10, ("[CEPH] getlock returning false and errno=0\n"));
> +
> + errno = 0;
> + return false;
> +}
> +
> +/*
> + * We cannot let this fall through to the default, because the file might only
> + * be accessible from libceph (which is a user-space client) but the fd might
> + * be for some file the kernel knows about.
> + */
> +static int cephwrap_linux_setlease(struct vfs_handle_struct *handle, files_struct *fsp,
> + int leasetype)
> +{
> + int result = -1;
> +
> + DEBUG(10, ("[CEPH] linux_setlease\n"));
> + errno = ENOSYS;
> + return result;
> +}
> +
> +static int cephwrap_symlink(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath)
> +{
> + int result = -1;
> + DEBUG(10, ("[CEPH] symlink(%p, %s, %s)\n", handle, oldpath, newpath));
> + result = ceph_symlink(handle->data, oldpath, newpath);
> + DEBUG(10, ("[CEPH] symlink(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_readlink(struct vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
> +{
> + int result = -1;
> + DEBUG(10, ("[CEPH] readlink(%p, %s, %p, %llu)\n", handle, path, buf, llu(bufsiz)));
> + result = ceph_readlink(handle->data, path, buf, bufsiz);
> + DEBUG(10, ("[CEPH] readlink(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_link(struct vfs_handle_struct *handle, const char *oldpath, const char *newpath)
> +{
> + int result = -1;
> + DEBUG(10, ("[CEPH] link(%p, %s, %s)\n", handle, oldpath, newpath));
> + result = ceph_link(handle->data, oldpath, newpath);
> + DEBUG(10, ("[CEPH] link(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +static int cephwrap_mknod(struct vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
> +{
> + int result = -1;
> + DEBUG(10, ("[CEPH] mknod(%p, %s)\n", handle, pathname));
> + result = ceph_mknod(handle->data, pathname, mode, dev);
> + DEBUG(10, ("[CEPH] mknod(...) = %d\n", result));
> + WRAP_RETURN(result);
> +}
> +
> +/*
> + * This is a simple version of real-path ... a better version is needed to
> + * ask libceph about symbolic links.
> + */
> +static char *cephwrap_realpath(struct vfs_handle_struct *handle, const char *path)
> +{
> + char *result;
> + size_t len = strlen(path);
> +
> + result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
> + if (len && (path[0] == '/')) {
> + int r = asprintf(&result, "%s", path);
> + if (r < 0) return NULL;
> + } else if ((len >= 2) && (path[0] == '.') && (path[1] == '/')) {
> + if (len == 2) {
> + int r = asprintf(&result, "%s",
> + handle->conn->connectpath);
> + if (r < 0) return NULL;
> + } else {
> + int r = asprintf(&result, "%s/%s",
> + handle->conn->connectpath, &path[2]);
> + if (r < 0) return NULL;
> + }
> + } else {
> + int r = asprintf(&result, "%s/%s",
> + handle->conn->connectpath, path);
> + if (r < 0) return NULL;
> + }
> + DEBUG(10, ("[CEPH] realpath(%p, %s) = %s\n", handle, path, result));
> + return result;
> +}
> +
> +static NTSTATUS cephwrap_notify_watch(struct vfs_handle_struct *vfs_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)
> +{
> + /*
> + * We cannot call inotify on files the kernel does not know about
> + */
> + return NT_STATUS_OK;
> +}
> +
> +static int cephwrap_chflags(struct vfs_handle_struct *handle, const char *path,
> + unsigned int flags)
> +{
> + errno = ENOSYS;
> + return -1;
> +}
> +
> +static int cephwrap_get_real_filename(struct vfs_handle_struct *handle,
> + const char *path,
> + const char *name,
> + TALLOC_CTX *mem_ctx,
> + char **found_name)
> +{
> + /*
> + * Don't fall back to get_real_filename so callers can differentiate
> + * between a full directory scan and an actual case-insensitive stat.
> + */
> + errno = EOPNOTSUPP;
> + return -1;
> +}
> +
> +static const char *cephwrap_connectpath(struct vfs_handle_struct *handle,
> + const char *fname)
> +{
> + return handle->conn->connectpath;
> +}
> +
> +/****************************************************************
> + Extended attribute operations.
> +*****************************************************************/
> +
> +static ssize_t cephwrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
> +{
> + DEBUG(10, ("[CEPH] getxattr(%p, %s, %s, %p, %llu)\n", handle, path, name, value, llu(size)));
> + int ret = ceph_getxattr(handle->data, path, name, value, size);
> + DEBUG(10, ("[CEPH] getxattr(...) = %d\n", ret));
> + if (ret < 0) {
> + WRAP_RETURN(ret);
> + } else {
> + return (ssize_t)ret;
> + }
> +}
> +
> +static ssize_t cephwrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
> +{
> + DEBUG(10, ("[CEPH] fgetxattr(%p, %p, %s, %p, %llu)\n", handle, fsp, name, value, llu(size)));
> + int ret = ceph_getxattr(handle->data, fsp->fsp_name->base_name, name, value, size);
> + DEBUG(10, ("[CEPH] fgetxattr(...) = %d\n", ret));
> + if (ret < 0) {
> + WRAP_RETURN(ret);
> + } else {
> + return (ssize_t)ret;
> + }
> +}
> +
> +static ssize_t cephwrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
> +{
> + DEBUG(10, ("[CEPH] listxattr(%p, %s, %p, %llu)\n", handle, path, list, llu(size)));
> + int ret = ceph_listxattr(handle->data, path, list, size);
> + DEBUG(10, ("[CEPH] listxattr(...) = %d\n", ret));
> + if (ret < 0) {
> + WRAP_RETURN(ret);
> + } else {
> + return (ssize_t)ret;
> + }
> +}
> +
> +static ssize_t cephwrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
> +{
> + DEBUG(10, ("[CEPH] llistxattr(%p, %s, %p, %llu)\n", handle, path, list, llu(size)));
> + int ret = ceph_llistxattr(handle->data, path, list, size);
> + DEBUG(10, ("[CEPH] listxattr(...) = %d\n", ret));
> + if (ret < 0) {
> + WRAP_RETURN(ret);
> + } else {
> + return (ssize_t)ret;
> + }
> +}
> +
> +static ssize_t cephwrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
> +{
> + DEBUG(10, ("[CEPH] flistxattr(%p, %p, %s, %llu)\n", handle, fsp, list, llu(size)));
> + int ret = ceph_listxattr(handle->data, fsp->fsp_name->base_name, list, size);
> + DEBUG(10, ("[CEPH] flistxattr(...)\n", ret));
> + if (ret < 0) {
> + WRAP_RETURN(ret);
> + } else {
> + return (ssize_t)ret;
> + }
> +}
> +
> +static int cephwrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
> +{
> + DEBUG(10, ("[CEPH] removexattr(%p, %s, %s)\n", handle, path, name));
> + int ret = ceph_removexattr(handle->data, path, name);
> + DEBUG(10, ("[CEPH] removexattr(...) = %d\n", ret));
> + WRAP_RETURN(ret);
> +}
> +
> +static int cephwrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
> +{
> + DEBUG(10, ("[CEPH] fremovexattr(%p, %p, %s)\n", handle, fsp, name));
> + int ret = ceph_removexattr(handle->data, fsp->fsp_name->base_name, name);
> + DEBUG(10, ("[CEPH] fremovexattr(...) = %d\n", ret));
> + WRAP_RETURN(ret);
> +}
> +
> +static int cephwrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
> +{
> + DEBUG(10, ("[CEPH] setxattr(%p, %s, %s, %p, %llu, %d)\n", handle, path, name, value, llu(size), flags));
> + int ret = ceph_setxattr(handle->data, path, name, value, size, flags);
> + DEBUG(10, ("[CEPH] setxattr(...) = %d\n", ret));
> + WRAP_RETURN(ret);
> +}
> +
> +static int cephwrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
> +{
> + DEBUG(10, ("[CEPH] fsetxattr(%p, %p, %s, %p, %llu, %d)\n", handle, fsp, name, value, llu(size), flags));
> + int ret = ceph_setxattr(handle->data, fsp->fsp_name->base_name, name, value, size, flags);
> + DEBUG(10, ("[CEPH] fsetxattr(...) = %d\n", ret));
> + WRAP_RETURN(ret);
> +}
> +
> +static bool cephwrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
> +{
> +
> + /*
> + * We do not support AIO yet.
> + */
> +
> + DEBUG(10, ("[CEPH] cephwrap_aio_force(%p, %p) = false (errno = ENOTSUP)\n", handle, fsp));
> + errno = ENOTSUP;
> + return false;
> +}
> +
> +static bool cephwrap_is_offline(struct vfs_handle_struct *handle,
> + const struct smb_filename *fname,
> + SMB_STRUCT_STAT *sbuf)
> +{
> + return false;
> +}
> +
> +static int cephwrap_set_offline(struct vfs_handle_struct *handle,
> + const struct smb_filename *fname)
> +{
> + errno = ENOTSUP;
> + return -1;
> +}
> +
> +static struct vfs_fn_pointers ceph_fns = {
> + /* Disk operations */
> +
> + .connect_fn = cephwrap_connect,
> + .disconnect_fn = cephwrap_disconnect,
> + .disk_free_fn = cephwrap_disk_free,
> + .get_quota_fn = cephwrap_get_quota,
> + .set_quota_fn = cephwrap_set_quota,
> + .statvfs_fn = cephwrap_statvfs,
> +
> + /* Directory operations */
> +
> + .opendir_fn = cephwrap_opendir,
> + .fdopendir_fn = cephwrap_fdopendir,
> + .readdir_fn = cephwrap_readdir,
> + .seekdir_fn = cephwrap_seekdir,
> + .telldir_fn = cephwrap_telldir,
> + .rewind_dir_fn = cephwrap_rewinddir,
> + .mkdir_fn = cephwrap_mkdir,
> + .rmdir_fn = cephwrap_rmdir,
> + .closedir_fn = cephwrap_closedir,
> +
> + /* File operations */
> +
> + .open_fn = cephwrap_open,
> + .close_fn = cephwrap_close,
> + .read_fn = cephwrap_read,
> + .pread_fn = cephwrap_pread,
> + .write_fn = cephwrap_write,
> + .pwrite_fn = cephwrap_pwrite,
> + .lseek_fn = cephwrap_lseek,
> + .sendfile_fn = cephwrap_sendfile,
> + .recvfile_fn = cephwrap_recvfile,
> + .rename_fn = cephwrap_rename,
> + .fsync_fn = cephwrap_fsync,
> + .stat_fn = cephwrap_stat,
> + .fstat_fn = cephwrap_fstat,
> + .lstat_fn = cephwrap_lstat,
> + .unlink_fn = cephwrap_unlink,
> + .chmod_fn = cephwrap_chmod,
> + .fchmod_fn = cephwrap_fchmod,
> + .chown_fn = cephwrap_chown,
> + .fchown_fn = cephwrap_fchown,
> + .lchown_fn = cephwrap_lchown,
> + .chdir_fn = cephwrap_chdir,
> + .getwd_fn = cephwrap_getwd,
> + .ntimes_fn = cephwrap_ntimes,
> + .ftruncate_fn = cephwrap_ftruncate,
> + .lock_fn = cephwrap_lock,
> + .kernel_flock_fn = cephwrap_kernel_flock,
> + .linux_setlease_fn = cephwrap_linux_setlease,
> + .getlock_fn = cephwrap_getlock,
> + .symlink_fn = cephwrap_symlink,
> + .readlink_fn = cephwrap_readlink,
> + .link_fn = cephwrap_link,
> + .mknod_fn = cephwrap_mknod,
> + .realpath_fn = cephwrap_realpath,
> + .notify_watch_fn = cephwrap_notify_watch,
> + .chflags_fn = cephwrap_chflags,
> + .get_real_filename_fn = cephwrap_get_real_filename,
> + .connectpath_fn = cephwrap_connectpath,
> +
> + /* EA operations. */
> + .getxattr_fn = cephwrap_getxattr,
> + .fgetxattr_fn = cephwrap_fgetxattr,
> + .listxattr_fn = cephwrap_listxattr,
> + .flistxattr_fn = cephwrap_flistxattr,
> + .removexattr_fn = cephwrap_removexattr,
> + .fremovexattr_fn = cephwrap_fremovexattr,
> + .setxattr_fn = cephwrap_setxattr,
> + .fsetxattr_fn = cephwrap_fsetxattr,
> +
> + /* aio operations */
> + .aio_force_fn = cephwrap_aio_force,
> +
> + /* offline operations */
> + .is_offline_fn = cephwrap_is_offline,
> + .set_offline_fn = cephwrap_set_offline
> +};
> +
> +NTSTATUS vfs_ceph_init(void);
> +NTSTATUS vfs_ceph_init(void)
> +{
> + return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
> + "ceph", &ceph_fns);
> +}
> diff --git a/source3/modules/wscript_build b/source3/modules/wscript_build
> index 6726ac3..df4f59a 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_CEPH_SRC = 'vfs_ceph.c'
>
>
> bld.SAMBA3_SUBSYSTEM('NFS4_ACLS',
> @@ -503,3 +504,12 @@ 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_ceph',
> + subsystem='vfs',
> + source=VFS_CEPH_SRC,
> + deps='samba-util cephfs',
> + init_function='',
> + internal_module=bld.SAMBA3_IS_STATIC_MODULE('vfs_ceph'),
> + enabled=bld.SAMBA3_IS_ENABLED_MODULE('vfs_ceph'),
> + cflags=bld.CONFIG_GET('CCFLAGS_CEPHFS'))
> diff --git a/source3/wscript b/source3/wscript
> index d687dae..18e45f2 100644
> --- a/source3/wscript
> +++ b/source3/wscript
> @@ -54,6 +54,10 @@ def set_options(opt):
> help=("enable building against (too) old version of ctdb (default=false)"),
> action="store_true", dest='enable_old_ctdb', default=False)
>
> + opt.add_option('--with-libcephfs',
> + help=("Directory under which libcephfs is installed"),
> + action="store", dest='libcephfs_dir', default=None)
> +
>
>
> def configure(conf):
> @@ -1699,6 +1703,14 @@ main() {
> if conf.CHECK_HEADERS('linux/ioctl.h sys/ioctl.h'):
> conf.DEFINE('HAVE_LINUX_IOCTL', '1')
>
> + conf.env['CCFLAGS_CEPHFS'] = "-D_FILE_OFFSET_BITS=64"
> + if Options.options.libcephfs_dir:
> + conf.env['CPPPATH_CEPHFS'] = Options.options.libcephfs_dir + '/include'
> + conf.env['LIBPATH_CEPHFS'] = Options.options.libcephfs_dir + '/lib'
> +
> + if conf.CHECK_HEADERS('cephfs/libcephfs.h', False, False, 'cephfs') and conf.CHECK_LIB('cephfs'):
> + conf.DEFINE('HAVE_CEPH', '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 +1778,9 @@ main() {
> if conf.CONFIG_SET('SAMBA_FAM_LIBS'):
> default_shared_modules.extend(TO_LIST('vfs_notify_fam'))
>
> + if conf.CONFIG_SET("HAVE_CEPH"):
> + default_shared_modules.extend(TO_LIST('vfs_ceph'))
> +
> explicit_shared_modules = TO_LIST(Options.options.shared_modules, delimiter=',')
> explicit_static_modules = TO_LIST(Options.options.static_modules, delimiter=',')
>
> --
> 1.7.10.4
>
More information about the samba-technical
mailing list