diff options
Diffstat (limited to 'source3/modules/onefs_cbrl.c')
| -rw-r--r-- | source3/modules/onefs_cbrl.c | 593 |
1 files changed, 0 insertions, 593 deletions
diff --git a/source3/modules/onefs_cbrl.c b/source3/modules/onefs_cbrl.c deleted file mode 100644 index 2f20d04ddb..0000000000 --- a/source3/modules/onefs_cbrl.c +++ /dev/null @@ -1,593 +0,0 @@ -/* - * Unix SMB/CIFS implementation. - * Support for OneFS system interfaces. - * - * Copyright (C) Zack Kirsch, 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 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 "smbd/smbd.h" -#include "onefs.h" - -#include <ifs/ifs_syscalls.h> -#include <sys/isi_cifs_brl.h> -#include <isi_ecs/isi_ecs_cbrl.h> - -#undef DBGC_CLASS -#define DBGC_CLASS DBGC_LOCKING - -static uint64_t onefs_get_new_id(void) { - static uint64_t id = 0; - - id++; - - return id; -} - -enum onefs_cbrl_lock_state {ONEFS_CBRL_NONE, ONEFS_CBRL_ASYNC, ONEFS_CBRL_DONE, - ONEFS_CBRL_ERROR}; - -struct onefs_cbrl_blr_state { - uint64_t id; - enum onefs_cbrl_lock_state state; -}; - -static char *onefs_cbrl_blr_state_str(const struct blocking_lock_record *blr) -{ - static fstring result; - struct onefs_cbrl_blr_state *bs; - - SMB_ASSERT(blr); - - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - - if (bs == NULL) { - fstrcpy(result, "NULL CBRL BLR state - Posix lock?"); - return result; - } - - switch (bs->state) { - case ONEFS_CBRL_NONE: - fstr_sprintf(result, "CBRL BLR id=%llu: state=NONE", bs->id); - break; - case ONEFS_CBRL_ASYNC: - fstr_sprintf(result, "CBRL BLR id=%llu: state=ASYNC", bs->id); - break; - case ONEFS_CBRL_DONE: - fstr_sprintf(result, "CBRL BLR id=%llu: state=DONE", bs->id); - break; - case ONEFS_CBRL_ERROR: - fstr_sprintf(result, "CBRL BLR id=%llu: state=ERROR", bs->id); - break; - default: - fstr_sprintf(result, "CBRL BLR id=%llu: unknown state %d", - bs->id, bs->state); - break; - } - - return result; -} - -static void onefs_cbrl_enumerate_blq(const char *fn) -{ - struct smbd_server_connection *sconn = smbd_server_conn; - struct blocking_lock_record *blr; - - if (DEBUGLVL(10)) - return; - - DEBUG(10, ("CBRL BLR records (%s):\n", fn)); - - if (sconn->using_smb2) { - struct smbd_smb2_request *smb2req; - for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) { - blr = get_pending_smb2req_blr(smb2req); - if (blr) { - DEBUGADD(10, ("%s\n", onefs_cbrl_blr_state_str(blr))); - } - } - } else { - for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) - DEBUGADD(10, ("%s\n", onefs_cbrl_blr_state_str(blr))); - } -} - -static struct blocking_lock_record *onefs_cbrl_find_blr(uint64_t id) -{ - struct smbd_server_connection *sconn = smbd_server_conn; - struct blocking_lock_record *blr; - struct onefs_cbrl_blr_state *bs; - - onefs_cbrl_enumerate_blq("onefs_cbrl_find_blr"); - - if (sconn->using_smb2) { - struct smbd_smb2_request *smb2req; - for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) { - blr = get_pending_smb2req_blr(smb2req); - if (!blr) { - continue; - } - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - if (bs == NULL) { - continue; - } - if (bs->id == id) { - DEBUG(10, ("found %s\n", - onefs_cbrl_blr_state_str(blr))); - break; - } - } - } else { - for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) { - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - - /* We don't control all of the BLRs on the BLQ. */ - if (bs == NULL) - continue; - - if (bs->id == id) { - DEBUG(10, ("found %s\n", - onefs_cbrl_blr_state_str(blr))); - break; - } - } - } - - if (blr == NULL) { - DEBUG(5, ("Could not find CBRL BLR for id %llu\n", id)); - return NULL; - } - - return blr; -} - -static void onefs_cbrl_async_success(uint64_t id) -{ - struct blocking_lock_record *blr; - struct onefs_cbrl_blr_state *bs; - uint16 num_locks; - - DEBUG(10, ("CBRL async success!\n")); - - /* Find BLR with id. Its okay not to find one (race with cancel) */ - blr = onefs_cbrl_find_blr(id); - if (blr == NULL) - return; - - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - SMB_ASSERT(bs); - SMB_ASSERT(bs->state == ONEFS_CBRL_ASYNC); - - blr->lock_num++; - - num_locks = SVAL(blr->req->vwv+7, 0); - - if (blr->lock_num == num_locks) - bs->state = ONEFS_CBRL_DONE; - else - bs->state = ONEFS_CBRL_NONE; - - /* Self contend our own level 2 oplock. The kernel handles - * contention of other opener's level 2 oplocks. */ - contend_level2_oplocks_begin(blr->fsp, - LEVEL2_CONTEND_WINDOWS_BRL); - - /* Process the queue, to try the next lock or finish up. */ - process_blocking_lock_queue(smbd_server_conn); -} - -static void onefs_cbrl_async_failure(uint64_t id) -{ - struct blocking_lock_record *blr; - struct onefs_cbrl_blr_state *bs; - - DEBUG(10, ("CBRL async failure!\n")); - - /* Find BLR with id. Its okay not to find one (race with cancel) */ - blr = onefs_cbrl_find_blr(id); - if (blr == NULL) - return; - - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - SMB_ASSERT(bs); - - SMB_ASSERT(bs->state == ONEFS_CBRL_ASYNC); - bs->state = ONEFS_CBRL_ERROR; - - /* Process the queue. It will end up trying to retake the same lock, - * see the error in onefs_cbrl_lock_windows() and fail. */ - process_blocking_lock_queue(smbd_server_conn); -} - -static struct cbrl_event_ops cbrl_ops = - {.cbrl_async_success = onefs_cbrl_async_success, - .cbrl_async_failure = onefs_cbrl_async_failure}; - -static void onefs_cbrl_events_handler(struct event_context *ev, - struct fd_event *fde, - uint16_t flags, - void *private_data) -{ - DEBUG(10, ("onefs_cbrl_events_handler\n")); - - if (cbrl_event_dispatcher(&cbrl_ops)) { - DEBUG(0, ("cbrl_event_dispatcher failed: %s\n", - strerror(errno))); - } -} - -static void onefs_init_cbrl(void) -{ - static bool init_done = false; - static int cbrl_event_fd; - static struct fd_event *cbrl_fde; - - if (init_done) - return; - - DEBUG(10, ("onefs_init_cbrl\n")); - - /* Register the event channel for CBRL. */ - cbrl_event_fd = cbrl_event_register(); - if (cbrl_event_fd == -1) { - DEBUG(0, ("cbrl_event_register failed: %s\n", - strerror(errno))); - return; - } - - DEBUG(10, ("cbrl_event_fd = %d\n", cbrl_event_fd)); - - /* Register the CBRL event_fd with samba's event system */ - cbrl_fde = event_add_fd(server_event_context(), - NULL, - cbrl_event_fd, - EVENT_FD_READ, - onefs_cbrl_events_handler, - NULL); - - init_done = true; - return; -} - -/** - * Blocking PID. As far as I can tell, the blocking_pid is only used to tell - * whether a posix lock or a CIFS lock blocked us. If it was a posix lock, - * Samba polls every 10 seconds, which we don't want. -zkirsch - */ -#define ONEFS_BLOCKING_PID 0xABCDABCD - -/** - * @param[in] br_lck Contains the fsp. - * @param[in] plock Lock request. - * @param[in] blocking_lock Only used for figuring out the error. - * @param[in,out] blr The BLR for the already-deferred operation. - */ -NTSTATUS onefs_brl_lock_windows(vfs_handle_struct *handle, - struct byte_range_lock *br_lck, - struct lock_struct *plock, - bool blocking_lock, - struct blocking_lock_record *blr) -{ - int fd = br_lck->fsp->fh->fd; - uint64_t id = 0; - enum cbrl_lock_type type; - bool async = false; - bool pending = false; - bool pending_async = false; - int error; - struct onefs_cbrl_blr_state *bs; - NTSTATUS status; - - START_PROFILE(syscall_brl_lock); - - SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK); - SMB_ASSERT(plock->lock_type != UNLOCK_LOCK); - - onefs_cbrl_enumerate_blq("onefs_brl_lock_windows"); - - /* Will only initialize the first time its called. */ - onefs_init_cbrl(); - - switch (plock->lock_type) { - case WRITE_LOCK: - type = CBRL_LK_EX; - break; - case READ_LOCK: - type = CBRL_LK_SH; - break; - case PENDING_WRITE_LOCK: - /* Called when a blocking lock request is added - do an - * async lock. */ - type = CBRL_LK_EX; - pending = true; - async = true; - break; - case PENDING_READ_LOCK: - /* Called when a blocking lock request is added - do an - * async lock. */ - type = CBRL_LK_SH; - pending = true; - async = true; - break; - default: - /* UNLOCK_LOCK: should only be used for a POSIX_LOCK */ - smb_panic("Invalid plock->lock_type passed in to " - "onefs_brl_lock_windows"); - } - - /* Figure out if we're actually doing the lock or a no-op. We need to - * do a no-op when process_blocking_lock_queue calls back into us. - * - * We know process_* is calling into us if a blr is passed in and - * pending is false. */ - if (!pending && blr) { - /* Check the BLR state. */ - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - SMB_ASSERT(bs); - - /* ASYNC still in progress: The process_* calls will keep - * calling even if we haven't gotten the lock. Keep erroring - * without calling ifs_cbrl, or getting/setting an id. */ - if (bs->state == ONEFS_CBRL_ASYNC) { - goto failure; - } - else if (bs->state == ONEFS_CBRL_ERROR) { - END_PROFILE(syscall_brl_lock); - return NT_STATUS_NO_MEMORY; - } - - SMB_ASSERT(bs->state == ONEFS_CBRL_NONE); - async = true; - } - - if (async) { - SMB_ASSERT(blocking_lock); - SMB_ASSERT(blr); - id = onefs_get_new_id(); - } - - DEBUG(10, ("Calling ifs_cbrl(LOCK)...\n")); - error = ifs_cbrl(fd, CBRL_OP_LOCK, type, plock->start, - plock->size, async, id, plock->context.smbpid, plock->context.tid, - plock->fnum); - if (!error) { - goto success; - } else if (errno == EWOULDBLOCK) { - SMB_ASSERT(!async); - } else if (errno == EINPROGRESS) { - SMB_ASSERT(async); - - if (pending) { - /* Talloc a new BLR private state. */ - blr->blr_private = talloc(blr, struct onefs_cbrl_blr_state); - pending_async = true; - } - - /* Store the new id in the BLR private state. */ - bs = (struct onefs_cbrl_blr_state *)blr->blr_private; - bs->id = id; - bs->state = ONEFS_CBRL_ASYNC; - } else { - DEBUG(0, ("onefs_brl_lock_windows failure: error=%d (%s).\n", - errno, strerror(errno))); - } - -failure: - - END_PROFILE(syscall_brl_lock); - - /* Failure - error or async. */ - plock->context.smbpid = (uint32) ONEFS_BLOCKING_PID; - - if (pending_async) - status = NT_STATUS_OK; - else - status = brl_lock_failed(br_lck->fsp, plock, blocking_lock); - - DEBUG(10, ("returning %s.\n", nt_errstr(status))); - return status; - -success: - /* Self contend our own level 2 oplock. The kernel handles - * contention of other opener's level 2 oplocks. */ - contend_level2_oplocks_begin(br_lck->fsp, - LEVEL2_CONTEND_WINDOWS_BRL); - - END_PROFILE(syscall_brl_lock); - - /* Success. */ - onefs_cbrl_enumerate_blq("onefs_brl_unlock_windows"); - DEBUG(10, ("returning NT_STATUS_OK.\n")); - return NT_STATUS_OK; -} - -bool onefs_brl_unlock_windows(vfs_handle_struct *handle, - struct messaging_context *msg_ctx, - struct byte_range_lock *br_lck, - const struct lock_struct *plock) -{ - int error; - int fd = br_lck->fsp->fh->fd; - - START_PROFILE(syscall_brl_unlock); - - SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK); - SMB_ASSERT(plock->lock_type == UNLOCK_LOCK); - - DEBUG(10, ("Calling ifs_cbrl(UNLOCK)...\n")); - error = ifs_cbrl(fd, CBRL_OP_UNLOCK, CBRL_LK_SH, - plock->start, plock->size, false, 0, plock->context.smbpid, - plock->context.tid, plock->fnum); - - END_PROFILE(syscall_brl_unlock); - - if (error) { - DEBUG(10, ("returning false.\n")); - return false; - } - - /* For symmetry purposes, end our oplock contention even though its - * currently a no-op. */ - contend_level2_oplocks_end(br_lck->fsp, LEVEL2_CONTEND_WINDOWS_BRL); - - DEBUG(10, ("returning true.\n")); - return true; - - /* Problem with storing things in TDB: I won't know what BRL to unlock in the TDB. - * - I could fake it? - * - I could send Samba a message with which lock is being unlocked? - * - I could *easily* make the "id" something you always pass in to - * lock, unlock or cancel -- it identifies a lock. Makes sense! - */ -} - -/* Default implementation only calls this on PENDING locks. */ -bool onefs_brl_cancel_windows(vfs_handle_struct *handle, - struct byte_range_lock *br_lck, - struct lock_struct *plock, - struct blocking_lock_record *blr) -{ - int error; - int fd = br_lck->fsp->fh->fd; - struct onefs_cbrl_blr_state *bs; - - START_PROFILE(syscall_brl_cancel); - - SMB_ASSERT(plock); - SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK); - SMB_ASSERT(blr); - - onefs_cbrl_enumerate_blq("onefs_brl_cancel_windows"); - - bs = ((struct onefs_cbrl_blr_state *)blr->blr_private); - SMB_ASSERT(bs); - - if (bs->state == ONEFS_CBRL_DONE || bs->state == ONEFS_CBRL_ERROR) { - /* No-op. */ - DEBUG(10, ("State=%d, returning true\n", bs->state)); - END_PROFILE(syscall_brl_cancel); - return true; - } - - SMB_ASSERT(bs->state == ONEFS_CBRL_NONE || - bs->state == ONEFS_CBRL_ASYNC); - - /* A real cancel. */ - DEBUG(10, ("Calling ifs_cbrl(CANCEL)...\n")); - error = ifs_cbrl(fd, CBRL_OP_CANCEL, CBRL_LK_UNSPEC, plock->start, - plock->size, false, bs->id, plock->context.smbpid, - plock->context.tid, plock->fnum); - - END_PROFILE(syscall_brl_cancel); - - if (error) { - DEBUG(10, ("returning false\n")); - bs->state = ONEFS_CBRL_ERROR; - return false; - } - - bs->state = ONEFS_CBRL_DONE; - onefs_cbrl_enumerate_blq("onefs_brl_cancel_windows"); - DEBUG(10, ("returning true\n")); - return true; -} - -bool onefs_strict_lock(vfs_handle_struct *handle, - files_struct *fsp, - struct lock_struct *plock) -{ - int error; - - START_PROFILE(syscall_strict_lock); - - SMB_ASSERT(plock->lock_type == READ_LOCK || - plock->lock_type == WRITE_LOCK); - - if (!lp_locking(handle->conn->params) || - !lp_strict_locking(handle->conn->params)) { - END_PROFILE(syscall_strict_lock); - return True; - } - - if (plock->lock_flav == POSIX_LOCK) { - END_PROFILE(syscall_strict_lock); - return SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock); - } - - if (plock->size == 0) { - END_PROFILE(syscall_strict_lock); - return True; - } - - error = ifs_cbrl(fsp->fh->fd, CBRL_OP_LOCK, - plock->lock_type == READ_LOCK ? CBRL_LK_RD : CBRL_LK_WR, - plock->start, plock->size, 0, 0, plock->context.smbpid, - plock->context.tid, plock->fnum); - - END_PROFILE(syscall_strict_lock); - - return (error == 0); -} - -void onefs_strict_unlock(vfs_handle_struct *handle, - files_struct *fsp, - struct lock_struct *plock) -{ - START_PROFILE(syscall_strict_unlock); - - SMB_ASSERT(plock->lock_type == READ_LOCK || - plock->lock_type == WRITE_LOCK); - - if (!lp_locking(handle->conn->params) || - !lp_strict_locking(handle->conn->params)) { - END_PROFILE(syscall_strict_unlock); - return; - } - - if (plock->lock_flav == POSIX_LOCK) { - SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock); - END_PROFILE(syscall_strict_unlock); - return; - } - - if (plock->size == 0) { - END_PROFILE(syscall_strict_unlock); - return; - } - - if (fsp->fh) { - ifs_cbrl(fsp->fh->fd, CBRL_OP_UNLOCK, - plock->lock_type == READ_LOCK ? CBRL_LK_RD : CBRL_LK_WR, - plock->start, plock->size, 0, 0, plock->context.smbpid, - plock->context.tid, plock->fnum); - } - - END_PROFILE(syscall_strict_unlock); -} - -/* TODO Optimization: Abstract out brl_get_locks() in the Windows case. - * We'll malloc some memory or whatever (can't return NULL), but not actually - * touch the TDB. */ - -/* XXX brl_locktest: CBRL does not support calling this, but its only for - * strict locking. Add empty VOP? */ - -/* XXX brl_lockquery: CBRL does not support calling this for WINDOWS LOCKS, but - * its only called for POSIX LOCKS. Add empty VOP? */ - -/* XXX brl_close_fnum: CBRL will do this automatically. I think this is a NO-OP - * for us, we could add an empty VOP. */ - |