source3/locking/share_mode_lock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Locking functions
   4    Copyright (C) Andrew Tridgell 1992-2000
   5    Copyright (C) Jeremy Allison 1992-2006
   6    Copyright (C) Volker Lendecke 2005
   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    Revision History:
  22
  23    12 aug 96: Erik.Devriendt@te6.siemens.be
  24    added support for shared memory implementation of share mode locking
  25
  26    May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
  27    locking to deal with multiple share modes per open file.
  28
  29    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
  30    support.
  31
  32    rewritten completely to use new tdb code. Tridge, Dec '99
  33
  34    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  35    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
  36 */
  37
  38 #include "includes.h"
  39 #include "lib/util/time_basic.h"
  40 #include "system/filesys.h"
  41 #include "lib/util/server_id.h"
  42 #include "share_mode_lock_private.h"
  43 struct share_mode_lock {
  44         struct file_id id;
  45         struct share_mode_data *cached_data;
  46 };
  47 #define SHARE_MODE_ENTRY_PREPARE_STATE_LCK_SPACE 1
  48 #include "share_mode_lock.h"
  49 #include "locking/proto.h"
  50 #include "smbd/globals.h"
  51 #include "dbwrap/dbwrap.h"
  52 #include "dbwrap/dbwrap_open.h"
  53 #include "dbwrap/dbwrap_private.h"
  54 #include "../libcli/security/security.h"
  55 #include "serverid.h"
  56 #include "messages.h"
  57 #include "util_tdb.h"
  58 #include "../librpc/gen_ndr/ndr_open_files.h"
  59 #include "source3/lib/dbwrap/dbwrap_watch.h"
  60 #include "locking/leases_db.h"
  61 #include "../lib/util/memcache.h"
  62 #include "lib/util/tevent_ntstatus.h"
  63 #include "g_lock.h"
  64 #include "smbd/fd_handle.h"
  65 #include "lib/global_contexts.h"
  66
  67 #undef DBGC_CLASS
  68 #define DBGC_CLASS DBGC_LOCKING
  69
  70 #define DBG_GET_SHARE_MODE_LOCK(__status, ...) \
  71         DBG_PREFIX( \
  72                 NT_STATUS_EQUAL(__status, NT_STATUS_NOT_FOUND) ? \
  73                 DBGLVL_DEBUG : DBGLVL_ERR, \
  74                 (__VA_ARGS__))
  75
  76 /* the locking database handle */
  77 static struct g_lock_ctx *lock_ctx;
  78 static struct g_lock_lock_cb_state *current_share_mode_glck = NULL;
  79
  80 static bool share_mode_g_lock_within_cb(TDB_DATA key);
  81
  82 static NTSTATUS share_mode_g_lock_dump(TDB_DATA key,
  83                                        void (*fn)(struct server_id exclusive,
  84                                                   size_t num_shared,
  85                                                   const struct server_id *shared,
  86                                                   const uint8_t *data,
  87                                                   size_t datalen,
  88                                                   void *private_data),
  89                                        void *private_data)
  90 {
  91         if (share_mode_g_lock_within_cb(key)) {
  92                 return g_lock_lock_cb_dump(current_share_mode_glck,
  93                                            fn, private_data);
  94         }
  95
  96         return g_lock_dump(lock_ctx, key, fn, private_data);
  97 }
  98
  99 static NTSTATUS share_mode_g_lock_writev(TDB_DATA key,
 100                                          const TDB_DATA *dbufs,
 101                                          size_t num_dbufs)
 102 {
 103         if (share_mode_g_lock_within_cb(key)) {
 104                 return g_lock_lock_cb_writev(current_share_mode_glck,
 105                                              dbufs, num_dbufs);
 106         }
 107
 108         return g_lock_writev_data(lock_ctx, key, dbufs, num_dbufs);
 109 }
 110
 111 static bool locking_init_internal(bool read_only)
 112 {
 113         struct db_context *backend;
 114         char *db_path;
 115
 116         brl_init(read_only);
 117
 118         if (lock_ctx != NULL) {
 119                 return True;
 120         }
 121
 122         db_path = lock_path(talloc_tos(), "locking.tdb");
 123         if (db_path == NULL) {
 124                 return false;
 125         }
 126
 127         backend = db_open(NULL, db_path,
 128                           SMBD_VOLATILE_TDB_HASH_SIZE,
 129                           SMBD_VOLATILE_TDB_FLAGS |
 130                           TDB_SEQNUM,
 131                           read_only?O_RDONLY:O_RDWR|O_CREAT, 0644,
 132                           DBWRAP_LOCK_ORDER_NONE,
 133                           DBWRAP_FLAG_NONE);
 134         TALLOC_FREE(db_path);
 135         if (!backend) {
 136                 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
 137                 return False;
 138         }
 139
 140         lock_ctx = g_lock_ctx_init_backend(
 141                 NULL, global_messaging_context(), &backend);
 142         if (lock_ctx == NULL) {
 143                 TALLOC_FREE(backend);
 144                 return false;
 145         }
 146         g_lock_set_lock_order(lock_ctx, DBWRAP_LOCK_ORDER_1);
 147
 148         if (!posix_locking_init(read_only)) {
 149                 TALLOC_FREE(lock_ctx);
 150                 return False;
 151         }
 152
 153         return True;
 154 }
 155
 156 bool locking_init(void)
 157 {
 158         return locking_init_internal(false);
 159 }
 160
 161 bool locking_init_readonly(void)
 162 {
 163         return locking_init_internal(true);
 164 }
 165
 166 /*******************************************************************
 167  Deinitialize the share_mode management.
 168 ******************************************************************/
 169
 170 bool locking_end(void)
 171 {
 172         brl_shutdown();
 173         TALLOC_FREE(lock_ctx);
 174         return true;
 175 }
 176
 177 /*******************************************************************
 178  Form a static locking key for a dev/inode pair.
 179 ******************************************************************/
 180
 181 static TDB_DATA locking_key(const struct file_id *id)
 182 {
 183         return make_tdb_data((const uint8_t *)id, sizeof(*id));
 184 }
 185
 186 /*******************************************************************
 187  Share mode cache utility functions that store/delete/retrieve
 188  entries from memcache.
 189
 190  For now share the statcache (global cache) memory space. If
 191  a lock record gets orphaned (which shouldn't happen as we're
 192  using the same locking_key data as lookup) it will eventually
 193  fall out of the cache via the normal LRU trim mechanism. If
 194  necessary we can always make this a separate (smaller) cache.
 195 ******************************************************************/
 196
 197 static DATA_BLOB memcache_key(const struct file_id *id)
 198 {
 199         return data_blob_const((const void *)id, sizeof(*id));
 200 }
 201
 202 static void share_mode_memcache_store(struct share_mode_data *d)
 203 {
 204         const DATA_BLOB key = memcache_key(&d->id);
 205         struct file_id_buf idbuf;
 206
 207         DBG_DEBUG("stored entry for file %s epoch %"PRIx64" key %s\n",
 208                   d->base_name,
 209                   d->unique_content_epoch,
 210                   file_id_str_buf(d->id, &idbuf));
 211
 212         /* Ensure everything stored in the cache is pristine. */
 213         SMB_ASSERT(!d->modified);
 214         SMB_ASSERT(!d->not_stored);
 215
 216         /*
 217          * Ensure the memory going into the cache
 218          * doesn't have a destructor so it can be
 219          * cleanly evicted by the memcache LRU
 220          * mechanism.
 221          */
 222         talloc_set_destructor(d, NULL);
 223
 224         /* Cache will own d after this call. */
 225         memcache_add_talloc(NULL,
 226                         SHARE_MODE_LOCK_CACHE,
 227                         key,
 228                         &d);
 229 }
 230
 231 /*
 232  * NB. We use ndr_pull_hyper on a stack-created
 233  * struct ndr_pull with no talloc allowed, as we
 234  * need this to be really fast as an ndr-peek into
 235  * the first 10 bytes of the blob.
 236  */
 237
 238 static enum ndr_err_code get_share_mode_blob_header(
 239         const uint8_t *buf, size_t buflen, uint64_t *pepoch, uint16_t *pflags)
 240 {
 241         struct ndr_pull ndr = {
 242                 .data = discard_const_p(uint8_t, buf),
 243                 .data_size = buflen,
 244         };
 245         NDR_CHECK(ndr_pull_hyper(&ndr, NDR_SCALARS, pepoch));
 246         NDR_CHECK(ndr_pull_uint16(&ndr, NDR_SCALARS, pflags));
 247         return NDR_ERR_SUCCESS;
 248 }
 249
 250 static int share_mode_data_nofree_destructor(struct share_mode_data *d)
 251 {
 252         return -1;
 253 }
 254
 255 static struct share_mode_data *share_mode_memcache_fetch(
 256         TALLOC_CTX *mem_ctx,
 257         struct file_id id,
 258         const uint8_t *buf,
 259         size_t buflen)
 260 {
 261         const DATA_BLOB key = memcache_key(&id);
 262         enum ndr_err_code ndr_err;
 263         struct share_mode_data *d;
 264         uint64_t unique_content_epoch;
 265         uint16_t flags;
 266         void *ptr;
 267         struct file_id_buf idbuf;
 268
 269         ptr = memcache_lookup_talloc(NULL,
 270                         SHARE_MODE_LOCK_CACHE,
 271                         key);
 272         if (ptr == NULL) {
 273                 DBG_DEBUG("failed to find entry for key %s\n",
 274                           file_id_str_buf(id, &idbuf));
 275                 return NULL;
 276         }
 277         /* sequence number key is at start of blob. */
 278         ndr_err = get_share_mode_blob_header(
 279                 buf, buflen, &unique_content_epoch, &flags);
 280         if (ndr_err != NDR_ERR_SUCCESS) {
 281                 /* Bad blob. Remove entry. */
 282                 DBG_DEBUG("bad blob %u key %s\n",
 283                           (unsigned int)ndr_err,
 284                           file_id_str_buf(id, &idbuf));
 285                 memcache_delete(NULL,
 286                         SHARE_MODE_LOCK_CACHE,
 287                         key);
 288                 return NULL;
 289         }
 290
 291         d = (struct share_mode_data *)ptr;
 292         if (d->unique_content_epoch != unique_content_epoch) {
 293                 DBG_DEBUG("epoch changed (cached %"PRIx64") (new %"PRIx64") "
 294                           "for key %s\n",
 295                           d->unique_content_epoch,
 296                           unique_content_epoch,
 297                           file_id_str_buf(id, &idbuf));
 298                 /* Cache out of date. Remove entry. */
 299                 memcache_delete(NULL,
 300                         SHARE_MODE_LOCK_CACHE,
 301                         key);
 302                 return NULL;
 303         }
 304
 305         /* Move onto mem_ctx. */
 306         d = talloc_move(mem_ctx, &ptr);
 307
 308         /*
 309          * Now we own d, prevent the cache from freeing it
 310          * when we delete the entry.
 311          */
 312         talloc_set_destructor(d, share_mode_data_nofree_destructor);
 313
 314         /* Remove from the cache. We own it now. */
 315         memcache_delete(NULL,
 316                         SHARE_MODE_LOCK_CACHE,
 317                         key);
 318
 319         /* And reset the destructor to none. */
 320         talloc_set_destructor(d, NULL);
 321
 322         DBG_DEBUG("fetched entry for file %s epoch %"PRIx64" key %s\n",
 323                   d->base_name,
 324                   d->unique_content_epoch,
 325                   file_id_str_buf(id, &idbuf));
 326
 327         return d;
 328 }
 329
 330 /*
 331  * 132 is the sizeof an ndr-encoded struct share_mode_entry_buf.
 332  * Reading/writing entries will immediately error out if this
 333  * size differs (push/pull is done without allocs).
 334  */
 335
 336 struct share_mode_entry_buf {
 337         uint8_t buf[132];
 338 };
 339 #define SHARE_MODE_ENTRY_SIZE (sizeof(struct share_mode_entry_buf))
 340
 341 static bool share_mode_entry_put(
 342         const struct share_mode_entry *e,
 343         struct share_mode_entry_buf *dst)
 344 {
 345         DATA_BLOB blob = { .data = dst->buf, .length = sizeof(dst->buf) };
 346         enum ndr_err_code ndr_err;
 347
 348         if (DEBUGLEVEL>=10) {
 349                 DBG_DEBUG("share_mode_entry:\n");
 350                 NDR_PRINT_DEBUG(share_mode_entry, discard_const_p(void, e));
 351         }
 352
 353         ndr_err = ndr_push_struct_into_fixed_blob(
 354                 &blob,
 355                 e,
 356                 (ndr_push_flags_fn_t)ndr_push_share_mode_entry);
 357         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 358                 DBG_WARNING("ndr_push_share_mode_entry failed: %s\n",
 359                             ndr_errstr(ndr_err));
 360                 return false;
 361         }
 362
 363         return true;
 364 }
 365
 366 static bool share_mode_entry_get(
 367         const uint8_t ptr[SHARE_MODE_ENTRY_SIZE], struct share_mode_entry *e)
 368 {
 369         enum ndr_err_code ndr_err = NDR_ERR_SUCCESS;
 370         DATA_BLOB blob = {
 371                 .data = discard_const_p(uint8_t, ptr),
 372                 .length = SHARE_MODE_ENTRY_SIZE,
 373         };
 374
 375         ndr_err = ndr_pull_struct_blob_all_noalloc(
 376                 &blob, e, (ndr_pull_flags_fn_t)ndr_pull_share_mode_entry);
 377         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 378                 DBG_WARNING("ndr_pull_share_mode_entry failed\n");
 379                 return false;
 380         }
 381         return true;
 382 }
 383
 384 /*
 385  * locking.tdb records consist of
 386  *
 387  * uint32_t share_mode_data_len
 388  * uint8_t [share_mode_data]       This is struct share_mode_data in NDR
 389  *
 390  * 0 [SHARE_MODE_ENTRY_SIZE]       Sorted array of share modes,
 391  * 1 [SHARE_MODE_ENTRY_SIZE]       filling up the rest of the data in the
 392  * 2 [SHARE_MODE_ENTRY_SIZE]       g_lock.c maintained record in locking.tdb
 393  */
 394
 395 struct locking_tdb_data {
 396         const uint8_t *share_mode_data_buf;
 397         size_t share_mode_data_len;
 398         const uint8_t *share_entries;
 399         size_t num_share_entries;
 400 };
 401
 402 static bool locking_tdb_data_get(
 403         struct locking_tdb_data *data, const uint8_t *buf, size_t buflen)
 404 {
 405         uint32_t share_mode_data_len, share_entries_len;
 406
 407         if (buflen == 0) {
 408                 *data = (struct locking_tdb_data) { 0 };
 409                 return true;
 410         }
 411         if (buflen < sizeof(uint32_t)) {
 412                 return false;
 413         }
 414
 415         share_mode_data_len = PULL_LE_U32(buf, 0);
 416
 417         buf += sizeof(uint32_t);
 418         buflen -= sizeof(uint32_t);
 419
 420         if (buflen < share_mode_data_len) {
 421                 return false;
 422         }
 423
 424         share_entries_len = buflen - share_mode_data_len;
 425
 426         if ((share_entries_len % SHARE_MODE_ENTRY_SIZE) != 0) {
 427                 return false;
 428         }
 429
 430         *data = (struct locking_tdb_data) {
 431                 .share_mode_data_buf = buf,
 432                 .share_mode_data_len = share_mode_data_len,
 433                 .share_entries = buf + share_mode_data_len,
 434                 .num_share_entries = share_entries_len / SHARE_MODE_ENTRY_SIZE,
 435         };
 436
 437         return true;
 438 }
 439
 440 struct locking_tdb_data_fetch_state {
 441         TALLOC_CTX *mem_ctx;
 442         uint8_t *data;
 443         size_t datalen;
 444 };
 445
 446 static void locking_tdb_data_fetch_fn(
 447         struct server_id exclusive,
 448         size_t num_shared,
 449         const struct server_id *shared,
 450         const uint8_t *data,
 451         size_t datalen,
 452         void *private_data)
 453 {
 454         struct locking_tdb_data_fetch_state *state = private_data;
 455         state->datalen = datalen;
 456         state->data = talloc_memdup(state->mem_ctx, data, datalen);
 457 }
 458
 459 static NTSTATUS locking_tdb_data_fetch(
 460         TDB_DATA key, TALLOC_CTX *mem_ctx, struct locking_tdb_data **ltdb)
 461 {
 462         struct locking_tdb_data_fetch_state state = { 0 };
 463         struct locking_tdb_data *result = NULL;
 464         NTSTATUS status;
 465         bool ok;
 466
 467         result = talloc_zero(mem_ctx, struct locking_tdb_data);
 468         if (result == NULL) {
 469                 return NT_STATUS_NO_MEMORY;
 470         }
 471         state.mem_ctx = result;
 472
 473         status = share_mode_g_lock_dump(key, locking_tdb_data_fetch_fn, &state);
 474         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
 475                 /*
 476                  * Just return an empty record
 477                  */
 478                 goto done;
 479         }
 480         if (!NT_STATUS_IS_OK(status)) {
 481                 DBG_ERR("share_mode_g_lock_dump failed: %s\n",
 482                         nt_errstr(status));
 483                 return status;
 484         }
 485         if (state.datalen == 0) {
 486                 goto done;
 487         }
 488
 489         ok = locking_tdb_data_get(result, state.data, state.datalen);
 490         if (!ok) {
 491                 DBG_ERR("locking_tdb_data_get failed for %zu bytes\n",
 492                           state.datalen);
 493                 TALLOC_FREE(result);
 494                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 495         }
 496
 497 done:
 498         *ltdb = result;
 499         return NT_STATUS_OK;
 500 }
 501
 502 static NTSTATUS locking_tdb_data_store(
 503         TDB_DATA key,
 504         const struct locking_tdb_data *ltdb,
 505         const TDB_DATA *share_mode_dbufs,
 506         size_t num_share_mode_dbufs)
 507 {
 508         uint8_t share_mode_data_len_buf[4];
 509         TDB_DATA dbufs[num_share_mode_dbufs+3];
 510         NTSTATUS status;
 511
 512         if ((ltdb->share_mode_data_len == 0) &&
 513             (ltdb->num_share_entries == 0) &&
 514             (num_share_mode_dbufs == 0)) {
 515                 /*
 516                  * Nothing to write
 517                  */
 518                 status = share_mode_g_lock_writev(key, NULL, 0);
 519                 if (!NT_STATUS_IS_OK(status)) {
 520                         DBG_ERR("share_mode_g_lock_writev(NULL) failed: %s\n",
 521                                 nt_errstr(status));
 522                 }
 523                 return status;
 524         }
 525
 526         PUSH_LE_U32(share_mode_data_len_buf, 0, ltdb->share_mode_data_len);
 527
 528         dbufs[0] = (TDB_DATA) {
 529                 .dptr = share_mode_data_len_buf,
 530                 .dsize = sizeof(share_mode_data_len_buf),
 531         };
 532         dbufs[1] = (TDB_DATA) {
 533                 .dptr = discard_const_p(uint8_t, ltdb->share_mode_data_buf),
 534                 .dsize = ltdb->share_mode_data_len,
 535         };
 536
 537         if (ltdb->num_share_entries > SIZE_MAX/SHARE_MODE_ENTRY_SIZE) {
 538                 /* overflow */
 539                 return NT_STATUS_BUFFER_OVERFLOW;
 540         }
 541         dbufs[2] = (TDB_DATA) {
 542                 .dptr = discard_const_p(uint8_t, ltdb->share_entries),
 543                 .dsize = ltdb->num_share_entries * SHARE_MODE_ENTRY_SIZE,
 544         };
 545
 546         if (num_share_mode_dbufs != 0) {
 547                 memcpy(&dbufs[3],
 548                        share_mode_dbufs,
 549                        num_share_mode_dbufs * sizeof(TDB_DATA));
 550         }
 551
 552         status = share_mode_g_lock_writev(key, dbufs, ARRAY_SIZE(dbufs));
 553         if (!NT_STATUS_IS_OK(status)) {
 554                 DBG_ERR("share_mode_g_lock_writev() failed: %s\n",
 555                         nt_errstr(status));
 556         }
 557         return status;
 558 }
 559
 560 /*******************************************************************
 561  Get all share mode entries for a dev/inode pair.
 562 ********************************************************************/
 563
 564 static struct share_mode_data *parse_share_modes(
 565         TALLOC_CTX *mem_ctx,
 566         struct file_id id,
 567         const uint8_t *buf,
 568         size_t buflen)
 569 {
 570         struct share_mode_data *d;
 571         enum ndr_err_code ndr_err;
 572         DATA_BLOB blob;
 573
 574         /* See if we already have a cached copy of this key. */
 575         d = share_mode_memcache_fetch(mem_ctx, id, buf, buflen);
 576         if (d != NULL) {
 577                 return d;
 578         }
 579
 580         d = talloc(mem_ctx, struct share_mode_data);
 581         if (d == NULL) {
 582                 DEBUG(0, ("talloc failed\n"));
 583                 goto fail;
 584         }
 585
 586         blob = (DATA_BLOB) {
 587                 .data = discard_const_p(uint8_t, buf),
 588                 .length = buflen,
 589         };
 590         ndr_err = ndr_pull_struct_blob_all(
 591                 &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
 592         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 593                 DBG_WARNING("ndr_pull_share_mode_data failed: %s\n",
 594                             ndr_errstr(ndr_err));
 595                 goto fail;
 596         }
 597
 598         if (DEBUGLEVEL >= 10) {
 599                 DEBUG(10, ("parse_share_modes:\n"));
 600                 NDR_PRINT_DEBUG(share_mode_data, d);
 601         }
 602
 603         return d;
 604 fail:
 605         TALLOC_FREE(d);
 606         return NULL;
 607 }
 608
 609 static NTSTATUS share_mode_data_ltdb_store(struct share_mode_data *d,
 610                                            TDB_DATA key,
 611                                            struct locking_tdb_data *ltdb,
 612                                            const TDB_DATA *share_mode_dbufs,
 613                                            size_t num_share_mode_dbufs)
 614 {
 615         DATA_BLOB blob = { 0 };
 616         NTSTATUS status;
 617
 618         if (!d->modified) {
 619                 DBG_DEBUG("share_mode_data not modified\n");
 620                 goto store;
 621         }
 622
 623         d->unique_content_epoch = generate_unique_u64(d->unique_content_epoch);
 624
 625         if (DEBUGLEVEL >= 10) {
 626                 DBG_DEBUG("\n");
 627                 NDR_PRINT_DEBUG(share_mode_data, d);
 628         }
 629
 630         if (ltdb->num_share_entries != 0 || num_share_mode_dbufs != 0) {
 631                 enum ndr_err_code ndr_err;
 632
 633                 ndr_err = ndr_push_struct_blob(
 634                         &blob,
 635                         ltdb,
 636                         d,
 637                         (ndr_push_flags_fn_t)ndr_push_share_mode_data);
 638                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 639                         DBG_ERR("ndr_push_share_mode_data failed: %s\n",
 640                                   ndr_errstr(ndr_err));
 641                         return ndr_map_error2ntstatus(ndr_err);
 642                 }
 643         }
 644
 645         ltdb->share_mode_data_buf = blob.data;
 646         ltdb->share_mode_data_len = blob.length;
 647
 648 store:
 649         status = locking_tdb_data_store(key,
 650                                         ltdb,
 651                                         share_mode_dbufs,
 652                                         num_share_mode_dbufs);
 653         if (!NT_STATUS_IS_OK(status)) {
 654                 DBG_ERR("locking_tdb_data_store failed: %s\n",
 655                         nt_errstr(status));
 656                 return status;
 657         }
 658
 659         d->modified = false;
 660         d->not_stored = (ltdb->share_mode_data_len == 0);
 661
 662         return NT_STATUS_OK;
 663 }
 664
 665 /*******************************************************************
 666  If modified, store the share_mode_data back into the database.
 667 ********************************************************************/
 668
 669 static NTSTATUS share_mode_data_store(struct share_mode_data *d)
 670 {
 671         TDB_DATA key = locking_key(&d->id);
 672         struct locking_tdb_data *ltdb = NULL;
 673         NTSTATUS status;
 674
 675         if (!d->modified) {
 676                 DBG_DEBUG("not modified\n");
 677                 return NT_STATUS_OK;
 678         }
 679
 680         if (DEBUGLEVEL >= 10) {
 681                 DBG_DEBUG("\n");
 682                 NDR_PRINT_DEBUG(share_mode_data, d);
 683         }
 684
 685         status = locking_tdb_data_fetch(key, d, &ltdb);
 686         if (!NT_STATUS_IS_OK(status)) {
 687                 DBG_ERR("locking_tdb_data_fetch failed: %s\n",
 688                         nt_errstr(status));
 689                 return status;
 690         }
 691
 692         status = share_mode_data_ltdb_store(d, key, ltdb, NULL, 0);
 693         TALLOC_FREE(ltdb);
 694         if (!NT_STATUS_IS_OK(status)) {
 695                 DBG_ERR("share_mode_data_ltdb_store failed: %s\n",
 696                         nt_errstr(status));
 697                 return status;
 698         }
 699
 700         return NT_STATUS_OK;
 701 }
 702
 703 /*******************************************************************
 704  Allocate a new share_mode_data struct, mark it unmodified.
 705  fresh is set to note that currently there is no database entry.
 706 ********************************************************************/
 707
 708 static struct share_mode_data *fresh_share_mode_lock(
 709         TALLOC_CTX *mem_ctx, const char *servicepath,
 710         const struct smb_filename *smb_fname,
 711         const struct timespec *old_write_time)
 712 {
 713         struct share_mode_data *d;
 714
 715         if ((servicepath == NULL) || (smb_fname == NULL) ||
 716             (old_write_time == NULL)) {
 717                 return NULL;
 718         }
 719
 720         d = talloc_zero(mem_ctx, struct share_mode_data);
 721         if (d == NULL) {
 722                 goto fail;
 723         }
 724         d->unique_content_epoch = generate_unique_u64(0);
 725
 726         d->base_name = talloc_strdup(d, smb_fname->base_name);
 727         if (d->base_name == NULL) {
 728                 goto fail;
 729         }
 730         if (smb_fname->stream_name != NULL) {
 731                 d->stream_name = talloc_strdup(d, smb_fname->stream_name);
 732                 if (d->stream_name == NULL) {
 733                         goto fail;
 734                 }
 735         }
 736         d->servicepath = talloc_strdup(d, servicepath);
 737         if (d->servicepath == NULL) {
 738                 goto fail;
 739         }
 740         d->old_write_time = full_timespec_to_nt_time(old_write_time);
 741         d->flags = SHARE_MODE_SHARE_DELETE |
 742                 SHARE_MODE_SHARE_WRITE |
 743                 SHARE_MODE_SHARE_READ;
 744         d->modified = false;
 745         d->not_stored = true;
 746         return d;
 747 fail:
 748         DEBUG(0, ("talloc failed\n"));
 749         TALLOC_FREE(d);
 750         return NULL;
 751 }
 752
 753 /*
 754  * Key that's locked with g_lock
 755  */
 756 static struct file_id share_mode_lock_key_id = {};
 757 static TDB_DATA share_mode_lock_key = {
 758         .dptr = (uint8_t *)&share_mode_lock_key_id,
 759         .dsize = sizeof(share_mode_lock_key_id),
 760 };
 761 static size_t share_mode_lock_key_refcount = 0;
 762
 763 static bool share_mode_g_lock_within_cb(TDB_DATA key)
 764 {
 765         int cmp;
 766
 767         if (current_share_mode_glck == NULL) {
 768                 return false;
 769         }
 770
 771         cmp = tdb_data_cmp(share_mode_lock_key, key);
 772         if (cmp != 0) {
 773                 struct file_id_buf existing;
 774
 775                 DBG_ERR("Can not lock two share modes "
 776                         "simultaneously: existing %s requested %s\n",
 777                         file_id_str_buf(share_mode_lock_key_id, &existing),
 778                         tdb_data_dbg(key));
 779                 smb_panic(__location__);
 780                 return false;
 781         }
 782
 783         return true;
 784 }
 785
 786 /*
 787  * We can only ever have one share mode locked. Use a static
 788  * share_mode_data pointer that is shared by multiple nested
 789  * share_mode_lock structures, explicitly refcounted.
 790  */
 791 static struct share_mode_data *static_share_mode_data = NULL;
 792
 793 /*******************************************************************
 794  Either fetch a share mode from the database, or allocate a fresh
 795  one if the record doesn't exist.
 796 ********************************************************************/
 797
 798 struct get_static_share_mode_data_state {
 799         TALLOC_CTX *mem_ctx;
 800         struct file_id id;
 801         const char *servicepath;
 802         const struct smb_filename *smb_fname;
 803         const struct timespec *old_write_time;
 804         NTSTATUS status;
 805 };
 806
 807 static void get_static_share_mode_data_fn(
 808         struct server_id exclusive,
 809         size_t num_shared,
 810         const struct server_id *shared,
 811         const uint8_t *data,
 812         size_t datalen,
 813         void *private_data)
 814 {
 815         struct get_static_share_mode_data_state *state = private_data;
 816         struct share_mode_data *d = NULL;
 817         struct locking_tdb_data ltdb = { 0 };
 818
 819         if (datalen != 0) {
 820                 bool ok;
 821
 822                 ok = locking_tdb_data_get(&ltdb, data, datalen);
 823                 if (!ok) {
 824                         DBG_ERR("locking_tdb_data_get failed\n");
 825                         state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 826                         return;
 827                 }
 828         }
 829
 830         if (ltdb.share_mode_data_len == 0) {
 831                 if (state->smb_fname == NULL) {
 832                         state->status = NT_STATUS_NOT_FOUND;
 833                         return;
 834                 }
 835                 d = fresh_share_mode_lock(
 836                         state->mem_ctx,
 837                         state->servicepath,
 838                         state->smb_fname,
 839                         state->old_write_time);
 840                 if (d == NULL) {
 841                         state->status = NT_STATUS_NO_MEMORY;
 842                         return;
 843                 }
 844         } else {
 845                 d = parse_share_modes(
 846                         lock_ctx,
 847                         state->id,
 848                         ltdb.share_mode_data_buf,
 849                         ltdb.share_mode_data_len);
 850                 if (d == NULL) {
 851                         state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 852                         return;
 853                 }
 854         }
 855
 856         d->id = state->id;
 857         static_share_mode_data = d;
 858 }
 859
 860 static NTSTATUS get_static_share_mode_data(
 861         struct file_id id,
 862         const char *servicepath,
 863         const struct smb_filename *smb_fname,
 864         const struct timespec *old_write_time)
 865 {
 866         struct get_static_share_mode_data_state state = {
 867                 .mem_ctx = lock_ctx,
 868                 .id = id,
 869                 .servicepath = servicepath,
 870                 .smb_fname = smb_fname,
 871                 .old_write_time = old_write_time,
 872         };
 873         NTSTATUS status;
 874
 875         SMB_ASSERT(static_share_mode_data == NULL);
 876
 877         status = share_mode_g_lock_dump(
 878                 share_mode_lock_key,
 879                 get_static_share_mode_data_fn,
 880                 &state);
 881         if (!NT_STATUS_IS_OK(status)) {
 882                 DBG_GET_SHARE_MODE_LOCK(status,
 883                         "share_mode_g_lock_dump failed: %s\n",
 884                         nt_errstr(status));
 885                 return status;
 886         }
 887         if (!NT_STATUS_IS_OK(state.status)) {
 888                 DBG_GET_SHARE_MODE_LOCK(state.status,
 889                         "get_static_share_mode_data_fn failed: %s\n",
 890                         nt_errstr(state.status));
 891                 return state.status;
 892         }
 893
 894         return NT_STATUS_OK;
 895 }
 896
 897 struct file_id share_mode_lock_file_id(const struct share_mode_lock *lck)
 898 {
 899         return lck->id;
 900 }
 901
 902 NTSTATUS share_mode_lock_access_private_data(struct share_mode_lock *lck,
 903                                              struct share_mode_data **data)
 904 {
 905         /*
 906          * For now we always have lck->cached_data,
 907          * but we may change that in future.
 908          */
 909         SMB_ASSERT(lck->cached_data != NULL);
 910         *data = lck->cached_data;
 911         return NT_STATUS_OK;
 912 }
 913
 914 /*******************************************************************
 915  Get a share_mode_lock, Reference counted to allow nested calls.
 916 ********************************************************************/
 917
 918 static int share_mode_lock_destructor(struct share_mode_lock *lck);
 919
 920 static bool share_mode_lock_skip_g_lock;
 921
 922 static NTSTATUS get_share_mode_lock_internal(
 923         struct file_id id,
 924         const char *servicepath,
 925         const struct smb_filename *smb_fname,
 926         const struct timespec *old_write_time,
 927         struct share_mode_lock *lck)
 928 {
 929         NTSTATUS status;
 930
 931         *lck = (struct share_mode_lock) {
 932                 .id = id,
 933         };
 934
 935         if (share_mode_lock_key_refcount == 0) {
 936                 if (!share_mode_lock_skip_g_lock) {
 937                         TDB_DATA key = locking_key(&id);
 938
 939                         status = g_lock_lock(
 940                                 lock_ctx,
 941                                 key,
 942                                 G_LOCK_WRITE,
 943                                 (struct timeval) { .tv_sec = 3600 },
 944                                 NULL, NULL);
 945                         if (!NT_STATUS_IS_OK(status)) {
 946                                 DBG_DEBUG("g_lock_lock failed: %s\n",
 947                                           nt_errstr(status));
 948                                 return status;
 949                         }
 950                 }
 951                 share_mode_lock_key_id = id;
 952         }
 953
 954         if (!file_id_equal(&share_mode_lock_key_id, &id)) {
 955                 struct file_id_buf existing;
 956                 struct file_id_buf requested;
 957
 958                 DBG_ERR("Can not lock two share modes "
 959                         "simultaneously: existing %s requested %s\n",
 960                         file_id_str_buf(share_mode_lock_key_id, &existing),
 961                         file_id_str_buf(id, &requested));
 962                 smb_panic(__location__);
 963                 goto fail;
 964         }
 965
 966         SMB_ASSERT(share_mode_lock_key_refcount < SIZE_MAX);
 967         share_mode_lock_key_refcount += 1;
 968
 969         if (static_share_mode_data != NULL) {
 970                 goto done;
 971         }
 972
 973         status = get_static_share_mode_data(
 974                 id,
 975                 servicepath,
 976                 smb_fname,
 977                 old_write_time);
 978         if (!NT_STATUS_IS_OK(status)) {
 979                 DBG_DEBUG("get_static_share_mode_data failed: %s\n",
 980                           nt_errstr(status));
 981                 share_mode_lock_key_refcount -= 1;
 982                 goto fail;
 983         }
 984 done:
 985         lck->cached_data = static_share_mode_data;
 986
 987         if (CHECK_DEBUGLVL(DBGLVL_DEBUG)) {
 988                 struct file_id_buf returned;
 989
 990                 DBG_DEBUG("Returning %s (data_cached=%u key_refcount=%zu)\n",
 991                           file_id_str_buf(id, &returned),
 992                           static_share_mode_data != NULL,
 993                           share_mode_lock_key_refcount);
 994         }
 995
 996         return NT_STATUS_OK;
 997 fail:
 998         if (share_mode_lock_key_refcount == 0) {
 999                 if (!share_mode_lock_skip_g_lock) {
1000                         NTSTATUS ulstatus = g_lock_unlock(lock_ctx, share_mode_lock_key);
1001                         if (!NT_STATUS_IS_OK(ulstatus)) {
1002                                 DBG_ERR("g_lock_unlock failed: %s\n",
1003                                         nt_errstr(ulstatus));
1004                         }
1005                 }
1006         }
1007         return status;
1008 }
1009
1010 static NTSTATUS put_share_mode_lock_internal(struct share_mode_lock *lck)
1011 {
1012         NTSTATUS status;
1013
1014         SMB_ASSERT(share_mode_lock_key_refcount > 0);
1015         share_mode_lock_key_refcount -= 1;
1016
1017         if (share_mode_lock_key_refcount > 0) {
1018                 return NT_STATUS_OK;
1019         }
1020
1021         status = share_mode_data_store(static_share_mode_data);
1022         if (!NT_STATUS_IS_OK(status)) {
1023                 DBG_ERR("share_mode_data_store failed: %s\n",
1024                         nt_errstr(status));
1025                 return status;
1026         }
1027
1028         if (!share_mode_lock_skip_g_lock) {
1029                 status = g_lock_unlock(lock_ctx, share_mode_lock_key);
1030                 if (!NT_STATUS_IS_OK(status)) {
1031                         DBG_ERR("g_lock_unlock failed: %s\n",
1032                                 nt_errstr(status));
1033                         return status;
1034                 }
1035         }
1036
1037         if (!static_share_mode_data->not_stored) {
1038                 /*
1039                  * This is worth keeping. Without share modes,
1040                  * share_mode_data_store above has left nothing in the
1041                  * database.
1042                  */
1043                 share_mode_memcache_store(static_share_mode_data);
1044                 static_share_mode_data = NULL;
1045         }
1046
1047         TALLOC_FREE(static_share_mode_data);
1048         return NT_STATUS_OK;
1049 }
1050
1051 static int share_mode_lock_destructor(struct share_mode_lock *lck)
1052 {
1053         NTSTATUS status;
1054
1055         status = put_share_mode_lock_internal(lck);
1056         if (!NT_STATUS_IS_OK(status)) {
1057                 DBG_ERR("put_share_mode_lock_internal failed: %s\n",
1058                         nt_errstr(status));
1059                 smb_panic("put_share_mode_lock_internal failed\n");
1060         }
1061
1062         return 0;
1063 }
1064
1065 /*******************************************************************
1066  Fetch a share mode where we know one MUST exist. This call reference
1067  counts it internally to allow for nested lock fetches.
1068 ********************************************************************/
1069
1070 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
1071                                                      const struct file_id id)
1072 {
1073         struct share_mode_lock *lck = NULL;
1074         NTSTATUS status;
1075
1076         lck = talloc(mem_ctx, struct share_mode_lock);
1077         if (lck == NULL) {
1078                 return NULL;
1079         }
1080
1081         status = get_share_mode_lock_internal(id,
1082                                               NULL, /* servicepath */
1083                                               NULL, /* smb_fname */
1084                                               NULL, /* old_write_time */
1085                                               lck);
1086         if (!NT_STATUS_IS_OK(status)) {
1087                 DBG_GET_SHARE_MODE_LOCK(status,
1088                         "get_share_mode_lock_internal() failed - %s\n",
1089                         nt_errstr(status));
1090                 TALLOC_FREE(lck);
1091                 return NULL;
1092         }
1093
1094         talloc_set_destructor(lck, share_mode_lock_destructor);
1095         return lck;
1096 }
1097
1098 static void share_mode_wakeup_waiters_fn(
1099         struct share_mode_lock *lck,
1100         void *private_data)
1101 {
1102         if (share_mode_g_lock_within_cb(share_mode_lock_key)) {
1103                 g_lock_lock_cb_wake_watchers(current_share_mode_glck);
1104                 return;
1105         }
1106
1107         g_lock_wake_watchers(lock_ctx, share_mode_lock_key);
1108 }
1109
1110 NTSTATUS share_mode_wakeup_waiters(struct file_id id)
1111 {
1112         return share_mode_do_locked_vfs_denied(id,
1113                                                share_mode_wakeup_waiters_fn,
1114                                                NULL);
1115 }
1116
1117 struct fsp_update_share_mode_flags_state {
1118         struct files_struct *fsp;
1119         enum ndr_err_code ndr_err;
1120         uint64_t share_mode_epoch;
1121         uint16_t share_mode_flags;
1122 };
1123
1124 static void fsp_update_share_mode_flags_fn(
1125         struct server_id exclusive,
1126         size_t num_shared,
1127         const struct server_id *shared,
1128         const uint8_t *data,
1129         size_t datalen,
1130         void *private_data)
1131 {
1132         struct fsp_update_share_mode_flags_state *state = private_data;
1133         struct locking_tdb_data ltdb = { 0 };
1134
1135         if (datalen != 0) {
1136                 bool ok = locking_tdb_data_get(&ltdb, data, datalen);
1137                 if (!ok) {
1138                         DBG_DEBUG("locking_tdb_data_get failed\n");
1139                         return;
1140                 }
1141         }
1142
1143         if (ltdb.share_mode_data_len == 0) {
1144                 /* Likely a ctdb tombstone record, ignore it */
1145                 return;
1146         }
1147
1148         if (exclusive.pid != 0) {
1149                 struct server_id self =
1150                         messaging_server_id(state->fsp->conn->sconn->msg_ctx);
1151                 bool is_self = server_id_equal(&self, &exclusive);
1152
1153                 if (!is_self) {
1154                         /*
1155                          * If someone else is holding an exclusive
1156                          * lock, pretend there's a read lease
1157                          */
1158                         state->share_mode_flags = SHARE_MODE_LEASE_READ;
1159                         return;
1160                 }
1161         }
1162
1163         state->ndr_err = get_share_mode_blob_header(ltdb.share_mode_data_buf,
1164                                                     ltdb.share_mode_data_len,
1165                                                     &state->share_mode_epoch,
1166                                                     &state->share_mode_flags);
1167 }
1168
1169 static NTSTATUS fsp_update_share_mode_flags(struct files_struct *fsp)
1170 {
1171         struct fsp_update_share_mode_flags_state state = { .fsp = fsp, };
1172         int seqnum = g_lock_seqnum(lock_ctx);
1173         TDB_DATA key = {0};
1174         NTSTATUS status;
1175
1176         if (seqnum == fsp->share_mode_flags_seqnum) {
1177                 return NT_STATUS_OK;
1178         }
1179
1180         key = locking_key(&fsp->file_id);
1181         status = share_mode_g_lock_dump(key,
1182                              fsp_update_share_mode_flags_fn,
1183                              &state);
1184         if (!NT_STATUS_IS_OK(status)) {
1185                 /* no DBG_GET_SHARE_MODE_LOCK here! */
1186                 DBG_ERR("share_mode_g_lock_dump returned %s\n",
1187                         nt_errstr(status));
1188                 return status;
1189         }
1190
1191         if (!NDR_ERR_CODE_IS_SUCCESS(state.ndr_err)) {
1192                 DBG_ERR("get_share_mode_blob_header returned %s\n",
1193                         ndr_errstr(state.ndr_err));
1194                 return ndr_map_error2ntstatus(state.ndr_err);
1195         }
1196
1197         fsp->share_mode_flags_seqnum = seqnum;
1198         fsp->share_mode_flags = state.share_mode_flags;
1199
1200         return NT_STATUS_OK;
1201 }
1202
1203 bool file_has_read_lease(struct files_struct *fsp)
1204 {
1205         NTSTATUS status;
1206
1207         status = fsp_update_share_mode_flags(fsp);
1208         if (!NT_STATUS_IS_OK(status)) {
1209                 /* Safe default for leases */
1210                 return true;
1211         }
1212
1213         return (fsp->share_mode_flags & SHARE_MODE_LEASE_READ) != 0;
1214 }
1215
1216 #define share_mode_lock_assert_private_data(__lck) \
1217         _share_mode_lock_assert_private_data(__lck, __func__, __location__)
1218 static struct share_mode_data *_share_mode_lock_assert_private_data(
1219                                         struct share_mode_lock *lck,
1220                                         const char *caller_function,
1221                                         const char *caller_location)
1222 {
1223         struct share_mode_data *d = NULL;
1224         NTSTATUS status;
1225
1226         status = share_mode_lock_access_private_data(lck, &d);
1227         if (!NT_STATUS_IS_OK(status)) {
1228                 struct file_id id = share_mode_lock_file_id(lck);
1229                 struct file_id_buf id_buf;
1230                 /* Any error recovery possible here ? */
1231                 D_ERR("%s:%s(): share_mode_lock_access_private_data() "
1232                       "failed for id=%s - %s\n",
1233                       caller_location, caller_function,
1234                       file_id_str_buf(id, &id_buf),
1235                       nt_errstr(status));
1236                 smb_panic(caller_location);
1237                 return NULL;
1238         }
1239
1240         return d;
1241 }
1242
1243 NTTIME share_mode_changed_write_time(struct share_mode_lock *lck)
1244 {
1245         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1246         return d->changed_write_time;
1247 }
1248
1249 void share_mode_set_changed_write_time(struct share_mode_lock *lck, struct timespec write_time)
1250 {
1251         struct file_id fileid = share_mode_lock_file_id(lck);
1252         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1253         struct file_id_buf ftmp;
1254         struct timeval_buf tbuf;
1255         NTTIME nt = full_timespec_to_nt_time(&write_time);
1256
1257         DBG_INFO("%s id=%s\n",
1258                  timespec_string_buf(&write_time, true, &tbuf),
1259                  file_id_str_buf(fileid, &ftmp));
1260
1261         if (d->changed_write_time != nt) {
1262                 d->modified = true;
1263                 d->changed_write_time = nt;
1264         }
1265 }
1266
1267 void share_mode_set_old_write_time(struct share_mode_lock *lck, struct timespec write_time)
1268 {
1269         struct file_id fileid = share_mode_lock_file_id(lck);
1270         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1271         struct file_id_buf ftmp;
1272         struct timeval_buf tbuf;
1273         NTTIME nt = full_timespec_to_nt_time(&write_time);
1274
1275         DBG_INFO("%s id=%s\n",
1276                  timespec_string_buf(&write_time, true, &tbuf),
1277                  file_id_str_buf(fileid, &ftmp));
1278
1279         if (d->changed_write_time != nt) {
1280                 d->modified = true;
1281                 d->old_write_time = nt;
1282         }
1283 }
1284
1285 const char *share_mode_servicepath(struct share_mode_lock *lck)
1286 {
1287         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1288         return d->servicepath;
1289 }
1290
1291 char *share_mode_filename(TALLOC_CTX *mem_ctx, struct share_mode_lock *lck)
1292 {
1293         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1294         bool has_stream = (d->stream_name != NULL);
1295         char *fname = NULL;
1296
1297         fname = talloc_asprintf(
1298                 mem_ctx,
1299                 "%s%s%s",
1300                 d->base_name,
1301                 has_stream ? ":" : "",
1302                 has_stream ? d->stream_name : "");
1303         return fname;
1304 }
1305
1306 char *share_mode_data_dump(
1307         TALLOC_CTX *mem_ctx, struct share_mode_lock *lck)
1308 {
1309         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1310         struct ndr_print *p = talloc(mem_ctx, struct ndr_print);
1311         char *ret = NULL;
1312
1313         if (p == NULL) {
1314                 return NULL;
1315         }
1316
1317         *p = (struct ndr_print) {
1318                 .print = ndr_print_string_helper,
1319                 .depth = 1,
1320                 .private_data = talloc_strdup(mem_ctx, ""),
1321         };
1322
1323         if (p->private_data == NULL) {
1324                 TALLOC_FREE(p);
1325                 return NULL;
1326         }
1327
1328         ndr_print_share_mode_data(p, "SHARE_MODE_DATA", d);
1329
1330         ret = p->private_data;
1331
1332         TALLOC_FREE(p);
1333
1334         return ret;
1335 }
1336
1337 void share_mode_flags_get(
1338         struct share_mode_lock *lck,
1339         uint32_t *access_mask,
1340         uint32_t *share_mode,
1341         uint32_t *lease_type)
1342 {
1343         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1344         uint16_t flags = d->flags;
1345
1346         if (access_mask != NULL) {
1347                 *access_mask =
1348                         ((flags & SHARE_MODE_ACCESS_READ) ?
1349                          FILE_READ_DATA : 0) |
1350                         ((flags & SHARE_MODE_ACCESS_WRITE) ?
1351                          FILE_WRITE_DATA : 0) |
1352                         ((flags & SHARE_MODE_ACCESS_DELETE) ?
1353                          DELETE_ACCESS : 0);
1354         }
1355         if (share_mode != NULL) {
1356                 *share_mode =
1357                         ((flags & SHARE_MODE_SHARE_READ) ?
1358                          FILE_SHARE_READ : 0) |
1359                         ((flags & SHARE_MODE_SHARE_WRITE) ?
1360                          FILE_SHARE_WRITE : 0) |
1361                         ((flags & SHARE_MODE_SHARE_DELETE) ?
1362                          FILE_SHARE_DELETE : 0);
1363         }
1364         if (lease_type != NULL) {
1365                 *lease_type =
1366                         ((flags & SHARE_MODE_LEASE_READ) ?
1367                          SMB2_LEASE_READ : 0) |
1368                         ((flags & SHARE_MODE_LEASE_WRITE) ?
1369                          SMB2_LEASE_WRITE : 0) |
1370                         ((flags & SHARE_MODE_LEASE_HANDLE) ?
1371                          SMB2_LEASE_HANDLE : 0);
1372         }
1373 }
1374
1375 void share_mode_flags_set(
1376         struct share_mode_lock *lck,
1377         uint32_t access_mask,
1378         uint32_t share_mode,
1379         uint32_t lease_type,
1380         bool *modified)
1381 {
1382         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1383         uint16_t flags = 0;
1384
1385         flags |= (access_mask & (FILE_READ_DATA | FILE_EXECUTE)) ?
1386                 SHARE_MODE_ACCESS_READ : 0;
1387         flags |= (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
1388                 SHARE_MODE_ACCESS_WRITE : 0;
1389         flags |= (access_mask & (DELETE_ACCESS)) ?
1390                 SHARE_MODE_ACCESS_DELETE : 0;
1391
1392         flags |= (share_mode & FILE_SHARE_READ) ?
1393                 SHARE_MODE_SHARE_READ : 0;
1394         flags |= (share_mode & FILE_SHARE_WRITE) ?
1395                 SHARE_MODE_SHARE_WRITE : 0;
1396         flags |= (share_mode & FILE_SHARE_DELETE) ?
1397                 SHARE_MODE_SHARE_DELETE : 0;
1398
1399         flags |= (lease_type & SMB2_LEASE_READ) ?
1400                 SHARE_MODE_LEASE_READ : 0;
1401         flags |= (lease_type & SMB2_LEASE_WRITE) ?
1402                 SHARE_MODE_LEASE_WRITE : 0;
1403         flags |= (lease_type & SMB2_LEASE_HANDLE) ?
1404                 SHARE_MODE_LEASE_HANDLE : 0;
1405
1406         if (d->flags == flags) {
1407                 return;
1408         }
1409
1410         if (modified != NULL) {
1411                 *modified = true;
1412         }
1413         d->flags = flags;
1414         d->modified = true;
1415 }
1416
1417 struct share_mode_watch_state {
1418         bool blockerdead;
1419         struct server_id blocker;
1420         bool within_cb;
1421 };
1422
1423 static void share_mode_watch_done(struct tevent_req *subreq);
1424
1425 struct tevent_req *share_mode_watch_send(
1426         TALLOC_CTX *mem_ctx,
1427         struct tevent_context *ev,
1428         struct share_mode_lock *lck,
1429         struct server_id blocker)
1430 {
1431         struct file_id id = share_mode_lock_file_id(lck);
1432         TDB_DATA key = locking_key(&id);
1433         struct tevent_req *req = NULL, *subreq = NULL;
1434         struct share_mode_watch_state *state = NULL;
1435
1436         req = tevent_req_create(
1437                 mem_ctx, &state, struct share_mode_watch_state);
1438         if (req == NULL) {
1439                 return NULL;
1440         }
1441
1442         if (share_mode_g_lock_within_cb(key)) {
1443                 state->within_cb = true;
1444                 subreq = g_lock_lock_cb_watch_data_send(state, ev,
1445                                                         current_share_mode_glck,
1446                                                         blocker);
1447                 if (tevent_req_nomem(subreq, req)) {
1448                         return tevent_req_post(req, ev);
1449                 }
1450         } else {
1451                 subreq = g_lock_watch_data_send(state, ev, lock_ctx, key, blocker);
1452                 if (tevent_req_nomem(subreq, req)) {
1453                         return tevent_req_post(req, ev);
1454                 }
1455         }
1456         tevent_req_set_callback(subreq, share_mode_watch_done, req);
1457         return req;
1458 }
1459
1460 static void share_mode_watch_done(struct tevent_req *subreq)
1461 {
1462         struct tevent_req *req = tevent_req_callback_data(
1463                 subreq, struct tevent_req);
1464         struct share_mode_watch_state *state = tevent_req_data(
1465                 req, struct share_mode_watch_state);
1466         NTSTATUS status;
1467
1468         if (state->within_cb) {
1469                 status = g_lock_lock_cb_watch_data_recv(
1470                         subreq, &state->blockerdead, &state->blocker);
1471                 if (tevent_req_nterror(req, status)) {
1472                         return;
1473                 }
1474         } else {
1475                 status = g_lock_watch_data_recv(
1476                         subreq, &state->blockerdead, &state->blocker);
1477                 if (tevent_req_nterror(req, status)) {
1478                         return;
1479                 }
1480         }
1481
1482         tevent_req_done(req);
1483 }
1484
1485 NTSTATUS share_mode_watch_recv(
1486         struct tevent_req *req, bool *blockerdead, struct server_id *blocker)
1487 {
1488         struct share_mode_watch_state *state = tevent_req_data(
1489                 req, struct share_mode_watch_state);
1490         NTSTATUS status;
1491
1492         if (tevent_req_is_nterror(req, &status)) {
1493                 return status;
1494         }
1495         if (blockerdead != NULL) {
1496                 *blockerdead = state->blockerdead;
1497         }
1498         if (blocker != NULL) {
1499                 *blocker = state->blocker;
1500         }
1501         return NT_STATUS_OK;
1502 }
1503
1504 struct fetch_share_mode_unlocked_state {
1505         TALLOC_CTX *mem_ctx;
1506         struct file_id id;
1507         struct share_mode_lock *lck;
1508 };
1509
1510 static void fetch_share_mode_unlocked_parser(
1511         struct server_id exclusive,
1512         size_t num_shared,
1513         const struct server_id *shared,
1514         const uint8_t *data,
1515         size_t datalen,
1516         void *private_data)
1517 {
1518         struct fetch_share_mode_unlocked_state *state = private_data;
1519         struct locking_tdb_data ltdb = { 0 };
1520
1521         if (datalen != 0) {
1522                 bool ok = locking_tdb_data_get(&ltdb, data, datalen);
1523                 if (!ok) {
1524                         DBG_DEBUG("locking_tdb_data_get failed\n");
1525                         return;
1526                 }
1527         }
1528
1529         if (ltdb.share_mode_data_len == 0) {
1530                 /* Likely a ctdb tombstone record, ignore it */
1531                 return;
1532         }
1533
1534         state->lck = talloc(state->mem_ctx, struct share_mode_lock);
1535         if (state->lck == NULL) {
1536                 DEBUG(0, ("talloc failed\n"));
1537                 return;
1538         }
1539         state->lck->id = state->id;
1540
1541         state->lck->cached_data = parse_share_modes(
1542                 state->lck,
1543                 state->id,
1544                 ltdb.share_mode_data_buf,
1545                 ltdb.share_mode_data_len);
1546         if (state->lck->cached_data == NULL) {
1547                 DBG_DEBUG("parse_share_modes failed\n");
1548                 TALLOC_FREE(state->lck);
1549         }
1550 }
1551
1552 /*******************************************************************
1553  Get a share_mode_lock without locking the database or reference
1554  counting. Used by smbstatus to display existing share modes.
1555 ********************************************************************/
1556
1557 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
1558                                                   struct file_id id)
1559 {
1560         struct fetch_share_mode_unlocked_state state = {
1561                 .mem_ctx = mem_ctx,
1562                 .id = id,
1563         };
1564         TDB_DATA key = locking_key(&id);
1565         NTSTATUS status;
1566
1567         status = g_lock_dump(
1568                 lock_ctx, key, fetch_share_mode_unlocked_parser, &state);
1569         if (!NT_STATUS_IS_OK(status)) {
1570                 DBG_DEBUG("g_lock_dump failed: %s\n", nt_errstr(status));
1571                 return NULL;
1572         }
1573         return state.lck;
1574 }
1575
1576 struct fetch_share_mode_state {
1577         struct file_id id;
1578         struct share_mode_lock *lck;
1579         NTSTATUS status;
1580 };
1581
1582 static void fetch_share_mode_fn(
1583         struct server_id exclusive,
1584         size_t num_shared,
1585         const struct server_id *shared,
1586         const uint8_t *data,
1587         size_t datalen,
1588         void *private_data);
1589 static void fetch_share_mode_done(struct tevent_req *subreq);
1590
1591 /**
1592  * @brief Get a share_mode_lock without locking or refcounting
1593  *
1594  * This can be used in a clustered Samba environment where the async dbwrap
1595  * request is sent over a socket to the local ctdbd. If the send queue is full
1596  * and the caller was issuing multiple async dbwrap requests in a loop, the
1597  * caller knows it's probably time to stop sending requests for now and try
1598  * again later.
1599  *
1600  * @param[in]  mem_ctx The talloc memory context to use.
1601  *
1602  * @param[in]  ev      The event context to work on.
1603  *
1604  * @param[in]  id      The file id for the locking.tdb key
1605  *
1606  * @param[out] queued  This boolean out parameter tells the caller whether the
1607  *                     async request is blocked in a full send queue:
1608  *
1609  *                     false := request is dispatched
1610  *
1611  *                     true  := send queue is full, request waiting to be
1612  *                              dispatched
1613  *
1614  * @return             The new async request, NULL on error.
1615  **/
1616 struct tevent_req *fetch_share_mode_send(TALLOC_CTX *mem_ctx,
1617                                          struct tevent_context *ev,
1618                                          struct file_id id,
1619                                          bool *queued)
1620 {
1621         struct tevent_req *req = NULL, *subreq = NULL;
1622         struct fetch_share_mode_state *state = NULL;
1623
1624         *queued = false;
1625
1626         req = tevent_req_create(mem_ctx, &state,
1627                                 struct fetch_share_mode_state);
1628         if (req == NULL) {
1629                 return NULL;
1630         }
1631         state->id = id;
1632
1633         subreq = g_lock_dump_send(
1634                 state,
1635                 ev,
1636                 lock_ctx,
1637                 locking_key(&id),
1638                 fetch_share_mode_fn,
1639                 state);
1640         if (tevent_req_nomem(subreq, req)) {
1641                 return tevent_req_post(req, ev);
1642         }
1643         tevent_req_set_callback(subreq, fetch_share_mode_done, req);
1644         return req;
1645 }
1646
1647 static void fetch_share_mode_fn(
1648         struct server_id exclusive,
1649         size_t num_shared,
1650         const struct server_id *shared,
1651         const uint8_t *data,
1652         size_t datalen,
1653         void *private_data)
1654 {
1655         struct fetch_share_mode_state *state = talloc_get_type_abort(
1656                 private_data, struct fetch_share_mode_state);
1657         struct locking_tdb_data ltdb = { 0 };
1658
1659         if (datalen != 0) {
1660                 bool ok = locking_tdb_data_get(&ltdb, data, datalen);
1661                 if (!ok) {
1662                         DBG_DEBUG("locking_tdb_data_get failed\n");
1663                         return;
1664                 }
1665         }
1666
1667         if (ltdb.share_mode_data_len == 0) {
1668                 /* Likely a ctdb tombstone record, ignore it */
1669                 return;
1670         }
1671
1672         state->lck = talloc(state, struct share_mode_lock);
1673         if (state->lck == NULL) {
1674                 DBG_WARNING("talloc failed\n");
1675                 state->status = NT_STATUS_NO_MEMORY;
1676                 return;
1677         }
1678         state->lck->id = state->id,
1679
1680         state->lck->cached_data = parse_share_modes(
1681                 state->lck,
1682                 state->id,
1683                 ltdb.share_mode_data_buf,
1684                 ltdb.share_mode_data_len);
1685         if (state->lck->cached_data == NULL) {
1686                 DBG_DEBUG("parse_share_modes failed\n");
1687                 state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
1688                 TALLOC_FREE(state->lck);
1689                 return;
1690         }
1691 }
1692
1693 static void fetch_share_mode_done(struct tevent_req *subreq)
1694 {
1695         struct tevent_req *req = tevent_req_callback_data(
1696                 subreq, struct tevent_req);
1697         struct fetch_share_mode_state *state = tevent_req_data(
1698                 req, struct fetch_share_mode_state);
1699         NTSTATUS status;
1700
1701         status = g_lock_dump_recv(subreq);
1702         TALLOC_FREE(subreq);
1703         if (tevent_req_nterror(req, status)) {
1704                 return;
1705         }
1706         if (tevent_req_nterror(req, state->status)) {
1707                 return;
1708         }
1709         tevent_req_done(req);
1710 }
1711
1712 NTSTATUS fetch_share_mode_recv(struct tevent_req *req,
1713                                TALLOC_CTX *mem_ctx,
1714                                struct share_mode_lock **_lck)
1715 {
1716         struct fetch_share_mode_state *state = tevent_req_data(
1717                 req, struct fetch_share_mode_state);
1718         struct share_mode_lock *lck = NULL;
1719
1720         NTSTATUS status;
1721
1722         if (tevent_req_is_nterror(req, &status)) {
1723                 tevent_req_received(req);
1724                 return status;
1725         }
1726
1727         if (state->lck == NULL) {
1728                 tevent_req_received(req);
1729                 return NT_STATUS_NOT_FOUND;
1730         }
1731
1732         lck = talloc_move(mem_ctx, &state->lck);
1733
1734         if (DEBUGLEVEL >= 10) {
1735                 DBG_DEBUG("share_mode_data:\n");
1736                 NDR_PRINT_DEBUG(share_mode_data, lck->cached_data);
1737         }
1738
1739         *_lck = lck;
1740         tevent_req_received(req);
1741         return NT_STATUS_OK;
1742 }
1743
1744 struct share_mode_forall_state {
1745         TDB_DATA key;
1746         int (*fn)(struct file_id fid,
1747                   const struct share_mode_data *data,
1748                   void *private_data);
1749         void *private_data;
1750 };
1751
1752 static void share_mode_forall_dump_fn(
1753         struct server_id exclusive,
1754         size_t num_shared,
1755         const struct server_id *shared,
1756         const uint8_t *data,
1757         size_t datalen,
1758         void *private_data)
1759 {
1760         struct share_mode_forall_state *state = private_data;
1761         struct file_id fid;
1762         struct locking_tdb_data ltdb = { 0 };
1763         bool ok;
1764         struct share_mode_data *d;
1765
1766         if (state->key.dsize != sizeof(fid)) {
1767                 DBG_DEBUG("Got invalid key length %zu\n", state->key.dsize);
1768                 return;
1769         }
1770         memcpy(&fid, state->key.dptr, sizeof(fid));
1771
1772         ok = locking_tdb_data_get(&ltdb, data, datalen);
1773         if (!ok) {
1774                 DBG_DEBUG("locking_tdb_data_get() failed\n");
1775                 return;
1776         }
1777
1778         d = parse_share_modes(
1779                 talloc_tos(),
1780                 fid,
1781                 ltdb.share_mode_data_buf,
1782                 ltdb.share_mode_data_len);
1783         if (d == NULL) {
1784                 DBG_DEBUG("parse_share_modes() failed\n");
1785                 return;
1786         }
1787
1788         state->fn(fid, d, state->private_data);
1789         TALLOC_FREE(d);
1790 }
1791
1792 static int share_mode_forall_fn(TDB_DATA key, void *private_data)
1793 {
1794         struct share_mode_forall_state *state = private_data;
1795         NTSTATUS status;
1796
1797         state->key = key;
1798
1799         status = share_mode_g_lock_dump(
1800                 key, share_mode_forall_dump_fn, private_data);
1801         if (!NT_STATUS_IS_OK(status)) {
1802                 DBG_GET_SHARE_MODE_LOCK(status,
1803                         "g_lock_dump failed: %s\n",
1804                         nt_errstr(status));
1805         }
1806         return 0;
1807 }
1808
1809 int share_mode_forall(int (*fn)(struct file_id fid,
1810                                 const struct share_mode_data *data,
1811                                 void *private_data),
1812                       void *private_data)
1813 {
1814         struct share_mode_forall_state state = {
1815                 .fn = fn,
1816                 .private_data = private_data
1817         };
1818         int ret;
1819
1820         if (lock_ctx == NULL) {
1821                 return 0;
1822         }
1823
1824         ret = g_lock_locks(
1825                 lock_ctx, share_mode_forall_fn, &state);
1826         if (ret < 0) {
1827                 DBG_ERR("g_lock_locks failed\n");
1828         }
1829         return ret;
1830 }
1831
1832 struct share_entry_forall_state {
1833         struct file_id fid;
1834         const struct share_mode_data *data;
1835         int (*fn)(struct file_id fid,
1836                   const struct share_mode_data *data,
1837                   const struct share_mode_entry *entry,
1838                   void *private_data);
1839         void *private_data;
1840         int ret;
1841 };
1842
1843 static bool share_entry_traverse_walker(
1844         struct share_mode_entry *e,
1845         bool *modified,
1846         void *private_data)
1847 {
1848         struct share_entry_forall_state *state = private_data;
1849
1850         state->ret = state->fn(
1851                 state->fid, state->data, e, state->private_data);
1852         return (state->ret != 0);
1853 }
1854
1855 static int share_entry_traverse_fn(struct file_id fid,
1856                                    const struct share_mode_data *data,
1857                                    void *private_data)
1858 {
1859         struct share_entry_forall_state *state = private_data;
1860         struct share_mode_lock lck = {
1861                 .id = fid,
1862                 .cached_data = discard_const_p(struct share_mode_data, data)
1863         };
1864         bool ok;
1865
1866         state->fid = fid;
1867         state->data = data;
1868
1869         ok = share_mode_forall_entries(
1870                 &lck, share_entry_traverse_walker, state);
1871         if (!ok) {
1872                 DBG_ERR("share_mode_forall_entries failed\n");
1873                 return false;
1874         }
1875
1876         return state->ret;
1877 }
1878
1879 /*******************************************************************
1880  Call the specified function on each entry under management by the
1881  share mode system.
1882 ********************************************************************/
1883
1884 int share_entry_forall(int (*fn)(struct file_id fid,
1885                                  const struct share_mode_data *data,
1886                                  const struct share_mode_entry *entry,
1887                                  void *private_data),
1888                       void *private_data)
1889 {
1890         struct share_entry_forall_state state = {
1891                 .fn = fn, .private_data = private_data };
1892
1893         return share_mode_forall(share_entry_traverse_fn, &state);
1894 }
1895
1896 static int share_mode_entry_cmp(
1897         struct server_id pid1,
1898         uint64_t share_file_id1,
1899         struct server_id pid2,
1900         uint64_t share_file_id2)
1901 {
1902         int cmp;
1903
1904         cmp = server_id_cmp(&pid1, &pid2);
1905         if (cmp != 0) {
1906                 return cmp;
1907         }
1908         if (share_file_id1 != share_file_id2) {
1909                 return (share_file_id1 < share_file_id2) ? -1 : 1;
1910         }
1911         return 0;
1912 }
1913
1914 static size_t share_mode_entry_find(
1915         const uint8_t *data,
1916         size_t num_share_modes,
1917         struct server_id pid,
1918         uint64_t share_file_id,
1919         struct share_mode_entry *e,
1920         bool *match)
1921 {
1922         ssize_t left, right, middle;
1923
1924         *match = false;
1925
1926         if (num_share_modes == 0) {
1927                 return 0;
1928         }
1929
1930         left = 0;
1931         right = (num_share_modes-1);
1932
1933         while (left <= right) {
1934                 const uint8_t *middle_ptr = NULL;
1935                 int cmp;
1936                 bool ok;
1937
1938                 middle = left + ((right - left) / 2);
1939                 middle_ptr = data + middle * SHARE_MODE_ENTRY_SIZE;
1940
1941                 DBG_DEBUG("left=%zu, right=%zu, middle=%zu, middle_ptr=%p\n",
1942                           left,
1943                           right,
1944                           middle,
1945                           middle_ptr);
1946
1947                 ok = share_mode_entry_get(middle_ptr, e);
1948                 if (!ok) {
1949                         DBG_DEBUG("share_mode_entry_get failed\n");
1950                         return 0;
1951                 }
1952
1953                 cmp = share_mode_entry_cmp(
1954                         e->pid, e->share_file_id, pid, share_file_id);
1955                 if (cmp == 0) {
1956                         *match = true;
1957                         return middle;
1958                 }
1959
1960                 if (cmp < 0) {
1961                         right = middle-1;
1962                 } else {
1963                         left = middle+1;
1964                 }
1965         }
1966
1967         return left;
1968 }
1969
1970 bool set_share_mode(struct share_mode_lock *lck,
1971                     struct files_struct *fsp,
1972                     uid_t uid,
1973                     uint64_t mid,
1974                     uint16_t op_type,
1975                     const struct smb2_lease_key *lease_key,
1976                     uint32_t share_access,
1977                     uint32_t access_mask)
1978 {
1979         struct share_mode_data *d = share_mode_lock_assert_private_data(lck);
1980         TDB_DATA key = locking_key(&d->id);
1981         struct server_id my_pid = messaging_server_id(
1982                 fsp->conn->sconn->msg_ctx);
1983         struct locking_tdb_data *ltdb = NULL;
1984         size_t idx;
1985         struct share_mode_entry e = { .pid.pid = 0 };
1986         struct share_mode_entry_buf e_buf;
1987         NTSTATUS status;
1988         bool ok, found;
1989
1990         TDB_DATA dbufs[3];
1991         size_t num_dbufs = 0;
1992
1993         status = locking_tdb_data_fetch(key, talloc_tos(), &ltdb);
1994         if (!NT_STATUS_IS_OK(status)) {
1995                 DBG_ERR("locking_tdb_data_fetch failed: %s\n",
1996                         nt_errstr(status));
1997                 return false;
1998         }
1999         DBG_DEBUG("num_share_modes=%zu\n", ltdb->num_share_entries);
2000
2001         idx = share_mode_entry_find(
2002                 ltdb->share_entries,
2003                 ltdb->num_share_entries,
2004                 my_pid,
2005                 fh_get_gen_id(fsp->fh),
2006                 &e,
2007                 &found);
2008         if (found) {
2009                 DBG_WARNING("Found duplicate share mode\n");
2010                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
2011                 goto done;
2012         }
2013
2014         e = (struct share_mode_entry) {
2015                 .pid = my_pid,
2016                 .share_access = share_access,
2017                 .private_options = fh_get_private_options(fsp->fh),
2018                 .access_mask = access_mask,
2019                 .op_mid = mid,
2020                 .op_type = op_type,
2021                 .time.tv_sec = fsp->open_time.tv_sec,
2022                 .time.tv_usec = fsp->open_time.tv_usec,
2023                 .share_file_id = fh_get_gen_id(fsp->fh),
2024                 .uid = (uint32_t)uid,
2025                 .flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
2026                         SHARE_MODE_FLAG_POSIX_OPEN : 0,
2027                 .name_hash = fsp->name_hash,
2028         };
2029
2030         if (op_type == LEASE_OPLOCK) {
2031                 const struct GUID *client_guid = fsp_client_guid(fsp);
2032                 e.client_guid = *client_guid;
2033                 e.lease_key = *lease_key;
2034         }
2035
2036         ok = share_mode_entry_put(&e, &e_buf);
2037         if (!ok) {
2038                 DBG_DEBUG("share_mode_entry_put failed\n");
2039                 status = NT_STATUS_INTERNAL_ERROR;
2040                 goto done;
2041         }
2042
2043         DBG_DEBUG("idx=%zu, found=%d\n", idx, (int)found);
2044
2045         if (idx > 0) {
2046                 dbufs[num_dbufs] = (TDB_DATA) {
2047                         .dptr = discard_const_p(uint8_t, ltdb->share_entries),
2048                         .dsize = idx * SHARE_MODE_ENTRY_SIZE,
2049                 };
2050                 num_dbufs += 1;
2051         }
2052
2053         dbufs[num_dbufs] = (TDB_DATA) {
2054                 .dptr = e_buf.buf, .dsize = SHARE_MODE_ENTRY_SIZE,
2055         };
2056         num_dbufs += 1;
2057
2058         if (idx < ltdb->num_share_entries) {
2059                 size_t num_after_idx = (ltdb->num_share_entries-idx);
2060                 dbufs[num_dbufs] = (TDB_DATA) {
2061                         .dptr = discard_const_p(uint8_t, ltdb->share_entries) +
2062                                 idx * SHARE_MODE_ENTRY_SIZE,
2063                         .dsize = num_after_idx * SHARE_MODE_ENTRY_SIZE,
2064                 };
2065                 num_dbufs += 1;
2066         }
2067
2068         {
2069                 size_t i;
2070                 for (i=0; i<num_dbufs; i++) {
2071                         DBG_DEBUG("dbufs[%zu]=(%p, %zu)\n",
2072                                   i,
2073                                   dbufs[i].dptr,
2074                                   dbufs[i].dsize);
2075                 }
2076         }
2077
2078         if (num_dbufs == 1) {
2079                 /*
2080                  * Storing a fresh record with just one share entry
2081                  */
2082                 d->modified = true;
2083         }
2084
2085         /*
2086          * If there was any existing data in
2087          * ltdb->share_entries, it's now been
2088          * moved and we've split it into:
2089          *
2090          * num_dbufs = 3
2091          * dbufs[0] -> old sorted data less than new_entry
2092          * dbufs[1] -> new_share_mode_entry
2093          * dbufs[2] -> old sorted_data greater than new entry.
2094          *
2095          * So the old data inside ltdb->share_entries is
2096          * no longer valid.
2097          *
2098          * If we're storing a brand new entry the
2099          * dbufs look like:
2100          *
2101          * num_dbufs = 1
2102          * dbufs[0] -> new_share_mode_entry
2103          *
2104          * Either way we must set ltdb->share_entries = NULL
2105          * and ltdb->num_share_entries = 0 so that
2106          * locking_tdb_data_store() doesn't use it to
2107          * store any data. It's no longer there.
2108          */
2109
2110         ltdb->share_entries = NULL;
2111         ltdb->num_share_entries = 0;
2112
2113         status = share_mode_data_ltdb_store(d, key, ltdb, dbufs, num_dbufs);
2114         if (!NT_STATUS_IS_OK(status)) {
2115                 DBG_ERR("share_mode_data_ltdb_store failed: %s\n",
2116                         nt_errstr(status));
2117         }
2118 done:
2119         TALLOC_FREE(ltdb);
2120         return NT_STATUS_IS_OK(status);
2121 }
2122
2123 static bool share_mode_for_one_entry(
2124         bool (*fn)(struct share_mode_entry *e,
2125                    bool *modified,
2126                    void *private_data),
2127         void *private_data,
2128         size_t *i,
2129         uint8_t *data,
2130         size_t *num_share_modes,
2131         bool *writeback)
2132 {
2133         DATA_BLOB blob = {
2134                 .data = data + (*i) * SHARE_MODE_ENTRY_SIZE,
2135                 .length = SHARE_MODE_ENTRY_SIZE,
2136         };
2137         struct share_mode_entry e = {.pid.pid=0};
2138         enum ndr_err_code ndr_err = NDR_ERR_SUCCESS;
2139         bool modified = false;
2140         bool stop = false;
2141         struct server_id e_pid;
2142         uint64_t e_share_file_id;
2143
2144         ndr_err = ndr_pull_struct_blob_all_noalloc(
2145                 &blob,
2146                 &e,
2147                 (ndr_pull_flags_fn_t)ndr_pull_share_mode_entry);
2148         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2149                 DBG_WARNING("ndr_pull_share_mode_entry failed\n");
2150                 *i += 1;
2151                 return false;
2152         }
2153         if (DEBUGLEVEL >= 10) {
2154                 DBG_DEBUG("entry[%zu]:\n", *i);
2155                 NDR_PRINT_DEBUG(share_mode_entry, &e);
2156         }
2157
2158         e_pid = e.pid;
2159         e_share_file_id = e.share_file_id;
2160
2161         stop = fn(&e, &modified, private_data);
2162
2163         DBG_DEBUG("entry[%zu]: modified=%d, e.stale=%d\n",
2164                   *i,
2165                   (int)modified,
2166                   (int)e.stale);
2167
2168         if (e.stale) {
2169                 if (DEBUGLEVEL>=10) {
2170                         DBG_DEBUG("share_mode_entry:\n");
2171                         NDR_PRINT_DEBUG(share_mode_entry, &e);
2172                 }
2173
2174                 if (*i < *num_share_modes) {
2175                         memmove(blob.data,
2176                                 blob.data + SHARE_MODE_ENTRY_SIZE,
2177                                 (*num_share_modes - *i - 1) *
2178                                 SHARE_MODE_ENTRY_SIZE);
2179                 }
2180                 *num_share_modes -= 1;
2181                 *writeback = true;
2182                 return stop;
2183         }
2184
2185         if (modified) {
2186                 if (DEBUGLEVEL>=10) {
2187                         DBG_DEBUG("share_mode_entry:\n");
2188                         NDR_PRINT_DEBUG(share_mode_entry, &e);
2189                 }
2190
2191                 /*
2192                  * Make sure sorting order is kept intact
2193                  */
2194                 SMB_ASSERT(server_id_equal(&e_pid, &e.pid));
2195                 SMB_ASSERT(e_share_file_id == e.share_file_id);
2196
2197                 ndr_err = ndr_push_struct_into_fixed_blob(
2198                         &blob,
2199                         &e,
2200                         (ndr_push_flags_fn_t)
2201                         ndr_push_share_mode_entry);
2202                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2203                         DBG_WARNING("ndr_push_share_mode_entry "
2204                                     "failed: %s\n",
2205                                     ndr_errstr(ndr_err));
2206                         /*
2207                          * Not much we can do, just ignore it
2208                          */
2209                 }
2210                 *i += 1;
2211                 *writeback = true;
2212                 return stop;
2213         }
2214
2215         if (stop) {
2216                 return true;
2217         }
2218
2219         *i += 1;
2220         return false;
2221 }
2222
2223 bool share_mode_forall_entries(
2224         struct share_mode_lock *lck,
2225         bool (*fn)(struct share_mode_entry *e,
2226                    bool *modified,
2227                    void *private_data),
2228         void *private_data)
2229 {
2230         struct file_id id = share_mode_lock_file_id(lck);
2231         struct share_mode_data *d = NULL;
2232         TDB_DATA key = locking_key(&id);
2233         struct locking_tdb_data *ltdb = NULL;
2234         uint8_t *share_entries = NULL;
2235         size_t num_share_entries;
2236         bool writeback = false;
2237         NTSTATUS status;
2238         bool stop = false;
2239         size_t i;
2240
2241         status = share_mode_lock_access_private_data(lck, &d);
2242         if (!NT_STATUS_IS_OK(status)) {
2243                 struct file_id_buf id_buf;
2244                 /* Any error recovery possible here ? */
2245                 DBG_ERR("share_mode_lock_access_private_data() failed for "
2246                         "%s - %s\n",
2247                         file_id_str_buf(id, &id_buf),
2248                         nt_errstr(status));
2249                 return false;
2250         }
2251
2252         status = locking_tdb_data_fetch(key, talloc_tos(), &ltdb);
2253         if (!NT_STATUS_IS_OK(status)) {
2254                 DBG_ERR("locking_tdb_data_fetch failed: %s\n",
2255                         nt_errstr(status));
2256                 return false;
2257         }
2258         DBG_DEBUG("num_share_modes=%zu\n", ltdb->num_share_entries);
2259
2260         num_share_entries = ltdb->num_share_entries;
2261         share_entries = discard_const_p(uint8_t, ltdb->share_entries);
2262
2263         i = 0;
2264         while (i<num_share_entries) {
2265                 stop = share_mode_for_one_entry(
2266                         fn,
2267                         private_data,
2268                         &i,
2269                         share_entries,
2270                         &num_share_entries,
2271                         &writeback);
2272                 if (stop) {
2273                         break;
2274                 }
2275         }
2276
2277         DBG_DEBUG("num_share_entries=%zu, writeback=%d\n",
2278                   num_share_entries,
2279                   (int)writeback);
2280
2281         if (!writeback) {
2282                 TALLOC_FREE(ltdb);
2283                 return true;
2284         }
2285
2286         if ((ltdb->num_share_entries != 0 ) && (num_share_entries == 0)) {
2287                 /*
2288                  * This routine wiped all share entries, let
2289                  * share_mode_data_store() delete the record
2290                  */
2291                 d->modified = true;
2292         }
2293
2294         ltdb->num_share_entries = num_share_entries;
2295         ltdb->share_entries = share_entries;
2296
2297         status = share_mode_data_ltdb_store(d, key, ltdb, NULL, 0);
2298         TALLOC_FREE(ltdb);
2299         if (!NT_STATUS_IS_OK(status)) {
2300                 DBG_ERR("share_mode_data_ltdb_store failed: %s\n",
2301                         nt_errstr(status));
2302                 return false;
2303         }
2304
2305         return true;
2306 }
2307
2308 struct share_mode_count_entries_state {
2309         size_t num_share_modes;
2310         NTSTATUS status;
2311 };
2312
2313 static void share_mode_count_entries_fn(
2314         struct server_id exclusive,
2315         size_t num_shared,
2316         const struct server_id *shared,
2317         const uint8_t *data,
2318         size_t datalen,
2319         void *private_data)
2320 {
2321         struct share_mode_count_entries_state *state = private_data;
2322         struct locking_tdb_data ltdb = { 0 };
2323         bool ok;
2324
2325         ok = locking_tdb_data_get(&ltdb, data, datalen);
2326         if (!ok) {
2327                 DBG_WARNING("locking_tdb_data_get failed for %zu\n", datalen);
2328                 state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
2329                 return;
2330         }
2331         state->num_share_modes = ltdb.num_share_entries;
2332         state->status = NT_STATUS_OK;
2333 }
2334
2335 NTSTATUS share_mode_count_entries(struct file_id fid, size_t *num_share_modes)
2336 {
2337         struct share_mode_count_entries_state state = {
2338                 .status = NT_STATUS_NOT_FOUND,
2339         };
2340         NTSTATUS status;
2341
2342         status = g_lock_dump(
2343                 lock_ctx,
2344                 locking_key(&fid),
2345                 share_mode_count_entries_fn,
2346                 &state);
2347         if (!NT_STATUS_IS_OK(status)) {
2348                 DBG_DEBUG("g_lock_dump failed: %s\n",
2349                           nt_errstr(status));
2350                 return status;
2351         }
2352         if (!NT_STATUS_IS_OK(state.status)) {
2353                 DBG_DEBUG("share_mode_count_entries_fn failed: %s\n",
2354                           nt_errstr(state.status));
2355                 return state.status;
2356         }
2357
2358         *num_share_modes = state.num_share_modes;
2359         return NT_STATUS_OK;
2360 }
2361
2362 static bool share_mode_entry_do(
2363         struct share_mode_data *d,
2364         struct server_id pid,
2365         uint64_t share_file_id,
2366         void (*fn)(struct share_mode_entry *e,
2367                    size_t num_share_modes,
2368                    bool *modified,
2369                    void *private_data),
2370         void *private_data)
2371 {
2372         TDB_DATA key = locking_key(&d->id);
2373         struct locking_tdb_data *ltdb = NULL;
2374         size_t idx;
2375         bool found = false;
2376         bool modified = false;
2377         struct share_mode_entry e;
2378         uint8_t *e_ptr = NULL;
2379         NTSTATUS status;
2380         bool ret = false;
2381
2382         status = locking_tdb_data_fetch(key, talloc_tos(), &ltdb);
2383         if (!NT_STATUS_IS_OK(status)) {
2384                 DBG_ERR("locking_tdb_data_fetch failed: %s\n",
2385                         nt_errstr(status));
2386                 return false;
2387         }
2388         DBG_DEBUG("num_share_modes=%zu\n", ltdb->num_share_entries);
2389
2390         idx = share_mode_entry_find(
2391                 ltdb->share_entries,
2392                 ltdb->num_share_entries,
2393                 pid,
2394                 share_file_id,
2395                 &e,
2396                 &found);
2397         if (!found) {
2398                 DBG_WARNING("Did not find share mode entry for %"PRIu64"\n",
2399                             share_file_id);
2400                 goto done;
2401         }
2402
2403         if (DEBUGLEVEL>=10) {
2404                 DBG_DEBUG("entry[%zu]:\n", idx);
2405                 NDR_PRINT_DEBUG(share_mode_entry, &e);
2406         }
2407
2408         fn(&e, ltdb->num_share_entries, &modified, private_data);
2409
2410         DBG_DEBUG("entry[%zu]: modified=%d, e.stale=%d\n",
2411                   idx,
2412                   (int)modified,
2413                   (int)e.stale);
2414
2415         if (!e.stale && !modified) {
2416                 ret = true;
2417                 goto done;
2418         }
2419
2420         e_ptr = discard_const_p(uint8_t, ltdb->share_entries) +
2421                 idx * SHARE_MODE_ENTRY_SIZE;
2422
2423         if (e.stale) {
2424                 /*
2425                  * Move the rest down one entry
2426                  */
2427                 size_t behind = ltdb->num_share_entries - idx - 1;
2428                 if (behind != 0) {
2429                         memmove(e_ptr,
2430                                 e_ptr + SHARE_MODE_ENTRY_SIZE,
2431                                 behind * SHARE_MODE_ENTRY_SIZE);
2432                 }
2433                 ltdb->num_share_entries -= 1;
2434
2435                 if (ltdb->num_share_entries == 0) {
2436                         /*
2437                          * Tell share_mode_lock_destructor() to delete
2438                          * the whole record
2439                          */
2440                         d->modified = true;
2441                 }
2442
2443                 if (DEBUGLEVEL>=10) {
2444                         DBG_DEBUG("share_mode_entry:\n");
2445                         NDR_PRINT_DEBUG(share_mode_entry, &e);
2446                 }
2447         } else {
2448                 struct share_mode_entry_buf buf;
2449                 bool ok;
2450
2451                 if (ltdb->num_share_entries != 1) {
2452                         /*
2453                          * Make sure the sorting order stays intact
2454                          */
2455                         SMB_ASSERT(server_id_equal(&e.pid, &pid));
2456                         SMB_ASSERT(e.share_file_id == share_file_id);
2457                 }
2458
2459                 ok = share_mode_entry_put(&e, &buf);
2460                 if (!ok) {
2461                         DBG_DEBUG("share_mode_entry_put failed\n");
2462                         goto done;
2463                 }
2464                 memcpy(e_ptr, buf.buf, SHARE_MODE_ENTRY_SIZE);
2465         }
2466
2467         status = share_mode_data_ltdb_store(d, key, ltdb, NULL, 0);
2468         if (!NT_STATUS_IS_OK(status)) {
2469                 DBG_ERR("share_mode_data_ltdb_store failed: %s\n",
2470                         nt_errstr(status));
2471                 goto done;
2472         }
2473
2474         ret = true;
2475 done:
2476         TALLOC_FREE(ltdb);
2477         return ret;
2478 }
2479
2480 struct del_share_mode_state {
2481         bool ok;
2482 };
2483
2484 static void del_share_mode_fn(
2485         struct share_mode_entry *e,
2486         size_t num_share_modes,
2487         bool *modified,
2488         void *private_data)
2489 {
2490         struct del_share_mode_state *state = private_data;
2491         e->stale = true;
2492         state->ok = true;
2493 }
2494
2495 bool del_share_mode_open_id(struct share_mode_lock *lck,
2496                             struct server_id open_pid,
2497                             uint64_t open_file_id)
2498 {
2499         struct del_share_mode_state state = { .ok = false };
2500         struct share_mode_data *d = NULL;
2501         NTSTATUS status;
2502         bool ok;
2503
2504         status = share_mode_lock_access_private_data(lck, &d);
2505         if (!NT_STATUS_IS_OK(status)) {
2506                 /* Any error recovery possible here ? */
2507                 return false;
2508         }
2509
2510         ok = share_mode_entry_do(
2511                 d,
2512                 open_pid,
2513                 open_file_id,
2514                 del_share_mode_fn,
2515                 &state);
2516         if (!ok) {
2517                 DBG_DEBUG("share_mode_entry_do failed\n");
2518                 return false;
2519         }
2520         if (!state.ok) {
2521                 DBG_DEBUG("del_share_mode_fn failed\n");
2522                 return false;
2523         }
2524         return true;
2525 }
2526
2527 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
2528 {
2529         struct server_id pid =
2530                 messaging_server_id(fsp->conn->sconn->msg_ctx);
2531         bool ok;
2532
2533         ok = del_share_mode_open_id(lck, pid, fh_get_gen_id(fsp->fh));
2534         if (!ok) {
2535                 struct file_id id = share_mode_lock_file_id(lck);
2536                 struct file_id_buf id_buf;
2537                 DBG_ERR("share_mode_lock_access_private_data() failed for "
2538                         "%s %s\n",
2539                         file_id_str_buf(id, &id_buf),
2540                         fsp_str_dbg(fsp));
2541                 return false;
2542         }
2543         return true;
2544 }
2545
2546 struct remove_share_oplock_state {
2547         bool ok;
2548 };
2549
2550 static void remove_share_oplock_fn(
2551         struct share_mode_entry *e,
2552         size_t num_share_modes,
2553         bool *modified,
2554         void *private_data)
2555 {
2556         struct remove_share_oplock_state *state = private_data;
2557
2558         e->op_type = NO_OPLOCK;
2559         *modified = true;
2560         state->ok = true;
2561 }
2562
2563 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
2564 {
2565         struct remove_share_oplock_state state = { .ok = false };
2566         struct share_mode_data *d = NULL;
2567         NTSTATUS status;
2568         bool ok;
2569
2570         status = share_mode_lock_access_private_data(lck, &d);
2571         if (!NT_STATUS_IS_OK(status)) {
2572                 struct file_id id = share_mode_lock_file_id(lck);
2573                 struct file_id_buf id_buf;
2574                 /* Any error recovery possible here ? */
2575                 DBG_ERR("share_mode_lock_access_private_data() failed for "
2576                         "%s %s - %s\n",
2577                         file_id_str_buf(id, &id_buf),
2578                         fsp_str_dbg(fsp),
2579                         nt_errstr(status));
2580                 return false;
2581         }
2582
2583         ok = share_mode_entry_do(
2584                 d,
2585                 messaging_server_id(fsp->conn->sconn->msg_ctx),
2586                 fh_get_gen_id(fsp->fh),
2587                 remove_share_oplock_fn,
2588                 &state);
2589         if (!ok) {
2590                 DBG_DEBUG("share_mode_entry_do failed\n");
2591                 return false;
2592         }
2593         if (!state.ok) {
2594                 DBG_DEBUG("remove_share_oplock_fn failed\n");
2595                 return false;
2596         }
2597
2598         if (fsp->oplock_type == LEASE_OPLOCK) {
2599                 remove_lease_if_stale(
2600                         lck,
2601                         fsp_client_guid(fsp),
2602                         &fsp->lease->lease.lease_key);
2603         }
2604
2605         share_mode_wakeup_waiters(fsp->file_id);
2606
2607         return true;
2608 }
2609
2610 struct downgrade_share_oplock_state {
2611         bool ok;
2612 };
2613
2614 static void downgrade_share_oplock_fn(
2615         struct share_mode_entry *e,
2616         size_t num_share_modes,
2617         bool *modified,
2618         void *private_data)
2619 {
2620         struct downgrade_share_oplock_state *state = private_data;
2621
2622         e->op_type = LEVEL_II_OPLOCK;
2623         *modified = true;
2624         state->ok = true;
2625 }
2626
2627 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
2628 {
2629         struct downgrade_share_oplock_state state = { .ok = false };
2630         struct share_mode_data *d = NULL;
2631         NTSTATUS status;
2632         bool ok;
2633
2634         status = share_mode_lock_access_private_data(lck, &d);
2635         if (!NT_STATUS_IS_OK(status)) {
2636                 struct file_id id = share_mode_lock_file_id(lck);
2637                 struct file_id_buf id_buf;
2638                 /* Any error recovery possible here ? */
2639                 DBG_ERR("share_mode_lock_access_private_data() failed for "
2640                         "%s %s - %s\n",
2641                         file_id_str_buf(id, &id_buf),
2642                         fsp_str_dbg(fsp),
2643                         nt_errstr(status));
2644                 return false;
2645         }
2646
2647         ok = share_mode_entry_do(
2648                 d,
2649                 messaging_server_id(fsp->conn->sconn->msg_ctx),
2650                 fh_get_gen_id(fsp->fh),
2651                 downgrade_share_oplock_fn,
2652                 &state);
2653         if (!ok) {
2654                 DBG_DEBUG("share_mode_entry_do failed\n");
2655                 return false;
2656         }
2657         if (!state.ok) {
2658                 DBG_DEBUG("downgrade_share_oplock_fn failed\n");
2659                 return false;
2660         }
2661
2662         d->flags |= SHARE_MODE_LEASE_READ;
2663         d->modified = true;
2664
2665         return true;
2666 }
2667
2668 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
2669                                   struct files_struct *fsp)
2670 {
2671         struct server_id disconnected_pid = { .pid = 0 };
2672         bool ok;
2673
2674         if (fsp->op == NULL) {
2675                 return false;
2676         }
2677         if (!fsp->op->global->durable) {
2678                 return false;
2679         }
2680
2681         server_id_set_disconnected(&disconnected_pid);
2682
2683         ok = reset_share_mode_entry(
2684                 lck,
2685                 messaging_server_id(fsp->conn->sconn->msg_ctx),
2686                 fh_get_gen_id(fsp->fh),
2687                 disconnected_pid,
2688                 UINT64_MAX,
2689                 fsp->op->global->open_persistent_id);
2690
2691         return ok;
2692 }
2693
2694 bool reset_share_mode_entry(
2695         struct share_mode_lock *lck,
2696         struct server_id old_pid,
2697         uint64_t old_share_file_id,
2698         struct server_id new_pid,
2699         uint64_t new_mid,
2700         uint64_t new_share_file_id)
2701 {
2702         struct file_id id = share_mode_lock_file_id(lck);
2703         struct share_mode_data *d = NULL;
2704         TDB_DATA key = locking_key(&id);
2705         struct locking_tdb_data *ltdb = NULL;
2706         struct share_mode_entry e;
2707         struct share_mode_entry_buf e_buf;
2708         NTSTATUS status;
2709         int cmp;
2710         bool ret = false;
2711         bool ok;
2712
2713         status = share_mode_lock_access_private_data(lck, &d);
2714         if (!NT_STATUS_IS_OK(status)) {
2715                 struct file_id_buf id_buf;
2716                 /* Any error recovery possible here ? */
2717                 DBG_ERR("share_mode_lock_access_private_data() failed for "
2718                         "%s - %s\n",
2719                         file_id_str_buf(id, &id_buf),
2720                         nt_errstr(status));
2721                 return false;
2722         }
2723
2724         status = locking_tdb_data_fetch(key, talloc_tos(), &ltdb);
2725         if (!NT_STATUS_IS_OK(status)) {
2726                 DBG_ERR("locking_tdb_data_fetch failed: %s\n",
2727                         nt_errstr(status));
2728                 return false;
2729         }
2730
2731         if (ltdb->num_share_entries != 1) {
2732                 DBG_DEBUG("num_share_modes=%zu\n", ltdb->num_share_entries);
2733                 goto done;
2734         }
2735
2736         ok = share_mode_entry_get(ltdb->share_entries, &e);
2737         if (!ok) {
2738                 DBG_WARNING("share_mode_entry_get failed\n");
2739                 goto done;
2740         }
2741
2742         cmp = share_mode_entry_cmp(
2743                 old_pid, old_share_file_id, e.pid, e.share_file_id);
2744         if (cmp != 0) {
2745                 struct server_id_buf tmp1, tmp2;
2746                 DBG_WARNING("Expected pid=%s, file_id=%"PRIu64", "
2747                             "got pid=%s, file_id=%"PRIu64"\n",
2748                             server_id_str_buf(old_pid, &tmp1),
2749                             old_share_file_id,
2750                             server_id_str_buf(e.pid, &tmp2),
2751                             e.share_file_id);
2752                 goto done;
2753         }
2754
2755         e.pid = new_pid;
2756         if (new_mid != UINT64_MAX) {
2757                 e.op_mid = new_mid;
2758         }
2759         e.share_file_id = new_share_file_id;
2760
2761         ok = share_mode_entry_put(&e, &e_buf);
2762         if (!ok) {
2763                 DBG_WARNING("share_mode_entry_put failed\n");
2764                 goto done;
2765         }
2766
2767         ltdb->share_entries = e_buf.buf;
2768
2769         d->modified = true;
2770
2771         status = share_mode_data_ltdb_store(d, key, ltdb, NULL, 0);
2772         if (!NT_STATUS_IS_OK(status)) {
2773                 DBG_ERR("share_mode_data_ltdb_store failed: %s\n",
2774                         nt_errstr(status));
2775                 goto done;
2776         }
2777
2778         ret = true;
2779 done:
2780         TALLOC_FREE(ltdb);
2781         return ret;
2782 }
2783
2784 struct share_mode_do_locked_vfs_denied_state {
2785         struct file_id id;
2786         share_mode_do_locked_vfs_fn_t fn;
2787         void *private_data;
2788         const char *location;
2789         NTSTATUS status;
2790 };
2791
2792 static void share_mode_do_locked_vfs_denied_fn(struct g_lock_lock_cb_state *glck,
2793                                                void *cb_private)
2794 {
2795         struct share_mode_do_locked_vfs_denied_state *state =
2796                 (struct share_mode_do_locked_vfs_denied_state *)cb_private;
2797         struct smb_vfs_deny_state vfs_deny = {};
2798         struct share_mode_lock lck;
2799
2800         if (glck != NULL) {
2801                 current_share_mode_glck = glck;
2802         }
2803
2804         state->status = get_share_mode_lock_internal(state->id,
2805                                                      NULL,  /* servicepath */
2806                                                      NULL,  /* smb_fname */
2807                                                      NULL,  /* old_write_time */
2808                                                      &lck);
2809         if (!NT_STATUS_IS_OK(state->status)) {
2810                 DBG_GET_SHARE_MODE_LOCK(state->status,
2811                         "get_share_mode_lock_internal failed: %s\n",
2812                         nt_errstr(state->status));
2813                 if (glck != NULL) {
2814                         g_lock_lock_cb_unlock(glck);
2815                         current_share_mode_glck = NULL;
2816                 }
2817                 return;
2818         }
2819
2820         _smb_vfs_deny_push(&vfs_deny, state->location);
2821         state->fn(&lck, state->private_data);
2822         _smb_vfs_deny_pop(&vfs_deny, state->location);
2823
2824         state->status = put_share_mode_lock_internal(&lck);
2825         if (!NT_STATUS_IS_OK(state->status)) {
2826                 DBG_ERR("put_share_mode_lock_internal failed: %s\n",
2827                         nt_errstr(state->status));
2828                 smb_panic("put_share_mode_lock_internal failed\n");
2829                 return;
2830         }
2831
2832         if (glck != NULL) {
2833                 g_lock_lock_cb_unlock(glck);
2834                 current_share_mode_glck = NULL;
2835         }
2836         return;
2837 }
2838
2839 /**
2840  * @brief Run @fn protected with G_LOCK_WRITE in the given file_id
2841  *
2842  * @fn is NOT allowed to call SMB_VFS_* or similar functions,
2843  * which may block for some time in the kernel.
2844  *
2845  * There must be at least one share_mode_entry, otherwise
2846  * NT_STATUS_NOT_FOUND is returned.
2847  *
2848  * @param[in]  id           The key for the share_mode record.
2849  * @param[in]  fn           The function to run under the g_lock.
2850  * @param[in]  private_date A private pointer passed to @fn.
2851  */
2852 NTSTATUS _share_mode_do_locked_vfs_denied(
2853         struct file_id id,
2854         share_mode_do_locked_vfs_fn_t fn,
2855         void *private_data,
2856         const char *location)
2857 {
2858         struct share_mode_do_locked_vfs_denied_state state = {
2859                 .id = id,
2860                 .fn = fn,
2861                 .private_data = private_data,
2862                 .location = location,
2863         };
2864
2865         if (share_mode_lock_key_refcount == 0) {
2866                 TDB_DATA key = locking_key(&id);
2867                 NTSTATUS status;
2868
2869                 share_mode_lock_skip_g_lock = true;
2870                 status = g_lock_lock(
2871                         lock_ctx,
2872                         key,
2873                         G_LOCK_WRITE,
2874                         (struct timeval) { .tv_sec = 3600 },
2875                         share_mode_do_locked_vfs_denied_fn,
2876                         &state);
2877                 share_mode_lock_skip_g_lock = false;
2878                 if (!NT_STATUS_IS_OK(status)) {
2879                         DBG_DEBUG("g_lock_lock failed: %s\n",
2880                                   nt_errstr(status));
2881                         return status;
2882                 }
2883                 return state.status;
2884         }
2885
2886         share_mode_do_locked_vfs_denied_fn(NULL, &state);
2887
2888         return state.status;
2889 }
2890
2891 /**
2892  * @brief Run @fn protected with G_LOCK_WRITE in the given file_id
2893  *
2894  * @fn is allowed to call SMB_VFS_* or similar functions,
2895  * which may block for some time in the kernel.
2896  *
2897  * There must be at least one share_mode_entry, otherwise
2898  * NT_STATUS_NOT_FOUND is returned.
2899  *
2900  * @param[in]  id           The key for the share_mode record.
2901  * @param[in]  fn           The function to run under the g_lock.
2902  * @param[in]  private_date A private pointer passed to @fn.
2903  */
2904 NTSTATUS _share_mode_do_locked_vfs_allowed(
2905         struct file_id id,
2906         share_mode_do_locked_vfs_fn_t fn,
2907         void *private_data,
2908         const char *location)
2909 {
2910         struct share_mode_lock lck;
2911         NTSTATUS status;
2912
2913         smb_vfs_assert_allowed();
2914
2915         status = get_share_mode_lock_internal(id,
2916                                               NULL,  /* servicepath */
2917                                               NULL,  /* smb_fname */
2918                                               NULL,  /* old_write_time */
2919                                               &lck);
2920         if (!NT_STATUS_IS_OK(status)) {
2921                 DBG_GET_SHARE_MODE_LOCK(status,
2922                         "get_share_mode_lock_internal failed: %s\n",
2923                         nt_errstr(status));
2924                 return status;
2925         }
2926
2927         fn(&lck, private_data);
2928
2929         status = put_share_mode_lock_internal(&lck);
2930         if (!NT_STATUS_IS_OK(status)) {
2931                 DBG_ERR("put_share_mode_lock_internal failed: %s\n",
2932                         nt_errstr(status));
2933                 smb_panic("put_share_mode_lock_internal failed\n");
2934                 return status;
2935         }
2936
2937         return NT_STATUS_OK;
2938 }
2939
2940 struct share_mode_entry_prepare_lock_state {
2941         struct file_id id;
2942         const char *servicepath;
2943         const struct smb_filename *smb_fname;
2944         const struct timespec *old_write_time;
2945         share_mode_entry_prepare_lock_fn_t fn;
2946         void *private_data;
2947         const char *location;
2948         bool keep_locked;
2949         struct share_mode_lock *lck;
2950         NTSTATUS status;
2951 };
2952
2953 static void share_mode_entry_prepare_lock_fn(struct g_lock_lock_cb_state *glck,
2954                                              void *cb_private)
2955 {
2956         struct share_mode_entry_prepare_lock_state *state =
2957                 (struct share_mode_entry_prepare_lock_state *)cb_private;
2958         struct smb_vfs_deny_state vfs_deny = {};
2959
2960         SMB_ASSERT(glck != NULL);
2961         current_share_mode_glck = glck;
2962
2963         state->status = get_share_mode_lock_internal(state->id,
2964                                                      state->servicepath,
2965                                                      state->smb_fname,
2966                                                      state->old_write_time,
2967                                                      state->lck);
2968         if (!NT_STATUS_IS_OK(state->status)) {
2969                 /* no DBG_GET_SHARE_MODE_LOCK here! */
2970                 DBG_ERR("get_share_mode_lock_internal failed: %s\n",
2971                         nt_errstr(state->status));
2972                 g_lock_lock_cb_unlock(glck);
2973                 current_share_mode_glck = NULL;
2974                 return;
2975         }
2976
2977         _smb_vfs_deny_push(&vfs_deny, state->location);
2978         state->fn(state->lck, &state->keep_locked, state->private_data);
2979         _smb_vfs_deny_pop(&vfs_deny, state->location);
2980
2981         if (state->keep_locked) {
2982                 current_share_mode_glck = NULL;
2983                 return;
2984         }
2985
2986         state->status = put_share_mode_lock_internal(state->lck);
2987         if (!NT_STATUS_IS_OK(state->status)) {
2988                 DBG_ERR("put_share_mode_lock_internal failed: %s\n",
2989                         nt_errstr(state->status));
2990                 smb_panic("put_share_mode_lock_internal failed\n");
2991                 return;
2992         }
2993
2994         g_lock_lock_cb_unlock(glck);
2995         current_share_mode_glck = NULL;
2996         return;
2997 }
2998
2999 NTSTATUS _share_mode_entry_prepare_lock(
3000         struct share_mode_entry_prepare_state *prepare_state,
3001         struct file_id id,
3002         const char *servicepath,
3003         const struct smb_filename *smb_fname,
3004         const struct timespec *old_write_time,
3005         share_mode_entry_prepare_lock_fn_t fn,
3006         void *private_data,
3007         const char *location)
3008 {
3009         struct share_mode_entry_prepare_lock_state state = {
3010                 .id = id,
3011                 .servicepath = servicepath,
3012                 .smb_fname = smb_fname,
3013                 .old_write_time = old_write_time,
3014                 .fn = fn,
3015                 .private_data = private_data,
3016                 .location = location,
3017         };
3018         TDB_DATA key = locking_key(&id);
3019         NTSTATUS status;
3020
3021         SMB_ASSERT(share_mode_lock_key_refcount == 0);
3022
3023         SMB_ASSERT(__SHARE_MODE_LOCK_SPACE >= sizeof(struct share_mode_lock));
3024
3025         *prepare_state = (struct share_mode_entry_prepare_state) {
3026                 .__fid = id,
3027                 .__lck_ptr = &prepare_state->__lck_space,
3028         };
3029
3030         state.lck = prepare_state->__lck_ptr;
3031
3032         share_mode_lock_skip_g_lock = true;
3033         status = g_lock_lock(
3034                 lock_ctx,
3035                 key,
3036                 G_LOCK_WRITE,
3037                 (struct timeval) { .tv_sec = 3600 },
3038                 share_mode_entry_prepare_lock_fn,
3039                 &state);
3040         share_mode_lock_skip_g_lock = false;
3041         if (!state.keep_locked) {
3042                 prepare_state->__lck_ptr = NULL;
3043         }
3044         if (!NT_STATUS_IS_OK(status)) {
3045                 DBG_DEBUG("g_lock_lock failed: %s\n",
3046                           nt_errstr(status));
3047                 return status;
3048         }
3049
3050         return state.status;
3051 }
3052
3053 struct share_mode_entry_prepare_unlock_state {
3054         struct file_id id;
3055         share_mode_entry_prepare_unlock_fn_t fn;
3056         void *private_data;
3057         const char *location;
3058         struct share_mode_lock *lck;
3059         NTSTATUS status;
3060 };
3061
3062 static void share_mode_entry_prepare_unlock_existing_fn(
3063         struct share_mode_entry_prepare_unlock_state *state)
3064 {
3065         if (state->fn != NULL) {
3066                 struct smb_vfs_deny_state vfs_deny = {};
3067
3068                 _smb_vfs_deny_push(&vfs_deny, state->location);
3069                 state->fn(state->lck, state->private_data);
3070                 _smb_vfs_deny_pop(&vfs_deny, state->location);
3071         }
3072
3073         state->status = put_share_mode_lock_internal(state->lck);
3074         if (!NT_STATUS_IS_OK(state->status)) {
3075                 DBG_ERR("put_share_mode_lock_internal failed: %s\n",
3076                         nt_errstr(state->status));
3077                 smb_panic("put_share_mode_lock_internal failed\n");
3078                 return;
3079         }
3080
3081         return;
3082 }
3083
3084 static void share_mode_entry_prepare_unlock_relock_fn(struct g_lock_lock_cb_state *glck,
3085                                                       void *cb_private)
3086 {
3087         struct share_mode_entry_prepare_unlock_state *state =
3088                 (struct share_mode_entry_prepare_unlock_state *)cb_private;
3089         struct smb_vfs_deny_state vfs_deny = {};
3090
3091         SMB_ASSERT(glck != NULL);
3092         current_share_mode_glck = glck;
3093
3094         state->status = get_share_mode_lock_internal(state->id,
3095                                                      NULL,  /* servicepath */
3096                                                      NULL,  /* smb_fname */
3097                                                      NULL,  /* old_write_time */
3098                                                      state->lck);
3099         if (!NT_STATUS_IS_OK(state->status)) {
3100                 /* no DBG_GET_SHARE_MODE_LOCK here! */
3101                 DBG_ERR("get_share_mode_lock_internal failed: %s\n",
3102                         nt_errstr(state->status));
3103                 g_lock_lock_cb_unlock(glck);
3104                 current_share_mode_glck = NULL;
3105                 return;
3106         }
3107
3108         _smb_vfs_deny_push(&vfs_deny, state->location);
3109         state->fn(state->lck, state->private_data);
3110         _smb_vfs_deny_pop(&vfs_deny, state->location);
3111
3112         state->status = put_share_mode_lock_internal(state->lck);
3113         if (!NT_STATUS_IS_OK(state->status)) {
3114                 DBG_ERR("put_share_mode_lock_internal failed: %s\n",
3115                         nt_errstr(state->status));
3116                 smb_panic("put_share_mode_lock_internal failed\n");
3117                 return;
3118         }
3119
3120         g_lock_lock_cb_unlock(glck);
3121         current_share_mode_glck = NULL;
3122         return;
3123 }
3124
3125 NTSTATUS _share_mode_entry_prepare_unlock(
3126         struct share_mode_entry_prepare_state *prepare_state,
3127         share_mode_entry_prepare_unlock_fn_t fn,
3128         void *private_data,
3129         const char *location)
3130 {
3131         struct share_mode_entry_prepare_unlock_state state = {
3132                 .id = prepare_state->__fid,
3133                 .fn = fn,
3134                 .private_data = private_data,
3135                 .location = location,
3136         };
3137         TDB_DATA key = locking_key(&prepare_state->__fid);
3138         NTSTATUS status;
3139
3140         if (prepare_state->__lck_ptr != NULL) {
3141                 /*
3142                  * With an existing lock, we just run the unlock prepare
3143                  * function following by the unlock.
3144                  */
3145
3146                 SMB_ASSERT(share_mode_lock_key_refcount == 1);
3147
3148                 state.lck = prepare_state->__lck_ptr;
3149                 prepare_state->__lck_ptr = NULL;
3150
3151                 share_mode_entry_prepare_unlock_existing_fn(&state);
3152                 return state.status;
3153         }
3154
3155         /*
3156          * No existing lock, which means
3157          * _share_mode_entry_prepare_lock() didn't steal
3158          * the lock...
3159          */
3160         SMB_ASSERT(share_mode_lock_key_refcount == 0);
3161
3162         if (fn == NULL) {
3163                 /*
3164                  * Without an existing lock and without
3165                  * a prepare function there's nothing to
3166                  * do...
3167                  */
3168                 return NT_STATUS_OK;
3169         }
3170
3171         /*
3172          * In order to run the unlock prepare function
3173          * we need to relock the entry.
3174          */
3175         state.lck = &prepare_state->__lck_space;
3176
3177         share_mode_lock_skip_g_lock = true;
3178         status = g_lock_lock(
3179                 lock_ctx,
3180                 key,
3181                 G_LOCK_WRITE,
3182                 (struct timeval) { .tv_sec = 3600 },
3183                 share_mode_entry_prepare_unlock_relock_fn,
3184                 &state);
3185         share_mode_lock_skip_g_lock = false;
3186         if (!NT_STATUS_IS_OK(status)) {
3187                 DBG_ERR("g_lock_lock failed: %s\n",
3188                         nt_errstr(status));
3189                 return status;
3190         }
3191
3192         return state.status;
3193 }