1c8ec8eeaSjose borrego /* 2c8ec8eeaSjose borrego * CDDL HEADER START 3c8ec8eeaSjose borrego * 4c8ec8eeaSjose borrego * The contents of this file are subject to the terms of the 5c8ec8eeaSjose borrego * Common Development and Distribution License (the "License"). 6c8ec8eeaSjose borrego * You may not use this file except in compliance with the License. 7c8ec8eeaSjose borrego * 8c8ec8eeaSjose borrego * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9c8ec8eeaSjose borrego * or http://www.opensolaris.org/os/licensing. 10c8ec8eeaSjose borrego * See the License for the specific language governing permissions 11c8ec8eeaSjose borrego * and limitations under the License. 12c8ec8eeaSjose borrego * 13c8ec8eeaSjose borrego * When distributing Covered Code, include this CDDL HEADER in each 14c8ec8eeaSjose borrego * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15c8ec8eeaSjose borrego * If applicable, add the following below this CDDL HEADER, with the 16c8ec8eeaSjose borrego * fields enclosed by brackets "[]" replaced with your own identifying 17c8ec8eeaSjose borrego * information: Portions Copyright [yyyy] [name of copyright owner] 18c8ec8eeaSjose borrego * 19c8ec8eeaSjose borrego * CDDL HEADER END 20c8ec8eeaSjose borrego */ 21c8ec8eeaSjose borrego /* 22148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23*bc7c423fSGordon Ross * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 24c8ec8eeaSjose borrego */ 25c8ec8eeaSjose borrego 26c8ec8eeaSjose borrego /* 27c8ec8eeaSjose borrego * This module provides range lock functionality for CIFS/SMB clients. 28c8ec8eeaSjose borrego * Lock range service functions process SMB lock and and unlock 29c8ec8eeaSjose borrego * requests for a file by applying lock rules and marks file range 30c8ec8eeaSjose borrego * as locked if the lock is successful otherwise return proper 31c8ec8eeaSjose borrego * error code. 32c8ec8eeaSjose borrego */ 33c8ec8eeaSjose borrego 34bbf6f00cSJordan Brown #include <smbsrv/smb_kproto.h> 35c8ec8eeaSjose borrego #include <smbsrv/smb_fsops.h> 36c8ec8eeaSjose borrego #include <sys/nbmlock.h> 37c8ec8eeaSjose borrego #include <sys/param.h> 38c8ec8eeaSjose borrego 39c8ec8eeaSjose borrego extern caller_context_t smb_ct; 40c8ec8eeaSjose borrego 41c8ec8eeaSjose borrego static void smb_lock_posix_unlock(smb_node_t *, smb_lock_t *, cred_t *); 42c8ec8eeaSjose borrego static boolean_t smb_is_range_unlocked(uint64_t, uint64_t, uint32_t, 43c8ec8eeaSjose borrego smb_llist_t *, uint64_t *); 44c8ec8eeaSjose borrego static int smb_lock_range_overlap(smb_lock_t *, uint64_t, uint64_t); 45c8ec8eeaSjose borrego static uint32_t smb_lock_range_lckrules(smb_request_t *, smb_ofile_t *, 46c8ec8eeaSjose borrego smb_node_t *, smb_lock_t *, smb_lock_t **); 47c8ec8eeaSjose borrego static clock_t smb_lock_wait(smb_request_t *, smb_lock_t *, smb_lock_t *); 48c8ec8eeaSjose borrego static uint32_t smb_lock_range_ulckrules(smb_request_t *, smb_node_t *, 49c8ec8eeaSjose borrego uint64_t, uint64_t, smb_lock_t **nodelock); 50c8ec8eeaSjose borrego static smb_lock_t *smb_lock_create(smb_request_t *, uint64_t, uint64_t, 51c8ec8eeaSjose borrego uint32_t, uint32_t); 52c8ec8eeaSjose borrego static void smb_lock_destroy(smb_lock_t *); 53c8ec8eeaSjose borrego static void smb_lock_free(smb_lock_t *); 54c8ec8eeaSjose borrego 551fcced4cSJordan Brown /* 56148c5f43SAlan Wright * Return the number of range locks on the specified ofile. 571fcced4cSJordan Brown */ 581fcced4cSJordan Brown uint32_t 59148c5f43SAlan Wright smb_lock_get_lock_count(smb_node_t *node, smb_ofile_t *of) 601fcced4cSJordan Brown { 61148c5f43SAlan Wright smb_lock_t *lock; 62148c5f43SAlan Wright smb_llist_t *llist; 63148c5f43SAlan Wright uint32_t count = 0; 64c8ec8eeaSjose borrego 651fcced4cSJordan Brown SMB_NODE_VALID(node); 66148c5f43SAlan Wright SMB_OFILE_VALID(of); 671fcced4cSJordan Brown 68148c5f43SAlan Wright llist = &node->n_lock_list; 69148c5f43SAlan Wright 70148c5f43SAlan Wright smb_llist_enter(llist, RW_READER); 71148c5f43SAlan Wright for (lock = smb_llist_head(llist); 72148c5f43SAlan Wright lock != NULL; 73148c5f43SAlan Wright lock = smb_llist_next(llist, lock)) { 74148c5f43SAlan Wright if (lock->l_file == of) 75148c5f43SAlan Wright ++count; 76148c5f43SAlan Wright } 77148c5f43SAlan Wright smb_llist_exit(llist); 781fcced4cSJordan Brown 791fcced4cSJordan Brown return (count); 801fcced4cSJordan Brown } 81c8ec8eeaSjose borrego 82c8ec8eeaSjose borrego /* 83c8ec8eeaSjose borrego * smb_unlock_range 84c8ec8eeaSjose borrego * 85c8ec8eeaSjose borrego * locates lock range performed for corresponding to unlock request. 86c8ec8eeaSjose borrego * 87c8ec8eeaSjose borrego * NT_STATUS_SUCCESS - Lock range performed successfully. 88c8ec8eeaSjose borrego * !NT_STATUS_SUCCESS - Error in unlock range operation. 89c8ec8eeaSjose borrego */ 90c8ec8eeaSjose borrego uint32_t 91c8ec8eeaSjose borrego smb_unlock_range( 92c8ec8eeaSjose borrego smb_request_t *sr, 93c8ec8eeaSjose borrego smb_node_t *node, 94c8ec8eeaSjose borrego uint64_t start, 95c8ec8eeaSjose borrego uint64_t length) 96c8ec8eeaSjose borrego { 97c8ec8eeaSjose borrego smb_lock_t *lock = NULL; 98c8ec8eeaSjose borrego uint32_t status; 99c8ec8eeaSjose borrego 100c8ec8eeaSjose borrego /* Apply unlocking rules */ 101c8ec8eeaSjose borrego smb_llist_enter(&node->n_lock_list, RW_WRITER); 102c8ec8eeaSjose borrego status = smb_lock_range_ulckrules(sr, node, start, length, &lock); 103c8ec8eeaSjose borrego if (status != NT_STATUS_SUCCESS) { 104c8ec8eeaSjose borrego /* 105c8ec8eeaSjose borrego * If lock range is not matching in the list 106c8ec8eeaSjose borrego * return error. 107c8ec8eeaSjose borrego */ 108c8ec8eeaSjose borrego ASSERT(lock == NULL); 109c8ec8eeaSjose borrego smb_llist_exit(&node->n_lock_list); 110c8ec8eeaSjose borrego return (status); 111c8ec8eeaSjose borrego } 112c8ec8eeaSjose borrego 113c8ec8eeaSjose borrego smb_llist_remove(&node->n_lock_list, lock); 114c8ec8eeaSjose borrego smb_lock_posix_unlock(node, lock, sr->user_cr); 115c8ec8eeaSjose borrego smb_llist_exit(&node->n_lock_list); 116c8ec8eeaSjose borrego smb_lock_destroy(lock); 117c8ec8eeaSjose borrego 118c8ec8eeaSjose borrego return (status); 119c8ec8eeaSjose borrego } 120c8ec8eeaSjose borrego 121c8ec8eeaSjose borrego /* 122c8ec8eeaSjose borrego * smb_lock_range 123c8ec8eeaSjose borrego * 124cb174861Sjoyce mcintosh * Checks for integrity of file lock operation for the given range of file data. 125c8ec8eeaSjose borrego * This is performed by applying lock rules with all the elements of the node 126c8ec8eeaSjose borrego * lock list. 127c8ec8eeaSjose borrego * 128cb174861Sjoyce mcintosh * Break shared (levelII) oplocks. If there is an exclusive oplock, it is 129cb174861Sjoyce mcintosh * owned by this ofile and therefore should not be broken. 130cb174861Sjoyce mcintosh * 131c8ec8eeaSjose borrego * The function returns with new lock added if lock request is non-conflicting 132c8ec8eeaSjose borrego * with existing range lock for the file. Otherwise smb request is filed 133c8ec8eeaSjose borrego * without returning. 134c8ec8eeaSjose borrego * 135c8ec8eeaSjose borrego * NT_STATUS_SUCCESS - Lock range performed successfully. 136c8ec8eeaSjose borrego * !NT_STATUS_SUCCESS - Error in lock range operation. 137c8ec8eeaSjose borrego */ 138c8ec8eeaSjose borrego uint32_t 139c8ec8eeaSjose borrego smb_lock_range( 140c8ec8eeaSjose borrego smb_request_t *sr, 141c8ec8eeaSjose borrego uint64_t start, 142c8ec8eeaSjose borrego uint64_t length, 143c8ec8eeaSjose borrego uint32_t timeout, 144c8ec8eeaSjose borrego uint32_t locktype) 145c8ec8eeaSjose borrego { 146c8ec8eeaSjose borrego smb_ofile_t *file = sr->fid_ofile; 147c8ec8eeaSjose borrego smb_node_t *node = file->f_node; 148c8ec8eeaSjose borrego smb_lock_t *lock; 149c8ec8eeaSjose borrego smb_lock_t *clock = NULL; 150c8ec8eeaSjose borrego uint32_t result = NT_STATUS_SUCCESS; 151c8ec8eeaSjose borrego boolean_t lock_has_timeout = (timeout != 0); 152c8ec8eeaSjose borrego 153c8ec8eeaSjose borrego lock = smb_lock_create(sr, start, length, locktype, timeout); 154c8ec8eeaSjose borrego 155c8ec8eeaSjose borrego smb_llist_enter(&node->n_lock_list, RW_WRITER); 156c8ec8eeaSjose borrego for (;;) { 157c8ec8eeaSjose borrego clock_t rc; 158c8ec8eeaSjose borrego 159c8ec8eeaSjose borrego /* Apply locking rules */ 160c8ec8eeaSjose borrego result = smb_lock_range_lckrules(sr, file, node, lock, &clock); 161c8ec8eeaSjose borrego 162c8ec8eeaSjose borrego if ((result == NT_STATUS_CANCELLED) || 163c8ec8eeaSjose borrego (result == NT_STATUS_SUCCESS) || 164c8ec8eeaSjose borrego (result == NT_STATUS_RANGE_NOT_LOCKED)) { 165c8ec8eeaSjose borrego ASSERT(clock == NULL); 166c8ec8eeaSjose borrego break; 167c8ec8eeaSjose borrego } else if (timeout == 0) { 168c8ec8eeaSjose borrego break; 169c8ec8eeaSjose borrego } 170c8ec8eeaSjose borrego 171c8ec8eeaSjose borrego ASSERT(result == NT_STATUS_LOCK_NOT_GRANTED); 172c8ec8eeaSjose borrego ASSERT(clock); 173c8ec8eeaSjose borrego /* 174c8ec8eeaSjose borrego * Call smb_lock_wait holding write lock for 175c8ec8eeaSjose borrego * node lock list. smb_lock_wait will release 176c8ec8eeaSjose borrego * this lock if it blocks. 177c8ec8eeaSjose borrego */ 178c8ec8eeaSjose borrego ASSERT(node == clock->l_file->f_node); 179c8ec8eeaSjose borrego 180c8ec8eeaSjose borrego rc = smb_lock_wait(sr, lock, clock); 181c8ec8eeaSjose borrego if (rc == 0) { 182c8ec8eeaSjose borrego result = NT_STATUS_CANCELLED; 183c8ec8eeaSjose borrego break; 184c8ec8eeaSjose borrego } 185c8ec8eeaSjose borrego if (rc == -1) 186c8ec8eeaSjose borrego timeout = 0; 187c8ec8eeaSjose borrego 188c8ec8eeaSjose borrego clock = NULL; 189c8ec8eeaSjose borrego } 190c8ec8eeaSjose borrego 191c8ec8eeaSjose borrego lock->l_blocked_by = NULL; 192c8ec8eeaSjose borrego 193c8ec8eeaSjose borrego if (result != NT_STATUS_SUCCESS) { 194c8ec8eeaSjose borrego /* 195c8ec8eeaSjose borrego * Under certain conditions NT_STATUS_FILE_LOCK_CONFLICT 196c8ec8eeaSjose borrego * should be returned instead of NT_STATUS_LOCK_NOT_GRANTED. 197c8ec8eeaSjose borrego */ 198c8ec8eeaSjose borrego if (result == NT_STATUS_LOCK_NOT_GRANTED) { 199c8ec8eeaSjose borrego /* 200c8ec8eeaSjose borrego * Locks with timeouts always return 201c8ec8eeaSjose borrego * NT_STATUS_FILE_LOCK_CONFLICT 202c8ec8eeaSjose borrego */ 203c8ec8eeaSjose borrego if (lock_has_timeout) 204c8ec8eeaSjose borrego result = NT_STATUS_FILE_LOCK_CONFLICT; 205c8ec8eeaSjose borrego 206c8ec8eeaSjose borrego /* 207c8ec8eeaSjose borrego * Locks starting higher than 0xef000000 that do not 208c8ec8eeaSjose borrego * have the MSB set always return 209c8ec8eeaSjose borrego * NT_STATUS_FILE_LOCK_CONFLICT 210c8ec8eeaSjose borrego */ 211c8ec8eeaSjose borrego if ((lock->l_start >= 0xef000000) && 212c8ec8eeaSjose borrego !(lock->l_start & (1ULL << 63))) { 213c8ec8eeaSjose borrego result = NT_STATUS_FILE_LOCK_CONFLICT; 214c8ec8eeaSjose borrego } 215c8ec8eeaSjose borrego 216c8ec8eeaSjose borrego /* 217c8ec8eeaSjose borrego * If the last lock attempt to fail on this file handle 218c8ec8eeaSjose borrego * started at the same offset as this one then return 219c8ec8eeaSjose borrego * NT_STATUS_FILE_LOCK_CONFLICT 220c8ec8eeaSjose borrego */ 221c8ec8eeaSjose borrego mutex_enter(&file->f_mutex); 222c8ec8eeaSjose borrego if ((file->f_flags & SMB_OFLAGS_LLF_POS_VALID) && 223c8ec8eeaSjose borrego (lock->l_start == file->f_llf_pos)) { 224c8ec8eeaSjose borrego result = NT_STATUS_FILE_LOCK_CONFLICT; 225c8ec8eeaSjose borrego } 226c8ec8eeaSjose borrego mutex_exit(&file->f_mutex); 227c8ec8eeaSjose borrego } 228c8ec8eeaSjose borrego 229c8ec8eeaSjose borrego /* Update last lock failed offset */ 230c8ec8eeaSjose borrego mutex_enter(&file->f_mutex); 231c8ec8eeaSjose borrego file->f_llf_pos = lock->l_start; 232c8ec8eeaSjose borrego file->f_flags |= SMB_OFLAGS_LLF_POS_VALID; 233c8ec8eeaSjose borrego mutex_exit(&file->f_mutex); 234c8ec8eeaSjose borrego 235c8ec8eeaSjose borrego smb_lock_free(lock); 236c8ec8eeaSjose borrego } else { 237c8ec8eeaSjose borrego /* 238c8ec8eeaSjose borrego * don't insert into the CIFS lock list unless the 239c8ec8eeaSjose borrego * posix lock worked 240c8ec8eeaSjose borrego */ 241c8ec8eeaSjose borrego if (smb_fsop_frlock(node, lock, B_FALSE, sr->user_cr)) 242c8ec8eeaSjose borrego result = NT_STATUS_FILE_LOCK_CONFLICT; 243c8ec8eeaSjose borrego else 244c8ec8eeaSjose borrego smb_llist_insert_tail(&node->n_lock_list, lock); 245c8ec8eeaSjose borrego } 246c8ec8eeaSjose borrego smb_llist_exit(&node->n_lock_list); 247c8ec8eeaSjose borrego 248cb174861Sjoyce mcintosh if (result == NT_STATUS_SUCCESS) 249cb174861Sjoyce mcintosh smb_oplock_break_levelII(node); 250cb174861Sjoyce mcintosh 251c8ec8eeaSjose borrego return (result); 252c8ec8eeaSjose borrego } 253c8ec8eeaSjose borrego 254c8ec8eeaSjose borrego 255c8ec8eeaSjose borrego /* 256c8ec8eeaSjose borrego * smb_lock_range_access 257c8ec8eeaSjose borrego * 258c8ec8eeaSjose borrego * scans node lock list 259c8ec8eeaSjose borrego * to check if there is any overlapping lock. Overlapping 260c8ec8eeaSjose borrego * lock is allowed only under same session and client pid. 261c8ec8eeaSjose borrego * 262c8ec8eeaSjose borrego * Return values 263c8ec8eeaSjose borrego * NT_STATUS_SUCCESS lock access granted. 264c8ec8eeaSjose borrego * NT_STATUS_FILE_LOCK_CONFLICT access denied due to lock conflict. 265c8ec8eeaSjose borrego */ 266c8ec8eeaSjose borrego int 267c8ec8eeaSjose borrego smb_lock_range_access( 268c8ec8eeaSjose borrego smb_request_t *sr, 269c8ec8eeaSjose borrego smb_node_t *node, 270c8ec8eeaSjose borrego uint64_t start, 271*bc7c423fSGordon Ross uint64_t length, /* zero means to EoF */ 272c8ec8eeaSjose borrego boolean_t will_write) 273c8ec8eeaSjose borrego { 274c8ec8eeaSjose borrego smb_lock_t *lock; 275c8ec8eeaSjose borrego smb_llist_t *llist; 276c8ec8eeaSjose borrego int status = NT_STATUS_SUCCESS; 277c8ec8eeaSjose borrego 278c8ec8eeaSjose borrego llist = &node->n_lock_list; 279c8ec8eeaSjose borrego smb_llist_enter(llist, RW_READER); 280c8ec8eeaSjose borrego /* Search for any applicable lock */ 281c8ec8eeaSjose borrego for (lock = smb_llist_head(llist); 282c8ec8eeaSjose borrego lock != NULL; 283c8ec8eeaSjose borrego lock = smb_llist_next(llist, lock)) { 284c8ec8eeaSjose borrego 285c8ec8eeaSjose borrego if (!smb_lock_range_overlap(lock, start, length)) 286c8ec8eeaSjose borrego /* Lock does not overlap */ 287c8ec8eeaSjose borrego continue; 288c8ec8eeaSjose borrego 289c8ec8eeaSjose borrego if (lock->l_type == SMB_LOCK_TYPE_READONLY && !will_write) 290c8ec8eeaSjose borrego continue; 291c8ec8eeaSjose borrego 292c8ec8eeaSjose borrego if (lock->l_type == SMB_LOCK_TYPE_READWRITE && 293c8ec8eeaSjose borrego lock->l_session_kid == sr->session->s_kid && 294c8ec8eeaSjose borrego lock->l_pid == sr->smb_pid) 295c8ec8eeaSjose borrego continue; 296c8ec8eeaSjose borrego 297c8ec8eeaSjose borrego status = NT_STATUS_FILE_LOCK_CONFLICT; 298c8ec8eeaSjose borrego break; 299c8ec8eeaSjose borrego } 300c8ec8eeaSjose borrego smb_llist_exit(llist); 301c8ec8eeaSjose borrego return (status); 302c8ec8eeaSjose borrego } 303c8ec8eeaSjose borrego 304c8ec8eeaSjose borrego void 305c8ec8eeaSjose borrego smb_node_destroy_lock_by_ofile(smb_node_t *node, smb_ofile_t *file) 306c8ec8eeaSjose borrego { 307c8ec8eeaSjose borrego smb_lock_t *lock; 308c8ec8eeaSjose borrego smb_lock_t *nxtl; 309c8ec8eeaSjose borrego list_t destroy_list; 310c8ec8eeaSjose borrego 3112c2961f8Sjose borrego SMB_NODE_VALID(node); 312c8ec8eeaSjose borrego ASSERT(node->n_refcnt); 313c8ec8eeaSjose borrego 314c8ec8eeaSjose borrego /* 315c8ec8eeaSjose borrego * Move locks matching the specified file from the node->n_lock_list 316c8ec8eeaSjose borrego * to a temporary list (holding the lock the entire time) then 317c8ec8eeaSjose borrego * destroy all the matching locks. We can't call smb_lock_destroy 318c8ec8eeaSjose borrego * while we are holding the lock for node->n_lock_list because we will 319c8ec8eeaSjose borrego * deadlock and we can't drop the lock because the list contents might 320c8ec8eeaSjose borrego * change (for example nxtl might get removed on another thread). 321c8ec8eeaSjose borrego */ 322c8ec8eeaSjose borrego list_create(&destroy_list, sizeof (smb_lock_t), 323c8ec8eeaSjose borrego offsetof(smb_lock_t, l_lnd)); 324c8ec8eeaSjose borrego 325c8ec8eeaSjose borrego smb_llist_enter(&node->n_lock_list, RW_WRITER); 326c8ec8eeaSjose borrego lock = smb_llist_head(&node->n_lock_list); 327c8ec8eeaSjose borrego while (lock) { 328c8ec8eeaSjose borrego nxtl = smb_llist_next(&node->n_lock_list, lock); 329c8ec8eeaSjose borrego if (lock->l_file == file) { 330c8ec8eeaSjose borrego smb_llist_remove(&node->n_lock_list, lock); 331c8ec8eeaSjose borrego smb_lock_posix_unlock(node, lock, file->f_user->u_cred); 332c8ec8eeaSjose borrego list_insert_tail(&destroy_list, lock); 333c8ec8eeaSjose borrego } 334c8ec8eeaSjose borrego lock = nxtl; 335c8ec8eeaSjose borrego } 336c8ec8eeaSjose borrego smb_llist_exit(&node->n_lock_list); 337c8ec8eeaSjose borrego 338c8ec8eeaSjose borrego lock = list_head(&destroy_list); 339c8ec8eeaSjose borrego while (lock) { 340c8ec8eeaSjose borrego nxtl = list_next(&destroy_list, lock); 341c8ec8eeaSjose borrego list_remove(&destroy_list, lock); 342c8ec8eeaSjose borrego smb_lock_destroy(lock); 343c8ec8eeaSjose borrego lock = nxtl; 344c8ec8eeaSjose borrego } 345c8ec8eeaSjose borrego 346c8ec8eeaSjose borrego list_destroy(&destroy_list); 347c8ec8eeaSjose borrego } 348c8ec8eeaSjose borrego 349c8ec8eeaSjose borrego void 350c8ec8eeaSjose borrego smb_lock_range_error(smb_request_t *sr, uint32_t status32) 351c8ec8eeaSjose borrego { 352c8ec8eeaSjose borrego uint16_t errcode; 353c8ec8eeaSjose borrego 354c8ec8eeaSjose borrego if (status32 == NT_STATUS_CANCELLED) 355c8ec8eeaSjose borrego errcode = ERROR_OPERATION_ABORTED; 356c8ec8eeaSjose borrego else 357c8ec8eeaSjose borrego errcode = ERRlock; 358c8ec8eeaSjose borrego 359c8ec8eeaSjose borrego smbsr_error(sr, status32, ERRDOS, errcode); 360c8ec8eeaSjose borrego } 361c8ec8eeaSjose borrego 362c8ec8eeaSjose borrego /* 363*bc7c423fSGordon Ross * An SMB variant of nbl_conflict(). 364c8ec8eeaSjose borrego * 365*bc7c423fSGordon Ross * SMB prevents remove or rename when conflicting locks exist 366*bc7c423fSGordon Ross * (unlike NFS, which is why we can't just use nbl_conflict). 367c8ec8eeaSjose borrego * 368*bc7c423fSGordon Ross * Returns: 369*bc7c423fSGordon Ross * NT_STATUS_SHARING_VIOLATION - nbl_share_conflict 370*bc7c423fSGordon Ross * NT_STATUS_FILE_LOCK_CONFLICT - nbl_lock_conflict 371*bc7c423fSGordon Ross * NT_STATUS_SUCCESS - operation can proceed 372*bc7c423fSGordon Ross * 373*bc7c423fSGordon Ross * NB: This function used to also check the list of ofiles, 374*bc7c423fSGordon Ross * via: smb_lock_range_access() but we _can't_ do that here 375*bc7c423fSGordon Ross * due to lock order constraints between node->n_lock_list 376*bc7c423fSGordon Ross * and node->vp->vnbllock (taken via nvl_start_crit). 377*bc7c423fSGordon Ross * They must be taken in that order, and in here, we 378*bc7c423fSGordon Ross * already hold vp->vnbllock. 379c8ec8eeaSjose borrego */ 380c8ec8eeaSjose borrego DWORD 381*bc7c423fSGordon Ross smb_nbl_conflict(smb_node_t *node, uint64_t off, uint64_t len, nbl_op_t op) 382c8ec8eeaSjose borrego { 383c8ec8eeaSjose borrego int svmand; 384c8ec8eeaSjose borrego 3852c2961f8Sjose borrego SMB_NODE_VALID(node); 386c8ec8eeaSjose borrego ASSERT(smb_node_in_crit(node)); 387*bc7c423fSGordon Ross ASSERT(op == NBL_READ || op == NBL_WRITE || op == NBL_READWRITE || 388*bc7c423fSGordon Ross op == NBL_REMOVE || op == NBL_RENAME); 389c8ec8eeaSjose borrego 390037cac00Sjoyce mcintosh if (smb_node_is_dir(node)) 391c8ec8eeaSjose borrego return (NT_STATUS_SUCCESS); 392c8ec8eeaSjose borrego 393*bc7c423fSGordon Ross if (nbl_share_conflict(node->vp, op, &smb_ct)) 394*bc7c423fSGordon Ross return (NT_STATUS_SHARING_VIOLATION); 395c8ec8eeaSjose borrego 396*bc7c423fSGordon Ross /* 397*bc7c423fSGordon Ross * When checking for lock conflicts, rename and remove 398*bc7c423fSGordon Ross * are not allowed, so treat those as read/write. 399*bc7c423fSGordon Ross */ 400*bc7c423fSGordon Ross if (op == NBL_RENAME || op == NBL_REMOVE) 401*bc7c423fSGordon Ross op = NBL_READWRITE; 402c8ec8eeaSjose borrego 403*bc7c423fSGordon Ross if (nbl_svmand(node->vp, kcred, &svmand)) 404*bc7c423fSGordon Ross svmand = 1; 405c8ec8eeaSjose borrego 406*bc7c423fSGordon Ross if (nbl_lock_conflict(node->vp, op, off, len, svmand, &smb_ct)) 407c8ec8eeaSjose borrego return (NT_STATUS_FILE_LOCK_CONFLICT); 408c8ec8eeaSjose borrego 409c8ec8eeaSjose borrego return (NT_STATUS_SUCCESS); 410c8ec8eeaSjose borrego } 411c8ec8eeaSjose borrego 412c8ec8eeaSjose borrego /* 413c8ec8eeaSjose borrego * smb_lock_posix_unlock 414c8ec8eeaSjose borrego * 415c8ec8eeaSjose borrego * checks if the current unlock request is in another lock and repeatedly calls 416c8ec8eeaSjose borrego * smb_is_range_unlocked on a sliding basis to unlock all bits of the lock 417c8ec8eeaSjose borrego * that are not in other locks 418c8ec8eeaSjose borrego * 419c8ec8eeaSjose borrego */ 420c8ec8eeaSjose borrego static void 421c8ec8eeaSjose borrego smb_lock_posix_unlock(smb_node_t *node, smb_lock_t *lock, cred_t *cr) 422c8ec8eeaSjose borrego { 423c8ec8eeaSjose borrego uint64_t new_mark; 424c8ec8eeaSjose borrego uint64_t unlock_start; 425c8ec8eeaSjose borrego uint64_t unlock_end; 426c8ec8eeaSjose borrego smb_lock_t new_unlock; 427c8ec8eeaSjose borrego smb_llist_t *llist; 428c8ec8eeaSjose borrego boolean_t can_unlock; 429c8ec8eeaSjose borrego 430c8ec8eeaSjose borrego new_mark = 0; 431c8ec8eeaSjose borrego unlock_start = lock->l_start; 432c8ec8eeaSjose borrego unlock_end = unlock_start + lock->l_length; 433c8ec8eeaSjose borrego llist = &node->n_lock_list; 434c8ec8eeaSjose borrego 435c8ec8eeaSjose borrego for (;;) { 436c8ec8eeaSjose borrego can_unlock = smb_is_range_unlocked(unlock_start, unlock_end, 437c8ec8eeaSjose borrego lock->l_file->f_uniqid, llist, &new_mark); 438c8ec8eeaSjose borrego if (can_unlock) { 439c8ec8eeaSjose borrego if (new_mark) { 440c8ec8eeaSjose borrego new_unlock = *lock; 441c8ec8eeaSjose borrego new_unlock.l_start = unlock_start; 442c8ec8eeaSjose borrego new_unlock.l_length = new_mark - unlock_start; 443c8ec8eeaSjose borrego (void) smb_fsop_frlock(node, &new_unlock, 444c8ec8eeaSjose borrego B_TRUE, cr); 445c8ec8eeaSjose borrego unlock_start = new_mark; 446c8ec8eeaSjose borrego } else { 447c8ec8eeaSjose borrego new_unlock = *lock; 448c8ec8eeaSjose borrego new_unlock.l_start = unlock_start; 449c8ec8eeaSjose borrego new_unlock.l_length = unlock_end - unlock_start; 450c8ec8eeaSjose borrego (void) smb_fsop_frlock(node, &new_unlock, 451c8ec8eeaSjose borrego B_TRUE, cr); 452c8ec8eeaSjose borrego break; 453c8ec8eeaSjose borrego } 454c8ec8eeaSjose borrego } else if (new_mark) { 455c8ec8eeaSjose borrego unlock_start = new_mark; 456c8ec8eeaSjose borrego } else { 457c8ec8eeaSjose borrego break; 458c8ec8eeaSjose borrego } 459c8ec8eeaSjose borrego } 460c8ec8eeaSjose borrego } 461c8ec8eeaSjose borrego 462c8ec8eeaSjose borrego /* 463c8ec8eeaSjose borrego * smb_lock_range_overlap 464c8ec8eeaSjose borrego * 465c8ec8eeaSjose borrego * Checks if lock range(start, length) overlaps range in lock structure. 466c8ec8eeaSjose borrego * 467c8ec8eeaSjose borrego * Zero-length byte range locks actually affect no single byte of the stream, 468c8ec8eeaSjose borrego * meaning they can still be accessed even with such locks in place. However, 469c8ec8eeaSjose borrego * they do conflict with other ranges in the following manner: 470c8ec8eeaSjose borrego * conflict will only exist if the positive-length range contains the 471c8ec8eeaSjose borrego * zero-length range's offset but doesn't start at it 472c8ec8eeaSjose borrego * 473c8ec8eeaSjose borrego * return values: 474c8ec8eeaSjose borrego * 0 - Lock range doesn't overlap 475c8ec8eeaSjose borrego * 1 - Lock range overlaps. 476c8ec8eeaSjose borrego */ 477c8ec8eeaSjose borrego 478c8ec8eeaSjose borrego #define RANGE_NO_OVERLAP 0 479c8ec8eeaSjose borrego #define RANGE_OVERLAP 1 480c8ec8eeaSjose borrego 481c8ec8eeaSjose borrego static int 482c8ec8eeaSjose borrego smb_lock_range_overlap(struct smb_lock *lock, uint64_t start, uint64_t length) 483c8ec8eeaSjose borrego { 484c8ec8eeaSjose borrego if (length == 0) { 485c8ec8eeaSjose borrego if ((lock->l_start < start) && 486c8ec8eeaSjose borrego ((lock->l_start + lock->l_length) > start)) 487c8ec8eeaSjose borrego return (RANGE_OVERLAP); 488c8ec8eeaSjose borrego 489c8ec8eeaSjose borrego return (RANGE_NO_OVERLAP); 490c8ec8eeaSjose borrego } 491c8ec8eeaSjose borrego 492c8ec8eeaSjose borrego /* The following test is intended to catch roll over locks. */ 493c8ec8eeaSjose borrego if ((start == lock->l_start) && (length == lock->l_length)) 494c8ec8eeaSjose borrego return (RANGE_OVERLAP); 495c8ec8eeaSjose borrego 496c8ec8eeaSjose borrego if (start < lock->l_start) { 497c8ec8eeaSjose borrego if (start + length > lock->l_start) 498c8ec8eeaSjose borrego return (RANGE_OVERLAP); 499c8ec8eeaSjose borrego } else if (start < lock->l_start + lock->l_length) 500c8ec8eeaSjose borrego return (RANGE_OVERLAP); 501c8ec8eeaSjose borrego 502c8ec8eeaSjose borrego return (RANGE_NO_OVERLAP); 503c8ec8eeaSjose borrego } 504c8ec8eeaSjose borrego 505c8ec8eeaSjose borrego /* 506c8ec8eeaSjose borrego * smb_lock_range_lckrules 507c8ec8eeaSjose borrego * 508c8ec8eeaSjose borrego * Lock range rules: 509c8ec8eeaSjose borrego * 1. Overlapping read locks are allowed if the 510c8ec8eeaSjose borrego * current locks in the region are only read locks 511c8ec8eeaSjose borrego * irrespective of pid of smb client issuing lock request. 512c8ec8eeaSjose borrego * 513c8ec8eeaSjose borrego * 2. Read lock in the overlapped region of write lock 514c8ec8eeaSjose borrego * are allowed if the pervious lock is performed by the 515c8ec8eeaSjose borrego * same pid and connection. 516c8ec8eeaSjose borrego * 517c8ec8eeaSjose borrego * return status: 518c8ec8eeaSjose borrego * NT_STATUS_SUCCESS - Input lock range adapts to lock rules. 519c8ec8eeaSjose borrego * NT_STATUS_LOCK_NOT_GRANTED - Input lock conflicts lock rules. 520c8ec8eeaSjose borrego * NT_STATUS_CANCELLED - Error in processing lock rules 521c8ec8eeaSjose borrego */ 522c8ec8eeaSjose borrego static uint32_t 523c8ec8eeaSjose borrego smb_lock_range_lckrules( 524c8ec8eeaSjose borrego smb_request_t *sr, 525c8ec8eeaSjose borrego smb_ofile_t *file, 526c8ec8eeaSjose borrego smb_node_t *node, 527c8ec8eeaSjose borrego smb_lock_t *dlock, 528c8ec8eeaSjose borrego smb_lock_t **clockp) 529c8ec8eeaSjose borrego { 530c8ec8eeaSjose borrego smb_lock_t *lock; 531c8ec8eeaSjose borrego uint32_t status = NT_STATUS_SUCCESS; 532c8ec8eeaSjose borrego 533c8ec8eeaSjose borrego /* Check if file is closed */ 534c8ec8eeaSjose borrego if (!smb_ofile_is_open(file)) { 535c8ec8eeaSjose borrego return (NT_STATUS_RANGE_NOT_LOCKED); 536c8ec8eeaSjose borrego } 537c8ec8eeaSjose borrego 538c8ec8eeaSjose borrego /* Caller must hold lock for node->n_lock_list */ 539c8ec8eeaSjose borrego for (lock = smb_llist_head(&node->n_lock_list); 540c8ec8eeaSjose borrego lock != NULL; 541c8ec8eeaSjose borrego lock = smb_llist_next(&node->n_lock_list, lock)) { 542c8ec8eeaSjose borrego 543c8ec8eeaSjose borrego if (!smb_lock_range_overlap(lock, dlock->l_start, 544c8ec8eeaSjose borrego dlock->l_length)) 545c8ec8eeaSjose borrego continue; 546c8ec8eeaSjose borrego 547c8ec8eeaSjose borrego /* 548c8ec8eeaSjose borrego * Check to see if lock in the overlapping record 549c8ec8eeaSjose borrego * is only read lock. Current finding is read 550c8ec8eeaSjose borrego * locks can overlapped irrespective of pids. 551c8ec8eeaSjose borrego */ 552c8ec8eeaSjose borrego if ((lock->l_type == SMB_LOCK_TYPE_READONLY) && 553c8ec8eeaSjose borrego (dlock->l_type == SMB_LOCK_TYPE_READONLY)) { 554c8ec8eeaSjose borrego continue; 555c8ec8eeaSjose borrego } 556c8ec8eeaSjose borrego 557c8ec8eeaSjose borrego /* 558c8ec8eeaSjose borrego * When the read lock overlaps write lock, check if 559c8ec8eeaSjose borrego * allowed. 560c8ec8eeaSjose borrego */ 561c8ec8eeaSjose borrego if ((dlock->l_type == SMB_LOCK_TYPE_READONLY) && 562c8ec8eeaSjose borrego !(lock->l_type == SMB_LOCK_TYPE_READONLY)) { 563c8ec8eeaSjose borrego if (lock->l_file == sr->fid_ofile && 564c8ec8eeaSjose borrego lock->l_session_kid == sr->session->s_kid && 565c8ec8eeaSjose borrego lock->l_pid == sr->smb_pid && 566c8ec8eeaSjose borrego lock->l_uid == sr->smb_uid) { 567c8ec8eeaSjose borrego continue; 568c8ec8eeaSjose borrego } 569c8ec8eeaSjose borrego } 570c8ec8eeaSjose borrego 571c8ec8eeaSjose borrego /* Conflict in overlapping lock element */ 572c8ec8eeaSjose borrego *clockp = lock; 573c8ec8eeaSjose borrego status = NT_STATUS_LOCK_NOT_GRANTED; 574c8ec8eeaSjose borrego break; 575c8ec8eeaSjose borrego } 576c8ec8eeaSjose borrego 577c8ec8eeaSjose borrego return (status); 578c8ec8eeaSjose borrego } 579c8ec8eeaSjose borrego 580c8ec8eeaSjose borrego /* 581c8ec8eeaSjose borrego * smb_lock_wait 582c8ec8eeaSjose borrego * 583c8ec8eeaSjose borrego * Wait operation for smb overlapping lock to be released. Caller must hold 584c8ec8eeaSjose borrego * write lock for node->n_lock_list so that the set of active locks can't 585c8ec8eeaSjose borrego * change unexpectedly. The lock for node->n_lock_list will be released 586c8ec8eeaSjose borrego * within this function during the sleep after the lock dependency has 587c8ec8eeaSjose borrego * been recorded. 588c8ec8eeaSjose borrego * 589c8ec8eeaSjose borrego * return value 590c8ec8eeaSjose borrego * 591c8ec8eeaSjose borrego * 0 The request was canceled. 592c8ec8eeaSjose borrego * -1 The timeout was reached. 593c8ec8eeaSjose borrego * >0 Condition met. 594c8ec8eeaSjose borrego */ 595c8ec8eeaSjose borrego static clock_t 596c8ec8eeaSjose borrego smb_lock_wait(smb_request_t *sr, smb_lock_t *b_lock, smb_lock_t *c_lock) 597c8ec8eeaSjose borrego { 598c8ec8eeaSjose borrego clock_t rc; 599c8ec8eeaSjose borrego 600c8ec8eeaSjose borrego ASSERT(sr->sr_awaiting == NULL); 601c8ec8eeaSjose borrego 602c8ec8eeaSjose borrego mutex_enter(&sr->sr_mutex); 603c8ec8eeaSjose borrego 604c8ec8eeaSjose borrego switch (sr->sr_state) { 605c8ec8eeaSjose borrego case SMB_REQ_STATE_ACTIVE: 606c8ec8eeaSjose borrego /* 607c8ec8eeaSjose borrego * Wait up till the timeout time keeping track of actual 608c8ec8eeaSjose borrego * time waited for possible retry failure. 609c8ec8eeaSjose borrego */ 610c8ec8eeaSjose borrego sr->sr_state = SMB_REQ_STATE_WAITING_LOCK; 611c8ec8eeaSjose borrego sr->sr_awaiting = c_lock; 612c8ec8eeaSjose borrego mutex_exit(&sr->sr_mutex); 613c8ec8eeaSjose borrego 614c8ec8eeaSjose borrego mutex_enter(&c_lock->l_mutex); 615c8ec8eeaSjose borrego /* 616c8ec8eeaSjose borrego * The conflict list (l_conflict_list) for a lock contains 617c8ec8eeaSjose borrego * all the locks that are blocked by and in conflict with 618c8ec8eeaSjose borrego * that lock. Add the new lock to the conflict list for the 619c8ec8eeaSjose borrego * active lock. 620c8ec8eeaSjose borrego * 621c8ec8eeaSjose borrego * l_conflict_list is currently a fancy way of representing 622c8ec8eeaSjose borrego * the references/dependencies on a lock. It could be 623c8ec8eeaSjose borrego * replaced with a reference count but this approach 624c8ec8eeaSjose borrego * has the advantage that MDB can display the lock 625c8ec8eeaSjose borrego * dependencies at any point in time. In the future 626c8ec8eeaSjose borrego * we should be able to leverage the list to implement 627c8ec8eeaSjose borrego * an asynchronous locking model. 628c8ec8eeaSjose borrego * 629c8ec8eeaSjose borrego * l_blocked_by is the reverse of the conflict list. It 630c8ec8eeaSjose borrego * points to the lock that the new lock conflicts with. 631c8ec8eeaSjose borrego * As currently implemented this value is purely for 632c8ec8eeaSjose borrego * debug purposes -- there are windows of time when 633c8ec8eeaSjose borrego * l_blocked_by may be non-NULL even though there is no 634c8ec8eeaSjose borrego * conflict list 635c8ec8eeaSjose borrego */ 636c8ec8eeaSjose borrego b_lock->l_blocked_by = c_lock; 637c8ec8eeaSjose borrego smb_slist_insert_tail(&c_lock->l_conflict_list, b_lock); 638c8ec8eeaSjose borrego smb_llist_exit(&c_lock->l_file->f_node->n_lock_list); 639c8ec8eeaSjose borrego 640c8ec8eeaSjose borrego if (SMB_LOCK_INDEFINITE_WAIT(b_lock)) { 641c8ec8eeaSjose borrego cv_wait(&c_lock->l_cv, &c_lock->l_mutex); 642c8ec8eeaSjose borrego } else { 643c8ec8eeaSjose borrego rc = cv_timedwait(&c_lock->l_cv, 644c8ec8eeaSjose borrego &c_lock->l_mutex, b_lock->l_end_time); 645c8ec8eeaSjose borrego } 646c8ec8eeaSjose borrego 647c8ec8eeaSjose borrego mutex_exit(&c_lock->l_mutex); 648c8ec8eeaSjose borrego 649c8ec8eeaSjose borrego smb_llist_enter(&c_lock->l_file->f_node->n_lock_list, 650c8ec8eeaSjose borrego RW_WRITER); 651c8ec8eeaSjose borrego smb_slist_remove(&c_lock->l_conflict_list, b_lock); 652c8ec8eeaSjose borrego 653c8ec8eeaSjose borrego mutex_enter(&sr->sr_mutex); 654c8ec8eeaSjose borrego sr->sr_awaiting = NULL; 655c8ec8eeaSjose borrego if (sr->sr_state == SMB_REQ_STATE_CANCELED) { 656c8ec8eeaSjose borrego rc = 0; 657c8ec8eeaSjose borrego } else { 658c8ec8eeaSjose borrego sr->sr_state = SMB_REQ_STATE_ACTIVE; 659c8ec8eeaSjose borrego } 660c8ec8eeaSjose borrego break; 661c8ec8eeaSjose borrego 662c8ec8eeaSjose borrego default: 663c8ec8eeaSjose borrego ASSERT(sr->sr_state == SMB_REQ_STATE_CANCELED); 664c8ec8eeaSjose borrego rc = 0; 665c8ec8eeaSjose borrego break; 666c8ec8eeaSjose borrego } 667c8ec8eeaSjose borrego mutex_exit(&sr->sr_mutex); 668c8ec8eeaSjose borrego 669c8ec8eeaSjose borrego return (rc); 670c8ec8eeaSjose borrego } 671c8ec8eeaSjose borrego 672c8ec8eeaSjose borrego /* 673c8ec8eeaSjose borrego * smb_lock_range_ulckrules 674c8ec8eeaSjose borrego * 675c8ec8eeaSjose borrego * 1. Unlock should be performed at exactly matching ends. 676c8ec8eeaSjose borrego * This has been changed because overlapping ends is 677c8ec8eeaSjose borrego * allowed and there is no other precise way of locating 678c8ec8eeaSjose borrego * lock entity in node lock list. 679c8ec8eeaSjose borrego * 680c8ec8eeaSjose borrego * 2. Unlock is failed if there is no corresponding lock exists. 681c8ec8eeaSjose borrego * 682c8ec8eeaSjose borrego * Return values 683c8ec8eeaSjose borrego * 684c8ec8eeaSjose borrego * NT_STATUS_SUCCESS Unlock request matches lock record 685c8ec8eeaSjose borrego * pointed by 'nodelock' lock structure. 686c8ec8eeaSjose borrego * 687c8ec8eeaSjose borrego * NT_STATUS_RANGE_NOT_LOCKED Unlock request doen't match any 688c8ec8eeaSjose borrego * of lock record in node lock request or 689c8ec8eeaSjose borrego * error in unlock range processing. 690c8ec8eeaSjose borrego */ 691c8ec8eeaSjose borrego static uint32_t 692c8ec8eeaSjose borrego smb_lock_range_ulckrules( 693c8ec8eeaSjose borrego smb_request_t *sr, 694c8ec8eeaSjose borrego smb_node_t *node, 695c8ec8eeaSjose borrego uint64_t start, 696c8ec8eeaSjose borrego uint64_t length, 697c8ec8eeaSjose borrego smb_lock_t **nodelock) 698c8ec8eeaSjose borrego { 699c8ec8eeaSjose borrego smb_lock_t *lock; 700c8ec8eeaSjose borrego uint32_t status = NT_STATUS_RANGE_NOT_LOCKED; 701c8ec8eeaSjose borrego 702c8ec8eeaSjose borrego /* Caller must hold lock for node->n_lock_list */ 703c8ec8eeaSjose borrego for (lock = smb_llist_head(&node->n_lock_list); 704c8ec8eeaSjose borrego lock != NULL; 705c8ec8eeaSjose borrego lock = smb_llist_next(&node->n_lock_list, lock)) { 706c8ec8eeaSjose borrego 707c8ec8eeaSjose borrego if ((start == lock->l_start) && 708c8ec8eeaSjose borrego (length == lock->l_length) && 709c8ec8eeaSjose borrego lock->l_file == sr->fid_ofile && 710c8ec8eeaSjose borrego lock->l_session_kid == sr->session->s_kid && 711c8ec8eeaSjose borrego lock->l_pid == sr->smb_pid && 712c8ec8eeaSjose borrego lock->l_uid == sr->smb_uid) { 713c8ec8eeaSjose borrego *nodelock = lock; 714c8ec8eeaSjose borrego status = NT_STATUS_SUCCESS; 715c8ec8eeaSjose borrego break; 716c8ec8eeaSjose borrego } 717c8ec8eeaSjose borrego } 718c8ec8eeaSjose borrego 719c8ec8eeaSjose borrego return (status); 720c8ec8eeaSjose borrego } 721c8ec8eeaSjose borrego 722c8ec8eeaSjose borrego static smb_lock_t * 723c8ec8eeaSjose borrego smb_lock_create( 724c8ec8eeaSjose borrego smb_request_t *sr, 725c8ec8eeaSjose borrego uint64_t start, 726c8ec8eeaSjose borrego uint64_t length, 727c8ec8eeaSjose borrego uint32_t locktype, 728c8ec8eeaSjose borrego uint32_t timeout) 729c8ec8eeaSjose borrego { 730c8ec8eeaSjose borrego smb_lock_t *lock; 731c8ec8eeaSjose borrego 732c8ec8eeaSjose borrego ASSERT(locktype == SMB_LOCK_TYPE_READWRITE || 733c8ec8eeaSjose borrego locktype == SMB_LOCK_TYPE_READONLY); 734c8ec8eeaSjose borrego 735c8ec8eeaSjose borrego lock = kmem_zalloc(sizeof (smb_lock_t), KM_SLEEP); 736c8ec8eeaSjose borrego lock->l_magic = SMB_LOCK_MAGIC; 737c8ec8eeaSjose borrego lock->l_sr = sr; /* Invalid after lock is active */ 738c8ec8eeaSjose borrego lock->l_session_kid = sr->session->s_kid; 739c8ec8eeaSjose borrego lock->l_session = sr->session; 740c8ec8eeaSjose borrego lock->l_file = sr->fid_ofile; 741c8ec8eeaSjose borrego lock->l_uid = sr->smb_uid; 742c8ec8eeaSjose borrego lock->l_pid = sr->smb_pid; 743c8ec8eeaSjose borrego lock->l_type = locktype; 744c8ec8eeaSjose borrego lock->l_start = start; 745c8ec8eeaSjose borrego lock->l_length = length; 746c8ec8eeaSjose borrego /* 747c8ec8eeaSjose borrego * Calculate the absolute end time so that we can use it 748c8ec8eeaSjose borrego * in cv_timedwait. 749c8ec8eeaSjose borrego */ 750d3d50737SRafael Vanoni lock->l_end_time = ddi_get_lbolt() + MSEC_TO_TICK(timeout); 751c8ec8eeaSjose borrego if (timeout == UINT_MAX) 752c8ec8eeaSjose borrego lock->l_flags |= SMB_LOCK_FLAG_INDEFINITE; 753c8ec8eeaSjose borrego 754c8ec8eeaSjose borrego mutex_init(&lock->l_mutex, NULL, MUTEX_DEFAULT, NULL); 755c8ec8eeaSjose borrego cv_init(&lock->l_cv, NULL, CV_DEFAULT, NULL); 756c8ec8eeaSjose borrego smb_slist_constructor(&lock->l_conflict_list, sizeof (smb_lock_t), 757c8ec8eeaSjose borrego offsetof(smb_lock_t, l_conflict_lnd)); 758c8ec8eeaSjose borrego 759c8ec8eeaSjose borrego return (lock); 760c8ec8eeaSjose borrego } 761c8ec8eeaSjose borrego 762c8ec8eeaSjose borrego static void 763c8ec8eeaSjose borrego smb_lock_free(smb_lock_t *lock) 764c8ec8eeaSjose borrego { 765c8ec8eeaSjose borrego smb_slist_destructor(&lock->l_conflict_list); 766c8ec8eeaSjose borrego cv_destroy(&lock->l_cv); 767c8ec8eeaSjose borrego mutex_destroy(&lock->l_mutex); 768c8ec8eeaSjose borrego 769c8ec8eeaSjose borrego kmem_free(lock, sizeof (smb_lock_t)); 770c8ec8eeaSjose borrego } 771c8ec8eeaSjose borrego 772c8ec8eeaSjose borrego /* 773c8ec8eeaSjose borrego * smb_lock_destroy 774c8ec8eeaSjose borrego * 775c8ec8eeaSjose borrego * Caller must hold node->n_lock_list 776c8ec8eeaSjose borrego */ 777c8ec8eeaSjose borrego static void 778c8ec8eeaSjose borrego smb_lock_destroy(smb_lock_t *lock) 779c8ec8eeaSjose borrego { 780c8ec8eeaSjose borrego /* 781c8ec8eeaSjose borrego * Caller must hold node->n_lock_list lock. 782c8ec8eeaSjose borrego */ 783c8ec8eeaSjose borrego mutex_enter(&lock->l_mutex); 784c8ec8eeaSjose borrego cv_broadcast(&lock->l_cv); 785c8ec8eeaSjose borrego mutex_exit(&lock->l_mutex); 786c8ec8eeaSjose borrego 787c8ec8eeaSjose borrego /* 788c8ec8eeaSjose borrego * The cv_broadcast above should wake up any locks that previous 789c8ec8eeaSjose borrego * had conflicts with this lock. Wait for the locking threads 790c8ec8eeaSjose borrego * to remove their references to this lock. 791c8ec8eeaSjose borrego */ 792c8ec8eeaSjose borrego smb_slist_wait_for_empty(&lock->l_conflict_list); 793c8ec8eeaSjose borrego 794c8ec8eeaSjose borrego smb_lock_free(lock); 795c8ec8eeaSjose borrego } 796c8ec8eeaSjose borrego 797c8ec8eeaSjose borrego /* 798c8ec8eeaSjose borrego * smb_is_range_unlocked 799c8ec8eeaSjose borrego * 800c8ec8eeaSjose borrego * Checks if the current unlock byte range request overlaps another lock 801c8ec8eeaSjose borrego * This function is used to determine where POSIX unlocks should be 802c8ec8eeaSjose borrego * applied. 803c8ec8eeaSjose borrego * 804c8ec8eeaSjose borrego * The return code and the value of new_mark must be interpreted as 805c8ec8eeaSjose borrego * follows: 806c8ec8eeaSjose borrego * 807c8ec8eeaSjose borrego * B_TRUE and (new_mark == 0): 808c8ec8eeaSjose borrego * This is the last or only lock left to be unlocked 809c8ec8eeaSjose borrego * 810c8ec8eeaSjose borrego * B_TRUE and (new_mark > 0): 811c8ec8eeaSjose borrego * The range from start to new_mark can be unlocked 812c8ec8eeaSjose borrego * 813c8ec8eeaSjose borrego * B_FALSE and (new_mark == 0): 814c8ec8eeaSjose borrego * The unlock can't be performed and we are done 815c8ec8eeaSjose borrego * 816c8ec8eeaSjose borrego * B_FALSE and (new_mark > 0), 817c8ec8eeaSjose borrego * The range from start to new_mark can't be unlocked 818c8ec8eeaSjose borrego * Start should be reset to new_mark for the next pass 819c8ec8eeaSjose borrego */ 820c8ec8eeaSjose borrego 821c8ec8eeaSjose borrego static boolean_t 822c8ec8eeaSjose borrego smb_is_range_unlocked(uint64_t start, uint64_t end, uint32_t uniqid, 823c8ec8eeaSjose borrego smb_llist_t *llist_head, uint64_t *new_mark) 824c8ec8eeaSjose borrego { 825c8ec8eeaSjose borrego struct smb_lock *lk = NULL; 826c8ec8eeaSjose borrego uint64_t low_water_mark = MAXOFFSET_T; 827c8ec8eeaSjose borrego uint64_t lk_start; 828c8ec8eeaSjose borrego uint64_t lk_end; 829c8ec8eeaSjose borrego 830c8ec8eeaSjose borrego *new_mark = 0; 831c8ec8eeaSjose borrego lk = smb_llist_head(llist_head); 832c8ec8eeaSjose borrego while (lk) { 833c8ec8eeaSjose borrego if (lk->l_length == 0) { 834c8ec8eeaSjose borrego lk = smb_llist_next(llist_head, lk); 835c8ec8eeaSjose borrego continue; 836c8ec8eeaSjose borrego } 837c8ec8eeaSjose borrego 838c8ec8eeaSjose borrego if (lk->l_file->f_uniqid != uniqid) { 839c8ec8eeaSjose borrego lk = smb_llist_next(llist_head, lk); 840c8ec8eeaSjose borrego continue; 841c8ec8eeaSjose borrego } 842c8ec8eeaSjose borrego 843c8ec8eeaSjose borrego lk_end = lk->l_start + lk->l_length - 1; 844c8ec8eeaSjose borrego lk_start = lk->l_start; 845c8ec8eeaSjose borrego 846c8ec8eeaSjose borrego /* 847c8ec8eeaSjose borrego * there is no overlap for the first 2 cases 848c8ec8eeaSjose borrego * check next node 849c8ec8eeaSjose borrego */ 850c8ec8eeaSjose borrego if (lk_end < start) { 851c8ec8eeaSjose borrego lk = smb_llist_next(llist_head, lk); 852c8ec8eeaSjose borrego continue; 853c8ec8eeaSjose borrego } 854c8ec8eeaSjose borrego if (lk_start > end) { 855c8ec8eeaSjose borrego lk = smb_llist_next(llist_head, lk); 856c8ec8eeaSjose borrego continue; 857c8ec8eeaSjose borrego } 858c8ec8eeaSjose borrego 859c8ec8eeaSjose borrego /* this range is completely locked */ 860c8ec8eeaSjose borrego if ((lk_start <= start) && (lk_end >= end)) { 861c8ec8eeaSjose borrego return (B_FALSE); 862c8ec8eeaSjose borrego } 863c8ec8eeaSjose borrego 864c8ec8eeaSjose borrego /* the first part of this range is locked */ 865c8ec8eeaSjose borrego if ((start >= lk_start) && (start <= lk_end)) { 866c8ec8eeaSjose borrego if (end > lk_end) 867c8ec8eeaSjose borrego *new_mark = lk_end + 1; 868c8ec8eeaSjose borrego return (B_FALSE); 869c8ec8eeaSjose borrego } 870c8ec8eeaSjose borrego 871c8ec8eeaSjose borrego /* this piece is unlocked */ 872c8ec8eeaSjose borrego if ((lk_start >= start) && (lk_start <= end)) { 873c8ec8eeaSjose borrego if (low_water_mark > lk_start) 874c8ec8eeaSjose borrego low_water_mark = lk_start; 875c8ec8eeaSjose borrego } 876c8ec8eeaSjose borrego 877c8ec8eeaSjose borrego lk = smb_llist_next(llist_head, lk); 878c8ec8eeaSjose borrego } 879c8ec8eeaSjose borrego 880c8ec8eeaSjose borrego if (low_water_mark != MAXOFFSET_T) { 881c8ec8eeaSjose borrego *new_mark = low_water_mark; 882c8ec8eeaSjose borrego return (B_TRUE); 883c8ec8eeaSjose borrego } 884c8ec8eeaSjose borrego /* the range is completely unlocked */ 885c8ec8eeaSjose borrego return (B_TRUE); 886c8ec8eeaSjose borrego } 887