drivers/staging/lustre/lustre/obdclass/cl_lock.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   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.
   9  *
  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).
  15  *
  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.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2012, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * Client Extent Lock.
  37  *
  38  *   Author: Nikita Danilov <nikita.danilov@sun.com>
  39  *   Author: Jinshan Xiong <jinshan.xiong@intel.com>
  40  */
  41
  42 #define DEBUG_SUBSYSTEM S_CLASS
  43
  44 #include "../include/obd_class.h"
  45 #include "../include/obd_support.h"
  46 #include "../include/lustre_fid.h"
  47 #include <linux/list.h>
  48 #include "../include/cl_object.h"
  49 #include "cl_internal.h"
  50
  51 static void cl_lock_trace0(int level, const struct lu_env *env,
  52                            const char *prefix, const struct cl_lock *lock,
  53                            const char *func, const int line)
  54 {
  55         struct cl_object_header *h = cl_object_header(lock->cll_descr.cld_obj);
  56
  57         CDEBUG(level, "%s: %p (%p/%d) at %s():%d\n",
  58                prefix, lock, env, h->coh_nesting, func, line);
  59 }
  60 #define cl_lock_trace(level, env, prefix, lock)                         \
  61         cl_lock_trace0(level, env, prefix, lock, __func__, __LINE__)
  62
  63 /**
  64  * Adds lock slice to the compound lock.
  65  *
  66  * This is called by cl_object_operations::coo_lock_init() methods to add a
  67  * per-layer state to the lock. New state is added at the end of
  68  * cl_lock::cll_layers list, that is, it is at the bottom of the stack.
  69  *
  70  * \see cl_req_slice_add(), cl_page_slice_add(), cl_io_slice_add()
  71  */
  72 void cl_lock_slice_add(struct cl_lock *lock, struct cl_lock_slice *slice,
  73                        struct cl_object *obj,
  74                        const struct cl_lock_operations *ops)
  75 {
  76         slice->cls_lock = lock;
  77         list_add_tail(&slice->cls_linkage, &lock->cll_layers);
  78         slice->cls_obj = obj;
  79         slice->cls_ops = ops;
  80 }
  81 EXPORT_SYMBOL(cl_lock_slice_add);
  82
  83 void cl_lock_fini(const struct lu_env *env, struct cl_lock *lock)
  84 {
  85         cl_lock_trace(D_DLMTRACE, env, "destroy lock", lock);
  86
  87         while (!list_empty(&lock->cll_layers)) {
  88                 struct cl_lock_slice *slice;
  89
  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);
  94         }
  95         POISON(lock, 0x5a, sizeof(*lock));
  96 }
  97 EXPORT_SYMBOL(cl_lock_fini);
  98
  99 int cl_lock_init(const struct lu_env *env, struct cl_lock *lock,
 100                  const struct cl_io *io)
 101 {
 102         struct cl_object *obj = lock->cll_descr.cld_obj;
 103         struct cl_object *scan;
 104         int result = 0;
 105
 106         /* Make sure cl_lock::cll_descr is initialized. */
 107         LASSERT(obj);
 108
 109         INIT_LIST_HEAD(&lock->cll_layers);
 110         list_for_each_entry(scan, &obj->co_lu.lo_header->loh_layers,
 111                             co_lu.lo_linkage) {
 112                 result = scan->co_ops->coo_lock_init(env, scan, lock, io);
 113                 if (result != 0) {
 114                         cl_lock_fini(env, lock);
 115                         break;
 116                 }
 117         }
 118
 119         return result;
 120 }
 121 EXPORT_SYMBOL(cl_lock_init);
 122
 123 /**
 124  * Returns a slice with a lock, corresponding to the given layer in the
 125  * device stack.
 126  *
 127  * \see cl_page_at()
 128  */
 129 const struct cl_lock_slice *cl_lock_at(const struct cl_lock *lock,
 130                                        const struct lu_device_type *dtype)
 131 {
 132         const struct cl_lock_slice *slice;
 133
 134         list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
 135                 if (slice->cls_obj->co_lu.lo_dev->ld_type == dtype)
 136                         return slice;
 137         }
 138         return NULL;
 139 }
 140 EXPORT_SYMBOL(cl_lock_at);
 141
 142 void cl_lock_cancel(const struct lu_env *env, struct cl_lock *lock)
 143 {
 144         const struct cl_lock_slice *slice;
 145
 146         cl_lock_trace(D_DLMTRACE, env, "cancel lock", lock);
 147         list_for_each_entry_reverse(slice, &lock->cll_layers, cls_linkage) {
 148                 if (slice->cls_ops->clo_cancel)
 149                         slice->cls_ops->clo_cancel(env, slice);
 150         }
 151 }
 152 EXPORT_SYMBOL(cl_lock_cancel);
 153
 154 /**
 155  * Enqueue a lock.
 156  * \param anchor: if we need to wait for resources before getting the lock,
 157  *                use @anchor for the purpose.
 158  * \retval 0  enqueue successfully
 159  * \retval <0 error code
 160  */
 161 int cl_lock_enqueue(const struct lu_env *env, struct cl_io *io,
 162                     struct cl_lock *lock, struct cl_sync_io *anchor)
 163 {
 164         const struct cl_lock_slice *slice;
 165         int rc = -ENOSYS;
 166
 167         list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
 168                 if (!slice->cls_ops->clo_enqueue)
 169                         continue;
 170
 171                 rc = slice->cls_ops->clo_enqueue(env, slice, io, anchor);
 172                 if (rc != 0)
 173                         break;
 174                 }
 175         return rc;
 176 }
 177 EXPORT_SYMBOL(cl_lock_enqueue);
 178
 179 /**
 180  * Main high-level entry point of cl_lock interface that finds existing or
 181  * enqueues new lock matching given description.
 182  */
 183 int cl_lock_request(const struct lu_env *env, struct cl_io *io,
 184                     struct cl_lock *lock)
 185 {
 186         struct cl_sync_io *anchor = NULL;
 187         __u32 enq_flags = lock->cll_descr.cld_enq_flags;
 188         int rc;
 189
 190         rc = cl_lock_init(env, lock, io);
 191         if (rc < 0)
 192                 return rc;
 193
 194         if ((enq_flags & CEF_ASYNC) && !(enq_flags & CEF_AGL)) {
 195                 anchor = &cl_env_info(env)->clt_anchor;
 196                 cl_sync_io_init(anchor, 1, cl_sync_io_end);
 197         }
 198
 199         rc = cl_lock_enqueue(env, io, lock, anchor);
 200
 201         if (anchor) {
 202                 int rc2;
 203
 204                 /* drop the reference count held at initialization time */
 205                 cl_sync_io_note(env, anchor, 0);
 206                 rc2 = cl_sync_io_wait(env, anchor, 0);
 207                 if (rc2 < 0 && rc == 0)
 208                         rc = rc2;
 209         }
 210
 211         if (rc < 0)
 212                 cl_lock_release(env, lock);
 213
 214         return rc;
 215 }
 216 EXPORT_SYMBOL(cl_lock_request);
 217
 218 /**
 219  * Releases a hold and a reference on a lock, obtained by cl_lock_hold().
 220  */
 221 void cl_lock_release(const struct lu_env *env, struct cl_lock *lock)
 222 {
 223         cl_lock_trace(D_DLMTRACE, env, "release lock", lock);
 224         cl_lock_cancel(env, lock);
 225         cl_lock_fini(env, lock);
 226 }
 227 EXPORT_SYMBOL(cl_lock_release);
 228
 229 const char *cl_lock_mode_name(const enum cl_lock_mode mode)
 230 {
 231         static const char *names[] = {
 232                 [CLM_READ]    = "R",
 233                 [CLM_WRITE]   = "W",
 234                 [CLM_GROUP]   = "G"
 235         };
 236         if (0 <= mode && mode < ARRAY_SIZE(names))
 237                 return names[mode];
 238         else
 239                 return "U";
 240 }
 241 EXPORT_SYMBOL(cl_lock_mode_name);
 242
 243 /**
 244  * Prints human readable representation of a lock description.
 245  */
 246 void cl_lock_descr_print(const struct lu_env *env, void *cookie,
 247                          lu_printer_t printer,
 248                          const struct cl_lock_descr *descr)
 249 {
 250         const struct lu_fid  *fid;
 251
 252         fid = lu_object_fid(&descr->cld_obj->co_lu);
 253         (*printer)(env, cookie, DDESCR"@"DFID, PDESCR(descr), PFID(fid));
 254 }
 255 EXPORT_SYMBOL(cl_lock_descr_print);
 256
 257 /**
 258  * Prints human readable representation of \a lock to the \a f.
 259  */
 260 void cl_lock_print(const struct lu_env *env, void *cookie,
 261                    lu_printer_t printer, const struct cl_lock *lock)
 262 {
 263         const struct cl_lock_slice *slice;
 264
 265         (*printer)(env, cookie, "lock@%p", lock);
 266         cl_lock_descr_print(env, cookie, printer, &lock->cll_descr);
 267         (*printer)(env, cookie, " {\n");
 268
 269         list_for_each_entry(slice, &lock->cll_layers, cls_linkage) {
 270                 (*printer)(env, cookie, "    %s@%p: ",
 271                            slice->cls_obj->co_lu.lo_dev->ld_type->ldt_name,
 272                            slice);
 273                 if (slice->cls_ops->clo_print)
 274                         slice->cls_ops->clo_print(env, cookie, printer, slice);
 275                 (*printer)(env, cookie, "\n");
 276         }
 277         (*printer)(env, cookie, "} lock@%p\n", lock);
 278 }
 279 EXPORT_SYMBOL(cl_lock_print);