struct byte_range_lock *do_lock(files_struct *fsp,
uint32 lock_pid,
SMB_BIG_UINT count,
SMB_BIG_UINT offset,
enum brl_type lock_type,
enum brl_flavour lock_flav,
BOOL blocking_lock,
NTSTATUS *perr,
uint32 *plock_pid)
{
struct byte_range_lock *br_lck = NULL;
if (!fsp->can_lock) {
*perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
return NULL;
}
if (!lp_locking(fsp->conn->params)) {
*perr = NT_STATUS_OK;
return NULL;
}
/* NOTE! 0 byte long ranges ARE allowed and should be stored */
DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
lock_flav_name(lock_flav), lock_type_name(lock_type),
(double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
br_lck = brl_get_locks(NULL, fsp);
if (!br_lck) {
*perr = NT_STATUS_NO_MEMORY;
return NULL;
}
*perr = brl_lock(br_lck,
lock_pid,
procid_self(),
offset,
count,
lock_type,
lock_flav,
blocking_lock,
plock_pid);
if (lock_flav == WINDOWS_LOCK &&
fsp->current_lock_count != NO_LOCKING_COUNT) {
/* blocking ie. pending, locks also count here,
* as this is an efficiency counter to avoid checking
* the lock db. on close. JRA. */
fsp->current_lock_count++;
} else {
/* Notice that this has had a POSIX lock request.
* We can't count locks after this so forget them.
*/
fsp->current_lock_count = NO_LOCKING_COUNT;
}
return br_lck;
}
NTSTATUS do_lock(files_struct *fsp,
uint16 lock_pid,
SMB_BIG_UINT count,
SMB_BIG_UINT offset,
enum brl_type lock_type,
enum brl_flavour lock_flav,
BOOL *my_lock_ctx)
{
struct byte_range_lock *br_lck = NULL;
NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
if (!OPEN_FSP(fsp) || !fsp->can_lock) {
return NT_STATUS_INVALID_HANDLE;
}
if (!lp_locking(SNUM(fsp->conn))) {
return NT_STATUS_OK;
}
/* NOTE! 0 byte long ranges ARE allowed and should be stored */
DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
lock_flav_name(lock_flav), lock_type_name(lock_type),
(double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
br_lck = brl_get_locks(fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
status = brl_lock(br_lck,
lock_pid,
procid_self(),
offset,
count,
lock_type,
lock_flav,
my_lock_ctx);
byte_range_lock_destructor(br_lck);
return status;
}
BOOL is_locked(files_struct *fsp,
SMB_BIG_UINT count,
SMB_BIG_UINT offset,
enum brl_type lock_type)
{
int snum = SNUM(fsp->conn);
int strict_locking = lp_strict_locking(snum);
enum brl_flavour lock_flav = lp_posix_cifsu_locktype();
BOOL ret = True;
if (count == 0) {
return False;
}
if (!lp_locking(snum) || !strict_locking) {
return False;
}
if (strict_locking == Auto) {
if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
ret = False;
} else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
(lock_type == READ_LOCK)) {
DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
ret = False;
} else {
struct byte_range_lock *br_lck = brl_get_locks(fsp);
if (!br_lck) {
return False;
}
ret = !brl_locktest(br_lck,
global_smbpid,
procid_self(),
offset,
count,
lock_type,
lock_flav);
byte_range_lock_destructor(br_lck);
}
} else {
struct byte_range_lock *br_lck = brl_get_locks(fsp);
if (!br_lck) {
return False;
}
ret = !brl_locktest(br_lck,
global_smbpid,
procid_self(),
offset,
count,
lock_type,
lock_flav);
byte_range_lock_destructor(br_lck);
}
DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
lock_flav_name(lock_flav),
(double)offset, (double)count, ret ? "locked" : "unlocked",
fsp->fnum, fsp->fsp_name ));
return ret;
}
struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
files_struct *fsp,
uint64_t smblctx,
uint64_t count,
uint64_t offset,
enum brl_type lock_type,
enum brl_flavour lock_flav,
bool blocking_lock,
NTSTATUS *perr,
uint64_t *psmblctx,
struct blocking_lock_record *blr)
{
struct byte_range_lock *br_lck = NULL;
/* silently return ok on print files as we don't do locking there */
if (fsp->print_file) {
*perr = NT_STATUS_OK;
return NULL;
}
if (!fsp->can_lock) {
*perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
return NULL;
}
if (!lp_locking(fsp->conn->params)) {
*perr = NT_STATUS_OK;
return NULL;
}
/* NOTE! 0 byte long ranges ARE allowed and should be stored */
DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
"blocking_lock=%s requested for %s file %s\n",
lock_flav_name(lock_flav), lock_type_name(lock_type),
(double)offset, (double)count, blocking_lock ? "true" :
"false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
*perr = NT_STATUS_NO_MEMORY;
return NULL;
}
*perr = brl_lock(msg_ctx,
br_lck,
smblctx,
messaging_server_id(fsp->conn->sconn->msg_ctx),
offset,
count,
lock_type,
lock_flav,
blocking_lock,
psmblctx,
blr);
DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
increment_current_lock_count(fsp, lock_flav);
return br_lck;
}
bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
{
int strict_locking = lp_strict_locking(fsp->conn->params);
bool ret = False;
if (plock->size == 0) {
return True;
}
if (!lp_locking(fsp->conn->params) || !strict_locking) {
return True;
}
if (strict_locking == Auto) {
if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
ret = True;
} else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
(plock->lock_type == READ_LOCK)) {
DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
ret = True;
} else {
struct byte_range_lock *br_lck;
br_lck = brl_get_locks_readonly(fsp);
if (!br_lck) {
return True;
}
ret = brl_locktest(br_lck,
plock->context.smblctx,
plock->context.pid,
plock->start,
plock->size,
plock->lock_type,
plock->lock_flav);
}
} else {
struct byte_range_lock *br_lck;
br_lck = brl_get_locks_readonly(fsp);
if (!br_lck) {
return True;
}
ret = brl_locktest(br_lck,
plock->context.smblctx,
plock->context.pid,
plock->start,
plock->size,
plock->lock_type,
plock->lock_flav);
}
DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
"len=%.0f %s for fnum %llu file %s\n",
lock_flav_name(plock->lock_flav),
(double)plock->start, (double)plock->size,
ret ? "unlocked" : "locked",
(unsigned long long)plock->fnum, fsp_str_dbg(fsp)));
return ret;
}
