#include "lib/util/tevent_unix.h"
#include "lib/asys/asys.h"
#include "lib/util/tevent_ntstatus.h"
+#include "lib/util/sys_rw.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_VFS
/* Disk operations */
-static uint64_t vfswrap_disk_free(vfs_handle_struct *handle, const char *path, bool small_query, uint64_t *bsize,
- uint64_t *dfree, uint64_t *dsize)
+static uint64_t vfswrap_disk_free(vfs_handle_struct *handle, const char *path,
+ uint64_t *bsize, uint64_t *dfree,
+ uint64_t *dsize)
{
- uint64_t result;
+ if (sys_fsusage(path, dfree, dsize) != 0) {
+ return (uint64_t)-1;
+ }
- result = sys_disk_free(handle->conn, path, small_query, bsize, dfree, dsize);
- return result;
+ *bsize = 512;
+ return *dfree / 2;
}
-static int vfswrap_get_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
+static int vfswrap_get_quota(struct vfs_handle_struct *handle, const char *path,
+ enum SMB_QUOTA_TYPE qtype, unid_t id,
+ SMB_DISK_QUOTA *qt)
{
#ifdef HAVE_SYS_QUOTAS
int result;
START_PROFILE(syscall_get_quota);
- result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
+ result = sys_get_quota(path, qtype, id, qt);
END_PROFILE(syscall_get_quota);
return result;
#else
pathnamep[consumedcnt] = '\0';
if (DEBUGLVL(3)) {
- dbgtext("setup_dfs_referral: Path %s to "
- "alternate path(s):",
+ dbgtext("Path %s to alternate path(s):",
pathnamep);
for (i=0; i < junction->referral_count; i++) {
dbgtext(" %s",
}
break;
default:
- DEBUG(0,("setup_dfs_referral: Invalid dfs referral "
- "version: %d\n",
+ DEBUG(0,("Invalid dfs referral version: %d\n",
max_referral_level));
return NT_STATUS_INVALID_LEVEL;
}
return NT_STATUS_OK;
}
+static NTSTATUS vfswrap_snap_check_path(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ const char *service_path,
+ char **base_volume)
+{
+ return NT_STATUS_NOT_SUPPORTED;
+}
+
+static NTSTATUS vfswrap_snap_create(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ const char *base_volume,
+ time_t *tstamp,
+ bool rw,
+ char **base_path,
+ char **snap_path)
+{
+ return NT_STATUS_NOT_SUPPORTED;
+}
+
+static NTSTATUS vfswrap_snap_delete(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ char *base_path,
+ char *snap_path)
+{
+ return NT_STATUS_NOT_SUPPORTED;
+}
+
/* Directory operations */
-static DIR *vfswrap_opendir(vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attr)
+static DIR *vfswrap_opendir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ const char *mask,
+ uint32_t attr)
{
DIR *result;
START_PROFILE(syscall_opendir);
- result = opendir(fname);
+ result = opendir(smb_fname->base_name);
END_PROFILE(syscall_opendir);
return result;
}
static DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
files_struct *fsp,
const char *mask,
- uint32 attr)
+ uint32_t attr)
{
DIR *result;
if (ret == 0) {
init_stat_ex_from_stat(sbuf,
&st,
- lp_fake_dir_create_times(
+ lp_fake_directory_create_times(
SNUM(handle->conn)));
}
}
return result;
}
+static NTSTATUS vfswrap_readdir_attr(struct vfs_handle_struct *handle,
+ const struct smb_filename *fname,
+ TALLOC_CTX *mem_ctx,
+ struct readdir_attr_data **attr_data)
+{
+ return NT_STATUS_NOT_SUPPORTED;
+}
+
static void vfswrap_seekdir(vfs_handle_struct *handle, DIR *dirp, long offset)
{
START_PROFILE(syscall_seekdir);
END_PROFILE(syscall_rewinddir);
}
-static int vfswrap_mkdir(vfs_handle_struct *handle, const char *path, mode_t mode)
+static int vfswrap_mkdir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ mode_t mode)
{
int result;
bool has_dacl = False;
+ const char *path = smb_fname->base_name;
char *parent = NULL;
START_PROFILE(syscall_mkdir);
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 & lp_dir_mask(SNUM(handle->conn)));
+ && (has_dacl = directory_has_default_acl(handle->conn, parent))) {
+ mode = (0777 & lp_directory_mask(SNUM(handle->conn)));
+ }
TALLOC_FREE(parent);
* 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))
+ if ((SMB_VFS_CHMOD_ACL(handle->conn, smb_fname, mode) == -1) &&
+ (errno == ENOSYS)) {
errno = saved_errno;
+ }
}
END_PROFILE(syscall_mkdir);
return result;
}
-static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
+static int vfswrap_rmdir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
{
int result;
START_PROFILE(syscall_rmdir);
- result = rmdir(path);
+ result = rmdir(smb_fname->base_name);
END_PROFILE(syscall_rmdir);
return result;
}
uint32_t create_options,
uint32_t file_attributes,
uint32_t oplock_request,
+ struct smb2_lease *lease,
uint64_t allocation_size,
uint32_t private_flags,
struct security_descriptor *sd,
struct ea_list *ea_list,
files_struct **result,
- int *pinfo)
+ int *pinfo,
+ const struct smb2_create_blobs *in_context_blobs,
+ struct smb2_create_blobs *out_context_blobs)
{
return create_file_default(handle->conn, req, root_dir_fid, smb_fname,
access_mask, share_access,
create_disposition, create_options,
- file_attributes, oplock_request,
+ file_attributes, oplock_request, lease,
allocation_size, private_flags,
sd, ea_list, result,
- pinfo);
+ pinfo, in_context_blobs, out_context_blobs);
}
static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
START_PROFILE_BYTES(syscall_read, n);
result = sys_read(fsp->fh->fd, data, n);
- END_PROFILE(syscall_read);
+ END_PROFILE_BYTES(syscall_read);
return result;
}
#if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
START_PROFILE_BYTES(syscall_pread, n);
result = sys_pread(fsp->fh->fd, data, n, offset);
- END_PROFILE(syscall_pread);
+ END_PROFILE_BYTES(syscall_pread);
if (result == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can be seeked (sought?) on. */
START_PROFILE_BYTES(syscall_write, n);
result = sys_write(fsp->fh->fd, data, n);
- END_PROFILE(syscall_write);
+ END_PROFILE_BYTES(syscall_write);
return result;
}
#if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
START_PROFILE_BYTES(syscall_pwrite, n);
result = sys_pwrite(fsp->fh->fd, data, n, offset);
- END_PROFILE(syscall_pwrite);
+ END_PROFILE_BYTES(syscall_pwrite);
if (result == -1 && errno == ESPIPE) {
/* Maintain the fiction that pipes can be sought on. */
struct tevent_fd *fde,
uint16_t flags, void *p);
-static bool vfswrap_init_asys_ctx(struct smbXsrv_connection *conn)
+static bool vfswrap_init_asys_ctx(struct smbd_server_connection *conn)
{
+ struct asys_context *ctx;
+ struct tevent_fd *fde;
int ret;
int fd;
if (conn->asys_ctx != NULL) {
return true;
}
- ret = asys_context_init(&conn->asys_ctx, aio_pending_size);
+
+ ret = asys_context_init(&ctx, lp_aio_max_threads());
if (ret != 0) {
DEBUG(1, ("asys_context_init failed: %s\n", strerror(ret)));
return false;
}
- fd = asys_signalfd(conn->asys_ctx);
+ fd = asys_signalfd(ctx);
- set_blocking(fd, false);
+ ret = set_blocking(fd, false);
+ if (ret != 0) {
+ DBG_WARNING("set_blocking failed: %s\n", strerror(errno));
+ goto fail;
+ }
- conn->asys_fde = tevent_add_fd(conn->ev_ctx, conn, fd,
- TEVENT_FD_READ,
- vfswrap_asys_finished,
- conn->asys_ctx);
- if (conn->asys_fde == NULL) {
+ fde = tevent_add_fd(conn->ev_ctx, conn, fd, TEVENT_FD_READ,
+ vfswrap_asys_finished, ctx);
+ if (fde == NULL) {
DEBUG(1, ("tevent_add_fd failed\n"));
- asys_context_destroy(conn->asys_ctx);
- conn->asys_ctx = NULL;
- return false;
+ goto fail;
}
+
+ conn->asys_ctx = ctx;
+ conn->asys_fde = fde;
return true;
+
+fail:
+ asys_context_destroy(ctx);
+ return false;
}
struct vfswrap_asys_state {
struct asys_context *asys_ctx;
struct tevent_req *req;
ssize_t ret;
- int err;
+ struct vfs_aio_state vfs_aio_state;
+ SMBPROFILE_BASIC_ASYNC_STATE(profile_basic);
+ SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
};
static int vfswrap_asys_state_destructor(struct vfswrap_asys_state *s)
if (req == NULL) {
return NULL;
}
- if (!vfswrap_init_asys_ctx(handle->conn->sconn->conn)) {
+ if (!vfswrap_init_asys_ctx(handle->conn->sconn)) {
tevent_req_oom(req);
return tevent_req_post(req, ev);
}
- state->asys_ctx = handle->conn->sconn->conn->asys_ctx;
+ state->asys_ctx = handle->conn->sconn->asys_ctx;
state->req = req;
+ SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pread, profile_p,
+ state->profile_bytes, n);
ret = asys_pread(state->asys_ctx, fsp->fh->fd, data, n, offset, req);
if (ret != 0) {
tevent_req_error(req, ret);
if (req == NULL) {
return NULL;
}
- if (!vfswrap_init_asys_ctx(handle->conn->sconn->conn)) {
+ if (!vfswrap_init_asys_ctx(handle->conn->sconn)) {
tevent_req_oom(req);
return tevent_req_post(req, ev);
}
- state->asys_ctx = handle->conn->sconn->conn->asys_ctx;
+ state->asys_ctx = handle->conn->sconn->asys_ctx;
state->req = req;
+ SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pwrite, profile_p,
+ state->profile_bytes, n);
ret = asys_pwrite(state->asys_ctx, fsp->fh->fd, data, n, offset, req);
if (ret != 0) {
tevent_req_error(req, ret);
if (req == NULL) {
return NULL;
}
- if (!vfswrap_init_asys_ctx(handle->conn->sconn->conn)) {
+ if (!vfswrap_init_asys_ctx(handle->conn->sconn)) {
tevent_req_oom(req);
return tevent_req_post(req, ev);
}
- state->asys_ctx = handle->conn->sconn->conn->asys_ctx;
+ state->asys_ctx = handle->conn->sconn->asys_ctx;
state->req = req;
+ SMBPROFILE_BASIC_ASYNC_START(syscall_asys_fsync, profile_p,
+ state->profile_basic);
ret = asys_fsync(state->asys_ctx, fsp->fh->fd, req);
if (ret != 0) {
tevent_req_error(req, ret);
uint16_t flags, void *p)
{
struct asys_context *asys_ctx = (struct asys_context *)p;
- struct tevent_req *req;
- struct vfswrap_asys_state *state;
- int res;
- ssize_t ret;
- int err;
- void *private_data;
+ struct asys_result results[get_outstanding_aio_calls()];
+ int i, ret;
if ((flags & TEVENT_FD_READ) == 0) {
return;
}
- while (true) {
- res = asys_result(asys_ctx, &ret, &err, &private_data);
- if (res == EINTR || res == EAGAIN) {
- return;
- }
-#ifdef EWOULDBLOCK
- if (res == EWOULDBLOCK) {
- return;
- }
-#endif
+ ret = asys_results(asys_ctx, results, get_outstanding_aio_calls());
+ if (ret < 0) {
+ DEBUG(1, ("asys_results returned %s\n", strerror(-ret)));
+ return;
+ }
- if (res == ECANCELED) {
- return;
- }
+ for (i=0; i<ret; i++) {
+ struct asys_result *result = &results[i];
+ struct tevent_req *req;
+ struct vfswrap_asys_state *state;
- if (res != 0) {
- DEBUG(1, ("asys_result returned %s\n", strerror(res)));
- return;
+ if ((result->ret == -1) && (result->err == ECANCELED)) {
+ continue;
}
- req = talloc_get_type_abort(private_data, struct tevent_req);
+ req = talloc_get_type_abort(result->private_data,
+ struct tevent_req);
state = tevent_req_data(req, struct vfswrap_asys_state);
talloc_set_destructor(state, NULL);
- state->ret = ret;
- state->err = err;
+ SMBPROFILE_BASIC_ASYNC_END(state->profile_basic);
+ SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
+ state->ret = result->ret;
+ state->vfs_aio_state.error = result->err;
+ state->vfs_aio_state.duration = result->duration;
tevent_req_defer_callback(req, ev);
tevent_req_done(req);
}
}
-static ssize_t vfswrap_asys_ssize_t_recv(struct tevent_req *req, int *err)
+static ssize_t vfswrap_asys_ssize_t_recv(struct tevent_req *req,
+ struct vfs_aio_state *vfs_aio_state)
{
struct vfswrap_asys_state *state = tevent_req_data(
req, struct vfswrap_asys_state);
- if (tevent_req_is_unix_error(req, err)) {
+ if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
return -1;
}
- *err = state->err;
+ *vfs_aio_state = state->vfs_aio_state;
return state->ret;
}
-static int vfswrap_asys_int_recv(struct tevent_req *req, int *err)
+static int vfswrap_asys_int_recv(struct tevent_req *req,
+ struct vfs_aio_state *vfs_aio_state)
{
struct vfswrap_asys_state *state = tevent_req_data(
req, struct vfswrap_asys_state);
- if (tevent_req_is_unix_error(req, err)) {
+ if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
return -1;
}
- *err = state->err;
+ *vfs_aio_state = state->vfs_aio_state;
return state->ret;
}
START_PROFILE_BYTES(syscall_sendfile, n);
result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
- END_PROFILE(syscall_sendfile);
+ END_PROFILE_BYTES(syscall_sendfile);
return result;
}
START_PROFILE_BYTES(syscall_recvfile, n);
result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
- END_PROFILE(syscall_recvfile);
+ END_PROFILE_BYTES(syscall_recvfile);
return result;
}
}
result = sys_stat(smb_fname->base_name, &smb_fname->st,
- lp_fake_dir_create_times(SNUM(handle->conn)));
+ lp_fake_directory_create_times(SNUM(handle->conn)));
out:
END_PROFILE(syscall_stat);
return result;
START_PROFILE(syscall_fstat);
result = sys_fstat(fsp->fh->fd,
- sbuf, lp_fake_dir_create_times(SNUM(handle->conn)));
+ sbuf, lp_fake_directory_create_times(SNUM(handle->conn)));
END_PROFILE(syscall_fstat);
return result;
}
}
result = sys_lstat(smb_fname->base_name, &smb_fname->st,
- lp_fake_dir_create_times(SNUM(handle->conn)));
+ lp_fake_directory_create_times(SNUM(handle->conn)));
out:
END_PROFILE(syscall_lstat);
return result;
{
const char *in_data = (const char *)_in_data;
char **out_data = (char **)_out_data;
+ NTSTATUS status;
switch (function) {
case FSCTL_SET_SPARSE:
{
bool set_sparse = true;
- NTSTATUS status;
if (in_len >= 1 && in_data[0] == 0) {
set_sparse = false;
}
status = file_set_sparse(handle->conn, fsp, set_sparse);
-
+
DEBUG(NT_STATUS_IS_OK(status) ? 10 : 9,
("FSCTL_SET_SPARSE: fname[%s] set[%u] - %s\n",
- smb_fname_str_dbg(fsp->fsp_name), set_sparse,
+ smb_fname_str_dbg(fsp->fsp_name), set_sparse,
nt_errstr(status)));
return status;
DEBUG(10,("FSCTL_CREATE_OR_GET_OBJECT_ID: called on %s\n",
fsp_fnum_dbg(fsp)));
- *out_len = (max_out_len >= 64) ? 64 : max_out_len;
+ *out_len = MIN(max_out_len, 64);
+
/* Hmmm, will this cause problems if less data asked for? */
return_data = talloc_array(ctx, char, 64);
if (return_data == NULL) {
push_file_id_16(return_data, &fsp->file_id);
memcpy(return_data+16,create_volume_objectid(fsp->conn,objid),16);
push_file_id_16(return_data+32, &fsp->file_id);
+ memset(return_data+48, 0, 16);
*out_data = return_data;
return NT_STATUS_OK;
}
*/
struct shadow_copy_data *shadow_data = NULL;
bool labels = False;
- uint32 labels_data_count = 0;
- uint32 i;
+ uint32_t labels_data_count = 0;
+ uint32_t i;
char *cur_pdata = NULL;
if (max_out_len < 16) {
* Call the VFS routine to actually do the work.
*/
if (SMB_VFS_GET_SHADOW_COPY_DATA(fsp, shadow_data, labels)!=0) {
- TALLOC_FREE(shadow_data);
- if (errno == ENOSYS) {
- DEBUG(5,("FSCTL_GET_SHADOW_COPY_DATA: connectpath %s, not supported.\n",
- fsp->conn->connectpath));
- return NT_STATUS_NOT_SUPPORTED;
+ int log_lev = 0;
+ if (errno == 0) {
+ /* broken module didn't set errno on error */
+ status = NT_STATUS_UNSUCCESSFUL;
} else {
- DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: connectpath %s, failed.\n",
- fsp->conn->connectpath));
- return NT_STATUS_UNSUCCESSFUL;
+ status = map_nt_error_from_unix(errno);
+ if (NT_STATUS_EQUAL(status,
+ NT_STATUS_NOT_SUPPORTED)) {
+ log_lev = 5;
+ }
}
+ DEBUG(log_lev, ("FSCTL_GET_SHADOW_COPY_DATA: "
+ "connectpath %s, failed - %s.\n",
+ fsp->conn->connectpath,
+ nt_errstr(status)));
+ TALLOC_FREE(shadow_data);
+ return status;
}
- labels_data_count = (shadow_data->num_volumes * 2 *
+ labels_data_count = (shadow_data->num_volumes * 2 *
sizeof(SHADOW_COPY_LABEL)) + 2;
if (!labels) {
*out_len = 16;
} else {
- *out_len = 12 + labels_data_count + 4;
+ *out_len = 12 + labels_data_count;
}
if (max_out_len < *out_len) {
return NT_STATUS_BUFFER_TOO_SMALL;
}
- cur_pdata = talloc_array(ctx, char, *out_len);
+ cur_pdata = talloc_zero_array(ctx, char, *out_len);
if (cur_pdata == NULL) {
TALLOC_FREE(shadow_data);
return NT_STATUS_NO_MEMORY;
}
/* needed_data_count 4 bytes */
- SIVAL(cur_pdata, 8, labels_data_count + 4);
+ SIVAL(cur_pdata, 8, labels_data_count);
cur_pdata += 12;
shadow_data->num_volumes, fsp_str_dbg(fsp)));
if (labels && shadow_data->labels) {
for (i=0; i<shadow_data->num_volumes; i++) {
- srvstr_push(cur_pdata, req_flags,
+ size_t len = 0;
+ status = srvstr_push(cur_pdata, req_flags,
cur_pdata, shadow_data->labels[i],
2 * sizeof(SHADOW_COPY_LABEL),
- STR_UNICODE|STR_TERMINATE);
+ STR_UNICODE|STR_TERMINATE, &len);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(*out_data);
+ TALLOC_FREE(shadow_data);
+ return status;
+ }
cur_pdata += 2 * sizeof(SHADOW_COPY_LABEL);
DEBUGADD(10,("Label[%u]: '%s'\n",i,shadow_data->labels[i]));
}
/* unknown 4 bytes: this is not the length of the sid :-( */
/*unknown = IVAL(pdata,0);*/
- if (!sid_parse(in_data + 4, sid_len, &sid)) {
+ if (!sid_parse(_in_data + 4, sid_len, &sid)) {
return NT_STATUS_INVALID_PARAMETER;
}
DEBUGADD(10, ("for SID: %s\n", sid_string_dbg(&sid)));
* and SEEK_DATA/SEEK_HOLE on Solaris is needed to make
* this FSCTL correct for sparse files.
*/
- NTSTATUS status;
uint64_t offset, length;
char *out_data_tmp = NULL;
}
default:
- /*
+ /*
* Only print once ... unfortunately there could be lots of
* different FSCTLs that are called.
*/
struct vfs_cc_state {
off_t copied;
- uint8_t buf[65536];
+ uint8_t *buf;
};
static struct tevent_req *vfswrap_copy_chunk_send(struct vfs_handle_struct *handle,
return NULL;
}
+ vfs_cc_state->buf = talloc_array(vfs_cc_state, uint8_t,
+ MIN(num, 8*1024*1024));
+ if (tevent_req_nomem(vfs_cc_state->buf, req)) {
+ return tevent_req_post(req, ev);
+ }
+
status = vfs_stat_fsp(src_fsp);
if (tevent_req_nterror(req, status)) {
return tevent_req_post(req, ev);
struct lock_struct lck;
int saved_errno;
- off_t this_num = MIN(sizeof(vfs_cc_state->buf),
+ off_t this_num = MIN(talloc_array_length(vfs_cc_state->buf),
num - vfs_cc_state->copied);
+ if (src_fsp->op == NULL) {
+ tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+ return tevent_req_post(req, ev);
+ }
init_strict_lock_struct(src_fsp,
src_fsp->op->global->open_persistent_id,
src_off,
src_off += ret;
+ if (dest_fsp->op == NULL) {
+ tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+ return tevent_req_post(req, ev);
+ }
+
init_strict_lock_struct(dest_fsp,
dest_fsp->op->global->open_persistent_id,
dest_off,
return NT_STATUS_OK;
}
+static NTSTATUS vfswrap_get_compression(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ struct files_struct *fsp,
+ struct smb_filename *smb_fname,
+ uint16_t *_compression_fmt)
+{
+ return NT_STATUS_INVALID_DEVICE_REQUEST;
+}
+
+static NTSTATUS vfswrap_set_compression(struct vfs_handle_struct *handle,
+ TALLOC_CTX *mem_ctx,
+ struct files_struct *fsp,
+ uint16_t compression_fmt)
+{
+ return NT_STATUS_INVALID_DEVICE_REQUEST;
+}
+
/********************************************************************
Given a stat buffer return the allocated size on disk, taking into
account sparse files.
#else
#error SIZEOF_BLKCNT_T_NOT_A_SUPPORTED_VALUE
#endif
+ if (result == 0) {
+ /*
+ * Some file systems do not allocate a block for very
+ * small files. But for non-empty file should report a
+ * positive size.
+ */
+
+ uint64_t filesize = get_file_size_stat(sbuf);
+ if (filesize > 0) {
+ result = MIN((uint64_t)STAT_ST_BLOCKSIZE, filesize);
+ }
+ }
#else
result = get_file_size_stat(sbuf);
#endif
return result;
}
-static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
+static int vfswrap_chmod(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ mode_t mode)
{
int result;
{
int saved_errno = errno; /* We might get ENOSYS */
- if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
+ result = SMB_VFS_CHMOD_ACL(handle->conn,
+ smb_fname,
+ mode);
+ if (result == 0) {
END_PROFILE(syscall_chmod);
return result;
}
errno = saved_errno;
}
- result = chmod(path, mode);
+ result = chmod(smb_fname->base_name, mode);
END_PROFILE(syscall_chmod);
return result;
}
return result;
}
-static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
+static int vfswrap_chown(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ uid_t uid,
+ gid_t gid)
{
int result;
START_PROFILE(syscall_chown);
- result = chown(path, uid, gid);
+ result = chown(smb_fname->base_name, uid, gid);
END_PROFILE(syscall_chown);
return result;
}
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;
+ ret = SMB_VFS_FALLOCATE(fsp, 0, pst->st_ex_size, space_to_write);
+ if (ret == -1 && errno == ENOSPC) {
return -1;
}
if (ret == 0) {
return 0;
}
DEBUG(10,("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
- "error %d. Falling back to slow manual allocation\n", ret));
+ "error %d. Falling back to slow manual allocation\n", errno));
/* available disk space is enough or not? */
space_avail = get_dfree_info(fsp->conn,
- fsp->fsp_name->base_name, false,
- &bsize,&dfree,&dsize);
+ fsp->fsp_name->base_name,
+ &bsize, &dfree, &dsize);
/* space_avail is 1k blocks */
if (space_avail == (uint64_t)-1 ||
((uint64_t)space_to_write/1024 > space_avail) ) {
/* 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 -1;
}
return 0;
ftruncate extend but ext2 can. */
result = ftruncate(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
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
+
+ /* We need to update the files_struct after successful ftruncate */
+ if (result == 0) {
+ goto done;
+ }
+
pst = &fsp->fsp_name->st;
#ifdef S_ISFIFO
static int vfswrap_fallocate(vfs_handle_struct *handle,
files_struct *fsp,
- enum vfs_fallocate_mode mode,
+ uint32_t mode,
off_t offset,
off_t len)
{
int result;
START_PROFILE(syscall_fallocate);
- if (mode == VFS_FALLOCATE_EXTEND_SIZE) {
+ if (mode == 0) {
result = sys_posix_fallocate(fsp->fh->fd, offset, len);
- } else if (mode == VFS_FALLOCATE_KEEP_SIZE) {
- result = sys_fallocate(fsp->fh->fd, mode, offset, len);
+ /*
+ * posix_fallocate returns 0 on success, errno on error
+ * and doesn't set errno. Make it behave like fallocate()
+ * which returns -1, and sets errno on failure.
+ */
+ if (result != 0) {
+ errno = result;
+ result = -1;
+ }
} else {
- errno = EINVAL;
- result = -1;
+ /* sys_fallocate handles filtering of unsupported mode flags */
+ result = sys_fallocate(fsp->fh->fd, mode, offset, len);
}
END_PROFILE(syscall_fallocate);
return result;
}
static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
- uint32 share_mode, uint32 access_mask)
+ uint32_t share_mode, uint32_t access_mask)
{
START_PROFILE(syscall_kernel_flock);
kernel_flock(fsp->fh->fd, share_mode, access_mask);
char *result;
START_PROFILE(syscall_realpath);
-#ifdef REALPATH_TAKES_NULL
- result = realpath(path, NULL);
-#else
- result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
- if (result) {
- char *resolved_path = realpath(path, result);
- if (!resolved_path) {
- SAFE_FREE(result);
- } else {
- /* SMB_ASSERT(result == resolved_path) ? */
- result = resolved_path;
- }
- }
-#endif
+ result = sys_realpath(path);
END_PROFILE(syscall_realpath);
return result;
}
-static NTSTATUS vfswrap_notify_watch(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)
-{
- /*
- * So far inotify is the only supported default notify mechanism. If
- * another platform like the the BSD's or a proprietary Unix comes
- * along and wants another default, we can play the same trick we
- * played with Posix ACLs.
- *
- * Until that is the case, hard-code inotify here.
- */
-#ifdef HAVE_INOTIFY
- if (lp_kernel_change_notify(vfs_handle->conn->params)) {
- return inotify_watch(ctx, path, filter, subdir_filter,
- callback, private_data, handle);
- }
-#endif
- /*
- * Do nothing, leave everything to notify_internal.c
- */
- return NT_STATUS_OK;
-}
-
static int vfswrap_chflags(vfs_handle_struct *handle, const char *path,
unsigned int flags)
{
static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
struct byte_range_lock *br_lck,
struct lock_struct *plock,
- bool blocking_lock,
- struct blocking_lock_record *blr)
+ bool blocking_lock)
{
SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct *handle,
struct byte_range_lock *br_lck,
- struct lock_struct *plock,
- struct blocking_lock_record *blr)
+ struct lock_struct *plock)
{
SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
files_struct *fsp,
- uint32 security_info,
+ uint32_t security_info,
TALLOC_CTX *mem_ctx,
struct security_descriptor **ppdesc)
{
}
static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
- const char *name,
- uint32 security_info,
+ const struct smb_filename *smb_fname,
+ uint32_t security_info,
TALLOC_CTX *mem_ctx,
struct security_descriptor **ppdesc)
{
NTSTATUS result;
START_PROFILE(get_nt_acl);
- result = posix_get_nt_acl(handle->conn, name, security_info,
- mem_ctx, ppdesc);
+ result = posix_get_nt_acl(handle->conn,
+ smb_fname->base_name,
+ security_info,
+ mem_ctx,
+ ppdesc);
END_PROFILE(get_nt_acl);
return result;
}
-static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
+static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32_t security_info_sent, const struct security_descriptor *psd)
{
NTSTATUS result;
return NT_STATUS_OK; /* Nothing to do here ... */
}
-static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
+static int vfswrap_chmod_acl(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ mode_t mode)
{
#ifdef HAVE_NO_ACL
errno = ENOSYS;
int result;
START_PROFILE(chmod_acl);
- result = chmod_acl(handle->conn, name, mode);
+ result = chmod_acl(handle->conn, smb_fname->base_name, mode);
END_PROFILE(chmod_acl);
return result;
#endif
.statvfs_fn = vfswrap_statvfs,
.fs_capabilities_fn = vfswrap_fs_capabilities,
.get_dfs_referrals_fn = vfswrap_get_dfs_referrals,
+ .snap_check_path_fn = vfswrap_snap_check_path,
+ .snap_create_fn = vfswrap_snap_create,
+ .snap_delete_fn = vfswrap_snap_delete,
/* Directory operations */
.opendir_fn = vfswrap_opendir,
.fdopendir_fn = vfswrap_fdopendir,
.readdir_fn = vfswrap_readdir,
+ .readdir_attr_fn = vfswrap_readdir_attr,
.seekdir_fn = vfswrap_seekdir,
.telldir_fn = vfswrap_telldir,
.rewind_dir_fn = vfswrap_rewinddir,
.link_fn = vfswrap_link,
.mknod_fn = vfswrap_mknod,
.realpath_fn = vfswrap_realpath,
- .notify_watch_fn = vfswrap_notify_watch,
.chflags_fn = vfswrap_chflags,
.file_id_create_fn = vfswrap_file_id_create,
.streaminfo_fn = vfswrap_streaminfo,
.fsctl_fn = vfswrap_fsctl,
.copy_chunk_send_fn = vfswrap_copy_chunk_send,
.copy_chunk_recv_fn = vfswrap_copy_chunk_recv,
+ .get_compression_fn = vfswrap_get_compression,
+ .set_compression_fn = vfswrap_set_compression,
/* NT ACL operations. */
git.samba.org / kai / samba-autobuild / .git / blobdiff