source4/ntvfs/posix/pvfs_oplock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    POSIX NTVFS backend - oplock handling
   5
   6    Copyright (C) Stefan Metzmacher 2008
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "lib/messaging/messaging.h"
  24 #include "lib/messaging/irpc.h"
  25 #include "vfs_posix.h"
  26
  27
  28 struct pvfs_oplock {
  29         struct pvfs_file_handle *handle;
  30         struct pvfs_file *file;
  31         uint32_t level;
  32         struct messaging_context *msg_ctx;
  33 };
  34
  35 static NTSTATUS pvfs_oplock_release_internal(struct pvfs_file_handle *h,
  36                                              uint8_t oplock_break)
  37 {
  38         struct odb_lock *olck;
  39         NTSTATUS status;
  40
  41         if (h->fd == -1) {
  42                 return NT_STATUS_FILE_IS_A_DIRECTORY;
  43         }
  44
  45         if (!h->have_opendb_entry) {
  46                 return NT_STATUS_FOOBAR;
  47         }
  48
  49         if (!h->oplock) {
  50                 return NT_STATUS_FOOBAR;
  51         }
  52
  53         olck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
  54         if (olck == NULL) {
  55                 DEBUG(0,("Unable to lock opendb for oplock update\n"));
  56                 return NT_STATUS_FOOBAR;
  57         }
  58
  59         if (oplock_break == OPLOCK_BREAK_TO_NONE) {
  60                 h->oplock->level = OPLOCK_NONE;
  61         } else if (oplock_break == OPLOCK_BREAK_TO_LEVEL_II) {
  62                 h->oplock->level = OPLOCK_LEVEL_II;
  63         } else {
  64                 /* fallback to level II in case of a invalid value */
  65                 DEBUG(1,("unexpected oplock break level[0x%02X]\n", oplock_break));
  66                 h->oplock->level = OPLOCK_LEVEL_II;
  67         }
  68         status = odb_update_oplock(olck, h, h->oplock->level);
  69         if (!NT_STATUS_IS_OK(status)) {
  70                 DEBUG(0,("Unable to update oplock level for '%s' - %s\n",
  71                          h->name->full_name, nt_errstr(status)));
  72                 talloc_free(olck);
  73                 return status;
  74         }
  75
  76         talloc_free(olck);
  77
  78         /* after a break to none, we no longer have an oplock attached */
  79         if (h->oplock->level == OPLOCK_NONE) {
  80                 talloc_free(h->oplock);
  81                 h->oplock = NULL;
  82         }
  83
  84         return NT_STATUS_OK;
  85 }
  86
  87 /*
  88   receive oplock breaks and forward them to the client
  89 */
  90 static void pvfs_oplock_break(struct pvfs_oplock *opl, uint8_t level)
  91 {
  92         NTSTATUS status;
  93         struct pvfs_file *f = opl->file;
  94         struct pvfs_file_handle *h = opl->handle;
  95         struct pvfs_state *pvfs = h->pvfs;
  96
  97         DEBUG(10,("pvfs_oplock_break: sending oplock break level %d for '%s' %p\n",
  98                 level, h->name->original_name, h));
  99         status = ntvfs_send_oplock_break(pvfs->ntvfs, f->ntvfs, level);
 100         if (!NT_STATUS_IS_OK(status)) {
 101                 DEBUG(0,("pvfs_oplock_break: sending oplock break failed: %s\n",
 102                         nt_errstr(status)));
 103         }
 104 }
 105
 106 static void pvfs_oplock_break_dispatch(struct messaging_context *msg,
 107                                        void *private_data, uint32_t msg_type,
 108                                        struct server_id src, DATA_BLOB *data)
 109 {
 110         struct pvfs_oplock *opl = talloc_get_type(private_data,
 111                                                   struct pvfs_oplock);
 112         struct opendb_oplock_break opb;
 113
 114         ZERO_STRUCT(opb);
 115
 116         /* we need to check that this one is for us. See
 117            messaging_send_ptr() for the other side of this.
 118          */
 119         if (data->length == sizeof(struct opendb_oplock_break)) {
 120                 struct opendb_oplock_break *p;
 121                 p = (struct opendb_oplock_break *)data->data;
 122                 opb = *p;
 123         } else {
 124                 DEBUG(0,("%s: ignore oplock break with length[%u]\n",
 125                         __location__, data->length));
 126                 return;
 127         }
 128         if (opb.file_handle != opl->handle) {
 129                 return;
 130         }
 131
 132         /*
 133          * maybe we should use ntvfs_setup_async()
 134          */
 135         pvfs_oplock_break(opl, opb.level);
 136 }
 137
 138 static int pvfs_oplock_destructor(struct pvfs_oplock *opl)
 139 {
 140         messaging_deregister(opl->msg_ctx, MSG_NTVFS_OPLOCK_BREAK, opl);
 141         return 0;
 142 }
 143
 144 NTSTATUS pvfs_setup_oplock(struct pvfs_file *f, uint32_t oplock_granted)
 145 {
 146         NTSTATUS status;
 147         struct pvfs_oplock *opl;
 148         uint32_t level = OPLOCK_NONE;
 149
 150         f->handle->oplock = NULL;
 151
 152         switch (oplock_granted) {
 153         case EXCLUSIVE_OPLOCK_RETURN:
 154                 level = OPLOCK_EXCLUSIVE;
 155                 break;
 156         case BATCH_OPLOCK_RETURN:
 157                 level = OPLOCK_BATCH;
 158                 break;
 159         case LEVEL_II_OPLOCK_RETURN:
 160                 level = OPLOCK_LEVEL_II;
 161                 break;
 162         }
 163
 164         if (level == OPLOCK_NONE) {
 165                 return NT_STATUS_OK;
 166         }
 167
 168         opl = talloc(f->handle, struct pvfs_oplock);
 169         NT_STATUS_HAVE_NO_MEMORY(opl);
 170
 171         opl->handle     = f->handle;
 172         opl->file       = f;
 173         opl->level      = level;
 174         opl->msg_ctx    = f->pvfs->ntvfs->ctx->msg_ctx;
 175
 176         status = messaging_register(opl->msg_ctx,
 177                                     opl,
 178                                     MSG_NTVFS_OPLOCK_BREAK,
 179                                     pvfs_oplock_break_dispatch);
 180         NT_STATUS_NOT_OK_RETURN(status);
 181
 182         /* destructor */
 183         talloc_set_destructor(opl, pvfs_oplock_destructor);
 184
 185         f->handle->oplock = opl;
 186
 187         return NT_STATUS_OK;
 188 }
 189
 190 NTSTATUS pvfs_oplock_release(struct ntvfs_module_context *ntvfs,
 191                              struct ntvfs_request *req, union smb_lock *lck)
 192 {
 193         struct pvfs_state *pvfs = ntvfs->private_data;
 194         struct pvfs_file *f;
 195         uint8_t oplock_break;
 196         NTSTATUS status;
 197
 198         f = pvfs_find_fd(pvfs, req, lck->lockx.in.file.ntvfs);
 199         if (!f) {
 200                 return NT_STATUS_INVALID_HANDLE;
 201         }
 202
 203         oplock_break = (lck->lockx.in.mode >> 8) & 0xFF;
 204
 205         status = pvfs_oplock_release_internal(f->handle, oplock_break);
 206         if (!NT_STATUS_IS_OK(status)) {
 207                 DEBUG(0,("%s: failed to release the oplock[0x%02X]: %s\n",
 208                         __FUNCTION__, oplock_break, nt_errstr(status)));
 209                 return status;
 210         }
 211
 212         return NT_STATUS_OK;
 213 }
 214
 215 NTSTATUS pvfs_break_level2_oplocks(struct pvfs_file *f)
 216 {
 217         struct pvfs_file_handle *h = f->handle;
 218         struct odb_lock *olck;
 219         NTSTATUS status;
 220
 221         if (h->oplock && h->oplock->level != OPLOCK_LEVEL_II) {
 222                 return NT_STATUS_OK;
 223         }
 224
 225         olck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
 226         if (olck == NULL) {
 227                 DEBUG(0,("Unable to lock opendb for oplock update\n"));
 228                 return NT_STATUS_FOOBAR;
 229         }
 230
 231         status = odb_break_oplocks(olck);
 232         if (!NT_STATUS_IS_OK(status)) {
 233                 DEBUG(0,("Unable to break level2 oplocks to none for '%s' - %s\n",
 234                          h->name->full_name, nt_errstr(status)));
 235                 talloc_free(olck);
 236                 return status;
 237         }
 238
 239         talloc_free(olck);
 240
 241         return NT_STATUS_OK;
 242 }