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,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 /****************************************************************************
 636  Pathetically try and map a 64 bit lock offset into 31 bits. I hate Windows :-).
 637 ****************************************************************************/
 638
 639 uint32 map_lock_offset(uint32 high, uint32 low)
 640 {
 641         unsigned int i;
 642         uint32 mask = 0;
 643         uint32 highcopy = high;
 644
 645         /*
 646          * Try and find out how many significant bits there are in high.
 647          */
 648
 649         for(i = 0; highcopy; i++)
 650                 highcopy >>= 1;
 651
 652         /*
 653          * We use 31 bits not 32 here as POSIX
 654          * lock offsets may not be negative.
 655          */
 656
 657         mask = (~0) << (31 - i);
 658
 659         if(low & mask)
 660                 return 0; /* Fail. */
 661
 662         high <<= (31 - i);
 663
 664         return (high|low);
 665 }
 666
 667 /****************************************************************************
 668  Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
 669  broken NFS implementations.
 670 ****************************************************************************/
 671
 672 static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 673 {
 674         int ret;
 675         struct connection_struct *conn = fsp->conn;
 676
 677 #if defined(LARGE_SMB_OFF_T)
 678         /*
 679          * In the 64 bit locking case we store the original
 680          * values in case we have to map to a 32 bit lock on
 681          * a filesystem that doesn't support 64 bit locks.
 682          */
 683         SMB_OFF_T orig_offset = offset;
 684         SMB_OFF_T orig_count = count;
 685 #endif /* LARGE_SMB_OFF_T */
 686
 687         DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fd,op,(double)offset,(double)count,type));
 688
 689         ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
 690
 691         if (!ret && (errno == EFBIG)) {
 692                 if( DEBUGLVL( 0 )) {
 693                         dbgtext("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n", (double)offset,(double)count);
 694                         dbgtext("a 'file too large' error. This can happen when using 64 bit lock offsets\n");
 695                         dbgtext("on 32 bit NFS mounted file systems. Retrying with 32 bit truncated length.\n");
 696                 }
 697                 /* 32 bit NFS file system, retry with smaller offset */
 698                 errno = 0;
 699                 count &= 0x7fffffff;
 700                 ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
 701         }
 702
 703         /* A lock query - just return. */
 704         if (op == SMB_F_GETLK)
 705                 return ret;
 706
 707         /* A lock set or unset. */
 708         if (!ret) {
 709                 DEBUG(3,("posix_fcntl_lock: lock failed at offset %.0f count %.0f op %d type %d (%s)\n",
 710                                 (double)offset,(double)count,op,type,strerror(errno)));
 711
 712                 /* Perhaps it doesn't support this sort of locking ? */
 713                 if (errno == EINVAL) {
 714 #if defined(LARGE_SMB_OFF_T)
 715                         {
 716                                 /*
 717                                  * Ok - if we get here then we have a 64 bit lock request
 718                                  * that has returned EINVAL. Try and map to 31 bits for offset
 719                                  * and length and try again. This may happen if a filesystem
 720                                  * doesn't support 64 bit offsets (efs/ufs) although the underlying
 721                                  * OS does.
 722                                  */
 723                                 uint32 off_low = (orig_offset & 0xFFFFFFFF);
 724                                 uint32 off_high = ((orig_offset >> 32) & 0xFFFFFFFF);
 725
 726                                 count = (orig_count & 0x7FFFFFFF);
 727                                 offset = (SMB_OFF_T)map_lock_offset(off_high, off_low);
 728                                 ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
 729                                 if (!ret) {
 730                                         if (errno == EINVAL) {
 731                                                 DEBUG(3,("posix_fcntl_lock: locking not supported? returning True\n"));
 732                                                 return(True);
 733                                         }
 734                                         return False;
 735                                 }
 736                                 DEBUG(3,("posix_fcntl_lock: 64 -> 32 bit modified lock call successful\n"));
 737                                 return True;
 738                         }
 739 #else /* LARGE_SMB_OFF_T */
 740                         DEBUG(3,("locking not supported? returning True\n"));
 741                         return(True);
 742 #endif /* LARGE_SMB_OFF_T */
 743                 }
 744
 745                 return(False);
 746         }
 747
 748         DEBUG(8,("posix_fcntl_lock: Lock call successful\n"));
 749
 750         return(True);
 751 }
 752
 753 /****************************************************************************
 754  POSIX function to see if a file region is locked. Returns True if the
 755  region is locked, False otherwise.
 756 ****************************************************************************/
 757
 758 BOOL is_posix_locked(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count, enum brl_type lock_type)
 759 {
 760         SMB_OFF_T offset;
 761         SMB_OFF_T count;
 762         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
 763
 764         DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, type = %s\n",
 765                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
 766
 767         /*
 768          * If the requested lock won't fit in the POSIX range, we will
 769          * never set it, so presume it is not locked.
 770          */
 771
 772         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
 773                 return False;
 774
 775         /*
 776          * Note that most UNIX's can *test* for a write lock on
 777          * a read-only fd, just not *set* a write lock on a read-only
 778          * fd. So we don't need to use map_lock_type here.
 779          */
 780
 781         return posix_fcntl_lock(fsp,SMB_F_GETLK,offset,count,posix_lock_type);
 782 }
 783
 784 /*
 785  * Structure used when splitting a lock range
 786  * into a POSIX lock range. Doubly linked list.
 787  */
 788
 789 struct lock_list {
 790     struct lock_list *next;
 791     struct lock_list *prev;
 792     SMB_OFF_T start;
 793     SMB_OFF_T size;
 794 };
 795
 796 /****************************************************************************
 797  Create a list of lock ranges that don't overlap a given range. Used in calculating
 798  POSIX locks and unlocks. This is a difficult function that requires ASCII art to
 799  understand it :-).
 800 ****************************************************************************/
 801
 802 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx, struct lock_list *lhead, files_struct *fsp)
 803 {
 804         TDB_DATA kbuf = locking_key_fsp(fsp);
 805         TDB_DATA dbuf;
 806         struct posix_lock *locks;
 807         size_t num_locks, i;
 808
 809         dbuf.dptr = NULL;
 810
 811         dbuf = tdb_fetch(posix_lock_tdb, kbuf);
 812
 813         if (!dbuf.dptr)
 814                 return lhead;
 815
 816         locks = (struct posix_lock *)dbuf.dptr;
 817         num_locks = (size_t)(dbuf.dsize / sizeof(*locks));
 818
 819         /*
 820          * Check the current lock list on this dev/inode pair.
 821          * Quit if the list is deleted.
 822          */
 823
 824         DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
 825                 (double)lhead->start, (double)lhead->size ));
 826
 827         for (i=0; i<num_locks && lhead; i++) {
 828
 829                 struct posix_lock *lock = &locks[i];
 830                 struct lock_list *l_curr;
 831
 832                 /*
 833                  * Walk the lock list, checking for overlaps. Note that
 834                  * the lock list can expand within this loop if the current
 835                  * range being examined needs to be split.
 836                  */
 837
 838                 for (l_curr = lhead; l_curr;) {
 839
 840                         DEBUG(10,("posix_lock_list: lock: fd=%d: start=%.0f,size=%.0f:type=%s", lock->fd,
 841                                 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
 842
 843                         if ( (l_curr->start >= (lock->start + lock->size)) ||
 844                                  (lock->start >= (l_curr->start + l_curr->size))) {
 845
 846                                 /* No overlap with this lock - leave this range alone. */
 847 /*********************************************
 848                                              +---------+
 849                                              | l_curr  |
 850                                              +---------+
 851                                 +-------+
 852                                 | lock  |
 853                                 +-------+
 854 OR....
 855              +---------+
 856              |  l_curr |
 857              +---------+
 858 **********************************************/
 859
 860                                 DEBUG(10,("no overlap case.\n" ));
 861
 862                                 l_curr = l_curr->next;
 863
 864                         } else if ( (l_curr->start >= lock->start) &&
 865                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 866
 867                                 /*
 868                                  * This unlock is completely overlapped by this existing lock range
 869                                  * and thus should have no effect (not be unlocked). Delete it from the list.
 870                                  */
 871 /*********************************************
 872                 +---------+
 873                 |  l_curr |
 874                 +---------+
 875         +---------------------------+
 876         |       lock                |
 877         +---------------------------+
 878 **********************************************/
 879                                 /* Save the next pointer */
 880                                 struct lock_list *ul_next = l_curr->next;
 881
 882                                 DEBUG(10,("delete case.\n" ));
 883
 884                                 DLIST_REMOVE(lhead, l_curr);
 885                                 if(lhead == NULL)
 886                                         break; /* No more list... */
 887
 888                                 l_curr = ul_next;
 889
 890                         } else if ( (l_curr->start >= lock->start) &&
 891                                                 (l_curr->start < lock->start + lock->size) &&
 892                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 893
 894                                 /*
 895                                  * This unlock overlaps the existing lock range at the high end.
 896                                  * Truncate by moving start to existing range end and reducing size.
 897                                  */
 898 /*********************************************
 899                 +---------------+
 900                 |  l_curr       |
 901                 +---------------+
 902         +---------------+
 903         |    lock       |
 904         +---------------+
 905 BECOMES....
 906                         +-------+
 907                         | l_curr|
 908                         +-------+
 909 **********************************************/
 910
 911                                 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
 912                                 l_curr->start = lock->start + lock->size;
 913
 914                                 DEBUG(10,("truncate high case: start=%.0f,size=%.0f\n",
 915                                                                 (double)l_curr->start, (double)l_curr->size ));
 916
 917                                 l_curr = l_curr->next;
 918
 919                         } else if ( (l_curr->start < lock->start) &&
 920                                                 (l_curr->start + l_curr->size > lock->start) &&
 921                                                 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
 922
 923                                 /*
 924                                  * This unlock overlaps the existing lock range at the low end.
 925                                  * Truncate by reducing size.
 926                                  */
 927 /*********************************************
 928    +---------------+
 929    |  l_curr       |
 930    +---------------+
 931            +---------------+
 932            |    lock       |
 933            +---------------+
 934 BECOMES....
 935    +-------+
 936    | l_curr|
 937    +-------+
 938 **********************************************/
 939
 940                                 l_curr->size = lock->start - l_curr->start;
 941
 942                                 DEBUG(10,("truncate low case: start=%.0f,size=%.0f\n",
 943                                                                 (double)l_curr->start, (double)l_curr->size ));
 944
 945                                 l_curr = l_curr->next;
 946
 947                         } else if ( (l_curr->start < lock->start) &&
 948                                                 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
 949                                 /*
 950                                  * Worst case scenario. Unlock request completely overlaps an existing
 951                                  * lock range. Split the request into two, push the new (upper) request
 952                                  * into the dlink list, and continue with the entry after ul_new (as we
 953                                  * know that ul_new will not overlap with this lock).
 954                                  */
 955 /*********************************************
 956         +---------------------------+
 957         |        l_curr             |
 958         +---------------------------+
 959                 +---------+
 960                 | lock    |
 961                 +---------+
 962 BECOMES.....
 963         +-------+         +---------+
 964         | l_curr|         | l_new   |
 965         +-------+         +---------+
 966 **********************************************/
 967                                 struct lock_list *l_new = (struct lock_list *)talloc(ctx,
 968                                                                                                         sizeof(struct lock_list));
 969
 970                                 if(l_new == NULL) {
 971                                         DEBUG(0,("posix_lock_list: talloc fail.\n"));
 972                                         return NULL; /* The talloc_destroy takes care of cleanup. */
 973                                 }
 974
 975                                 ZERO_STRUCTP(l_new);
 976                                 l_new->start = lock->start + lock->size;
 977                                 l_new->size = l_curr->start + l_curr->size - l_new->start;
 978
 979                                 /* Truncate the l_curr. */
 980                                 l_curr->size = lock->start - l_curr->start;
 981
 982                                 DEBUG(10,("split case: curr: start=%.0f,size=%.0f \
 983 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
 984                                                                 (double)l_new->start, (double)l_new->size ));
 985
 986                                 /*
 987                                  * Add into the dlink list after the l_curr point - NOT at lhead.
 988                                  * Note we can't use DLINK_ADD here as this inserts at the head of the given list.
 989                                  */
 990
 991                                 l_new->prev = l_curr;
 992                                 l_new->next = l_curr->next;
 993                                 l_curr->next = l_new;
 994
 995                                 /* And move after the link we added. */
 996                                 l_curr = l_new->next;
 997
 998                         } else {
 999
1000                                 /*
1001                                  * This logic case should never happen. Ensure this is the
1002                                  * case by forcing an abort.... Remove in production.
1003                                  */
1004                                 pstring msg;
1005
1006                                 slprintf(msg, sizeof(msg)-1, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
1007 lock: start = %.0f, size = %.0f\n", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size );
1008
1009                                 smb_panic(msg);
1010                         }
1011                 } /* end for ( l_curr = lhead; l_curr;) */
1012         } /* end for (i=0; i<num_locks && ul_head; i++) */
1013
1014         if (dbuf.dptr)
1015                 free(dbuf.dptr);
1016
1017         return lhead;
1018 }
1019
1020 /****************************************************************************
1021  POSIX function to acquire a lock. Returns True if the
1022  lock could be granted, False if not.
1023 ****************************************************************************/
1024
1025 BOOL set_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count, enum brl_type lock_type)
1026 {
1027         SMB_OFF_T offset;
1028         SMB_OFF_T count;
1029         BOOL ret = True;
1030         size_t entry_num = 0;
1031         size_t lock_count;
1032         TALLOC_CTX *l_ctx = NULL;
1033         struct lock_list *llist = NULL;
1034         struct lock_list *ll = NULL;
1035         int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1036
1037         DEBUG(5,("set_posix_lock: File %s, offset = %.0f, count = %.0f, type = %s\n",
1038                         fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) ));
1039
1040         /*
1041          * If the requested lock won't fit in the POSIX range, we will
1042          * pretend it was successful.
1043          */
1044
1045         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
1046                 return True;
1047
1048         /*
1049          * Windows is very strange. It allows read locks to be overlayed
1050          * (even over a write lock), but leaves the write lock in force until the first
1051          * unlock. It also reference counts the locks. This means the following sequence :
1052          *
1053          * process1                                      process2
1054          * ------------------------------------------------------------------------
1055          * WRITE LOCK : start = 2, len = 10
1056          *                                            READ LOCK: start =0, len = 10 - FAIL
1057          * READ LOCK : start = 0, len = 14
1058          *                                            READ LOCK: start =0, len = 10 - FAIL
1059          * UNLOCK : start = 2, len = 10
1060          *                                            READ LOCK: start =0, len = 10 - OK
1061          *
1062          * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
1063          * would leave a single read lock over the 0-14 region. In order to
1064          * re-create Windows semantics mapped to POSIX locks, we create multiple TDB
1065          * entries, one for each overlayed lock request. We are guarenteed by the brlock
1066          * semantics that if a write lock is added, then it will be first in the array.
1067          */
1068
1069         if ((l_ctx = talloc_init()) == NULL) {
1070                 DEBUG(0,("set_posix_lock: unable to init talloc context.\n"));
1071                 return True; /* Not a fatal error. */
1072         }
1073
1074         if ((ll = (struct lock_list *)talloc(l_ctx, sizeof(struct lock_list))) == NULL) {
1075                 DEBUG(0,("set_posix_lock: unable to talloc unlock list.\n"));
1076                 talloc_destroy(l_ctx);
1077                 return True; /* Not a fatal error. */
1078         }
1079
1080         /*
1081          * Create the initial list entry containing the
1082          * lock we want to add.
1083          */
1084
1085         ZERO_STRUCTP(ll);
1086         ll->start = offset;
1087         ll->size = count;
1088
1089         DLIST_ADD(llist, ll);
1090
1091         /*
1092          * The following call calculates if there are any
1093          * overlapping locks held by this process on
1094          * fd's open on the same file and splits this list
1095          * into a list of lock ranges that do not overlap with existing
1096          * POSIX locks.
1097          */
1098
1099         llist = posix_lock_list(l_ctx, llist, fsp);
1100
1101         /*
1102          * Now we have the list of ranges to lock it is safe to add the
1103          * entry into the POSIX lock tdb. We take note of the entry we
1104          * added here in case we have to remove it on POSIX lock fail.
1105          */
1106
1107         if (!add_posix_lock_entry(fsp,offset,count,posix_lock_type,&entry_num)) {
1108                 DEBUG(0,("set_posix_lock: Unable to create posix lock entry !\n"));
1109                 talloc_destroy(l_ctx);
1110                 return False;
1111         }
1112
1113         /*
1114          * Add the POSIX locks on the list of ranges returned.
1115          * As the lock is supposed to be added atomically, we need to
1116          * back out all the locks if any one of these calls fail.
1117          */
1118
1119         for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1120                 offset = ll->start;
1121                 count = ll->size;
1122
1123                 DEBUG(5,("set_posix_lock: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1124                         posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1125
1126                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1127                         DEBUG(5,("set_posix_lock: Lock fail !: Type = %s: offset = %.0f, count = %.0f\n",
1128                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1129                         ret = False;
1130                         break;
1131                 }
1132         }
1133
1134         if (!ret) {
1135
1136                 /*
1137                  * Back out all the POSIX locks we have on fail.
1138                  */
1139
1140                 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1141                         offset = ll->start;
1142                         count = ll->size;
1143
1144                         DEBUG(5,("set_posix_lock: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1145                                 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1146
1147                         posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1148                 }
1149
1150                 /*
1151                  * Remove the tdb entry for this lock.
1152                  */
1153
1154                 delete_posix_lock_entry_by_index(fsp,entry_num);
1155         }
1156
1157         talloc_destroy(l_ctx);
1158         return ret;
1159 }
1160
1161 /****************************************************************************
1162  POSIX function to release a lock. Returns True if the
1163  lock could be released, False if not.
1164 ****************************************************************************/
1165
1166 BOOL release_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_count)
1167 {
1168         SMB_OFF_T offset;
1169         SMB_OFF_T count;
1170         BOOL ret = True;
1171         TALLOC_CTX *ul_ctx = NULL;
1172         struct lock_list *ulist = NULL;
1173         struct lock_list *ul = NULL;
1174         struct posix_lock deleted_lock;
1175         int num_overlapped_entries;
1176
1177         DEBUG(5,("release_posix_lock: File %s, offset = %.0f, count = %.0f\n",
1178                 fsp->fsp_name, (double)u_offset, (double)u_count ));
1179
1180         /*
1181          * If the requested lock won't fit in the POSIX range, we will
1182          * pretend it was successful.
1183          */
1184
1185         if(!posix_lock_in_range(&offset, &count, u_offset, u_count))
1186                 return True;
1187
1188         /*
1189          * We treat this as one unlock request for POSIX accounting purposes even
1190          * if it may later be split into multiple smaller POSIX unlock ranges.
1191          * num_overlapped_entries is the number of existing locks that have any
1192          * overlap with this unlock request.
1193          */
1194
1195         num_overlapped_entries = delete_posix_lock_entry(fsp, offset, count, &deleted_lock);
1196
1197         if (num_overlapped_entries == -1) {
1198         smb_panic("release_posix_lock: unable find entry to delete !\n");
1199         }
1200
1201         /*
1202          * If num_overlapped_entries is > 0, and the lock_type we just deleted from the tdb was
1203          * a POSIX write lock, then before doing the unlock we need to downgrade
1204          * the POSIX lock to a read lock. This allows any overlapping read locks
1205          * to be atomically maintained.
1206          */
1207
1208         if (num_overlapped_entries > 0 && deleted_lock.lock_type == F_WRLCK) {
1209                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1210                         DEBUG(0,("release_posix_lock: downgrade of lock failed !\n"));
1211                         return False;
1212                 }
1213         }
1214
1215         if ((ul_ctx = talloc_init()) == NULL) {
1216                 DEBUG(0,("release_posix_lock: unable to init talloc context.\n"));
1217                 return True; /* Not a fatal error. */
1218         }
1219
1220         if ((ul = (struct lock_list *)talloc(ul_ctx, sizeof(struct lock_list))) == NULL) {
1221                 DEBUG(0,("release_posix_lock: unable to talloc unlock list.\n"));
1222                 talloc_destroy(ul_ctx);
1223                 return True; /* Not a fatal error. */
1224         }
1225
1226         /*
1227          * Create the initial list entry containing the
1228          * lock we want to remove.
1229          */
1230
1231         ZERO_STRUCTP(ul);
1232         ul->start = offset;
1233         ul->size = count;
1234
1235         DLIST_ADD(ulist, ul);
1236
1237         /*
1238          * The following call calculates if there are any
1239          * overlapping locks held by this process on
1240          * fd's open on the same file and creates a
1241          * list of unlock ranges that will allow
1242          * POSIX lock ranges to remain on the file whilst the
1243          * unlocks are performed.
1244          */
1245
1246         ulist = posix_lock_list(ul_ctx, ulist, fsp);
1247
1248         /*
1249          * Release the POSIX locks on the list of ranges returned.
1250          */
1251
1252         for(; ulist; ulist = ulist->next) {
1253                 offset = ulist->start;
1254                 count = ulist->size;
1255
1256                 DEBUG(5,("release_posix_lock: Real unlock: offset = %.0f, count = %.0f\n",
1257                         (double)offset, (double)count ));
1258
1259                 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK))
1260                         ret = False;
1261         }
1262
1263         talloc_destroy(ul_ctx);
1264
1265         return ret;
1266 }
1267
1268 /****************************************************************************
1269  Remove all lock entries for a specific dev/inode pair from the tdb.
1270 ****************************************************************************/
1271
1272 static void delete_posix_lock_entries(files_struct *fsp)
1273 {
1274         TDB_DATA kbuf = locking_key_fsp(fsp);
1275
1276         if (tdb_delete(posix_lock_tdb, kbuf) == -1)
1277                 DEBUG(0,("delete_close_entries: tdb_delete fail !\n"));
1278 }
1279
1280 /****************************************************************************
1281  Debug function.
1282 ****************************************************************************/
1283
1284 static void dump_entry(struct posix_lock *pl)
1285 {
1286         DEBUG(10,("entry: start=%.0f, size=%.0f, type=%d, fd=%i\n",
1287                 (double)pl->start, (double)pl->size, (int)pl->lock_type, pl->fd ));
1288 }
1289
1290 /****************************************************************************
1291  Remove any locks on this fd. Called from file_close().
1292 ****************************************************************************/
1293
1294 void posix_locking_close_file(files_struct *fsp)
1295 {
1296         struct posix_lock *entries = NULL;
1297         size_t count, i;
1298
1299         /*
1300          * Optimization for the common case where we are the only
1301          * opener of a file. If all fd entries are our own, we don't
1302          * need to explicitly release all the locks via the POSIX functions,
1303          * we can just remove all the entries in the tdb and allow the
1304          * close to remove the real locks.
1305          */
1306
1307         count = get_posix_lock_entries(fsp, &entries);
1308
1309         if (count == 0) {
1310                 DEBUG(10,("posix_locking_close_file: file %s has no outstanding locks.\n", fsp->fsp_name ));
1311                 return;
1312         }
1313
1314         for (i = 0; i < count; i++) {
1315                 if (entries[i].fd != fsp->fd )
1316                         break;
1317
1318                 dump_entry(&entries[i]);
1319         }
1320
1321         if (i == count) {
1322                 /* All locks are ours. */
1323                 DEBUG(10,("posix_locking_close_file: file %s has %u outstanding locks, but all on one fd.\n",
1324                         fsp->fsp_name, (unsigned int)count ));
1325                 free((char *)entries);
1326                 delete_posix_lock_entries(fsp);
1327                 return;
1328         }
1329
1330         /*
1331          * Difficult case. We need to delete all our locks, whilst leaving
1332          * all other POSIX locks in place.
1333          */
1334
1335         for (i = 0; i < count; i++) {
1336                 struct posix_lock *pl = &entries[i];
1337                 if (pl->fd == fsp->fd)
1338                         release_posix_lock(fsp, (SMB_BIG_UINT)pl->start, (SMB_BIG_UINT)pl->size );
1339         }
1340         free((char *)entries);
1341 }
1342
1343 /*******************************************************************
1344  Create the in-memory POSIX lock databases.
1345 ********************************************************************/
1346
1347 BOOL posix_locking_init(int read_only)
1348 {
1349         if (posix_lock_tdb && posix_pending_close_tdb)
1350                 return True;
1351
1352         if (!posix_lock_tdb)
1353                 posix_lock_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL,
1354                                           read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
1355         if (!posix_lock_tdb) {
1356                 DEBUG(0,("Failed to open POSIX byte range locking database.\n"));
1357                 return False;
1358         }
1359         if (!posix_pending_close_tdb)
1360                 posix_pending_close_tdb = tdb_open_log(NULL, 0, TDB_INTERNAL,
1361                                                    read_only?O_RDONLY:(O_RDWR|O_CREAT), 0644);
1362         if (!posix_pending_close_tdb) {
1363                 DEBUG(0,("Failed to open POSIX pending close database.\n"));
1364                 return False;
1365         }
1366
1367         return True;
1368 }
1369
1370 /*******************************************************************
1371  Delete the in-memory POSIX lock databases.
1372 ********************************************************************/
1373
1374 BOOL posix_locking_end(void)
1375 {
1376     if (posix_lock_tdb && tdb_close(posix_lock_tdb) != 0)
1377                 return False;
1378     if (posix_pending_close_tdb && tdb_close(posix_pending_close_tdb) != 0)
1379                 return False;
1380         return True;
1381 }