used. This allows us to provide the same semantics as NT */
#include "includes.h"
-#include "librpc/gen_ndr/messaging.h"
+#include "system/filesys.h"
+#include "locking/proto.h"
+#include "smbd/globals.h"
+#include "dbwrap.h"
+#include "serverid.h"
+#include "messages.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
static void print_lock_struct(unsigned int i, struct lock_struct *pls)
{
- DEBUG(10,("[%u]: smbpid = %u, tid = %u, pid = %s, ",
+ DEBUG(10,("[%u]: smblctx = %llu, tid = %u, pid = %s, ",
i,
- (unsigned int)pls->context.smbpid,
+ (unsigned long long)pls->context.smblctx,
(unsigned int)pls->context.tid,
procid_str(talloc_tos(), &pls->context.pid) ));
const struct lock_context *ctx2)
{
return (procid_equal(&ctx1->pid, &ctx2->pid) &&
- (ctx1->smbpid == ctx2->smbpid) &&
+ (ctx1->smblctx == ctx2->smblctx) &&
(ctx1->tid == ctx2->tid));
}
return;
}
- tdb_flags = TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST;
+ tdb_flags = TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH;
if (!lp_clustering()) {
/*
SMB_ASSERT(plock->lock_type != UNLOCK_LOCK);
- for (i=0; i < br_lck->num_locks; i++) {
- if (locks[i].start + locks[i].size < locks[i].start) {
- /* 64-bit wrap. Error. */
- return NT_STATUS_INVALID_LOCK_RANGE;
- }
+ if ((plock->start + plock->size - 1 < plock->start) &&
+ plock->size != 0) {
+ return NT_STATUS_INVALID_LOCK_RANGE;
+ }
+ for (i=0; i < br_lck->num_locks; i++) {
/* Do any Windows or POSIX locks conflict ? */
if (brl_conflict(&locks[i], plock)) {
/* Remember who blocked us. */
- plock->context.smbpid = locks[i].context.smbpid;
+ plock->context.smblctx = locks[i].context.smblctx;
return brl_lock_failed(fsp,plock,blocking_lock);
}
#if ZERO_ZERO
&errno_ret)) {
/* We don't know who blocked us. */
- plock->context.smbpid = 0xFFFFFFFF;
+ plock->context.smblctx = 0xFFFFFFFFFFFFFFFFLL;
if (errno_ret == EACCES || errno_ret == EAGAIN) {
status = NT_STATUS_FILE_LOCK_CONFLICT;
}
/* Don't allow 64-bit lock wrap. */
- if (plock->start + plock->size < plock->start ||
- plock->start + plock->size < plock->size) {
+ if (plock->start + plock->size - 1 < plock->start) {
return NT_STATUS_INVALID_PARAMETER;
}
/* No games with error messages. */
SAFE_FREE(tp);
/* Remember who blocked us. */
- plock->context.smbpid = curr_lock->context.smbpid;
+ plock->context.smblctx = curr_lock->context.smblctx;
return NT_STATUS_FILE_LOCK_CONFLICT;
}
/* Just copy the Windows lock into the new array. */
/* No games with error messages. */
SAFE_FREE(tp);
/* Remember who blocked us. */
- plock->context.smbpid = curr_lock->context.smbpid;
+ plock->context.smblctx = curr_lock->context.smblctx;
return NT_STATUS_FILE_LOCK_CONFLICT;
}
&errno_ret)) {
/* We don't know who blocked us. */
- plock->context.smbpid = 0xFFFFFFFF;
+ plock->context.smblctx = 0xFFFFFFFFFFFFFFFFLL;
if (errno_ret == EACCES || errno_ret == EAGAIN) {
SAFE_FREE(tp);
NTSTATUS brl_lock(struct messaging_context *msg_ctx,
struct byte_range_lock *br_lck,
- uint32 smbpid,
+ uint64_t smblctx,
struct server_id pid,
br_off start,
br_off size,
enum brl_type lock_type,
enum brl_flavour lock_flav,
bool blocking_lock,
- uint32 *psmbpid,
+ uint64_t *psmblctx,
struct blocking_lock_record *blr)
{
NTSTATUS ret;
memset(&lock, '\0', sizeof(lock));
#endif
- lock.context.smbpid = smbpid;
+ lock.context.smblctx = smblctx;
lock.context.pid = pid;
lock.context.tid = br_lck->fsp->conn->cnum;
lock.start = start;
#endif
/* If we're returning an error, return who blocked us. */
- if (!NT_STATUS_IS_OK(ret) && psmbpid) {
- *psmbpid = lock.context.smbpid;
+ if (!NT_STATUS_IS_OK(ret) && psmblctx) {
+ *psmblctx = lock.context.smblctx;
}
return ret;
}
for (i = 0; i < br_lck->num_locks; i++) {
struct lock_struct *lock = &locks[i];
+ if (IS_PENDING_LOCK(lock->lock_type)) {
+ continue;
+ }
+
/* Only remove our own locks that match in start, size, and flavour. */
if (brl_same_context(&lock->context, &plock->context) &&
lock->fnum == plock->fnum &&
bool brl_unlock(struct messaging_context *msg_ctx,
struct byte_range_lock *br_lck,
- uint32 smbpid,
+ uint64_t smblctx,
struct server_id pid,
br_off start,
br_off size,
{
struct lock_struct lock;
- lock.context.smbpid = smbpid;
+ lock.context.smblctx = smblctx;
lock.context.pid = pid;
lock.context.tid = br_lck->fsp->conn->cnum;
lock.start = start;
****************************************************************************/
bool brl_locktest(struct byte_range_lock *br_lck,
- uint32 smbpid,
+ uint64_t smblctx,
struct server_id pid,
br_off start,
br_off size,
const struct lock_struct *locks = br_lck->lock_data;
files_struct *fsp = br_lck->fsp;
- lock.context.smbpid = smbpid;
+ lock.context.smblctx = smblctx;
lock.context.pid = pid;
lock.context.tid = br_lck->fsp->conn->cnum;
lock.start = start;
****************************************************************************/
NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
- uint32 *psmbpid,
+ uint64_t *psmblctx,
struct server_id pid,
br_off *pstart,
br_off *psize,
const struct lock_struct *locks = br_lck->lock_data;
files_struct *fsp = br_lck->fsp;
- lock.context.smbpid = *psmbpid;
+ lock.context.smblctx = *psmblctx;
lock.context.pid = pid;
lock.context.tid = br_lck->fsp->conn->cnum;
lock.start = *pstart;
}
if (conflict) {
- *psmbpid = exlock->context.smbpid;
+ *psmblctx = exlock->context.smblctx;
*pstart = exlock->start;
*psize = exlock->size;
*plock_type = exlock->lock_type;
fsp->fnum, fsp_str_dbg(fsp)));
if (ret) {
- /* Hmmm. No clue what to set smbpid to - use -1. */
- *psmbpid = 0xFFFF;
+ /* Hmmm. No clue what to set smblctx to - use -1. */
+ *psmblctx = 0xFFFFFFFFFFFFFFFFLL;
return NT_STATUS_LOCK_NOT_GRANTED;
}
}
Remove a particular pending lock.
****************************************************************************/
bool brl_lock_cancel(struct byte_range_lock *br_lck,
- uint32 smbpid,
+ uint64_t smblctx,
struct server_id pid,
br_off start,
br_off size,
bool ret;
struct lock_struct lock;
- lock.context.smbpid = smbpid;
+ lock.context.smblctx = smblctx;
lock.context.pid = pid;
lock.context.tid = br_lck->fsp->conn->cnum;
lock.start = start;
unsigned int i, j, dcount=0;
int num_deleted_windows_locks = 0;
struct lock_struct *locks = br_lck->lock_data;
- struct server_id pid = procid_self();
+ struct server_id pid = sconn_server_id(fsp->conn->sconn);
bool unlock_individually = False;
bool posix_level2_contention_ended = false;
(lock->fnum == fnum)) {
brl_unlock(msg_ctx,
br_lck,
- lock->context.smbpid,
+ lock->context.smblctx,
pid,
lock->start,
lock->size,
num_valid_entries = 0;
for (i = 0; i < *pnum_entries; i++) {
struct lock_struct *lock_data = &locks[i];
- if (lock_data->context.smbpid &&
+ if (lock_data->context.smblctx &&
lock_data->context.tid) {
/* Valid (nonzero) entry - copy it. */
memcpy(&new_lock_data[num_valid_entries],
Unlock the record.
********************************************************************/
-static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
+static void byte_range_lock_flush(struct byte_range_lock *br_lck)
{
if (br_lck->read_only) {
SMB_ASSERT(!br_lck->modified);
done:
- SAFE_FREE(br_lck->lock_data);
+ br_lck->read_only = true;
+ br_lck->modified = false;
+
TALLOC_FREE(br_lck->record);
+}
+
+static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
+{
+ byte_range_lock_flush(br_lck);
+ SAFE_FREE(br_lck->lock_data);
return 0;
}
{
TDB_DATA key, data;
struct byte_range_lock *br_lck = TALLOC_P(mem_ctx, struct byte_range_lock);
+ bool do_read_only = read_only;
if (br_lck == NULL) {
return NULL;
if (!fsp->lockdb_clean) {
/* We must be read/write to clean
the dead entries. */
- read_only = False;
+ do_read_only = false;
}
- if (read_only) {
+ if (do_read_only) {
if (brlock_db->fetch(brlock_db, br_lck, key, &data) == -1) {
DEBUG(3, ("Could not fetch byte range lock record\n"));
TALLOC_FREE(br_lck);
return NULL;
}
br_lck->record = NULL;
- }
- else {
+ } else {
br_lck->record = brlock_db->fetch_locked(brlock_db, br_lck, key);
if (br_lck->record == NULL) {
data = br_lck->record->value;
}
- br_lck->read_only = read_only;
+ br_lck->read_only = do_read_only;
br_lck->lock_data = NULL;
talloc_set_destructor(br_lck, byte_range_lock_destructor);
print_lock_struct(i, &locks[i]);
}
}
+
+ if (do_read_only != read_only) {
+ /*
+ * this stores the record and gets rid of
+ * the write lock that is needed for a cleanup
+ */
+ byte_range_lock_flush(br_lck);
+ }
+
return br_lck;
}
TALLOC_FREE(fsp->brlock_rec);
- br_lock = brl_get_locks_internal(talloc_tos(), fsp, false);
+ br_lock = brl_get_locks_internal(talloc_tos(), fsp, true);
if (br_lock == NULL) {
return NULL;
}
fsp->brlock_seqnum = brlock_db->get_seqnum(brlock_db);
- fsp->brlock_rec = talloc_zero(fsp, struct byte_range_lock);
- if (fsp->brlock_rec == NULL) {
- goto fail;
- }
- fsp->brlock_rec->fsp = fsp;
- fsp->brlock_rec->num_locks = br_lock->num_locks;
- fsp->brlock_rec->read_only = true;
- fsp->brlock_rec->key = br_lock->key;
+ fsp->brlock_rec = talloc_move(fsp, &br_lock);
- fsp->brlock_rec->lock_data = (struct lock_struct *)
- talloc_memdup(fsp->brlock_rec, br_lock->lock_data,
- sizeof(struct lock_struct) * br_lock->num_locks);
- if (fsp->brlock_rec->lock_data == NULL) {
- goto fail;
- }
-
- TALLOC_FREE(br_lock);
return fsp->brlock_rec;
-fail:
- TALLOC_FREE(br_lock);
- TALLOC_FREE(fsp->brlock_rec);
- return NULL;
}
struct brl_revalidate_state {
static int compare_procids(const void *p1, const void *p2)
{
- const struct server_id *i1 = (struct server_id *)p1;
- const struct server_id *i2 = (struct server_id *)p2;
+ const struct server_id *i1 = (const struct server_id *)p1;
+ const struct server_id *i2 = (const struct server_id *)p2;
if (i1->pid < i2->pid) return -1;
if (i2->pid > i2->pid) return 1;
git.samba.org / amitay / samba.git / blobdiff