1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-22 13:34:15 +03:00
samba-mirror/source4/ntvfs/posix/pvfs_oplock.c
Volker Lendecke 3084928383 messaging4: Pass fds to messaging handlers
Boiler-plate replacement moving the (num_fds!=0) check down

Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>
2019-09-18 20:10:24 +00:00

308 lines
7.5 KiB
C

/*
Unix SMB/CIFS implementation.
POSIX NTVFS backend - oplock handling
Copyright (C) Stefan Metzmacher 2008
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 <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "lib/messaging/messaging.h"
#include "lib/messaging/irpc.h"
#include "system/time.h"
#include "vfs_posix.h"
struct pvfs_oplock {
struct pvfs_file_handle *handle;
struct pvfs_file *file;
uint32_t level;
struct timeval break_to_level_II;
struct timeval break_to_none;
struct imessaging_context *msg_ctx;
};
static NTSTATUS pvfs_oplock_release_internal(struct pvfs_file_handle *h,
uint8_t oplock_break)
{
struct odb_lock *olck;
NTSTATUS status;
if (h->fd == -1) {
return NT_STATUS_FILE_IS_A_DIRECTORY;
}
if (!h->have_opendb_entry) {
return NT_STATUS_FOOBAR;
}
if (!h->oplock) {
return NT_STATUS_FOOBAR;
}
olck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
if (olck == NULL) {
DEBUG(0,("Unable to lock opendb for oplock update\n"));
return NT_STATUS_FOOBAR;
}
if (oplock_break == OPLOCK_BREAK_TO_NONE) {
h->oplock->level = OPLOCK_NONE;
} else if (oplock_break == OPLOCK_BREAK_TO_LEVEL_II) {
h->oplock->level = OPLOCK_LEVEL_II;
} else {
/* fallback to level II in case of a invalid value */
DEBUG(1,("unexpected oplock break level[0x%02X]\n", oplock_break));
h->oplock->level = OPLOCK_LEVEL_II;
}
status = odb_update_oplock(olck, h, h->oplock->level);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Unable to update oplock level for '%s' - %s\n",
h->name->full_name, nt_errstr(status)));
talloc_free(olck);
return status;
}
talloc_free(olck);
/* after a break to none, we no longer have an oplock attached */
if (h->oplock->level == OPLOCK_NONE) {
talloc_free(h->oplock);
h->oplock = NULL;
}
return NT_STATUS_OK;
}
/*
receive oplock breaks and forward them to the client
*/
static void pvfs_oplock_break(struct pvfs_oplock *opl, uint8_t level)
{
NTSTATUS status;
struct pvfs_file *f = opl->file;
struct pvfs_file_handle *h = opl->handle;
struct pvfs_state *pvfs = h->pvfs;
struct timeval cur = timeval_current();
struct timeval *last = NULL;
struct timeval end;
switch (level) {
case OPLOCK_BREAK_TO_LEVEL_II:
last = &opl->break_to_level_II;
break;
case OPLOCK_BREAK_TO_NONE:
last = &opl->break_to_none;
break;
}
if (!last) {
DEBUG(0,("%s: got unexpected level[0x%02X]\n",
__FUNCTION__, level));
return;
}
if (timeval_is_zero(last)) {
/*
* this is the first break we for this level
* remember the time
*/
*last = cur;
DEBUG(5,("%s: sending oplock break level %d for '%s' %p\n",
__FUNCTION__, level, h->name->original_name, h));
status = ntvfs_send_oplock_break(pvfs->ntvfs, f->ntvfs, level);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("%s: sending oplock break failed: %s\n",
__FUNCTION__, nt_errstr(status)));
}
return;
}
end = timeval_add(last, pvfs->oplock_break_timeout, 0);
if (timeval_compare(&cur, &end) < 0) {
/*
* If it's not expired just ignore the break
* as we already sent the break request to the client
*/
DEBUG(0,("%s: do not resend oplock break level %d for '%s' %p\n",
__FUNCTION__, level, h->name->original_name, h));
return;
}
/*
* If the client did not send a release within the
* oplock break timeout time frame we auto release
* the oplock
*/
DEBUG(0,("%s: auto release oplock level %d for '%s' %p\n",
__FUNCTION__, level, h->name->original_name, h));
status = pvfs_oplock_release_internal(h, level);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("%s: failed to auto release the oplock[0x%02X]: %s\n",
__FUNCTION__, level, nt_errstr(status)));
}
}
static void pvfs_oplock_break_dispatch(struct imessaging_context *msg,
void *private_data,
uint32_t msg_type,
struct server_id src,
size_t num_fds,
int *fds,
DATA_BLOB *data)
{
struct pvfs_oplock *opl = talloc_get_type(private_data,
struct pvfs_oplock);
struct opendb_oplock_break opb;
if (num_fds != 0) {
DBG_WARNING("Received %zu fds, ignoring message\n", num_fds);
return;
}
ZERO_STRUCT(opb);
/* we need to check that this one is for us. See
imessaging_send_ptr() for the other side of this.
*/
if (data->length == sizeof(struct opendb_oplock_break)) {
struct opendb_oplock_break *p;
p = (struct opendb_oplock_break *)data->data;
opb = *p;
} else {
DEBUG(0,("%s: ignore oplock break with length[%u]\n",
__location__, (unsigned)data->length));
return;
}
if (opb.file_handle != opl->handle) {
return;
}
/*
* maybe we should use ntvfs_setup_async()
*/
pvfs_oplock_break(opl, opb.level);
}
static int pvfs_oplock_destructor(struct pvfs_oplock *opl)
{
imessaging_deregister(opl->msg_ctx, MSG_NTVFS_OPLOCK_BREAK, opl);
return 0;
}
NTSTATUS pvfs_setup_oplock(struct pvfs_file *f, uint32_t oplock_granted)
{
NTSTATUS status;
struct pvfs_oplock *opl;
uint32_t level = OPLOCK_NONE;
f->handle->oplock = NULL;
switch (oplock_granted) {
case EXCLUSIVE_OPLOCK_RETURN:
level = OPLOCK_EXCLUSIVE;
break;
case BATCH_OPLOCK_RETURN:
level = OPLOCK_BATCH;
break;
case LEVEL_II_OPLOCK_RETURN:
level = OPLOCK_LEVEL_II;
break;
}
if (level == OPLOCK_NONE) {
return NT_STATUS_OK;
}
opl = talloc_zero(f->handle, struct pvfs_oplock);
NT_STATUS_HAVE_NO_MEMORY(opl);
opl->handle = f->handle;
opl->file = f;
opl->level = level;
opl->msg_ctx = f->pvfs->ntvfs->ctx->msg_ctx;
status = imessaging_register(opl->msg_ctx,
opl,
MSG_NTVFS_OPLOCK_BREAK,
pvfs_oplock_break_dispatch);
NT_STATUS_NOT_OK_RETURN(status);
/* destructor */
talloc_set_destructor(opl, pvfs_oplock_destructor);
f->handle->oplock = opl;
return NT_STATUS_OK;
}
NTSTATUS pvfs_oplock_release(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req, union smb_lock *lck)
{
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
struct pvfs_file *f;
uint8_t oplock_break;
NTSTATUS status;
f = pvfs_find_fd(pvfs, req, lck->lockx.in.file.ntvfs);
if (!f) {
return NT_STATUS_INVALID_HANDLE;
}
oplock_break = (lck->lockx.in.mode >> 8) & 0xFF;
status = pvfs_oplock_release_internal(f->handle, oplock_break);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("%s: failed to release the oplock[0x%02X]: %s\n",
__FUNCTION__, oplock_break, nt_errstr(status)));
return status;
}
return NT_STATUS_OK;
}
NTSTATUS pvfs_break_level2_oplocks(struct pvfs_file *f)
{
struct pvfs_file_handle *h = f->handle;
struct odb_lock *olck;
NTSTATUS status;
if (h->oplock && h->oplock->level != OPLOCK_LEVEL_II) {
return NT_STATUS_OK;
}
olck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
if (olck == NULL) {
DEBUG(0,("Unable to lock opendb for oplock update\n"));
return NT_STATUS_FOOBAR;
}
status = odb_break_oplocks(olck);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Unable to break level2 oplocks to none for '%s' - %s\n",
h->name->full_name, nt_errstr(status)));
talloc_free(olck);
return status;
}
talloc_free(olck);
return NT_STATUS_OK;
}