source/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,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(fsp,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,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. We return the index number of the
 349  added lock (used in case we need to delete *exactly* this entry). Returns
 350  False on fail, True on success.
 351 ****************************************************************************/
 352
 353 static BOOL add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, int lock_type, size_t *pentry_num)
 354 {
 355         TDB_DATA kbuf = locking_key_fsp(fsp);
 356         TDB_DATA dbuf;
 357         struct posix_lock pl;
 358
 359         dbuf.dptr = NULL;
 360
 361         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 362
 363         *pentry_num = (size_t)(dbuf.dsize / sizeof(pl));
 364
 365         /*
 366          * Add new record.
 367          */
 368
 369         pl.fd = fsp->fd;
 370         pl.start = start;
 371         pl.size = size;
 372         pl.lock_type = lock_type;
 373
 374         dbuf.dptr = Realloc(dbuf.dptr, dbuf.dsize + sizeof(pl));
 375         if (!dbuf.dptr) {
 376                 DEBUG(0,("add_posix_lock_entry: Realloc fail !\n"));
 377                 goto fail;
 378         }
 379
 380         memcpy(dbuf.dptr + dbuf.dsize, &pl, sizeof(pl));
 381         dbuf.dsize += sizeof(pl);
 382
 383         if (tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE) == -1) {
 384                 DEBUG(0,("add_posix_lock: Failed to add lock entry on file %s\n", fsp->fsp_name));
 385                 goto fail;
 386         }
 387
 388     free(dbuf.dptr);
 389
 390         DEBUG(10,("add_posix_lock: File %s: type = %s: start=%.0f size=%.0f: dev=%.0f inode=%.0f\n",
 391                         fsp->fsp_name, posix_lock_type_name(lock_type), (double)start, (double)size,
 392                         (double)fsp->dev, (double)fsp->inode ));
 393
 394     return True;
 395
 396  fail:
 397     if (dbuf.dptr)
 398                 free(dbuf.dptr);
 399     return False;
 400 }
 401
 402 /****************************************************************************
 403  Calculate if locks have any overlap at all.
 404 ****************************************************************************/
 405
 406 static BOOL does_lock_overlap(SMB_OFF_T start1, SMB_OFF_T size1, SMB_OFF_T start2, SMB_OFF_T size2)
 407 {
 408         if (start1 >= start2 && start1 <= start2 + size2)
 409                 return True;
 410
 411         if (start1 < start2 && start1 + size1 > start2);
 412                 return True;
 413
 414         return False;
 415 }
 416
 417 /****************************************************************************
 418  Delete an entry from the POSIX locking tdb. Returns a copy of the entry being
 419  deleted and the number of records that are overlapped by this one, or -1 on error.
 420 ****************************************************************************/
 421
 422 static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, struct posix_lock *pl)
 423 {
 424         TDB_DATA kbuf = locking_key_fsp(fsp);
 425         TDB_DATA dbuf;
 426         struct posix_lock *locks;
 427         size_t i, count;
 428         BOOL found = False;
 429         int num_overlapping_records = 0;
 430
 431         dbuf.dptr = NULL;
 432
 433         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 434
 435         if (!dbuf.dptr) {
 436                 DEBUG(10,("delete_posix_lock_entry: tdb_fetch failed !\n"));
 437                 goto fail;
 438         }
 439
 440         /* There are existing locks - find a match. */
 441         locks = (struct posix_lock *)dbuf.dptr;
 442         count = (size_t)(dbuf.dsize / sizeof(*locks));
 443
 444         /*
 445          * Search for and delete the first record that matches the
 446          * unlock criteria.
 447          */
 448
 449         for (i=0; i<count; i++) {
 450                 struct posix_lock *entry = &locks[i];
 451
 452                 if (entry->fd == fsp->fd &&
 453                         entry->start == start &&
 454                         entry->size == size) {
 455
 456                         /* Make a copy if requested. */
 457                         if (pl)
 458                                 *pl = *entry;
 459
 460                         /* Found it - delete it. */
 461                         if (count == 1) {
 462                                 tdb_delete(posix_lock_tdb, kbuf);
 463                         } else {
 464                                 if (i < count-1) {
 465                                         memmove(&locks[i], &locks[i+1], sizeof(*locks)*((count-1) - i));
 466                                 }
 467                                 dbuf.dsize -= sizeof(*locks);
 468                                 tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE);
 469                         }
 470                         count--;
 471                         found = True;
 472                         break;
 473                 }
 474         }
 475
 476         if (!found)
 477                 goto fail;
 478
 479         /*
 480          * Count the number of entries that are
 481          * overlapped by this unlock request.
 482          */
 483
 484         for (i = 0; i < count; i++) {
 485                 struct posix_lock *entry = &locks[i];
 486
 487                 if (fsp->fd == entry->fd &&
 488                         does_lock_overlap( start, size, entry->start, entry->size))
 489                                 num_overlapping_records++;
 490         }
 491
 492         DEBUG(10,("delete_posix_lock_entry: type = %s: start=%.0f size=%.0f, num_records = %d\n",
 493                         posix_lock_type_name(pl->lock_type), (double)pl->start, (double)pl->size,
 494                                 (unsigned int)num_overlapping_records ));
 495
 496     if (dbuf.dptr)
 497                 free(dbuf.dptr);
 498
 499         return num_overlapping_records;
 500
 501  fail:
 502     if (dbuf.dptr)
 503                 free(dbuf.dptr);
 504     return -1;
 505 }
 506
 507 /****************************************************************************
 508  Utility function to map a lock type correctly depending on the open
 509  mode of a file.
 510 ****************************************************************************/
 511
 512 static int map_posix_lock_type( files_struct *fsp, enum brl_type lock_type)
 513 {
 514         if((lock_type == WRITE_LOCK) && !fsp->can_write) {
 515                 /*
 516                  * Many UNIX's cannot get a write lock on a file opened read-only.
 517                  * Win32 locking semantics allow this.
 518                  * Do the best we can and attempt a read-only lock.
 519                  */
 520                 DEBUG(10,("map_posix_lock_type: Downgrading write lock to read due to read-only file.\n"));
 521                 return F_RDLCK;
 522         } else if((lock_type == READ_LOCK) && !fsp->can_read) {
 523                 /*
 524                  * Ditto for read locks on write only files.
 525                  */
 526                 DEBUG(10,("map_posix_lock_type: Changing read lock to write due to write-only file.\n"));
 527                 return F_WRLCK;
 528         }
 529
 530   /*
 531    * This return should be the most normal, as we attempt
 532    * to always open files read/write.
 533    */
 534
 535   return (lock_type == READ_LOCK) ? F_RDLCK : F_WRLCK;
 536 }
 537
 538 /****************************************************************************
 539  Check to see if the given unsigned lock range is within the possible POSIX
 540  range. Modifies the given args to be in range if possible, just returns
 541  False if not.
 542 ****************************************************************************/
 543
 544 static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
 545                                                                 SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
 546 {
 547         SMB_OFF_T offset = (SMB_OFF_T)u_offset;
 548         SMB_OFF_T count = (SMB_OFF_T)u_count;
 549
 550         /*
 551          * For the type of system we are, attempt to
 552          * find the maximum positive lock offset as an SMB_OFF_T.
 553          */
 554
 555 #if defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
 556
 557         /*
 558          * In this case SMB_OFF_T is 64 bits,
 559          * and the underlying system can handle 64 bit signed locks.
 560          */
 561
 562     SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
 563     SMB_OFF_T mask = (mask2<<1);
 564     SMB_OFF_T max_positive_lock_offset = ~mask;
 565
 566 #else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
 567
 568         /*
 569          * In this case either SMB_OFF_T is 32 bits,
 570          * or the underlying system cannot handle 64 bit signed locks.
 571          * All offsets & counts must be 2^31 or less.
 572          */
 573
 574     SMB_OFF_T max_positive_lock_offset = 0x7FFFFFFF;
 575
 576 #endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
 577
 578         /*
 579          * If the given offset was > max_positive_lock_offset then we cannot map this at all
 580          * ignore this lock.
 581          */
 582
 583         if (u_offset & ~((SMB_BIG_UINT)max_positive_lock_offset)) {
 584                 DEBUG(10,("posix_lock_in_range: (offset = %.0f) offset > %.0f and we cannot handle this. Ignoring lock.\n",
 585                                 (double)u_offset, (double)((SMB_BIG_UINT)max_positive_lock_offset) ));
 586                 return False;
 587         }
 588
 589         /*
 590          * We must truncate the offset and count to less than max_positive_lock_offset.
 591          */
 592
 593         offset &= max_positive_lock_offset;
 594         count &= max_positive_lock_offset;
 595
 596
 597         /*
 598          * Deal with a very common case of count of all ones.
 599          * (lock entire file).
 600          */
 601
 602         if(count == (SMB_OFF_T)-1)
 603                 count = max_positive_lock_offset;
 604
 605         /*
 606          * Truncate count to end at max lock offset.
 607          */
 608
 609         if (offset + count < 0 || offset + count > max_positive_lock_offset)
 610                 count = max_positive_lock_offset - offset;
 611
 612         /*
 613          * If we ate all the count, ignore this lock.
 614          */
 615
 616         if (count == 0) {
 617                 DEBUG(10,("posix_lock_in_range: Count = 0. Ignoring lock u_offset = %.0f, u_count = %.0f\n",
 618                                 (double)u_offset, (double)u_count ));
 619                 return False;
 620         }
 621
 622         /*
 623          * The mapping was successful.
 624          */
 625
 626         DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
 627                         (double)offset, (double)count ));
 628
 629         *offset_out = offset;
 630         *count_out = count;
 631
 632         return True;
 633 }
 634
 635 #if defined(LARGE_SMB_OFF_T)
 636 /****************************************************************************
 637  Pathetically try and map a 64 bit lock offset into 31 bits. I hate Windows :-).
 638 ****************************************************************************/
 639
 640 static uint32 map_lock_offset(uint32 high, uint32 low)
 641 {
 642         unsigned int i;
 643         uint32 mask = 0;
 644         uint32 highcopy = high;
 645
 646         /*
 647          * Try and find out how many significant bits there are in high.
 648          */
 649
 650         for(i = 0; highcopy; i++)
 651                 highcopy >>= 1;
 652
 653         /*
 654          * We use 31 bits not 32 here as POSIX
 655          * lock offsets may not be negative.
 656          */
 657
 658         mask = (~0) << (31 - i);
 659
 660         if(low & mask)
 661                 return 0; /* Fail. */
 662
 663         high <<= (31 - i);
 664
 665         return (high|low);
 666 }
 667 #endif
 668
 669 /****************************************************************************
 670  Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
 671  broken NFS implementations.
 672 ****************************************************************************/
 673
 674 static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 675 {
 676         int ret;
 677         struct connection_struct *conn = fsp->conn;
 678
 679 #if defined(LARGE_SMB_OFF_T)
 680         /*
 681          * In the 64 bit locking case we store the original
 682          * values in case we have to map to a 32 bit lock on
 683          * a filesystem that doesn't support 64 bit locks.
 684          */
 685         SMB_OFF_T orig_offset = offset;
 686         SMB_OFF_T orig_count = count;
 687 #endif /* LARGE_SMB_OFF_T */
 688
 689         DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fd,op,(double)offset,(double)count,type));
 690
 691         ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
 692
 693         if (!ret && (errno == EFBIG)) {
 694                 if( DEBUGLVL( 0 )) {
 695                         dbgtext("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n", (double)offset,(double)count);
 696                         dbgtext("a 'file too large' error. This can happen when using 64 bit lock offsets\n");
 697                         dbgtext("on 32 bit NFS mounted file systems. Retrying with 32 bit truncated length.\n");
 698                 }
 699                 /* 32 bit NFS file system, retry with smaller offset */
 700                 errno = 0;
 701                 count &= 0x7fffffff;
 702                 ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
 703         }
 704
 705         /* A lock query - just return. */
 706         if (op == SMB_F_GETLK)
 707                 return ret;
 708
 709         /* A lock set or unset. */
 710         if (!ret) {
 711                 DEBUG(3,("posix_fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
 712                                 (double)offset,(double)count,op,type,strerror(errno)));
 713
 714                 /* Perhaps it doesn't support this sort of locking ? */
 715                 if (errno == EINVAL) {
 716 #if defined(LARGE_SMB_OFF_T)
 717                         {
 718                                 /*
 719                                  * Ok - if we get here then we have a 64 bit lock request
 720                                  * that has returned EINVAL. Try and map to 31 bits for offset
 721                                  * and length and try again. This may happen if a filesystem
 722                                  * doesn't support 64 bit offsets (efs/ufs) although the underlying
 723                                  * OS does.
 724                                  */
 725                                 uint32 off_low = (orig_offset & 0xFFFFFFFF);
 726                                 uint32 off_high = ((orig_offset >> 32) & 0xFFFFFFFF);
 727
 728                                 count = (orig_count & 0x7FFFFFFF);
 729                                 offset = (SMB_OFF_T)map_lock_offset(off_high, off_low);
 730                                 ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
 731                                 if (!ret) {
 732                                         if (errno == EINVAL) {
 733                                                 DEBUG(3,("posix_fcntl_lock: locking not supported? returning True\n"));
 734                                                 return(True);
 735                                         }
 736                                         return False;
 737                                 }
 738                                 DEBUG(3,("posix_fcntl_lock: 64 -> 32 bit modified lock call successful\n"));
 739                                 return True;
 740                         }
 741 #else /* LARGE_SMB_OFF_T */
 742                         DEBUG(3,("locking not supported? returning True\n"));
 743                         return(True);
 744 #endif /* LARGE_SMB_OFF_T */
 745                 }
 746
 747                 return(False);
 748         }
 749
 750         DEBUG(8,("posix_fcntl_lock: Lock call successful\n"));
 751
 752         return(True);
 753 }
 754
 755 /****************************************************************************
 756  POSIX function to see if a file region is locked. Returns True if the
 757  region is locked, False otherwise.
 758 ****************************************************************************/
 759
 760 BOOL is_posix_locked(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count, enum brl_type lock_type)
 761 {
 762         SMB_OFF_T offset;
 763         SMB_OFF_T count;
 764         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
 765
 766         DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, type = %s\n",
 767                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
 768
 769         /*
 770          * If the requested lock won't fit in the POSIX range, we will
 771          * never set it, so presume it is not locked.
 772          */
 773
 774         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
 775                 return False;
 776
 777         /*
 778          * Note that most UNIX's can *test* for a write lock on
 779          * a read-only fd, just not *set* a write lock on a read-only
 780          * fd. So we don't need to use map_lock_type here.
 781          */
 782
 783         return posix_fcntl_lock(fsp,SMB_F_GETLK,offset,count,posix_lock_type);
 784 }
 785
 786 /*
 787  * Structure used when splitting a lock range
 788  * into a POSIX lock range. Doubly linked list.
 789  */
 790
 791 struct lock_list {
 792     struct lock_list *next;
 793     struct lock_list *prev;
 794     SMB_OFF_T start;
 795     SMB_OFF_T size;
 796 };
 797
 798 /****************************************************************************
 799  Create a list of lock ranges that don't overlap a given range. Used in calculating
 800  POSIX locks and unlocks. This is a difficult function that requires ASCII art to
 801  understand it :-).
 802 ****************************************************************************/
 803
 804 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx, struct lock_list *lhead, files_struct *fsp)
 805 {
 806         TDB_DATA kbuf = locking_key_fsp(fsp);
 807         TDB_DATA dbuf;
 808         struct posix_lock *locks;
 809         size_t num_locks, i;
 810
 811         dbuf.dptr = NULL;
 812
 813         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 814
 815         if (!dbuf.dptr)
 816                 return lhead;
 817
 818         locks = (struct posix_lock *)dbuf.dptr;
 819         num_locks = (size_t)(dbuf.dsize / sizeof(*locks));
 820
 821         /*
 822          * Check the current lock list on this dev/inode pair.
 823          * Quit if the list is deleted.
 824          */
 825
 826         DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
 827                 (double)lhead->start, (double)lhead->size ));
 828
 829         for (i=0; i<num_locks && lhead; i++) {
 830
 831                 struct posix_lock *lock = &locks[i];
 832                 struct lock_list *l_curr;
 833
 834                 /*
 835                  * Walk the lock list, checking for overlaps. Note that
 836                  * the lock list can expand within this loop if the current
 837                  * range being examined needs to be split.
 838                  */
 839
 840                 for (l_curr = lhead; l_curr;) {
 841
 842                         DEBUG(10,("posix_lock_list: lock: fd=%d: start=%.0f,size=%.0f:type=%s", lock->fd,
 843                                 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
 844
 845                         if ( (l_curr->start >= (lock->start + lock->size)) ||
 846                                  (lock->start >= (l_curr->start + l_curr->size))) {
 847
 848                                 /* No overlap with this lock - leave this range alone. */
 849 /*********************************************
 850                                              +---------+
 851                                              | l_curr  |
 852                                              +---------+
 853                                 +-------+
 854                                 | lock  |
 855                                 +-------+
 856 OR....
 857              +---------+
 858              |  l_curr |
 859              +---------+
 860 **********************************************/
 861
 862                                 DEBUG(10,("no overlap case.\n" ));
 863
 864                                 l_curr = l_curr->next;
 865
 866                         } else if ( (l_curr->start >= lock->start) &&
 867                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 868
 869                                 /*
 870                                  * This unlock is completely overlapped by this existing lock range
 871                                  * and thus should have no effect (not be unlocked). Delete it from the list.
 872                                  */
 873 /*********************************************
 874                 +---------+
 875                 |  l_curr |
 876                 +---------+
 877         +---------------------------+
 878         |       lock                |
 879         +---------------------------+
 880 **********************************************/
 881                                 /* Save the next pointer */
 882                                 struct lock_list *ul_next = l_curr->next;
 883
 884                                 DEBUG(10,("delete case.\n" ));
 885
 886                                 DLIST_REMOVE(lhead, l_curr);
 887                                 if(lhead == NULL)
 888                                         break; /* No more list... */
 889
 890                                 l_curr = ul_next;
 891
 892                         } else if ( (l_curr->start >= lock->start) &&
 893                                                 (l_curr->start < lock->start + lock->size) &&
 894                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 895
 896                                 /*
 897                                  * This unlock overlaps the existing lock range at the high end.
 898                                  * Truncate by moving start to existing range end and reducing size.
 899                                  */
 900 /*********************************************
 901                 +---------------+
 902                 |  l_curr       |
 903                 +---------------+
 904         +---------------+
 905         |    lock       |
 906         +---------------+
 907 BECOMES....
 908                         +-------+
 909                         | l_curr|
 910                         +-------+
 911 **********************************************/
 912
 913                                 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
 914                                 l_curr->start = lock->start + lock->size;
 915
 916                                 DEBUG(10,("truncate high case: start=%.0f,size=%.0f\n",
 917                                                                 (double)l_curr->start, (double)l_curr->size ));
 918
 919                                 l_curr = l_curr->next;
 920
 921                         } else if ( (l_curr->start < lock->start) &&
 922                                                 (l_curr->start + l_curr->size > lock->start) &&
 923                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 924
 925                                 /*
 926                                  * This unlock overlaps the existing lock range at the low end.
 927                                  * Truncate by reducing size.
 928                                  */
 929 /*********************************************
 930    +---------------+
 931    |  l_curr       |
 932    +---------------+
 933            +---------------+
 934            |    lock       |
 935            +---------------+
 936 BECOMES....
 937    +-------+
 938    | l_curr|
 939    +-------+
 940 **********************************************/
 941
 942                                 l_curr->size = lock->start - l_curr->start;
 943
 944                                 DEBUG(10,("truncate low case: start=%.0f,size=%.0f\n",
 945                                                                 (double)l_curr->start, (double)l_curr->size ));
 946
 947                                 l_curr = l_curr->next;
 948
 949                         } else if ( (l_curr->start < lock->start) &&
 950                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 951                                 /*
 952                                  * Worst case scenario. Unlock request completely overlaps an existing
 953                                  * lock range. Split the request into two, push the new (upper) request
 954                                  * into the dlink list, and continue with the entry after ul_new (as we
 955                                  * know that ul_new will not overlap with this lock).
 956                                  */
 957 /*********************************************
 958         +---------------------------+
 959         |        l_curr             |
 960         +---------------------------+
 961                 +---------+
 962                 | lock    |
 963                 +---------+
 964 BECOMES.....
 965         +-------+         +---------+
 966         | l_curr|         | l_new   |
 967         +-------+         +---------+
 968 **********************************************/
 969                                 struct lock_list *l_new = (struct lock_list *)talloc(ctx,
 970                                                                                                         sizeof(struct lock_list));
 971
 972                                 if(l_new == NULL) {
 973                                         DEBUG(0,("posix_lock_list: talloc fail.\n"));
 974                                         return NULL; /* The talloc_destroy takes care of cleanup. */
 975                                 }
 976
 977                                 ZERO_STRUCTP(l_new);
 978                                 l_new->start = lock->start + lock->size;
 979                                 l_new->size = l_curr->start + l_curr->size - l_new->start;
 980
 981                                 /* Truncate the l_curr. */
 982                                 l_curr->size = lock->start - l_curr->start;
 983
 984                                 DEBUG(10,("split case: curr: start=%.0f,size=%.0f \
 985 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
 986                                                                 (double)l_new->start, (double)l_new->size ));
 987
 988                                 /*
 989                                  * Add into the dlink list after the l_curr point - NOT at lhead.
 990                                  * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
 991                                  */
 992
 993                                 l_new->prev = l_curr;
 994                                 l_new->next = l_curr->next;
 995                                 l_curr->next = l_new;
 996
 997                                 /* And move after the link we added. */
 998                                 l_curr = l_new->next;
 999
1000                         } else {
1001
1002                                 /*
1003                                  * This logic case should never happen. Ensure this is the
1004                                  * case by forcing an abort.... Remove in production.
1005                                  */
1006                                 pstring msg;
1007
1008                                 slprintf(msg, sizeof(msg)-1, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
1009 lock: start = %.0f, size = %.0f\n", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
1010
1011                                 smb_panic(msg);
1012                         }
1013                 } /* end for ( l_curr = lhead; l_curr;) */
1014         } /* end for (i=0; i<num_locks && ul_head; i++) */
1015
1016         if (dbuf.dptr)
1017                 free(dbuf.dptr);
1018
1019         return lhead;
1020 }
1021
1022 /****************************************************************************
1023  POSIX function to acquire a lock. Returns True if the
1024  lock could be granted, False if not.
1025 ****************************************************************************/
1026
1027 BOOL set_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count, enum brl_type lock_type)
1028 {
1029         SMB_OFF_T offset;
1030         SMB_OFF_T count;
1031         BOOL ret = True;
1032         size_t entry_num = 0;
1033         size_t lock_count;
1034         TALLOC_CTX *l_ctx = NULL;
1035         struct lock_list *llist = NULL;
1036         struct lock_list *ll = NULL;
1037         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1038
1039         DEBUG(5,("set_posix_lock: File %s, offset = %.0f, count = %.0f, type = %s\n",
1040                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
1041
1042         /*
1043          * If the requested lock won't fit in the POSIX range, we will
1044          * pretend it was successful.
1045          */
1046
1047         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
1048                 return True;
1049
1050         /*
1051          * Windows is very strange. It allows read locks to be overlayed
1052          * (even over a write lock), but leaves the write lock in force until the first
1053          * unlock. It also reference counts the locks. This means the following sequence :
1054          *
1055          * process1                                      process2
1056          * ------------------------------------------------------------------------
1057          * WRITE LOCK : start = 2, len = 10
1058          *                                            READ LOCK: start =0, len = 10 - FAIL
1059          * READ LOCK : start = 0, len = 14
1060          *                                            READ LOCK: start =0, len = 10 - FAIL
1061          * UNLOCK : start = 2, len = 10
1062          *                                            READ LOCK: start =0, len = 10 - OK
1063          *
1064          * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
1065          * would leave a single read lock over the 0-14 region. In order to
1066          * re-create Windows semantics mapped to POSIX locks, we create multiple TDB
1067          * entries, one for each overlayed lock request. We are guarenteed by the brlock
1068          * semantics that if a write lock is added, then it will be first in the array.
1069          */
1070
1071         if ((l_ctx = talloc_init()) == NULL) {
1072                 DEBUG(0,("set_posix_lock: unable to init talloc context.\n"));
1073                 return True; /* Not a fatal error. */
1074         }
1075
1076         if ((ll = (struct lock_list *)talloc(l_ctx, sizeof(struct lock_list))) == NULL) {
1077                 DEBUG(0,("set_posix_lock: unable to talloc unlock list.\n"));
1078                 talloc_destroy(l_ctx);
1079                 return True; /* Not a fatal error. */
1080         }
1081
1082         /*
1083          * Create the initial list entry containing the
1084          * lock we want to add.
1085          */
1086
1087         ZERO_STRUCTP(ll);
1088         ll->start = offset;
1089         ll->size = count;
1090
1091         DLIST_ADD(llist, ll);
1092
1093         /*
1094          * The following call calculates if there are any
1095          * overlapping locks held by this process on
1096          * fd's open on the same file and splits this list
1097          * into a list of lock ranges that do not overlap with existing
1098          * POSIX locks.
1099          */
1100
1101         llist = posix_lock_list(l_ctx, llist, fsp);
1102
1103         /*
1104          * Now we have the list of ranges to lock it is safe to add the
1105          * entry into the POSIX lock tdb. We take note of the entry we
1106          * added here in case we have to remove it on POSIX lock fail.
1107          */
1108
1109         if (!add_posix_lock_entry(fsp,offset,count,posix_lock_type,&entry_num)) {
1110                 DEBUG(0,("set_posix_lock: Unable to create posix lock entry !\n"));
1111                 talloc_destroy(l_ctx);
1112                 return False;
1113         }
1114
1115         /*
1116          * Add the POSIX locks on the list of ranges returned.
1117          * As the lock is supposed to be added atomically, we need to
1118          * back out all the locks if any one of these calls fail.
1119          */
1120
1121         for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1122                 offset = ll->start;
1123                 count = ll->size;
1124
1125                 DEBUG(5,("set_posix_lock: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1126                         posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1127
1128                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1129                         DEBUG(5,("set_posix_lock: Lock fail !: Type = %s: offset = %.0f, count = %.0f\n",
1130                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1131                         ret = False;
1132                         break;
1133                 }
1134         }
1135
1136         if (!ret) {
1137
1138                 /*
1139                  * Back out all the POSIX locks we have on fail.
1140                  */
1141
1142                 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1143                         offset = ll->start;
1144                         count = ll->size;
1145
1146                         DEBUG(5,("set_posix_lock: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1147                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1148
1149                         posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1150                 }
1151
1152                 /*
1153                  * Remove the tdb entry for this lock.
1154                  */
1155
1156                 delete_posix_lock_entry_by_index(fsp,entry_num);
1157         }
1158
1159         talloc_destroy(l_ctx);
1160         return ret;
1161 }
1162
1163 /****************************************************************************
1164  POSIX function to release a lock. Returns True if the
1165  lock could be released, False if not.
1166 ****************************************************************************/
1167
1168 BOOL release_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
1169 {
1170         SMB_OFF_T offset;
1171         SMB_OFF_T count;
1172         BOOL ret = True;
1173         TALLOC_CTX *ul_ctx = NULL;
1174         struct lock_list *ulist = NULL;
1175         struct lock_list *ul = NULL;
1176         struct posix_lock deleted_lock;
1177         int num_overlapped_entries;
1178
1179         DEBUG(5,("release_posix_lock: File %s, offset = %.0f, count = %.0f\n",
1180                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1181
1182         /*
1183          * If the requested lock won't fit in the POSIX range, we will
1184          * pretend it was successful.
1185          */
1186
1187         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
1188                 return True;
1189
1190         /*
1191          * We treat this as one unlock request for POSIX accounting purposes even
1192          * if it may later be split into multiple smaller POSIX unlock ranges.
1193          * num_overlapped_entries is the number of existing locks that have any
1194          * overlap with this unlock request.
1195          */
1196
1197         num_overlapped_entries = delete_posix_lock_entry(fsp, offset, count, &deleted_lock);
1198
1199         if (num_overlapped_entries == -1) {
1200         smb_panic("release_posix_lock: unable find entry to delete !\n");
1201         }
1202
1203         /*
1204          * If num_overlapped_entries is > 0, and the lock_type we just deleted from the tdb was
1205          * a POSIX write lock, then before doing the unlock we need to downgrade
1206          * the POSIX lock to a read lock. This allows any overlapping read locks
1207          * to be atomically maintained.
1208          */
1209
1210         if (num_overlapped_entries > 0 && deleted_lock.lock_type == F_WRLCK) {
1211                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1212                         DEBUG(0,("release_posix_lock: downgrade of lock failed !\n"));
1213                         return False;
1214                 }
1215         }
1216
1217         if ((ul_ctx = talloc_init()) == NULL) {
1218                 DEBUG(0,("release_posix_lock: unable to init talloc context.\n"));
1219                 return True; /* Not a fatal error. */
1220         }
1221
1222         if ((ul = (struct lock_list *)talloc(ul_ctx, sizeof(struct lock_list))) == NULL) {
1223                 DEBUG(0,("release_posix_lock: unable to talloc unlock list.\n"));
1224                 talloc_destroy(ul_ctx);
1225                 return True; /* Not a fatal error. */
1226         }
1227
1228         /*
1229          * Create the initial list entry containing the
1230          * lock we want to remove.
1231          */
1232
1233         ZERO_STRUCTP(ul);
1234         ul->start = offset;
1235         ul->size = count;
1236
1237         DLIST_ADD(ulist, ul);
1238
1239         /*
1240          * The following call calculates if there are any
1241          * overlapping locks held by this process on
1242          * fd's open on the same file and creates a
1243          * list of unlock ranges that will allow
1244          * POSIX lock ranges to remain on the file whilst the
1245          * unlocks are performed.
1246          */
1247
1248         ulist = posix_lock_list(ul_ctx, ulist, fsp);
1249
1250         /*
1251          * Release the POSIX locks on the list of ranges returned.
1252          */
1253
1254         for(; ulist; ulist = ulist->next) {
1255                 offset = ulist->start;
1256                 count = ulist->size;
1257
1258                 DEBUG(5,("release_posix_lock: Real unlock: offset = %.0f, count = %.0f\n",
1259                         (double)offset, (double)count ));
1260
1261                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK))
1262                         ret = False;
1263         }
1264
1265         talloc_destroy(ul_ctx);
1266
1267         return ret;
1268 }
1269
1270 /****************************************************************************
1271  Remove all lock entries for a specific dev/inode pair from the tdb.
1272 ****************************************************************************/
1273
1274 static void delete_posix_lock_entries(files_struct *fsp)
1275 {
1276         TDB_DATA kbuf = locking_key_fsp(fsp);
1277
1278         if (tdb_delete(posix_lock_tdb, kbuf) == -1)
1279                 DEBUG(0,("delete_close_entries: tdb_delete fail !\n"));
1280 }
1281
1282 /****************************************************************************
1283  Debug function.
1284 ****************************************************************************/
1285
1286 static void dump_entry(struct posix_lock *pl)
1287 {
1288         DEBUG(10,("entry: start=%.0f, size=%.0f, type=%d, fd=%i\n",
1289                 (double)pl->start, (double)pl->size, (int)pl->lock_type, pl->fd ));
1290 }
1291
1292 /****************************************************************************
1293  Remove any locks on this fd. Called from file_close().
1294 ****************************************************************************/
1295
1296 void posix_locking_close_file(files_struct *fsp)
1297 {
1298         struct posix_lock *entries = NULL;
1299         size_t count, i;
1300
1301         /*
1302          * Optimization for the common case where we are the only
1303          * opener of a file. If all fd entries are our own, we don't
1304          * need to explicitly release all the locks via the POSIX functions,
1305          * we can just remove all the entries in the tdb and allow the
1306          * close to remove the real locks.
1307          */
1308
1309         count = get_posix_lock_entries(fsp, &entries);
1310
1311         if (count == 0) {
1312                 DEBUG(10,("posix_locking_close_file: file %s has no outstanding locks.\n", fsp->fsp_name ));
1313                 return;
1314         }
1315
1316         for (i = 0; i < count; i++) {
1317                 if (entries[i].fd != fsp->fd )
1318                         break;
1319
1320                 dump_entry(&entries[i]);
1321         }
1322
1323         if (i == count) {
1324                 /* All locks are ours. */
1325                 DEBUG(10,("posix_locking_close_file: file %s has %u outstanding locks, but all on one fd.\n",
1326                         fsp->fsp_name, (unsigned int)count ));
1327                 free((char *)entries);
1328                 delete_posix_lock_entries(fsp);
1329                 return;
1330         }
1331
1332         /*
1333          * Difficult case. We need to delete all our locks, whilst leaving
1334          * all other POSIX locks in place.
1335          */
1336
1337         for (i = 0; i < count; i++) {
1338                 struct posix_lock *pl = &entries[i];
1339                 if (pl->fd == fsp->fd)
1340                         release_posix_lock(fsp, (SMB_BIG_UINT)pl->start, (SMB_BIG_UINT)pl->size );
1341         }
1342         free((char *)entries);
1343 }
1344
1345 /*******************************************************************
1346  Create the in-memory POSIX lock databases.
1347 ********************************************************************/
1348
1349 BOOL posix_locking_init(int read_only)
1350 {
1351         if (posix_lock_tdb && posix_pending_close_tdb)
1352                 return True;
1353
1354         if (!posix_lock_tdb)
1355                 posix_lock_tdb = tdb_open(NULL, 0, TDB_INTERNAL,
1356                                           read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
1357         if (!posix_lock_tdb) {
1358                 DEBUG(0,("Failed to open POSIX byte range locking database.\n"));
1359                 return False;
1360         }
1361         if (!posix_pending_close_tdb)
1362                 posix_pending_close_tdb = tdb_open(NULL, 0, TDB_INTERNAL,
1363                                                    read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
1364         if (!posix_pending_close_tdb) {
1365                 DEBUG(0,("Failed to open POSIX pending close database.\n"));
1366                 return False;
1367         }
1368
1369         return True;
1370 }
1371
1372 /*******************************************************************
1373  Delete the in-memory POSIX lock databases.
1374 ********************************************************************/
1375
1376 BOOL posix_locking_end(void)
1377 {
1378     if (posix_lock_tdb && tdb_close(posix_lock_tdb) != 0)
1379                 return False;
1380     if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0)
1381                 return False;
1382         return True;
1383 }