*/
#include "includes.h"
+#include "smbd/smbd.h"
+#include "librpc/gen_ndr/ndr_xattr.h"
+#include "include/smbprofile.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_VFS
#include <gpfs_gpl.h>
#include "nfs4_acls.h"
#include "vfs_gpfs.h"
+#include "system/filesys.h"
+
+struct gpfs_config_data {
+ bool sharemodes;
+ bool leases;
+ bool hsm;
+ bool syncio;
+};
+
static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
- uint32 share_mode)
+ uint32 share_mode, uint32 access_mask)
{
- START_PROFILE(syscall_kernel_flock);
+ struct gpfs_config_data *config;
- kernel_flock(fsp->fh->fd, share_mode);
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
- if (!set_gpfs_sharemode(fsp, fsp->access_mask, fsp->share_access)) {
+ START_PROFILE(syscall_kernel_flock);
- return -1;
+ kernel_flock(fsp->fh->fd, share_mode, access_mask);
+ if (config->sharemodes
+ && !set_gpfs_sharemode(fsp, access_mask, fsp->share_access)) {
+ return -1;
}
END_PROFILE(syscall_kernel_flock);
return 0;
}
+static int vfs_gpfs_close(vfs_handle_struct *handle, files_struct *fsp)
+{
+
+ struct gpfs_config_data *config;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
+
+ if (config->sharemodes && (fsp->fh != NULL) && (fsp->fh->fd != -1)) {
+ set_gpfs_sharemode(fsp, 0, 0);
+ }
+
+ return SMB_VFS_NEXT_CLOSE(handle, fsp);
+}
+
static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp,
int leasetype)
{
- int ret;
+ struct gpfs_config_data *config;
+ int ret=0;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
START_PROFILE(syscall_linux_setlease);
- if ( linux_set_lease_sighandler(fsp->fh->fd) == -1)
+ if (linux_set_lease_sighandler(fsp->fh->fd) == -1)
return -1;
- ret = set_gpfs_lease(fsp->fh->fd,leasetype);
+ if (config->leases) {
+ ret = set_gpfs_lease(fsp->fh->fd,leasetype);
+ }
- if ( ret < 0 ) {
+ if (ret < 0) {
/* This must have come from GPFS not being available */
/* or some other error, hence call the default */
ret = linux_setlease(fsp->fh->fd, leasetype);
char *full_path;
char real_pathname[PATH_MAX+1];
int buflen;
+ bool mangled;
+
+ mangled = mangle_is_mangled(name, handle->conn->params);
+ if (mangled) {
+ return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
+ mem_ctx, found_name);
+ }
full_path = talloc_asprintf(talloc_tos(), "%s/%s", path, name);
if (full_path == NULL) {
static void gpfs_dumpacl(int level, struct gpfs_acl *gacl)
{
- int i;
+ gpfs_aclCount_t i;
if (gacl==NULL)
{
DEBUG(0, ("gpfs acl is NULL\n"));
*/
static int gpfs_get_nfs4_acl(const char *fname, SMB4ACL_T **ppacl)
{
- int i;
+ gpfs_aclCount_t i;
struct gpfs_acl *gacl = NULL;
DEBUG(10, ("gpfs_get_nfs4_acl invoked for %s\n", fname));
static NTSTATUS gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
files_struct *fsp, uint32 security_info,
- SEC_DESC **ppdesc)
+ struct security_descriptor **ppdesc)
{
SMB4ACL_T *pacl = NULL;
int result;
*ppdesc = NULL;
- result = gpfs_get_nfs4_acl(fsp->fsp_name, &pacl);
+ result = gpfs_get_nfs4_acl(fsp->fsp_name->base_name, &pacl);
if (result == 0)
return smb_fget_nt_acl_nfs4(fsp, security_info, ppdesc, pacl);
static NTSTATUS gpfsacl_get_nt_acl(vfs_handle_struct *handle,
const char *name,
- uint32 security_info, SEC_DESC **ppdesc)
+ uint32 security_info, struct security_descriptor **ppdesc)
{
SMB4ACL_T *pacl = NULL;
int result;
"merge_writeappend", True)) {
DEBUG(2, ("vfs_gpfs.c: file [%s]: ACE contains "
"WRITE^APPEND, setting WRITE|APPEND\n",
- fsp->fsp_name));
+ fsp_str_dbg(fsp)));
gace->aceMask |= ACE4_MASK_WRITE|ACE4_MASK_APPEND;
}
gacl->acl_nace++;
}
- ret = smbd_gpfs_putacl(fsp->fsp_name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
+ ret = smbd_gpfs_putacl(fsp->fsp_name->base_name,
+ GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
if (ret != 0) {
DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
gpfs_dumpacl(8, gacl);
return True;
}
-static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
{
struct gpfs_acl *acl;
NTSTATUS result = NT_STATUS_ACCESS_DENIED;
- acl = gpfs_getacl_alloc(fsp->fsp_name, 0);
+ acl = gpfs_getacl_alloc(fsp->fsp_name->base_name, 0);
if (acl == NULL)
return result;
if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
{
+ if (lp_parm_bool(fsp->conn->params->service, "gpfs",
+ "refuse_dacl_protected", false)
+ && (psd->type&SEC_DESC_DACL_PROTECTED)) {
+ DEBUG(2, ("Rejecting unsupported ACL with DACL_PROTECTED bit set\n"));
+ return NT_STATUS_NOT_SUPPORTED;
+ }
+
result = smb_set_nt_acl_nfs4(
fsp, security_info_sent, psd,
gpfsacl_process_smbacl);
return result;
}
-static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
{
return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
}
static SMB_ACL_T gpfs2smb_acl(const struct gpfs_acl *pacl)
{
SMB_ACL_T result;
- int i;
+ gpfs_aclCount_t i;
result = sys_acl_init(pacl->acl_nace);
if (result == NULL) {
return result;
}
-SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
- const char *path_p,
- SMB_ACL_TYPE_T type)
+static SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle,
+ const char *path_p,
+ SMB_ACL_TYPE_T type)
{
gpfs_aclType_t gpfs_type;
return gpfsacl_get_posix_acl(path_p, gpfs_type);
}
-SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
- files_struct *fsp)
+static SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
+ files_struct *fsp)
{
- return gpfsacl_get_posix_acl(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
+ return gpfsacl_get_posix_acl(fsp->fsp_name->base_name,
+ GPFS_ACL_TYPE_ACCESS);
}
static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
return result;
}
-int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
- const char *name,
- SMB_ACL_TYPE_T type,
- SMB_ACL_T theacl)
+static int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle,
+ const char *name,
+ SMB_ACL_TYPE_T type,
+ SMB_ACL_T theacl)
{
struct gpfs_acl *gpfs_acl;
int result;
return result;
}
-int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
- files_struct *fsp,
- SMB_ACL_T theacl)
+static int gpfsacl_sys_acl_set_fd(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_ACL_T theacl)
{
- return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name, SMB_ACL_TYPE_ACCESS, theacl);
+ return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name->base_name,
+ SMB_ACL_TYPE_ACCESS, theacl);
}
-int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
- const char *path)
+static int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
+ const char *path)
{
errno = ENOTSUP;
return -1;
int i;
files_struct fake_fsp; /* TODO: rationalize parametrization */
SMB4ACE_T *smbace;
+ NTSTATUS status;
DEBUG(10, ("gpfsacl_emu_chmod invoked for %s mode %o\n", path, mode));
/* don't add complementary DENY ACEs here */
ZERO_STRUCT(fake_fsp);
- fake_fsp.fsp_name = (char *)path; /* no file_new is needed here */
-
+ status = create_synthetic_smb_fname(talloc_tos(), path, NULL, NULL,
+ &fake_fsp.fsp_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
/* put the acl */
- if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False)
+ if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False) {
+ TALLOC_FREE(fake_fsp.fsp_name);
return -1;
+ }
+
+ TALLOC_FREE(fake_fsp.fsp_name);
return 0; /* ok for [f]chmod */
}
static int vfs_gpfs_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
{
- SMB_STRUCT_STAT st;
- int rc;
+ struct smb_filename *smb_fname_cpath;
+ int rc;
+ NTSTATUS status;
- if (SMB_VFS_NEXT_STAT(handle, path, &st) != 0) {
- return -1;
- }
+ status = create_synthetic_smb_fname(
+ talloc_tos(), path, NULL, NULL, &smb_fname_cpath);
- /* avoid chmod() if possible, to preserve acls */
- if ((st.st_mode & ~S_IFMT) == mode) {
- return 0;
- }
+ if (SMB_VFS_NEXT_STAT(handle, smb_fname_cpath) != 0) {
+ return -1;
+ }
- rc = gpfsacl_emu_chmod(path, mode);
- if (rc == 1)
- return SMB_VFS_NEXT_CHMOD(handle, path, mode);
- return rc;
+ /* avoid chmod() if possible, to preserve acls */
+ if ((smb_fname_cpath->st.st_ex_mode & ~S_IFMT) == mode) {
+ return 0;
+ }
+
+ rc = gpfsacl_emu_chmod(path, mode);
+ if (rc == 1)
+ return SMB_VFS_NEXT_CHMOD(handle, path, mode);
+ return rc;
}
static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
}
/* avoid chmod() if possible, to preserve acls */
- if ((st.st_mode & ~S_IFMT) == mode) {
+ if ((st.st_ex_mode & ~S_IFMT) == mode) {
return 0;
}
- rc = gpfsacl_emu_chmod(fsp->fsp_name, mode);
+ rc = gpfsacl_emu_chmod(fsp->fsp_name->base_name, mode);
if (rc == 1)
return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
return rc;
}
-/* VFS operations structure */
+static int gpfs_set_xattr(struct vfs_handle_struct *handle, const char *path,
+ const char *name, const void *value, size_t size, int flags){
+ struct xattr_DOSATTRIB dosattrib;
+ enum ndr_err_code ndr_err;
+ DATA_BLOB blob;
+ const char *attrstr = value;
+ unsigned int dosmode=0;
+ struct gpfs_winattr attrs;
+ int ret = 0;
+
+ DEBUG(10, ("gpfs_set_xattr: %s \n",path));
+
+ /* Only handle DOS Attributes */
+ if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
+ DEBUG(1, ("gpfs_set_xattr:name is %s\n",name));
+ return SMB_VFS_NEXT_SETXATTR(handle,path,name,value,size,flags);
+ }
+
+ blob.data = (uint8_t *)attrstr;
+ blob.length = size;
+
+ ndr_err = ndr_pull_struct_blob(&blob, talloc_tos(), &dosattrib,
+ (ndr_pull_flags_fn_t)ndr_pull_xattr_DOSATTRIB);
+
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ DEBUG(1, ("gpfs_set_xattr: bad ndr decode "
+ "from EA on file %s: Error = %s\n",
+ path, ndr_errstr(ndr_err)));
+ return false;
+ }
-static vfs_op_tuple gpfs_op_tuples[] = {
+ if (dosattrib.version != 3) {
+ DEBUG(1, ("gpfs_set_xattr: expected dosattrib version 3, got "
+ "%d\n", (int)dosattrib.version));
+ return false;
+ }
+ if (!(dosattrib.info.info3.valid_flags & XATTR_DOSINFO_ATTRIB)) {
+ DEBUG(10, ("gpfs_set_xattr: XATTR_DOSINFO_ATTRIB not "
+ "valid, ignoring\n"));
+ return true;
+ }
- { SMB_VFS_OP(vfs_gpfs_kernel_flock),
- SMB_VFS_OP_KERNEL_FLOCK,
- SMB_VFS_LAYER_OPAQUE },
+ dosmode = dosattrib.info.info3.attrib;
+
+ attrs.winAttrs = 0;
+ /*Just map RD_ONLY, ARCHIVE, SYSTEM HIDDEN and SPARSE. Ignore the others*/
+ if (dosmode & FILE_ATTRIBUTE_ARCHIVE){
+ attrs.winAttrs |= GPFS_WINATTR_ARCHIVE;
+ }
+ if (dosmode & FILE_ATTRIBUTE_HIDDEN){
+ attrs.winAttrs |= GPFS_WINATTR_HIDDEN;
+ }
+ if (dosmode & FILE_ATTRIBUTE_SYSTEM){
+ attrs.winAttrs |= GPFS_WINATTR_SYSTEM;
+ }
+ if (dosmode & FILE_ATTRIBUTE_READONLY){
+ attrs.winAttrs |= GPFS_WINATTR_READONLY;
+ }
+ if (dosmode & FILE_ATTRIBUTE_SPARSE) {
+ attrs.winAttrs |= GPFS_WINATTR_SPARSE_FILE;
+ }
- { SMB_VFS_OP(vfs_gpfs_setlease),
- SMB_VFS_OP_LINUX_SETLEASE,
- SMB_VFS_LAYER_OPAQUE },
- { SMB_VFS_OP(vfs_gpfs_get_real_filename),
- SMB_VFS_OP_GET_REAL_FILENAME,
- SMB_VFS_LAYER_OPAQUE },
+ ret = set_gpfs_winattrs(discard_const_p(char, path),
+ GPFS_WINATTR_SET_ATTRS, &attrs);
+ if ( ret == -1){
+ if (errno == ENOSYS) {
+ return SMB_VFS_NEXT_SETXATTR(handle, path, name, value,
+ size, flags);
+ }
- { SMB_VFS_OP(gpfsacl_fget_nt_acl),
- SMB_VFS_OP_FGET_NT_ACL,
- SMB_VFS_LAYER_TRANSPARENT },
+ DEBUG(1, ("gpfs_set_xattr:Set GPFS attributes failed %d\n",ret));
+ return -1;
+ }
- { SMB_VFS_OP(gpfsacl_get_nt_acl),
- SMB_VFS_OP_GET_NT_ACL,
- SMB_VFS_LAYER_TRANSPARENT },
+ DEBUG(10, ("gpfs_set_xattr:Set attributes: 0x%x\n",attrs.winAttrs));
+ return 0;
+}
- { SMB_VFS_OP(gpfsacl_fset_nt_acl),
- SMB_VFS_OP_FSET_NT_ACL,
- SMB_VFS_LAYER_TRANSPARENT },
+static ssize_t gpfs_get_xattr(struct vfs_handle_struct *handle, const char *path,
+ const char *name, void *value, size_t size){
+ char *attrstr = value;
+ unsigned int dosmode = 0;
+ struct gpfs_winattr attrs;
+ int ret = 0;
+
+ DEBUG(10, ("gpfs_get_xattr: %s \n",path));
+
+ /* Only handle DOS Attributes */
+ if (strcmp(name,SAMBA_XATTR_DOS_ATTRIB) != 0){
+ DEBUG(1, ("gpfs_get_xattr:name is %s\n",name));
+ return SMB_VFS_NEXT_GETXATTR(handle,path,name,value,size);
+ }
+
+ ret = get_gpfs_winattrs(discard_const_p(char, path), &attrs);
+ if ( ret == -1){
+ if (errno == ENOSYS) {
+ return SMB_VFS_NEXT_GETXATTR(handle, path, name, value,
+ size);
+ }
- { SMB_VFS_OP(gpfsacl_sys_acl_get_file),
- SMB_VFS_OP_SYS_ACL_GET_FILE,
- SMB_VFS_LAYER_TRANSPARENT },
+ DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: "
+ "%d (%s)\n", ret, strerror(errno)));
+ return -1;
+ }
+
+ DEBUG(10, ("gpfs_get_xattr:Got attributes: 0x%x\n",attrs.winAttrs));
+
+ /*Just map RD_ONLY, ARCHIVE, SYSTEM, HIDDEN and SPARSE. Ignore the others*/
+ if (attrs.winAttrs & GPFS_WINATTR_ARCHIVE){
+ dosmode |= FILE_ATTRIBUTE_ARCHIVE;
+ }
+ if (attrs.winAttrs & GPFS_WINATTR_HIDDEN){
+ dosmode |= FILE_ATTRIBUTE_HIDDEN;
+ }
+ if (attrs.winAttrs & GPFS_WINATTR_SYSTEM){
+ dosmode |= FILE_ATTRIBUTE_SYSTEM;
+ }
+ if (attrs.winAttrs & GPFS_WINATTR_READONLY){
+ dosmode |= FILE_ATTRIBUTE_READONLY;
+ }
+ if (attrs.winAttrs & GPFS_WINATTR_SPARSE_FILE) {
+ dosmode |= FILE_ATTRIBUTE_SPARSE;
+ }
- { SMB_VFS_OP(gpfsacl_sys_acl_get_fd),
- SMB_VFS_OP_SYS_ACL_GET_FD,
- SMB_VFS_LAYER_TRANSPARENT },
+ snprintf(attrstr, size, "0x%2.2x",
+ (unsigned int)(dosmode & SAMBA_ATTRIBUTES_MASK));
+ DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr));
+ return 4;
+}
- { SMB_VFS_OP(gpfsacl_sys_acl_set_file),
- SMB_VFS_OP_SYS_ACL_SET_FILE,
- SMB_VFS_LAYER_TRANSPARENT },
+static int vfs_gpfs_stat(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
+{
+ struct gpfs_winattr attrs;
+ char *fname = NULL;
+ NTSTATUS status;
+ int ret;
- { SMB_VFS_OP(gpfsacl_sys_acl_set_fd),
- SMB_VFS_OP_SYS_ACL_SET_FD,
- SMB_VFS_LAYER_TRANSPARENT },
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
+ if (ret == -1) {
+ return -1;
+ }
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+ ret = get_gpfs_winattrs(discard_const_p(char, fname), &attrs);
+ TALLOC_FREE(fname);
+ if (ret == 0) {
+ smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
+ smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+ smb_fname->st.vfs_private = attrs.winAttrs;
+ }
+ return 0;
+}
- { SMB_VFS_OP(gpfsacl_sys_acl_delete_def_file),
- SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
- SMB_VFS_LAYER_TRANSPARENT },
+static int vfs_gpfs_fstat(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
+{
+ struct gpfs_winattr attrs;
+ int ret;
- { SMB_VFS_OP(vfs_gpfs_chmod),
- SMB_VFS_OP_CHMOD,
- SMB_VFS_LAYER_TRANSPARENT },
+ ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
+ if (ret == -1) {
+ return -1;
+ }
+ if ((fsp->fh == NULL) || (fsp->fh->fd == -1)) {
+ return 0;
+ }
+ ret = smbd_fget_gpfs_winattrs(fsp->fh->fd, &attrs);
+ if (ret == 0) {
+ sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
+ sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+ }
+ return 0;
+}
- { SMB_VFS_OP(vfs_gpfs_fchmod),
- SMB_VFS_OP_FCHMOD,
- SMB_VFS_LAYER_TRANSPARENT },
+static int vfs_gpfs_lstat(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
+{
+ struct gpfs_winattr attrs;
+ char *path = NULL;
+ NTSTATUS status;
+ int ret;
- { SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP }
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
+ if (ret == -1) {
+ return -1;
+ }
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+ ret = get_gpfs_winattrs(discard_const_p(char, path), &attrs);
+ TALLOC_FREE(path);
+ if (ret == 0) {
+ smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
+ smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+ smb_fname->st.vfs_private = attrs.winAttrs;
+ }
+ return 0;
+}
-};
+static int vfs_gpfs_ntimes(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ struct smb_file_time *ft)
+{
+
+ struct gpfs_winattr attrs;
+ int ret;
+ char *path = NULL;
+ NTSTATUS status;
+
+ ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
+ if(ret == -1){
+ DEBUG(1,("vfs_gpfs_ntimes: SMB_VFS_NEXT_NTIMES failed\n"));
+ return -1;
+ }
+
+ if(null_timespec(ft->create_time)){
+ DEBUG(10,("vfs_gpfs_ntimes:Create Time is NULL\n"));
+ return 0;
+ }
+
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+
+ attrs.winAttrs = 0;
+ attrs.creationTime.tv_sec = ft->create_time.tv_sec;
+ attrs.creationTime.tv_nsec = ft->create_time.tv_nsec;
+
+ ret = set_gpfs_winattrs(discard_const_p(char, path),
+ GPFS_WINATTR_SET_CREATION_TIME, &attrs);
+ if(ret == -1 && errno != ENOSYS){
+ DEBUG(1,("vfs_gpfs_ntimes: set GPFS ntimes failed %d\n",ret));
+ return -1;
+ }
+ return 0;
+
+}
+
+static int vfs_gpfs_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
+ SMB_OFF_T len)
+{
+ int result;
+
+ result = smbd_gpfs_ftruncate(fsp->fh->fd, len);
+ if ((result == -1) && (errno == ENOSYS)) {
+ return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
+ }
+ return result;
+}
+
+static bool vfs_gpfs_is_offline(struct vfs_handle_struct *handle,
+ const struct smb_filename *fname,
+ SMB_STRUCT_STAT *sbuf)
+{
+ struct gpfs_winattr attrs;
+ char *path = NULL;
+ NTSTATUS status;
+
+ status = get_full_smb_filename(talloc_tos(), fname, &path);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+
+ if (VALID_STAT(*sbuf)) {
+ attrs.winAttrs = sbuf->vfs_private;
+ } else {
+ int ret;
+ ret = get_gpfs_winattrs(path, &attrs);
+
+ if (ret == -1) {
+ TALLOC_FREE(path);
+ return false;
+ }
+ }
+ if ((attrs.winAttrs & GPFS_WINATTR_OFFLINE) != 0) {
+ DEBUG(10, ("%s is offline\n", path));
+ TALLOC_FREE(path);
+ return true;
+ }
+ DEBUG(10, ("%s is online\n", path));
+ TALLOC_FREE(path);
+ return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
+}
+
+static bool vfs_gpfs_aio_force(struct vfs_handle_struct *handle,
+ struct files_struct *fsp)
+{
+ return vfs_gpfs_is_offline(handle, fsp->fsp_name, &fsp->fsp_name->st);
+}
+
+static ssize_t vfs_gpfs_sendfile(vfs_handle_struct *handle, int tofd,
+ files_struct *fsp, const DATA_BLOB *hdr,
+ SMB_OFF_T offset, size_t n)
+{
+ if ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0) {
+ errno = ENOSYS;
+ return -1;
+ }
+ return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
+}
+
+int vfs_gpfs_connect(struct vfs_handle_struct *handle, const char *service,
+ const char *user)
+{
+ struct gpfs_config_data *config;
+
+ smbd_gpfs_lib_init();
+
+ int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
+
+ if (ret < 0) {
+ return ret;
+ }
+
+ config = talloc_zero(handle->conn, struct gpfs_config_data);
+ if (!config) {
+ SMB_VFS_NEXT_DISCONNECT(handle);
+ DEBUG(0, ("talloc_zero() failed\n")); return -1;
+ }
+
+ config->sharemodes = lp_parm_bool(SNUM(handle->conn), "gpfs",
+ "sharemodes", true);
+
+ config->leases = lp_parm_bool(SNUM(handle->conn), "gpfs",
+ "leases", true);
+ config->hsm = lp_parm_bool(SNUM(handle->conn), "gpfs",
+ "hsm", false);
+
+ config->syncio = lp_parm_bool(SNUM(handle->conn), "gpfs",
+ "syncio", false);
+
+ SMB_VFS_HANDLE_SET_DATA(handle, config,
+ NULL, struct gpfs_config_data,
+ return -1);
+
+ return 0;
+}
+
+static uint32_t vfs_gpfs_capabilities(struct vfs_handle_struct *handle,
+ enum timestamp_set_resolution *p_ts_res)
+{
+ struct gpfs_config_data *config;
+ uint32_t next;
+
+ next = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return next);
+
+ if (config->hsm) {
+ next |= FILE_SUPPORTS_REMOTE_STORAGE;
+ }
+ return next;
+}
+
+static int vfs_gpfs_open(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname, files_struct *fsp,
+ int flags, mode_t mode)
+{
+ struct gpfs_config_data *config;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
+
+ if (config->syncio) {
+ flags |= O_SYNC;
+ }
+ return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
+}
+
+
+static struct vfs_fn_pointers vfs_gpfs_fns = {
+ .connect_fn = vfs_gpfs_connect,
+ .fs_capabilities_fn = vfs_gpfs_capabilities,
+ .kernel_flock_fn = vfs_gpfs_kernel_flock,
+ .linux_setlease_fn = vfs_gpfs_setlease,
+ .get_real_filename_fn = vfs_gpfs_get_real_filename,
+ .fget_nt_acl_fn = gpfsacl_fget_nt_acl,
+ .get_nt_acl_fn = gpfsacl_get_nt_acl,
+ .fset_nt_acl_fn = gpfsacl_fset_nt_acl,
+ .sys_acl_get_file_fn = gpfsacl_sys_acl_get_file,
+ .sys_acl_get_fd_fn = gpfsacl_sys_acl_get_fd,
+ .sys_acl_set_file_fn = gpfsacl_sys_acl_set_file,
+ .sys_acl_set_fd_fn = gpfsacl_sys_acl_set_fd,
+ .sys_acl_delete_def_file_fn = gpfsacl_sys_acl_delete_def_file,
+ .chmod_fn = vfs_gpfs_chmod,
+ .fchmod_fn = vfs_gpfs_fchmod,
+ .close_fn = vfs_gpfs_close,
+ .setxattr_fn = gpfs_set_xattr,
+ .getxattr_fn = gpfs_get_xattr,
+ .stat_fn = vfs_gpfs_stat,
+ .fstat_fn = vfs_gpfs_fstat,
+ .lstat_fn = vfs_gpfs_lstat,
+ .ntimes_fn = vfs_gpfs_ntimes,
+ .is_offline_fn = vfs_gpfs_is_offline,
+ .aio_force_fn = vfs_gpfs_aio_force,
+ .sendfile_fn = vfs_gpfs_sendfile,
+ .open_fn = vfs_gpfs_open,
+ .ftruncate_fn = vfs_gpfs_ftruncate
+};
NTSTATUS vfs_gpfs_init(void);
NTSTATUS vfs_gpfs_init(void)
init_gpfs();
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs",
- gpfs_op_tuples);
+ &vfs_gpfs_fns);
}
git.samba.org / kai / samba.git / blobdiff