2 Unix SMB/CIFS implementation.
4 POSIX NTVFS backend - locking
6 Copyright (C) Andrew Tridgell 2004
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "vfs_posix.h"
24 #include "system/time.h"
25 #include "lib/util/dlinklist.h"
26 #include "messaging/messaging.h"
30 check if we can perform IO on a range that might be locked
32 NTSTATUS pvfs_check_lock(struct pvfs_state *pvfs,
35 uint64_t offset, uint64_t count,
38 if (!(pvfs->flags & PVFS_FLAG_STRICT_LOCKING)) {
42 return brl_locktest(pvfs->brl_context,
48 /* this state structure holds information about a lock we are waiting on */
49 struct pvfs_pending_lock {
50 struct pvfs_pending_lock *next, *prev;
51 struct pvfs_state *pvfs;
54 struct ntvfs_request *req;
56 struct pvfs_wait *wait_handle;
57 struct timeval end_time;
61 a secondary attempt to setup a lock has failed - back out
62 the locks we did get and send an error
64 static void pvfs_lock_async_failed(struct pvfs_state *pvfs,
65 struct ntvfs_request *req,
67 struct smb_lock_entry *locks,
71 /* undo the locks we just did */
73 brl_unlock(pvfs->brl_context,
80 req->async_states->status = status;
81 req->async_states->send_fn(req);
86 called when we receive a pending lock notification. It means that
87 either our lock timed out or someone else has unlocked a overlapping
88 range, so we should try the lock again. Note that on timeout we
89 do retry the lock, giving it a last chance.
91 static void pvfs_pending_lock_continue(void *private, enum pvfs_wait_notice reason)
93 struct pvfs_pending_lock *pending = private;
94 struct pvfs_state *pvfs = pending->pvfs;
95 struct pvfs_file *f = pending->f;
96 struct ntvfs_request *req = pending->req;
97 union smb_lock *lck = pending->lck;
98 struct smb_lock_entry *locks;
104 timed_out = (reason != PVFS_WAIT_EVENT);
106 locks = lck->lockx.in.locks + lck->lockx.in.ulock_cnt;
108 if (lck->lockx.in.mode & LOCKING_ANDX_SHARED_LOCK) {
114 DLIST_REMOVE(f->pending_list, pending);
116 /* we don't retry on a cancel */
117 if (reason == PVFS_WAIT_CANCEL) {
118 status = NT_STATUS_FILE_LOCK_CONFLICT;
121 * here it's important to pass the pending pointer
122 * because with this we'll get the correct error code
123 * FILE_LOCK_CONFLICT in the error case
125 status = brl_lock(pvfs->brl_context,
127 locks[pending->pending_lock].pid,
128 locks[pending->pending_lock].offset,
129 locks[pending->pending_lock].count,
132 if (NT_STATUS_IS_OK(status)) {
137 /* if we have failed and timed out, or succeeded, then we
138 don't need the pending lock any more */
139 if (NT_STATUS_IS_OK(status) || timed_out) {
141 status2 = brl_remove_pending(pvfs->brl_context,
142 f->brl_handle, pending);
143 if (!NT_STATUS_IS_OK(status2)) {
144 DEBUG(0,("pvfs_lock: failed to remove pending lock - %s\n", nt_errstr(status2)));
146 talloc_free(pending->wait_handle);
149 if (!NT_STATUS_IS_OK(status)) {
151 /* no more chances */
152 pvfs_lock_async_failed(pvfs, req, f, locks, pending->pending_lock, status);
153 talloc_free(pending);
155 /* we can try again */
156 DLIST_ADD(f->pending_list, pending);
161 /* if we haven't timed out yet, then we can do more pending locks */
162 if (rw == READ_LOCK) {
163 rw = PENDING_READ_LOCK;
165 rw = PENDING_WRITE_LOCK;
168 /* we've now got the pending lock. try and get the rest, which might
169 lead to more pending locks */
170 for (i=pending->pending_lock+1;i<lck->lockx.in.lock_cnt;i++) {
172 pending->pending_lock = i;
175 status = brl_lock(pvfs->brl_context,
181 if (!NT_STATUS_IS_OK(status)) {
183 /* a timed lock failed - setup a wait message to handle
184 the pending lock notification or a timeout */
185 pending->wait_handle = pvfs_wait_message(pvfs, req, MSG_BRL_RETRY,
187 pvfs_pending_lock_continue,
189 if (pending->wait_handle == NULL) {
190 pvfs_lock_async_failed(pvfs, req, f, locks, i, NT_STATUS_NO_MEMORY);
191 talloc_free(pending);
193 talloc_steal(pending, pending->wait_handle);
194 DLIST_ADD(f->pending_list, pending);
198 pvfs_lock_async_failed(pvfs, req, f, locks, i, status);
199 talloc_free(pending);
206 /* we've managed to get all the locks. Tell the client */
207 req->async_states->status = NT_STATUS_OK;
208 req->async_states->send_fn(req);
209 talloc_free(pending);
214 called when we close a file that might have locks
216 void pvfs_lock_close(struct pvfs_state *pvfs, struct pvfs_file *f)
218 struct pvfs_pending_lock *p, *next;
220 if (f->lock_count || f->pending_list) {
221 DEBUG(5,("pvfs_lock: removing %.0f locks on close\n",
222 (double)f->lock_count));
223 brl_close(f->pvfs->brl_context, f->brl_handle);
227 /* reply to all the pending lock requests, telling them the
229 for (p=f->pending_list;p;p=next) {
231 DLIST_REMOVE(f->pending_list, p);
232 p->req->async_states->status = NT_STATUS_RANGE_NOT_LOCKED;
233 p->req->async_states->send_fn(p->req);
239 cancel a set of locks
241 static NTSTATUS pvfs_lock_cancel(struct pvfs_state *pvfs, struct ntvfs_request *req, union smb_lock *lck,
244 struct pvfs_pending_lock *p;
246 for (p=f->pending_list;p;p=p->next) {
247 /* check if the lock request matches exactly - you can only cancel with exact matches */
248 if (p->lck->lockx.in.ulock_cnt == lck->lockx.in.ulock_cnt &&
249 p->lck->lockx.in.lock_cnt == lck->lockx.in.lock_cnt &&
250 p->lck->lockx.in.file.ntvfs== lck->lockx.in.file.ntvfs &&
251 p->lck->lockx.in.mode == (lck->lockx.in.mode & ~LOCKING_ANDX_CANCEL_LOCK)) {
254 for (i=0;i<lck->lockx.in.ulock_cnt + lck->lockx.in.lock_cnt;i++) {
255 if (p->lck->lockx.in.locks[i].pid != lck->lockx.in.locks[i].pid ||
256 p->lck->lockx.in.locks[i].offset != lck->lockx.in.locks[i].offset ||
257 p->lck->lockx.in.locks[i].count != lck->lockx.in.locks[i].count) {
261 if (i < lck->lockx.in.ulock_cnt) continue;
263 /* an exact match! we can cancel it, which is equivalent
264 to triggering the timeout early */
265 pvfs_pending_lock_continue(p, PVFS_WAIT_TIMEOUT);
270 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
275 lock or unlock a byte range
277 NTSTATUS pvfs_lock(struct ntvfs_module_context *ntvfs,
278 struct ntvfs_request *req, union smb_lock *lck)
280 struct pvfs_state *pvfs = ntvfs->private_data;
282 struct smb_lock_entry *locks;
285 struct pvfs_pending_lock *pending = NULL;
288 if (lck->generic.level != RAW_LOCK_GENERIC) {
289 return ntvfs_map_lock(ntvfs, req, lck);
292 if (lck->lockx.in.mode & LOCKING_ANDX_OPLOCK_RELEASE) {
293 return pvfs_oplock_release(ntvfs, req, lck);
296 f = pvfs_find_fd(pvfs, req, lck->lockx.in.file.ntvfs);
298 return NT_STATUS_INVALID_HANDLE;
301 if (f->handle->fd == -1) {
302 return NT_STATUS_FILE_IS_A_DIRECTORY;
305 status = pvfs_break_level2_oplocks(f);
306 NT_STATUS_NOT_OK_RETURN(status);
308 if (lck->lockx.in.timeout != 0 &&
309 (req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
310 pending = talloc(f, struct pvfs_pending_lock);
311 if (pending == NULL) {
312 return NT_STATUS_NO_MEMORY;
315 pending->pvfs = pvfs;
321 timeval_current_ofs(lck->lockx.in.timeout/1000,
322 1000*(lck->lockx.in.timeout%1000));
325 if (lck->lockx.in.mode & LOCKING_ANDX_SHARED_LOCK) {
326 rw = pending? PENDING_READ_LOCK : READ_LOCK;
328 rw = pending? PENDING_WRITE_LOCK : WRITE_LOCK;
331 if (lck->lockx.in.mode & LOCKING_ANDX_CANCEL_LOCK) {
332 talloc_free(pending);
333 return pvfs_lock_cancel(pvfs, req, lck, f);
336 if (lck->lockx.in.mode & LOCKING_ANDX_CHANGE_LOCKTYPE) {
337 /* this seems to not be supported by any windows server,
338 or used by any clients */
339 talloc_free(pending);
340 return NT_STATUS_DOS(ERRDOS, ERRnoatomiclocks);
343 /* the unlocks happen first */
344 locks = lck->lockx.in.locks;
346 for (i=0;i<lck->lockx.in.ulock_cnt;i++) {
347 status = brl_unlock(pvfs->brl_context,
352 if (!NT_STATUS_IS_OK(status)) {
353 talloc_free(pending);
361 for (i=0;i<lck->lockx.in.lock_cnt;i++) {
363 pending->pending_lock = i;
366 status = brl_lock(pvfs->brl_context,
372 if (!NT_STATUS_IS_OK(status)) {
374 /* a timed lock failed - setup a wait message to handle
375 the pending lock notification or a timeout */
376 pending->wait_handle = pvfs_wait_message(pvfs, req, MSG_BRL_RETRY,
378 pvfs_pending_lock_continue,
380 if (pending->wait_handle == NULL) {
381 talloc_free(pending);
382 return NT_STATUS_NO_MEMORY;
384 talloc_steal(pending, pending->wait_handle);
385 DLIST_ADD(f->pending_list, pending);
389 /* undo the locks we just did */
391 brl_unlock(pvfs->brl_context,
398 talloc_free(pending);
404 talloc_free(pending);