4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.gnu.org/licenses/gpl-2.0.html
23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2011, 2014, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Sun Microsystems, Inc.
34 * Author: Nikita Danilov <nikita.danilov@sun.com>
35 * Author: Jinshan Xiong <jinshan.xiong@intel.com>
38 #define DEBUG_SUBSYSTEM S_CLASS
40 #include <linux/list.h>
41 #include <libcfs/libcfs.h>
42 #include <obd_class.h>
43 #include <obd_support.h>
44 #include <lustre_fid.h>
45 #include <cl_object.h>
46 #include "cl_internal.h"
48 static void cl_lock_trace0(int level, const struct lu_env *env,
49 const char *prefix, const struct cl_lock *lock,
50 const char *func, const int line)
52 struct cl_object_header *h = cl_object_header(lock->cll_descr.cld_obj);
53 CDEBUG(level, "%s: %p (%p/%d) at %s():%d\n",
54 prefix, lock, env, h->coh_nesting, func, line);
56 #define cl_lock_trace(level, env, prefix, lock) \
57 cl_lock_trace0(level, env, prefix, lock, __FUNCTION__, __LINE__)
60 * Adds lock slice to the compound lock.
62 * This is called by cl_object_operations::coo_lock_init() methods to add a
63 * per-layer state to the lock. New state is added at the end of
64 * cl_lock::cll_layers list, that is, it is at the bottom of the stack.
66 * \see cl_req_slice_add(), cl_page_slice_add(), cl_io_slice_add()
68 void cl_lock_slice_add(struct cl_lock *lock, struct cl_lock_slice *slice,
69 struct cl_object *obj,
70 const struct cl_lock_operations *ops)
73 slice->cls_lock = lock;
74 list_add_tail(&slice->cls_linkage, &lock->cll_layers);
79 EXPORT_SYMBOL(cl_lock_slice_add);
81 void cl_lock_fini(const struct lu_env *env, struct cl_lock *lock)
85 cl_lock_trace(D_DLMTRACE, env, "destroy lock", lock);
87 while (!list_empty(&lock->cll_layers)) {
88 struct cl_lock_slice *slice;
90 slice = list_entry(lock->cll_layers.next,
91 struct cl_lock_slice, cls_linkage);
92 list_del_init(lock->cll_layers.next);
93 slice->cls_ops->clo_fini(env, slice);
95 POISON(lock, 0x5a, sizeof(*lock));
98 EXPORT_SYMBOL(cl_lock_fini);
100 int cl_lock_init(const struct lu_env *env, struct cl_lock *lock,
101 const struct cl_io *io)
103 struct cl_object *obj = lock->cll_descr.cld_obj;
104 struct cl_object *scan;
108 /* Make sure cl_lock::cll_descr is initialized. */
109 LASSERT(obj != NULL);
111 INIT_LIST_HEAD(&lock->cll_layers);
112 cl_object_for_each(scan, obj) {
113 if (scan->co_ops->coo_lock_init != NULL)
114 result = scan->co_ops->coo_lock_init(env, scan, lock,
118 cl_lock_fini(env, lock);
124 EXPORT_SYMBOL(cl_lock_init);
127 * Returns a slice with a lock, corresponding to the given layer in the
132 const struct cl_lock_slice *cl_lock_at(const struct cl_lock *lock,
133 const struct lu_device_type *dtype)
135 const struct cl_lock_slice *slice;
139 list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
140 if (slice->cls_obj->co_lu.lo_dev->ld_type == dtype)
145 EXPORT_SYMBOL(cl_lock_at);
147 void cl_lock_cancel(const struct lu_env *env, struct cl_lock *lock)
149 const struct cl_lock_slice *slice;
152 cl_lock_trace(D_DLMTRACE, env, "cancel lock", lock);
153 list_for_each_entry_reverse(slice, &lock->cll_layers, cls_linkage) {
154 if (slice->cls_ops->clo_cancel != NULL)
155 slice->cls_ops->clo_cancel(env, slice);
160 EXPORT_SYMBOL(cl_lock_cancel);
164 * \param anchor: if we need to wait for resources before getting the lock,
165 * use @anchor for the purpose.
166 * \retval 0 enqueue successfully
167 * \retval <0 error code
169 int cl_lock_enqueue(const struct lu_env *env, struct cl_io *io,
170 struct cl_lock *lock, struct cl_sync_io *anchor)
172 const struct cl_lock_slice *slice;
177 list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
178 if (slice->cls_ops->clo_enqueue == NULL)
181 rc = slice->cls_ops->clo_enqueue(env, slice, io, anchor);
187 EXPORT_SYMBOL(cl_lock_enqueue);
190 * Main high-level entry point of cl_lock interface that finds existing or
191 * enqueues new lock matching given description.
193 int cl_lock_request(const struct lu_env *env, struct cl_io *io,
194 struct cl_lock *lock)
196 struct cl_sync_io *anchor = NULL;
197 __u32 enq_flags = lock->cll_descr.cld_enq_flags;
201 rc = cl_lock_init(env, lock, io);
205 if ((enq_flags & CEF_GLIMPSE) && !(enq_flags & CEF_SPECULATIVE)) {
206 anchor = &cl_env_info(env)->clt_anchor;
207 cl_sync_io_init(anchor, 1);
210 rc = cl_lock_enqueue(env, io, lock, anchor);
212 if (anchor != NULL) {
215 /* drop the reference count held at initialization time */
216 cl_sync_io_note(env, anchor, 0);
217 rc2 = cl_sync_io_wait(env, anchor, 0);
218 if (rc2 < 0 && rc == 0)
223 cl_lock_release(env, lock);
226 EXPORT_SYMBOL(cl_lock_request);
229 * Releases a hold and a reference on a lock, obtained by cl_lock_hold().
231 void cl_lock_release(const struct lu_env *env, struct cl_lock *lock)
235 cl_lock_trace(D_DLMTRACE, env, "release lock", lock);
236 cl_lock_cancel(env, lock);
237 cl_lock_fini(env, lock);
240 EXPORT_SYMBOL(cl_lock_release);
242 const char *cl_lock_mode_name(const enum cl_lock_mode mode)
244 static const char * const names[] = {
249 BUILD_BUG_ON(CLM_MAX != ARRAY_SIZE(names));
252 EXPORT_SYMBOL(cl_lock_mode_name);
255 * Prints human readable representation of a lock description.
257 void cl_lock_descr_print(const struct lu_env *env, void *cookie,
258 lu_printer_t printer,
259 const struct cl_lock_descr *descr)
261 const struct lu_fid *fid;
263 fid = lu_object_fid(&descr->cld_obj->co_lu);
264 (*printer)(env, cookie, DDESCR"@"DFID, PDESCR(descr), PFID(fid));
266 EXPORT_SYMBOL(cl_lock_descr_print);
269 * Prints human readable representation of \a lock to the \a f.
271 void cl_lock_print(const struct lu_env *env, void *cookie,
272 lu_printer_t printer, const struct cl_lock *lock)
274 const struct cl_lock_slice *slice;
276 (*printer)(env, cookie, "lock@%p", lock);
277 cl_lock_descr_print(env, cookie, printer, &lock->cll_descr);
278 (*printer)(env, cookie, " {\n");
280 list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
281 (*printer)(env, cookie, " %s@%p: ",
282 slice->cls_obj->co_lu.lo_dev->ld_type->ldt_name,
284 if (slice->cls_ops->clo_print != NULL)
285 slice->cls_ops->clo_print(env, cookie, printer, slice);
286 (*printer)(env, cookie, "\n");
288 (*printer)(env, cookie, "} lock@%p\n", lock);
290 EXPORT_SYMBOL(cl_lock_print);