X-Git-Url: http://git.samba.org/samba.git/?p=ira%2Fwip.git;a=blobdiff_plain;f=source3%2Fmodules%2Fvfs_gpfs.c;h=26f96889092f02468aa892c8d3045ae3da45b54f;hp=fa0b4e97a5c1716a3f7635526b2897abb63072dc;hb=e0a6a344be326c58dc9307f286226f76f15f78e8;hpb=5209a846a9157e649fcdcb561f7eaf19c8c0e465 diff --git a/source3/modules/vfs_gpfs.c b/source3/modules/vfs_gpfs.c index fa0b4e97a5c..26f96889092 100644 --- a/source3/modules/vfs_gpfs.c +++ b/source3/modules/vfs_gpfs.c @@ -1,26 +1,24 @@ /* Unix SMB/CIFS implementation. Wrap gpfs calls in vfs functions. - + Copyright (C) Christian Ambach 2006 - + Major code contributions by Chetan Shringarpure and Gomati Mohanan - + 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 . - - */ #include "includes.h" @@ -51,18 +49,27 @@ static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, return 0; } +static int vfs_gpfs_close(vfs_handle_struct *handle, files_struct *fsp) +{ + if ((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; - + START_PROFILE(syscall_linux_setlease); - + if ( linux_set_lease_sighandler(fsp->fh->fd) == -1) return -1; ret = set_gpfs_lease(fsp->fh->fd,leasetype); - + if ( ret < 0 ) { /* This must have come from GPFS not being available */ /* or some other error, hence call the default */ @@ -74,7 +81,69 @@ static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp, return ret; } +static int vfs_gpfs_get_real_filename(struct vfs_handle_struct *handle, + const char *path, + const char *name, + TALLOC_CTX *mem_ctx, + char **found_name) +{ + int result; + char *full_path; + char real_pathname[PATH_MAX+1]; + int buflen; + + full_path = talloc_asprintf(talloc_tos(), "%s/%s", path, name); + if (full_path == NULL) { + errno = ENOMEM; + return -1; + } + + buflen = sizeof(real_pathname) - 1; + + result = smbd_gpfs_get_realfilename_path(full_path, real_pathname, + &buflen); + + TALLOC_FREE(full_path); + + if ((result == -1) && (errno == ENOSYS)) { + return SMB_VFS_NEXT_GET_REAL_FILENAME( + handle, path, name, mem_ctx, found_name); + } + + if (result == -1) { + DEBUG(10, ("smbd_gpfs_get_realfilename_path returned %s\n", + strerror(errno))); + return -1; + } + + /* + * GPFS does not necessarily null-terminate the returned path + * but instead returns the buffer length in buflen. + */ + + if (buflen < sizeof(real_pathname)) { + real_pathname[buflen] = '\0'; + } else { + real_pathname[sizeof(real_pathname)-1] = '\0'; + } + DEBUG(10, ("smbd_gpfs_get_realfilename_path: %s/%s -> %s\n", + path, name, real_pathname)); + + name = strrchr_m(real_pathname, '/'); + if (name == NULL) { + errno = ENOENT; + return -1; + } + + *found_name = talloc_strdup(mem_ctx, name+1); + if (*found_name == NULL) { + errno = ENOMEM; + return -1; + } + + return 0; +} static void gpfs_dumpacl(int level, struct gpfs_acl *gacl) { @@ -281,7 +350,7 @@ static bool gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl) gacl_len = sizeof(struct gpfs_acl) + (smb_get_naces(smbacl)-1)*sizeof(gpfs_ace_v4_t); - gacl = TALLOC_SIZE(mem_ctx, gacl_len); + gacl = (struct gpfs_acl *)TALLOC_SIZE(mem_ctx, gacl_len); if (gacl == NULL) { DEBUG(0, ("talloc failed\n")); errno = ENOMEM; @@ -301,13 +370,13 @@ static bool gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl) gace->aceType = aceprop->aceType; gace->aceFlags = aceprop->aceFlags; gace->aceMask = aceprop->aceMask; - + /* * GPFS can't distinguish between WRITE and APPEND on * files, so one being set without the other is an * error. Sorry for the many ()'s :-) */ - + if (!fsp->is_directory && ((((gace->aceMask & ACE4_MASK_WRITE) == 0) @@ -323,9 +392,9 @@ static bool gpfsacl_process_smbacl(files_struct *fsp, SMB4ACL_T *smbacl) fsp->fsp_name)); gace->aceMask |= ACE4_MASK_WRITE|ACE4_MASK_APPEND; } - + gace->aceIFlags = (aceprop->flags&SMB_ACE4_ID_SPECIAL) ? ACE4_IFLAG_SPECIAL_ID : 0; - + if (aceprop->flags&SMB_ACE4_ID_SPECIAL) { switch(aceprop->who.special_id) @@ -478,7 +547,7 @@ static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type) errno = EINVAL; goto done; } - + DEBUG(10, ("len: %d, level: %d, version: %d, nace: %d\n", pacl->acl_len, pacl->acl_level, pacl->acl_version, pacl->acl_nace)); @@ -496,10 +565,9 @@ static SMB_ACL_T gpfsacl_get_posix_acl(const char *path, gpfs_aclType_t type) 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; @@ -518,8 +586,8 @@ SMB_ACL_T gpfsacl_sys_acl_get_file(vfs_handle_struct *handle, 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); } @@ -541,7 +609,7 @@ static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl, len = sizeof(struct gpfs_acl) - sizeof(union gpfs_ace_union) + (pacl->count)*sizeof(gpfs_ace_v1_t); - result = SMB_MALLOC(len); + result = (struct gpfs_acl *)SMB_MALLOC(len); if (result == NULL) { errno = ENOMEM; return result; @@ -557,7 +625,7 @@ static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl, for (i=0; icount; i++) { const struct smb_acl_entry *ace = &pacl->acl[i]; struct gpfs_ace_v1 *g_ace = &result->ace_v1[i]; - + DEBUG(10, ("Converting type %d perm %x\n", (int)ace->a_type, (int)ace->a_perm)); @@ -611,11 +679,10 @@ 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; @@ -631,16 +698,15 @@ int gpfsacl_sys_acl_set_file(vfs_handle_struct *handle, 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); } -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; @@ -661,11 +727,11 @@ static uint32 gpfsacl_mask_filter(uint32 aceType, uint32 aceMask, uint32 rwx) uint32_t posix_mask = 0x01; uint32_t posix_bit; uint32_t nfs4_bits; - + for(i=0; i<3; i++) { nfs4_bits = posix_nfs4map[i]; posix_bit = rwx & posix_mask; - + if (aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE) { if (posix_bit) aceMask |= nfs4_bits; @@ -678,10 +744,10 @@ static uint32 gpfsacl_mask_filter(uint32 aceType, uint32 aceMask, uint32 rwx) else aceMask &= ~nfs4_bits; } /* other ace types are unexpected */ - + posix_mask <<= 1; } - + return aceMask; } @@ -693,30 +759,30 @@ static int gpfsacl_emu_chmod(const char *path, mode_t mode) int i; files_struct fake_fsp; /* TODO: rationalize parametrization */ SMB4ACE_T *smbace; - + DEBUG(10, ("gpfsacl_emu_chmod invoked for %s mode %o\n", path, mode)); - + result = gpfs_get_nfs4_acl(path, &pacl); if (result) return result; - + if (mode & ~(S_IRWXU | S_IRWXG | S_IRWXO)) { DEBUG(2, ("WARNING: cutting extra mode bits %o on %s\n", mode, path)); } - + for (smbace=smb_first_ace4(pacl); smbace!=NULL; smbace = smb_next_ace4(smbace)) { SMB_ACE4PROP_T *ace = smb_get_ace4(smbace); uint32_t specid = ace->who.special_id; - + if (ace->flags&SMB_ACE4_ID_SPECIAL && ace->aceType<=SMB_ACE4_ACCESS_DENIED_ACE_TYPE && specid <= SMB_ACE4_WHO_EVERYONE) { - + uint32_t newMask; - + if (ace->aceType==SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE) haveAllowEntry[specid] = True; - + /* mode >> 6 for @owner, mode >> 3 for @group, * mode >> 0 for @everyone */ newMask = gpfsacl_mask_filter(ace->aceType, ace->aceMask, @@ -735,35 +801,35 @@ static int gpfsacl_emu_chmod(const char *path, mode_t mode) */ for(i = SMB_ACE4_WHO_OWNER; i<=SMB_ACE4_WHO_EVERYONE; i++) { SMB_ACE4PROP_T ace; - + if (haveAllowEntry[i]==True) continue; - + ZERO_STRUCT(ace); ace.aceType = SMB_ACE4_ACCESS_ALLOWED_ACE_TYPE; ace.flags |= SMB_ACE4_ID_SPECIAL; ace.who.special_id = i; - + if (i==SMB_ACE4_WHO_GROUP) /* not sure it's necessary... */ ace.aceFlags |= SMB_ACE4_IDENTIFIER_GROUP; - + ace.aceMask = gpfsacl_mask_filter(ace.aceType, ace.aceMask, mode >> ((SMB_ACE4_WHO_EVERYONE - i) * 3)); - + /* don't add unnecessary aces */ if (!ace.aceMask) continue; - + /* we add it to the END - as windows expects allow aces */ smb_add_ace4(pacl, &ace); DEBUG(10, ("Added ALLOW ace for %s, mode=%o, id=%d, aceMask=%x\n", path, mode, i, ace.aceMask)); } - + /* don't add complementary DENY ACEs here */ ZERO_STRUCT(fake_fsp); fake_fsp.fsp_name = (char *)path; /* no file_new is needed here */ - + /* put the acl */ if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False) return -1; @@ -774,13 +840,13 @@ static int vfs_gpfs_chmod(vfs_handle_struct *handle, const char *path, mode_t mo { SMB_STRUCT_STAT st; int rc; - + if (SMB_VFS_NEXT_STAT(handle, path, &st) != 0) { return -1; } - + /* avoid chmod() if possible, to preserve acls */ - if ((st.st_mode & ~S_IFMT) == mode) { + if ((st.st_ex_mode & ~S_IFMT) == mode) { return 0; } @@ -794,13 +860,13 @@ static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t { SMB_STRUCT_STAT st; int rc; - + if (SMB_VFS_NEXT_FSTAT(handle, fsp, &st) != 0) { return -1; } /* avoid chmod() if possible, to preserve acls */ - if ((st.st_mode & ~S_IFMT) == mode) { + if ((st.st_ex_mode & ~S_IFMT) == mode) { return 0; } @@ -810,58 +876,233 @@ static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t return rc; } +static int gpfs_set_xattr(struct vfs_handle_struct *handle, const char *path, + const char *name, const void *value, size_t size, int flags){ + 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); + } + + if (size < 2 || attrstr[0] != '0' || attrstr[1] != 'x' || + sscanf(attrstr, "%x", &dosmode) != 1) { + DEBUG(1,("gpfs_set_xattr: Trying to set badly formed DOSATTRIB on file %s - %s\n", path, attrstr)); + return False; + } + + attrs.winAttrs = 0; + /*Just map RD_ONLY, ARCHIVE, SYSTEM and HIDDEN. 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; + } + + + ret = set_gpfs_winattrs(CONST_DISCARD(char *, path), + GPFS_WINATTR_SET_ATTRS, &attrs); + if ( ret == -1){ + DEBUG(1, ("gpfs_set_xattr:Set GPFS attributes failed %d\n",ret)); + return -1; + } + + DEBUG(10, ("gpfs_set_xattr:Set attributes: 0x%x\n",attrs.winAttrs)); + return 0; +} + +static size_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(CONST_DISCARD(char *, path), &attrs); + if ( ret == -1){ + DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: %d\n",ret)); + return -1; + } + + DEBUG(10, ("gpfs_get_xattr:Got attributes: 0x%x\n",attrs.winAttrs)); + + /*Just map RD_ONLY, ARCHIVE, SYSTEM and HIDDEN. 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; + } + + snprintf(attrstr, size, "0x%x", dosmode & SAMBA_ATTRIBUTES_MASK); + DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr)); + return size; +} + +static int vfs_gpfs_stat(struct vfs_handle_struct *handle, const char *fname, + SMB_STRUCT_STAT *sbuf) +{ + struct gpfs_winattr attrs; + int ret; + + ret = SMB_VFS_NEXT_STAT(handle, fname, sbuf); + if (ret == -1) { + return -1; + } + ret = get_gpfs_winattrs(CONST_DISCARD(char *, fname), &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; +} + +static int vfs_gpfs_fstat(struct vfs_handle_struct *handle, + struct files_struct *fsp, SMB_STRUCT_STAT *sbuf) +{ + struct gpfs_winattr attrs; + int ret; + + 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; +} + +static int vfs_gpfs_lstat(struct vfs_handle_struct *handle, const char *path, + SMB_STRUCT_STAT *sbuf) +{ + struct gpfs_winattr attrs; + int ret; + + ret = SMB_VFS_NEXT_LSTAT(handle, path, sbuf); + if (ret == -1) { + return -1; + } + ret = get_gpfs_winattrs(CONST_DISCARD(char *, path), &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; +} + /* VFS operations structure */ static vfs_op_tuple gpfs_op_tuples[] = { - + { SMB_VFS_OP(vfs_gpfs_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK, SMB_VFS_LAYER_OPAQUE }, - + { 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 }, + { SMB_VFS_OP(gpfsacl_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_get_nt_acl), SMB_VFS_OP_GET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(gpfsacl_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(vfs_gpfs_chmod), SMB_VFS_OP_CHMOD, SMB_VFS_LAYER_TRANSPARENT }, - + { SMB_VFS_OP(vfs_gpfs_fchmod), SMB_VFS_OP_FCHMOD, SMB_VFS_LAYER_TRANSPARENT }, + { SMB_VFS_OP(vfs_gpfs_close), + SMB_VFS_OP_CLOSE, + SMB_VFS_LAYER_TRANSPARENT }, + + { SMB_VFS_OP(gpfs_set_xattr), + SMB_VFS_OP_SETXATTR, + SMB_VFS_LAYER_TRANSPARENT }, + + { SMB_VFS_OP(gpfs_get_xattr), + SMB_VFS_OP_GETXATTR, + SMB_VFS_LAYER_TRANSPARENT }, + + { SMB_VFS_OP(vfs_gpfs_stat), + SMB_VFS_OP_STAT, + SMB_VFS_LAYER_TRANSPARENT }, + + { SMB_VFS_OP(vfs_gpfs_fstat), + SMB_VFS_OP_FSTAT, + SMB_VFS_LAYER_TRANSPARENT }, + + { SMB_VFS_OP(vfs_gpfs_lstat), + SMB_VFS_OP_LSTAT, + SMB_VFS_LAYER_TRANSPARENT }, + { SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP } }; @@ -871,7 +1112,7 @@ NTSTATUS vfs_gpfs_init(void); NTSTATUS vfs_gpfs_init(void) { init_gpfs(); - + return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs", gpfs_op_tuples); }