s3: Put an indirection layer into share_mode_lock

Signed-off-by: Jeremy Allison <jra@samba.org>

9 files changed, 193 insertions, 173 deletions

diff --git a/source3/include/smb.h b/source3/include/smb.h
index 2adfa36c8c..11a05f9369 100644
--- a/source3/include/smb.h
+++ b/source3/include/smb.h
@@ -163,6 +163,10 @@ struct wb_context;
 struct rpc_cli_smbd_conn;
 struct fncall_context;
 
+struct share_mode_lock {
+	struct share_mode_data *data;
+};
+
 struct vfs_fsp_data {
     struct vfs_fsp_data *next;
     struct vfs_handle_struct *owner;
diff --git a/source3/librpc/idl/open_files.idl b/source3/librpc/idl/open_files.idl
index 9f06a0c123..cefb75a2a3 100644
--- a/source3/librpc/idl/open_files.idl
+++ b/source3/librpc/idl/open_files.idl
@@ -44,5 +44,5 @@ interface open_files
 		uint8 fresh;
 		uint8 modified;
 		[ignore] db_record *record;
-	} share_mode_lock;
+	} share_mode_data;
 }
diff --git a/source3/locking/locking.c b/source3/locking/locking.c
index 2e400ac8ef..d98d19b399 100644
--- a/source3/locking/locking.c
+++ b/source3/locking/locking.c
@@ -513,18 +513,18 @@ char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
  Get all share mode entries for a dev/inode pair.
 ********************************************************************/
 
-static struct share_mode_lock *parse_share_modes(TALLOC_CTX *mem_ctx,
+static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
 						 const TDB_DATA dbuf)
 {
-	struct share_mode_lock *lck;
+	struct share_mode_data *d;
 	int i;
 	struct server_id *pids;
 	bool *pid_exists;
 	enum ndr_err_code ndr_err;
 	DATA_BLOB blob;
 
-	lck = talloc_zero(mem_ctx, struct share_mode_lock);
-	if (lck == NULL) {
+	d = talloc_zero(mem_ctx, struct share_mode_data);
+	if (d == NULL) {
 		DEBUG(0, ("talloc failed\n"));
 		goto fail;
 	}
@@ -533,19 +533,18 @@ static struct share_mode_lock *parse_share_modes(TALLOC_CTX *mem_ctx,
 	blob.length = dbuf.dsize;
 
 	ndr_err = ndr_pull_struct_blob(
-		&blob, lck, lck,
-		(ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
+		&blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
 	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 		DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
 		goto fail;
 	}
 
-	lck->modified = false;
-	lck->fresh = false;
+	d->modified = false;
+	d->fresh = false;
 
 	if (DEBUGLEVEL >= 10) {
 		DEBUG(10, ("parse_share_modes:\n"));
-		NDR_PRINT_DEBUG(share_mode_lock, lck);
+		NDR_PRINT_DEBUG(share_mode_data, d);
 	}
 
 	/*
@@ -553,62 +552,61 @@ static struct share_mode_lock *parse_share_modes(TALLOC_CTX *mem_ctx,
 	 */
 
 	pids = talloc_array(talloc_tos(), struct server_id,
-			    lck->num_share_modes);
+			    d->num_share_modes);
 	if (pids == NULL) {
 		DEBUG(0, ("talloc failed\n"));
 		goto fail;
 	}
-	pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
+	pid_exists = talloc_array(talloc_tos(), bool, d->num_share_modes);
 	if (pid_exists == NULL) {
 		DEBUG(0, ("talloc failed\n"));
 		goto fail;
 	}
 
-	for (i=0; i<lck->num_share_modes; i++) {
-		pids[i] = lck->share_modes[i].pid;
+	for (i=0; i<d->num_share_modes; i++) {
+		pids[i] = d->share_modes[i].pid;
 	}
-	if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
+	if (!serverids_exist(pids, d->num_share_modes, pid_exists)) {
 		DEBUG(0, ("serverid_exists failed\n"));
 		goto fail;
 	}
 
 	i = 0;
-	while (i < lck->num_share_modes) {
-		struct share_mode_entry *e = &lck->share_modes[i];
+	while (i < d->num_share_modes) {
+		struct share_mode_entry *e = &d->share_modes[i];
 		if (!pid_exists[i]) {
-			*e = lck->share_modes[lck->num_share_modes-1];
-			lck->num_share_modes -= 1;
-			lck->modified = True;
+			*e = d->share_modes[d->num_share_modes-1];
+			d->num_share_modes -= 1;
+			d->modified = True;
 			continue;
 		}
 		i += 1;
 	}
 	TALLOC_FREE(pid_exists);
 	TALLOC_FREE(pids);
-	return lck;
+	return d;
 fail:
-	TALLOC_FREE(lck);
+	TALLOC_FREE(d);
 	return NULL;
 }
 
-static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
+static TDB_DATA unparse_share_modes(struct share_mode_data *d)
 {
 	DATA_BLOB blob;
 	enum ndr_err_code ndr_err;
 
 	if (DEBUGLEVEL >= 10) {
 		DEBUG(10, ("unparse_share_modes:\n"));
-		NDR_PRINT_DEBUG(share_mode_lock, lck);
+		NDR_PRINT_DEBUG(share_mode_data, d);
 	}
 
-	if (lck->num_share_modes == 0) {
+	if (d->num_share_modes == 0) {
 		DEBUG(10, ("No used share mode found\n"));
 		return make_tdb_data(NULL, 0);
 	}
 
 	ndr_err = ndr_push_struct_blob(
-		&blob, lck, lck,
-		(ndr_push_flags_fn_t)ndr_push_share_mode_lock);
+		&blob, d, d, (ndr_push_flags_fn_t)ndr_push_share_mode_data);
 	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 		smb_panic("ndr_push_share_mode_lock failed");
 	}
@@ -616,22 +614,22 @@ static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
 	return make_tdb_data(blob.data, blob.length);
 }
 
-static int share_mode_lock_destructor(struct share_mode_lock *lck)
+static int share_mode_data_destructor(struct share_mode_data *d)
 {
 	NTSTATUS status;
 	TDB_DATA data;
 
-	if (!lck->modified) {
+	if (!d->modified) {
 		return 0;
 	}
 
-	data = unparse_share_modes(lck);
+	data = unparse_share_modes(d);
 
 	if (data.dptr == NULL) {
-		if (!lck->fresh) {
+		if (!d->fresh) {
 			/* There has been an entry before, delete it */
 
-			status = dbwrap_record_delete(lck->record);
+			status = dbwrap_record_delete(d->record);
 			if (!NT_STATUS_IS_OK(status)) {
 				char *errmsg;
 
@@ -650,7 +648,7 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
 		goto done;
 	}
 
-	status = dbwrap_record_store(lck->record, data, TDB_REPLACE);
+	status = dbwrap_record_store(d->record, data, TDB_REPLACE);
 	if (!NT_STATUS_IS_OK(status)) {
 		char *errmsg;
 
@@ -668,43 +666,43 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
 	return 0;
 }
 
-static struct share_mode_lock *fresh_share_mode_lock(
+static struct share_mode_data *fresh_share_mode_lock(
 	TALLOC_CTX *mem_ctx, const char *servicepath,
 	const struct smb_filename *smb_fname,
 	const struct timespec *old_write_time)
 {
-	struct share_mode_lock *lck;
+	struct share_mode_data *d;
 
 	if ((servicepath == NULL) || (smb_fname == NULL) ||
 	    (old_write_time == NULL)) {
 		return NULL;
 	}
 
-	lck = talloc_zero(mem_ctx, struct share_mode_lock);
-	if (lck == NULL) {
+	d = talloc_zero(mem_ctx, struct share_mode_data);
+	if (d == NULL) {
 		goto fail;
 	}
-	lck->base_name = talloc_strdup(lck, smb_fname->base_name);
-	if (lck->base_name == NULL) {
+	d->base_name = talloc_strdup(d, smb_fname->base_name);
+	if (d->base_name == NULL) {
 		goto fail;
 	}
 	if (smb_fname->stream_name != NULL) {
-		lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
-		if (lck->stream_name == NULL) {
+		d->stream_name = talloc_strdup(d, smb_fname->stream_name);
+		if (d->stream_name == NULL) {
 			goto fail;
 		}
 	}
-	lck->servicepath = talloc_strdup(lck, servicepath);
-	if (lck->servicepath == NULL) {
+	d->servicepath = talloc_strdup(d, servicepath);
+	if (d->servicepath == NULL) {
 		goto fail;
 	}
-	lck->old_write_time = *old_write_time;
-	lck->modified = false;
-	lck->fresh = true;
-	return lck;
+	d->old_write_time = *old_write_time;
+	d->modified = false;
+	d->fresh = true;
+	return d;
 fail:
 	DEBUG(0, ("talloc failed\n"));
-	TALLOC_FREE(lck);
+	TALLOC_FREE(d);
 	return NULL;
 }
 
@@ -715,6 +713,7 @@ struct share_mode_lock *get_share_mode_lock_fresh(TALLOC_CTX *mem_ctx,
 						  const struct timespec *old_write_time)
 {
 	struct share_mode_lock *lck;
+	struct share_mode_data *d;
 	struct file_id tmp;
 	struct db_record *rec;
 	TDB_DATA key = locking_key(&id, &tmp);
@@ -729,20 +728,28 @@ struct share_mode_lock *get_share_mode_lock_fresh(TALLOC_CTX *mem_ctx,
 	value = dbwrap_record_get_value(rec);
 
 	if (value.dptr == NULL) {
-		lck = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
-					    old_write_time);
+		d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
+					  old_write_time);
 	} else {
-		lck = parse_share_modes(mem_ctx, value);
+		d = parse_share_modes(mem_ctx, value);
 	}
 
-	if (lck == NULL) {
+	if (d == NULL) {
 		DEBUG(1, ("Could not get share mode lock\n"));
 		TALLOC_FREE(rec);
 		return NULL;
 	}
-	lck->id = id;
-	lck->record = talloc_move(lck, &rec);
-	talloc_set_destructor(lck, share_mode_lock_destructor);
+	d->id = id;
+	d->record = talloc_move(d, &rec);
+	talloc_set_destructor(d, share_mode_data_destructor);
+
+	lck = talloc(mem_ctx, struct share_mode_lock);
+	if (lck == NULL) {
+		DEBUG(1, ("talloc failed\n"));
+		TALLOC_FREE(d);
+		return NULL;
+	}
+	lck->data = talloc_move(lck, &d);
 	return lck;
 }
 
@@ -769,11 +776,17 @@ struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
 	if (data.dptr == NULL) {
 		return NULL;
 	}
-	lck = parse_share_modes(mem_ctx, data);
-	if (lck != NULL) {
-		lck->id = id;
+	lck = talloc(mem_ctx, struct share_mode_lock);
+	if (lck == NULL) {
+		TALLOC_FREE(data.dptr);
+		return NULL;
 	}
+	lck->data = parse_share_modes(mem_ctx, data);
 	TALLOC_FREE(data.dptr);
+	if (lck->data == NULL) {
+		TALLOC_FREE(lck);
+		return NULL;
+	}
 	return lck;
 }
 
@@ -791,6 +804,7 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 			uint32_t new_name_hash,
 			const struct smb_filename *smb_fname_dst)
 {
+	struct share_mode_data *d = lck->data;
 	size_t sp_len;
 	size_t bn_len;
 	size_t sn_len;
@@ -814,48 +828,48 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 		strip_two_chars = true;
 	}
 
-	lck->servicepath = talloc_strdup(lck, servicepath);
-	lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
+	d->servicepath = talloc_strdup(d, servicepath);
+	d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
 				       (strip_two_chars ? 2 : 0));
-	lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
-	if (lck->base_name == NULL ||
-	    (has_stream && lck->stream_name == NULL) ||
-	    lck->servicepath == NULL) {
+	d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
+	if (d->base_name == NULL ||
+	    (has_stream && d->stream_name == NULL) ||
+	    d->servicepath == NULL) {
 		DEBUG(0, ("rename_share_filename: talloc failed\n"));
 		return False;
 	}
-	lck->modified = True;
+	d->modified = True;
 
-	sp_len = strlen(lck->servicepath);
-	bn_len = strlen(lck->base_name);
-	sn_len = has_stream ? strlen(lck->stream_name) : 0;
+	sp_len = strlen(d->servicepath);
+	bn_len = strlen(d->base_name);
+	sn_len = has_stream ? strlen(d->stream_name) : 0;
 
 	msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
 	    sn_len + 1;
 
 	/* Set up the name changed message. */
-	frm = talloc_array(lck, char, msg_len);
+	frm = talloc_array(d, char, msg_len);
 	if (!frm) {
 		return False;
 	}
 
-	push_file_id_24(frm, &lck->id);
+	push_file_id_24(frm, &d->id);
 
 	DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 
 	strlcpy(&frm[24],
-		lck->servicepath ? lck->servicepath : "",
+		d->servicepath ? d->servicepath : "",
 		sp_len+1);
 	strlcpy(&frm[24 + sp_len + 1],
-		lck->base_name ? lck->base_name : "",
+		d->base_name ? d->base_name : "",
 		bn_len+1);
 	strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
-		lck->stream_name ? lck->stream_name : "",
+		d->stream_name ? d->stream_name : "",
 		sn_len+1);
 
 	/* Send the messages. */
-	for (i=0; i<lck->num_share_modes; i++) {
-		struct share_mode_entry *se = &lck->share_modes[i];
+	for (i=0; i<d->num_share_modes; i++) {
+		struct share_mode_entry *se = &d->share_modes[i];
 		if (!is_valid_share_mode_entry(se)) {
 			continue;
 		}
@@ -877,9 +891,9 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 			  "pid %s file_id %s sharepath %s base_name %s "
 			  "stream_name %s\n",
 			  procid_str_static(&se->pid),
-			  file_id_string_tos(&lck->id),
-			  lck->servicepath, lck->base_name,
-			has_stream ? lck->stream_name : ""));
+			  file_id_string_tos(&d->id),
+			  d->servicepath, d->base_name,
+			has_stream ? d->stream_name : ""));
 
 		messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
 				   (uint8 *)frm, msg_len);
@@ -914,9 +928,9 @@ void get_file_infos(struct file_id id,
 	if (write_time) {
 		struct timespec wt;
 
-		wt = lck->changed_write_time;
+		wt = lck->data->changed_write_time;
 		if (null_timespec(wt)) {
-			wt = lck->old_write_time;
+			wt = lck->data->old_write_time;
 		}
 
 		*write_time = wt;
@@ -983,12 +997,12 @@ static void fill_deferred_open_entry(struct share_mode_entry *e,
 	e->flags = 0;
 }
 
-static void add_share_mode_entry(struct share_mode_lock *lck,
+static void add_share_mode_entry(struct share_mode_data *d,
 				 const struct share_mode_entry *entry)
 {
-	ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
-		     &lck->share_modes, &lck->num_share_modes);
-	lck->modified = True;
+	ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
+		     &d->share_modes, &d->num_share_modes);
+	d->modified = True;
 }
 
 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
@@ -996,7 +1010,7 @@ void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
 {
 	struct share_mode_entry entry;
 	fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
-	add_share_mode_entry(lck, &entry);
+	add_share_mode_entry(lck->data, &entry);
 }
 
 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
@@ -1005,7 +1019,7 @@ void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
 {
 	struct share_mode_entry entry;
 	fill_deferred_open_entry(&entry, request_time, id, pid, mid);
-	add_share_mode_entry(lck, &entry);
+	add_share_mode_entry(lck->data, &entry);
 }
 
 /*******************************************************************
@@ -1035,13 +1049,13 @@ static bool deferred_open_identical(struct share_mode_entry *e1,
 		file_id_equal(&e1->id, &e2->id));
 }
 
-static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
+static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
 						      struct share_mode_entry *entry)
 {
 	int i;
 
-	for (i=0; i<lck->num_share_modes; i++) {
-		struct share_mode_entry *e = &lck->share_modes[i];
+	for (i=0; i<d->num_share_modes; i++) {
+		struct share_mode_entry *e = &d->share_modes[i];
 		if (is_valid_share_mode_entry(entry) &&
 		    is_valid_share_mode_entry(e) &&
 		    share_modes_identical(e, entry)) {
@@ -1068,13 +1082,13 @@ bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 	/* Don't care about the pid owner being correct here - just a search. */
 	fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
 
-	e = find_share_mode_entry(lck, &entry);
+	e = find_share_mode_entry(lck->data, &entry);
 	if (e == NULL) {
 		return False;
 	}
-	*e = lck->share_modes[lck->num_share_modes-1];
-	lck->num_share_modes -= 1;
-	lck->modified = True;
+	*e = lck->data->share_modes[lck->data->num_share_modes-1];
+	lck->data->num_share_modes -= 1;
+	lck->data->modified = True;
 	return True;
 }
 
@@ -1084,15 +1098,15 @@ void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
 	struct share_mode_entry entry, *e;
 
 	fill_deferred_open_entry(&entry, timeval_zero(),
-				 lck->id, pid, mid);
+				 lck->data->id, pid, mid);
 
-	e = find_share_mode_entry(lck, &entry);
+	e = find_share_mode_entry(lck->data, &entry);
 	if (e == NULL) {
 		return;
 	}
-	*e = lck->share_modes[lck->num_share_modes-1];
-	lck->num_share_modes -= 1;
-	lck->modified = True;
+	*e = lck->data->share_modes[lck->data->num_share_modes-1];
+	lck->data->num_share_modes -= 1;
+	lck->data->modified = True;
 }
 
 /*******************************************************************
@@ -1106,7 +1120,7 @@ bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 	/* Don't care about the pid owner being correct here - just a search. */
 	fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
 
-	e = find_share_mode_entry(lck, &entry);
+	e = find_share_mode_entry(lck->data, &entry);
 	if (e == NULL) {
 		return False;
 	}
@@ -1124,7 +1138,7 @@ bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 	} else {
 		e->op_type = NO_OPLOCK;
 	}
-	lck->modified = True;
+	lck->data->modified = True;
 	return True;
 }
 
@@ -1139,13 +1153,13 @@ bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 	/* Don't care about the pid owner being correct here - just a search. */
 	fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
 
-	e = find_share_mode_entry(lck, &entry);
+	e = find_share_mode_entry(lck->data, &entry);
 	if (e == NULL) {
 		return False;
 	}
 
 	e->op_type = LEVEL_II_OPLOCK;
-	lck->modified = True;
+	lck->data->modified = True;
 	return True;
 }
 
@@ -1182,27 +1196,27 @@ static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct
  Adds a delete on close token.
 ****************************************************************************/
 
-static bool add_delete_on_close_token(struct share_mode_lock *lck,
+static bool add_delete_on_close_token(struct share_mode_data *d,
 			uint32_t name_hash,
 			const struct security_unix_token *tok)
 {
 	struct delete_token *tmp, *dtl;
 
-	tmp = talloc_realloc(lck, lck->delete_tokens, struct delete_token,
-			     lck->num_delete_tokens+1);
+	tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
+			     d->num_delete_tokens+1);
 	if (tmp == NULL) {
 		return false;
 	}
-	lck->delete_tokens = tmp;
-	dtl = &lck->delete_tokens[lck->num_delete_tokens];
+	d->delete_tokens = tmp;
+	dtl = &d->delete_tokens[d->num_delete_tokens];
 
 	dtl->name_hash = name_hash;
-	dtl->delete_token = copy_unix_token(lck->delete_tokens, tok);
+	dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
 	if (dtl->delete_token == NULL) {
 		return false;
 	}
-	lck->num_delete_tokens += 1;
-	lck->modified = true;
+	d->num_delete_tokens += 1;
+	d->modified = true;
 	return true;
 }
 
@@ -1222,6 +1236,7 @@ void set_delete_on_close_lck(files_struct *fsp,
 			bool delete_on_close,
 			const struct security_unix_token *tok)
 {
+	struct share_mode_data *d = lck->data;
 	int i;
 	bool ret;
 
@@ -1231,16 +1246,16 @@ void set_delete_on_close_lck(files_struct *fsp,
 		SMB_ASSERT(tok == NULL);
 	}
 
-	for (i=0; i<lck->num_delete_tokens; i++) {
-		struct delete_token *dt = &lck->delete_tokens[i];
+	for (i=0; i<d->num_delete_tokens; i++) {
+		struct delete_token *dt = &d->delete_tokens[i];
 		if (dt->name_hash == fsp->name_hash) {
-			lck->modified = true;
+			d->modified = true;
 			if (delete_on_close == false) {
 				/* Delete this entry. */
 				TALLOC_FREE(dt->delete_token);
-				*dt = lck->delete_tokens[
-					lck->num_delete_tokens-1];
-				lck->num_delete_tokens -= 1;
+				*dt = d->delete_tokens[
+					d->num_delete_tokens-1];
+				d->num_delete_tokens -= 1;
 				return;
 			}
 			/* Replace this token with the
@@ -1256,7 +1271,7 @@ void set_delete_on_close_lck(files_struct *fsp,
 		return;
 	}
 
-	ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
+	ret = add_delete_on_close_token(lck->data, fsp->name_hash, tok);
 	SMB_ASSERT(ret);
 }
 
@@ -1297,8 +1312,8 @@ const struct security_unix_token *get_delete_on_close_token(struct share_mode_lo
 	DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
 			(unsigned int)name_hash ));
 
-	for (i=0; i<lck->num_delete_tokens; i++) {
-		struct delete_token *dt = &lck->delete_tokens[i];
+	for (i=0; i<lck->data->num_delete_tokens; i++) {
+		struct delete_token *dt = &lck->data->delete_tokens[i];
 		DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
 				(unsigned int)dt->name_hash ));
 		if (dt->name_hash == name_hash) {
@@ -1327,9 +1342,9 @@ bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
 		return False;
 	}
 
-	if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
-		lck->modified = True;
-		lck->changed_write_time = write_time;
+	if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
+		lck->data->modified = True;
+		lck->data->changed_write_time = write_time;
 	}
 
 	TALLOC_FREE(lck);
@@ -1350,9 +1365,9 @@ bool set_write_time(struct file_id fileid, struct timespec write_time)
 		return False;
 	}
 
-	if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
-		lck->modified = True;
-		lck->old_write_time = write_time;
+	if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
+		lck->data->modified = True;
+		lck->data->old_write_time = write_time;
 	}
 
 	TALLOC_FREE(lck);
@@ -1376,7 +1391,7 @@ static int traverse_fn(struct db_record *rec, void *_state)
 	TDB_DATA value;
 	DATA_BLOB blob;
 	enum ndr_err_code ndr_err;
-	struct share_mode_lock *lck;
+	struct share_mode_data *d;
 
 	key = dbwrap_record_get_key(rec);
 	value = dbwrap_record_get_value(rec);
@@ -1385,8 +1400,8 @@ static int traverse_fn(struct db_record *rec, void *_state)
 	if (key.dsize != sizeof(struct file_id))
 		return 0;
 
-	lck = talloc(talloc_tos(), struct share_mode_lock);
-	if (lck == NULL) {
+	d = talloc(talloc_tos(), struct share_mode_data);
+	if (d == NULL) {
 		return 0;
 	}
 
@@ -1394,18 +1409,17 @@ static int traverse_fn(struct db_record *rec, void *_state)
 	blob.length = value.dsize;
 
 	ndr_err = ndr_pull_struct_blob(
-		&blob, lck, lck,
-		(ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
+		&blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
 	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 		DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
 		return 0;
 	}
-	for (i=0; i<lck->num_share_modes; i++) {
-		state->fn(&lck->share_modes[i],
-			  lck->servicepath, lck->base_name,
+	for (i=0; i<d->num_share_modes; i++) {
+		state->fn(&d->share_modes[i],
+			  d->servicepath, d->base_name,
 			  state->private_data);
 	}
-	TALLOC_FREE(lck);
+	TALLOC_FREE(d);
 
 	return 0;
 }
diff --git a/source3/smbd/close.c b/source3/smbd/close.c
index a07ab4b42c..131f4bf5d1 100644
--- a/source3/smbd/close.c
+++ b/source3/smbd/close.c
@@ -178,8 +178,8 @@ static void notify_deferred_opens(struct smbd_server_connection *sconn,
 	}
 
 	num_deferred = 0;
-	for (i=0; i<lck->num_share_modes; i++) {
-		if (is_deferred_open_entry(&lck->share_modes[i])) {
+	for (i=0; i<lck->data->num_share_modes; i++) {
+		if (is_deferred_open_entry(&lck->data->share_modes[i])) {
 			num_deferred += 1;
 		}
 	}
@@ -194,8 +194,8 @@ static void notify_deferred_opens(struct smbd_server_connection *sconn,
 	}
 
 	num_deferred = 0;
-	for (i=0; i<lck->num_share_modes; i++) {
- 		struct share_mode_entry *e = &lck->share_modes[i];
+	for (i=0; i<lck->data->num_share_modes; i++) {
+		struct share_mode_entry *e = &lck->data->share_modes[i];
 		if (is_deferred_open_entry(e)) {
 			deferred[num_deferred] = *e;
 			num_deferred += 1;
@@ -359,7 +359,7 @@ static NTSTATUS close_remove_share_mode(files_struct *fsp,
 		DEBUG(10,("close_remove_share_mode: write time forced "
 			"for file %s\n",
 			fsp_str_dbg(fsp)));
-		set_close_write_time(fsp, lck->changed_write_time);
+		set_close_write_time(fsp, lck->data->changed_write_time);
 	} else if (fsp->update_write_time_on_close) {
 		/* Someone had a pending write. */
 		if (null_timespec(fsp->close_write_time)) {
@@ -408,8 +408,8 @@ static NTSTATUS close_remove_share_mode(files_struct *fsp,
 		/* See if others still have the file open via this pathname.
 		   If this is the case, then don't delete. If all opens are
 		   POSIX delete now. */
-		for (i=0; i<lck->num_share_modes; i++) {
-			struct share_mode_entry *e = &lck->share_modes[i];
+		for (i=0; i<lck->data->num_share_modes; i++) {
+			struct share_mode_entry *e = &lck->data->share_modes[i];
 			if (is_valid_share_mode_entry(e) &&
 					e->name_hash == fsp->name_hash) {
 				if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
@@ -619,7 +619,7 @@ static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
 	if (lck) {
 		/* Close write times overwrite sticky write times
 		   so we must replace any sticky write time here. */
-		if (!null_timespec(lck->changed_write_time)) {
+		if (!null_timespec(lck->data->changed_write_time)) {
 			(void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
 		}
 		TALLOC_FREE(lck);
@@ -1058,8 +1058,8 @@ static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
 		int i;
 		/* See if others still have the dir open. If this is the
 		 * case, then don't delete. If all opens are POSIX delete now. */
-		for (i=0; i<lck->num_share_modes; i++) {
-			struct share_mode_entry *e = &lck->share_modes[i];
+		for (i=0; i<lck->data->num_share_modes; i++) {
+			struct share_mode_entry *e = &lck->data->share_modes[i];
 			if (is_valid_share_mode_entry(e) &&
 					e->name_hash == fsp->name_hash) {
 				if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
diff --git a/source3/smbd/open.c b/source3/smbd/open.c
index 46d5d28863..7a85552910 100644
--- a/source3/smbd/open.c
+++ b/source3/smbd/open.c
@@ -987,7 +987,7 @@ static NTSTATUS open_mode_check(connection_struct *conn,
 {
 	int i;
 
-	if(lck->num_share_modes == 0) {
+	if(lck->data->num_share_modes == 0) {
 		return NT_STATUS_OK;
 	}
 
@@ -1010,9 +1010,9 @@ static NTSTATUS open_mode_check(connection_struct *conn,
 	 */
 
 #if defined(DEVELOPER)
-	for(i = 0; i < lck->num_share_modes; i++) {
+	for(i = 0; i < lck->data->num_share_modes; i++) {
 		validate_my_share_entries(conn->sconn, i,
-					  &lck->share_modes[i]);
+					  &lck->data->share_modes[i]);
 	}
 #endif
 
@@ -1021,15 +1021,15 @@ static NTSTATUS open_mode_check(connection_struct *conn,
 	}
 
 	/* Now we check the share modes, after any oplock breaks. */
-	for(i = 0; i < lck->num_share_modes; i++) {
+	for(i = 0; i < lck->data->num_share_modes; i++) {
 
-		if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
+		if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
 			continue;
 		}
 
 		/* someone else has a share lock on it, check to see if we can
 		 * too */
-		if (share_conflict(&lck->share_modes[i],
+		if (share_conflict(&lck->data->share_modes[i],
 				   access_mask, share_access)) {
 			return NT_STATUS_SHARING_VIOLATION;
 		}
@@ -1115,43 +1115,43 @@ static void find_oplock_types(files_struct *fsp,
 		return;
 	}
 
-	for (i=0; i<lck->num_share_modes; i++) {
-		if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
+	for (i=0; i<lck->data->num_share_modes; i++) {
+		if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
 			continue;
 		}
 
-		if (lck->share_modes[i].op_type == NO_OPLOCK &&
-				is_stat_open(lck->share_modes[i].access_mask)) {
+		if (lck->data->share_modes[i].op_type == NO_OPLOCK &&
+				is_stat_open(lck->data->share_modes[i].access_mask)) {
 			/* We ignore stat opens in the table - they
 			   always have NO_OPLOCK and never get or
 			   cause breaks. JRA. */
 			continue;
 		}
 
-		if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
+		if (BATCH_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
 			/* batch - can only be one. */
 			if (*pp_ex_or_batch || *pp_batch || *got_level2 || *got_no_oplock) {
 				smb_panic("Bad batch oplock entry.");
 			}
-			*pp_batch = &lck->share_modes[i];
+			*pp_batch = &lck->data->share_modes[i];
 		}
 
-		if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
+		if (EXCLUSIVE_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
 			/* Exclusive or batch - can only be one. */
 			if (*pp_ex_or_batch || *got_level2 || *got_no_oplock) {
 				smb_panic("Bad exclusive or batch oplock entry.");
 			}
-			*pp_ex_or_batch = &lck->share_modes[i];
+			*pp_ex_or_batch = &lck->data->share_modes[i];
 		}
 
-		if (LEVEL_II_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
+		if (LEVEL_II_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
 			if (*pp_batch || *pp_ex_or_batch) {
 				smb_panic("Bad levelII oplock entry.");
 			}
 			*got_level2 = true;
 		}
 
-		if (lck->share_modes[i].op_type == NO_OPLOCK) {
+		if (lck->data->share_modes[i].op_type == NO_OPLOCK) {
 			if (*pp_batch || *pp_ex_or_batch) {
 				smb_panic("Bad no oplock entry.");
 			}
@@ -1296,8 +1296,8 @@ static void defer_open(struct share_mode_lock *lck,
 
 	/* Paranoia check */
 
-	for (i=0; i<lck->num_share_modes; i++) {
-		struct share_mode_entry *e = &lck->share_modes[i];
+	for (i=0; i<lck->data->num_share_modes; i++) {
+		struct share_mode_entry *e = &lck->data->share_modes[i];
 
 		if (is_deferred_open_entry(e) &&
 		    procid_is_me(&e->pid) &&
@@ -1465,7 +1465,7 @@ static void schedule_defer_open(struct share_mode_lock *lck,
 	   a 1 second delay for share mode conflicts. */
 
 	state.delayed_for_oplocks = True;
-	state.id = lck->id;
+	state.id = lck->data->id;
 
 	if (!request_timed_out(request_time, timeout)) {
 		defer_open(lck, request_time, timeout, req, &state);
diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index e1731f1e10..2197c7947f 100644
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -766,10 +766,10 @@ static void contend_level2_oplocks_begin_default(files_struct *fsp,
 	}
 
 	DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n", 
-		  lck->num_share_modes ));
+		  lck->data->num_share_modes ));
 
-	for(i = 0; i < lck->num_share_modes; i++) {
-		struct share_mode_entry *share_entry = &lck->share_modes[i];
+	for(i = 0; i < lck->data->num_share_modes; i++) {
+		struct share_mode_entry *share_entry = &lck->data->share_modes[i];
 		char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 
 		if (!is_valid_share_mode_entry(share_entry)) {
diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c
index b8da33549c..5b0f7cf6c8 100644
--- a/source3/smbd/reply.c
+++ b/source3/smbd/reply.c
@@ -5855,7 +5855,7 @@ static void rename_open_files(connection_struct *conn,
 	NTSTATUS status;
 	uint32_t new_name_hash = 0;
 
-	for(fsp = file_find_di_first(conn->sconn, lck->id); fsp;
+	for(fsp = file_find_di_first(conn->sconn, lck->data->id); fsp;
 	    fsp = file_find_di_next(fsp)) {
 		/* fsp_name is a relative path under the fsp. To change this for other
 		   sharepaths we need to manipulate relative paths. */
@@ -5881,7 +5881,7 @@ static void rename_open_files(connection_struct *conn,
 
 	if (!did_rename) {
 		DEBUG(10, ("rename_open_files: no open files on file_id %s "
-			   "for %s\n", file_id_string_tos(&lck->id),
+			   "for %s\n", file_id_string_tos(&lck->data->id),
 			   smb_fname_str_dbg(smb_fname_dst)));
 	}
 
diff --git a/source3/smbd/trans2.c b/source3/smbd/trans2.c
index 4e86fbfcdd..ba6bcbbb9e 100644
--- a/source3/smbd/trans2.c
+++ b/source3/smbd/trans2.c
@@ -7585,8 +7585,8 @@ static NTSTATUS smb_posix_unlink(connection_struct *conn,
 	 * don't delete. If all opens are POSIX delete we can set the delete
 	 * on close disposition.
 	 */
-	for (i=0; i<lck->num_share_modes; i++) {
-		struct share_mode_entry *e = &lck->share_modes[i];
+	for (i=0; i<lck->data->num_share_modes; i++) {
+		struct share_mode_entry *e = &lck->data->share_modes[i];
 		if (is_valid_share_mode_entry(e)) {
 			if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
 				continue;
diff --git a/source3/utils/status.c b/source3/utils/status.c
index 76f6167570..8ae8de76a3 100644
--- a/source3/utils/status.c
+++ b/source3/utils/status.c
@@ -212,11 +212,13 @@ static void print_brl(struct file_id id,
 
 	share_mode = fetch_share_mode_unlocked(NULL, id);
 	if (share_mode) {
-		bool has_stream = share_mode->stream_name != NULL;
+		bool has_stream = share_mode->data->stream_name != NULL;
 
-		fname = talloc_asprintf(NULL, "%s%s%s", share_mode->base_name,
+		fname = talloc_asprintf(NULL, "%s%s%s",
+					share_mode->data->base_name,
 					has_stream ? ":" : "",
-					has_stream ? share_mode->stream_name :
+					has_stream ?
+					share_mode->data->stream_name :
 					"");
 	} else {
 		fname = talloc_strdup(NULL, "");