source3/locking/brlock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    byte range locking code
   4    Updated to handle range splits/merges.
   5
   6    Copyright (C) Andrew Tridgell 1992-2000
   7    Copyright (C) Jeremy Allison 1992-2000
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /* This module implements a tdb based byte range locking service,
  24    replacing the fcntl() based byte range locking previously
  25    used. This allows us to provide the same semantics as NT */
  26
  27 #include "includes.h"
  28 #include "system/filesys.h"
  29 #include "locking/proto.h"
  30 #include "smbd/globals.h"
  31 #include "dbwrap/dbwrap.h"
  32 #include "dbwrap/dbwrap_open.h"
  33 #include "serverid.h"
  34 #include "messages.h"
  35 #include "util_tdb.h"
  36
  37 #undef DBGC_CLASS
  38 #define DBGC_CLASS DBGC_LOCKING
  39
  40 #define ZERO_ZERO 0
  41
  42 /* The open brlock.tdb database. */
  43
  44 static struct db_context *brlock_db;
  45
  46 struct byte_range_lock {
  47         struct files_struct *fsp;
  48         unsigned int num_locks;
  49         bool modified;
  50         bool have_read_oplocks;
  51         struct lock_struct *lock_data;
  52         struct db_record *record;
  53 };
  54
  55 /****************************************************************************
  56  Debug info at level 10 for lock struct.
  57 ****************************************************************************/
  58
  59 static void print_lock_struct(unsigned int i, const struct lock_struct *pls)
  60 {
  61         DEBUG(10,("[%u]: smblctx = %llu, tid = %u, pid = %s, ",
  62                         i,
  63                         (unsigned long long)pls->context.smblctx,
  64                         (unsigned int)pls->context.tid,
  65                         server_id_str(talloc_tos(), &pls->context.pid) ));
  66
  67         DEBUG(10,("start = %.0f, size = %.0f, fnum = %llu, %s %s\n",
  68                 (double)pls->start,
  69                 (double)pls->size,
  70                 (unsigned long long)pls->fnum,
  71                 lock_type_name(pls->lock_type),
  72                 lock_flav_name(pls->lock_flav) ));
  73 }
  74
  75 unsigned int brl_num_locks(const struct byte_range_lock *brl)
  76 {
  77         return brl->num_locks;
  78 }
  79
  80 struct files_struct *brl_fsp(struct byte_range_lock *brl)
  81 {
  82         return brl->fsp;
  83 }
  84
  85 bool brl_have_read_oplocks(const struct byte_range_lock *brl)
  86 {
  87         return brl->have_read_oplocks;
  88 }
  89
  90 void brl_set_have_read_oplocks(struct byte_range_lock *brl,
  91                                bool have_read_oplocks)
  92 {
  93         DEBUG(10, ("Setting have_read_oplocks to %s\n",
  94                    have_read_oplocks ? "true" : "false"));
  95         SMB_ASSERT(brl->record != NULL); /* otherwise we're readonly */
  96         brl->have_read_oplocks = have_read_oplocks;
  97         brl->modified = true;
  98 }
  99
 100 /****************************************************************************
 101  See if two locking contexts are equal.
 102 ****************************************************************************/
 103
 104 static bool brl_same_context(const struct lock_context *ctx1,
 105                              const struct lock_context *ctx2)
 106 {
 107         return (serverid_equal(&ctx1->pid, &ctx2->pid) &&
 108                 (ctx1->smblctx == ctx2->smblctx) &&
 109                 (ctx1->tid == ctx2->tid));
 110 }
 111
 112 /****************************************************************************
 113  See if lck1 and lck2 overlap.
 114 ****************************************************************************/
 115
 116 static bool brl_overlap(const struct lock_struct *lck1,
 117                         const struct lock_struct *lck2)
 118 {
 119         /* XXX Remove for Win7 compatibility. */
 120         /* this extra check is not redundant - it copes with locks
 121            that go beyond the end of 64 bit file space */
 122         if (lck1->size != 0 &&
 123             lck1->start == lck2->start &&
 124             lck1->size == lck2->size) {
 125                 return True;
 126         }
 127
 128         if (lck1->start >= (lck2->start+lck2->size) ||
 129             lck2->start >= (lck1->start+lck1->size)) {
 130                 return False;
 131         }
 132         return True;
 133 }
 134
 135 /****************************************************************************
 136  See if lock2 can be added when lock1 is in place.
 137 ****************************************************************************/
 138
 139 static bool brl_conflict(const struct lock_struct *lck1,
 140                          const struct lock_struct *lck2)
 141 {
 142         /* Ignore PENDING locks. */
 143         if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
 144                 return False;
 145
 146         /* Read locks never conflict. */
 147         if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) {
 148                 return False;
 149         }
 150
 151         /* A READ lock can stack on top of a WRITE lock if they have the same
 152          * context & fnum. */
 153         if (lck1->lock_type == WRITE_LOCK && lck2->lock_type == READ_LOCK &&
 154             brl_same_context(&lck1->context, &lck2->context) &&
 155             lck1->fnum == lck2->fnum) {
 156                 return False;
 157         }
 158
 159         return brl_overlap(lck1, lck2);
 160 }
 161
 162 /****************************************************************************
 163  See if lock2 can be added when lock1 is in place - when both locks are POSIX
 164  flavour. POSIX locks ignore fnum - they only care about dev/ino which we
 165  know already match.
 166 ****************************************************************************/
 167
 168 static bool brl_conflict_posix(const struct lock_struct *lck1,
 169                                 const struct lock_struct *lck2)
 170 {
 171 #if defined(DEVELOPER)
 172         SMB_ASSERT(lck1->lock_flav == POSIX_LOCK);
 173         SMB_ASSERT(lck2->lock_flav == POSIX_LOCK);
 174 #endif
 175
 176         /* Ignore PENDING locks. */
 177         if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
 178                 return False;
 179
 180         /* Read locks never conflict. */
 181         if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) {
 182                 return False;
 183         }
 184
 185         /* Locks on the same context don't conflict. Ignore fnum. */
 186         if (brl_same_context(&lck1->context, &lck2->context)) {
 187                 return False;
 188         }
 189
 190         /* One is read, the other write, or the context is different,
 191            do they overlap ? */
 192         return brl_overlap(lck1, lck2);
 193 }
 194
 195 #if ZERO_ZERO
 196 static bool brl_conflict1(const struct lock_struct *lck1,
 197                          const struct lock_struct *lck2)
 198 {
 199         if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
 200                 return False;
 201
 202         if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK) {
 203                 return False;
 204         }
 205
 206         if (brl_same_context(&lck1->context, &lck2->context) &&
 207             lck2->lock_type == READ_LOCK && lck1->fnum == lck2->fnum) {
 208                 return False;
 209         }
 210
 211         if (lck2->start == 0 && lck2->size == 0 && lck1->size != 0) {
 212                 return True;
 213         }
 214
 215         if (lck1->start >= (lck2->start + lck2->size) ||
 216             lck2->start >= (lck1->start + lck1->size)) {
 217                 return False;
 218         }
 219
 220         return True;
 221 }
 222 #endif
 223
 224 /****************************************************************************
 225  Check to see if this lock conflicts, but ignore our own locks on the
 226  same fnum only. This is the read/write lock check code path.
 227  This is never used in the POSIX lock case.
 228 ****************************************************************************/
 229
 230 static bool brl_conflict_other(const struct lock_struct *lck1, const struct lock_struct *lck2)
 231 {
 232         if (IS_PENDING_LOCK(lck1->lock_type) || IS_PENDING_LOCK(lck2->lock_type))
 233                 return False;
 234
 235         if (lck1->lock_type == READ_LOCK && lck2->lock_type == READ_LOCK)
 236                 return False;
 237
 238         /* POSIX flavour locks never conflict here - this is only called
 239            in the read/write path. */
 240
 241         if (lck1->lock_flav == POSIX_LOCK && lck2->lock_flav == POSIX_LOCK)
 242                 return False;
 243
 244         /*
 245          * Incoming WRITE locks conflict with existing READ locks even
 246          * if the context is the same. JRA. See LOCKTEST7 in smbtorture.
 247          */
 248
 249         if (!(lck2->lock_type == WRITE_LOCK && lck1->lock_type == READ_LOCK)) {
 250                 if (brl_same_context(&lck1->context, &lck2->context) &&
 251                                         lck1->fnum == lck2->fnum)
 252                         return False;
 253         }
 254
 255         return brl_overlap(lck1, lck2);
 256 }
 257
 258 /****************************************************************************
 259  Check if an unlock overlaps a pending lock.
 260 ****************************************************************************/
 261
 262 static bool brl_pending_overlap(const struct lock_struct *lock, const struct lock_struct *pend_lock)
 263 {
 264         if ((lock->start <= pend_lock->start) && (lock->start + lock->size > pend_lock->start))
 265                 return True;
 266         if ((lock->start >= pend_lock->start) && (lock->start <= pend_lock->start + pend_lock->size))
 267                 return True;
 268         return False;
 269 }
 270
 271 /****************************************************************************
 272  Amazingly enough, w2k3 "remembers" whether the last lock failure on a fnum
 273  is the same as this one and changes its error code. I wonder if any
 274  app depends on this ?
 275 ****************************************************************************/
 276
 277 static NTSTATUS brl_lock_failed(files_struct *fsp,
 278                                 const struct lock_struct *lock,
 279                                 bool blocking_lock)
 280 {
 281         if (lock->start >= 0xEF000000 && (lock->start >> 63) == 0) {
 282                 /* amazing the little things you learn with a test
 283                    suite. Locks beyond this offset (as a 64 bit
 284                    number!) always generate the conflict error code,
 285                    unless the top bit is set */
 286                 if (!blocking_lock) {
 287                         fsp->last_lock_failure = *lock;
 288                 }
 289                 return NT_STATUS_FILE_LOCK_CONFLICT;
 290         }
 291
 292         if (serverid_equal(&lock->context.pid, &fsp->last_lock_failure.context.pid) &&
 293                         lock->context.tid == fsp->last_lock_failure.context.tid &&
 294                         lock->fnum == fsp->last_lock_failure.fnum &&
 295                         lock->start == fsp->last_lock_failure.start) {
 296                 return NT_STATUS_FILE_LOCK_CONFLICT;
 297         }
 298
 299         if (!blocking_lock) {
 300                 fsp->last_lock_failure = *lock;
 301         }
 302         return NT_STATUS_LOCK_NOT_GRANTED;
 303 }
 304
 305 /****************************************************************************
 306  Open up the brlock.tdb database.
 307 ****************************************************************************/
 308
 309 void brl_init(bool read_only)
 310 {
 311         int tdb_flags;
 312
 313         if (brlock_db) {
 314                 return;
 315         }
 316
 317         tdb_flags = TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH;
 318
 319         if (!lp_clustering()) {
 320                 /*
 321                  * We can't use the SEQNUM trick to cache brlock
 322                  * entries in the clustering case because ctdb seqnum
 323                  * propagation has a delay.
 324                  */
 325                 tdb_flags |= TDB_SEQNUM;
 326         }
 327
 328         brlock_db = db_open(NULL, lock_path("brlock.tdb"),
 329                             SMB_OPEN_DATABASE_TDB_HASH_SIZE, tdb_flags,
 330                             read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644,
 331                             DBWRAP_LOCK_ORDER_2, DBWRAP_FLAG_NONE);
 332         if (!brlock_db) {
 333                 DEBUG(0,("Failed to open byte range locking database %s\n",
 334                         lock_path("brlock.tdb")));
 335                 return;
 336         }
 337 }
 338
 339 /****************************************************************************
 340  Close down the brlock.tdb database.
 341 ****************************************************************************/
 342
 343 void brl_shutdown(void)
 344 {
 345         TALLOC_FREE(brlock_db);
 346 }
 347
 348 #if ZERO_ZERO
 349 /****************************************************************************
 350  Compare two locks for sorting.
 351 ****************************************************************************/
 352
 353 static int lock_compare(const struct lock_struct *lck1,
 354                          const struct lock_struct *lck2)
 355 {
 356         if (lck1->start != lck2->start) {
 357                 return (lck1->start - lck2->start);
 358         }
 359         if (lck2->size != lck1->size) {
 360                 return ((int)lck1->size - (int)lck2->size);
 361         }
 362         return 0;
 363 }
 364 #endif
 365
 366 /****************************************************************************
 367  Lock a range of bytes - Windows lock semantics.
 368 ****************************************************************************/
 369
 370 NTSTATUS brl_lock_windows_default(struct byte_range_lock *br_lck,
 371     struct lock_struct *plock, bool blocking_lock)
 372 {
 373         unsigned int i;
 374         files_struct *fsp = br_lck->fsp;
 375         struct lock_struct *locks = br_lck->lock_data;
 376         NTSTATUS status;
 377
 378         SMB_ASSERT(plock->lock_type != UNLOCK_LOCK);
 379
 380         if ((plock->start + plock->size - 1 < plock->start) &&
 381                         plock->size != 0) {
 382                 return NT_STATUS_INVALID_LOCK_RANGE;
 383         }
 384
 385         for (i=0; i < br_lck->num_locks; i++) {
 386                 /* Do any Windows or POSIX locks conflict ? */
 387                 if (brl_conflict(&locks[i], plock)) {
 388                         /* Remember who blocked us. */
 389                         plock->context.smblctx = locks[i].context.smblctx;
 390                         return brl_lock_failed(fsp,plock,blocking_lock);
 391                 }
 392 #if ZERO_ZERO
 393                 if (plock->start == 0 && plock->size == 0 &&
 394                                 locks[i].size == 0) {
 395                         break;
 396                 }
 397 #endif
 398         }
 399
 400         if (!IS_PENDING_LOCK(plock->lock_type)) {
 401                 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WINDOWS_BRL);
 402         }
 403
 404         /* We can get the Windows lock, now see if it needs to
 405            be mapped into a lower level POSIX one, and if so can
 406            we get it ? */
 407
 408         if (!IS_PENDING_LOCK(plock->lock_type) && lp_posix_locking(fsp->conn->params)) {
 409                 int errno_ret;
 410                 if (!set_posix_lock_windows_flavour(fsp,
 411                                 plock->start,
 412                                 plock->size,
 413                                 plock->lock_type,
 414                                 &plock->context,
 415                                 locks,
 416                                 br_lck->num_locks,
 417                                 &errno_ret)) {
 418
 419                         /* We don't know who blocked us. */
 420                         plock->context.smblctx = 0xFFFFFFFFFFFFFFFFLL;
 421
 422                         if (errno_ret == EACCES || errno_ret == EAGAIN) {
 423                                 status = NT_STATUS_FILE_LOCK_CONFLICT;
 424                                 goto fail;
 425                         } else {
 426                                 status = map_nt_error_from_unix(errno);
 427                                 goto fail;
 428                         }
 429                 }
 430         }
 431
 432         /* no conflicts - add it to the list of locks */
 433         locks = talloc_realloc(br_lck, locks, struct lock_struct,
 434                                (br_lck->num_locks + 1));
 435         if (!locks) {
 436                 status = NT_STATUS_NO_MEMORY;
 437                 goto fail;
 438         }
 439
 440         memcpy(&locks[br_lck->num_locks], plock, sizeof(struct lock_struct));
 441         br_lck->num_locks += 1;
 442         br_lck->lock_data = locks;
 443         br_lck->modified = True;
 444
 445         return NT_STATUS_OK;
 446  fail:
 447         if (!IS_PENDING_LOCK(plock->lock_type)) {
 448                 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WINDOWS_BRL);
 449         }
 450         return status;
 451 }
 452
 453 /****************************************************************************
 454  Cope with POSIX range splits and merges.
 455 ****************************************************************************/
 456
 457 static unsigned int brlock_posix_split_merge(struct lock_struct *lck_arr,       /* Output array. */
 458                                                 struct lock_struct *ex,         /* existing lock. */
 459                                                 struct lock_struct *plock)      /* proposed lock. */
 460 {
 461         bool lock_types_differ = (ex->lock_type != plock->lock_type);
 462
 463         /* We can't merge non-conflicting locks on different context - ignore fnum. */
 464
 465         if (!brl_same_context(&ex->context, &plock->context)) {
 466                 /* Just copy. */
 467                 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 468                 return 1;
 469         }
 470
 471         /* We now know we have the same context. */
 472
 473         /* Did we overlap ? */
 474
 475 /*********************************************
 476                                         +---------+
 477                                         | ex      |
 478                                         +---------+
 479                          +-------+
 480                          | plock |
 481                          +-------+
 482 OR....
 483         +---------+
 484         |  ex     |
 485         +---------+
 486 **********************************************/
 487
 488         if ( (ex->start > (plock->start + plock->size)) ||
 489                 (plock->start > (ex->start + ex->size))) {
 490
 491                 /* No overlap with this lock - copy existing. */
 492
 493                 memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 494                 return 1;
 495         }
 496
 497 /*********************************************
 498         +---------------------------+
 499         |          ex               |
 500         +---------------------------+
 501         +---------------------------+
 502         |       plock               | -> replace with plock.
 503         +---------------------------+
 504 OR
 505              +---------------+
 506              |       ex      |
 507              +---------------+
 508         +---------------------------+
 509         |       plock               | -> replace with plock.
 510         +---------------------------+
 511
 512 **********************************************/
 513
 514         if ( (ex->start >= plock->start) &&
 515                 (ex->start + ex->size <= plock->start + plock->size) ) {
 516
 517                 /* Replace - discard existing lock. */
 518
 519                 return 0;
 520         }
 521
 522 /*********************************************
 523 Adjacent after.
 524                         +-------+
 525                         |  ex   |
 526                         +-------+
 527         +---------------+
 528         |   plock       |
 529         +---------------+
 530
 531 BECOMES....
 532         +---------------+-------+
 533         |   plock       | ex    | - different lock types.
 534         +---------------+-------+
 535 OR.... (merge)
 536         +-----------------------+
 537         |   plock               | - same lock type.
 538         +-----------------------+
 539 **********************************************/
 540
 541         if (plock->start + plock->size == ex->start) {
 542
 543                 /* If the lock types are the same, we merge, if different, we
 544                    add the remainder of the old lock. */
 545
 546                 if (lock_types_differ) {
 547                         /* Add existing. */
 548                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 549                         return 1;
 550                 } else {
 551                         /* Merge - adjust incoming lock as we may have more
 552                          * merging to come. */
 553                         plock->size += ex->size;
 554                         return 0;
 555                 }
 556         }
 557
 558 /*********************************************
 559 Adjacent before.
 560         +-------+
 561         |  ex   |
 562         +-------+
 563                 +---------------+
 564                 |   plock       |
 565                 +---------------+
 566 BECOMES....
 567         +-------+---------------+
 568         | ex    |   plock       | - different lock types
 569         +-------+---------------+
 570
 571 OR.... (merge)
 572         +-----------------------+
 573         |      plock            | - same lock type.
 574         +-----------------------+
 575
 576 **********************************************/
 577
 578         if (ex->start + ex->size == plock->start) {
 579
 580                 /* If the lock types are the same, we merge, if different, we
 581                    add the existing lock. */
 582
 583                 if (lock_types_differ) {
 584                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 585                         return 1;
 586                 } else {
 587                         /* Merge - adjust incoming lock as we may have more
 588                          * merging to come. */
 589                         plock->start = ex->start;
 590                         plock->size += ex->size;
 591                         return 0;
 592                 }
 593         }
 594
 595 /*********************************************
 596 Overlap after.
 597         +-----------------------+
 598         |          ex           |
 599         +-----------------------+
 600         +---------------+
 601         |   plock       |
 602         +---------------+
 603 OR
 604                +----------------+
 605                |       ex       |
 606                +----------------+
 607         +---------------+
 608         |   plock       |
 609         +---------------+
 610
 611 BECOMES....
 612         +---------------+-------+
 613         |   plock       | ex    | - different lock types.
 614         +---------------+-------+
 615 OR.... (merge)
 616         +-----------------------+
 617         |   plock               | - same lock type.
 618         +-----------------------+
 619 **********************************************/
 620
 621         if ( (ex->start >= plock->start) &&
 622                 (ex->start <= plock->start + plock->size) &&
 623                 (ex->start + ex->size > plock->start + plock->size) ) {
 624
 625                 /* If the lock types are the same, we merge, if different, we
 626                    add the remainder of the old lock. */
 627
 628                 if (lock_types_differ) {
 629                         /* Add remaining existing. */
 630                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 631                         /* Adjust existing start and size. */
 632                         lck_arr[0].start = plock->start + plock->size;
 633                         lck_arr[0].size = (ex->start + ex->size) - (plock->start + plock->size);
 634                         return 1;
 635                 } else {
 636                         /* Merge - adjust incoming lock as we may have more
 637                          * merging to come. */
 638                         plock->size += (ex->start + ex->size) - (plock->start + plock->size);
 639                         return 0;
 640                 }
 641         }
 642
 643 /*********************************************
 644 Overlap before.
 645         +-----------------------+
 646         |  ex                   |
 647         +-----------------------+
 648                 +---------------+
 649                 |   plock       |
 650                 +---------------+
 651 OR
 652         +-------------+
 653         |  ex         |
 654         +-------------+
 655                 +---------------+
 656                 |   plock       |
 657                 +---------------+
 658
 659 BECOMES....
 660         +-------+---------------+
 661         | ex    |   plock       | - different lock types
 662         +-------+---------------+
 663
 664 OR.... (merge)
 665         +-----------------------+
 666         |      plock            | - same lock type.
 667         +-----------------------+
 668
 669 **********************************************/
 670
 671         if ( (ex->start < plock->start) &&
 672                         (ex->start + ex->size >= plock->start) &&
 673                         (ex->start + ex->size <= plock->start + plock->size) ) {
 674
 675                 /* If the lock types are the same, we merge, if different, we
 676                    add the truncated old lock. */
 677
 678                 if (lock_types_differ) {
 679                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 680                         /* Adjust existing size. */
 681                         lck_arr[0].size = plock->start - ex->start;
 682                         return 1;
 683                 } else {
 684                         /* Merge - adjust incoming lock as we may have more
 685                          * merging to come. MUST ADJUST plock SIZE FIRST ! */
 686                         plock->size += (plock->start - ex->start);
 687                         plock->start = ex->start;
 688                         return 0;
 689                 }
 690         }
 691
 692 /*********************************************
 693 Complete overlap.
 694         +---------------------------+
 695         |        ex                 |
 696         +---------------------------+
 697                 +---------+
 698                 |  plock  |
 699                 +---------+
 700 BECOMES.....
 701         +-------+---------+---------+
 702         | ex    |  plock  | ex      | - different lock types.
 703         +-------+---------+---------+
 704 OR
 705         +---------------------------+
 706         |        plock              | - same lock type.
 707         +---------------------------+
 708 **********************************************/
 709
 710         if ( (ex->start < plock->start) && (ex->start + ex->size > plock->start + plock->size) ) {
 711
 712                 if (lock_types_differ) {
 713
 714                         /* We have to split ex into two locks here. */
 715
 716                         memcpy(&lck_arr[0], ex, sizeof(struct lock_struct));
 717                         memcpy(&lck_arr[1], ex, sizeof(struct lock_struct));
 718
 719                         /* Adjust first existing size. */
 720                         lck_arr[0].size = plock->start - ex->start;
 721
 722                         /* Adjust second existing start and size. */
 723                         lck_arr[1].start = plock->start + plock->size;
 724                         lck_arr[1].size = (ex->start + ex->size) - (plock->start + plock->size);
 725                         return 2;
 726                 } else {
 727                         /* Just eat the existing locks, merge them into plock. */
 728                         plock->start = ex->start;
 729                         plock->size = ex->size;
 730                         return 0;
 731                 }
 732         }
 733
 734         /* Never get here. */
 735         smb_panic("brlock_posix_split_merge");
 736         /* Notreached. */
 737
 738         /* Keep some compilers happy. */
 739         return 0;
 740 }
 741
 742 /****************************************************************************
 743  Lock a range of bytes - POSIX lock semantics.
 744  We must cope with range splits and merges.
 745 ****************************************************************************/
 746
 747 static NTSTATUS brl_lock_posix(struct messaging_context *msg_ctx,
 748                                struct byte_range_lock *br_lck,
 749                                struct lock_struct *plock)
 750 {
 751         unsigned int i, count, posix_count;
 752         struct lock_struct *locks = br_lck->lock_data;
 753         struct lock_struct *tp;
 754         bool signal_pending_read = False;
 755         bool break_oplocks = false;
 756         NTSTATUS status;
 757
 758         /* No zero-zero locks for POSIX. */
 759         if (plock->start == 0 && plock->size == 0) {
 760                 return NT_STATUS_INVALID_PARAMETER;
 761         }
 762
 763         /* Don't allow 64-bit lock wrap. */
 764         if (plock->start + plock->size - 1 < plock->start) {
 765                 return NT_STATUS_INVALID_PARAMETER;
 766         }
 767
 768         /* The worst case scenario here is we have to split an
 769            existing POSIX lock range into two, and add our lock,
 770            so we need at most 2 more entries. */
 771
 772         tp = talloc_array(br_lck, struct lock_struct, br_lck->num_locks + 2);
 773         if (!tp) {
 774                 return NT_STATUS_NO_MEMORY;
 775         }
 776
 777         count = posix_count = 0;
 778
 779         for (i=0; i < br_lck->num_locks; i++) {
 780                 struct lock_struct *curr_lock = &locks[i];
 781
 782                 /* If we have a pending read lock, a lock downgrade should
 783                    trigger a lock re-evaluation. */
 784                 if (curr_lock->lock_type == PENDING_READ_LOCK &&
 785                                 brl_pending_overlap(plock, curr_lock)) {
 786                         signal_pending_read = True;
 787                 }
 788
 789                 if (curr_lock->lock_flav == WINDOWS_LOCK) {
 790                         /* Do any Windows flavour locks conflict ? */
 791                         if (brl_conflict(curr_lock, plock)) {
 792                                 /* No games with error messages. */
 793                                 TALLOC_FREE(tp);
 794                                 /* Remember who blocked us. */
 795                                 plock->context.smblctx = curr_lock->context.smblctx;
 796                                 return NT_STATUS_FILE_LOCK_CONFLICT;
 797                         }
 798                         /* Just copy the Windows lock into the new array. */
 799                         memcpy(&tp[count], curr_lock, sizeof(struct lock_struct));
 800                         count++;
 801                 } else {
 802                         unsigned int tmp_count = 0;
 803
 804                         /* POSIX conflict semantics are different. */
 805                         if (brl_conflict_posix(curr_lock, plock)) {
 806                                 /* Can't block ourselves with POSIX locks. */
 807                                 /* No games with error messages. */
 808                                 TALLOC_FREE(tp);
 809                                 /* Remember who blocked us. */
 810                                 plock->context.smblctx = curr_lock->context.smblctx;
 811                                 return NT_STATUS_FILE_LOCK_CONFLICT;
 812                         }
 813
 814                         /* Work out overlaps. */
 815                         tmp_count += brlock_posix_split_merge(&tp[count], curr_lock, plock);
 816                         posix_count += tmp_count;
 817                         count += tmp_count;
 818                 }
 819         }
 820
 821         /*
 822          * Break oplocks while we hold a brl. Since lock() and unlock() calls
 823          * are not symetric with POSIX semantics, we cannot guarantee our
 824          * contend_level2_oplocks_begin/end calls will be acquired and
 825          * released one-for-one as with Windows semantics. Therefore we only
 826          * call contend_level2_oplocks_begin if this is the first POSIX brl on
 827          * the file.
 828          */
 829         break_oplocks = (!IS_PENDING_LOCK(plock->lock_type) &&
 830                          posix_count == 0);
 831         if (break_oplocks) {
 832                 contend_level2_oplocks_begin(br_lck->fsp,
 833                                              LEVEL2_CONTEND_POSIX_BRL);
 834         }
 835
 836         /* Try and add the lock in order, sorted by lock start. */
 837         for (i=0; i < count; i++) {
 838                 struct lock_struct *curr_lock = &tp[i];
 839
 840                 if (curr_lock->start <= plock->start) {
 841                         continue;
 842                 }
 843         }
 844
 845         if (i < count) {
 846                 memmove(&tp[i+1], &tp[i],
 847                         (count - i)*sizeof(struct lock_struct));
 848         }
 849         memcpy(&tp[i], plock, sizeof(struct lock_struct));
 850         count++;
 851
 852         /* We can get the POSIX lock, now see if it needs to
 853            be mapped into a lower level POSIX one, and if so can
 854            we get it ? */
 855
 856         if (!IS_PENDING_LOCK(plock->lock_type) && lp_posix_locking(br_lck->fsp->conn->params)) {
 857                 int errno_ret;
 858
 859                 /* The lower layer just needs to attempt to
 860                    get the system POSIX lock. We've weeded out
 861                    any conflicts above. */
 862
 863                 if (!set_posix_lock_posix_flavour(br_lck->fsp,
 864                                 plock->start,
 865                                 plock->size,
 866                                 plock->lock_type,
 867                                 &errno_ret)) {
 868
 869                         /* We don't know who blocked us. */
 870                         plock->context.smblctx = 0xFFFFFFFFFFFFFFFFLL;
 871
 872                         if (errno_ret == EACCES || errno_ret == EAGAIN) {
 873                                 TALLOC_FREE(tp);
 874                                 status = NT_STATUS_FILE_LOCK_CONFLICT;
 875                                 goto fail;
 876                         } else {
 877                                 TALLOC_FREE(tp);
 878                                 status = map_nt_error_from_unix(errno);
 879                                 goto fail;
 880                         }
 881                 }
 882         }
 883
 884         /* If we didn't use all the allocated size,
 885          * Realloc so we don't leak entries per lock call. */
 886         if (count < br_lck->num_locks + 2) {
 887                 tp = talloc_realloc(br_lck, tp, struct lock_struct, count);
 888                 if (!tp) {
 889                         status = NT_STATUS_NO_MEMORY;
 890                         goto fail;
 891                 }
 892         }
 893
 894         br_lck->num_locks = count;
 895         TALLOC_FREE(br_lck->lock_data);
 896         br_lck->lock_data = tp;
 897         locks = tp;
 898         br_lck->modified = True;
 899
 900         /* A successful downgrade from write to read lock can trigger a lock
 901            re-evalutation where waiting readers can now proceed. */
 902
 903         if (signal_pending_read) {
 904                 /* Send unlock messages to any pending read waiters that overlap. */
 905                 for (i=0; i < br_lck->num_locks; i++) {
 906                         struct lock_struct *pend_lock = &locks[i];
 907
 908                         /* Ignore non-pending locks. */
 909                         if (!IS_PENDING_LOCK(pend_lock->lock_type)) {
 910                                 continue;
 911                         }
 912
 913                         if (pend_lock->lock_type == PENDING_READ_LOCK &&
 914                                         brl_pending_overlap(plock, pend_lock)) {
 915                                 DEBUG(10,("brl_lock_posix: sending unlock message to pid %s\n",
 916                                         procid_str_static(&pend_lock->context.pid )));
 917
 918                                 messaging_send(msg_ctx, pend_lock->context.pid,
 919                                                MSG_SMB_UNLOCK, &data_blob_null);
 920                         }
 921                 }
 922         }
 923
 924         return NT_STATUS_OK;
 925  fail:
 926         if (break_oplocks) {
 927                 contend_level2_oplocks_end(br_lck->fsp,
 928                                            LEVEL2_CONTEND_POSIX_BRL);
 929         }
 930         return status;
 931 }
 932
 933 NTSTATUS smb_vfs_call_brl_lock_windows(struct vfs_handle_struct *handle,
 934                                        struct byte_range_lock *br_lck,
 935                                        struct lock_struct *plock,
 936                                        bool blocking_lock,
 937                                        struct blocking_lock_record *blr)
 938 {
 939         VFS_FIND(brl_lock_windows);
 940         return handle->fns->brl_lock_windows_fn(handle, br_lck, plock,
 941                                                 blocking_lock, blr);
 942 }
 943
 944 /****************************************************************************
 945  Lock a range of bytes.
 946 ****************************************************************************/
 947
 948 NTSTATUS brl_lock(struct messaging_context *msg_ctx,
 949                 struct byte_range_lock *br_lck,
 950                 uint64_t smblctx,
 951                 struct server_id pid,
 952                 br_off start,
 953                 br_off size,
 954                 enum brl_type lock_type,
 955                 enum brl_flavour lock_flav,
 956                 bool blocking_lock,
 957                 uint64_t *psmblctx,
 958                 struct blocking_lock_record *blr)
 959 {
 960         NTSTATUS ret;
 961         struct lock_struct lock;
 962
 963 #if !ZERO_ZERO
 964         if (start == 0 && size == 0) {
 965                 DEBUG(0,("client sent 0/0 lock - please report this\n"));
 966         }
 967 #endif
 968
 969 #ifdef DEVELOPER
 970         /* Quieten valgrind on test. */
 971         ZERO_STRUCT(lock);
 972 #endif
 973
 974         lock.context.smblctx = smblctx;
 975         lock.context.pid = pid;
 976         lock.context.tid = br_lck->fsp->conn->cnum;
 977         lock.start = start;
 978         lock.size = size;
 979         lock.fnum = br_lck->fsp->fnum;
 980         lock.lock_type = lock_type;
 981         lock.lock_flav = lock_flav;
 982
 983         if (lock_flav == WINDOWS_LOCK) {
 984                 ret = SMB_VFS_BRL_LOCK_WINDOWS(br_lck->fsp->conn, br_lck,
 985                     &lock, blocking_lock, blr);
 986         } else {
 987                 ret = brl_lock_posix(msg_ctx, br_lck, &lock);
 988         }
 989
 990 #if ZERO_ZERO
 991         /* sort the lock list */
 992         TYPESAFE_QSORT(br_lck->lock_data, (size_t)br_lck->num_locks, lock_compare);
 993 #endif
 994
 995         /* If we're returning an error, return who blocked us. */
 996         if (!NT_STATUS_IS_OK(ret) && psmblctx) {
 997                 *psmblctx = lock.context.smblctx;
 998         }
 999         return ret;
1000 }
1001
1002 /****************************************************************************
1003  Unlock a range of bytes - Windows semantics.
1004 ****************************************************************************/
1005
1006 bool brl_unlock_windows_default(struct messaging_context *msg_ctx,
1007                                struct byte_range_lock *br_lck,
1008                                const struct lock_struct *plock)
1009 {
1010         unsigned int i, j;
1011         struct lock_struct *locks = br_lck->lock_data;
1012         enum brl_type deleted_lock_type = READ_LOCK; /* shut the compiler up.... */
1013
1014         SMB_ASSERT(plock->lock_type == UNLOCK_LOCK);
1015
1016 #if ZERO_ZERO
1017         /* Delete write locks by preference... The lock list
1018            is sorted in the zero zero case. */
1019
1020         for (i = 0; i < br_lck->num_locks; i++) {
1021                 struct lock_struct *lock = &locks[i];
1022
1023                 if (lock->lock_type == WRITE_LOCK &&
1024                     brl_same_context(&lock->context, &plock->context) &&
1025                     lock->fnum == plock->fnum &&
1026                     lock->lock_flav == WINDOWS_LOCK &&
1027                     lock->start == plock->start &&
1028                     lock->size == plock->size) {
1029
1030                         /* found it - delete it */
1031                         deleted_lock_type = lock->lock_type;
1032                         break;
1033                 }
1034         }
1035
1036         if (i != br_lck->num_locks) {
1037                 /* We found it - don't search again. */
1038                 goto unlock_continue;
1039         }
1040 #endif
1041
1042         for (i = 0; i < br_lck->num_locks; i++) {
1043                 struct lock_struct *lock = &locks[i];
1044
1045                 if (IS_PENDING_LOCK(lock->lock_type)) {
1046                         continue;
1047                 }
1048
1049                 /* Only remove our own locks that match in start, size, and flavour. */
1050                 if (brl_same_context(&lock->context, &plock->context) &&
1051                                         lock->fnum == plock->fnum &&
1052                                         lock->lock_flav == WINDOWS_LOCK &&
1053                                         lock->start == plock->start &&
1054                                         lock->size == plock->size ) {
1055                         deleted_lock_type = lock->lock_type;
1056                         break;
1057                 }
1058         }
1059
1060         if (i == br_lck->num_locks) {
1061                 /* we didn't find it */
1062                 return False;
1063         }
1064
1065 #if ZERO_ZERO
1066   unlock_continue:
1067 #endif
1068
1069         /* Actually delete the lock. */
1070         if (i < br_lck->num_locks - 1) {
1071                 memmove(&locks[i], &locks[i+1],
1072                         sizeof(*locks)*((br_lck->num_locks-1) - i));
1073         }
1074
1075         br_lck->num_locks -= 1;
1076         br_lck->modified = True;
1077
1078         /* Unlock the underlying POSIX regions. */
1079         if(lp_posix_locking(br_lck->fsp->conn->params)) {
1080                 release_posix_lock_windows_flavour(br_lck->fsp,
1081                                 plock->start,
1082                                 plock->size,
1083                                 deleted_lock_type,
1084                                 &plock->context,
1085                                 locks,
1086                                 br_lck->num_locks);
1087         }
1088
1089         /* Send unlock messages to any pending waiters that overlap. */
1090         for (j=0; j < br_lck->num_locks; j++) {
1091                 struct lock_struct *pend_lock = &locks[j];
1092
1093                 /* Ignore non-pending locks. */
1094                 if (!IS_PENDING_LOCK(pend_lock->lock_type)) {
1095                         continue;
1096                 }
1097
1098                 /* We could send specific lock info here... */
1099                 if (brl_pending_overlap(plock, pend_lock)) {
1100                         DEBUG(10,("brl_unlock: sending unlock message to pid %s\n",
1101                                 procid_str_static(&pend_lock->context.pid )));
1102
1103                         messaging_send(msg_ctx, pend_lock->context.pid,
1104                                        MSG_SMB_UNLOCK, &data_blob_null);
1105                 }
1106         }
1107
1108         contend_level2_oplocks_end(br_lck->fsp, LEVEL2_CONTEND_WINDOWS_BRL);
1109         return True;
1110 }
1111
1112 /****************************************************************************
1113  Unlock a range of bytes - POSIX semantics.
1114 ****************************************************************************/
1115
1116 static bool brl_unlock_posix(struct messaging_context *msg_ctx,
1117                              struct byte_range_lock *br_lck,
1118                              struct lock_struct *plock)
1119 {
1120         unsigned int i, j, count;
1121         struct lock_struct *tp;
1122         struct lock_struct *locks = br_lck->lock_data;
1123         bool overlap_found = False;
1124
1125         /* No zero-zero locks for POSIX. */
1126         if (plock->start == 0 && plock->size == 0) {
1127                 return False;
1128         }
1129
1130         /* Don't allow 64-bit lock wrap. */
1131         if (plock->start + plock->size < plock->start ||
1132                         plock->start + plock->size < plock->size) {
1133                 DEBUG(10,("brl_unlock_posix: lock wrap\n"));
1134                 return False;
1135         }
1136
1137         /* The worst case scenario here is we have to split an
1138            existing POSIX lock range into two, so we need at most
1139            1 more entry. */
1140
1141         tp = talloc_array(br_lck, struct lock_struct, br_lck->num_locks + 1);
1142         if (!tp) {
1143                 DEBUG(10,("brl_unlock_posix: malloc fail\n"));
1144                 return False;
1145         }
1146
1147         count = 0;
1148         for (i = 0; i < br_lck->num_locks; i++) {
1149                 struct lock_struct *lock = &locks[i];
1150                 unsigned int tmp_count;
1151
1152                 /* Only remove our own locks - ignore fnum. */
1153                 if (IS_PENDING_LOCK(lock->lock_type) ||
1154                                 !brl_same_context(&lock->context, &plock->context)) {
1155                         memcpy(&tp[count], lock, sizeof(struct lock_struct));
1156                         count++;
1157                         continue;
1158                 }
1159
1160                 if (lock->lock_flav == WINDOWS_LOCK) {
1161                         /* Do any Windows flavour locks conflict ? */
1162                         if (brl_conflict(lock, plock)) {
1163                                 TALLOC_FREE(tp);
1164                                 return false;
1165                         }
1166                         /* Just copy the Windows lock into the new array. */
1167                         memcpy(&tp[count], lock, sizeof(struct lock_struct));
1168                         count++;
1169                         continue;
1170                 }
1171
1172                 /* Work out overlaps. */
1173                 tmp_count = brlock_posix_split_merge(&tp[count], lock, plock);
1174
1175                 if (tmp_count == 0) {
1176                         /* plock overlapped the existing lock completely,
1177                            or replaced it. Don't copy the existing lock. */
1178                         overlap_found = true;
1179                 } else if (tmp_count == 1) {
1180                         /* Either no overlap, (simple copy of existing lock) or
1181                          * an overlap of an existing lock. */
1182                         /* If the lock changed size, we had an overlap. */
1183                         if (tp[count].size != lock->size) {
1184                                 overlap_found = true;
1185                         }
1186                         count += tmp_count;
1187                 } else if (tmp_count == 2) {
1188                         /* We split a lock range in two. */
1189                         overlap_found = true;
1190                         count += tmp_count;
1191
1192                         /* Optimisation... */
1193                         /* We know we're finished here as we can't overlap any
1194                            more POSIX locks. Copy the rest of the lock array. */
1195
1196                         if (i < br_lck->num_locks - 1) {
1197                                 memcpy(&tp[count], &locks[i+1],
1198                                         sizeof(*locks)*((br_lck->num_locks-1) - i));
1199                                 count += ((br_lck->num_locks-1) - i);
1200                         }
1201                         break;
1202                 }
1203
1204         }
1205
1206         if (!overlap_found) {
1207                 /* Just ignore - no change. */
1208                 TALLOC_FREE(tp);
1209                 DEBUG(10,("brl_unlock_posix: No overlap - unlocked.\n"));
1210                 return True;
1211         }
1212
1213         /* Unlock any POSIX regions. */
1214         if(lp_posix_locking(br_lck->fsp->conn->params)) {
1215                 release_posix_lock_posix_flavour(br_lck->fsp,
1216                                                 plock->start,
1217                                                 plock->size,
1218                                                 &plock->context,
1219                                                 tp,
1220                                                 count);
1221         }
1222
1223         /* Realloc so we don't leak entries per unlock call. */
1224         if (count) {
1225                 tp = talloc_realloc(br_lck, tp, struct lock_struct, count);
1226                 if (!tp) {
1227                         DEBUG(10,("brl_unlock_posix: realloc fail\n"));
1228                         return False;
1229                 }
1230         } else {
1231                 /* We deleted the last lock. */
1232                 TALLOC_FREE(tp);
1233                 tp = NULL;
1234         }
1235
1236         contend_level2_oplocks_end(br_lck->fsp,
1237                                    LEVEL2_CONTEND_POSIX_BRL);
1238
1239         br_lck->num_locks = count;
1240         TALLOC_FREE(br_lck->lock_data);
1241         locks = tp;
1242         br_lck->lock_data = tp;
1243         br_lck->modified = True;
1244
1245         /* Send unlock messages to any pending waiters that overlap. */
1246
1247         for (j=0; j < br_lck->num_locks; j++) {
1248                 struct lock_struct *pend_lock = &locks[j];
1249
1250                 /* Ignore non-pending locks. */
1251                 if (!IS_PENDING_LOCK(pend_lock->lock_type)) {
1252                         continue;
1253                 }
1254
1255                 /* We could send specific lock info here... */
1256                 if (brl_pending_overlap(plock, pend_lock)) {
1257                         DEBUG(10,("brl_unlock: sending unlock message to pid %s\n",
1258                                 procid_str_static(&pend_lock->context.pid )));
1259
1260                         messaging_send(msg_ctx, pend_lock->context.pid,
1261                                        MSG_SMB_UNLOCK, &data_blob_null);
1262                 }
1263         }
1264
1265         return True;
1266 }
1267
1268 bool smb_vfs_call_brl_unlock_windows(struct vfs_handle_struct *handle,
1269                                      struct messaging_context *msg_ctx,
1270                                      struct byte_range_lock *br_lck,
1271                                      const struct lock_struct *plock)
1272 {
1273         VFS_FIND(brl_unlock_windows);
1274         return handle->fns->brl_unlock_windows_fn(handle, msg_ctx, br_lck,
1275                                                   plock);
1276 }
1277
1278 /****************************************************************************
1279  Unlock a range of bytes.
1280 ****************************************************************************/
1281
1282 bool brl_unlock(struct messaging_context *msg_ctx,
1283                 struct byte_range_lock *br_lck,
1284                 uint64_t smblctx,
1285                 struct server_id pid,
1286                 br_off start,
1287                 br_off size,
1288                 enum brl_flavour lock_flav)
1289 {
1290         struct lock_struct lock;
1291
1292         lock.context.smblctx = smblctx;
1293         lock.context.pid = pid;
1294         lock.context.tid = br_lck->fsp->conn->cnum;
1295         lock.start = start;
1296         lock.size = size;
1297         lock.fnum = br_lck->fsp->fnum;
1298         lock.lock_type = UNLOCK_LOCK;
1299         lock.lock_flav = lock_flav;
1300
1301         if (lock_flav == WINDOWS_LOCK) {
1302                 return SMB_VFS_BRL_UNLOCK_WINDOWS(br_lck->fsp->conn, msg_ctx,
1303                     br_lck, &lock);
1304         } else {
1305                 return brl_unlock_posix(msg_ctx, br_lck, &lock);
1306         }
1307 }
1308
1309 /****************************************************************************
1310  Test if we could add a lock if we wanted to.
1311  Returns True if the region required is currently unlocked, False if locked.
1312 ****************************************************************************/
1313
1314 bool brl_locktest(struct byte_range_lock *br_lck,
1315                 uint64_t smblctx,
1316                 struct server_id pid,
1317                 br_off start,
1318                 br_off size,
1319                 enum brl_type lock_type,
1320                 enum brl_flavour lock_flav)
1321 {
1322         bool ret = True;
1323         unsigned int i;
1324         struct lock_struct lock;
1325         const struct lock_struct *locks = br_lck->lock_data;
1326         files_struct *fsp = br_lck->fsp;
1327
1328         lock.context.smblctx = smblctx;
1329         lock.context.pid = pid;
1330         lock.context.tid = br_lck->fsp->conn->cnum;
1331         lock.start = start;
1332         lock.size = size;
1333         lock.fnum = fsp->fnum;
1334         lock.lock_type = lock_type;
1335         lock.lock_flav = lock_flav;
1336
1337         /* Make sure existing locks don't conflict */
1338         for (i=0; i < br_lck->num_locks; i++) {
1339                 /*
1340                  * Our own locks don't conflict.
1341                  */
1342                 if (brl_conflict_other(&locks[i], &lock)) {
1343                         return False;
1344                 }
1345         }
1346
1347         /*
1348          * There is no lock held by an SMB daemon, check to
1349          * see if there is a POSIX lock from a UNIX or NFS process.
1350          * This only conflicts with Windows locks, not POSIX locks.
1351          */
1352
1353         if(lp_posix_locking(fsp->conn->params) && (lock_flav == WINDOWS_LOCK)) {
1354                 ret = is_posix_locked(fsp, &start, &size, &lock_type, WINDOWS_LOCK);
1355
1356                 DEBUG(10,("brl_locktest: posix start=%.0f len=%.0f %s for %s file %s\n",
1357                         (double)start, (double)size, ret ? "locked" : "unlocked",
1358                         fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
1359
1360                 /* We need to return the inverse of is_posix_locked. */
1361                 ret = !ret;
1362         }
1363
1364         /* no conflicts - we could have added it */
1365         return ret;
1366 }
1367
1368 /****************************************************************************
1369  Query for existing locks.
1370 ****************************************************************************/
1371
1372 NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
1373                 uint64_t *psmblctx,
1374                 struct server_id pid,
1375                 br_off *pstart,
1376                 br_off *psize,
1377                 enum brl_type *plock_type,
1378                 enum brl_flavour lock_flav)
1379 {
1380         unsigned int i;
1381         struct lock_struct lock;
1382         const struct lock_struct *locks = br_lck->lock_data;
1383         files_struct *fsp = br_lck->fsp;
1384
1385         lock.context.smblctx = *psmblctx;
1386         lock.context.pid = pid;
1387         lock.context.tid = br_lck->fsp->conn->cnum;
1388         lock.start = *pstart;
1389         lock.size = *psize;
1390         lock.fnum = fsp->fnum;
1391         lock.lock_type = *plock_type;
1392         lock.lock_flav = lock_flav;
1393
1394         /* Make sure existing locks don't conflict */
1395         for (i=0; i < br_lck->num_locks; i++) {
1396                 const struct lock_struct *exlock = &locks[i];
1397                 bool conflict = False;
1398
1399                 if (exlock->lock_flav == WINDOWS_LOCK) {
1400                         conflict = brl_conflict(exlock, &lock);
1401                 } else {
1402                         conflict = brl_conflict_posix(exlock, &lock);
1403                 }
1404
1405                 if (conflict) {
1406                         *psmblctx = exlock->context.smblctx;
1407                         *pstart = exlock->start;
1408                         *psize = exlock->size;
1409                         *plock_type = exlock->lock_type;
1410                         return NT_STATUS_LOCK_NOT_GRANTED;
1411                 }
1412         }
1413
1414         /*
1415          * There is no lock held by an SMB daemon, check to
1416          * see if there is a POSIX lock from a UNIX or NFS process.
1417          */
1418
1419         if(lp_posix_locking(fsp->conn->params)) {
1420                 bool ret = is_posix_locked(fsp, pstart, psize, plock_type, POSIX_LOCK);
1421
1422                 DEBUG(10,("brl_lockquery: posix start=%.0f len=%.0f %s for %s file %s\n",
1423                         (double)*pstart, (double)*psize, ret ? "locked" : "unlocked",
1424                         fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
1425
1426                 if (ret) {
1427                         /* Hmmm. No clue what to set smblctx to - use -1. */
1428                         *psmblctx = 0xFFFFFFFFFFFFFFFFLL;
1429                         return NT_STATUS_LOCK_NOT_GRANTED;
1430                 }
1431         }
1432
1433         return NT_STATUS_OK;
1434 }
1435
1436
1437 bool smb_vfs_call_brl_cancel_windows(struct vfs_handle_struct *handle,
1438                                      struct byte_range_lock *br_lck,
1439                                      struct lock_struct *plock,
1440                                      struct blocking_lock_record *blr)
1441 {
1442         VFS_FIND(brl_cancel_windows);
1443         return handle->fns->brl_cancel_windows_fn(handle, br_lck, plock, blr);
1444 }
1445
1446 /****************************************************************************
1447  Remove a particular pending lock.
1448 ****************************************************************************/
1449 bool brl_lock_cancel(struct byte_range_lock *br_lck,
1450                 uint64_t smblctx,
1451                 struct server_id pid,
1452                 br_off start,
1453                 br_off size,
1454                 enum brl_flavour lock_flav,
1455                 struct blocking_lock_record *blr)
1456 {
1457         bool ret;
1458         struct lock_struct lock;
1459
1460         lock.context.smblctx = smblctx;
1461         lock.context.pid = pid;
1462         lock.context.tid = br_lck->fsp->conn->cnum;
1463         lock.start = start;
1464         lock.size = size;
1465         lock.fnum = br_lck->fsp->fnum;
1466         lock.lock_flav = lock_flav;
1467         /* lock.lock_type doesn't matter */
1468
1469         if (lock_flav == WINDOWS_LOCK) {
1470                 ret = SMB_VFS_BRL_CANCEL_WINDOWS(br_lck->fsp->conn, br_lck,
1471                     &lock, blr);
1472         } else {
1473                 ret = brl_lock_cancel_default(br_lck, &lock);
1474         }
1475
1476         return ret;
1477 }
1478
1479 bool brl_lock_cancel_default(struct byte_range_lock *br_lck,
1480                 struct lock_struct *plock)
1481 {
1482         unsigned int i;
1483         struct lock_struct *locks = br_lck->lock_data;
1484
1485         SMB_ASSERT(plock);
1486
1487         for (i = 0; i < br_lck->num_locks; i++) {
1488                 struct lock_struct *lock = &locks[i];
1489
1490                 /* For pending locks we *always* care about the fnum. */
1491                 if (brl_same_context(&lock->context, &plock->context) &&
1492                                 lock->fnum == plock->fnum &&
1493                                 IS_PENDING_LOCK(lock->lock_type) &&
1494                                 lock->lock_flav == plock->lock_flav &&
1495                                 lock->start == plock->start &&
1496                                 lock->size == plock->size) {
1497                         break;
1498                 }
1499         }
1500
1501         if (i == br_lck->num_locks) {
1502                 /* Didn't find it. */
1503                 return False;
1504         }
1505
1506         if (i < br_lck->num_locks - 1) {
1507                 /* Found this particular pending lock - delete it */
1508                 memmove(&locks[i], &locks[i+1],
1509                         sizeof(*locks)*((br_lck->num_locks-1) - i));
1510         }
1511
1512         br_lck->num_locks -= 1;
1513         br_lck->modified = True;
1514         return True;
1515 }
1516
1517 /****************************************************************************
1518  Remove any locks associated with a open file.
1519  We return True if this process owns any other Windows locks on this
1520  fd and so we should not immediately close the fd.
1521 ****************************************************************************/
1522
1523 void brl_close_fnum(struct messaging_context *msg_ctx,
1524                     struct byte_range_lock *br_lck)
1525 {
1526         files_struct *fsp = br_lck->fsp;
1527         uint32_t tid = fsp->conn->cnum;
1528         uint64_t fnum = fsp->fnum;
1529         unsigned int i;
1530         struct lock_struct *locks = br_lck->lock_data;
1531         struct server_id pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
1532         struct lock_struct *locks_copy;
1533         unsigned int num_locks_copy;
1534
1535         /* Copy the current lock array. */
1536         if (br_lck->num_locks) {
1537                 locks_copy = (struct lock_struct *)talloc_memdup(br_lck, locks, br_lck->num_locks * sizeof(struct lock_struct));
1538                 if (!locks_copy) {
1539                         smb_panic("brl_close_fnum: talloc failed");
1540                         }
1541         } else {
1542                 locks_copy = NULL;
1543         }
1544
1545         num_locks_copy = br_lck->num_locks;
1546
1547         for (i=0; i < num_locks_copy; i++) {
1548                 struct lock_struct *lock = &locks_copy[i];
1549
1550                 if (lock->context.tid == tid && serverid_equal(&lock->context.pid, &pid) &&
1551                                 (lock->fnum == fnum)) {
1552                         brl_unlock(msg_ctx,
1553                                 br_lck,
1554                                 lock->context.smblctx,
1555                                 pid,
1556                                 lock->start,
1557                                 lock->size,
1558                                 lock->lock_flav);
1559                 }
1560         }
1561 }
1562
1563 bool brl_mark_disconnected(struct files_struct *fsp)
1564 {
1565         uint32_t tid = fsp->conn->cnum;
1566         uint64_t smblctx;
1567         uint64_t fnum = fsp->fnum;
1568         unsigned int i;
1569         struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1570         struct byte_range_lock *br_lck = NULL;
1571
1572         if (fsp->op == NULL) {
1573                 return false;
1574         }
1575
1576         smblctx = fsp->op->global->open_persistent_id;
1577
1578         if (!fsp->op->global->durable) {
1579                 return false;
1580         }
1581
1582         if (fsp->current_lock_count == 0) {
1583                 return true;
1584         }
1585
1586         br_lck = brl_get_locks(talloc_tos(), fsp);
1587         if (br_lck == NULL) {
1588                 return false;
1589         }
1590
1591         for (i=0; i < br_lck->num_locks; i++) {
1592                 struct lock_struct *lock = &br_lck->lock_data[i];
1593
1594                 /*
1595                  * as this is a durable handle, we only expect locks
1596                  * of the current file handle!
1597                  */
1598
1599                 if (lock->context.smblctx != smblctx) {
1600                         TALLOC_FREE(br_lck);
1601                         return false;
1602                 }
1603
1604                 if (lock->context.tid != tid) {
1605                         TALLOC_FREE(br_lck);
1606                         return false;
1607                 }
1608
1609                 if (!serverid_equal(&lock->context.pid, &self)) {
1610                         TALLOC_FREE(br_lck);
1611                         return false;
1612                 }
1613
1614                 if (lock->fnum != fnum) {
1615                         TALLOC_FREE(br_lck);
1616                         return false;
1617                 }
1618
1619                 server_id_set_disconnected(&lock->context.pid);
1620                 lock->context.tid = TID_FIELD_INVALID;
1621                 lock->fnum = FNUM_FIELD_INVALID;
1622         }
1623
1624         br_lck->modified = true;
1625         TALLOC_FREE(br_lck);
1626         return true;
1627 }
1628
1629 bool brl_reconnect_disconnected(struct files_struct *fsp)
1630 {
1631         uint32_t tid = fsp->conn->cnum;
1632         uint64_t smblctx;
1633         uint64_t fnum = fsp->fnum;
1634         unsigned int i;
1635         struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1636         struct byte_range_lock *br_lck = NULL;
1637
1638         if (fsp->op == NULL) {
1639                 return false;
1640         }
1641
1642         smblctx = fsp->op->global->open_persistent_id;
1643
1644         if (!fsp->op->global->durable) {
1645                 return false;
1646         }
1647
1648         /*
1649          * When reconnecting, we do not want to validate the brlock entries
1650          * and thereby remove our own (disconnected) entries but reactivate
1651          * them instead.
1652          */
1653         fsp->lockdb_clean = true;
1654
1655         br_lck = brl_get_locks(talloc_tos(), fsp);
1656         if (br_lck == NULL) {
1657                 return false;
1658         }
1659
1660         if (br_lck->num_locks == 0) {
1661                 TALLOC_FREE(br_lck);
1662                 return true;
1663         }
1664
1665         for (i=0; i < br_lck->num_locks; i++) {
1666                 struct lock_struct *lock = &br_lck->lock_data[i];
1667
1668                 /*
1669                  * as this is a durable handle we only expect locks
1670                  * of the current file handle!
1671                  */
1672
1673                 if (lock->context.smblctx != smblctx) {
1674                         TALLOC_FREE(br_lck);
1675                         return false;
1676                 }
1677
1678                 if (lock->context.tid != TID_FIELD_INVALID) {
1679                         TALLOC_FREE(br_lck);
1680                         return false;
1681                 }
1682
1683                 if (!server_id_is_disconnected(&lock->context.pid)) {
1684                         TALLOC_FREE(br_lck);
1685                         return false;
1686                 }
1687
1688                 if (lock->fnum != FNUM_FIELD_INVALID) {
1689                         TALLOC_FREE(br_lck);
1690                         return false;
1691                 }
1692
1693                 lock->context.pid = self;
1694                 lock->context.tid = tid;
1695                 lock->fnum = fnum;
1696         }
1697
1698         fsp->current_lock_count = br_lck->num_locks;
1699         br_lck->modified = true;
1700         TALLOC_FREE(br_lck);
1701         return true;
1702 }
1703
1704 /****************************************************************************
1705  Ensure this set of lock entries is valid.
1706 ****************************************************************************/
1707 static bool validate_lock_entries(TALLOC_CTX *mem_ctx,
1708                                   unsigned int *pnum_entries, struct lock_struct **pplocks,
1709                                   bool keep_disconnected)
1710 {
1711         unsigned int i;
1712         unsigned int num_valid_entries = 0;
1713         struct lock_struct *locks = *pplocks;
1714         TALLOC_CTX *frame;
1715         struct server_id *ids;
1716         bool *exists;
1717
1718         if (*pnum_entries == 0) {
1719                 return true;
1720         }
1721
1722         frame = talloc_stackframe();
1723
1724         ids = talloc_array(frame, struct server_id, *pnum_entries);
1725         if (ids == NULL) {
1726                 DEBUG(0, ("validate_lock_entries: "
1727                           "talloc_array(struct server_id, %u) failed\n",
1728                           *pnum_entries));
1729                 talloc_free(frame);
1730                 return false;
1731         }
1732
1733         exists = talloc_array(frame, bool, *pnum_entries);
1734         if (exists == NULL) {
1735                 DEBUG(0, ("validate_lock_entries: "
1736                           "talloc_array(bool, %u) failed\n",
1737                           *pnum_entries));
1738                 talloc_free(frame);
1739                 return false;
1740         }
1741
1742         for (i = 0; i < *pnum_entries; i++) {
1743                 ids[i] = locks[i].context.pid;
1744         }
1745
1746         if (!serverids_exist(ids, *pnum_entries, exists)) {
1747                 DEBUG(3, ("validate_lock_entries: serverids_exists failed\n"));
1748                 talloc_free(frame);
1749                 return false;
1750         }
1751
1752         for (i = 0; i < *pnum_entries; i++) {
1753                 if (exists[i]) {
1754                         num_valid_entries++;
1755                         continue;
1756                 }
1757
1758                 if (keep_disconnected &&
1759                     server_id_is_disconnected(&ids[i]))
1760                 {
1761                         num_valid_entries++;
1762                         continue;
1763                 }
1764
1765                 /* This process no longer exists - mark this
1766                    entry as invalid by zeroing it. */
1767                 ZERO_STRUCTP(&locks[i]);
1768         }
1769         TALLOC_FREE(frame);
1770
1771         if (num_valid_entries != *pnum_entries) {
1772                 struct lock_struct *new_lock_data = NULL;
1773
1774                 if (num_valid_entries) {
1775                         new_lock_data = talloc_array(
1776                                 mem_ctx, struct lock_struct,
1777                                 num_valid_entries);
1778                         if (!new_lock_data) {
1779                                 DEBUG(3, ("malloc fail\n"));
1780                                 return False;
1781                         }
1782
1783                         num_valid_entries = 0;
1784                         for (i = 0; i < *pnum_entries; i++) {
1785                                 struct lock_struct *lock_data = &locks[i];
1786                                 if (lock_data->context.smblctx &&
1787                                                 lock_data->context.tid) {
1788                                         /* Valid (nonzero) entry - copy it. */
1789                                         memcpy(&new_lock_data[num_valid_entries],
1790                                                 lock_data, sizeof(struct lock_struct));
1791                                         num_valid_entries++;
1792                                 }
1793                         }
1794                 }
1795
1796                 TALLOC_FREE(*pplocks);
1797                 *pplocks = new_lock_data;
1798                 *pnum_entries = num_valid_entries;
1799         }
1800
1801         return True;
1802 }
1803
1804 struct brl_forall_cb {
1805         void (*fn)(struct file_id id, struct server_id pid,
1806                    enum brl_type lock_type,
1807                    enum brl_flavour lock_flav,
1808                    br_off start, br_off size,
1809                    void *private_data);
1810         void *private_data;
1811 };
1812
1813 /****************************************************************************
1814  Traverse the whole database with this function, calling traverse_callback
1815  on each lock.
1816 ****************************************************************************/
1817
1818 static int brl_traverse_fn(struct db_record *rec, void *state)
1819 {
1820         struct brl_forall_cb *cb = (struct brl_forall_cb *)state;
1821         struct lock_struct *locks;
1822         struct file_id *key;
1823         unsigned int i;
1824         unsigned int num_locks = 0;
1825         unsigned int orig_num_locks = 0;
1826         TDB_DATA dbkey;
1827         TDB_DATA value;
1828
1829         dbkey = dbwrap_record_get_key(rec);
1830         value = dbwrap_record_get_value(rec);
1831
1832         /* In a traverse function we must make a copy of
1833            dbuf before modifying it. */
1834
1835         locks = (struct lock_struct *)talloc_memdup(
1836                 talloc_tos(), value.dptr, value.dsize);
1837         if (!locks) {
1838                 return -1; /* Terminate traversal. */
1839         }
1840
1841         key = (struct file_id *)dbkey.dptr;
1842         orig_num_locks = num_locks = value.dsize/sizeof(*locks);
1843
1844         /* Ensure the lock db is clean of entries from invalid processes. */
1845
1846         if (!validate_lock_entries(talloc_tos(), &num_locks, &locks, true)) {
1847                 TALLOC_FREE(locks);
1848                 return -1; /* Terminate traversal */
1849         }
1850
1851         if (orig_num_locks != num_locks) {
1852                 if (num_locks) {
1853                         TDB_DATA data;
1854                         data.dptr = (uint8_t *)locks;
1855                         data.dsize = num_locks*sizeof(struct lock_struct);
1856                         dbwrap_record_store(rec, data, TDB_REPLACE);
1857                 } else {
1858                         dbwrap_record_delete(rec);
1859                 }
1860         }
1861
1862         if (cb->fn) {
1863                 for ( i=0; i<num_locks; i++) {
1864                         cb->fn(*key,
1865                                 locks[i].context.pid,
1866                                 locks[i].lock_type,
1867                                 locks[i].lock_flav,
1868                                 locks[i].start,
1869                                 locks[i].size,
1870                                 cb->private_data);
1871                 }
1872         }
1873
1874         TALLOC_FREE(locks);
1875         return 0;
1876 }
1877
1878 /*******************************************************************
1879  Call the specified function on each lock in the database.
1880 ********************************************************************/
1881
1882 int brl_forall(void (*fn)(struct file_id id, struct server_id pid,
1883                           enum brl_type lock_type,
1884                           enum brl_flavour lock_flav,
1885                           br_off start, br_off size,
1886                           void *private_data),
1887                void *private_data)
1888 {
1889         struct brl_forall_cb cb;
1890         NTSTATUS status;
1891         int count = 0;
1892
1893         if (!brlock_db) {
1894                 return 0;
1895         }
1896         cb.fn = fn;
1897         cb.private_data = private_data;
1898         status = dbwrap_traverse(brlock_db, brl_traverse_fn, &cb, &count);
1899
1900         if (!NT_STATUS_IS_OK(status)) {
1901                 return -1;
1902         } else {
1903                 return count;
1904         }
1905 }
1906
1907 /*******************************************************************
1908  Store a potentially modified set of byte range lock data back into
1909  the database.
1910  Unlock the record.
1911 ********************************************************************/
1912
1913 static void byte_range_lock_flush(struct byte_range_lock *br_lck)
1914 {
1915         size_t data_len;
1916         if (!br_lck->modified) {
1917                 DEBUG(10, ("br_lck not modified\n"));
1918                 goto done;
1919         }
1920
1921         data_len = br_lck->num_locks * sizeof(struct lock_struct);
1922
1923         if (br_lck->have_read_oplocks) {
1924                 data_len += 1;
1925         }
1926
1927         DEBUG(10, ("data_len=%d\n", (int)data_len));
1928
1929         if (data_len == 0) {
1930                 /* No locks - delete this entry. */
1931                 NTSTATUS status = dbwrap_record_delete(br_lck->record);
1932                 if (!NT_STATUS_IS_OK(status)) {
1933                         DEBUG(0, ("delete_rec returned %s\n",
1934                                   nt_errstr(status)));
1935                         smb_panic("Could not delete byte range lock entry");
1936                 }
1937         } else {
1938                 TDB_DATA data;
1939                 NTSTATUS status;
1940
1941                 data.dsize = data_len;
1942                 data.dptr = talloc_array(talloc_tos(), uint8_t, data_len);
1943                 SMB_ASSERT(data.dptr != NULL);
1944
1945                 memcpy(data.dptr, br_lck->lock_data,
1946                        br_lck->num_locks * sizeof(struct lock_struct));
1947
1948                 if (br_lck->have_read_oplocks) {
1949                         data.dptr[data_len-1] = 1;
1950                 }
1951
1952                 status = dbwrap_record_store(br_lck->record, data, TDB_REPLACE);
1953                 TALLOC_FREE(data.dptr);
1954                 if (!NT_STATUS_IS_OK(status)) {
1955                         DEBUG(0, ("store returned %s\n", nt_errstr(status)));
1956                         smb_panic("Could not store byte range mode entry");
1957                 }
1958         }
1959
1960         DEBUG(10, ("seqnum=%d\n", dbwrap_get_seqnum(brlock_db)));
1961
1962  done:
1963         br_lck->modified = false;
1964         TALLOC_FREE(br_lck->record);
1965 }
1966
1967 static int byte_range_lock_destructor(struct byte_range_lock *br_lck)
1968 {
1969         byte_range_lock_flush(br_lck);
1970         return 0;
1971 }
1972
1973 /*******************************************************************
1974  Fetch a set of byte range lock data from the database.
1975  Leave the record locked.
1976  TALLOC_FREE(brl) will release the lock in the destructor.
1977 ********************************************************************/
1978
1979 struct byte_range_lock *brl_get_locks(TALLOC_CTX *mem_ctx, files_struct *fsp)
1980 {
1981         TDB_DATA key, data;
1982         struct byte_range_lock *br_lck = talloc(mem_ctx, struct byte_range_lock);
1983
1984         if (br_lck == NULL) {
1985                 return NULL;
1986         }
1987
1988         br_lck->fsp = fsp;
1989         br_lck->num_locks = 0;
1990         br_lck->have_read_oplocks = false;
1991         br_lck->modified = False;
1992
1993         key.dptr = (uint8 *)&fsp->file_id;
1994         key.dsize = sizeof(struct file_id);
1995
1996         br_lck->record = dbwrap_fetch_locked(brlock_db, br_lck, key);
1997
1998         if (br_lck->record == NULL) {
1999                 DEBUG(3, ("Could not lock byte range lock entry\n"));
2000                 TALLOC_FREE(br_lck);
2001                 return NULL;
2002         }
2003
2004         data = dbwrap_record_get_value(br_lck->record);
2005
2006         br_lck->lock_data = NULL;
2007
2008         talloc_set_destructor(br_lck, byte_range_lock_destructor);
2009
2010         br_lck->num_locks = data.dsize / sizeof(struct lock_struct);
2011
2012         if (br_lck->num_locks != 0) {
2013                 br_lck->lock_data = talloc_array(
2014                         br_lck, struct lock_struct, br_lck->num_locks);
2015                 if (br_lck->lock_data == NULL) {
2016                         DEBUG(0, ("malloc failed\n"));
2017                         TALLOC_FREE(br_lck);
2018                         return NULL;
2019                 }
2020
2021                 memcpy(br_lck->lock_data, data.dptr,
2022                        talloc_get_size(br_lck->lock_data));
2023         }
2024
2025         DEBUG(10, ("data.dsize=%d\n", (int)data.dsize));
2026
2027         if ((data.dsize % sizeof(struct lock_struct)) == 1) {
2028                 br_lck->have_read_oplocks = (data.dptr[data.dsize-1] == 1);
2029         }
2030
2031         if (!fsp->lockdb_clean) {
2032                 int orig_num_locks = br_lck->num_locks;
2033
2034                 /*
2035                  * This is the first time we access the byte range lock
2036                  * record with this fsp. Go through and ensure all entries
2037                  * are valid - remove any that don't.
2038                  * This makes the lockdb self cleaning at low cost.
2039                  *
2040                  * Note: Disconnected entries belong to disconnected
2041                  * durable handles. So at this point, we have a new
2042                  * handle on the file and the disconnected durable has
2043                  * already been closed (we are not a durable reconnect).
2044                  * So we need to clean the disconnected brl entry.
2045                  */
2046
2047                 if (!validate_lock_entries(br_lck, &br_lck->num_locks,
2048                                            &br_lck->lock_data, false)) {
2049                         TALLOC_FREE(br_lck);
2050                         return NULL;
2051                 }
2052
2053                 /* Ensure invalid locks are cleaned up in the destructor. */
2054                 if (orig_num_locks != br_lck->num_locks) {
2055                         br_lck->modified = True;
2056                 }
2057
2058                 /* Mark the lockdb as "clean" as seen from this open file. */
2059                 fsp->lockdb_clean = True;
2060         }
2061
2062         if (DEBUGLEVEL >= 10) {
2063                 unsigned int i;
2064                 struct lock_struct *locks = br_lck->lock_data;
2065                 DEBUG(10,("brl_get_locks_internal: %u current locks on file_id %s\n",
2066                         br_lck->num_locks,
2067                           file_id_string_tos(&fsp->file_id)));
2068                 for( i = 0; i < br_lck->num_locks; i++) {
2069                         print_lock_struct(i, &locks[i]);
2070                 }
2071         }
2072
2073         return br_lck;
2074 }
2075
2076 struct brl_get_locks_readonly_state {
2077         TALLOC_CTX *mem_ctx;
2078         struct byte_range_lock **br_lock;
2079 };
2080
2081 static void brl_get_locks_readonly_parser(TDB_DATA key, TDB_DATA data,
2082                                           void *private_data)
2083 {
2084         struct brl_get_locks_readonly_state *state =
2085                 (struct brl_get_locks_readonly_state *)private_data;
2086         struct byte_range_lock *br_lock;
2087
2088         br_lock = talloc_pooled_object(
2089                 state->mem_ctx, struct byte_range_lock, 1, data.dsize);
2090         if (br_lock == NULL) {
2091                 *state->br_lock = NULL;
2092                 return;
2093         }
2094         br_lock->lock_data = (struct lock_struct *)talloc_memdup(
2095                 br_lock, data.dptr, data.dsize);
2096         br_lock->num_locks = data.dsize / sizeof(struct lock_struct);
2097
2098         if ((data.dsize % sizeof(struct lock_struct)) == 1) {
2099                 br_lock->have_read_oplocks = (data.dptr[data.dsize-1] == 1);
2100         } else {
2101                 br_lock->have_read_oplocks = false;
2102         }
2103
2104         DEBUG(10, ("Got %d bytes, have_read_oplocks: %s\n", (int)data.dsize,
2105                    br_lock->have_read_oplocks ? "true" : "false"));
2106
2107         *state->br_lock = br_lock;
2108 }
2109
2110 struct byte_range_lock *brl_get_locks_readonly(files_struct *fsp)
2111 {
2112         struct byte_range_lock *br_lock = NULL;
2113         struct byte_range_lock *rw = NULL;
2114
2115         DEBUG(10, ("seqnum=%d, fsp->brlock_seqnum=%d\n",
2116                    dbwrap_get_seqnum(brlock_db), fsp->brlock_seqnum));
2117
2118         if ((fsp->brlock_rec != NULL)
2119             && (dbwrap_get_seqnum(brlock_db) == fsp->brlock_seqnum)) {
2120                 /*
2121                  * We have cached the brlock_rec and the database did not
2122                  * change.
2123                  */
2124                 return fsp->brlock_rec;
2125         }
2126
2127         if (!fsp->lockdb_clean) {
2128                 /*
2129                  * Fetch the record in R/W mode to give validate_lock_entries
2130                  * a chance to kick in once.
2131                  */
2132                 rw = brl_get_locks(talloc_tos(), fsp);
2133                 if (rw == NULL) {
2134                         return NULL;
2135                 }
2136                 fsp->lockdb_clean = true;
2137         }
2138
2139         if (rw != NULL) {
2140                 size_t lock_data_size;
2141
2142                 /*
2143                  * Make a copy of the already retrieved and sanitized rw record
2144                  */
2145                 lock_data_size = rw->num_locks * sizeof(struct lock_struct);
2146                 br_lock = talloc_pooled_object(
2147                         fsp, struct byte_range_lock, 1, lock_data_size);
2148                 if (br_lock == NULL) {
2149                         goto fail;
2150                 }
2151                 br_lock->have_read_oplocks = rw->have_read_oplocks;
2152                 br_lock->num_locks = rw->num_locks;
2153                 br_lock->lock_data = (struct lock_struct *)talloc_memdup(
2154                         br_lock, rw->lock_data, lock_data_size);
2155         } else {
2156                 struct brl_get_locks_readonly_state state;
2157                 NTSTATUS status;
2158
2159                 /*
2160                  * Parse the record fresh from the database
2161                  */
2162
2163                 state.mem_ctx = fsp;
2164                 state.br_lock = &br_lock;
2165
2166                 status = dbwrap_parse_record(
2167                         brlock_db,
2168                         make_tdb_data((uint8_t *)&fsp->file_id,
2169                                       sizeof(fsp->file_id)),
2170                         brl_get_locks_readonly_parser, &state);
2171
2172                 if (NT_STATUS_EQUAL(status,NT_STATUS_NOT_FOUND)) {
2173                         /*
2174                          * No locks on this file. Return an empty br_lock.
2175                          */
2176                         br_lock = talloc(fsp, struct byte_range_lock);
2177                         if (br_lock == NULL) {
2178                                 goto fail;
2179                         }
2180
2181                         br_lock->have_read_oplocks = false;
2182                         br_lock->num_locks = 0;
2183                         br_lock->lock_data = NULL;
2184
2185                 } else if (!NT_STATUS_IS_OK(status)) {
2186                         DEBUG(3, ("Could not parse byte range lock record: "
2187                                   "%s\n", nt_errstr(status)));
2188                         goto fail;
2189                 }
2190                 if (br_lock == NULL) {
2191                         goto fail;
2192                 }
2193         }
2194
2195         br_lock->fsp = fsp;
2196         br_lock->modified = false;
2197         br_lock->record = NULL;
2198
2199         if (lp_clustering()) {
2200                 /*
2201                  * In the cluster case we can't cache the brlock struct
2202                  * because dbwrap_get_seqnum does not work reliably over
2203                  * ctdb. Thus we have to throw away the brlock struct soon.
2204                  */
2205                 talloc_steal(talloc_tos(), br_lock);
2206         } else {
2207                 /*
2208                  * Cache the brlock struct, invalidated when the dbwrap_seqnum
2209                  * changes. See beginning of this routine.
2210                  */
2211                 TALLOC_FREE(fsp->brlock_rec);
2212                 fsp->brlock_rec = br_lock;
2213                 fsp->brlock_seqnum = dbwrap_get_seqnum(brlock_db);
2214         }
2215
2216 fail:
2217         TALLOC_FREE(rw);
2218         return br_lock;
2219 }
2220
2221 struct brl_revalidate_state {
2222         ssize_t array_size;
2223         uint32 num_pids;
2224         struct server_id *pids;
2225 };
2226
2227 /*
2228  * Collect PIDs of all processes with pending entries
2229  */
2230
2231 static void brl_revalidate_collect(struct file_id id, struct server_id pid,
2232                                    enum brl_type lock_type,
2233                                    enum brl_flavour lock_flav,
2234                                    br_off start, br_off size,
2235                                    void *private_data)
2236 {
2237         struct brl_revalidate_state *state =
2238                 (struct brl_revalidate_state *)private_data;
2239
2240         if (!IS_PENDING_LOCK(lock_type)) {
2241                 return;
2242         }
2243
2244         add_to_large_array(state, sizeof(pid), (void *)&pid,
2245                            &state->pids, &state->num_pids,
2246                            &state->array_size);
2247 }
2248
2249 /*
2250  * qsort callback to sort the processes
2251  */
2252
2253 static int compare_procids(const void *p1, const void *p2)
2254 {
2255         const struct server_id *i1 = (const struct server_id *)p1;
2256         const struct server_id *i2 = (const struct server_id *)p2;
2257
2258         if (i1->pid < i2->pid) return -1;
2259         if (i1->pid > i2->pid) return 1;
2260         return 0;
2261 }
2262
2263 /*
2264  * Send a MSG_SMB_UNLOCK message to all processes with pending byte range
2265  * locks so that they retry. Mainly used in the cluster code after a node has
2266  * died.
2267  *
2268  * Done in two steps to avoid double-sends: First we collect all entries in an
2269  * array, then qsort that array and only send to non-dupes.
2270  */
2271
2272 void brl_revalidate(struct messaging_context *msg_ctx,
2273                     void *private_data,
2274                     uint32_t msg_type,
2275                     struct server_id server_id,
2276                     DATA_BLOB *data)
2277 {
2278         struct brl_revalidate_state *state;
2279         uint32 i;
2280         struct server_id last_pid;
2281
2282         if (!(state = talloc_zero(NULL, struct brl_revalidate_state))) {
2283                 DEBUG(0, ("talloc failed\n"));
2284                 return;
2285         }
2286
2287         brl_forall(brl_revalidate_collect, state);
2288
2289         if (state->array_size == -1) {
2290                 DEBUG(0, ("talloc failed\n"));
2291                 goto done;
2292         }
2293
2294         if (state->num_pids == 0) {
2295                 goto done;
2296         }
2297
2298         TYPESAFE_QSORT(state->pids, state->num_pids, compare_procids);
2299
2300         ZERO_STRUCT(last_pid);
2301
2302         for (i=0; i<state->num_pids; i++) {
2303                 if (serverid_equal(&last_pid, &state->pids[i])) {
2304                         /*
2305                          * We've seen that one already
2306                          */
2307                         continue;
2308                 }
2309
2310                 messaging_send(msg_ctx, state->pids[i], MSG_SMB_UNLOCK,
2311                                &data_blob_null);
2312                 last_pid = state->pids[i];
2313         }
2314
2315  done:
2316         TALLOC_FREE(state);
2317         return;
2318 }
2319
2320 bool brl_cleanup_disconnected(struct file_id fid, uint64_t open_persistent_id)
2321 {
2322         bool ret = false;
2323         TALLOC_CTX *frame = talloc_stackframe();
2324         TDB_DATA key, val;
2325         struct db_record *rec;
2326         struct lock_struct *lock;
2327         unsigned n, num;
2328         NTSTATUS status;
2329
2330         key = make_tdb_data((void*)&fid, sizeof(fid));
2331
2332         rec = dbwrap_fetch_locked(brlock_db, frame, key);
2333         if (rec == NULL) {
2334                 DEBUG(5, ("brl_cleanup_disconnected: failed to fetch record "
2335                           "for file %s\n", file_id_string(frame, &fid)));
2336                 goto done;
2337         }
2338
2339         val = dbwrap_record_get_value(rec);
2340         lock = (struct lock_struct*)val.dptr;
2341         num = val.dsize / sizeof(struct lock_struct);
2342         if (lock == NULL) {
2343                 DEBUG(10, ("brl_cleanup_disconnected: no byte range locks for "
2344                            "file %s\n", file_id_string(frame, &fid)));
2345                 ret = true;
2346                 goto done;
2347         }
2348
2349         for (n=0; n<num; n++) {
2350                 struct lock_context *ctx = &lock[n].context;
2351
2352                 if (!server_id_is_disconnected(&ctx->pid)) {
2353                         DEBUG(5, ("brl_cleanup_disconnected: byte range lock "
2354                                   "%s used by server %s, do not cleanup\n",
2355                                   file_id_string(frame, &fid),
2356                                   server_id_str(frame, &ctx->pid)));
2357                         goto done;
2358                 }
2359
2360                 if (ctx->smblctx != open_persistent_id) {
2361                         DEBUG(5, ("brl_cleanup_disconnected: byte range lock "
2362                                   "%s expected smblctx %llu but found %llu"
2363                                   ", do not cleanup\n",
2364                                   file_id_string(frame, &fid),
2365                                   (unsigned long long)open_persistent_id,
2366                                   (unsigned long long)ctx->smblctx));
2367                         goto done;
2368                 }
2369         }
2370
2371         status = dbwrap_record_delete(rec);
2372         if (!NT_STATUS_IS_OK(status)) {
2373                 DEBUG(5, ("brl_cleanup_disconnected: failed to delete record "
2374                           "for file %s from %s, open %llu: %s\n",
2375                           file_id_string(frame, &fid), dbwrap_name(brlock_db),
2376                           (unsigned long long)open_persistent_id,
2377                           nt_errstr(status)));
2378                 goto done;
2379         }
2380
2381         DEBUG(10, ("brl_cleanup_disconnected: "
2382                    "file %s cleaned up %u entries from open %llu\n",
2383                    file_id_string(frame, &fid), num,
2384                    (unsigned long long)open_persistent_id));
2385
2386         ret = true;
2387 done:
2388         talloc_free(frame);
2389         return ret;
2390 }