s3:locking: convert brl_have_read field to brl_num_read.

Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>
Reviewed-by: Stefan Metzmacher <metze@samba.org>

diff --git a/source3/locking/brlock.c b/source3/locking/brlock.c
index 0bed9f998fd7edb4e40e92139e89295711f058d6..6c73c725dd1028901eac176af08bccf450d9d649 100644 (file)
--- a/source3/locking/brlock.c
+++ b/source3/locking/brlock.c
@@ -47,7 +47,7 @@ struct byte_range_lock {
        struct files_struct *fsp;
        unsigned int num_locks;
        bool modified;
-       bool have_read_oplocks;
+       uint32_t num_read_oplocks;
        struct lock_struct *lock_data;
        struct db_record *record;
 };
@@ -82,18 +82,18 @@ struct files_struct *brl_fsp(struct byte_range_lock *brl)
        return brl->fsp;
 }
 
-bool brl_have_read_oplocks(const struct byte_range_lock *brl)
+uint32_t brl_num_read_oplocks(const struct byte_range_lock *brl)
 {
-       return brl->have_read_oplocks;
+       return brl->num_read_oplocks;
 }
 
-void brl_set_have_read_oplocks(struct byte_range_lock *brl,
-                              bool have_read_oplocks)
+void brl_set_num_read_oplocks(struct byte_range_lock *brl,
+                             uint32_t num_read_oplocks)
 {
-       DEBUG(10, ("Setting have_read_oplocks to %s\n",
-                  have_read_oplocks ? "true" : "false"));
+       DEBUG(10, ("Setting num_read_oplocks to %"PRIu32"\n",
+                  num_read_oplocks));
        SMB_ASSERT(brl->record != NULL); /* otherwise we're readonly */
-       brl->have_read_oplocks = have_read_oplocks;
+       brl->num_read_oplocks = num_read_oplocks;
        brl->modified = true;
 }
 
@@ -1850,7 +1850,6 @@ int brl_forall(void (*fn)(struct file_id id, struct server_id pid,
 
 static void byte_range_lock_flush(struct byte_range_lock *br_lck)
 {
-       size_t data_len;
        unsigned i;
        struct lock_struct *locks = br_lck->lock_data;
 
@@ -1874,15 +1873,7 @@ static void byte_range_lock_flush(struct byte_range_lock *br_lck)
                }
        }
 
-       data_len = br_lck->num_locks * sizeof(struct lock_struct);
-
-       if (br_lck->have_read_oplocks) {
-               data_len += 1;
-       }
-
-       DEBUG(10, ("data_len=%d\n", (int)data_len));
-
-       if (data_len == 0) {
+       if ((br_lck->num_locks == 0) && (br_lck->num_read_oplocks == 0)) {
                /* No locks - delete this entry. */
                NTSTATUS status = dbwrap_record_delete(br_lck->record);
                if (!NT_STATUS_IS_OK(status)) {
@@ -1891,19 +1882,20 @@ static void byte_range_lock_flush(struct byte_range_lock *br_lck)
                        smb_panic("Could not delete byte range lock entry");
                }
        } else {
+               size_t lock_len, data_len;
                TDB_DATA data;
                NTSTATUS status;
 
+               lock_len = br_lck->num_locks * sizeof(struct lock_struct);
+               data_len = lock_len + sizeof(br_lck->num_read_oplocks);
+
                data.dsize = data_len;
                data.dptr = talloc_array(talloc_tos(), uint8_t, data_len);
                SMB_ASSERT(data.dptr != NULL);
 
-               memcpy(data.dptr, br_lck->lock_data,
-                      br_lck->num_locks * sizeof(struct lock_struct));
-
-               if (br_lck->have_read_oplocks) {
-                       data.dptr[data_len-1] = 1;
-               }
+               memcpy(data.dptr, br_lck->lock_data, lock_len);
+               memcpy(data.dptr + lock_len, &br_lck->num_read_oplocks,
+                      sizeof(br_lck->num_read_oplocks));
 
                status = dbwrap_record_store(br_lck->record, data, TDB_REPLACE);
                TALLOC_FREE(data.dptr);
@@ -1926,6 +1918,32 @@ static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
        return 0;
 }
 
+static bool brl_parse_data(struct byte_range_lock *br_lck, TDB_DATA data)
+{
+       size_t data_len;
+
+       if (data.dsize == 0) {
+               return true;
+       }
+       if (data.dsize % sizeof(struct lock_struct) !=
+           sizeof(br_lck->num_read_oplocks)) {
+               DEBUG(1, ("Invalid data size: %u\n", (unsigned)data.dsize));
+               return false;
+       }
+
+       br_lck->num_locks = data.dsize / sizeof(struct lock_struct);
+       data_len = br_lck->num_locks * sizeof(struct lock_struct);
+
+       br_lck->lock_data = talloc_memdup(br_lck, data.dptr, data_len);
+       if (br_lck->lock_data == NULL) {
+               DEBUG(1, ("talloc_memdup failed\n"));
+               return false;
+       }
+       memcpy(&br_lck->num_read_oplocks, data.dptr + data_len,
+              sizeof(br_lck->num_read_oplocks));
+       return true;
+}
+
 /*******************************************************************
  Fetch a set of byte range lock data from the database.
  Leave the record locked.
@@ -1935,16 +1953,14 @@ static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
 struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx, files_struct *fsp)
 {
        TDB_DATA key, data;
-       struct byte_range_lock *br_lck = talloc(mem_ctx, struct byte_range_lock);
+       struct byte_range_lock *br_lck;
 
+       br_lck = talloc_zero(mem_ctx, struct byte_range_lock);
        if (br_lck == NULL) {
                return NULL;
        }
 
        br_lck->fsp = fsp;
-       br_lck->num_locks = 0;
-       br_lck->have_read_oplocks = false;
-       br_lck->modified = False;
 
        key.dptr = (uint8 *)&fsp->file_id;
        key.dsize = sizeof(struct file_id);
@@ -1959,30 +1975,12 @@ struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx, files_struct *fsp)
 
        data = dbwrap_record_get_value(br_lck->record);
 
-       br_lck->lock_data = NULL;
-
-       talloc_set_destructor(br_lck, byte_range_lock_destructor);
-
-       br_lck->num_locks = data.dsize / sizeof(struct lock_struct);
-
-       if (br_lck->num_locks != 0) {
-               br_lck->lock_data = talloc_array(
-                       br_lck, struct lock_struct, br_lck->num_locks);
-               if (br_lck->lock_data == NULL) {
-                       DEBUG(0, ("malloc failed\n"));
-                       TALLOC_FREE(br_lck);
-                       return NULL;
-               }
-
-               memcpy(br_lck->lock_data, data.dptr,
-                      talloc_get_size(br_lck->lock_data));
+       if (!brl_parse_data(br_lck, data)) {
+               TALLOC_FREE(br_lck);
+               return NULL;
        }
 
-       DEBUG(10, ("data.dsize=%d\n", (int)data.dsize));
-
-       if ((data.dsize % sizeof(struct lock_struct)) == 1) {
-               br_lck->have_read_oplocks = (data.dptr[data.dsize-1] == 1);
-       }
+       talloc_set_destructor(br_lck, byte_range_lock_destructor);
 
        if (DEBUGLEVEL >= 10) {
                unsigned int i;
@@ -2008,28 +2006,19 @@ static void brl_get_locks_readonly_parser(TDB_DATA key, TDB_DATA data,
 {
        struct brl_get_locks_readonly_state *state =
                (struct brl_get_locks_readonly_state *)private_data;
-       struct byte_range_lock *br_lock;
+       struct byte_range_lock *br_lck;
 
-       br_lock = talloc_pooled_object(
+       br_lck = talloc_pooled_object(
                state->mem_ctx, struct byte_range_lock, 1, data.dsize);
-       if (br_lock == NULL) {
+       if (br_lck == NULL) {
                *state->br_lock = NULL;
                return;
        }
-       br_lock->lock_data = (struct lock_struct *)talloc_memdup(
-               br_lock, data.dptr, data.dsize);
-       br_lock->num_locks = data.dsize / sizeof(struct lock_struct);
-
-       if ((data.dsize % sizeof(struct lock_struct)) == 1) {
-               br_lock->have_read_oplocks = (data.dptr[data.dsize-1] == 1);
-       } else {
-               br_lock->have_read_oplocks = false;
+       if (!brl_parse_data(br_lck, data)) {
+               *state->br_lock = NULL;
+               return;
        }
-
-       DEBUG(10, ("Got %d bytes, have_read_oplocks: %s\n", (int)data.dsize,
-                  br_lock->have_read_oplocks ? "true" : "false"));
-
-       *state->br_lock = br_lock;
+       *state->br_lock = br_lck;
 }
 
 struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp)
@@ -2072,7 +2061,7 @@ struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp)
                        return NULL;
                }
 
-               br_lock->have_read_oplocks = false;
+               br_lock->num_read_oplocks = 0;
                br_lock->num_locks = 0;
                br_lock->lock_data = NULL;
 

diff --git a/source3/locking/proto.h b/source3/locking/proto.h
index 44f3ba13e0839b9a56fd4215ac73567b3c5a11bf..8eccff8370bceb478d87970c44305ca593f11826 100644 (file)
--- a/source3/locking/proto.h
+++ b/source3/locking/proto.h
@@ -30,9 +30,9 @@ void brl_shutdown(void);
 
 unsigned int brl_num_locks(const struct byte_range_lock *brl);
 struct files_struct *brl_fsp(struct byte_range_lock *brl);
-bool brl_have_read_oplocks(const struct byte_range_lock *brl);
-void brl_set_have_read_oplocks(struct byte_range_lock *brl,
-                              bool have_read_oplocks);
+uint32_t brl_num_read_oplocks(const struct byte_range_lock *brl);
+void brl_set_num_read_oplocks(struct byte_range_lock *brl,
+                             uint32_t num_read_oplocks);
 
 NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
                struct lock_struct *plock,

diff --git a/source3/smbd/open.c b/source3/smbd/open.c
index 28ab434f909e6ffe0f0bb35ffb53506f7412747c..1952823d37fbb26e21c0fd52aec93140f21fa131 100644 (file)
--- a/source3/smbd/open.c
+++ b/source3/smbd/open.c
@@ -1573,17 +1573,10 @@ static NTSTATUS grant_fsp_oplock_type(struct smb_request *req,
                return NT_STATUS_NO_MEMORY;
        }
 
-       if (fsp->oplock_type == LEVEL_II_OPLOCK && !got_level2_oplock) {
-               /*
-                * We're the first level2 oplock. Indicate that in brlock.tdb.
-                */
-               struct byte_range_lock *brl;
-
-               brl = brl_get_locks(talloc_tos(), fsp);
-               if (brl != NULL) {
-                       brl_set_have_read_oplocks(brl, true);
-                       TALLOC_FREE(brl);
-               }
+       ok = update_num_read_oplocks(fsp, lck);
+       if (!ok) {
+               del_share_mode(lck, fsp);
+               return NT_STATUS_INTERNAL_ERROR;
        }
 
        DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",

diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index 79350923c323ad8ba2b6e6b5f08f4deb50373535..aa99f686ac468a4d5ea8ebd6e227686612e3ba56 100644 (file)
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -148,6 +148,53 @@ static void downgrade_file_oplock(files_struct *fsp)
        TALLOC_FREE(fsp->oplock_timeout);
 }
 
+bool update_num_read_oplocks(files_struct *fsp, struct share_mode_lock *lck)
+{
+       struct share_mode_data *d = lck->data;
+       struct byte_range_lock *br_lck;
+       uint32_t num_read_oplocks = 0;
+       uint32_t i;
+
+       if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
+               /*
+                * If we're the only one, we don't need a brlock entry
+                */
+               SMB_ASSERT(d->num_share_modes == 1);
+               SMB_ASSERT(EXCLUSIVE_OPLOCK_TYPE(d->share_modes[0].op_type));
+               return true;
+       }
+
+       for (i=0; i<d->num_share_modes; i++) {
+               struct share_mode_entry *e = &d->share_modes[i];
+
+               if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
+                       num_read_oplocks += 1;
+                       continue;
+               }
+
+               if (LEVEL_II_OPLOCK_TYPE(e->op_type)) {
+                       num_read_oplocks += 1;
+                       continue;
+               }
+       }
+
+       br_lck = brl_get_locks_readonly(fsp);
+       if (br_lck == NULL) {
+               return false;
+       }
+       if (brl_num_read_oplocks(br_lck) == num_read_oplocks) {
+               return true;
+       }
+
+       br_lck = brl_get_locks(talloc_tos(), fsp);
+       if (br_lck == NULL) {
+               return false;
+       }
+       brl_set_num_read_oplocks(br_lck, num_read_oplocks);
+       TALLOC_FREE(br_lck);
+       return true;
+}
+
 /****************************************************************************
  Remove a file oplock. Copes with level II and exclusive.
  Locks then unlocks the share mode lock. Client can decide to go directly
@@ -170,44 +217,6 @@ bool remove_oplock(files_struct *fsp)
                return False;
        }
 
-       if (fsp->oplock_type == LEVEL_II_OPLOCK) {
-
-               /*
-                * If we're the only LEVEL_II holder, we have to remove the
-                * have_read_oplocks from the brlock entry
-                */
-
-               struct share_mode_data *data = lck->data;
-               uint32_t i, num_level2;
-
-               num_level2 = 0;
-               for (i=0; i<data->num_share_modes; i++) {
-                       if (data->share_modes[i].op_type == LEVEL_II_OPLOCK) {
-                               num_level2 += 1;
-                       }
-                       if (num_level2 > 1) {
-                               /*
-                                * No need to count them all...
-                                */
-                               break;
-                       }
-               }
-
-               if (num_level2 == 1) {
-                       /*
-                        * That's only us. We are dropping that level2 oplock,
-                        * so remove the brlock flag.
-                        */
-                       struct byte_range_lock *brl;
-
-                       brl = brl_get_locks(talloc_tos(), fsp);
-                       if (brl) {
-                               brl_set_have_read_oplocks(brl, false);
-                               TALLOC_FREE(brl);
-                       }
-               }
-       }
-
        ret = remove_share_oplock(lck, fsp);
        if (!ret) {
                DEBUG(0,("remove_oplock: failed to remove share oplock for "
@@ -216,6 +225,15 @@ bool remove_oplock(files_struct *fsp)
                         file_id_string_tos(&fsp->file_id)));
        }
        release_file_oplock(fsp);
+
+       ret = update_num_read_oplocks(fsp, lck);
+       if (!ret) {
+               DEBUG(0, ("%s: update_num_read_oplocks failed for "
+                        "file %s, %s, %s\n",
+                         __func__, fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
+                        file_id_string_tos(&fsp->file_id)));
+       }
+
        TALLOC_FREE(lck);
        return ret;
 }
@@ -227,7 +245,6 @@ bool downgrade_oplock(files_struct *fsp)
 {
        bool ret;
        struct share_mode_lock *lck;
-       struct byte_range_lock *brl;
 
        DEBUG(10, ("downgrade_oplock called for %s\n",
                   fsp_str_dbg(fsp)));
@@ -245,13 +262,14 @@ bool downgrade_oplock(files_struct *fsp)
                         fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
                         file_id_string_tos(&fsp->file_id)));
        }
-
        downgrade_file_oplock(fsp);
 
-       brl = brl_get_locks(talloc_tos(), fsp);
-       if (brl != NULL) {
-               brl_set_have_read_oplocks(brl, true);
-               TALLOC_FREE(brl);
+       ret = update_num_read_oplocks(fsp, lck);
+       if (!ret) {
+               DEBUG(0, ("%s: update_num_read_oplocks failed for "
+                        "file %s, %s, %s\n",
+                         __func__, fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
+                        file_id_string_tos(&fsp->file_id)));
        }
 
        TALLOC_FREE(lck);
@@ -596,6 +614,7 @@ static void contend_level2_oplocks_begin_default(files_struct *fsp,
        struct tevent_immediate *im;
        struct break_to_none_state *state;
        struct byte_range_lock *brl;
+       uint32_t num_read_oplocks = 0;
 
        /*
         * If this file is level II oplocked then we need
@@ -613,7 +632,13 @@ static void contend_level2_oplocks_begin_default(files_struct *fsp,
        }
 
        brl = brl_get_locks_readonly(fsp);
-       if ((brl != NULL) && !brl_have_read_oplocks(brl)) {
+       if (brl != NULL) {
+               num_read_oplocks = brl_num_read_oplocks(brl);
+       }
+
+       DEBUG(10, ("num_read_oplocks = %"PRIu32"\n", num_read_oplocks));
+
+       if (num_read_oplocks == 0) {
                DEBUG(10, ("No read oplocks around\n"));
                return;
        }

diff --git a/source3/smbd/proto.h b/source3/smbd/proto.h
index 68c2da24bc1e4aa04656d726844365bc7cbcace2..1080895fddc2eb38d0c77c2fdd0f9896efafc7b5 100644 (file)
--- a/source3/smbd/proto.h
+++ b/source3/smbd/proto.h
@@ -647,6 +647,8 @@ NTSTATUS get_relative_fid_filename(connection_struct *conn,
 
 /* The following definitions come from smbd/oplock.c  */
 
+bool update_num_read_oplocks(files_struct *fsp, struct share_mode_lock *lck);
+
 void break_kernel_oplock(struct messaging_context *msg_ctx, files_struct *fsp);
 NTSTATUS set_file_oplock(files_struct *fsp);
 bool remove_oplock(files_struct *fsp);