opendb: force odb_can_open() before odb_open_file()
authorStefan Metzmacher <metze@samba.org>
Fri, 7 Mar 2008 17:23:34 +0000 (18:23 +0100)
committerStefan Metzmacher <metze@samba.org>
Fri, 7 Mar 2008 18:35:12 +0000 (19:35 +0100)
Now there's only odb_can_open() which handles the
share_access rules.

And odb_open_file() only adds the new opendb_entry into the
database and calculates the granted oplock level.

metze

source/cluster/ctdb/opendb_ctdb.c
source/ntvfs/common/opendb.c
source/ntvfs/common/opendb.h
source/ntvfs/common/opendb_tdb.c

index fe48f987601f3a04cb37e16b4d4656efc598de09..a7b8ddf7606ab5ca89bd6d7e95cb5acc9b09371e 100644 (file)
@@ -261,6 +261,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
        return NT_STATUS_OK;
 }
 
+#if 0
 /*
   send an oplock break to a client
 */
@@ -271,6 +272,7 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_ent
        return messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, e->server, 
                                  MSG_NTVFS_OPLOCK_BREAK, e->file_handle);
 }
+#endif
 
 /*
   register an open file in the open files database. This implements the share_access
@@ -281,104 +283,16 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_ent
 */
 static NTSTATUS odb_ctdb_open_file(struct odb_lock *lck,
                                   void *file_handle, const char *path,
-                                  uint32_t stream_id, uint32_t share_access,
-                                  uint32_t access_mask, bool delete_on_close,
-                                  uint32_t open_disposition, bool break_to_none,
                                   bool allow_level_II_oplock,
                                   uint32_t oplock_level, uint32_t *oplock_granted)
 
 {
-       struct odb_context *odb = lck->odb;
-       struct opendb_entry e;
-       int i;
-       struct opendb_file file;
-       NTSTATUS status;
-
-       if (odb->oplocks == false) {
-               oplock_level = OPLOCK_NONE;
-       }
-
-       status = odb_pull_record(lck, &file);
-       if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-               /* initialise a blank structure */
-               ZERO_STRUCT(file);
-               file.path = path;
-       } else {
-               NT_STATUS_NOT_OK_RETURN(status);
-       }
-
-       /* see if it conflicts */
-       e.server          = odb->ntvfs_ctx->server_id;
-       e.file_handle     = file_handle;
-       e.stream_id       = stream_id;
-       e.share_access    = share_access;
-       e.access_mask     = access_mask;
-       e.delete_on_close = delete_on_close;
-       e.oplock_level    = OPLOCK_NONE;
-               
-       /* see if anyone has an oplock, which we need to break */
-       for (i=0;i<file.num_entries;i++) {
-               if (file.entries[i].oplock_level == OPLOCK_BATCH) {
-                       /* a batch oplock caches close calls, which
-                          means the client application might have
-                          already closed the file. We have to allow
-                          this close to propogate by sending a oplock
-                          break request and suspending this call
-                          until the break is acknowledged or the file
-                          is closed */
-                       odb_oplock_break_send(odb, &file.entries[i]);
-                       return NT_STATUS_OPLOCK_NOT_GRANTED;
-               }
-       }
-
-       if (file.delete_on_close || 
-           (file.num_entries != 0 && delete_on_close)) {
-               /* while delete on close is set, no new opens are allowed */
-               return NT_STATUS_DELETE_PENDING;
-       }
-
-       /* check for sharing violations */
-       for (i=0;i<file.num_entries;i++) {
-               status = share_conflict(&file.entries[i], &e);
-               NT_STATUS_NOT_OK_RETURN(status);
-       }
-
-       /* we now know the open could succeed, but we need to check
-          for any exclusive oplocks. We can't grant a second open
-          till these are broken. Note that we check for batch oplocks
-          before checking for sharing violations, and check for
-          exclusive oplocks afterwards. */
-       for (i=0;i<file.num_entries;i++) {
-               if (file.entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
-                       odb_oplock_break_send(odb, &file.entries[i]);
-                       return NT_STATUS_OPLOCK_NOT_GRANTED;
-               }
-       }
-
        /*
-         possibly grant an exclusive or batch oplock if this is the only client
-         with the file open. We don't yet grant levelII oplocks.
-       */
-       if (oplock_granted != NULL) {
-               if ((oplock_level == OPLOCK_BATCH ||
-                    oplock_level == OPLOCK_EXCLUSIVE) &&
-                   file.num_entries == 0) {
-                       (*oplock_granted) = oplock_level;
-               } else {
-                       (*oplock_granted) = OPLOCK_NONE;
-               }
-               e.oplock_level = (*oplock_granted);
-       }
-
-       /* it doesn't conflict, so add it to the end */
-       file.entries = talloc_realloc(lck, file.entries, struct opendb_entry, 
-                                     file.num_entries+1);
-       NT_STATUS_HAVE_NO_MEMORY(file.entries);
-
-       file.entries[file.num_entries] = e;
-       file.num_entries++;
-
-       return odb_push_record(lck, &file);
+        * as this file will went away and isn't used yet,
+        * copy the implementation from the tdb backend
+        * --metze
+        */
+       return NT_STATUS_FOOBAR;
 }
 
 
index a7e5458aaf85d8c23702dff5b8660d5ade753f32..1cc077137cc150710eaaf43a62eadf580a4ccdba 100644 (file)
@@ -87,23 +87,21 @@ _PUBLIC_ DATA_BLOB odb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
 }
 
 /*
-  register an open file in the open files database. This implements the share_access
-  rules
+  register an open file in the open files database.
+  The share_access rules are implemented by odb_can_open()
+  and it's needed to call odb_can_open() before
+  odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
 
   Note that the path is only used by the delete on close logic, not
   for comparing with other filenames
 */
 _PUBLIC_ NTSTATUS odb_open_file(struct odb_lock *lck,
                                void *file_handle, const char *path,
-                               uint32_t stream_id, uint32_t share_access,
-                               uint32_t access_mask, bool delete_on_close,
-                               uint32_t open_disposition, bool break_to_none,
                                bool allow_level_II_oplock,
                                uint32_t oplock_level, uint32_t *oplock_granted)
 {
-       return ops->odb_open_file(lck, file_handle, path, stream_id, share_access,
-                                 access_mask, delete_on_close, open_disposition,
-                                 break_to_none, allow_level_II_oplock,
+       return ops->odb_open_file(lck, file_handle, path,
+                                 allow_level_II_oplock,
                                  oplock_level, oplock_granted);
 }
 
index 1c7f815dea41420d42193b7f2cd911f7768f3b6e..fb3223aea929fc24dabeda6e3a8673503472cb0a 100644 (file)
@@ -27,9 +27,6 @@ struct opendb_ops {
        DATA_BLOB (*odb_get_key)(TALLOC_CTX *mem_ctx, struct odb_lock *lck);
        NTSTATUS (*odb_open_file)(struct odb_lock *lck,
                                  void *file_handle, const char *path,
-                                 uint32_t stream_id, uint32_t share_access,
-                                 uint32_t access_mask, bool delete_on_close,
-                                 uint32_t open_disposition, bool break_to_none,
                                  bool allow_level_II_oplock,
                                  uint32_t oplock_level, uint32_t *oplock_granted);
        NTSTATUS (*odb_open_file_pending)(struct odb_lock *lck, void *private);
index 75424e65f65b501040633b03800a9c33dd4550ab..f71416ec83eefa73366a65f1ed9cd003a5194122 100644 (file)
@@ -63,6 +63,11 @@ struct odb_context {
 struct odb_lock {
        struct odb_context *odb;
        TDB_DATA key;
+
+       struct {
+               struct opendb_entry *e;
+               bool attrs_only;
+       } can_open;
 };
 
 /*
@@ -130,6 +135,8 @@ static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
                return NULL;
        }
 
+       ZERO_STRUCT(lck->can_open);
+
        talloc_set_destructor(lck, odb_lock_destructor);
        
        return lck;
@@ -411,30 +418,35 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
 }
 
 /*
-  register an open file in the open files database. This implements the share_access
-  rules
+  register an open file in the open files database.
+  The share_access rules are implemented by odb_can_open()
+  and it's needed to call odb_can_open() before
+  odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
 
   Note that the path is only used by the delete on close logic, not
   for comparing with other filenames
 */
 static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
                                  void *file_handle, const char *path,
-                                 uint32_t stream_id, uint32_t share_access,
-                                 uint32_t access_mask, bool delete_on_close,
-                                 uint32_t open_disposition, bool break_to_none,
                                  bool allow_level_II_oplock,
                                  uint32_t oplock_level, uint32_t *oplock_granted)
 {
        struct odb_context *odb = lck->odb;
-       struct opendb_entry e;
        struct opendb_file file;
        NTSTATUS status;
-       bool attrs_only = false;
+
+       if (!lck->can_open.e) {
+               return NT_STATUS_INTERNAL_ERROR;
+       }
 
        if (odb->oplocks == false) {
                oplock_level = OPLOCK_NONE;
        }
 
+       if (!oplock_granted) {
+               oplock_level = OPLOCK_NONE;
+       }
+
        status = odb_pull_record(lck, &file);
        if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
                /* initialise a blank structure */
@@ -444,67 +456,55 @@ static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
                NT_STATUS_NOT_OK_RETURN(status);
        }
 
-       /* see if it conflicts */
-       status = odb_tdb_open_can_internal(odb, &file, stream_id,
-                                          share_access, access_mask,
-                                          delete_on_close, open_disposition,
-                                          break_to_none, &attrs_only);
-       NT_STATUS_NOT_OK_RETURN(status);
-
-       /* see if it conflicts */
-       e.server                = odb->ntvfs_ctx->server_id;
-       e.file_handle           = file_handle;
-       e.stream_id             = stream_id;
-       e.share_access          = share_access;
-       e.access_mask           = access_mask;
-       e.delete_on_close       = delete_on_close;
-       e.allow_level_II_oplock = allow_level_II_oplock;
-       e.oplock_level          = OPLOCK_NONE;
-
        /*
          possibly grant an exclusive, batch or level2 oplock
        */
+       if (lck->can_open.attrs_only) {
+               oplock_level    = OPLOCK_NONE;
+       } else if (oplock_level == OPLOCK_EXCLUSIVE) {
+               if (file.num_entries == 0) {
+                       oplock_level    = OPLOCK_EXCLUSIVE;
+               } else if (allow_level_II_oplock) {
+                       oplock_level    = OPLOCK_LEVEL_II;
+               } else {
+                       oplock_level    = OPLOCK_NONE;
+               }
+       } else if (oplock_level == OPLOCK_BATCH) {
+               if (file.num_entries == 0) {
+                       oplock_level    = OPLOCK_BATCH;
+               } else if (allow_level_II_oplock) {
+                       oplock_level    = OPLOCK_LEVEL_II;
+               } else {
+                       oplock_level    = OPLOCK_NONE;
+               }
+       } else if (oplock_level == OPLOCK_LEVEL_II) {
+               oplock_level    = OPLOCK_LEVEL_II;
+       } else {
+               oplock_level    = OPLOCK_NONE;
+       }
+
        if (oplock_granted) {
-               if (attrs_only) {
-                       e.oplock_level  = OPLOCK_NONE;
-                       *oplock_granted = NO_OPLOCK_RETURN;
-               } else if (oplock_level == OPLOCK_EXCLUSIVE) {
-                       if (file.num_entries == 0) {
-                               e.oplock_level  = OPLOCK_EXCLUSIVE;
-                               *oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
-                       } else if (allow_level_II_oplock) {
-                               e.oplock_level  = OPLOCK_LEVEL_II;
-                               *oplock_granted = LEVEL_II_OPLOCK_RETURN;
-                       } else {
-                               e.oplock_level  = OPLOCK_NONE;
-                               *oplock_granted = NO_OPLOCK_RETURN;
-                       }
+               if (oplock_level == OPLOCK_EXCLUSIVE) {
+                       *oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
                } else if (oplock_level == OPLOCK_BATCH) {
-                       if (file.num_entries == 0) {
-                               e.oplock_level  = OPLOCK_BATCH;
-                               *oplock_granted = BATCH_OPLOCK_RETURN;
-                       } else if (allow_level_II_oplock) {
-                               e.oplock_level  = OPLOCK_LEVEL_II;
-                               *oplock_granted = LEVEL_II_OPLOCK_RETURN;
-                       } else {
-                               e.oplock_level  = OPLOCK_NONE;
-                               *oplock_granted = NO_OPLOCK_RETURN;
-                       }
+                       *oplock_granted = BATCH_OPLOCK_RETURN;
                } else if (oplock_level == OPLOCK_LEVEL_II) {
-                       e.oplock_level  = OPLOCK_LEVEL_II;
                        *oplock_granted = LEVEL_II_OPLOCK_RETURN;
                } else {
-                       e.oplock_level  = OPLOCK_NONE;
                        *oplock_granted = NO_OPLOCK_RETURN;
                }
        }
 
+       lck->can_open.e->file_handle            = file_handle;
+       lck->can_open.e->allow_level_II_oplock  = allow_level_II_oplock;
+       lck->can_open.e->oplock_level           = oplock_level;
+
        /* it doesn't conflict, so add it to the end */
        file.entries = talloc_realloc(lck, file.entries, struct opendb_entry, 
                                      file.num_entries+1);
        NT_STATUS_HAVE_NO_MEMORY(file.entries);
 
-       file.entries[file.num_entries] = e;
+       file.entries[file.num_entries] = *lck->can_open.e;
        file.num_entries++;
 
        return odb_push_record(lck, &file);
@@ -807,20 +807,32 @@ static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
        struct odb_context *odb = lck->odb;
        NTSTATUS status;
        struct opendb_file file;
-       bool attrs_only = false;
 
        status = odb_pull_record(lck, &file);
        if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-               return NT_STATUS_OK;
+               goto ok;
        }
        NT_STATUS_NOT_OK_RETURN(status);
 
        status = odb_tdb_open_can_internal(odb, &file, stream_id,
                                           share_access, access_mask,
                                           delete_on_close, open_disposition,
-                                          break_to_none, &attrs_only);
+                                          break_to_none, &lck->can_open.attrs_only);
        NT_STATUS_NOT_OK_RETURN(status);
 
+ok:
+       lck->can_open.e = talloc(lck, struct opendb_entry);
+       NT_STATUS_HAVE_NO_MEMORY(lck->can_open.e);
+
+       lck->can_open.e->server                 = odb->ntvfs_ctx->server_id;
+       lck->can_open.e->file_handle            = NULL;
+       lck->can_open.e->stream_id              = stream_id;
+       lck->can_open.e->share_access           = share_access;
+       lck->can_open.e->access_mask            = access_mask;
+       lck->can_open.e->delete_on_close        = delete_on_close;
+       lck->can_open.e->allow_level_II_oplock  = false;
+       lck->can_open.e->oplock_level           = OPLOCK_NONE;
+
        return NT_STATUS_OK;
 }