2 * Unix SMB/CIFS implementation.
3 * Support for OneFS system interfaces.
5 * Copyright (C) Zack Kirsch, 2009
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 3 of the License, or
10 * (at your option) any later version.
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.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
23 #include <ifs/ifs_syscalls.h>
24 #include <sys/isi_cifs_brl.h>
25 #include <isi_ecs/isi_ecs_cbrl.h>
28 #define DBGC_CLASS DBGC_LOCKING
30 extern struct blocking_lock_record
*blocking_lock_queue
;
32 static uint64_t onefs_get_new_id(void) {
33 static uint64_t id
= 0;
40 enum onefs_cbrl_lock_state
{ONEFS_CBRL_NONE
, ONEFS_CBRL_ASYNC
, ONEFS_CBRL_DONE
,
43 struct onefs_cbrl_blr_state
{
45 enum onefs_cbrl_lock_state state
;
48 static char *onefs_cbrl_blr_state_str(const struct blocking_lock_record
*blr
)
50 static fstring result
;
51 struct onefs_cbrl_blr_state
*bs
;
55 bs
= (struct onefs_cbrl_blr_state
*)blr
->blr_private
;
58 fstrcpy(result
, "NULL CBRL BLR state - Posix lock?");
64 fstr_sprintf(result
, "CBRL BLR id=%llu: state=NONE", bs
->id
);
66 case ONEFS_CBRL_ASYNC
:
67 fstr_sprintf(result
, "CBRL BLR id=%llu: state=ASYNC", bs
->id
);
70 fstr_sprintf(result
, "CBRL BLR id=%llu: state=DONE", bs
->id
);
72 case ONEFS_CBRL_ERROR
:
73 fstr_sprintf(result
, "CBRL BLR id=%llu: state=ERROR", bs
->id
);
76 fstr_sprintf(result
, "CBRL BLR id=%llu: unknown state %d",
84 static void onefs_cbrl_enumerate_blq(const char *fn
)
86 struct blocking_lock_record
*blr
;
91 DEBUG(10, ("CBRL BLR records (%s):\n", fn
));
93 for (blr
= blocking_lock_queue
; blr
; blr
= blr
->next
)
94 DEBUGADD(10, ("%s\n", onefs_cbrl_blr_state_str(blr
)));
97 static struct blocking_lock_record
*onefs_cbrl_find_blr(uint64_t id
)
99 struct blocking_lock_record
*blr
;
100 struct onefs_cbrl_blr_state
*bs
;
102 onefs_cbrl_enumerate_blq("onefs_cbrl_find_blr");
104 for (blr
= blocking_lock_queue
; blr
; blr
= blr
->next
) {
105 bs
= (struct onefs_cbrl_blr_state
*)blr
->blr_private
;
107 /* We don't control all of the BLRs on the BLQ. */
112 DEBUG(10, ("found %s\n",
113 onefs_cbrl_blr_state_str(blr
)));
119 DEBUG(5, ("Could not find CBRL BLR for id %llu\n", id
));
126 static void onefs_cbrl_async_success(uint64_t id
)
128 struct blocking_lock_record
*blr
;
129 struct onefs_cbrl_blr_state
*bs
;
132 DEBUG(10, ("CBRL async success!\n"));
134 /* Find BLR with id. Its okay not to find one (race with cancel) */
135 blr
= onefs_cbrl_find_blr(id
);
139 bs
= (struct onefs_cbrl_blr_state
*)blr
->blr_private
;
141 SMB_ASSERT(bs
->state
== ONEFS_CBRL_ASYNC
);
145 num_locks
= SVAL(blr
->req
->vwv
+7, 0);
147 if (blr
->lock_num
== num_locks
)
148 bs
->state
= ONEFS_CBRL_DONE
;
150 bs
->state
= ONEFS_CBRL_NONE
;
152 /* Process the queue, to try the next lock or finish up. */
153 process_blocking_lock_queue();
156 static void onefs_cbrl_async_failure(uint64_t id
)
158 struct blocking_lock_record
*blr
;
159 struct onefs_cbrl_blr_state
*bs
;
161 DEBUG(10, ("CBRL async failure!\n"));
163 /* Find BLR with id. Its okay not to find one (race with cancel) */
164 blr
= onefs_cbrl_find_blr(id
);
168 bs
= (struct onefs_cbrl_blr_state
*)blr
->blr_private
;
171 SMB_ASSERT(bs
->state
== ONEFS_CBRL_ASYNC
);
172 bs
->state
= ONEFS_CBRL_ERROR
;
174 /* Process the queue. It will end up trying to retake the same lock,
175 * see the error in onefs_cbrl_lock_windows() and fail. */
176 process_blocking_lock_queue();
179 static struct cbrl_event_ops cbrl_ops
=
180 {.cbrl_async_success
= onefs_cbrl_async_success
,
181 .cbrl_async_failure
= onefs_cbrl_async_failure
};
183 static void onefs_cbrl_events_handler(struct event_context
*ev
,
184 struct fd_event
*fde
,
188 DEBUG(10, ("onefs_cbrl_events_handler\n"));
190 if (cbrl_event_dispatcher(&cbrl_ops
)) {
191 DEBUG(0, ("cbrl_event_dispatcher failed: %s\n",
196 static void onefs_init_cbrl(void)
198 static bool init_done
= false;
199 static int cbrl_event_fd
;
200 static struct fd_event
*cbrl_fde
;
205 DEBUG(10, ("onefs_init_cbrl\n"));
207 /* Register the event channel for CBRL. */
208 cbrl_event_fd
= cbrl_event_register();
209 if (cbrl_event_fd
== -1) {
210 DEBUG(0, ("cbrl_event_register failed: %s\n",
215 DEBUG(10, ("cbrl_event_fd = %d\n", cbrl_event_fd
));
217 /* Register the oplock event_fd with samba's event system */
218 cbrl_fde
= event_add_fd(smbd_event_context(),
222 onefs_cbrl_events_handler
,
230 * Blocking PID. As far as I can tell, the blocking_pid is only used to tell
231 * whether a posix lock or a CIFS lock blocked us. If it was a posix lock,
232 * Samba polls every 10 seconds, which we don't want. -zkirsch
234 #define ONEFS_BLOCKING_PID 0xABCDABCD
237 * @param[in] br_lck Contains the fsp.
238 * @param[in] plock Lock request.
239 * @param[in] blocking_lock Only used for figuring out the error.
240 * @param[in,out] blr The BLR for the already-deferred operation.
242 NTSTATUS
onefs_brl_lock_windows(vfs_handle_struct
*handle
,
243 struct byte_range_lock
*br_lck
,
244 struct lock_struct
*plock
,
246 struct blocking_lock_record
*blr
)
248 int fd
= br_lck
->fsp
->fh
->fd
;
250 bool exclusive
= false;
252 bool pending
= false;
253 bool pending_async
= false;
255 struct onefs_cbrl_blr_state
*bs
;
258 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
259 SMB_ASSERT(plock
->lock_type
!= UNLOCK_LOCK
);
261 onefs_cbrl_enumerate_blq("onefs_brl_lock_windows");
263 /* Will only initialize the first time its called. */
266 switch (plock
->lock_type
) {
272 case PENDING_WRITE_LOCK
:
273 /* Called when a blocking lock request is added - do an
279 case PENDING_READ_LOCK
:
280 /* Called when a blocking lock request is added - do an
286 /* UNLOCK_LOCK: should only be used for a POSIX_LOCK */
287 smb_panic("Invalid plock->lock_type passed in to "
288 "onefs_brl_lock_windows");
291 /* Figure out if we're actually doing the lock or a no-op. We need to
292 * do a no-op when process_blocking_lock_queue calls back into us.
294 * We know process_* is calling into us if a blr is passed in and
295 * pending is false. */
296 if (!pending
&& blr
) {
297 /* Check the BLR state. */
298 bs
= (struct onefs_cbrl_blr_state
*)blr
->blr_private
;
301 /* ASYNC still in progress: The process_* calls will keep
302 * calling even if we haven't gotten the lock. Keep erroring
303 * without calling ifs_cbrl, or getting/setting an id. */
304 if (bs
->state
== ONEFS_CBRL_ASYNC
)
306 else if (bs
->state
== ONEFS_CBRL_ERROR
)
307 return NT_STATUS_NO_MEMORY
;
309 SMB_ASSERT(bs
->state
== ONEFS_CBRL_NONE
);
314 SMB_ASSERT(blocking_lock
);
316 id
= onefs_get_new_id();
319 DEBUG(10, ("Calling ifs_cbrl(LOCK)..."));
320 error
= ifs_cbrl(fd
, CBRL_OP_LOCK
, exclusive
, plock
->start
,
321 plock
->size
, async
, id
, plock
->context
.smbpid
, plock
->context
.tid
);
324 } else if (errno
== EWOULDBLOCK
) {
326 } else if (errno
== EINPROGRESS
) {
330 /* Talloc a new BLR private state. */
331 blr
->blr_private
= talloc(blr
, struct onefs_cbrl_blr_state
);
332 pending_async
= true;
335 /* Store the new id in the BLR private state. */
336 bs
= (struct onefs_cbrl_blr_state
*)blr
->blr_private
;
338 bs
->state
= ONEFS_CBRL_ASYNC
;
340 DEBUG(0, ("onefs_brl_lock_windows failure: error=%d (%s).\n",
341 errno
, strerror(errno
)));
345 /* Failure - error or async. */
346 plock
->context
.smbpid
= (uint32
) ONEFS_BLOCKING_PID
;
349 status
= NT_STATUS_OK
;
351 status
= brl_lock_failed(br_lck
->fsp
, plock
, blocking_lock
);
353 DEBUG(10, ("returning %s.\n", nt_errstr(status
)));
358 onefs_cbrl_enumerate_blq("onefs_brl_unlock_windows");
359 DEBUG(10, ("returning NT_STATUS_OK.\n"));
363 #define CBRL_NOTYPE true
365 bool onefs_brl_unlock_windows(vfs_handle_struct
*handle
,
366 struct messaging_context
*msg_ctx
,
367 struct byte_range_lock
*br_lck
,
368 const struct lock_struct
*plock
)
371 int fd
= br_lck
->fsp
->fh
->fd
;
373 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
374 SMB_ASSERT(plock
->lock_type
== UNLOCK_LOCK
);
376 DEBUG(10, ("Calling ifs_cbrl(UNLOCK)..."));
377 error
= ifs_cbrl(fd
, CBRL_OP_UNLOCK
, CBRL_NOTYPE
,
378 plock
->start
, plock
->size
, CBRL_NOTYPE
, 0, plock
->context
.smbpid
,
381 DEBUG(10, ("returning false.\n"));
385 DEBUG(10, ("returning true.\n"));
388 /* Problem with storing things in TDB: I won't know what BRL to unlock in the TDB.
390 * - I could send Samba a message with which lock is being unlocked?
391 * - I could *easily* make the "id" something you always pass in to
392 * lock, unlock or cancel -- it identifies a lock. Makes sense!
396 /* Default implementation only calls this on PENDING locks. */
397 bool onefs_brl_cancel_windows(vfs_handle_struct
*handle
,
398 struct byte_range_lock
*br_lck
,
399 struct lock_struct
*plock
,
400 struct blocking_lock_record
*blr
)
403 int fd
= br_lck
->fsp
->fh
->fd
;
404 struct onefs_cbrl_blr_state
*bs
;
407 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
410 onefs_cbrl_enumerate_blq("onefs_brl_cancel_windows");
412 bs
= ((struct onefs_cbrl_blr_state
*)blr
->blr_private
);
415 if (bs
->state
== ONEFS_CBRL_DONE
) {
417 DEBUG(10, ("State=DONE, returning true\n"));
421 SMB_ASSERT(bs
->state
== ONEFS_CBRL_NONE
||
422 bs
->state
== ONEFS_CBRL_ASYNC
);
425 DEBUG(10, ("Calling ifs_cbrl(CANCEL)..."));
426 error
= ifs_cbrl(fd
, CBRL_OP_CANCEL
, CBRL_NOTYPE
, plock
->start
,
427 plock
->size
, CBRL_NOTYPE
, bs
->id
, plock
->context
.smbpid
,
430 DEBUG(10, ("returning false\n"));
431 bs
->state
= ONEFS_CBRL_ERROR
;
435 bs
->state
= ONEFS_CBRL_DONE
;
436 onefs_cbrl_enumerate_blq("onefs_brl_cancel_windows");
437 DEBUG(10, ("returning true\n"));
441 /* TODO Optimization: Abstract out brl_get_locks() in the Windows case.
442 * We'll malloc some memory or whatever (can't return NULL), but not actually
445 /* XXX brl_locktest: CBRL does not support calling this, but its only for
446 * strict locking. Add empty VOP? */
448 /* XXX brl_lockquery: CBRL does not support calling this for WINDOWS LOCKS, but
449 * its only called for POSIX LOCKS. Add empty VOP? */
451 /* XXX brl_close_fnum: CBRL will do this automatically. I think this is a NO-OP
452 * for us, we could add an empty VOP. */