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