1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
samba-mirror/source3/modules/vfs_onefs_shadow_copy.c
Günther Deschner c7073f8b54 s3-vfs: rename open function to open_fn.
This should finally fix the AIX build and allow to remove AIX specific ifdefs.

Guenther

Signed-off-by: Jeremy Allison <jra@samba.org>

Autobuild-User: Jeremy Allison <jra@samba.org>
Autobuild-Date: Thu Apr 21 02:01:20 CEST 2011 on sn-devel-104
2011-04-21 02:01:20 +02:00

726 lines
18 KiB
C

/*
* OneFS shadow copy implementation that utilizes the file system's native
* snapshot support. This is based on the original shadow copy module from
* 2004.
*
* Copyright (C) Stefan Metzmacher 2003-2004
* Copyright (C) Tim Prouty 2009
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "includes.h"
#include "smbd/smbd.h"
#include "onefs_shadow_copy.h"
static int vfs_onefs_shadow_copy_debug_level = DBGC_VFS;
#undef DBGC_CLASS
#define DBGC_CLASS vfs_onefs_shadow_copy_debug_level
#define SHADOW_COPY_PREFIX "@GMT-"
#define SHADOW_COPY_SAMPLE "@GMT-2004.02.18-15.44.00"
bool
shadow_copy_match_name(const char *name, char **snap_component)
{
uint32 i = 0;
char delim[] = SHADOW_COPY_PREFIX;
char* start;
start = strstr( name, delim );
/*
* The name could have SHADOW_COPY_PREFIX in it so we need to keep
* trying until we get something that is the full length of the
* SHADOW_COPY_SAMPLE.
*/
while (start != NULL) {
DEBUG(10,("Processing %s\n", name));
/* size / correctness check */
*snap_component = start;
for ( i = sizeof(SHADOW_COPY_PREFIX);
i < sizeof(SHADOW_COPY_SAMPLE); i++) {
if (start[i] == '/') {
if (i == sizeof(SHADOW_COPY_SAMPLE) - 1)
return true;
else
break;
} else if (start[i] == '\0')
return (i == sizeof(SHADOW_COPY_SAMPLE) - 1);
}
start = strstr( start, delim );
}
return false;
}
static int
onefs_shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle,
files_struct *fsp,
SHADOW_COPY_DATA *shadow_copy_data,
bool labels)
{
void *p = osc_version_opendir();
char *snap_component = NULL;
shadow_copy_data->num_volumes = 0;
shadow_copy_data->labels = NULL;
if (!p) {
DEBUG(0, ("shadow_copy_get_shadow_copy_data: osc_opendir() "
"failed for [%s]\n",fsp->conn->connectpath));
return -1;
}
while (true) {
SHADOW_COPY_LABEL *tlabels;
char *d;
d = osc_version_readdir(p);
if (d == NULL)
break;
if (!shadow_copy_match_name(d, &snap_component)) {
DEBUG(10,("shadow_copy_get_shadow_copy_data: ignore "
"[%s]\n",d));
continue;
}
DEBUG(7,("shadow_copy_get_shadow_copy_data: not ignore "
"[%s]\n",d));
if (!labels) {
shadow_copy_data->num_volumes++;
continue;
}
tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(
shadow_copy_data->mem_ctx,
shadow_copy_data->labels,
(shadow_copy_data->num_volumes+1) *
sizeof(SHADOW_COPY_LABEL));
if (tlabels == NULL) {
DEBUG(0,("shadow_copy_get_shadow_copy_data: Out of "
"memory\n"));
osc_version_closedir(p);
return -1;
}
snprintf(tlabels[shadow_copy_data->num_volumes++],
sizeof(*tlabels), "%s",d);
shadow_copy_data->labels = tlabels;
}
osc_version_closedir(p);
return 0;
}
#define SHADOW_NEXT(op, args, rtype) do { \
char *cpath = NULL; \
char *snap_component = NULL; \
rtype ret; \
if (shadow_copy_match_name(path, &snap_component)) \
cpath = osc_canonicalize_path(path, snap_component); \
ret = SMB_VFS_NEXT_ ## op args; \
SAFE_FREE(cpath); \
return ret; \
} while (0) \
/*
* XXX: Convert osc_canonicalize_path to use talloc instead of malloc.
*/
#define SHADOW_NEXT_SMB_FNAME(op, args, rtype) do { \
char *smb_base_name_tmp = NULL; \
char *cpath = NULL; \
char *snap_component = NULL; \
rtype ret; \
smb_base_name_tmp = smb_fname->base_name; \
if (shadow_copy_match_name(smb_fname->base_name, \
&snap_component)) { \
cpath = osc_canonicalize_path(smb_fname->base_name, \
snap_component); \
smb_fname->base_name = cpath; \
} \
ret = SMB_VFS_NEXT_ ## op args; \
smb_fname->base_name = smb_base_name_tmp; \
SAFE_FREE(cpath); \
return ret; \
} while (0) \
static uint64_t
onefs_shadow_copy_disk_free(vfs_handle_struct *handle, const char *path,
bool small_query, uint64_t *bsize, uint64_t *dfree,
uint64_t *dsize)
{
SHADOW_NEXT(DISK_FREE,
(handle, cpath ?: path, small_query, bsize, dfree, dsize),
uint64_t);
}
static int
onefs_shadow_copy_statvfs(struct vfs_handle_struct *handle, const char *path,
struct vfs_statvfs_struct *statbuf)
{
SHADOW_NEXT(STATVFS,
(handle, cpath ?: path, statbuf),
int);
}
static SMB_STRUCT_DIR *
onefs_shadow_copy_opendir(vfs_handle_struct *handle, const char *path,
const char *mask, uint32_t attr)
{
SHADOW_NEXT(OPENDIR,
(handle, cpath ?: path, mask, attr),
SMB_STRUCT_DIR *);
}
static int
onefs_shadow_copy_mkdir(vfs_handle_struct *handle, const char *path,
mode_t mode)
{
SHADOW_NEXT(MKDIR,
(handle, cpath ?: path, mode),
int);
}
static int
onefs_shadow_copy_rmdir(vfs_handle_struct *handle, const char *path)
{
SHADOW_NEXT(RMDIR,
(handle, cpath ?: path),
int);
}
static int
onefs_shadow_copy_open(vfs_handle_struct *handle,
struct smb_filename *smb_fname, files_struct *fsp,
int flags, mode_t mode)
{
SHADOW_NEXT_SMB_FNAME(OPEN,
(handle, smb_fname, fsp, flags, mode),
int);
}
static NTSTATUS
onefs_shadow_copy_create_file(vfs_handle_struct *handle,
struct smb_request *req,
uint16_t root_dir_fid,
struct smb_filename *smb_fname,
uint32_t access_mask,
uint32_t share_access,
uint32_t create_disposition,
uint32_t create_options,
uint32_t file_attributes,
uint32_t oplock_request,
uint64_t allocation_size,
uint32_t private_flags,
struct security_descriptor *sd,
struct ea_list *ea_list,
files_struct **result,
int *pinfo)
{
SHADOW_NEXT_SMB_FNAME(CREATE_FILE,
(handle, req, root_dir_fid, smb_fname,
access_mask, share_access,
create_disposition, create_options,
file_attributes, oplock_request,
allocation_size, private_flags,
sd, ea_list, result, pinfo),
NTSTATUS);
}
/**
* XXX: macro-ize
*/
static int
onefs_shadow_copy_rename(vfs_handle_struct *handle,
const struct smb_filename *smb_fname_src,
const struct smb_filename *smb_fname_dst)
{
char *old_cpath = NULL;
char *old_snap_component = NULL;
char *new_cpath = NULL;
char *new_snap_component = NULL;
struct smb_filename *smb_fname_src_tmp = NULL;
struct smb_filename *smb_fname_dst_tmp = NULL;
NTSTATUS status;
int ret = -1;
status = copy_smb_filename(talloc_tos(), smb_fname_src,
&smb_fname_src_tmp);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
goto out;
}
status = copy_smb_filename(talloc_tos(), smb_fname_dst,
&smb_fname_dst_tmp);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
goto out;
}
if (shadow_copy_match_name(smb_fname_src_tmp->base_name,
&old_snap_component)) {
old_cpath = osc_canonicalize_path(smb_fname_src_tmp->base_name,
old_snap_component);
smb_fname_src_tmp->base_name = old_cpath;
}
if (shadow_copy_match_name(smb_fname_dst_tmp->base_name,
&new_snap_component)) {
new_cpath = osc_canonicalize_path(smb_fname_dst_tmp->base_name,
new_snap_component);
smb_fname_dst_tmp->base_name = new_cpath;
}
ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
smb_fname_dst_tmp);
out:
SAFE_FREE(old_cpath);
SAFE_FREE(new_cpath);
TALLOC_FREE(smb_fname_src_tmp);
TALLOC_FREE(smb_fname_dst_tmp);
return ret;
}
static int
onefs_shadow_copy_stat(vfs_handle_struct *handle,
struct smb_filename *smb_fname)
{
SHADOW_NEXT_SMB_FNAME(STAT,
(handle, smb_fname),
int);
}
static int
onefs_shadow_copy_lstat(vfs_handle_struct *handle,
struct smb_filename *smb_fname)
{
SHADOW_NEXT_SMB_FNAME(LSTAT,
(handle, smb_fname),
int);
}
static int
onefs_shadow_copy_unlink(vfs_handle_struct *handle,
const struct smb_filename *smb_fname_in)
{
struct smb_filename *smb_fname = NULL;
NTSTATUS status;
status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
return -1;
}
SHADOW_NEXT_SMB_FNAME(UNLINK,
(handle, smb_fname),
int);
}
static int
onefs_shadow_copy_chmod(vfs_handle_struct *handle, const char *path,
mode_t mode)
{
SHADOW_NEXT(CHMOD,
(handle, cpath ?: path, mode),
int);
}
static int
onefs_shadow_copy_chown(vfs_handle_struct *handle, const char *path,
uid_t uid, gid_t gid)
{
SHADOW_NEXT(CHOWN,
(handle, cpath ?: path, uid, gid),
int);
}
static int
onefs_shadow_copy_lchown(vfs_handle_struct *handle, const char *path,
uid_t uid, gid_t gid)
{
SHADOW_NEXT(LCHOWN,
(handle, cpath ?: path, uid, gid),
int);
}
static int
onefs_shadow_copy_chdir(vfs_handle_struct *handle, const char *path)
{
SHADOW_NEXT(CHDIR,
(handle, cpath ?: path),
int);
}
static int
onefs_shadow_copy_ntimes(vfs_handle_struct *handle,
const struct smb_filename *smb_fname_in,
struct smb_file_time *ft)
{
struct smb_filename *smb_fname = NULL;
NTSTATUS status;
status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
return -1;
}
SHADOW_NEXT_SMB_FNAME(NTIMES,
(handle, smb_fname, ft),
int);
}
/**
* XXX: macro-ize
*/
static int
onefs_shadow_copy_symlink(vfs_handle_struct *handle,
const char *oldpath, const char *newpath)
{
char *old_cpath = NULL;
char *old_snap_component = NULL;
char *new_cpath = NULL;
char *new_snap_component = NULL;
bool ret;
if (shadow_copy_match_name(oldpath, &old_snap_component))
old_cpath = osc_canonicalize_path(oldpath, old_snap_component);
if (shadow_copy_match_name(newpath, &new_snap_component))
new_cpath = osc_canonicalize_path(newpath, new_snap_component);
ret = SMB_VFS_NEXT_SYMLINK(handle, old_cpath ?: oldpath,
new_cpath ?: newpath);
SAFE_FREE(old_cpath);
SAFE_FREE(new_cpath);
return ret;
}
static int
onefs_shadow_copy_readlink(vfs_handle_struct *handle, const char *path,
char *buf, size_t bufsiz)
{
SHADOW_NEXT(READLINK,
(handle, cpath ?: path, buf, bufsiz),
int);
}
/**
* XXX: macro-ize
*/
static int
onefs_shadow_copy_link(vfs_handle_struct *handle, const char *oldpath,
const char *newpath)
{
char *old_cpath = NULL;
char *old_snap_component = NULL;
char *new_cpath = NULL;
char *new_snap_component = NULL;
int ret;
if (shadow_copy_match_name(oldpath, &old_snap_component))
old_cpath = osc_canonicalize_path(oldpath, old_snap_component);
if (shadow_copy_match_name(newpath, &new_snap_component))
new_cpath = osc_canonicalize_path(newpath, new_snap_component);
ret = SMB_VFS_NEXT_LINK(handle, old_cpath ?: oldpath,
new_cpath ?: newpath);
SAFE_FREE(old_cpath);
SAFE_FREE(new_cpath);
return ret;
}
static int
onefs_shadow_copy_mknod(vfs_handle_struct *handle, const char *path,
mode_t mode, SMB_DEV_T dev)
{
SHADOW_NEXT(MKNOD,
(handle, cpath ?: path, mode, dev),
int);
}
static char *
onefs_shadow_copy_realpath(vfs_handle_struct *handle, const char *path)
{
SHADOW_NEXT(REALPATH,
(handle, cpath ?: path),
char *);
}
static int onefs_shadow_copy_chflags(struct vfs_handle_struct *handle,
const char *path, unsigned int flags)
{
SHADOW_NEXT(CHFLAGS,
(handle, cpath ?: path, flags),
int);
}
static NTSTATUS
onefs_shadow_copy_streaminfo(struct vfs_handle_struct *handle,
struct files_struct *fsp,
const char *path,
TALLOC_CTX *mem_ctx,
unsigned int *num_streams,
struct stream_struct **streams)
{
SHADOW_NEXT(STREAMINFO,
(handle, fsp, cpath ?: path, mem_ctx, num_streams,
streams),
NTSTATUS);
}
static int
onefs_shadow_copy_get_real_filename(struct vfs_handle_struct *handle,
const char *full_path,
const char *path,
TALLOC_CTX *mem_ctx,
char **found_name)
{
SHADOW_NEXT(GET_REAL_FILENAME,
(handle, full_path, cpath ?: path, mem_ctx, found_name),
int);
}
static NTSTATUS
onefs_shadow_copy_get_nt_acl(struct vfs_handle_struct *handle,
const char *path, uint32 security_info,
struct security_descriptor **ppdesc)
{
SHADOW_NEXT(GET_NT_ACL,
(handle, cpath ?: path, security_info, ppdesc),
NTSTATUS);
}
static int
onefs_shadow_copy_chmod_acl(vfs_handle_struct *handle, const char *path,
mode_t mode)
{
SHADOW_NEXT(CHMOD_ACL,
(handle, cpath ?: path, mode),
int);
}
static SMB_ACL_T
onefs_shadow_copy_sys_acl_get_file(vfs_handle_struct *handle,
const char *path, SMB_ACL_TYPE_T type)
{
SHADOW_NEXT(SYS_ACL_GET_FILE,
(handle, cpath ?: path, type),
SMB_ACL_T);
}
static int
onefs_shadow_copy_sys_acl_set_file(vfs_handle_struct *handle, const char *path,
SMB_ACL_TYPE_T type, SMB_ACL_T theacl)
{
SHADOW_NEXT(SYS_ACL_SET_FILE,
(handle, cpath ?: path, type, theacl),
int);
}
static int
onefs_shadow_copy_sys_acl_delete_def_file(vfs_handle_struct *handle,
const char *path)
{
SHADOW_NEXT(SYS_ACL_DELETE_DEF_FILE,
(handle, cpath ?: path),
int);
}
static ssize_t
onefs_shadow_copy_getxattr(vfs_handle_struct *handle, const char *path,
const char *name, void *value, size_t size)
{
SHADOW_NEXT(GETXATTR,
(handle, cpath ?: path, name, value, size),
ssize_t);
}
static ssize_t
onefs_shadow_copy_lgetxattr(vfs_handle_struct *handle, const char *path,
const char *name, void *value, size_t size)
{
SHADOW_NEXT(LGETXATTR,
(handle, cpath ?: path, name, value, size),
ssize_t);
}
static ssize_t
onefs_shadow_copy_listxattr(vfs_handle_struct *handle, const char *path,
char *list, size_t size)
{
SHADOW_NEXT(LISTXATTR,
(handle, cpath ?: path, list, size),
ssize_t);
}
static ssize_t
onefs_shadow_copy_llistxattr(vfs_handle_struct *handle, const char *path,
char *list, size_t size)
{
SHADOW_NEXT(LLISTXATTR,
(handle, cpath ?: path, list, size),
ssize_t);
}
static int
onefs_shadow_copy_removexattr(vfs_handle_struct *handle, const char *path,
const char *name)
{
SHADOW_NEXT(REMOVEXATTR,
(handle, cpath ?: path, name),
int);
}
static int
onefs_shadow_copy_lremovexattr(vfs_handle_struct *handle, const char *path,
const char *name)
{
SHADOW_NEXT(LREMOVEXATTR,
(handle, cpath ?: path, name),
int);
}
static int
onefs_shadow_copy_setxattr(vfs_handle_struct *handle, const char *path,
const char *name, const void *value, size_t size,
int flags)
{
SHADOW_NEXT(SETXATTR,
(handle, cpath ?: path, name, value, size, flags),
int);
}
static int
onefs_shadow_copy_lsetxattr(vfs_handle_struct *handle, const char *path,
const char *name, const void *value, size_t size,
int flags)
{
SHADOW_NEXT(LSETXATTR,
(handle, cpath ?: path, name, value, size, flags),
int);
}
static bool
onefs_shadow_copy_is_offline(struct vfs_handle_struct *handle,
const struct smb_fname *fname,
SMB_STRUCT_STAT *sbuf)
{
#error Isilon, please convert "char *path" to "struct smb_fname *fname"
SHADOW_NEXT(IS_OFFLINE,
(handle, cpath ?: path, sbuf),
bool);
}
static int
onefs_shadow_copy_set_offline(struct vfs_handle_struct *handle,
const struct smb_filename *fname)
{
#error Isilon, please convert "char *path" to "struct smb_fname *fname"
SHADOW_NEXT(SET_OFFLINE,
(handle, cpath ?: path),
int);
}
/* VFS operations structure */
static struct vfs_fn_pointers onefs_shadow_copy_fns = {
.disk_free = onefs_shadow_copy_disk_free,
.get_shadow_copy_data = onefs_shadow_copy_get_shadow_copy_data,
.statvfs = onefs_shadow_copy_statvfs,
.opendir = onefs_shadow_copy_opendir,
.mkdir = onefs_shadow_copy_mkdir,
.rmdir = onefs_shadow_copy_rmdir,
.open_fn = onefs_shadow_copy_open,
.create_file = onefs_shadow_copy_create_file,
.rename = onefs_shadow_copy_rename,
.stat = onefs_shadow_copy_stat,
.stat = onefs_shadow_copy_stat,
.lstat = onefs_shadow_copy_lstat,
.unlink = onefs_shadow_copy_unlink,
.chmod = onefs_shadow_copy_chmod,
.chown = onefs_shadow_copy_chown,
.lchown = onefs_shadow_copy_lchown,
.chdir = onefs_shadow_copy_chdir,
.ntimes = onefs_shadow_copy_ntimes,
.symlink = onefs_shadow_copy_symlink,
.vfs_readlink = onefs_shadow_copy_readlink,
.link = onefs_shadow_copy_link,
.mknod = onefs_shadow_copy_mknod,
.realpath = onefs_shadow_copy_realpath,
.chflags = onefs_shadow_copy_chflags,
.streaminfo = onefs_shadow_copy_streaminfo,
.get_real_filename = onefs_shadow_copy_get_real_filename,
.get_nt_acl = onefs_shadow_copy_get_nt_acl,
.chmod_acl = onefs_shadow_copy_chmod_acl,
.sys_acl_get_file = onefs_shadow_copy_sys_acl_get_file,
.sys_acl_set_file = onefs_shadow_copy_sys_acl_set_file,
.sys_acl_delete_def_file = onefs_shadow_copy_sys_acl_delete_def_file,
.getxattr = onefs_shadow_copy_getxattr,
.lgetxattr = onefs_shadow_copy_lgetxattr,
.listxattr = onefs_shadow_copy_listxattr,
.llistxattr = onefs_shadow_copy_llistxattr,
.removexattr = onefs_shadow_copy_removexattr,
.lremovexattr = onefs_shadow_copy_lremovexattr,
.setxattr = onefs_shadow_copy_setxattr,
.lsetxattr = onefs_shadow_copy_lsetxattr,
.is_offline = onefs_shadow_copy_is_offline,
.set_offline = onefs_shadow_copy_set_offline,
};
NTSTATUS vfs_shadow_copy_init(void)
{
NTSTATUS ret;
ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
"onefs_shadow_copy",
&onefs_shadow_copy_fns);
if (!NT_STATUS_IS_OK(ret))
return ret;
vfs_onefs_shadow_copy_debug_level = debug_add_class("onefs_shadow_copy");
if (vfs_onefs_shadow_copy_debug_level == -1) {
vfs_onefs_shadow_copy_debug_level = DBGC_VFS;
DEBUG(0, ("Couldn't register custom debugging class!\n"));
} else {
DEBUG(10, ("Debug class number of 'onefs_shadow_copy': %d\n",
vfs_onefs_shadow_copy_debug_level));
}
return ret;
}