diff options
| -rw-r--r-- | source3/locking/posix.c | 210 |
1 files changed, 142 insertions, 68 deletions
diff --git a/source3/locking/posix.c b/source3/locking/posix.c index 45d139b734..f7468aac4b 100644 --- a/source3/locking/posix.c +++ b/source3/locking/posix.c @@ -299,18 +299,66 @@ static const char *posix_lock_type_name(int lock_type) } /**************************************************************************** + Delete a POSIX lock entry by index number. Used if the tdb add succeeds, but + then the POSIX fcntl lock fails. +****************************************************************************/ + +static BOOL delete_posix_lock_entry_by_index(files_struct *fsp, size_t entry) +{ + TDB_DATA kbuf = locking_key_fsp(fsp); + TDB_DATA dbuf; + struct posix_lock *locks; + size_t count; + + dbuf.dptr = NULL; + + dbuf = tdb_fetch(posix_lock_tdb, kbuf); + + if (!dbuf.dptr) { + DEBUG(10,("delete_posix_lock_entry_by_index: tdb_fetch failed !\n")); + goto fail; + } + + count = (size_t)(dbuf.dsize / sizeof(struct posix_lock)); + locks = (struct posix_lock *)dbuf.dptr; + + if (count == 1) { + tdb_delete(posix_lock_tdb, kbuf); + } else { + if (entry < count-1) { + memmove(&locks[entry], &locks[entry+1], sizeof(*locks)*((count-1) - entry)); + } + dbuf.dsize -= sizeof(*locks); + tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE); + } + + free(dbuf.dptr); + + return True; + + fail: + if (dbuf.dptr) + free(dbuf.dptr); + return False; +} + +/**************************************************************************** Add an entry into the POSIX locking tdb. Returns the number of records that - match the given start and size, or -1 on error. + completely overlap this request, or -1 on error. entry_num gets set to the + index number of the added lock (used in case we need to delete *exactly* + this entry). ****************************************************************************/ -static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, int lock_type) +static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, int lock_type, size_t *entry_num) { TDB_DATA kbuf = locking_key_fsp(fsp); TDB_DATA dbuf; struct posix_lock pl; struct posix_lock *entries; size_t i, count; - int num_records = 0; + int num_overlapping_records = 0; + + *entry_num = 0; /* * Windows is very strange. It allows read locks to be overlayed on @@ -321,7 +369,7 @@ static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T si * ------------------------------------------------------------------------ * WRITE LOCK : start = 0, len = 10 * READ LOCK: start =0, len = 10 - FAIL - * READ LOCK : start = 0, len = 10 + * READ LOCK : start = 5, len = 2 * READ LOCK: start =0, len = 10 - FAIL * UNLOCK : start = 0, len = 10 * READ LOCK: start =0, len = 10 - OK @@ -337,8 +385,26 @@ static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T si dbuf = tdb_fetch(posix_lock_tdb, kbuf); + count = (size_t)(dbuf.dsize / sizeof(pl)); + entries = (struct posix_lock *)dbuf.dptr; + + /* + * Ensure we look for overlapping entries *before* + * we add this entry. Count the number of entries + * that completely overlap this request. + */ + + for (i = 0; i < count; i++) { + struct posix_lock *entry = &entries[i]; + + if (fsp->fd == entry->fd && + start >= entry->start && + start + size <= entry->start + entry->size) + num_overlapping_records++; + } + /* - * New record. + * Add new record. */ pl.fd = fsp->fd; @@ -355,18 +421,7 @@ static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T si memcpy(dbuf.dptr + dbuf.dsize, &pl, sizeof(pl)); dbuf.dsize += sizeof(pl); - count = (size_t)(dbuf.dsize / sizeof(pl)); - entries = (struct posix_lock *)dbuf.dptr; - - for (i = 0; i < count; i++) { - struct posix_lock *entry = &entries[i]; - - if (fsp->fd == entry->fd && - start == entry->start && - size == entry->size) - num_records++; - - } + *entry_num = count; if (tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE) == -1) { DEBUG(0,("add_posix_lock: Failed to add lock entry on file %s\n", fsp->fsp_name)); @@ -376,20 +431,22 @@ static int add_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T si free(dbuf.dptr); DEBUG(10,("add_posix_lock: File %s: type = %s: start=%.0f size=%.0f: num_records = %d : dev=%.0f inode=%.0f\n", - fsp->fsp_name, posix_lock_type_name(lock_type), (double)start, (double)size, num_records, + fsp->fsp_name, posix_lock_type_name(lock_type), (double)start, (double)size, num_overlapping_records, (double)fsp->dev, (double)fsp->inode )); - return num_records; + return num_overlapping_records; fail: if (dbuf.dptr) free(dbuf.dptr); + *entry_num = 0; return -1; } /**************************************************************************** Delete an entry from the POSIX locking tdb. Returns a copy of the entry being - deleted and the number of remaining matching records, or -1 on error. + deleted and the number of records that are completely overlapped by this one, + or -1 on error. ****************************************************************************/ static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T size, struct posix_lock *pl) @@ -398,7 +455,8 @@ static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T TDB_DATA dbuf; struct posix_lock *locks; size_t i, count; - int num_records = 0; + BOOL found = False; + int num_overlapping_records = 0; dbuf.dptr = NULL; @@ -414,20 +472,10 @@ static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T count = (size_t)(dbuf.dsize / sizeof(*locks)); /* - * Count the number of entries that match this - * unlock request. + * Search for and delete the first record that matches the + * unlock criteria. */ - for (i = 0; i < count; i++) { - struct posix_lock *entry = &locks[i]; - - if (entry->fd == fsp->fd && - entry->start == start && - entry->size == size) { - num_records++; - } - } - for (i=0; i<count; i++) { struct posix_lock *entry = &locks[i]; @@ -435,16 +483,10 @@ static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T entry->start == start && entry->size == size) { - num_records--; /* We're deleting one. */ - /* Make a copy if requested. */ if (pl) *pl = *entry; - DEBUG(10,("delete_posix_lock_entry: type = %s: start=%.0f size=%.0f, num_records = %d\n", - posix_lock_type_name(entry->lock_type), (double)entry->start, (double)entry->size, - (unsigned int)num_records )); - /* Found it - delete it. */ if (count == 1) { tdb_delete(posix_lock_tdb, kbuf); @@ -455,13 +497,39 @@ static int delete_posix_lock_entry(files_struct *fsp, SMB_OFF_T start, SMB_OFF_T dbuf.dsize -= sizeof(*locks); tdb_store(posix_lock_tdb, kbuf, dbuf, TDB_REPLACE); } - - free(dbuf.dptr); - return num_records; + count--; + found = True; + break; } } - /* We didn't find it. */ + if (!found) + goto fail; + + /* + * Count the number of entries that are + * overlapped completely by this unlock request. + * (Note that this is the reverse of the test in + * add_posix_lock). + */ + + for (i = 0; i < count; i++) { + struct posix_lock *entry = &locks[i]; + + if (fsp->fd == entry->fd && + entry->start >= start && + entry->start + entry->size <= start + size) + num_overlapping_records++; + } + + DEBUG(10,("delete_posix_lock_entry: type = %s: start=%.0f size=%.0f, num_records = %d\n", + posix_lock_type_name(pl->lock_type), (double)pl->start, (double)pl->size, + (unsigned int)num_overlapping_records )); + + if (dbuf.dptr) + free(dbuf.dptr); + + return num_overlapping_records; fail: if (dbuf.dptr) @@ -854,8 +922,9 @@ BOOL set_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_cou SMB_OFF_T offset; SMB_OFF_T count; BOOL ret = True; + size_t entry_num = 0; int posix_lock_type = map_posix_lock_type(fsp,lock_type); - int ref_count; + int num_overlapping_records; DEBUG(5,("set_posix_lock: File %s, offset = %.0f, count = %.0f, type = %s\n", fsp->fsp_name, (double)u_offset, (double)u_count, posix_lock_type_name(lock_type) )); @@ -878,19 +947,30 @@ BOOL set_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u_cou * case described above in add_posix_lock_entry(). */ - ref_count = add_posix_lock_entry(fsp,offset,count,posix_lock_type); + num_overlapping_records = add_posix_lock_entry(fsp,offset,count,posix_lock_type,&entry_num); + + if (num_overlapping_records == -1) { + DEBUG(0,("set_posix_lock: Unable to create posix lock entry !\n")); + return False; + } - if (ref_count == 1) { + /* + * num_overlapping_records is the count of lock records that + * completely contain this request on the same fsp. Only bother + * with the real lock request if there are none, otherwise ignore. + */ + + if (num_overlapping_records == 0) { /* - * First lock entry created. Do a real POSIX lock. + * First lock entry for this range created. Do a real POSIX lock. */ ret = posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type); /* - * Oops, POSIX lock failed, delete the tdb entry. + * Oops, POSIX lock failed, delete the tdb entry we just added. */ if (!ret) - delete_posix_lock_entry(fsp,offset,count,NULL); + delete_posix_lock_entry_by_index(fsp,entry_num); } return ret; @@ -953,8 +1033,8 @@ static struct unlock_list *posix_unlock_list(TALLOC_CTX *ctx, struct unlock_list for (ul_curr = ulhead; ul_curr;) { - DEBUG(10,("posix_unlock_list: lock: start=%.0f,size=%.0f:", - (double)lock->start, (double)lock->size )); + DEBUG(10,("posix_unlock_list: lock: fd=%d: start=%.0f,size=%.0f:type=%s", lock->fd, + (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) )); if ( (ul_curr->start >= (lock->start + lock->size)) || (lock->start >= (ul_curr->start + ul_curr->size))) { @@ -1139,7 +1219,7 @@ BOOL release_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u struct unlock_list *ulist = NULL; struct unlock_list *ul = NULL; struct posix_lock deleted_lock; - int num_entries; + int num_overlapped_entries; DEBUG(5,("release_posix_lock: File %s, offset = %.0f, count = %.0f\n", fsp->fsp_name, (double)u_offset, (double)u_count )); @@ -1154,32 +1234,26 @@ BOOL release_posix_lock(files_struct *fsp, SMB_BIG_UINT u_offset, SMB_BIG_UINT u /* * We treat this as one unlock request for POSIX accounting purposes even - * if it may have been split into multiple smaller POSIX unlock ranges. + * if it may later be split into multiple smaller POSIX unlock ranges. */ - num_entries = delete_posix_lock_entry(fsp, offset, count, &deleted_lock); + num_overlapped_entries = delete_posix_lock_entry(fsp, offset, count, &deleted_lock); - if (num_entries == -1) { + if (num_overlapped_entries == -1) { smb_panic("release_posix_lock: unable find entry to delete !\n"); } /* - * If num_entries is > 0, and the lock_type we just deleted from the tdb was - * a POSIX write lock, then rather than doing an unlock we need to downgrade + * If num_overlapped_entries is > 0, and the lock_type we just deleted from the tdb was + * a POSIX write lock, then before doing the unlock we need to downgrade * the POSIX lock to a read lock. */ - if (num_entries > 0 && deleted_lock.lock_type == F_WRLCK) { - return posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK); - } - - /* - * Only do the POSIX unlock when the num_entries is now zero. - */ - - if (num_entries > 0) { - DEBUG(10, ("release_posix_lock: num_entries = %d\n", num_entries )); - return True; + if (num_overlapped_entries > 0 && deleted_lock.lock_type == F_WRLCK) { + if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) { + DEBUG(0,("release_posix_lock: downgrade of lock failed !\n")); + return False; + } } if ((ul_ctx = talloc_init()) == NULL) { |