From cfebba96bdab2097b6115f10b649ec6c23c72519 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Tue, 10 Jan 2012 13:56:37 +0100 Subject: s3: Put an indirection layer into share_mode_lock Signed-off-by: Jeremy Allison --- source3/include/smb.h | 4 + source3/librpc/idl/open_files.idl | 2 +- source3/locking/locking.c | 280 ++++++++++++++++++++------------------ source3/smbd/close.c | 20 +-- source3/smbd/open.c | 38 +++--- source3/smbd/oplock.c | 6 +- source3/smbd/reply.c | 4 +- source3/smbd/trans2.c | 4 +- source3/utils/status.c | 8 +- 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; inum_share_modes; i++) { - pids[i] = lck->share_modes[i].pid; + for (i=0; inum_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; inum_share_modes; i++) { - struct share_mode_entry *se = &lck->share_modes[i]; + for (i=0; inum_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; inum_share_modes; i++) { - struct share_mode_entry *e = &lck->share_modes[i]; + for (i=0; inum_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; inum_delete_tokens; i++) { - struct delete_token *dt = &lck->delete_tokens[i]; + for (i=0; inum_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; inum_delete_tokens; i++) { - struct delete_token *dt = &lck->delete_tokens[i]; + for (i=0; idata->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; inum_share_modes; i++) { - state->fn(&lck->share_modes[i], - lck->servicepath, lck->base_name, + for (i=0; inum_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; inum_share_modes; i++) { - if (is_deferred_open_entry(&lck->share_modes[i])) { + for (i=0; idata->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; inum_share_modes; i++) { - struct share_mode_entry *e = &lck->share_modes[i]; + for (i=0; idata->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; inum_share_modes; i++) { - struct share_mode_entry *e = &lck->share_modes[i]; + for (i=0; idata->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; inum_share_modes; i++) { - struct share_mode_entry *e = &lck->share_modes[i]; + for (i=0; idata->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; inum_share_modes; i++) { - if (!is_valid_share_mode_entry(&lck->share_modes[i])) { + for (i=0; idata->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; inum_share_modes; i++) { - struct share_mode_entry *e = &lck->share_modes[i]; + for (i=0; idata->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; inum_share_modes; i++) { - struct share_mode_entry *e = &lck->share_modes[i]; + for (i=0; idata->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, ""); -- cgit