s3:onefs: remove all onefs related code as it not maintained anymore

See https://lists.samba.org/archive/samba-technical/2012-May/083631.html
for the discussion.

metze

Autobuild-User: Stefan Metzmacher <metze@samba.org>
Autobuild-Date: Wed May 16 11:23:05 CEST 2012 on sn-devel-104

3 files changed, 0 insertions, 740 deletions

diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index 173c53e2ec..e3f00a70ec 100644
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -991,9 +991,6 @@ void init_kernel_oplocks(struct smbd_server_connection *sconn)
 		koplocks = irix_init_kernel_oplocks(sconn);
 #elif HAVE_KERNEL_OPLOCKS_LINUX
 		koplocks = linux_init_kernel_oplocks(sconn);
-#elif HAVE_ONEFS
-#error Isilon, please check if the NULL context is okay here. Thanks!
-		koplocks = onefs_init_kernel_oplocks(sconn);
 #endif
 	}
 }
diff --git a/source3/smbd/oplock_onefs.c b/source3/smbd/oplock_onefs.c
deleted file mode 100644
index 615747e92c..0000000000
--- a/source3/smbd/oplock_onefs.c
+++ /dev/null
@@ -1,733 +0,0 @@
-/*
- * Unix SMB/CIFS implementation.
- * Support for OneFS kernel oplocks
- *
- * Copyright (C) Volker Lendecke 2007
- * 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 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/>.
- */
-
-#define DBGC_CLASS DBGC_LOCKING
-
-#include "includes.h"
-
-#if HAVE_ONEFS
-#include "oplock_onefs.h"
-#include "smbd/smbd.h"
-#include "smbd/globals.h"
-
-#include <ifs/ifs_syscalls.h>
-#include <isi_ecs/isi_ecs_oplocks.h>
-#include <sys/proc.h>
-
-struct onefs_oplocks_context {
-	struct kernel_oplocks *ctx;
-	struct smbd_server_connection *sconn;
-	const struct oplocks_event_ops *onefs_ops;
-	int onefs_event_fd;
-	struct fd_event *read_fde;
-};
-
-enum onefs_callback_state {
-	ONEFS_OPEN_FILE,
-	ONEFS_WAITING_FOR_OPLOCK
-};
-
-struct onefs_callback_record {
-	struct onefs_callback_record *prev, *next;
-	struct smbd_server_connection *sconn;
-	uint64_t id;
-	enum onefs_callback_state state;
-	union {
-		files_struct *fsp;	/* ONEFS_OPEN_FILE */
-		uint64_t mid;		/* ONEFS_WAITING_FOR_OPLOCK */
-	} data;
-};
-
-/**
- * Internal list of files (along with additional state) that have outstanding
- * oplocks or requests for oplocks.
- */
-struct onefs_callback_record *callback_recs;
-
-/**
- * Convert a onefs_callback_record to a debug string using the dbg_ctx().
- */
-const char *onefs_cb_record_str_dbg(const struct onefs_callback_record *r)
-{
-	char *result;
-
-	if (r == NULL) {
-		result = talloc_strdup(talloc_tos(), "NULL callback record");
-		return result;
-	}
-
-	switch (r->state) {
-	case ONEFS_OPEN_FILE:
-		result = talloc_asprintf(talloc_tos(), "cb record %llu for "
-					 "file %s", r->id,
-					 fsp_str_dbg(r->data.fsp));
-	case ONEFS_WAITING_FOR_OPLOCK:
-		result = talloc_asprintf(talloc_tos(), "cb record %llu for "
-					 "pending mid %llu", r->id,
-					 (unsigned long long)r->data.mid);
-		break;
-	default:
-		result = talloc_asprintf(talloc_tos(), "cb record %llu unknown "
-					 "state %d", r->id, r->state);
-		break;
-	}
-
-	return result;
-}
-
-/**
- * Traverse the list of onefs_callback_records and print all entries.
- */
-static void debug_cb_records(const char *fn)
-{
-	struct onefs_callback_record *rec;
-
-	if (DEBUGLEVEL < 10)
-		return;
-
-	DEBUG(10, ("cb records (%s):\n", fn));
-
-	for (rec = callback_recs; rec; rec = rec->next) {
-		DEBUGADD(10, ("%s\n", onefs_cb_record_str_dbg(rec)));
-	}
-}
-
-/**
- * Find a callback record in the list of outstanding oplock operations.
- *
- * Once n ifs_createfile requests an oplock on a file, the kernel communicates
- * with samba via the oplock event channel by sending events that reference an
- * id.  This function maps that id to the onefs_callback_record that was
- * created for it during the initial setup on open (onefs_oplock_wait_record).
- * When a matching id is found in the onefs_callback_record list, the
- * callback_type is checked to make sure the record is in in the correct
- * state.
- */
-static struct onefs_callback_record *onefs_find_cb(uint64_t id,
-    enum onefs_callback_state expected_state)
-{
-	struct onefs_callback_record *rec;
-
-	debug_cb_records("onefs_find_cb");
-
-	for (rec = callback_recs; rec; rec = rec->next) {
-		if (rec->id == id) {
-			DEBUG(10, ("found %s\n",
-				   onefs_cb_record_str_dbg(rec)));
-			break;
-		}
-	}
-
-	if (rec == NULL) {
-		DEBUG(5, ("Could not find callback record for id %llu\n", id));
-		return NULL;
-	}
-
-	if (rec->state != expected_state) {
-		DEBUG(0, ("Expected cb type %d, got %s", expected_state,
-			  onefs_cb_record_str_dbg(rec)));
-		SMB_ASSERT(0);
-		return NULL;
-	}
-
-	return rec;
-}
-
-/**
- * Remove and free a callback record from the callback record list.
- */
-void destroy_onefs_callback_record(uint64_t id)
-{
-	struct onefs_callback_record *rec;
-
-	debug_cb_records("destroy_onefs_callback_record");
-
-	if (id == 0) {
-		DEBUG(10, ("destroy_onefs_callback_record: Nothing to "
-			   "destroy\n"));
-		return;
-	}
-
-	for (rec = callback_recs; rec; rec = rec->next) {
-		if (rec->id == id) {
-			DLIST_REMOVE(callback_recs, rec);
-			SAFE_FREE(rec);
-			DEBUG(10, ("removed cb rec %llu\n", id));
-			return;
-		}
-	}
-
-	DEBUG(0, ("Could not find cb rec %llu to delete", id));
-	SMB_ASSERT(0);
-}
-
-/**
- * Initialize a callback record and add it to the list of outstanding callback
- * records.
- *
- * This is called in the open path before ifs_createfile so an id can be
- * passed in.  Each callback record can be in one of two states:
- *
- *   1. WAITING_FOR_OPLOCK: This is the initial state for all callback
- *   records.  If ifs_createfile can be completed syncronously without needing
- *   to break any level I oplocks, the state is transitioned to OPEN_FILE.
- *   Otherwise ifs_createfile will finish asynchronously and the open is
- *   deferred.  When the necessary level I opocks have been broken, and the
- *   open can be done, an event is sent by the kernel on the oplock event
- *   channel, which is handled by semlock_available_handler.  At this point
- *   the deferred open is retried.  Unless a level I oplock was acquired by
- *   another client, ifs_createfile will now complete synchronously.
- *
- *   2. OPEN_FILE: Once ifs_createfile completes, the callback record is
- *   transitioned to this state via onefs_set_oplock_callback.
- */
-uint64_t onefs_oplock_wait_record(struct smbd_server_connection *sconn,
-				  uint64_t mid)
-{
-	struct onefs_callback_record *result;
-	static uint64_t id_generator = 0;
-
-	if (!(result = SMB_MALLOC_P(struct onefs_callback_record))) {
-		DEBUG(0, ("talloc failed\n"));
-		return 0;
-	}
-
-	memset(result, '\0', sizeof(result));
-
-	id_generator += 1;
-	if (id_generator == 0) {
-		/* Wow, that's a long-running smbd... */
-		id_generator += 1;
-	}
-
-	result->sconn = sconn;
-	result->id = id_generator;
-
-	result->state = ONEFS_WAITING_FOR_OPLOCK;
-	result->data.mid = mid;
-	DLIST_ADD(callback_recs, result);
-
-	DEBUG(10, ("New cb rec %llu created\n", result->id));
-
-	return result->id;
-}
-
-/**
- * Transition the callback record state to OPEN_FILE.
- *
- * This is called after the file is opened and an fsp struct has been
- * allocated.  The mid is dropped in favor of storing the fsp.
- */
-void onefs_set_oplock_callback(uint64_t id, files_struct *fsp)
-{
-	struct onefs_callback_record *cb;
-	char *msg;
-
-	DEBUG(10, ("onefs_set_oplock_callback called for cb rec %llu\n", id));
-
-	if (!(cb = onefs_find_cb(id, ONEFS_WAITING_FOR_OPLOCK))) {
-		if (asprintf(&msg, "Got invalid callback %lld\n", id) != -1) {
-			smb_panic(msg);
-		}
-		smb_panic("Got invalid callback id\n");
-	}
-
-	/*
-	 * Paranoia check
-	 */
-	if (open_was_deferred(cb->data.mid)) {
-		if (asprintf(&msg, "Trying to upgrade callback for deferred "
-			     "open mid=%llu\n", (unsigned long long)cb->data.mid) != -1) {
-			smb_panic(msg);
-		}
-		smb_panic("Trying to upgrade callback for deferred open "
-			  "mid\n");
-	}
-
-	cb->state = ONEFS_OPEN_FILE;
-	cb->data.fsp = fsp;
-}
-
-/**
- * Using a callback record, initialize a share mode entry to pass to
- * share_mode_entry_to_message to send samba IPC messages.
- */
-static void init_share_mode_entry(struct share_mode_entry *sme,
-				  struct onefs_callback_record *cb,
-				  int op_type)
-{
-	ZERO_STRUCT(*sme);
-
-	sme->pid = procid_self();
-	sme->op_type = op_type;
-	sme->id = cb->data.fsp->file_id;
-	sme->share_file_id = cb->data.fsp->fh->gen_id;
-}
-
-/**
- * Callback when a break-to-none event is received from the kernel.
- *
- * On OneFS level 1 oplocks are always broken to level 2 first, therefore an
- * async level 2 break message is always sent when breaking to none.  The
- * downside of this is that OneFS currently has no way to express breaking
- * directly from level 1 to none.
- */
-static void oplock_break_to_none_handler(uint64_t id)
-{
-	struct onefs_callback_record *cb;
-	struct share_mode_entry sme;
-	char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
-
-	DEBUG(10, ("oplock_break_to_none_handler called for id %llu\n", id));
-
-	if (!(cb = onefs_find_cb(id, ONEFS_OPEN_FILE))) {
-		DEBUG(3, ("oplock_break_to_none_handler: could not find "
-			  "callback id %llu\n", id));
-		return;
-	}
-
-	DEBUG(10, ("oplock_break_to_none_handler called for file %s\n",
-		   fsp_str_dbg(cb->data.fsp)));
-
-	init_share_mode_entry(&sme, cb, FORCE_OPLOCK_BREAK_TO_NONE);
-	share_mode_entry_to_message(msg, &sme);
-	messaging_send_buf(cb->sconn->msg_ctx,
-			   sme.pid,
-			   MSG_SMB_ASYNC_LEVEL2_BREAK,
-			   (uint8_t *)msg,
-			   MSG_SMB_SHARE_MODE_ENTRY_SIZE);
-
-	/*
-	 * We could still receive an OPLOCK_REVOKED message, so keep the
-	 * oplock_callback_id around.
-	 */
-}
-
-/**
- * Callback when a break-to-level2 event is received from the kernel.
- *
- * Breaks from level 1 to level 2.
- */
-static void oplock_break_to_level_two_handler(uint64_t id)
-{
-	struct onefs_callback_record *cb;
-	struct share_mode_entry sme;
-	char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
-
-	DEBUG(10, ("oplock_break_to_level_two_handler called for id %llu\n",
-		   id));
-
-	if (!(cb = onefs_find_cb(id, ONEFS_OPEN_FILE))) {
-		DEBUG(3, ("oplock_break_to_level_two_handler: could not find "
-			  "callback id %llu\n", id));
-		return;
-	}
-
-	DEBUG(10, ("oplock_break_to_level_two_handler called for file %s\n",
-		   fsp_str_dbg(cb->data.fsp)));
-
-	init_share_mode_entry(&sme, cb, LEVEL_II_OPLOCK);
-	share_mode_entry_to_message(msg, &sme);
-	messaging_send_buf(cb->sconn->msg_ctx,
-			  sme.pid,
-			  MSG_SMB_BREAK_REQUEST,
-			  (uint8_t *)msg,
-			  MSG_SMB_SHARE_MODE_ENTRY_SIZE);
-
-	/*
-	 * We could still receive an OPLOCK_REVOKED or OPLOCK_BREAK_TO_NONE
-	 * message, so keep the oplock_callback_id around.
-	 */
-}
-
-/**
- * Revoke an oplock from an unresponsive client.
- *
- * The kernel will send this message when it times out waiting for a level 1
- * oplock break to be acknowledged by the client.  The oplock is then
- * immediately removed.
- */
-static void oplock_revoked_handler(uint64_t id)
-{
-	struct onefs_callback_record *cb;
-	files_struct *fsp = NULL;
-
-	DEBUG(10, ("oplock_revoked_handler called for id %llu\n", id));
-
-	if (!(cb = onefs_find_cb(id, ONEFS_OPEN_FILE))) {
-		DEBUG(3, ("oplock_revoked_handler: could not find "
-			  "callback id %llu\n", id));
-		return;
-	}
-
-	fsp = cb->data.fsp;
-
-	SMB_ASSERT(fsp->oplock_timeout == NULL);
-
-	DEBUG(0,("Level 1 oplock break failed for file %s. Forcefully "
-		 "revoking oplock\n", fsp_str_dbg(fsp)));
-
-	remove_oplock(fsp);
-
-	/*
-	 * cb record is cleaned up in fsp ext data destructor on close, so
-	 * leave it in the list.
-	 */
-}
-
-/**
- * Asynchronous ifs_createfile callback
- *
- * If ifs_createfile had to asynchronously break any oplocks, this function is
- * called when the kernel sends an event that the open can be retried.
- */
-static void semlock_available_handler(uint64_t id)
-{
-	struct onefs_callback_record *cb;
-
-	DEBUG(10, ("semlock_available_handler called: %llu\n", id));
-
-	if (!(cb = onefs_find_cb(id, ONEFS_WAITING_FOR_OPLOCK))) {
-		DEBUG(5, ("semlock_available_handler: Did not find callback "
-			  "%llu\n", id));
-		return;
-	}
-
-	DEBUG(10, ("Got semlock available for mid %llu\n",
-		(unsigned long long)cb->data.mid));
-
-	/* Paranoia check */
-	if (!(open_was_deferred(cb->data.mid))) {
-		char *msg;
-		if (asprintf(&msg, "Semlock available on an open that wasn't "
-			     "deferred: %s\n",
-			      onefs_cb_record_str_dbg(cb)) != -1) {
-			smb_panic(msg);
-		}
-		smb_panic("Semlock available on an open that wasn't "
-			  "deferred\n");
-	}
-
-	schedule_deferred_open_smb_message(cb->data.mid);
-
-	/* Cleanup the callback record since the open will be retried. */
-	destroy_onefs_callback_record(id);
-
-	return;
-}
-
-/**
- * Asynchronous ifs_createfile failure callback
- *
- * If ifs_createfile had to asynchronously break any oplocks, but an error was
- * encountered in the kernel, the open will be retried with the state->failed
- * set to true.  This will prompt the open path to send an INTERNAL_ERROR
- * error message to the client.
- */
-static void semlock_async_failure_handler(uint64_t id)
-{
-	struct onefs_callback_record *cb;
-	struct deferred_open_record *state;
-
-	DEBUG(1, ("semlock_async_failure_handler called: %llu\n", id));
-
-	if (!(cb = onefs_find_cb(id, ONEFS_WAITING_FOR_OPLOCK))) {
-		DEBUG(5, ("semlock_async_failure_handler: Did not find callback "
-			  "%llu\n", id));
-		return;
-	}
-
-	DEBUG(1, ("Got semlock_async_failure message for mid %llu\n",
-		(unsigned long long)cb->data.mid));
-
-	/* Paranoia check */
-	if (!(open_was_deferred(cb->data.mid))) {
-		char *msg;
-		if (asprintf(&msg, "Semlock failure on an open that wasn't "
-			     "deferred: %s\n",
-			      onefs_cb_record_str_dbg(cb)) != -1) {
-			smb_panic(msg);
-		}
-		smb_panic("Semlock failure on an open that wasn't deferred\n");
-	}
-
-	/* Find the actual deferred open record. */
-	if (!get_open_deferred_message_state(cb->data.mid, NULL, &state)) {
-		DEBUG(0, ("Could not find deferred request for "
-			  "mid %d\n", cb->data.mid));
-		destroy_onefs_callback_record(id);
-		return;
-	}
-
-	/* Update to failed so the client can be notified on retried open. */
-	state->failed = true;
-
-	/* Schedule deferred open for immediate retry. */
-	schedule_deferred_open_smb_message(cb->data.mid);
-
-	/* Cleanup the callback record here since the open will be retried. */
-	destroy_onefs_callback_record(id);
-
-	return;
-}
-
-/**
- * OneFS acquires all oplocks via ifs_createfile, so this is a no-op.
- */
-static bool onefs_set_kernel_oplock(struct kernel_oplocks *_ctx,
-				    files_struct *fsp, int oplock_type) {
-	return true;
-}
-
-/**
- * Release the kernel oplock.
- */
-static void onefs_release_kernel_oplock(struct kernel_oplocks *_ctx,
-					files_struct *fsp, int oplock_type)
-{
-	enum oplock_type oplock = onefs_samba_oplock_to_oplock(oplock_type);
-
-	DEBUG(10, ("onefs_release_kernel_oplock: Releasing %s to type %s\n",
-		   fsp_str_dbg(fsp), onefs_oplock_str(oplock)));
-
-	if (fsp->fh->fd == -1) {
-		DEBUG(1, ("no fd\n"));
-		return;
-	}
-
-	/* Downgrade oplock to either SHARED or NONE. */
-	if (ifs_oplock_downgrade(fsp->fh->fd, oplock)) {
-		DEBUG(1,("ifs_oplock_downgrade failed: %s\n",
-			 strerror(errno)));
-	}
-}
-
-/**
- * Wrap ifs_semlock_write so it is only called on operations that aren't
- * already contended in the kernel.
- */
-static void onefs_semlock_write(int fd, enum level2_contention_type type,
-				enum semlock_operation semlock_op)
-{
-	int ret;
-
-	switch (type) {
-	case LEVEL2_CONTEND_ALLOC_GROW:
-	case LEVEL2_CONTEND_POSIX_BRL:
-		DEBUG(10, ("Taking %d write semlock for cmd %d on fd: %d\n",
-			   semlock_op, type, fd));
-		ret = ifs_semlock_write(fd, semlock_op);
-		if (ret) {
-			DEBUG(0,("ifs_semlock_write failed taking %d write "
-				 "semlock for cmd %d on fd: %d: %s",
-				 semlock_op, type, fd, strerror(errno)));
-		}
-		break;
-	default:
-		DEBUG(10, ("Skipping write semlock for cmd %d on fd: %d\n",
-			   type, fd));
-	}
-}
-
-/**
- * Contend level 2 oplocks in the kernel and smbd.
- *
- * Taking a write semlock will contend all level 2 oplocks in all smbds across
- * the cluster except the fsp's own level 2 oplock.  This lack of
- * self-contention is a limitation of the current OneFS kernel oplocks
- * implementation.  Luckily it is easy to contend our own level 2 oplock by
- * checking the the fsp's oplock_type.  If it's a level2, send a break message
- * to the client and remove the oplock.
- */
-static void onefs_contend_level2_oplocks_begin(files_struct *fsp,
-					       enum level2_contention_type type)
-{
-	/* Take care of level 2 kernel contention. */
-	onefs_semlock_write(fsp->fh->fd, type, SEMLOCK_LOCK);
-
-	/* Take care of level 2 self contention. */
-	if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
-		break_level2_to_none_async(fsp);
-}
-
-/**
- * Unlock the write semlock when the level 2 contending operation ends.
- */
-static void onefs_contend_level2_oplocks_end(files_struct *fsp,
-					     enum level2_contention_type type)
-{
-	/* Take care of level 2 kernel contention. */
-	onefs_semlock_write(fsp->fh->fd, type, SEMLOCK_UNLOCK);
-}
-
-/**
- * Return string value of onefs oplock types.
- */
-const char *onefs_oplock_str(enum oplock_type onefs_oplock_type)
-{
-	switch (onefs_oplock_type) {
-	case OPLOCK_NONE:
-		return "OPLOCK_NONE";
-	case OPLOCK_EXCLUSIVE:
-		return "OPLOCK_EXCLUSIVE";
-	case OPLOCK_BATCH:
-		return "OPLOCK_BATCH";
-	case OPLOCK_SHARED:
-		return "OPLOCK_SHARED";
-	default:
-		break;
-	}
-	return "UNKNOWN";
-}
-
-/**
- * Convert from onefs to samba oplock.
- */
-int onefs_oplock_to_samba_oplock(enum oplock_type onefs_oplock)
-{
-	switch (onefs_oplock) {
-	case OPLOCK_NONE:
-		return NO_OPLOCK;
-	case OPLOCK_EXCLUSIVE:
-		return EXCLUSIVE_OPLOCK;
-	case OPLOCK_BATCH:
-		return BATCH_OPLOCK;
-	case OPLOCK_SHARED:
-		return LEVEL_II_OPLOCK;
-	default:
-		DEBUG(0, ("unknown oplock type %d found\n", onefs_oplock));
-		break;
-	}
-	return NO_OPLOCK;
-}
-
-/**
- * Convert from samba to onefs oplock.
- */
-enum oplock_type onefs_samba_oplock_to_oplock(int samba_oplock_type)
-{
-	if (BATCH_OPLOCK_TYPE(samba_oplock_type)) return OPLOCK_BATCH;
-	if (EXCLUSIVE_OPLOCK_TYPE(samba_oplock_type)) return OPLOCK_EXCLUSIVE;
-	if (LEVEL_II_OPLOCK_TYPE(samba_oplock_type)) return OPLOCK_SHARED;
-	return OPLOCK_NONE;
-}
-
-/**
- * Oplock event handler.
- *
- * Call into the event system dispatcher to handle each event.
- */
-static void onefs_oplocks_read_fde_handler(struct event_context *ev,
-					   struct fd_event *fde,
-					   uint16_t flags,
-					   void *private_data)
-{
-	struct onefs_oplocks_context *ctx =
-	    talloc_get_type(private_data, struct onefs_oplocks_context);
-
-	if (oplocks_event_dispatcher(ctx->onefs_ops)) {
-		DEBUG(0, ("oplocks_event_dispatcher failed: %s\n",
-			  strerror(errno)));
-	}
-}
-
-/**
- * Setup kernel oplocks
- */
-static const struct kernel_oplocks_ops onefs_koplocks_ops = {
-	.set_oplock			= onefs_set_kernel_oplock,
-	.release_oplock			= onefs_release_kernel_oplock,
-	.contend_level2_oplocks_begin	= onefs_contend_level2_oplocks_begin,
-	.contend_level2_oplocks_end	= onefs_contend_level2_oplocks_end,
-};
-
-static const struct oplocks_event_ops onefs_dispatch_ops = {
-	.oplock_break_to_none = oplock_break_to_none_handler,
-	.oplock_break_to_level_two = oplock_break_to_level_two_handler,
-	.oplock_revoked = oplock_revoked_handler,
-	.semlock_available = semlock_available_handler,
-	.semlock_async_failure = semlock_async_failure_handler,
-};
-
-struct kernel_oplocks *onefs_init_kernel_oplocks(struct smbd_server_connection *sconn)
-{
-	struct kernel_oplocks *_ctx = NULL;
-	struct onefs_oplocks_context *ctx = NULL;
-        struct procoptions po = PROCOPTIONS_INIT;
-
-	DEBUG(10, ("onefs_init_kernel_oplocks called\n"));
-
-	/* Set the non-blocking proc flag */
-	po.po_flags_on |= P_NON_BLOCKING_SEMLOCK;
-	if (setprocoptions(&po) != 0) {
-		DEBUG(0, ("setprocoptions failed: %s.\n", strerror(errno)));
-		return NULL;
-	}
-
-	/* Setup the oplock contexts */
-	_ctx = talloc_zero(mem_ctx, struct kernel_oplocks);
-	if (!_ctx) {
-		return NULL;
-	}
-
-	ctx = talloc_zero(_ctx, struct onefs_oplocks_context);
-	if (!ctx) {
-		goto err_out;
-	}
-	ctx->sconn = sconn;
-
-	_ctx->ops = &onefs_koplocks_ops;
-	_ctx->flags = (KOPLOCKS_LEVEL2_SUPPORTED |
-		       KOPLOCKS_DEFERRED_OPEN_NOTIFICATION |
-		       KOPLOCKS_TIMEOUT_NOTIFICATION |
-		       KOPLOCKS_OPLOCK_BROKEN_NOTIFICATION);
-	_ctx->private_data = ctx;
-	ctx->ctx = _ctx;
-	ctx->onefs_ops = &onefs_dispatch_ops;
-
-	/* Register an kernel event channel for oplocks */
-	ctx->onefs_event_fd = oplocks_event_register();
-	if (ctx->onefs_event_fd == -1) {
-		DEBUG(0, ("oplocks_event_register failed: %s\n",
-			   strerror(errno)));
-		goto err_out;
-	}
-
-	DEBUG(10, ("oplock event_fd = %d\n", ctx->onefs_event_fd));
-
-	/* Register the oplock event_fd with samba's event system */
-	ctx->read_fde = event_add_fd(sconn->ev_ctx,
-				     ctx,
-				     ctx->onefs_event_fd,
-				     EVENT_FD_READ,
-				     onefs_oplocks_read_fde_handler,
-				     ctx);
-	return _ctx;
-
- err_out:
-	talloc_free(_ctx);
-	return NULL;
-}
-
-#else
- void oplock_onefs_dummy(void);
- void oplock_onefs_dummy(void) {}
-#endif /* HAVE_ONEFS */
diff --git a/source3/smbd/proto.h b/source3/smbd/proto.h
index 4300ee3bca..4a3bd2d334 100644
--- a/source3/smbd/proto.h
+++ b/source3/smbd/proto.h
@@ -696,10 +696,6 @@ int linux_set_lease_sighandler(int fd);
 int linux_setlease(int fd, int leasetype);
 struct kernel_oplocks *linux_init_kernel_oplocks(struct smbd_server_connection *sconn);
 
-/* The following definitions come from smbd/oplock_onefs.c  */
-
-struct kernel_oplocks *onefs_init_kernel_oplocks(struct smbd_server_connection *sconn);
-
 /* The following definitions come from smbd/password.c  */
 
 user_struct *get_valid_user_struct(struct smbd_server_connection *sconn,