lustre/mdd/mdd_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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30 /*
  31  * This file is part of Lustre, http://www.lustre.org/
  32  * Lustre is a trademark of Sun Microsystems, Inc.
  33  *
  34  * lustre/mdd/mdd_lock.c
  35  *
  36  * Lustre Metadata Server (mdd) routines
  37  *
  38  * Author: Mike Pershin <tappro@clusterfs.com>
  39  */
  40
  41 #ifndef EXPORT_SYMTAB
  42 # define EXPORT_SYMTAB
  43 #endif
  44 #define DEBUG_SUBSYSTEM S_MDS
  45
  46 #include <linux/module.h>
  47 #include <lustre_ver.h>
  48 #include "mdd_internal.h"
  49
  50 void mdd_write_lock(const struct lu_env *env, struct mdd_object *obj,
  51                     enum mdd_object_role role)
  52 {
  53         struct dt_object  *next = mdd_object_child(obj);
  54
  55         next->do_ops->do_write_lock(env, next, role);
  56 }
  57
  58 void mdd_read_lock(const struct lu_env *env, struct mdd_object *obj,
  59                    enum mdd_object_role role)
  60 {
  61         struct dt_object  *next = mdd_object_child(obj);
  62
  63         next->do_ops->do_read_lock(env, next, role);
  64 }
  65
  66 void mdd_write_unlock(const struct lu_env *env, struct mdd_object *obj)
  67 {
  68         struct dt_object  *next = mdd_object_child(obj);
  69
  70         next->do_ops->do_write_unlock(env, next);
  71 }
  72
  73 void mdd_read_unlock(const struct lu_env *env, struct mdd_object *obj)
  74 {
  75         struct dt_object  *next = mdd_object_child(obj);
  76
  77         next->do_ops->do_read_unlock(env, next);
  78 }
  79
  80 int mdd_write_locked(const struct lu_env *env, struct mdd_object *obj)
  81 {
  82         struct dt_object  *next = mdd_object_child(obj);
  83
  84         return next->do_ops->do_write_locked(env, next);
  85 }
  86
  87 unsigned long mdd_name2hash(const char *name)
  88 {
  89         return full_name_hash((unsigned char*)name, strlen(name));
  90 }
  91
  92 /* Methods for parallel directory locking */
  93 #if MDD_DISABLE_PDO_LOCK
  94
  95 static void *pdo_handle = (void *)0xbabecafe;
  96
  97 void mdd_pdlock_init(struct mdd_object *obj)
  98 {
  99 }
 100
 101 void *mdd_pdo_write_lock(const struct lu_env *env, struct mdd_object *obj,
 102                          const char *name, enum mdd_object_role role)
 103 {
 104         return pdo_handle;
 105 }
 106
 107 void *mdd_pdo_read_lock(const struct lu_env *env, struct mdd_object *obj,
 108                         const char *name, enum mdd_object_role role)
 109 {
 110         return pdo_handle;
 111 }
 112
 113 void mdd_pdo_write_unlock(const struct lu_env *env, struct mdd_object *obj,
 114                           void *dlh)
 115 {
 116         LASSERT(dlh == pdo_handle);
 117 }
 118
 119 void mdd_pdo_read_unlock(const struct lu_env *env, struct mdd_object *obj,
 120                          void *dlh)
 121 {
 122         LASSERT(dlh == pdo_handle);
 123 }
 124
 125 #else /* !MDD_DISABLE_PDO_LOCK */
 126
 127 #ifdef CONFIG_LOCKDEP
 128 static cfs_lock_class_key_t mdd_pdirop_key;
 129
 130 #define RETIP ((unsigned long)__builtin_return_address(0))
 131
 132 static void mdd_lockdep_init(struct mdd_object *obj)
 133 {
 134         lockdep_set_class_and_name(obj, &mdd_pdirop_key, "pdir");
 135 }
 136
 137 static void mdd_lockdep_pd_acquire(struct mdd_object *obj,
 138                                    enum mdd_object_role role)
 139 {
 140 #ifdef HAVE_LOCK_MAP_ACQUIRE
 141         lock_map_acquire(&obj->dep_map);
 142 #else
 143         lock_acquire(&obj->dep_map, role, 0, 1, 2, RETIP);
 144 #endif
 145 }
 146
 147 static void mdd_lockdep_pd_release(struct mdd_object *obj)
 148 {
 149 #ifdef HAVE_LOCK_MAP_ACQUIRE
 150         lock_map_release(&obj->dep_map);
 151 #else
 152         lock_release(&obj->dep_map, 0, RETIP);
 153 #endif
 154 }
 155
 156 #else /* !CONFIG_LOCKDEP */
 157
 158 static void mdd_lockdep_init(struct mdd_object *obj)
 159 {}
 160 static void mdd_lockdep_pd_acquire(struct mdd_object *obj,
 161                                    enum mdd_object_role role)
 162 {}
 163 static void mdd_lockdep_pd_release(struct mdd_object *obj)
 164 {}
 165
 166 #endif /* !CONFIG_LOCKDEP */
 167
 168 void mdd_pdlock_init(struct mdd_object *obj)
 169 {
 170         dynlock_init(&obj->mod_pdlock);
 171         mdd_lockdep_init(obj);
 172 }
 173
 174 void *mdd_pdo_write_lock(const struct lu_env *env, struct mdd_object *obj,
 175                          const char *name, enum mdd_object_role role)
 176 {
 177         struct dynlock_handle *handle;
 178         unsigned long value = mdd_name2hash(name);
 179
 180         handle = dynlock_lock(&obj->mod_pdlock, value, DLT_WRITE, GFP_NOFS);
 181         if (handle != NULL)
 182                 mdd_lockdep_pd_acquire(obj, role);
 183         return handle;
 184 }
 185
 186 void *mdd_pdo_read_lock(const struct lu_env *env, struct mdd_object *obj,
 187                         const char *name, enum mdd_object_role role)
 188 {
 189         struct dynlock_handle *handle;
 190         unsigned long value = mdd_name2hash(name);
 191         handle = dynlock_lock(&obj->mod_pdlock, value, DLT_READ, GFP_NOFS);
 192         if (handle != NULL)
 193                 mdd_lockdep_pd_acquire(obj, role);
 194         return handle;
 195 }
 196
 197 void mdd_pdo_write_unlock(const struct lu_env *env, struct mdd_object *obj,
 198                           void *dlh)
 199 {
 200         mdd_lockdep_pd_release(obj);
 201         return dynlock_unlock(&obj->mod_pdlock, dlh);
 202 }
 203
 204 void mdd_pdo_read_unlock(const struct lu_env *env, struct mdd_object *obj,
 205                          void *dlh)
 206 {
 207         mdd_lockdep_pd_release(obj);
 208         return dynlock_unlock(&obj->mod_pdlock, dlh);
 209 }
 210
 211 #endif /* MDD_DISABLE_PDO_LOCK */