return false;
}
-static void skel_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-{
- ;
-}
-
static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
const char *mapped_name,
enum vfs_translate_direction direction,
.brl_unlock_windows_fn = skel_brl_unlock_windows,
.brl_cancel_windows_fn = skel_brl_cancel_windows,
.strict_lock_fn = skel_strict_lock,
- .strict_unlock_fn = skel_strict_unlock,
.translate_name_fn = skel_translate_name,
.fsctl_fn = skel_fsctl,
.readdir_attr_fn = skel_readdir_attr,
return SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock);
}
-static void skel_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-{
- SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock);
-}
-
static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
const char *mapped_name,
enum vfs_translate_direction direction,
.brl_unlock_windows_fn = skel_brl_unlock_windows,
.brl_cancel_windows_fn = skel_brl_cancel_windows,
.strict_lock_fn = skel_strict_lock,
- .strict_unlock_fn = skel_strict_unlock,
.translate_name_fn = skel_translate_name,
.fsctl_fn = skel_fsctl,
.readdir_attr_fn = skel_readdir_attr,
/* Version 37 - Add SMB_VFS_OFFLOAD_READ_SEND/RECV */
/* Version 37 - Rename SMB_VFS_COPY_CHUNK_SEND/RECV to
SMB_VFS_OFFLOAD_READ_SEND/RECV */
+/* Version 37 - Remove SMB_VFS_STRICT_UNLOCK */
#define SMB_VFS_INTERFACE_VERSION 37
struct files_struct *fsp,
struct lock_struct *plock);
- void (*strict_unlock_fn)(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock);
-
NTSTATUS (*translate_name_fn)(struct vfs_handle_struct *handle,
const char *name,
enum vfs_translate_direction direction,
bool smb_vfs_call_strict_lock(struct vfs_handle_struct *handle,
struct files_struct *fsp,
struct lock_struct *plock);
-void smb_vfs_call_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock);
NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle,
const char *name,
enum vfs_translate_direction direction,
#define SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock) \
smb_vfs_call_strict_lock((handle)->next, (fsp), (plock))
-#define SMB_VFS_STRICT_UNLOCK(conn, fsp, plock) \
- smb_vfs_call_strict_unlock((conn)->vfs_handles, (fsp), (plock))
-#define SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock) \
- smb_vfs_call_strict_unlock((handle)->next, (fsp), (plock))
-
#define SMB_VFS_TRANSLATE_NAME(conn, name, direction, mem_ctx, mapped_name) \
smb_vfs_call_translate_name((conn)->vfs_handles, (name), (direction), (mem_ctx), (mapped_name))
#define SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx, mapped_name) \
return ret;
}
-void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
-{
-}
-
/****************************************************************************
Find out if a lock could be granted - return who is blocking us if we can't.
****************************************************************************/
struct lock_struct *plock);
bool strict_lock_default(files_struct *fsp,
struct lock_struct *plock);
-void strict_unlock_default(files_struct *fsp,
- struct lock_struct *plock);
NTSTATUS query_lock(files_struct *fsp,
uint64_t *psmblctx,
uint64_t *pcount,
return tevent_req_post(req, ev);
}
if (!SMB_VFS_STRICT_LOCK(dest_fsp->conn, dest_fsp, &dest_lck)) {
- SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &src_lck);
tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
return tevent_req_post(req, ev);
}
cr_args.src_length = (uint64_t)num;
ret = ioctl(dest_fsp->fh->fd, BTRFS_IOC_CLONE_RANGE, &cr_args);
- if (do_locking) {
- SMB_VFS_STRICT_UNLOCK(dest_fsp->conn, dest_fsp, &dest_lck);
- SMB_VFS_STRICT_UNLOCK(src_fsp->conn, src_fsp, &src_lck);
- }
if (ret < 0) {
/*
* BTRFS_IOC_CLONE_RANGE only supports 'sectorsize' aligned
return ok;
}
-static void catia_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-{
- struct catia_cache *cc = NULL;
- int ret;
-
- ret = CATIA_FETCH_FSP_PRE_NEXT(talloc_tos(), handle, fsp, &cc);
- if (ret != 0) {
- smb_panic("CATIA_FETCH_FSP_PRE_NEXT failed\n");
- }
-
- SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock);
-
- CATIA_FETCH_FSP_POST_NEXT(&cc, fsp);
-}
-
static NTSTATUS catia_fsctl(struct vfs_handle_struct *handle,
struct files_struct *fsp,
TALLOC_CTX *ctx,
.chflags_fn = catia_chflags,
.streaminfo_fn = catia_streaminfo,
.strict_lock_fn = catia_strict_lock,
- .strict_unlock_fn = catia_strict_unlock,
.translate_name_fn = catia_translate_name,
.fsctl_fn = catia_fsctl,
.get_dos_attributes_fn = catia_get_dos_attributes,
struct tevent_context *ev;
uint8_t *buf;
bool read_lck_locked;
- struct lock_struct read_lck;
bool write_lck_locked;
- struct lock_struct write_lck;
DATA_BLOB *token;
struct files_struct *src_fsp;
off_t src_off;
struct vfswrap_offload_write_state *state = tevent_req_data(
req, struct vfswrap_offload_write_state);
struct tevent_req *subreq = NULL;
+ struct lock_struct read_lck;
bool ok;
state->next_io_size = MIN(state->remaining, talloc_array_length(state->buf));
state->src_off,
state->next_io_size,
READ_LOCK,
- &state->read_lck);
+ &read_lck);
ok = SMB_VFS_STRICT_LOCK(state->src_fsp->conn,
state->src_fsp,
- &state->read_lck);
+ &read_lck);
if (!ok) {
return NT_STATUS_FILE_LOCK_CONFLICT;
}
struct vfswrap_offload_write_state *state = tevent_req_data(
req, struct vfswrap_offload_write_state);
struct vfs_aio_state aio_state;
+ struct lock_struct write_lck;
ssize_t nread;
bool ok;
- SMB_VFS_STRICT_UNLOCK(state->src_fsp->conn,
- state->src_fsp,
- &state->read_lck);
- ZERO_STRUCT(state->read_lck);
-
nread = SMB_VFS_PREAD_RECV(subreq, &aio_state);
TALLOC_FREE(subreq);
if (nread == -1) {
state->dst_off,
state->next_io_size,
WRITE_LOCK,
- &state->write_lck);
+ &write_lck);
ok = SMB_VFS_STRICT_LOCK(state->dst_fsp->conn,
state->dst_fsp,
- &state->write_lck);
+ &write_lck);
if (!ok) {
tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
return;
ssize_t nwritten;
NTSTATUS status;
- SMB_VFS_STRICT_UNLOCK(state->dst_fsp->conn,
- state->dst_fsp,
- &state->write_lck);
- ZERO_STRUCT(state->write_lck);
-
nwritten = SMB_VFS_PWRITE_RECV(subreq, &aio_state);
TALLOC_FREE(subreq);
if (nwritten == -1) {
return strict_lock_default(fsp, plock);
}
-static void vfswrap_strict_unlock(struct vfs_handle_struct *handle,
- files_struct *fsp,
- struct lock_struct *plock)
-{
- SMB_ASSERT(plock->lock_type == READ_LOCK ||
- plock->lock_type == WRITE_LOCK);
-
- strict_unlock_default(fsp, plock);
-}
-
/* NT ACL operations. */
static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
.brl_unlock_windows_fn = vfswrap_brl_unlock_windows,
.brl_cancel_windows_fn = vfswrap_brl_cancel_windows,
.strict_lock_fn = vfswrap_strict_lock,
- .strict_unlock_fn = vfswrap_strict_unlock,
.translate_name_fn = vfswrap_translate_name,
.fsctl_fn = vfswrap_fsctl,
.set_dos_attributes_fn = vfswrap_set_dos_attributes,
SMB_VFS_OP_BRL_UNLOCK_WINDOWS,
SMB_VFS_OP_BRL_CANCEL_WINDOWS,
SMB_VFS_OP_STRICT_LOCK,
- SMB_VFS_OP_STRICT_UNLOCK,
SMB_VFS_OP_TRANSLATE_NAME,
SMB_VFS_OP_FSCTL,
SMB_VFS_OP_OFFLOAD_READ_SEND,
{ SMB_VFS_OP_BRL_UNLOCK_WINDOWS, "brl_unlock_windows" },
{ SMB_VFS_OP_BRL_CANCEL_WINDOWS, "brl_cancel_windows" },
{ SMB_VFS_OP_STRICT_LOCK, "strict_lock" },
- { SMB_VFS_OP_STRICT_UNLOCK, "strict_unlock" },
{ SMB_VFS_OP_TRANSLATE_NAME, "translate_name" },
{ SMB_VFS_OP_FSCTL, "fsctl" },
{ SMB_VFS_OP_OFFLOAD_READ_SEND, "offload_read_send" },
return result;
}
-static void smb_full_audit_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-{
- SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock);
-
- do_log(SMB_VFS_OP_STRICT_UNLOCK, true, handle,
- "%s:%llu-%llu:%d", fsp_str_do_log(fsp), plock->start,
- plock->size, plock->lock_type);
-}
-
static NTSTATUS smb_full_audit_translate_name(struct vfs_handle_struct *handle,
const char *name,
enum vfs_translate_direction direction,
.brl_unlock_windows_fn = smb_full_audit_brl_unlock_windows,
.brl_cancel_windows_fn = smb_full_audit_brl_cancel_windows,
.strict_lock_fn = smb_full_audit_strict_lock,
- .strict_unlock_fn = smb_full_audit_strict_unlock,
.translate_name_fn = smb_full_audit_translate_name,
.fsctl_fn = smb_full_audit_fsctl,
.get_dos_attributes_fn = smb_full_audit_get_dos_attributes,
.brl_unlock_windows_fn = NULL,
.brl_cancel_windows_fn = NULL,
.strict_lock_fn = NULL,
- .strict_unlock_fn = NULL,
.translate_name_fn = NULL,
.fsctl_fn = NULL,
return result;
}
-static void smb_time_audit_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-{
- struct timespec ts1,ts2;
- double timediff;
-
- clock_gettime_mono(&ts1);
- SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock);
- clock_gettime_mono(&ts2);
- timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
-
- if (timediff > audit_timeout) {
- smb_time_audit_log_fsp("strict_unlock", timediff, fsp);
- }
-}
-
static NTSTATUS smb_time_audit_translate_name(struct vfs_handle_struct *handle,
const char *name,
enum vfs_translate_direction direction,
.brl_unlock_windows_fn = smb_time_audit_brl_unlock_windows,
.brl_cancel_windows_fn = smb_time_audit_brl_cancel_windows,
.strict_lock_fn = smb_time_audit_strict_lock,
- .strict_unlock_fn = smb_time_audit_strict_unlock,
.translate_name_fn = smb_time_audit_translate_name,
.fsctl_fn = smb_time_audit_fsctl,
.get_dos_attributes_fn = smb_time_get_dos_attributes,
if (req == NULL) {
DEBUG(0,("schedule_aio_read_and_X: aio_read failed. "
"Error %s\n", strerror(errno) ));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
if (!aio_add_req_to_fsp(fsp, req)) {
DEBUG(1, ("Could not add req to fsp\n"));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
return;
}
- /* Unlock now we're done. */
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &aio_ex->lock);
-
if (nread < 0) {
DEBUG( 3, ("handle_aio_read_complete: file %s nread == %d. "
"Error = %s\n", fsp_str_dbg(fsp), (int)nread,
if (req == NULL) {
DEBUG(3,("schedule_aio_wrote_and_X: aio_write failed. "
"Error %s\n", strerror(errno) ));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
if (!aio_add_req_to_fsp(fsp, req)) {
DEBUG(1, ("Could not add req to fsp\n"));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
return;
}
- /* Unlock now we're done. */
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &aio_ex->lock);
-
mark_file_modified(fsp);
if (fsp->aio_write_behind) {
if (req == NULL) {
DEBUG(0, ("smb2: SMB_VFS_PREAD_SEND failed. "
"Error %s\n", strerror(errno)));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
if (!aio_add_req_to_fsp(fsp, req)) {
DEBUG(1, ("Could not add req to fsp\n"));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
return;
}
- /* Unlock now we're done. */
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &aio_ex->lock);
-
/* Common error or success code processing for async or sync
read returns. */
if (req == NULL) {
DEBUG(3, ("smb2: SMB_VFS_PWRITE_SEND failed. "
"Error %s\n", strerror(errno)));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
if (!aio_add_req_to_fsp(fsp, req)) {
DEBUG(1, ("Could not add req to fsp\n"));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
TALLOC_FREE(aio_ex);
return NT_STATUS_RETRY;
}
return;
}
- /* Unlock now we're done. */
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &aio_ex->lock);
-
mark_file_modified(fsp);
status = smb2_write_complete_nosync(subreq, nwritten, err);
DEBUG(5,("reply_readbraw finished\n"));
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
-
END_PROFILE(SMBreadbraw);
return;
}
if (nread < 0) {
reply_nterror(req, map_nt_error_from_unix(errno));
- goto strict_unlock;
+ goto out;
}
srv_set_message((char *)req->outbuf, 5, nread+3, False);
DEBUG(3, ("read %s num=%d nread=%d\n",
fsp_fnum_dbg(fsp), (int)numtoread, (int)nread));
-strict_unlock:
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
-
+out:
END_PROFILE(SMBread);
return;
}
if(fsp_stat(fsp) == -1) {
reply_nterror(req, map_nt_error_from_unix(errno));
- goto strict_unlock;
+ goto out;
}
if (!S_ISREG(fsp->fsp_name->st.st_ex_mode) ||
DEBUG(3, ("send_file_readX: fake_sendfile %s max=%d nread=%d\n",
fsp_fnum_dbg(fsp), (int)smb_maxcnt, (int)nread));
/* No outbuf here means successful sendfile. */
- goto strict_unlock;
+ goto out;
}
DEBUG(0,("send_file_readX: sendfile failed for file "
/* No outbuf here means successful sendfile. */
SMB_PERFCOUNT_SET_MSGLEN_OUT(&req->pcd, nread);
SMB_PERFCOUNT_END(&req->pcd);
- goto strict_unlock;
+ goto out;
}
normal_read:
errno = saved_errno;
exit_server_cleanly("send_file_readX: fake_sendfile failed");
}
- goto strict_unlock;
+ goto out;
}
nosendfile_read:
startpos, smb_maxcnt);
saved_errno = errno;
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
-
if (nread < 0) {
reply_nterror(req, map_nt_error_from_unix(saved_errno));
return;
fsp_fnum_dbg(fsp), (int)smb_maxcnt, (int)nread));
return;
- strict_unlock:
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+out:
TALLOC_FREE(req->outbuf);
return;
}
if (nwritten < (ssize_t)numtowrite) {
reply_nterror(req, NT_STATUS_DISK_FULL);
error_to_writebrawerr(req);
- goto strict_unlock;
+ goto out;
}
total_written = nwritten;
if (!buf) {
reply_nterror(req, NT_STATUS_NO_MEMORY);
error_to_writebrawerr(req);
- goto strict_unlock;
+ goto out;
}
/* Return a SMBwritebraw message to the redirector to tell
TALLOC_FREE(buf);
reply_nterror(req, map_nt_error_from_unix(errno));
error_to_writebrawerr(req);
- goto strict_unlock;
+ goto out;
}
if (nwritten < (ssize_t)numtowrite) {
fsp_str_dbg(fsp), nt_errstr(status)));
reply_nterror(req, status);
error_to_writebrawerr(req);
- goto strict_unlock;
+ goto out;
}
DEBUG(3,("reply_writebraw: secondart write %s start=%.0f num=%d "
fsp_fnum_dbg(fsp), (double)startpos, (int)numtowrite,
(int)total_written));
- if (!fsp->print_file) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
- }
-
/* We won't return a status if write through is not selected - this
* follows what WfWg does */
END_PROFILE(SMBwritebraw);
}
return;
-strict_unlock:
- if (!fsp->print_file) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
- }
-
+out:
END_PROFILE(SMBwritebraw);
return;
}
DEBUG(5,("reply_writeunlock: sync_file for %s returned %s\n",
fsp_str_dbg(fsp), nt_errstr(status)));
reply_nterror(req, status);
- goto strict_unlock;
+ goto out;
}
if(nwritten < 0) {
reply_nterror(req, map_nt_error_from_unix(saved_errno));
- goto strict_unlock;
+ goto out;
}
if((nwritten < numtowrite) && (numtowrite != 0)) {
reply_nterror(req, NT_STATUS_DISK_FULL);
- goto strict_unlock;
+ goto out;
}
if (numtowrite && !fsp->print_file) {
if (NT_STATUS_V(status)) {
reply_nterror(req, status);
- goto strict_unlock;
+ goto out;
}
}
DEBUG(3, ("writeunlock %s num=%d wrote=%d\n",
fsp_fnum_dbg(fsp), (int)numtowrite, (int)nwritten));
-strict_unlock:
- if (numtowrite && !fsp->print_file) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
- }
-
+out:
END_PROFILE(SMBwriteunlock);
return;
}
nwritten = vfs_allocate_file_space(fsp, (off_t)startpos);
if (nwritten < 0) {
reply_nterror(req, NT_STATUS_DISK_FULL);
- goto strict_unlock;
+ goto out;
}
nwritten = vfs_set_filelen(fsp, (off_t)startpos);
if (nwritten < 0) {
reply_nterror(req, NT_STATUS_DISK_FULL);
- goto strict_unlock;
+ goto out;
}
trigger_write_time_update_immediate(fsp);
} else {
DEBUG(5,("reply_write: sync_file for %s returned %s\n",
fsp_str_dbg(fsp), nt_errstr(status)));
reply_nterror(req, status);
- goto strict_unlock;
+ goto out;
}
if(nwritten < 0) {
reply_nterror(req, map_nt_error_from_unix(saved_errno));
- goto strict_unlock;
+ goto out;
}
if((nwritten == 0) && (numtowrite != 0)) {
reply_nterror(req, NT_STATUS_DISK_FULL);
- goto strict_unlock;
+ goto out;
}
reply_outbuf(req, 1, 0);
DEBUG(3, ("write %s num=%d wrote=%d\n", fsp_fnum_dbg(fsp), (int)numtowrite, (int)nwritten));
-strict_unlock:
- if (!fsp->print_file) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
- }
-
+out:
END_PROFILE(SMBwrite);
return;
}
nwritten = write_file(req,fsp,data,startpos,numtowrite);
saved_errno = errno;
-
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
}
if(nwritten < 0) {
nwritten = write_file(req,fsp,data,startpos,numtowrite);
- if (fsp->print_file == NULL) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
- }
-
set_close_write_time(fsp, mtime);
/*
status = map_nt_error_from_unix_common(errno);
DEBUG(2, ("zero-data fallocate(0x%x) failed: %s\n", mode,
strerror(errno)));
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &lck);
return status;
}
if (ret == -1) {
status = map_nt_error_from_unix_common(errno);
DEBUG(0, ("fallocate failed: %s\n", strerror(errno)));
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &lck);
return status;
}
}
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &lck);
return NT_STATUS_OK;
}
READ_LOCK,
&lock);
- SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &lock);
-
*pstatus = NT_STATUS_OK;
return 0;
}
return tevent_req_post(req, ev);
} else {
if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
tevent_req_nterror(req, status);
return tevent_req_post(req, ev);
}
/* Ok, read into memory. Allocate the out buffer. */
state->out_data = data_blob_talloc(state, NULL, in_length);
if (in_length > 0 && tevent_req_nomem(state->out_data.data, req)) {
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
return tevent_req_post(req, ev);
}
saved_errno = errno;
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
-
DEBUG(10,("smbd_smb2_read: file %s, %s, offset=%llu "
"len=%llu returned %lld\n",
fsp_str_dbg(fsp),
status = smb2_write_complete(req, nwritten, errno);
- SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
-
DEBUG(10,("smb2: write on "
"file %s, offset %.0f, requested %u, written = %u\n",
fsp_str_dbg(fsp),
return handle->fns->strict_lock_fn(handle, fsp, plock);
}
-void smb_vfs_call_strict_unlock(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- struct lock_struct *plock)
-{
- VFS_FIND(strict_unlock);
- handle->fns->strict_unlock_fn(handle, fsp, plock);
-}
-
NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle,
const char *name,
enum vfs_translate_direction direction,
git.samba.org / metze / samba / wip.git / commitdiff