source3/locking/posix.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 3.0
   4    Locking functions
   5    Copyright (C) Jeremy Allison 1992-2000
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21    Revision History:
  22
  23    POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
  24 */
  25
  26 #include "includes.h"
  27 extern int DEBUGLEVEL;
  28 extern int global_smbpid;
  29
  30 /*
  31  * The POSIX locking database handle.
  32  */
  33
  34 static TDB_CONTEXT *posix_lock_tdb;
  35
  36 /*
  37  * The pending close database handle.
  38  */
  39
  40 static TDB_CONTEXT *posix_pending_close_tdb;
  41
  42 /*
  43  * The data in POSIX lock records is an unsorted linear array of these
  44  * records.  It is unnecessary to store the count as tdb provides the
  45  * size of the record.
  46  */
  47
  48 struct posix_lock {
  49         int fd;
  50         SMB_OFF_T start;
  51         SMB_OFF_T size;
  52         int lock_type;
  53 };
  54
  55 /*
  56  * The data in POSIX pending close records is an unsorted linear array of int
  57  * records.  It is unnecessary to store the count as tdb provides the
  58  * size of the record.
  59  */
  60
  61 /* The key used in both the POSIX databases. */
  62
  63 struct posix_lock_key {
  64         SMB_DEV_T device;
  65         SMB_INO_T inode;
  66 };
  67
  68 /*******************************************************************
  69  Form a static locking key for a dev/inode pair.
  70 ******************************************************************/
  71
  72 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
  73 {
  74         static struct posix_lock_key key;
  75         TDB_DATA kbuf;
  76
  77         memset(&key, '\0', sizeof(key));
  78         key.device = dev;
  79         key.inode = inode;
  80         kbuf.dptr = (char *)&key;
  81         kbuf.dsize = sizeof(key);
  82         return kbuf;
  83 }
  84
  85 /*******************************************************************
  86  Convenience function to get a key from an fsp.
  87 ******************************************************************/
  88
  89 static TDB_DATA locking_key_fsp(files_struct *fsp)
  90 {
  91         return locking_key(fsp->dev, fsp->inode);
  92 }
  93
  94 /****************************************************************************
  95  Add an fd to the pending close tdb.
  96 ****************************************************************************/
  97
  98 static BOOL add_fd_to_close_entry(files_struct *fsp)
  99 {
 100         TDB_DATA kbuf = locking_key_fsp(fsp);
 101         TDB_DATA dbuf;
 102
 103         dbuf.dptr = NULL;
 104
 105         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 106
 107         dbuf.dptr = Realloc(dbuf.dptr, dbuf.dsize + sizeof(int));
 108         if (!dbuf.dptr) {
 109                 DEBUG(0,("add_fd_to_close_entry: Realloc fail !\n"));
 110                 return False;
 111         }
 112         memcpy(dbuf.dptr + dbuf.dsize, &fsp->fd, sizeof(int));
 113         dbuf.dsize += sizeof(int);
 114
 115         if (tdb_store(posix_pending_close_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 116                 DEBUG(0,("add_fd_to_close_entry: tdb_store fail !\n"));
 117         }
 118
 119         free(dbuf.dptr);
 120         return True;
 121 }
 122
 123 /****************************************************************************
 124  Remove all fd entries for a specific dev/inode pair from the tdb.
 125 ****************************************************************************/
 126
 127 static void delete_close_entries(files_struct *fsp)
 128 {
 129         TDB_DATA kbuf = locking_key_fsp(fsp);
 130
 131         if (tdb_delete(posix_pending_close_tdb, kbuf) == -1)
 132                 DEBUG(0,("delete_close_entries: tdb_delete fail !\n"));
 133 }
 134
 135 /****************************************************************************
 136  Get the array of POSIX pending close records for an open fsp. Caller must
 137  free. Returns number of entries.
 138 ****************************************************************************/
 139
 140 static size_t get_posix_pending_close_entries(files_struct *fsp, int **entries)
 141 {
 142         TDB_DATA kbuf = locking_key_fsp(fsp);
 143         TDB_DATA dbuf;
 144         size_t count = 0;
 145
 146         *entries = NULL;
 147         dbuf.dptr = NULL;
 148
 149         dbuf = tdb_fetch(posix_pending_close_tdb, kbuf);
 150
 151     if (!dbuf.dptr) {
 152                 return 0;
 153         }
 154
 155         *entries = (int *)dbuf.dptr;
 156         count = (size_t)(dbuf.dsize / sizeof(int));
 157
 158         return count;
 159 }
 160
 161 /****************************************************************************
 162  Get the array of POSIX locks for an fsp. Caller must free. Returns
 163  number of entries.
 164 ****************************************************************************/
 165
 166 static size_t get_posix_lock_entries(files_struct *fsp, struct posix_lock **entries)
 167 {
 168         TDB_DATA kbuf = locking_key_fsp(fsp);
 169         TDB_DATA dbuf;
 170         size_t count = 0;
 171
 172         *entries = NULL;
 173
 174         dbuf.dptr = NULL;
 175
 176         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 177
 178     if (!dbuf.dptr) {
 179                 return 0;
 180         }
 181
 182         *entries = (struct posix_lock *)dbuf.dptr;
 183         count = (size_t)(dbuf.dsize / sizeof(struct posix_lock));
 184
 185         return count;
 186 }
 187
 188 /****************************************************************************
 189  Deal with pending closes needed by POSIX locking support.
 190  Note that posix_locking_close_file() is expected to have been called
 191  to delete all locks on this fsp before this function is called.
 192 ****************************************************************************/
 193
 194 int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
 195 {
 196         int saved_errno = 0;
 197         int ret;
 198         size_t count, i;
 199         struct posix_lock *entries = NULL;
 200         int *fd_array = NULL;
 201         BOOL locks_on_other_fds = False;
 202
 203         if (!lp_posix_locking(SNUM(conn))) {
 204                 /*
 205                  * No POSIX to worry about, just close.
 206                  */
 207                 ret = conn->vfs_ops.close(fsp->fd);
 208                 fsp->fd = -1;
 209                 return ret;
 210         }
 211
 212         /*
 213          * Get the number of outstanding POSIX locks on this dev/inode pair.
 214          */
 215
 216         count = get_posix_lock_entries(fsp, &entries);
 217
 218         /*
 219          * Check if there are any outstanding locks belonging to
 220          * other fd's. This should never be the case if posix_locking_close_file()
 221          * has been called first, but it never hurts to be *sure*.
 222          */
 223
 224         for (i = 0; i < count; i++) {
 225                 if (entries[i].fd != fsp->fd) {
 226                         locks_on_other_fds = True;
 227                         break;
 228                 }
 229         }
 230
 231         if (locks_on_other_fds) {
 232
 233                 /*
 234                  * There are outstanding locks on this dev/inode pair on other fds.
 235                  * Add our fd to the pending close tdb and set fsp->fd to -1.
 236                  */
 237
 238                 if (!add_fd_to_close_entry(fsp)) {
 239                         free((char *)entries);
 240                         return False;
 241                 }
 242
 243                 free((char *)entries);
 244                 fsp->fd = -1;
 245                 return 0;
 246         }
 247
 248         if(entries)
 249                 free((char *)entries);
 250
 251         /*
 252          * No outstanding POSIX locks. Get the pending close fd's
 253          * from the tdb and close them all.
 254          */
 255
 256         count = get_posix_pending_close_entries(fsp, &fd_array);
 257
 258         if (count) {
 259                 DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
 260
 261                 for(i = 0; i < count; i++) {
 262                         if (conn->vfs_ops.close(fd_array[i]) == -1) {
 263                                 saved_errno = errno;
 264                         }
 265                 }
 266
 267                 /*
 268                  * Delete all fd's stored in the tdb
 269                  * for this dev/inode pair.
 270                  */
 271
 272                 delete_close_entries(fsp);
 273         }
 274
 275         if (fd_array)
 276                 free((char *)fd_array);
 277
 278         /*
 279          * Finally close the fd associated with this fsp.
 280          */
 281
 282         ret = conn->vfs_ops.close(fsp->fd);
 283
 284         if (saved_errno != 0) {
 285         errno = saved_errno;
 286                 ret = -1;
 287     }
 288
 289         fsp->fd = -1;
 290
 291         return ret;
 292 }
 293
 294 /****************************************************************************
 295  Debugging aid :-).
 296 ****************************************************************************/
 297
 298 static const char *posix_lock_type_name(int lock_type)
 299 {
 300         return (lock_type == F_RDLCK) ? "READ" : "WRITE";
 301 }
 302
 303 /****************************************************************************
 304  Delete a POSIX lock entry by index number. Used if the tdb add succeeds, but
 305  then the POSIX fcntl lock fails.
 306 ****************************************************************************/
 307
 308 static BOOL delete_posix_lock_entry_by_index(files_struct *fsp, size_t entry)
 309 {
 310         TDB_DATA kbuf = locking_key_fsp(fsp);
 311         TDB_DATA dbuf;
 312         struct posix_lock *locks;
 313         size_t count;
 314
 315         dbuf.dptr = NULL;
 316
 317         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 318
 319         if (!dbuf.dptr) {
 320                 DEBUG(10,("delete_posix_lock_entry_by_index: tdb_fetch failed !\n"));
 321                 goto fail;
 322         }
 323
 324         count = (size_t)(dbuf.dsize / sizeof(struct posix_lock));
 325         locks = (struct posix_lock *)dbuf.dptr;
 326
 327         if (count == 1) {
 328                 tdb_delete(posix_lock_tdb, kbuf);
 329         } else {
 330                 if (entry < count-1) {
 331                         memmove(&locks[entry], &locks[entry+1], sizeof(*locks)*((count-1) - entry));
 332                 }
 333                 dbuf.dsize -= sizeof(*locks);
 334                 tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE);
 335         }
 336
 337         free(dbuf.dptr);
 338
 339         return True;
 340
 341  fail:
 342     if (dbuf.dptr)
 343                 free(dbuf.dptr);
 344     return False;
 345 }
 346
 347 /****************************************************************************
 348  Add an entry into the POSIX locking tdb. Returns the number of records that
 349  completely overlap this request, or -1 on error. entry_num gets set to the
 350  index number of the added lock (used in case we need to delete *exactly*
 351  this entry).
 352 ****************************************************************************/
 353
 354 static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, int lock_type, size_t *entry_num)
 355 {
 356         TDB_DATA kbuf = locking_key_fsp(fsp);
 357         TDB_DATA dbuf;
 358         struct posix_lock pl;
 359         struct posix_lock *entries;
 360         size_t i, count;
 361         int num_overlapping_records = 0;
 362
 363         *entry_num = 0;
 364
 365         /*
 366          * Windows is very strange. It allows read locks to be overlayed on
 367          * a write lock, but leaves the write lock in force until the first
 368          * unlock. It also reference counts the locks. This means the following sequence :
 369          *
 370          * process1                                      process2
 371          * ------------------------------------------------------------------------
 372          * WRITE LOCK : start = 0, len = 10
 373          *                                            READ LOCK: start =0, len = 10 - FAIL
 374          * READ LOCK : start = 5, len = 2
 375          *                                            READ LOCK: start =0, len = 10 - FAIL
 376          * UNLOCK : start = 0, len = 10
 377          *                                            READ LOCK: start =0, len = 10 - OK
 378          *
 379          * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
 380          * would leave a single read lock over the 0-10 region. In order to
 381          * re-create Windows semantics mapped to POSIX locks, we create multiple TDB
 382          * entries, one for each overlayed lock request. We are guarenteed by the brlock
 383          * semantics that if a write lock is added, then it will be first in the array.
 384          */
 385
 386         dbuf.dptr = NULL;
 387
 388         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 389
 390         count = (size_t)(dbuf.dsize / sizeof(pl));
 391         entries = (struct posix_lock *)dbuf.dptr;
 392
 393         /*
 394          * Ensure we look for overlapping entries *before*
 395          * we add this entry. Count the number of entries
 396          * that completely overlap this request.
 397          */
 398
 399         for (i = 0; i < count; i++) {
 400                 struct posix_lock *entry = &entries[i];
 401
 402                 if (fsp->fd == entry->fd &&
 403                         start >= entry->start &&
 404                         start + size <= entry->start + entry->size)
 405                                 num_overlapping_records++;
 406         }
 407
 408         /*
 409          * Add new record.
 410          */
 411
 412         pl.fd = fsp->fd;
 413         pl.start = start;
 414         pl.size = size;
 415         pl.lock_type = lock_type;
 416
 417         dbuf.dptr = Realloc(dbuf.dptr, dbuf.dsize + sizeof(pl));
 418         if (!dbuf.dptr) {
 419                 DEBUG(0,("add_posix_lock_entry: Realloc fail !\n"));
 420                 goto fail;
 421         }
 422
 423         memcpy(dbuf.dptr + dbuf.dsize, &pl, sizeof(pl));
 424         dbuf.dsize += sizeof(pl);
 425
 426         *entry_num = count;
 427
 428         if (tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 429                 DEBUG(0,("add_posix_lock: Failed to add lock entry on file %s\n", fsp->fsp_name));
 430                 goto fail;
 431         }
 432
 433     free(dbuf.dptr);
 434
 435         DEBUG(10,("add_posix_lock: File %s: type = %s: start=%.0f size=%.0f: num_records = %d : dev=%.0f inode=%.0f\n",
 436                         fsp->fsp_name, posix_lock_type_name(lock_type), (double)start, (double)size, num_overlapping_records,
 437                         (double)fsp->dev, (double)fsp->inode ));
 438
 439     return num_overlapping_records;
 440
 441  fail:
 442     if (dbuf.dptr)
 443                 free(dbuf.dptr);
 444         *entry_num = 0;
 445     return -1;
 446 }
 447
 448 /****************************************************************************
 449  Delete an entry from the POSIX locking tdb. Returns a copy of the entry being
 450  deleted and the number of records that are completely overlapped by this one,
 451  or -1 on error.
 452 ****************************************************************************/
 453
 454 static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, struct posix_lock *pl)
 455 {
 456         TDB_DATA kbuf = locking_key_fsp(fsp);
 457         TDB_DATA dbuf;
 458         struct posix_lock *locks;
 459         size_t i, count;
 460         BOOL found = False;
 461         int num_overlapping_records = 0;
 462
 463         dbuf.dptr = NULL;
 464
 465         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 466
 467         if (!dbuf.dptr) {
 468                 DEBUG(10,("delete_posix_lock_entry: tdb_fetch failed !\n"));
 469                 goto fail;
 470         }
 471
 472         /* There are existing locks - find a match. */
 473         locks = (struct posix_lock *)dbuf.dptr;
 474         count = (size_t)(dbuf.dsize / sizeof(*locks));
 475
 476         /*
 477          * Search for and delete the first record that matches the
 478          * unlock criteria.
 479          */
 480
 481         for (i=0; i<count; i++) {
 482                 struct posix_lock *entry = &locks[i];
 483
 484                 if (entry->fd == fsp->fd &&
 485                         entry->start == start &&
 486                         entry->size == size) {
 487
 488                         /* Make a copy if requested. */
 489                         if (pl)
 490                                 *pl = *entry;
 491
 492                         /* Found it - delete it. */
 493                         if (count == 1) {
 494                                 tdb_delete(posix_lock_tdb, kbuf);
 495                         } else {
 496                                 if (i < count-1) {
 497                                         memmove(&locks[i], &locks[i+1], sizeof(*locks)*((count-1) - i));
 498                                 }
 499                                 dbuf.dsize -= sizeof(*locks);
 500                                 tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE);
 501                         }
 502                         count--;
 503                         found = True;
 504                         break;
 505                 }
 506         }
 507
 508         if (!found)
 509                 goto fail;
 510
 511         /*
 512          * Count the number of entries that are
 513          * overlapped completely by this unlock request.
 514          * (Note that this is the reverse of the test in
 515          * add_posix_lock).
 516          */
 517
 518         for (i = 0; i < count; i++) {
 519                 struct posix_lock *entry = &locks[i];
 520
 521                 if (fsp->fd == entry->fd &&
 522                         entry->start >= start &&
 523                         entry->start + entry->size <= start + size)
 524                                 num_overlapping_records++;
 525         }
 526
 527                 DEBUG(10,("delete_posix_lock_entry: type = %s: start=%.0f size=%.0f, num_records = %d\n",
 528                                 posix_lock_type_name(pl->lock_type), (double)pl->start, (double)pl->size,
 529                                         (unsigned int)num_overlapping_records ));
 530
 531     if (dbuf.dptr)
 532                 free(dbuf.dptr);
 533
 534         return num_overlapping_records;
 535
 536  fail:
 537     if (dbuf.dptr)
 538                 free(dbuf.dptr);
 539     return -1;
 540 }
 541
 542 /****************************************************************************
 543  Utility function to map a lock type correctly depending on the open
 544  mode of a file.
 545 ****************************************************************************/
 546
 547 static int map_posix_lock_type( files_struct *fsp, enum brl_type lock_type)
 548 {
 549         if((lock_type == WRITE_LOCK) && !fsp->can_write) {
 550                 /*
 551                  * Many UNIX's cannot get a write lock on a file opened read-only.
 552                  * Win32 locking semantics allow this.
 553                  * Do the best we can and attempt a read-only lock.
 554                  */
 555                 DEBUG(10,("map_posix_lock_type: Downgrading write lock to read due to read-only file.\n"));
 556                 return F_RDLCK;
 557         } else if((lock_type == READ_LOCK) && !fsp->can_read) {
 558                 /*
 559                  * Ditto for read locks on write only files.
 560                  */
 561                 DEBUG(10,("map_posix_lock_type: Changing read lock to write due to write-only file.\n"));
 562                 return F_WRLCK;
 563         }
 564
 565   /*
 566    * This return should be the most normal, as we attempt
 567    * to always open files read/write.
 568    */
 569
 570   return (lock_type == READ_LOCK) ? F_RDLCK : F_WRLCK;
 571 }
 572
 573 /****************************************************************************
 574  Check to see if the given unsigned lock range is within the possible POSIX
 575  range. Modifies the given args to be in range if possible, just returns
 576  False if not.
 577 ****************************************************************************/
 578
 579 static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
 580                                                                 SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
 581 {
 582         SMB_OFF_T offset;
 583         SMB_OFF_T count;
 584
 585 #if defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
 586
 587     SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
 588     SMB_OFF_T mask = (mask2<<1);
 589     SMB_OFF_T neg_mask = ~mask;
 590
 591         /*
 592          * In this case SMB_OFF_T is 64 bits,
 593          * and the underlying system can handle 64 bit signed locks.
 594          * Cast to signed type.
 595          */
 596
 597         offset = (SMB_OFF_T)u_offset;
 598         count = (SMB_OFF_T)u_count;
 599
 600         /*
 601          * Deal with a very common case of count of all ones.
 602          * (lock entire file).
 603          */
 604
 605         if(count == (SMB_OFF_T)-1)
 606                 count &= ~mask;
 607
 608         /*
 609          * POSIX lock ranges cannot be negative.
 610          * Fail if any combination becomes negative.
 611          */
 612
 613         if(offset < 0 || count < 0 || (offset + count < 0)) {
 614                 DEBUG(10,("posix_lock_in_range: negative range: offset = %.0f, count = %.0f. Ignoring lock.\n",
 615                                 (double)offset, (double)count ));
 616                 return False;
 617         }
 618
 619         /*
 620          * In this case SMB_OFF_T is 64 bits, the offset and count
 621          * fit within the positive range, and the underlying
 622          * system can handle 64 bit locks. Just return as the
 623          * cast values are ok.
 624          */
 625
 626 #else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
 627
 628         /*
 629          * In this case either SMB_OFF_T is 32 bits,
 630          * or the underlying system cannot handle 64 bit signed locks.
 631          * Either way we have to try and mangle to fit within 31 bits.
 632          * This is difficult.
 633          */
 634
 635 #if defined(HAVE_BROKEN_FCNTL64_LOCKS)
 636
 637         /*
 638          * SMB_OFF_T is 64 bits, but we need to use 31 bits due to
 639          * broken large locking.
 640          */
 641
 642         /*
 643          * Deal with a very common case of count of all ones.
 644          * (lock entire file).
 645          */
 646
 647         if(u_count == (SMB_BIG_UINT)-1)
 648                 count = 0x7FFFFFFF;
 649
 650         if(((u_offset >> 32) & 0xFFFFFFFF) || ((u_count >> 32) & 0xFFFFFFFF)) {
 651                 DEBUG(10,("posix_lock_in_range: top 32 bits not zero. offset = %.0f, count = %.0f. Ignoring lock.\n",
 652                                 (double)u_offset, (double)u_count ));
 653                 /* Top 32 bits of offset or count were not zero. */
 654                 return False;
 655         }
 656
 657         /* Cast from 64 bits unsigned to 64 bits signed. */
 658         offset = (SMB_OFF_T)u_offset;
 659         count = (SMB_OFF_T)u_count;
 660
 661         /*
 662          * Check if we are within the 2^31 range.
 663          */
 664
 665         {
 666                 int32 low_offset = (int32)offset;
 667                 int32 low_count = (int32)count;
 668
 669                 if(low_offset < 0 || low_count < 0 || (low_offset + low_count < 0)) {
 670                         DEBUG(10,("posix_lock_in_range: not within 2^31 range. low_offset = %d, low_count = %d. Ignoring lock.\n",
 671                                         low_offset, low_count ));
 672                         return False;
 673                 }
 674         }
 675
 676         /*
 677          * Ok - we can map from a 64 bit number to a 31 bit lock.
 678          */
 679
 680 #else /* HAVE_BROKEN_FCNTL64_LOCKS */
 681
 682         /*
 683          * SMB_OFF_T is 32 bits.
 684          */
 685
 686 #if defined(HAVE_LONGLONG)
 687
 688         /*
 689          * SMB_BIG_UINT is 64 bits, we can do a 32 bit shift.
 690          */
 691
 692         /*
 693          * Deal with a very common case of count of all ones.
 694          * (lock entire file).
 695          */
 696
 697         if(u_count == (SMB_BIG_UINT)-1)
 698                 count = 0x7FFFFFFF;
 699
 700         if(((u_offset >> 32) & 0xFFFFFFFF) || ((u_count >> 32) & 0xFFFFFFFF)) {
 701                 DEBUG(10,("posix_lock_in_range: top 32 bits not zero. u_offset = %.0f, u_count = %.0f. Ignoring lock.\n",
 702                                 (double)u_offset, (double)u_count ));
 703                 return False;
 704         }
 705
 706         /* Cast from 64 bits unsigned to 32 bits signed. */
 707         offset = (SMB_OFF_T)u_offset;
 708         count = (SMB_OFF_T)u_count;
 709
 710         /*
 711          * Check if we are within the 2^31 range.
 712          */
 713
 714         if(offset < 0 || count < 0 || (offset + count < 0)) {
 715                 DEBUG(10,("posix_lock_in_range: not within 2^31 range. offset = %d, count = %d. Ignoring lock.\n",
 716                                 (int)offset, (int)count ));
 717                 return False;
 718         }
 719
 720 #else /* HAVE_LONGLONG */
 721
 722         /*
 723          * SMB_BIG_UINT and SMB_OFF_T are both 32 bits,
 724          * just cast.
 725          */
 726
 727         /*
 728          * Deal with a very common case of count of all ones.
 729          * (lock entire file).
 730          */
 731
 732         if(u_count == (SMB_BIG_UINT)-1)
 733                 count = 0x7FFFFFFF;
 734
 735         /* Cast from 32 bits unsigned to 32 bits signed. */
 736         offset = (SMB_OFF_T)u_offset;
 737         count = (SMB_OFF_T)u_count;
 738
 739         /*
 740          * Check if we are within the 2^31 range.
 741          */
 742
 743         if(offset < 0 || count < 0 || (offset + count < 0)) {
 744                 DEBUG(10,("posix_lock_in_range: not within 2^31 range. offset = %d, count = %d. Ignoring lock.\n",
 745                                 (int)offset, (int)count ));
 746                 return False;
 747         }
 748
 749 #endif /* HAVE_LONGLONG */
 750 #endif /* LARGE_SMB_OFF_T */
 751 #endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
 752
 753         /*
 754          * The mapping was successful.
 755          */
 756
 757         DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
 758                         (double)offset, (double)count ));
 759
 760         *offset_out = offset;
 761         *count_out = count;
 762
 763         return True;
 764 }
 765
 766 #if defined(LARGE_SMB_OFF_T)
 767 /****************************************************************************
 768  Pathetically try and map a 64 bit lock offset into 31 bits. I hate Windows :-).
 769 ****************************************************************************/
 770
 771 static uint32 map_lock_offset(uint32 high, uint32 low)
 772 {
 773         unsigned int i;
 774         uint32 mask = 0;
 775         uint32 highcopy = high;
 776
 777         /*
 778          * Try and find out how many significant bits there are in high.
 779          */
 780
 781         for(i = 0; highcopy; i++)
 782                 highcopy >>= 1;
 783
 784         /*
 785          * We use 31 bits not 32 here as POSIX
 786          * lock offsets may not be negative.
 787          */
 788
 789         mask = (~0) << (31 - i);
 790
 791         if(low & mask)
 792                 return 0; /* Fail. */
 793
 794         high <<= (31 - i);
 795
 796         return (high|low);
 797 }
 798 #endif
 799
 800 /****************************************************************************
 801  Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
 802  broken NFS implementations.
 803 ****************************************************************************/
 804
 805 static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 806 {
 807         int ret;
 808         struct connection_struct *conn = fsp->conn;
 809
 810 #if defined(LARGE_SMB_OFF_T)
 811         /*
 812          * In the 64 bit locking case we store the original
 813          * values in case we have to map to a 32 bit lock on
 814          * a filesystem that doesn't support 64 bit locks.
 815          */
 816         SMB_OFF_T orig_offset = offset;
 817         SMB_OFF_T orig_count = count;
 818 #endif /* LARGE_SMB_OFF_T */
 819
 820         DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fd,op,(double)offset,(double)count,type));
 821
 822         ret = conn->vfs_ops.lock(fsp->fd,op,offset,count,type);
 823
 824         if (!ret && (errno == EFBIG)) {
 825                 if( DEBUGLVL( 0 )) {
 826                         dbgtext("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n", (double)offset,(double)count);
 827                         dbgtext("a 'file too large' error. This can happen when using 64 bit lock offsets\n");
 828                         dbgtext("on 32 bit NFS mounted file systems. Retrying with 32 bit truncated length.\n");
 829                 }
 830                 /* 32 bit NFS file system, retry with smaller offset */
 831                 errno = 0;
 832                 count &= 0x7fffffff;
 833                 ret = conn->vfs_ops.lock(fsp->fd,op,offset,count,type);
 834         }
 835
 836         /* A lock query - just return. */
 837         if (op == SMB_F_GETLK)
 838                 return ret;
 839
 840         /* A lock set or unset. */
 841         if (!ret) {
 842                 DEBUG(3,("posix_fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
 843                                 (double)offset,(double)count,op,type,strerror(errno)));
 844
 845                 /* Perhaps it doesn't support this sort of locking ? */
 846                 if (errno == EINVAL) {
 847 #if defined(LARGE_SMB_OFF_T)
 848                         {
 849                                 /*
 850                                  * Ok - if we get here then we have a 64 bit lock request
 851                                  * that has returned EINVAL. Try and map to 31 bits for offset
 852                                  * and length and try again. This may happen if a filesystem
 853                                  * doesn't support 64 bit offsets (efs/ufs) although the underlying
 854                                  * OS does.
 855                                  */
 856                                 uint32 off_low = (orig_offset & 0xFFFFFFFF);
 857                                 uint32 off_high = ((orig_offset >> 32) & 0xFFFFFFFF);
 858
 859                                 count = (orig_count & 0x7FFFFFFF);
 860                                 offset = (SMB_OFF_T)map_lock_offset(off_high, off_low);
 861                                 ret = conn->vfs_ops.lock(fsp->fd,op,offset,count,type);
 862                                 if (!ret) {
 863                                         if (errno == EINVAL) {
 864                                                 DEBUG(3,("posix_fcntl_lock: locking not supported? returning True\n"));
 865                                                 return(True);
 866                                         }
 867                                         return False;
 868                                 }
 869                                 DEBUG(3,("posix_fcntl_lock: 64 -> 32 bit modified lock call successful\n"));
 870                                 return True;
 871                         }
 872 #else /* LARGE_SMB_OFF_T */
 873                         DEBUG(3,("locking not supported? returning True\n"));
 874                         return(True);
 875 #endif /* LARGE_SMB_OFF_T */
 876                 }
 877
 878                 return(False);
 879         }
 880
 881         DEBUG(8,("posix_fcntl_lock: Lock call successful\n"));
 882
 883         return(True);
 884 }
 885
 886 /****************************************************************************
 887  POSIX function to see if a file region is locked. Returns True if the
 888  region is locked, False otherwise.
 889 ****************************************************************************/
 890
 891 BOOL is_posix_locked(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count, enum brl_type lock_type)
 892 {
 893         SMB_OFF_T offset;
 894         SMB_OFF_T count;
 895         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
 896
 897         DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, type = %s\n",
 898                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
 899
 900         /*
 901          * If the requested lock won't fit in the POSIX range, we will
 902          * never set it, so presume it is not locked.
 903          */
 904
 905         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
 906                 return False;
 907
 908         /*
 909          * Note that most UNIX's can *test* for a write lock on
 910          * a read-only fd, just not *set* a write lock on a read-only
 911          * fd. So we don't need to use map_lock_type here.
 912          */
 913
 914         return posix_fcntl_lock(fsp,SMB_F_GETLK,offset,count,posix_lock_type);
 915 }
 916
 917 /****************************************************************************
 918  POSIX function to acquire a lock. Returns True if the
 919  lock could be granted, False if not.
 920 ****************************************************************************/
 921
 922 BOOL set_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count, enum brl_type lock_type)
 923 {
 924         SMB_OFF_T offset;
 925         SMB_OFF_T count;
 926         BOOL ret = True;
 927         size_t entry_num = 0;
 928         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
 929         int num_overlapping_records;
 930
 931         DEBUG(5,("set_posix_lock: File %s, offset = %.0f, count = %.0f, type = %s\n",
 932                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
 933
 934         /*
 935          * If the requested lock won't fit in the POSIX range, we will
 936          * pretend it was successful.
 937          */
 938
 939         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
 940                 return True;
 941
 942         /*
 943          * Note that setting multiple overlapping locks on different
 944          * file descriptors will not be held separately by the kernel (POSIX
 945          * braindamage), but will be merged into one continuous lock
 946          * range. We cope with this case in the release_posix_lock code
 947          * below. We need to add the posix lock entry into the tdb before
 948          * doing the real posix lock call to deal with the locking overlay
 949          * case described above in add_posix_lock_entry().
 950          */
 951
 952         num_overlapping_records = add_posix_lock_entry(fsp,offset,count,posix_lock_type,&entry_num);
 953
 954         if (num_overlapping_records == -1) {
 955                 DEBUG(0,("set_posix_lock: Unable to create posix lock entry !\n"));
 956                 return False;
 957         }
 958
 959         /*
 960          * num_overlapping_records is the count of lock records that
 961          * completely contain this request on the same fsp. Only bother
 962          * with the real lock request if there are none, otherwise ignore.
 963          */
 964
 965         if (num_overlapping_records == 0) {
 966                 /*
 967                  * First lock entry for this range created. Do a real POSIX lock.
 968                  */
 969             ret = posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type);
 970
 971                 /*
 972                  * Oops, POSIX lock failed, delete the tdb entry we just added.
 973                  */
 974                 if (!ret)
 975                         delete_posix_lock_entry_by_index(fsp,entry_num);
 976         }
 977
 978         return ret;
 979 }
 980
 981 /*
 982  * Structure used when splitting a lock range
 983  * into a POSIX lock range. Doubly linked list.
 984  */
 985
 986 struct unlock_list {
 987     struct unlock_list *next;
 988     struct unlock_list *prev;
 989     SMB_OFF_T start;
 990     SMB_OFF_T size;
 991 };
 992
 993 /****************************************************************************
 994  Create a list of lock ranges that don't overlap a given range. Used in calculating
 995  POSIX lock unlocks. This is a difficult function that requires ASCII art to
 996  understand it :-).
 997 ****************************************************************************/
 998
 999 static struct unlock_list *posix_unlock_list(TALLOC_CTX *ctx, struct unlock_list *ulhead, files_struct *fsp)
1000 {
1001         TDB_DATA kbuf = locking_key_fsp(fsp);
1002         TDB_DATA dbuf;
1003         struct posix_lock *locks;
1004         size_t num_locks, i;
1005
1006         dbuf.dptr = NULL;
1007
1008         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
1009
1010         if (!dbuf.dptr) {
1011                 return ulhead;
1012         }
1013
1014         locks = (struct posix_lock *)dbuf.dptr;
1015         num_locks = (size_t)(dbuf.dsize / sizeof(*locks));
1016
1017         /*
1018          * Check the current lock list on this dev/inode pair.
1019          * Quit if the list is deleted.
1020          */
1021
1022         DEBUG(10,("posix_unlock_list: curr: start=%.0f,size=%.0f\n",
1023                 (double)ulhead->start, (double)ulhead->size ));
1024
1025         for (i=0; i<num_locks && ulhead; i++) {
1026
1027                 struct posix_lock *lock = &locks[i];
1028                 struct unlock_list *ul_curr;
1029
1030                 /*
1031                  * Walk the unlock list, checking for overlaps. Note that
1032                  * the unlock list can expand within this loop if the current
1033                  * range being examined needs to be split.
1034                  */
1035
1036                 for (ul_curr = ulhead; ul_curr;) {
1037
1038                         DEBUG(10,("posix_unlock_list: lock: fd=%d: start=%.0f,size=%.0f:type=%s", lock->fd,
1039                                 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
1040
1041                         if ( (ul_curr->start >= (lock->start + lock->size)) ||
1042                                  (lock->start >= (ul_curr->start + ul_curr->size))) {
1043
1044                                 /* No overlap with this lock - leave this range alone. */
1045 /*********************************************
1046                                              +---------+
1047                                              | ul_curr |
1048                                              +---------+
1049                                 +-------+
1050                                 | lock  |
1051                                 +-------+
1052 OR....
1053              +---------+
1054              | ul_curr |
1055              +---------+
1056 **********************************************/
1057
1058                                 DEBUG(10,("no overlap case.\n" ));
1059
1060                                 ul_curr = ul_curr->next;
1061
1062                         } else if ( (ul_curr->start >= lock->start) &&
1063                                                 (ul_curr->start + ul_curr->size <= lock->start + lock->size) ) {
1064
1065                                 /*
1066                                  * This unlock is completely overlapped by this existing lock range
1067                                  * and thus should have no effect (not be unlocked). Delete it from the list.
1068                                  */
1069 /*********************************************
1070                 +---------+
1071                 | ul_curr |
1072                 +---------+
1073         +---------------------------+
1074         |       lock                |
1075         +---------------------------+
1076 **********************************************/
1077                                 /* Save the next pointer */
1078                                 struct unlock_list *ul_next = ul_curr->next;
1079
1080                                 DEBUG(10,("delete case.\n" ));
1081
1082                                 DLIST_REMOVE(ulhead, ul_curr);
1083                                 if(ulhead == NULL)
1084                                         break; /* No more list... */
1085
1086                                 ul_curr = ul_next;
1087
1088                         } else if ( (ul_curr->start >= lock->start) &&
1089                                                 (ul_curr->start < lock->start + lock->size) &&
1090                                                 (ul_curr->start + ul_curr->size > lock->start + lock->size) ) {
1091
1092                                 /*
1093                                  * This unlock overlaps the existing lock range at the high end.
1094                                  * Truncate by moving start to existing range end and reducing size.
1095                                  */
1096 /*********************************************
1097                 +---------------+
1098                 | ul_curr       |
1099                 +---------------+
1100         +---------------+
1101         |    lock       |
1102         +---------------+
1103 BECOMES....
1104                         +-------+
1105                         |ul_curr|
1106                         +-------+
1107 **********************************************/
1108
1109                                 ul_curr->size = (ul_curr->start + ul_curr->size) - (lock->start + lock->size);
1110                                 ul_curr->start = lock->start + lock->size;
1111
1112                                 DEBUG(10,("truncate high case: start=%.0f,size=%.0f\n",
1113                                                                 (double)ul_curr->start, (double)ul_curr->size ));
1114
1115                                 ul_curr = ul_curr->next;
1116
1117                         } else if ( (ul_curr->start < lock->start) &&
1118                                                 (ul_curr->start + ul_curr->size > lock->start) &&
1119                                                 (ul_curr->start + ul_curr->size <= lock->start + lock->size) ) {
1120
1121                                 /*
1122                                  * This unlock overlaps the existing lock range at the low end.
1123                                  * Truncate by reducing size.
1124                                  */
1125 /*********************************************
1126    +---------------+
1127    | ul_curr       |
1128    +---------------+
1129            +---------------+
1130            |    lock       |
1131            +---------------+
1132 BECOMES....
1133    +-------+
1134    |ul_curr|
1135    +-------+
1136 **********************************************/
1137
1138                                 ul_curr->size = lock->start - ul_curr->start;
1139
1140                                 DEBUG(10,("truncate low case: start=%.0f,size=%.0f\n",
1141                                                                 (double)ul_curr->start, (double)ul_curr->size ));
1142
1143                                 ul_curr = ul_curr->next;
1144
1145                         } else if ( (ul_curr->start < lock->start) &&
1146                                                 (ul_curr->start + ul_curr->size > lock->start + lock->size) ) {
1147                                 /*
1148                                  * Worst case scenario. Unlock request completely overlaps an existing
1149                                  * lock range. Split the request into two, push the new (upper) request
1150                                  * into the dlink list, and continue with the entry after ul_new (as we
1151                                  * know that ul_new will not overlap with this lock).
1152                                  */
1153 /*********************************************
1154         +---------------------------+
1155         |       ul_curr             |
1156         +---------------------------+
1157                 +---------+
1158                 | lock    |
1159                 +---------+
1160 BECOMES.....
1161         +-------+         +---------+
1162         |ul_curr|         |ul_new   |
1163         +-------+         +---------+
1164 **********************************************/
1165                                 struct unlock_list *ul_new = (struct unlock_list *)talloc(ctx,
1166                                                                                                         sizeof(struct unlock_list));
1167
1168                                 if(ul_new == NULL) {
1169                                         DEBUG(0,("posix_unlock_list: talloc fail.\n"));
1170                                         return NULL; /* The talloc_destroy takes care of cleanup. */
1171                                 }
1172
1173                                 ZERO_STRUCTP(ul_new);
1174                                 ul_new->start = lock->start + lock->size;
1175                                 ul_new->size = ul_curr->start + ul_curr->size - ul_new->start;
1176
1177                                 /* Truncate the ul_curr. */
1178                                 ul_curr->size = lock->start - ul_curr->start;
1179
1180                                 DEBUG(10,("split case: curr: start=%.0f,size=%.0f \
1181 new: start=%.0f,size=%.0f\n", (double)ul_curr->start, (double)ul_curr->size,
1182                                                                 (double)ul_new->start, (double)ul_new->size ));
1183
1184                                 /*
1185                                  * Add into the dlink list after the ul_curr point - NOT at ulhead.
1186                                  * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
1187                                  */
1188
1189                                 ul_new->prev = ul_curr;
1190                                 ul_new->next = ul_curr->next;
1191                                 ul_curr->next = ul_new;
1192
1193                                 /* And move after the link we added. */
1194                                 ul_curr = ul_new->next;
1195
1196                         } else {
1197
1198                                 /*
1199                                  * This logic case should never happen. Ensure this is the
1200                                  * case by forcing an abort.... Remove in production.
1201                                  */
1202                                 pstring msg;
1203
1204                                 slprintf(msg, sizeof(msg)-1, "logic flaw in cases: ul_curr: start = %.0f, size = %.0f : \
1205 lock: start = %.0f, size = %.0f\n", (double)ul_curr->start, (double)ul_curr->size, (double)lock->start, (double)lock->size );
1206
1207                                 smb_panic(msg);
1208                         }
1209                 } /* end for ( ul_curr = ulhead; ul_curr;) */
1210         } /* end for (i=0; i<num_locks && ul_head; i++) */
1211
1212         if (dbuf.dptr)
1213                 free(dbuf.dptr);
1214
1215         return ulhead;
1216 }
1217
1218 /****************************************************************************
1219  POSIX function to release a lock. Returns True if the
1220  lock could be released, False if not.
1221 ****************************************************************************/
1222
1223 BOOL release_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
1224 {
1225         SMB_OFF_T offset;
1226         SMB_OFF_T count;
1227         BOOL ret = True;
1228         TALLOC_CTX *ul_ctx = NULL;
1229         struct unlock_list *ulist = NULL;
1230         struct unlock_list *ul = NULL;
1231         struct posix_lock deleted_lock;
1232         int num_overlapped_entries;
1233
1234         DEBUG(5,("release_posix_lock: File %s, offset = %.0f, count = %.0f\n",
1235                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1236
1237         /*
1238          * If the requested lock won't fit in the POSIX range, we will
1239          * pretend it was successful.
1240          */
1241
1242         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
1243                 return True;
1244
1245         /*
1246          * We treat this as one unlock request for POSIX accounting purposes even
1247          * if it may later be split into multiple smaller POSIX unlock ranges.
1248          */
1249
1250         num_overlapped_entries = delete_posix_lock_entry(fsp, offset, count, &deleted_lock);
1251
1252         if (num_overlapped_entries == -1) {
1253         smb_panic("release_posix_lock: unable find entry to delete !\n");
1254         }
1255
1256         /*
1257          * If num_overlapped_entries is > 0, and the lock_type we just deleted from the tdb was
1258          * a POSIX write lock, then before doing the unlock we need to downgrade
1259          * the POSIX lock to a read lock.
1260          */
1261
1262         if (num_overlapped_entries > 0 && deleted_lock.lock_type == F_WRLCK) {
1263                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1264                         DEBUG(0,("release_posix_lock: downgrade of lock failed !\n"));
1265                         return False;
1266                 }
1267         }
1268
1269         if ((ul_ctx = talloc_init()) == NULL) {
1270         DEBUG(0,("release_posix_lock: unable to init talloc context.\n"));
1271                 return True; /* Not a fatal error. */
1272         }
1273
1274         if ((ul = (struct unlock_list *)talloc(ul_ctx, sizeof(struct unlock_list))) == NULL) {
1275                 DEBUG(0,("release_posix_lock: unable to talloc unlock list.\n"));
1276                 talloc_destroy(ul_ctx);
1277                 return True; /* Not a fatal error. */
1278         }
1279
1280         /*
1281          * Create the initial list entry containing the
1282          * lock we want to remove.
1283          */
1284
1285         ZERO_STRUCTP(ul);
1286         ul->start = offset;
1287         ul->size = count;
1288
1289         DLIST_ADD(ulist, ul);
1290
1291         /*
1292          * The following call calculates if there are any
1293          * overlapping locks held by this process on
1294          * fd's open on the same file and creates a
1295          * list of unlock ranges that will allow
1296          * POSIX lock ranges to remain on the file whilst the
1297          * unlocks are performed.
1298          */
1299
1300         ulist = posix_unlock_list(ul_ctx, ulist, fsp);
1301
1302         /*
1303          * Release the POSIX locks on the list of ranges returned.
1304          */
1305
1306         for(; ulist; ulist = ulist->next) {
1307                 offset = ulist->start;
1308                 count = ulist->size;
1309
1310                 if(u_count == 0) {
1311
1312                         /*
1313                          * This lock must overlap with an existing lock.
1314                          * Don't do any POSIX call.
1315                          */
1316
1317                         continue;
1318                 }
1319
1320                 DEBUG(5,("release_posix_lock: Real unlock: offset = %.0f, count = %.0f\n",
1321                         (double)offset, (double)count ));
1322
1323                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK))
1324                         ret = False;
1325         }
1326
1327         talloc_destroy(ul_ctx);
1328
1329         return ret;
1330 }
1331
1332 /****************************************************************************
1333  Remove all lock entries for a specific dev/inode pair from the tdb.
1334 ****************************************************************************/
1335
1336 static void delete_posix_lock_entries(files_struct *fsp)
1337 {
1338         TDB_DATA kbuf = locking_key_fsp(fsp);
1339
1340         if (tdb_delete(posix_lock_tdb, kbuf) == -1)
1341                 DEBUG(0,("delete_close_entries: tdb_delete fail !\n"));
1342 }
1343
1344 /****************************************************************************
1345  Debug function.
1346 ****************************************************************************/
1347
1348 static void dump_entry(struct posix_lock *pl)
1349 {
1350         DEBUG(10,("entry: start=%.0f, size=%.0f, type=%d, fd=%i\n",
1351                 (double)pl->start, (double)pl->size, (int)pl->lock_type, pl->fd ));
1352 }
1353
1354 /****************************************************************************
1355  Remove any locks on this fd. Called from file_close().
1356 ****************************************************************************/
1357
1358 void posix_locking_close_file(files_struct *fsp)
1359 {
1360         struct posix_lock *entries = NULL;
1361         size_t count, i;
1362
1363         /*
1364          * Optimization for the common case where we are the only
1365          * opener of a file. If all fd entries are our own, we don't
1366          * need to explicitly release all the locks via the POSIX functions,
1367          * we can just remove all the entries in the tdb and allow the
1368          * close to remove the real locks.
1369          */
1370
1371         count = get_posix_lock_entries(fsp, &entries);
1372
1373         if (count == 0) {
1374                 DEBUG(10,("posix_locking_close_file: file %s has no outstanding locks.\n", fsp->fsp_name ));
1375                 return;
1376         }
1377
1378         for (i = 0; i < count; i++) {
1379                 if (entries[i].fd != fsp->fd )
1380                         break;
1381
1382                 dump_entry(&entries[i]);
1383         }
1384
1385         if (i == count) {
1386                 /* All locks are ours. */
1387                 DEBUG(10,("posix_locking_close_file: file %s has %u outstanding locks, but all on one fd.\n",
1388                         fsp->fsp_name, (unsigned int)count ));
1389                 free((char *)entries);
1390                 delete_posix_lock_entries(fsp);
1391                 return;
1392         }
1393
1394         /*
1395          * Difficult case. We need to delete all our locks, whilst leaving
1396          * all other POSIX locks in place.
1397          */
1398
1399         for (i = 0; i < count; i++) {
1400                 struct posix_lock *pl = &entries[i];
1401                 if (pl->fd == fsp->fd)
1402                         release_posix_lock(fsp, (SMB_BIG_UINT)pl->start, (SMB_BIG_UINT)pl->size );
1403         }
1404         free((char *)entries);
1405 }
1406
1407 /*******************************************************************
1408  Create the in-memory POSIX lock databases.
1409 ********************************************************************/
1410
1411 BOOL posix_locking_init(void)
1412 {
1413         if (posix_lock_tdb && posix_pending_close_tdb)
1414                 return True;
1415
1416         if (!posix_lock_tdb)
1417                 posix_lock_tdb = tdb_open(NULL, 0, TDB_INTERNAL,
1418                                           O_RDWR|O_CREAT, 0644);
1419     if (!posix_lock_tdb) {
1420         DEBUG(0,("Failed to open POSIX byte range locking database.\n"));
1421                 return False;
1422     }
1423         if (!posix_pending_close_tdb)
1424                 posix_pending_close_tdb = tdb_open(NULL, 0, TDB_INTERNAL,
1425                     O_RDWR|O_CREAT, 0644);
1426     if (!posix_pending_close_tdb) {
1427         DEBUG(0,("Failed to open POSIX pending close database.\n"));
1428                 return False;
1429     }
1430
1431         return True;
1432 }
1433
1434 /*******************************************************************
1435  Delete the in-memory POSIX lock databases.
1436 ********************************************************************/
1437
1438 BOOL posix_locking_end(void)
1439 {
1440     if (posix_lock_tdb && tdb_close(posix_lock_tdb) != 0)
1441                 return False;
1442     if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0)
1443                 return False;
1444         return True;
1445 }