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