projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ocfs2: Wake up a starting region if it gets killed in the background.
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / ocfs2 / dlmglue.c
CommitLineData
ccd979bd
MF		 1/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * dlmglue.c
5 *
6 * Code which implements an OCFS2 specific interface to our DLM.
7 *
8 * Copyright (C) 2003, 2004 Oracle. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the
22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 * Boston, MA 021110-1307, USA.
24 */
25
26#include <linux/types.h>
27#include <linux/slab.h>
28#include <linux/highmem.h>
29#include <linux/mm.h>
ccd979bd
MF		 30#include <linux/crc32.h>
31#include <linux/kthread.h>
32#include <linux/pagemap.h>
33#include <linux/debugfs.h>
34#include <linux/seq_file.h>
35
36#include <cluster/heartbeat.h>
37#include <cluster/nodemanager.h>
38#include <cluster/tcp.h>
39
40#include <dlm/dlmapi.h>
41
42#define MLOG_MASK_PREFIX ML_DLM_GLUE
43#include <cluster/masklog.h>
44
45#include "ocfs2.h"
46
47#include "alloc.h"
d680efe9 48#include "dcache.h"
ccd979bd
MF		 49#include "dlmglue.h"
50#include "extent_map.h"
7f1a37e3 51#include "file.h"
ccd979bd
MF		 52#include "heartbeat.h"
53#include "inode.h"
54#include "journal.h"
55#include "slot_map.h"
56#include "super.h"
57#include "uptodate.h"
58#include "vote.h"
59
60#include "buffer_head_io.h"
61
62struct ocfs2_mask_waiter {
63 struct list_head mw_item;
64 int mw_status;
65 struct completion mw_complete;
66 unsigned long mw_mask;
67 unsigned long mw_goal;
68};
69
54a7e755
MF		 70static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres);
71static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres);
ccd979bd 72
d680efe9 73/*
cc567d89 74 * Return value from ->downconvert_worker functions.
d680efe9 75 *
b5e500e2 76 * These control the precise actions of ocfs2_unblock_lock()
d680efe9
MF		 77 * and ocfs2_process_blocked_lock()
78 *
79 */
80enum ocfs2_unblock_action {
81 UNBLOCK_CONTINUE = 0, /* Continue downconvert */
82 UNBLOCK_CONTINUE_POST = 1, /* Continue downconvert, fire
83 * ->post_unlock callback */
84 UNBLOCK_STOP_POST = 2, /* Do not downconvert, fire
85 * ->post_unlock() callback. */
86};
87
88struct ocfs2_unblock_ctl {
89 int requeue;
90 enum ocfs2_unblock_action unblock_action;
91};
92
810d5aeb
MF		 93static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
94 int new_level);
95static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres);
96
cc567d89
MF		 97static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
98 int blocking);
99
cc567d89
MF		 100static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
101 int blocking);
d680efe9
MF		 102
103static void ocfs2_dentry_post_unlock(struct ocfs2_super *osb,
104 struct ocfs2_lock_res *lockres);
ccd979bd 105
6cb129f5
AB		 106
107#define mlog_meta_lvb(__level, __lockres) ocfs2_dump_meta_lvb_info(__level, __PRETTY_FUNCTION__, __LINE__, __lockres)
108
109/* This aids in debugging situations where a bad LVB might be involved. */
110static void ocfs2_dump_meta_lvb_info(u64 level,
111 const char *function,
112 unsigned int line,
113 struct ocfs2_lock_res *lockres)
114{
115 struct ocfs2_meta_lvb *lvb = (struct ocfs2_meta_lvb *) lockres->l_lksb.lvb;
116
117 mlog(level, "LVB information for %s (called from %s:%u):\n",
118 lockres->l_name, function, line);
119 mlog(level, "version: %u, clusters: %u, generation: 0x%x\n",
120 lvb->lvb_version, be32_to_cpu(lvb->lvb_iclusters),
121 be32_to_cpu(lvb->lvb_igeneration));
122 mlog(level, "size: %llu, uid %u, gid %u, mode 0x%x\n",
123 (unsigned long long)be64_to_cpu(lvb->lvb_isize),
124 be32_to_cpu(lvb->lvb_iuid), be32_to_cpu(lvb->lvb_igid),
125 be16_to_cpu(lvb->lvb_imode));
126 mlog(level, "nlink %u, atime_packed 0x%llx, ctime_packed 0x%llx, "
127 "mtime_packed 0x%llx iattr 0x%x\n", be16_to_cpu(lvb->lvb_inlink),
128 (long long)be64_to_cpu(lvb->lvb_iatime_packed),
129 (long long)be64_to_cpu(lvb->lvb_ictime_packed),
130 (long long)be64_to_cpu(lvb->lvb_imtime_packed),
131 be32_to_cpu(lvb->lvb_iattr));
132}
133
134
f625c979
MF		 135/*
136 * OCFS2 Lock Resource Operations
137 *
138 * These fine tune the behavior of the generic dlmglue locking infrastructure.
0d5dc6c2
MF		 139 *
140 * The most basic of lock types can point ->l_priv to their respective
141 * struct ocfs2_super and allow the default actions to manage things.
142 *
143 * Right now, each lock type also needs to implement an init function,
144 * and trivial lock/unlock wrappers. ocfs2_simple_drop_lockres()
145 * should be called when the lock is no longer needed (i.e., object
146 * destruction time).
f625c979 147 */
ccd979bd 148struct ocfs2_lock_res_ops {
54a7e755
MF		 149 /*
150 * Translate an ocfs2_lock_res * into an ocfs2_super *. Define
151 * this callback if ->l_priv is not an ocfs2_super pointer
152 */
153 struct ocfs2_super * (*get_osb)(struct ocfs2_lock_res *);
b5e500e2 154
0d5dc6c2
MF		 155 /*
156 * Optionally called in the downconvert (or "vote") thread
157 * after a successful downconvert. The lockres will not be
158 * referenced after this callback is called, so it is safe to
159 * free memory, etc.
160 *
161 * The exact semantics of when this is called are controlled
162 * by ->downconvert_worker()
163 */
d680efe9 164 void (*post_unlock)(struct ocfs2_super *, struct ocfs2_lock_res *);
f625c979 165
16d5b956
MF		 166 /*
167 * Allow a lock type to add checks to determine whether it is
168 * safe to downconvert a lock. Return 0 to re-queue the
169 * downconvert at a later time, nonzero to continue.
170 *
171 * For most locks, the default checks that there are no
172 * incompatible holders are sufficient.
173 *
174 * Called with the lockres spinlock held.
175 */
176 int (*check_downconvert)(struct ocfs2_lock_res *, int);
177
5ef0d4ea
MF		 178 /*
179 * Allows a lock type to populate the lock value block. This
180 * is called on downconvert, and when we drop a lock.
181 *
182 * Locks that want to use this should set LOCK_TYPE_USES_LVB
183 * in the flags field.
184 *
185 * Called with the lockres spinlock held.
186 */
187 void (*set_lvb)(struct ocfs2_lock_res *);
188
cc567d89
MF		 189 /*
190 * Called from the downconvert thread when it is determined
191 * that a lock will be downconverted. This is called without
192 * any locks held so the function can do work that might
193 * schedule (syncing out data, etc).
194 *
195 * This should return any one of the ocfs2_unblock_action
196 * values, depending on what it wants the thread to do.
197 */
198 int (*downconvert_worker)(struct ocfs2_lock_res *, int);
199
f625c979
MF		 200 /*
201 * LOCK_TYPE_* flags which describe the specific requirements
202 * of a lock type. Descriptions of each individual flag follow.
203 */
204 int flags;
ccd979bd
MF		 205};
206
f625c979
MF		 207/*
208 * Some locks want to "refresh" potentially stale data when a
209 * meaningful (PRMODE or EXMODE) lock level is first obtained. If this
210 * flag is set, the OCFS2_LOCK_NEEDS_REFRESH flag will be set on the
211 * individual lockres l_flags member from the ast function. It is
212 * expected that the locking wrapper will clear the
213 * OCFS2_LOCK_NEEDS_REFRESH flag when done.
214 */
215#define LOCK_TYPE_REQUIRES_REFRESH 0x1
216
b80fc012 217/*
5ef0d4ea
MF		 218 * Indicate that a lock type makes use of the lock value block. The
219 * ->set_lvb lock type callback must be defined.
b80fc012
MF		 220 */
221#define LOCK_TYPE_USES_LVB 0x2
222
ccd979bd 223static struct ocfs2_lock_res_ops ocfs2_inode_rw_lops = {
54a7e755 224 .get_osb = ocfs2_get_inode_osb,
f625c979 225 .flags = 0,
ccd979bd
MF		 226};
227
228static struct ocfs2_lock_res_ops ocfs2_inode_meta_lops = {
54a7e755 229 .get_osb = ocfs2_get_inode_osb,
810d5aeb
MF		 230 .check_downconvert = ocfs2_check_meta_downconvert,
231 .set_lvb = ocfs2_set_meta_lvb,
b80fc012 232 .flags = LOCK_TYPE_REQUIRES_REFRESH|LOCK_TYPE_USES_LVB,
ccd979bd
MF		 233};
234
ccd979bd 235static struct ocfs2_lock_res_ops ocfs2_inode_data_lops = {
54a7e755 236 .get_osb = ocfs2_get_inode_osb,
cc567d89 237 .downconvert_worker = ocfs2_data_convert_worker,
f625c979 238 .flags = 0,
ccd979bd
MF		 239};
240
241static struct ocfs2_lock_res_ops ocfs2_super_lops = {
f625c979 242 .flags = LOCK_TYPE_REQUIRES_REFRESH,
ccd979bd
MF		 243};
244
245static struct ocfs2_lock_res_ops ocfs2_rename_lops = {
f625c979 246 .flags = 0,
ccd979bd
MF		 247};
248
d680efe9 249static struct ocfs2_lock_res_ops ocfs2_dentry_lops = {
54a7e755 250 .get_osb = ocfs2_get_dentry_osb,
d680efe9 251 .post_unlock = ocfs2_dentry_post_unlock,
cc567d89 252 .downconvert_worker = ocfs2_dentry_convert_worker,
f625c979 253 .flags = 0,
d680efe9
MF		 254};
255
50008630
TY		 256static struct ocfs2_lock_res_ops ocfs2_inode_open_lops = {
257 .get_osb = ocfs2_get_inode_osb,
258 .flags = 0,
259};
260
ccd979bd
MF		 261static inline int ocfs2_is_inode_lock(struct ocfs2_lock_res *lockres)
262{
263 return lockres->l_type == OCFS2_LOCK_TYPE_META ||
264 lockres->l_type == OCFS2_LOCK_TYPE_DATA ||
50008630
TY		 265 lockres->l_type == OCFS2_LOCK_TYPE_RW ||
266 lockres->l_type == OCFS2_LOCK_TYPE_OPEN;
ccd979bd
MF		 267}
268
ccd979bd
MF		 269static inline struct inode *ocfs2_lock_res_inode(struct ocfs2_lock_res *lockres)
270{
271 BUG_ON(!ocfs2_is_inode_lock(lockres));
272
273 return (struct inode *) lockres->l_priv;
274}
275
d680efe9
MF		 276static inline struct ocfs2_dentry_lock *ocfs2_lock_res_dl(struct ocfs2_lock_res *lockres)
277{
278 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_DENTRY);
279
280 return (struct ocfs2_dentry_lock *)lockres->l_priv;
281}
282
54a7e755
MF		 283static inline struct ocfs2_super *ocfs2_get_lockres_osb(struct ocfs2_lock_res *lockres)
284{
285 if (lockres->l_ops->get_osb)
286 return lockres->l_ops->get_osb(lockres);
287
288 return (struct ocfs2_super *)lockres->l_priv;
289}
290
ccd979bd
MF		 291static int ocfs2_lock_create(struct ocfs2_super *osb,
292 struct ocfs2_lock_res *lockres,
293 int level,
294 int dlm_flags);
295static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
296 int wanted);
297static void ocfs2_cluster_unlock(struct ocfs2_super *osb,
298 struct ocfs2_lock_res *lockres,
299 int level);
300static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres);
301static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres);
302static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres);
303static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, int level);
304static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
305 struct ocfs2_lock_res *lockres);
306static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
307 int convert);
308#define ocfs2_log_dlm_error(_func, _stat, _lockres) do { \
309 mlog(ML_ERROR, "Dlm error \"%s\" while calling %s on " \
310 "resource %s: %s\n", dlm_errname(_stat), _func, \
311 _lockres->l_name, dlm_errmsg(_stat)); \
312} while (0)
313static void ocfs2_vote_on_unlock(struct ocfs2_super *osb,
314 struct ocfs2_lock_res *lockres);
315static int ocfs2_meta_lock_update(struct inode *inode,
316 struct buffer_head **bh);
317static void ocfs2_drop_osb_locks(struct ocfs2_super *osb);
318static inline int ocfs2_highest_compat_lock_level(int level);
ccd979bd 319
ccd979bd
MF		 320static void ocfs2_build_lock_name(enum ocfs2_lock_type type,
321 u64 blkno,
322 u32 generation,
323 char *name)
324{
325 int len;
326
327 mlog_entry_void();
328
329 BUG_ON(type >= OCFS2_NUM_LOCK_TYPES);
330
b0697053
MF		 331 len = snprintf(name, OCFS2_LOCK_ID_MAX_LEN, "%c%s%016llx%08x",
332 ocfs2_lock_type_char(type), OCFS2_LOCK_ID_PAD,
333 (long long)blkno, generation);
ccd979bd
MF		 334
335 BUG_ON(len != (OCFS2_LOCK_ID_MAX_LEN - 1));
336
337 mlog(0, "built lock resource with name: %s\n", name);
338
339 mlog_exit_void();
340}
341
34af946a 342static DEFINE_SPINLOCK(ocfs2_dlm_tracking_lock);
ccd979bd
MF		 343
344static void ocfs2_add_lockres_tracking(struct ocfs2_lock_res *res,
345 struct ocfs2_dlm_debug *dlm_debug)
346{
347 mlog(0, "Add tracking for lockres %s\n", res->l_name);
348
349 spin_lock(&ocfs2_dlm_tracking_lock);
350 list_add(&res->l_debug_list, &dlm_debug->d_lockres_tracking);
351 spin_unlock(&ocfs2_dlm_tracking_lock);
352}
353
354static void ocfs2_remove_lockres_tracking(struct ocfs2_lock_res *res)
355{
356 spin_lock(&ocfs2_dlm_tracking_lock);
357 if (!list_empty(&res->l_debug_list))
358 list_del_init(&res->l_debug_list);
359 spin_unlock(&ocfs2_dlm_tracking_lock);
360}
361
362static void ocfs2_lock_res_init_common(struct ocfs2_super *osb,
363 struct ocfs2_lock_res *res,
364 enum ocfs2_lock_type type,
ccd979bd
MF		 365 struct ocfs2_lock_res_ops *ops,
366 void *priv)
367{
ccd979bd
MF		 368 res->l_type = type;
369 res->l_ops = ops;
370 res->l_priv = priv;
371
372 res->l_level = LKM_IVMODE;
373 res->l_requested = LKM_IVMODE;
374 res->l_blocking = LKM_IVMODE;
375 res->l_action = OCFS2_AST_INVALID;
376 res->l_unlock_action = OCFS2_UNLOCK_INVALID;
377
378 res->l_flags = OCFS2_LOCK_INITIALIZED;
379
380 ocfs2_add_lockres_tracking(res, osb->osb_dlm_debug);
381}
382
383void ocfs2_lock_res_init_once(struct ocfs2_lock_res *res)
384{
385 /* This also clears out the lock status block */
386 memset(res, 0, sizeof(struct ocfs2_lock_res));
387 spin_lock_init(&res->l_lock);
388 init_waitqueue_head(&res->l_event);
389 INIT_LIST_HEAD(&res->l_blocked_list);
390 INIT_LIST_HEAD(&res->l_mask_waiters);
391}
392
393void ocfs2_inode_lock_res_init(struct ocfs2_lock_res *res,
394 enum ocfs2_lock_type type,
24c19ef4 395 unsigned int generation,
ccd979bd
MF		 396 struct inode *inode)
397{
398 struct ocfs2_lock_res_ops *ops;
399
400 switch(type) {
401 case OCFS2_LOCK_TYPE_RW:
402 ops = &ocfs2_inode_rw_lops;
403 break;
404 case OCFS2_LOCK_TYPE_META:
405 ops = &ocfs2_inode_meta_lops;
406 break;
407 case OCFS2_LOCK_TYPE_DATA:
408 ops = &ocfs2_inode_data_lops;
409 break;
50008630
TY		 410 case OCFS2_LOCK_TYPE_OPEN:
411 ops = &ocfs2_inode_open_lops;
412 break;
ccd979bd
MF		 413 default:
414 mlog_bug_on_msg(1, "type: %d\n", type);
415 ops = NULL; /* thanks, gcc */
416 break;
417 };
418
d680efe9 419 ocfs2_build_lock_name(type, OCFS2_I(inode)->ip_blkno,
24c19ef4 420 generation, res->l_name);
d680efe9
MF		 421 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), res, type, ops, inode);
422}
423
54a7e755
MF		 424static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres)
425{
426 struct inode *inode = ocfs2_lock_res_inode(lockres);
427
428 return OCFS2_SB(inode->i_sb);
429}
430
d680efe9
MF		 431static __u64 ocfs2_get_dentry_lock_ino(struct ocfs2_lock_res *lockres)
432{
433 __be64 inode_blkno_be;
434
435 memcpy(&inode_blkno_be, &lockres->l_name[OCFS2_DENTRY_LOCK_INO_START],
436 sizeof(__be64));
437
438 return be64_to_cpu(inode_blkno_be);
439}
440
54a7e755
MF		 441static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres)
442{
443 struct ocfs2_dentry_lock *dl = lockres->l_priv;
444
445 return OCFS2_SB(dl->dl_inode->i_sb);
446}
447
d680efe9
MF		 448void ocfs2_dentry_lock_res_init(struct ocfs2_dentry_lock *dl,
449 u64 parent, struct inode *inode)
450{
451 int len;
452 u64 inode_blkno = OCFS2_I(inode)->ip_blkno;
453 __be64 inode_blkno_be = cpu_to_be64(inode_blkno);
454 struct ocfs2_lock_res *lockres = &dl->dl_lockres;
455
456 ocfs2_lock_res_init_once(lockres);
457
458 /*
459 * Unfortunately, the standard lock naming scheme won't work
460 * here because we have two 16 byte values to use. Instead,
461 * we'll stuff the inode number as a binary value. We still
462 * want error prints to show something without garbling the
463 * display, so drop a null byte in there before the inode
464 * number. A future version of OCFS2 will likely use all
465 * binary lock names. The stringified names have been a
466 * tremendous aid in debugging, but now that the debugfs
467 * interface exists, we can mangle things there if need be.
468 *
469 * NOTE: We also drop the standard "pad" value (the total lock
470 * name size stays the same though - the last part is all
471 * zeros due to the memset in ocfs2_lock_res_init_once()
472 */
473 len = snprintf(lockres->l_name, OCFS2_DENTRY_LOCK_INO_START,
474 "%c%016llx",
475 ocfs2_lock_type_char(OCFS2_LOCK_TYPE_DENTRY),
476 (long long)parent);
477
478 BUG_ON(len != (OCFS2_DENTRY_LOCK_INO_START - 1));
479
480 memcpy(&lockres->l_name[OCFS2_DENTRY_LOCK_INO_START], &inode_blkno_be,
481 sizeof(__be64));
482
483 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
484 OCFS2_LOCK_TYPE_DENTRY, &ocfs2_dentry_lops,
485 dl);
ccd979bd
MF		 486}
487
488static void ocfs2_super_lock_res_init(struct ocfs2_lock_res *res,
489 struct ocfs2_super *osb)
490{
491 /* Superblock lockres doesn't come from a slab so we call init
492 * once on it manually. */
493 ocfs2_lock_res_init_once(res);
d680efe9
MF		 494 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_SUPER, OCFS2_SUPER_BLOCK_BLKNO,
495 0, res->l_name);
ccd979bd 496 ocfs2_lock_res_init_common(osb, res, OCFS2_LOCK_TYPE_SUPER,
ccd979bd
MF		 497 &ocfs2_super_lops, osb);
498}
499
500static void ocfs2_rename_lock_res_init(struct ocfs2_lock_res *res,
501 struct ocfs2_super *osb)
502{
503 /* Rename lockres doesn't come from a slab so we call init
504 * once on it manually. */
505 ocfs2_lock_res_init_once(res);
d680efe9
MF		 506 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_RENAME, 0, 0, res->l_name);
507 ocfs2_lock_res_init_common(osb, res, OCFS2_LOCK_TYPE_RENAME,
ccd979bd
MF		 508 &ocfs2_rename_lops, osb);
509}
510
511void ocfs2_lock_res_free(struct ocfs2_lock_res *res)
512{
513 mlog_entry_void();
514
515 if (!(res->l_flags & OCFS2_LOCK_INITIALIZED))
516 return;
517
518 ocfs2_remove_lockres_tracking(res);
519
520 mlog_bug_on_msg(!list_empty(&res->l_blocked_list),
521 "Lockres %s is on the blocked list\n",
522 res->l_name);
523 mlog_bug_on_msg(!list_empty(&res->l_mask_waiters),
524 "Lockres %s has mask waiters pending\n",
525 res->l_name);
526 mlog_bug_on_msg(spin_is_locked(&res->l_lock),
527 "Lockres %s is locked\n",
528 res->l_name);
529 mlog_bug_on_msg(res->l_ro_holders,
530 "Lockres %s has %u ro holders\n",
531 res->l_name, res->l_ro_holders);
532 mlog_bug_on_msg(res->l_ex_holders,
533 "Lockres %s has %u ex holders\n",
534 res->l_name, res->l_ex_holders);
535
536 /* Need to clear out the lock status block for the dlm */
537 memset(&res->l_lksb, 0, sizeof(res->l_lksb));
538
539 res->l_flags = 0UL;
540 mlog_exit_void();
541}
542
543static inline void ocfs2_inc_holders(struct ocfs2_lock_res *lockres,
544 int level)
545{
546 mlog_entry_void();
547
548 BUG_ON(!lockres);
549
550 switch(level) {
551 case LKM_EXMODE:
552 lockres->l_ex_holders++;
553 break;
554 case LKM_PRMODE:
555 lockres->l_ro_holders++;
556 break;
557 default:
558 BUG();
559 }
560
561 mlog_exit_void();
562}
563
564static inline void ocfs2_dec_holders(struct ocfs2_lock_res *lockres,
565 int level)
566{
567 mlog_entry_void();
568
569 BUG_ON(!lockres);
570
571 switch(level) {
572 case LKM_EXMODE:
573 BUG_ON(!lockres->l_ex_holders);
574 lockres->l_ex_holders--;
575 break;
576 case LKM_PRMODE:
577 BUG_ON(!lockres->l_ro_holders);
578 lockres->l_ro_holders--;
579 break;
580 default:
581 BUG();
582 }
583 mlog_exit_void();
584}
585
586/* WARNING: This function lives in a world where the only three lock
587 * levels are EX, PR, and NL. It *will* have to be adjusted when more
588 * lock types are added. */
589static inline int ocfs2_highest_compat_lock_level(int level)
590{
591 int new_level = LKM_EXMODE;
592
593 if (level == LKM_EXMODE)
594 new_level = LKM_NLMODE;
595 else if (level == LKM_PRMODE)
596 new_level = LKM_PRMODE;
597 return new_level;
598}
599
600static void lockres_set_flags(struct ocfs2_lock_res *lockres,
601 unsigned long newflags)
602{
603 struct list_head *pos, *tmp;
604 struct ocfs2_mask_waiter *mw;
605
606 assert_spin_locked(&lockres->l_lock);
607
608 lockres->l_flags = newflags;
609
610 list_for_each_safe(pos, tmp, &lockres->l_mask_waiters) {
611 mw = list_entry(pos, struct ocfs2_mask_waiter, mw_item);
612 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
613 continue;
614
615 list_del_init(&mw->mw_item);
616 mw->mw_status = 0;
617 complete(&mw->mw_complete);
618 }
619}
620static void lockres_or_flags(struct ocfs2_lock_res *lockres, unsigned long or)
621{
622 lockres_set_flags(lockres, lockres->l_flags | or);
623}
624static void lockres_clear_flags(struct ocfs2_lock_res *lockres,
625 unsigned long clear)
626{
627 lockres_set_flags(lockres, lockres->l_flags & ~clear);
628}
629
630static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres)
631{
632 mlog_entry_void();
633
634 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
635 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
636 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
637 BUG_ON(lockres->l_blocking <= LKM_NLMODE);
638
639 lockres->l_level = lockres->l_requested;
640 if (lockres->l_level <=
641 ocfs2_highest_compat_lock_level(lockres->l_blocking)) {
642 lockres->l_blocking = LKM_NLMODE;
643 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
644 }
645 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
646
647 mlog_exit_void();
648}
649
650static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres)
651{
652 mlog_entry_void();
653
654 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
655 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
656
657 /* Convert from RO to EX doesn't really need anything as our
658 * information is already up to data. Convert from NL to
659 * *anything* however should mark ourselves as needing an
660 * update */
f625c979
MF		 661 if (lockres->l_level == LKM_NLMODE &&
662 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
ccd979bd
MF		 663 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
664
665 lockres->l_level = lockres->l_requested;
666 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
667
668 mlog_exit_void();
669}
670
671static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres)
672{
673 mlog_entry_void();
674
675 BUG_ON((!lockres->l_flags & OCFS2_LOCK_BUSY));
676 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
677
678 if (lockres->l_requested > LKM_NLMODE &&
f625c979
MF		 679 !(lockres->l_flags & OCFS2_LOCK_LOCAL) &&
680 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
ccd979bd
MF		 681 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
682
683 lockres->l_level = lockres->l_requested;
684 lockres_or_flags(lockres, OCFS2_LOCK_ATTACHED);
685 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
686
687 mlog_exit_void();
688}
689
ccd979bd
MF		 690static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres,
691 int level)
692{
693 int needs_downconvert = 0;
694 mlog_entry_void();
695
696 assert_spin_locked(&lockres->l_lock);
697
698 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
699
700 if (level > lockres->l_blocking) {
701 /* only schedule a downconvert if we haven't already scheduled
702 * one that goes low enough to satisfy the level we're
703 * blocking. this also catches the case where we get
704 * duplicate BASTs */
705 if (ocfs2_highest_compat_lock_level(level) <
706 ocfs2_highest_compat_lock_level(lockres->l_blocking))
707 needs_downconvert = 1;
708
709 lockres->l_blocking = level;
710 }
711
712 mlog_exit(needs_downconvert);
713 return needs_downconvert;
714}
715
aa2623ad 716static void ocfs2_blocking_ast(void *opaque, int level)
ccd979bd 717{
aa2623ad
MF		 718 struct ocfs2_lock_res *lockres = opaque;
719 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
ccd979bd
MF		 720 int needs_downconvert;
721 unsigned long flags;
722
ccd979bd
MF		 723 BUG_ON(level <= LKM_NLMODE);
724
aa2623ad
MF		 725 mlog(0, "BAST fired for lockres %s, blocking %d, level %d type %s\n",
726 lockres->l_name, level, lockres->l_level,
727 ocfs2_lock_type_string(lockres->l_type));
728
ccd979bd
MF		 729 spin_lock_irqsave(&lockres->l_lock, flags);
730 needs_downconvert = ocfs2_generic_handle_bast(lockres, level);
731 if (needs_downconvert)
732 ocfs2_schedule_blocked_lock(osb, lockres);
733 spin_unlock_irqrestore(&lockres->l_lock, flags);
734
d680efe9
MF		 735 wake_up(&lockres->l_event);
736
ccd979bd 737 ocfs2_kick_vote_thread(osb);
ccd979bd
MF		 738}
739
e92d57df 740static void ocfs2_locking_ast(void *opaque)
ccd979bd 741{
e92d57df 742 struct ocfs2_lock_res *lockres = opaque;
ccd979bd
MF		 743 struct dlm_lockstatus *lksb = &lockres->l_lksb;
744 unsigned long flags;
745
746 spin_lock_irqsave(&lockres->l_lock, flags);
747
748 if (lksb->status != DLM_NORMAL) {
749 mlog(ML_ERROR, "lockres %s: lksb status value of %u!\n",
750 lockres->l_name, lksb->status);
751 spin_unlock_irqrestore(&lockres->l_lock, flags);
752 return;
753 }
754
755 switch(lockres->l_action) {
756 case OCFS2_AST_ATTACH:
757 ocfs2_generic_handle_attach_action(lockres);
e92d57df 758 lockres_clear_flags(lockres, OCFS2_LOCK_LOCAL);
ccd979bd
MF		 759 break;
760 case OCFS2_AST_CONVERT:
761 ocfs2_generic_handle_convert_action(lockres);
762 break;
763 case OCFS2_AST_DOWNCONVERT:
764 ocfs2_generic_handle_downconvert_action(lockres);
765 break;
766 default:
e92d57df
MF		 767 mlog(ML_ERROR, "lockres %s: ast fired with invalid action: %u "
768 "lockres flags = 0x%lx, unlock action: %u\n",
769 lockres->l_name, lockres->l_action, lockres->l_flags,
770 lockres->l_unlock_action);
ccd979bd
MF		 771 BUG();
772 }
773
ccd979bd
MF		 774 /* set it to something invalid so if we get called again we
775 * can catch it. */
776 lockres->l_action = OCFS2_AST_INVALID;
ccd979bd
MF		 777
778 wake_up(&lockres->l_event);
d680efe9 779 spin_unlock_irqrestore(&lockres->l_lock, flags);
ccd979bd
MF		 780}
781
ccd979bd
MF		 782static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
783 int convert)
784{
785 unsigned long flags;
786
787 mlog_entry_void();
788 spin_lock_irqsave(&lockres->l_lock, flags);
789 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
790 if (convert)
791 lockres->l_action = OCFS2_AST_INVALID;
792 else
793 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
794 spin_unlock_irqrestore(&lockres->l_lock, flags);
795
796 wake_up(&lockres->l_event);
797 mlog_exit_void();
798}
799
800/* Note: If we detect another process working on the lock (i.e.,
801 * OCFS2_LOCK_BUSY), we'll bail out returning 0. It's up to the caller
802 * to do the right thing in that case.
803 */
804static int ocfs2_lock_create(struct ocfs2_super *osb,
805 struct ocfs2_lock_res *lockres,
806 int level,
807 int dlm_flags)
808{
809 int ret = 0;
c271c5c2 810 enum dlm_status status = DLM_NORMAL;
ccd979bd
MF		 811 unsigned long flags;
812
813 mlog_entry_void();
814
815 mlog(0, "lock %s, level = %d, flags = %d\n", lockres->l_name, level,
816 dlm_flags);
817
818 spin_lock_irqsave(&lockres->l_lock, flags);
819 if ((lockres->l_flags & OCFS2_LOCK_ATTACHED) ||
820 (lockres->l_flags & OCFS2_LOCK_BUSY)) {
821 spin_unlock_irqrestore(&lockres->l_lock, flags);
822 goto bail;
823 }
824
825 lockres->l_action = OCFS2_AST_ATTACH;
826 lockres->l_requested = level;
827 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
828 spin_unlock_irqrestore(&lockres->l_lock, flags);
829
830 status = dlmlock(osb->dlm,
831 level,
832 &lockres->l_lksb,
833 dlm_flags,
834 lockres->l_name,
f0681062 835 OCFS2_LOCK_ID_MAX_LEN - 1,
e92d57df 836 ocfs2_locking_ast,
ccd979bd 837 lockres,
aa2623ad 838 ocfs2_blocking_ast);
ccd979bd
MF		 839 if (status != DLM_NORMAL) {
840 ocfs2_log_dlm_error("dlmlock", status, lockres);
841 ret = -EINVAL;
842 ocfs2_recover_from_dlm_error(lockres, 1);
843 }
844
845 mlog(0, "lock %s, successfull return from dlmlock\n", lockres->l_name);
846
847bail:
848 mlog_exit(ret);
849 return ret;
850}
851
852static inline int ocfs2_check_wait_flag(struct ocfs2_lock_res *lockres,
853 int flag)
854{
855 unsigned long flags;
856 int ret;
857
858 spin_lock_irqsave(&lockres->l_lock, flags);
859 ret = lockres->l_flags & flag;
860 spin_unlock_irqrestore(&lockres->l_lock, flags);
861
862 return ret;
863}
864
865static inline void ocfs2_wait_on_busy_lock(struct ocfs2_lock_res *lockres)
866
867{
868 wait_event(lockres->l_event,
869 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_BUSY));
870}
871
872static inline void ocfs2_wait_on_refreshing_lock(struct ocfs2_lock_res *lockres)
873
874{
875 wait_event(lockres->l_event,
876 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_REFRESHING));
877}
878
879/* predict what lock level we'll be dropping down to on behalf
880 * of another node, and return true if the currently wanted
881 * level will be compatible with it. */
882static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
883 int wanted)
884{
885 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
886
887 return wanted <= ocfs2_highest_compat_lock_level(lockres->l_blocking);
888}
889
890static void ocfs2_init_mask_waiter(struct ocfs2_mask_waiter *mw)
891{
892 INIT_LIST_HEAD(&mw->mw_item);
893 init_completion(&mw->mw_complete);
894}
895
896static int ocfs2_wait_for_mask(struct ocfs2_mask_waiter *mw)
897{
898 wait_for_completion(&mw->mw_complete);
899 /* Re-arm the completion in case we want to wait on it again */
900 INIT_COMPLETION(mw->mw_complete);
901 return mw->mw_status;
902}
903
904static void lockres_add_mask_waiter(struct ocfs2_lock_res *lockres,
905 struct ocfs2_mask_waiter *mw,
906 unsigned long mask,
907 unsigned long goal)
908{
909 BUG_ON(!list_empty(&mw->mw_item));
910
911 assert_spin_locked(&lockres->l_lock);
912
913 list_add_tail(&mw->mw_item, &lockres->l_mask_waiters);
914 mw->mw_mask = mask;
915 mw->mw_goal = goal;
916}
917
918/* returns 0 if the mw that was removed was already satisfied, -EBUSY
919 * if the mask still hadn't reached its goal */
920static int lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
921 struct ocfs2_mask_waiter *mw)
922{
923 unsigned long flags;
924 int ret = 0;
925
926 spin_lock_irqsave(&lockres->l_lock, flags);
927 if (!list_empty(&mw->mw_item)) {
928 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
929 ret = -EBUSY;
930
931 list_del_init(&mw->mw_item);
932 init_completion(&mw->mw_complete);
933 }
934 spin_unlock_irqrestore(&lockres->l_lock, flags);
935
936 return ret;
937
938}
939
940static int ocfs2_cluster_lock(struct ocfs2_super *osb,
941 struct ocfs2_lock_res *lockres,
942 int level,
943 int lkm_flags,
944 int arg_flags)
945{
946 struct ocfs2_mask_waiter mw;
947 enum dlm_status status;
948 int wait, catch_signals = !(osb->s_mount_opt & OCFS2_MOUNT_NOINTR);
949 int ret = 0; /* gcc doesn't realize wait = 1 guarantees ret is set */
950 unsigned long flags;
951
952 mlog_entry_void();
953
954 ocfs2_init_mask_waiter(&mw);
955
b80fc012
MF		 956 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
957 lkm_flags |= LKM_VALBLK;
958
ccd979bd
MF		 959again:
960 wait = 0;
961
962 if (catch_signals && signal_pending(current)) {
963 ret = -ERESTARTSYS;
964 goto out;
965 }
966
967 spin_lock_irqsave(&lockres->l_lock, flags);
968
969 mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING,
970 "Cluster lock called on freeing lockres %s! flags "
971 "0x%lx\n", lockres->l_name, lockres->l_flags);
972
973 /* We only compare against the currently granted level
974 * here. If the lock is blocked waiting on a downconvert,
975 * we'll get caught below. */
976 if (lockres->l_flags & OCFS2_LOCK_BUSY &&
977 level > lockres->l_level) {
978 /* is someone sitting in dlm_lock? If so, wait on
979 * them. */
980 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
981 wait = 1;
982 goto unlock;
983 }
984
985 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
986 /* lock has not been created yet. */
987 spin_unlock_irqrestore(&lockres->l_lock, flags);
988
989 ret = ocfs2_lock_create(osb, lockres, LKM_NLMODE, 0);
990 if (ret < 0) {
991 mlog_errno(ret);
992 goto out;
993 }
994 goto again;
995 }
996
997 if (lockres->l_flags & OCFS2_LOCK_BLOCKED &&
998 !ocfs2_may_continue_on_blocked_lock(lockres, level)) {
999 /* is the lock is currently blocked on behalf of
1000 * another node */
1001 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BLOCKED, 0);
1002 wait = 1;
1003 goto unlock;
1004 }
1005
1006 if (level > lockres->l_level) {
1007 if (lockres->l_action != OCFS2_AST_INVALID)
1008 mlog(ML_ERROR, "lockres %s has action %u pending\n",
1009 lockres->l_name, lockres->l_action);
1010
1011 lockres->l_action = OCFS2_AST_CONVERT;
1012 lockres->l_requested = level;
1013 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1014 spin_unlock_irqrestore(&lockres->l_lock, flags);
1015
1016 BUG_ON(level == LKM_IVMODE);
1017 BUG_ON(level == LKM_NLMODE);
1018
1019 mlog(0, "lock %s, convert from %d to level = %d\n",
1020 lockres->l_name, lockres->l_level, level);
1021
1022 /* call dlm_lock to upgrade lock now */
1023 status = dlmlock(osb->dlm,
1024 level,
1025 &lockres->l_lksb,
b80fc012 1026 lkm_flags|LKM_CONVERT,
ccd979bd 1027 lockres->l_name,
f0681062 1028 OCFS2_LOCK_ID_MAX_LEN - 1,
e92d57df 1029 ocfs2_locking_ast,
ccd979bd 1030 lockres,
aa2623ad 1031 ocfs2_blocking_ast);
ccd979bd
MF		 1032 if (status != DLM_NORMAL) {
1033 if ((lkm_flags & LKM_NOQUEUE) &&
1034 (status == DLM_NOTQUEUED))
1035 ret = -EAGAIN;
1036 else {
1037 ocfs2_log_dlm_error("dlmlock", status,
1038 lockres);
1039 ret = -EINVAL;
1040 }
1041 ocfs2_recover_from_dlm_error(lockres, 1);
1042 goto out;
1043 }
1044
1045 mlog(0, "lock %s, successfull return from dlmlock\n",
1046 lockres->l_name);
1047
1048 /* At this point we've gone inside the dlm and need to
1049 * complete our work regardless. */
1050 catch_signals = 0;
1051
1052 /* wait for busy to clear and carry on */
1053 goto again;
1054 }
1055
1056 /* Ok, if we get here then we're good to go. */
1057 ocfs2_inc_holders(lockres, level);
1058
1059 ret = 0;
1060unlock:
1061 spin_unlock_irqrestore(&lockres->l_lock, flags);
1062out:
1063 /*
1064 * This is helping work around a lock inversion between the page lock
1065 * and dlm locks. One path holds the page lock while calling aops
1066 * which block acquiring dlm locks. The voting thread holds dlm
1067 * locks while acquiring page locks while down converting data locks.
1068 * This block is helping an aop path notice the inversion and back
1069 * off to unlock its page lock before trying the dlm lock again.
1070 */
1071 if (wait && arg_flags & OCFS2_LOCK_NONBLOCK &&
1072 mw.mw_mask & (OCFS2_LOCK_BUSY|OCFS2_LOCK_BLOCKED)) {
1073 wait = 0;
1074 if (lockres_remove_mask_waiter(lockres, &mw))
1075 ret = -EAGAIN;
1076 else
1077 goto again;
1078 }
1079 if (wait) {
1080 ret = ocfs2_wait_for_mask(&mw);
1081 if (ret == 0)
1082 goto again;
1083 mlog_errno(ret);
1084 }
1085
1086 mlog_exit(ret);
1087 return ret;
1088}
1089
1090static void ocfs2_cluster_unlock(struct ocfs2_super *osb,
1091 struct ocfs2_lock_res *lockres,
1092 int level)
1093{
1094 unsigned long flags;
1095
1096 mlog_entry_void();
1097 spin_lock_irqsave(&lockres->l_lock, flags);
1098 ocfs2_dec_holders(lockres, level);
1099 ocfs2_vote_on_unlock(osb, lockres);
1100 spin_unlock_irqrestore(&lockres->l_lock, flags);
1101 mlog_exit_void();
1102}
1103
da66116e
AB		 1104static int ocfs2_create_new_lock(struct ocfs2_super *osb,
1105 struct ocfs2_lock_res *lockres,
1106 int ex,
1107 int local)
ccd979bd 1108{
d680efe9 1109 int level = ex ? LKM_EXMODE : LKM_PRMODE;
ccd979bd 1110 unsigned long flags;
24c19ef4 1111 int lkm_flags = local ? LKM_LOCAL : 0;
ccd979bd
MF		 1112
1113 spin_lock_irqsave(&lockres->l_lock, flags);
1114 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
1115 lockres_or_flags(lockres, OCFS2_LOCK_LOCAL);
1116 spin_unlock_irqrestore(&lockres->l_lock, flags);
1117
24c19ef4 1118 return ocfs2_lock_create(osb, lockres, level, lkm_flags);
ccd979bd
MF		 1119}
1120
1121/* Grants us an EX lock on the data and metadata resources, skipping
1122 * the normal cluster directory lookup. Use this ONLY on newly created
1123 * inodes which other nodes can't possibly see, and which haven't been
1124 * hashed in the inode hash yet. This can give us a good performance
1125 * increase as it'll skip the network broadcast normally associated
1126 * with creating a new lock resource. */
1127int ocfs2_create_new_inode_locks(struct inode *inode)
1128{
1129 int ret;
d680efe9 1130 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1131
1132 BUG_ON(!inode);
1133 BUG_ON(!ocfs2_inode_is_new(inode));
1134
1135 mlog_entry_void();
1136
b0697053 1137 mlog(0, "Inode %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
ccd979bd
MF		 1138
1139 /* NOTE: That we don't increment any of the holder counts, nor
1140 * do we add anything to a journal handle. Since this is
1141 * supposed to be a new inode which the cluster doesn't know
1142 * about yet, there is no need to. As far as the LVB handling
1143 * is concerned, this is basically like acquiring an EX lock
1144 * on a resource which has an invalid one -- we'll set it
1145 * valid when we release the EX. */
1146
24c19ef4 1147 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_rw_lockres, 1, 1);
ccd979bd
MF		 1148 if (ret) {
1149 mlog_errno(ret);
1150 goto bail;
1151 }
1152
24c19ef4
MF		 1153 /*
1154 * We don't want to use LKM_LOCAL on a meta data lock as they
1155 * don't use a generation in their lock names.
1156 */
1157 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_meta_lockres, 1, 0);
ccd979bd
MF		 1158 if (ret) {
1159 mlog_errno(ret);
1160 goto bail;
1161 }
1162
24c19ef4 1163 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_data_lockres, 1, 1);
ccd979bd
MF		 1164 if (ret) {
1165 mlog_errno(ret);
1166 goto bail;
1167 }
1168
50008630
TY		 1169 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_open_lockres, 0, 0);
1170 if (ret) {
1171 mlog_errno(ret);
1172 goto bail;
1173 }
1174
ccd979bd
MF		 1175bail:
1176 mlog_exit(ret);
1177 return ret;
1178}
1179
1180int ocfs2_rw_lock(struct inode *inode, int write)
1181{
1182 int status, level;
1183 struct ocfs2_lock_res *lockres;
c271c5c2 1184 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1185
1186 BUG_ON(!inode);
1187
1188 mlog_entry_void();
1189
b0697053
MF		 1190 mlog(0, "inode %llu take %s RW lock\n",
1191 (unsigned long long)OCFS2_I(inode)->ip_blkno,
ccd979bd
MF		 1192 write ? "EXMODE" : "PRMODE");
1193
c271c5c2
SM		 1194 if (ocfs2_mount_local(osb))
1195 return 0;
1196
ccd979bd
MF		 1197 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1198
1199 level = write ? LKM_EXMODE : LKM_PRMODE;
1200
1201 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres, level, 0,
1202 0);
1203 if (status < 0)
1204 mlog_errno(status);
1205
1206 mlog_exit(status);
1207 return status;
1208}
1209
1210void ocfs2_rw_unlock(struct inode *inode, int write)
1211{
1212 int level = write ? LKM_EXMODE : LKM_PRMODE;
1213 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_rw_lockres;
c271c5c2 1214 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1215
1216 mlog_entry_void();
1217
b0697053
MF		 1218 mlog(0, "inode %llu drop %s RW lock\n",
1219 (unsigned long long)OCFS2_I(inode)->ip_blkno,
ccd979bd
MF		 1220 write ? "EXMODE" : "PRMODE");
1221
c271c5c2
SM		 1222 if (!ocfs2_mount_local(osb))
1223 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
ccd979bd
MF		 1224
1225 mlog_exit_void();
1226}
1227
50008630
TY		 1228/*
1229 * ocfs2_open_lock always get PR mode lock.
1230 */
1231int ocfs2_open_lock(struct inode *inode)
1232{
1233 int status = 0;
1234 struct ocfs2_lock_res *lockres;
1235 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1236
1237 BUG_ON(!inode);
1238
1239 mlog_entry_void();
1240
1241 mlog(0, "inode %llu take PRMODE open lock\n",
1242 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1243
1244 if (ocfs2_mount_local(osb))
1245 goto out;
1246
1247 lockres = &OCFS2_I(inode)->ip_open_lockres;
1248
1249 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres,
1250 LKM_PRMODE, 0, 0);
1251 if (status < 0)
1252 mlog_errno(status);
1253
1254out:
1255 mlog_exit(status);
1256 return status;
1257}
1258
1259int ocfs2_try_open_lock(struct inode *inode, int write)
1260{
1261 int status = 0, level;
1262 struct ocfs2_lock_res *lockres;
1263 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1264
1265 BUG_ON(!inode);
1266
1267 mlog_entry_void();
1268
1269 mlog(0, "inode %llu try to take %s open lock\n",
1270 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1271 write ? "EXMODE" : "PRMODE");
1272
1273 if (ocfs2_mount_local(osb))
1274 goto out;
1275
1276 lockres = &OCFS2_I(inode)->ip_open_lockres;
1277
1278 level = write ? LKM_EXMODE : LKM_PRMODE;
1279
1280 /*
1281 * The file system may already holding a PRMODE/EXMODE open lock.
1282 * Since we pass LKM_NOQUEUE, the request won't block waiting on
1283 * other nodes and the -EAGAIN will indicate to the caller that
1284 * this inode is still in use.
1285 */
1286 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres,
1287 level, LKM_NOQUEUE, 0);
1288
1289out:
1290 mlog_exit(status);
1291 return status;
1292}
1293
1294/*
1295 * ocfs2_open_unlock unlock PR and EX mode open locks.
1296 */
1297void ocfs2_open_unlock(struct inode *inode)
1298{
1299 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_open_lockres;
1300 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1301
1302 mlog_entry_void();
1303
1304 mlog(0, "inode %llu drop open lock\n",
1305 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1306
1307 if (ocfs2_mount_local(osb))
1308 goto out;
1309
1310 if(lockres->l_ro_holders)
1311 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres,
1312 LKM_PRMODE);
1313 if(lockres->l_ex_holders)
1314 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres,
1315 LKM_EXMODE);
1316
1317out:
1318 mlog_exit_void();
1319}
1320
ccd979bd
MF		 1321int ocfs2_data_lock_full(struct inode *inode,
1322 int write,
1323 int arg_flags)
1324{
1325 int status = 0, level;
1326 struct ocfs2_lock_res *lockres;
c271c5c2 1327 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1328
1329 BUG_ON(!inode);
1330
1331 mlog_entry_void();
1332
b0697053
MF		 1333 mlog(0, "inode %llu take %s DATA lock\n",
1334 (unsigned long long)OCFS2_I(inode)->ip_blkno,
ccd979bd
MF		 1335 write ? "EXMODE" : "PRMODE");
1336
1337 /* We'll allow faking a readonly data lock for
1338 * rodevices. */
1339 if (ocfs2_is_hard_readonly(OCFS2_SB(inode->i_sb))) {
1340 if (write) {
1341 status = -EROFS;
1342 mlog_errno(status);
1343 }
1344 goto out;
1345 }
1346
c271c5c2
SM		 1347 if (ocfs2_mount_local(osb))
1348 goto out;
1349
ccd979bd
MF		 1350 lockres = &OCFS2_I(inode)->ip_data_lockres;
1351
1352 level = write ? LKM_EXMODE : LKM_PRMODE;
1353
1354 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres, level,
1355 0, arg_flags);
1356 if (status < 0 && status != -EAGAIN)
1357 mlog_errno(status);
1358
1359out:
1360 mlog_exit(status);
1361 return status;
1362}
1363
1364/* see ocfs2_meta_lock_with_page() */
1365int ocfs2_data_lock_with_page(struct inode *inode,
1366 int write,
1367 struct page *page)
1368{
1369 int ret;
1370
1371 ret = ocfs2_data_lock_full(inode, write, OCFS2_LOCK_NONBLOCK);
1372 if (ret == -EAGAIN) {
1373 unlock_page(page);
1374 if (ocfs2_data_lock(inode, write) == 0)
1375 ocfs2_data_unlock(inode, write);
1376 ret = AOP_TRUNCATED_PAGE;
1377 }
1378
1379 return ret;
1380}
1381
1382static void ocfs2_vote_on_unlock(struct ocfs2_super *osb,
1383 struct ocfs2_lock_res *lockres)
1384{
1385 int kick = 0;
1386
1387 mlog_entry_void();
1388
1389 /* If we know that another node is waiting on our lock, kick
1390 * the vote thread * pre-emptively when we reach a release
1391 * condition. */
1392 if (lockres->l_flags & OCFS2_LOCK_BLOCKED) {
1393 switch(lockres->l_blocking) {
1394 case LKM_EXMODE:
1395 if (!lockres->l_ex_holders && !lockres->l_ro_holders)
1396 kick = 1;
1397 break;
1398 case LKM_PRMODE:
1399 if (!lockres->l_ex_holders)
1400 kick = 1;
1401 break;
1402 default:
1403 BUG();
1404 }
1405 }
1406
1407 if (kick)
1408 ocfs2_kick_vote_thread(osb);
1409
1410 mlog_exit_void();
1411}
1412
1413void ocfs2_data_unlock(struct inode *inode,
1414 int write)
1415{
1416 int level = write ? LKM_EXMODE : LKM_PRMODE;
1417 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_data_lockres;
c271c5c2 1418 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1419
1420 mlog_entry_void();
1421
b0697053
MF		 1422 mlog(0, "inode %llu drop %s DATA lock\n",
1423 (unsigned long long)OCFS2_I(inode)->ip_blkno,
ccd979bd
MF		 1424 write ? "EXMODE" : "PRMODE");
1425
c271c5c2
SM		 1426 if (!ocfs2_is_hard_readonly(OCFS2_SB(inode->i_sb)) &&
1427 !ocfs2_mount_local(osb))
ccd979bd
MF		 1428 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
1429
1430 mlog_exit_void();
1431}
1432
1433#define OCFS2_SEC_BITS 34
1434#define OCFS2_SEC_SHIFT (64 - 34)
1435#define OCFS2_NSEC_MASK ((1ULL << OCFS2_SEC_SHIFT) - 1)
1436
1437/* LVB only has room for 64 bits of time here so we pack it for
1438 * now. */
1439static u64 ocfs2_pack_timespec(struct timespec *spec)
1440{
1441 u64 res;
1442 u64 sec = spec->tv_sec;
1443 u32 nsec = spec->tv_nsec;
1444
1445 res = (sec << OCFS2_SEC_SHIFT) | (nsec & OCFS2_NSEC_MASK);
1446
1447 return res;
1448}
1449
1450/* Call this with the lockres locked. I am reasonably sure we don't
1451 * need ip_lock in this function as anyone who would be changing those
1452 * values is supposed to be blocked in ocfs2_meta_lock right now. */
1453static void __ocfs2_stuff_meta_lvb(struct inode *inode)
1454{
1455 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1456 struct ocfs2_lock_res *lockres = &oi->ip_meta_lockres;
1457 struct ocfs2_meta_lvb *lvb;
1458
1459 mlog_entry_void();
1460
1461 lvb = (struct ocfs2_meta_lvb *) lockres->l_lksb.lvb;
1462
24c19ef4
MF		 1463 /*
1464 * Invalidate the LVB of a deleted inode - this way other
1465 * nodes are forced to go to disk and discover the new inode
1466 * status.
1467 */
1468 if (oi->ip_flags & OCFS2_INODE_DELETED) {
1469 lvb->lvb_version = 0;
1470 goto out;
1471 }
1472
4d3b83f7 1473 lvb->lvb_version = OCFS2_LVB_VERSION;
ccd979bd
MF		 1474 lvb->lvb_isize = cpu_to_be64(i_size_read(inode));
1475 lvb->lvb_iclusters = cpu_to_be32(oi->ip_clusters);
1476 lvb->lvb_iuid = cpu_to_be32(inode->i_uid);
1477 lvb->lvb_igid = cpu_to_be32(inode->i_gid);
1478 lvb->lvb_imode = cpu_to_be16(inode->i_mode);
1479 lvb->lvb_inlink = cpu_to_be16(inode->i_nlink);
1480 lvb->lvb_iatime_packed =
1481 cpu_to_be64(ocfs2_pack_timespec(&inode->i_atime));
1482 lvb->lvb_ictime_packed =
1483 cpu_to_be64(ocfs2_pack_timespec(&inode->i_ctime));
1484 lvb->lvb_imtime_packed =
1485 cpu_to_be64(ocfs2_pack_timespec(&inode->i_mtime));
ca4d147e 1486 lvb->lvb_iattr = cpu_to_be32(oi->ip_attr);
f9e2d82e 1487 lvb->lvb_igeneration = cpu_to_be32(inode->i_generation);
ccd979bd 1488
24c19ef4 1489out:
ccd979bd
MF		 1490 mlog_meta_lvb(0, lockres);
1491
1492 mlog_exit_void();
1493}
1494
1495static void ocfs2_unpack_timespec(struct timespec *spec,
1496 u64 packed_time)
1497{
1498 spec->tv_sec = packed_time >> OCFS2_SEC_SHIFT;
1499 spec->tv_nsec = packed_time & OCFS2_NSEC_MASK;
1500}
1501
1502static void ocfs2_refresh_inode_from_lvb(struct inode *inode)
1503{
1504 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1505 struct ocfs2_lock_res *lockres = &oi->ip_meta_lockres;
1506 struct ocfs2_meta_lvb *lvb;
1507
1508 mlog_entry_void();
1509
1510 mlog_meta_lvb(0, lockres);
1511
1512 lvb = (struct ocfs2_meta_lvb *) lockres->l_lksb.lvb;
1513
1514 /* We're safe here without the lockres lock... */
1515 spin_lock(&oi->ip_lock);
1516 oi->ip_clusters = be32_to_cpu(lvb->lvb_iclusters);
1517 i_size_write(inode, be64_to_cpu(lvb->lvb_isize));
1518
ca4d147e
HP		 1519 oi->ip_attr = be32_to_cpu(lvb->lvb_iattr);
1520 ocfs2_set_inode_flags(inode);
1521
ccd979bd
MF		 1522 /* fast-symlinks are a special case */
1523 if (S_ISLNK(inode->i_mode) && !oi->ip_clusters)
1524 inode->i_blocks = 0;
1525 else
8110b073 1526 inode->i_blocks = ocfs2_inode_sector_count(inode);
ccd979bd
MF		 1527
1528 inode->i_uid = be32_to_cpu(lvb->lvb_iuid);
1529 inode->i_gid = be32_to_cpu(lvb->lvb_igid);
1530 inode->i_mode = be16_to_cpu(lvb->lvb_imode);
1531 inode->i_nlink = be16_to_cpu(lvb->lvb_inlink);
1532 ocfs2_unpack_timespec(&inode->i_atime,
1533 be64_to_cpu(lvb->lvb_iatime_packed));
1534 ocfs2_unpack_timespec(&inode->i_mtime,
1535 be64_to_cpu(lvb->lvb_imtime_packed));
1536 ocfs2_unpack_timespec(&inode->i_ctime,
1537 be64_to_cpu(lvb->lvb_ictime_packed));
1538 spin_unlock(&oi->ip_lock);
1539
1540 mlog_exit_void();
1541}
1542
f9e2d82e
MF		 1543static inline int ocfs2_meta_lvb_is_trustable(struct inode *inode,
1544 struct ocfs2_lock_res *lockres)
ccd979bd
MF		 1545{
1546 struct ocfs2_meta_lvb *lvb = (struct ocfs2_meta_lvb *) lockres->l_lksb.lvb;
1547
f9e2d82e
MF		 1548 if (lvb->lvb_version == OCFS2_LVB_VERSION
1549 && be32_to_cpu(lvb->lvb_igeneration) == inode->i_generation)
ccd979bd
MF		 1550 return 1;
1551 return 0;
1552}
1553
1554/* Determine whether a lock resource needs to be refreshed, and
1555 * arbitrate who gets to refresh it.
1556 *
1557 * 0 means no refresh needed.
1558 *
1559 * > 0 means you need to refresh this and you MUST call
1560 * ocfs2_complete_lock_res_refresh afterwards. */
1561static int ocfs2_should_refresh_lock_res(struct ocfs2_lock_res *lockres)
1562{
1563 unsigned long flags;
1564 int status = 0;
1565
1566 mlog_entry_void();
1567
1568refresh_check:
1569 spin_lock_irqsave(&lockres->l_lock, flags);
1570 if (!(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH)) {
1571 spin_unlock_irqrestore(&lockres->l_lock, flags);
1572 goto bail;
1573 }
1574
1575 if (lockres->l_flags & OCFS2_LOCK_REFRESHING) {
1576 spin_unlock_irqrestore(&lockres->l_lock, flags);
1577
1578 ocfs2_wait_on_refreshing_lock(lockres);
1579 goto refresh_check;
1580 }
1581
1582 /* Ok, I'll be the one to refresh this lock. */
1583 lockres_or_flags(lockres, OCFS2_LOCK_REFRESHING);
1584 spin_unlock_irqrestore(&lockres->l_lock, flags);
1585
1586 status = 1;
1587bail:
1588 mlog_exit(status);
1589 return status;
1590}
1591
1592/* If status is non zero, I'll mark it as not being in refresh
1593 * anymroe, but i won't clear the needs refresh flag. */
1594static inline void ocfs2_complete_lock_res_refresh(struct ocfs2_lock_res *lockres,
1595 int status)
1596{
1597 unsigned long flags;
1598 mlog_entry_void();
1599
1600 spin_lock_irqsave(&lockres->l_lock, flags);
1601 lockres_clear_flags(lockres, OCFS2_LOCK_REFRESHING);
1602 if (!status)
1603 lockres_clear_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
1604 spin_unlock_irqrestore(&lockres->l_lock, flags);
1605
1606 wake_up(&lockres->l_event);
1607
1608 mlog_exit_void();
1609}
1610
1611/* may or may not return a bh if it went to disk. */
1612static int ocfs2_meta_lock_update(struct inode *inode,
1613 struct buffer_head **bh)
1614{
1615 int status = 0;
1616 struct ocfs2_inode_info *oi = OCFS2_I(inode);
be9e986b 1617 struct ocfs2_lock_res *lockres = &oi->ip_meta_lockres;
ccd979bd 1618 struct ocfs2_dinode *fe;
c271c5c2 1619 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1620
1621 mlog_entry_void();
1622
be9e986b
MF		 1623 if (ocfs2_mount_local(osb))
1624 goto bail;
1625
ccd979bd
MF		 1626 spin_lock(&oi->ip_lock);
1627 if (oi->ip_flags & OCFS2_INODE_DELETED) {
b0697053 1628 mlog(0, "Orphaned inode %llu was deleted while we "
ccd979bd 1629 "were waiting on a lock. ip_flags = 0x%x\n",
b0697053 1630 (unsigned long long)oi->ip_blkno, oi->ip_flags);
ccd979bd
MF		 1631 spin_unlock(&oi->ip_lock);
1632 status = -ENOENT;
1633 goto bail;
1634 }
1635 spin_unlock(&oi->ip_lock);
1636
be9e986b
MF		 1637 if (!ocfs2_should_refresh_lock_res(lockres))
1638 goto bail;
ccd979bd
MF		 1639
1640 /* This will discard any caching information we might have had
1641 * for the inode metadata. */
1642 ocfs2_metadata_cache_purge(inode);
1643
83418978
MF		 1644 ocfs2_extent_map_trunc(inode, 0);
1645
be9e986b 1646 if (ocfs2_meta_lvb_is_trustable(inode, lockres)) {
b0697053
MF		 1647 mlog(0, "Trusting LVB on inode %llu\n",
1648 (unsigned long long)oi->ip_blkno);
ccd979bd
MF		 1649 ocfs2_refresh_inode_from_lvb(inode);
1650 } else {
1651 /* Boo, we have to go to disk. */
1652 /* read bh, cast, ocfs2_refresh_inode */
1653 status = ocfs2_read_block(OCFS2_SB(inode->i_sb), oi->ip_blkno,
1654 bh, OCFS2_BH_CACHED, inode);
1655 if (status < 0) {
1656 mlog_errno(status);
1657 goto bail_refresh;
1658 }
1659 fe = (struct ocfs2_dinode *) (*bh)->b_data;
1660
1661 /* This is a good chance to make sure we're not
1662 * locking an invalid object.
1663 *
1664 * We bug on a stale inode here because we checked
1665 * above whether it was wiped from disk. The wiping
1666 * node provides a guarantee that we receive that
1667 * message and can mark the inode before dropping any
1668 * locks associated with it. */
1669 if (!OCFS2_IS_VALID_DINODE(fe)) {
1670 OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
1671 status = -EIO;
1672 goto bail_refresh;
1673 }
1674 mlog_bug_on_msg(inode->i_generation !=
1675 le32_to_cpu(fe->i_generation),
b0697053 1676 "Invalid dinode %llu disk generation: %u "
ccd979bd 1677 "inode->i_generation: %u\n",
b0697053
MF		 1678 (unsigned long long)oi->ip_blkno,
1679 le32_to_cpu(fe->i_generation),
ccd979bd
MF		 1680 inode->i_generation);
1681 mlog_bug_on_msg(le64_to_cpu(fe->i_dtime) ||
1682 !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL)),
b0697053
MF		 1683 "Stale dinode %llu dtime: %llu flags: 0x%x\n",
1684 (unsigned long long)oi->ip_blkno,
1685 (unsigned long long)le64_to_cpu(fe->i_dtime),
ccd979bd
MF		 1686 le32_to_cpu(fe->i_flags));
1687
1688 ocfs2_refresh_inode(inode, fe);
1689 }
1690
1691 status = 0;
1692bail_refresh:
be9e986b 1693 ocfs2_complete_lock_res_refresh(lockres, status);
ccd979bd
MF		 1694bail:
1695 mlog_exit(status);
1696 return status;
1697}
1698
1699static int ocfs2_assign_bh(struct inode *inode,
1700 struct buffer_head **ret_bh,
1701 struct buffer_head *passed_bh)
1702{
1703 int status;
1704
1705 if (passed_bh) {
1706 /* Ok, the update went to disk for us, use the
1707 * returned bh. */
1708 *ret_bh = passed_bh;
1709 get_bh(*ret_bh);
1710
1711 return 0;
1712 }
1713
1714 status = ocfs2_read_block(OCFS2_SB(inode->i_sb),
1715 OCFS2_I(inode)->ip_blkno,
1716 ret_bh,
1717 OCFS2_BH_CACHED,
1718 inode);
1719 if (status < 0)
1720 mlog_errno(status);
1721
1722 return status;
1723}
1724
1725/*
1726 * returns < 0 error if the callback will never be called, otherwise
1727 * the result of the lock will be communicated via the callback.
1728 */
1729int ocfs2_meta_lock_full(struct inode *inode,
ccd979bd
MF		 1730 struct buffer_head **ret_bh,
1731 int ex,
1732 int arg_flags)
1733{
1734 int status, level, dlm_flags, acquired;
c271c5c2 1735 struct ocfs2_lock_res *lockres = NULL;
ccd979bd
MF		 1736 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1737 struct buffer_head *local_bh = NULL;
1738
1739 BUG_ON(!inode);
1740
1741 mlog_entry_void();
1742
b0697053
MF		 1743 mlog(0, "inode %llu, take %s META lock\n",
1744 (unsigned long long)OCFS2_I(inode)->ip_blkno,
ccd979bd
MF		 1745 ex ? "EXMODE" : "PRMODE");
1746
1747 status = 0;
1748 acquired = 0;
1749 /* We'll allow faking a readonly metadata lock for
1750 * rodevices. */
1751 if (ocfs2_is_hard_readonly(osb)) {
1752 if (ex)
1753 status = -EROFS;
1754 goto bail;
1755 }
1756
c271c5c2
SM		 1757 if (ocfs2_mount_local(osb))
1758 goto local;
1759
ccd979bd
MF		 1760 if (!(arg_flags & OCFS2_META_LOCK_RECOVERY))
1761 wait_event(osb->recovery_event,
1762 ocfs2_node_map_is_empty(osb, &osb->recovery_map));
1763
ccd979bd
MF		 1764 lockres = &OCFS2_I(inode)->ip_meta_lockres;
1765 level = ex ? LKM_EXMODE : LKM_PRMODE;
1766 dlm_flags = 0;
1767 if (arg_flags & OCFS2_META_LOCK_NOQUEUE)
1768 dlm_flags |= LKM_NOQUEUE;
1769
1770 status = ocfs2_cluster_lock(osb, lockres, level, dlm_flags, arg_flags);
1771 if (status < 0) {
1772 if (status != -EAGAIN && status != -EIOCBRETRY)
1773 mlog_errno(status);
1774 goto bail;
1775 }
1776
1777 /* Notify the error cleanup path to drop the cluster lock. */
1778 acquired = 1;
1779
1780 /* We wait twice because a node may have died while we were in
1781 * the lower dlm layers. The second time though, we've
1782 * committed to owning this lock so we don't allow signals to
1783 * abort the operation. */
1784 if (!(arg_flags & OCFS2_META_LOCK_RECOVERY))
1785 wait_event(osb->recovery_event,
1786 ocfs2_node_map_is_empty(osb, &osb->recovery_map));
1787
c271c5c2 1788local:
24c19ef4
MF		 1789 /*
1790 * We only see this flag if we're being called from
1791 * ocfs2_read_locked_inode(). It means we're locking an inode
1792 * which hasn't been populated yet, so clear the refresh flag
1793 * and let the caller handle it.
1794 */
1795 if (inode->i_state & I_NEW) {
1796 status = 0;
c271c5c2
SM		 1797 if (lockres)
1798 ocfs2_complete_lock_res_refresh(lockres, 0);
24c19ef4
MF		 1799 goto bail;
1800 }
1801
ccd979bd
MF		 1802 /* This is fun. The caller may want a bh back, or it may
1803 * not. ocfs2_meta_lock_update definitely wants one in, but
1804 * may or may not read one, depending on what's in the
1805 * LVB. The result of all of this is that we've *only* gone to
1806 * disk if we have to, so the complexity is worthwhile. */
1807 status = ocfs2_meta_lock_update(inode, &local_bh);
1808 if (status < 0) {
1809 if (status != -ENOENT)
1810 mlog_errno(status);
1811 goto bail;
1812 }
1813
1814 if (ret_bh) {
1815 status = ocfs2_assign_bh(inode, ret_bh, local_bh);
1816 if (status < 0) {
1817 mlog_errno(status);
1818 goto bail;
1819 }
1820 }
1821
ccd979bd
MF		 1822bail:
1823 if (status < 0) {
1824 if (ret_bh && (*ret_bh)) {
1825 brelse(*ret_bh);
1826 *ret_bh = NULL;
1827 }
1828 if (acquired)
1829 ocfs2_meta_unlock(inode, ex);
1830 }
1831
1832 if (local_bh)
1833 brelse(local_bh);
1834
1835 mlog_exit(status);
1836 return status;
1837}
1838
1839/*
1840 * This is working around a lock inversion between tasks acquiring DLM locks
1841 * while holding a page lock and the vote thread which blocks dlm lock acquiry
1842 * while acquiring page locks.
1843 *
1844 * ** These _with_page variantes are only intended to be called from aop
1845 * methods that hold page locks and return a very specific *positive* error
1846 * code that aop methods pass up to the VFS -- test for errors with != 0. **
1847 *
1848 * The DLM is called such that it returns -EAGAIN if it would have blocked
1849 * waiting for the vote thread. In that case we unlock our page so the vote
1850 * thread can make progress. Once we've done this we have to return
1851 * AOP_TRUNCATED_PAGE so the aop method that called us can bubble that back up
1852 * into the VFS who will then immediately retry the aop call.
1853 *
1854 * We do a blocking lock and immediate unlock before returning, though, so that
1855 * the lock has a great chance of being cached on this node by the time the VFS
1856 * calls back to retry the aop. This has a potential to livelock as nodes
1857 * ping locks back and forth, but that's a risk we're willing to take to avoid
1858 * the lock inversion simply.
1859 */
1860int ocfs2_meta_lock_with_page(struct inode *inode,
ccd979bd
MF		 1861 struct buffer_head **ret_bh,
1862 int ex,
1863 struct page *page)
1864{
1865 int ret;
1866
4bcec184 1867 ret = ocfs2_meta_lock_full(inode, ret_bh, ex, OCFS2_LOCK_NONBLOCK);
ccd979bd
MF		 1868 if (ret == -EAGAIN) {
1869 unlock_page(page);
4bcec184 1870 if (ocfs2_meta_lock(inode, ret_bh, ex) == 0)
ccd979bd
MF		 1871 ocfs2_meta_unlock(inode, ex);
1872 ret = AOP_TRUNCATED_PAGE;
1873 }
1874
1875 return ret;
1876}
1877
7f1a37e3
TY		 1878int ocfs2_meta_lock_atime(struct inode *inode,
1879 struct vfsmount *vfsmnt,
1880 int *level)
1881{
1882 int ret;
1883
1884 mlog_entry_void();
1885 ret = ocfs2_meta_lock(inode, NULL, 0);
1886 if (ret < 0) {
1887 mlog_errno(ret);
1888 return ret;
1889 }
1890
1891 /*
1892 * If we should update atime, we will get EX lock,
1893 * otherwise we just get PR lock.
1894 */
1895 if (ocfs2_should_update_atime(inode, vfsmnt)) {
1896 struct buffer_head *bh = NULL;
1897
1898 ocfs2_meta_unlock(inode, 0);
1899 ret = ocfs2_meta_lock(inode, &bh, 1);
1900 if (ret < 0) {
1901 mlog_errno(ret);
1902 return ret;
1903 }
1904 *level = 1;
1905 if (ocfs2_should_update_atime(inode, vfsmnt))
1906 ocfs2_update_inode_atime(inode, bh);
1907 if (bh)
1908 brelse(bh);
1909 } else
1910 *level = 0;
1911
1912 mlog_exit(ret);
1913 return ret;
1914}
1915
ccd979bd
MF		 1916void ocfs2_meta_unlock(struct inode *inode,
1917 int ex)
1918{
1919 int level = ex ? LKM_EXMODE : LKM_PRMODE;
1920 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_meta_lockres;
c271c5c2 1921 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
ccd979bd
MF		 1922
1923 mlog_entry_void();
1924
b0697053
MF		 1925 mlog(0, "inode %llu drop %s META lock\n",
1926 (unsigned long long)OCFS2_I(inode)->ip_blkno,
ccd979bd
MF		 1927 ex ? "EXMODE" : "PRMODE");
1928
c271c5c2
SM		 1929 if (!ocfs2_is_hard_readonly(OCFS2_SB(inode->i_sb)) &&
1930 !ocfs2_mount_local(osb))
ccd979bd
MF		 1931 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
1932
1933 mlog_exit_void();
1934}
1935
1936int ocfs2_super_lock(struct ocfs2_super *osb,
1937 int ex)
1938{
c271c5c2 1939 int status = 0;
ccd979bd
MF		 1940 int level = ex ? LKM_EXMODE : LKM_PRMODE;
1941 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
1942 struct buffer_head *bh;
1943 struct ocfs2_slot_info *si = osb->slot_info;
1944
1945 mlog_entry_void();
1946
1947 if (ocfs2_is_hard_readonly(osb))
1948 return -EROFS;
1949
c271c5c2
SM		 1950 if (ocfs2_mount_local(osb))
1951 goto bail;
1952
ccd979bd
MF		 1953 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
1954 if (status < 0) {
1955 mlog_errno(status);
1956 goto bail;
1957 }
1958
1959 /* The super block lock path is really in the best position to
1960 * know when resources covered by the lock need to be
1961 * refreshed, so we do it here. Of course, making sense of
1962 * everything is up to the caller :) */
1963 status = ocfs2_should_refresh_lock_res(lockres);
1964 if (status < 0) {
1965 mlog_errno(status);
1966 goto bail;
1967 }
1968 if (status) {
1969 bh = si->si_bh;
1970 status = ocfs2_read_block(osb, bh->b_blocknr, &bh, 0,
1971 si->si_inode);
1972 if (status == 0)
1973 ocfs2_update_slot_info(si);
1974
1975 ocfs2_complete_lock_res_refresh(lockres, status);
1976
1977 if (status < 0)
1978 mlog_errno(status);
1979 }
1980bail:
1981 mlog_exit(status);
1982 return status;
1983}
1984
1985void ocfs2_super_unlock(struct ocfs2_super *osb,
1986 int ex)
1987{
1988 int level = ex ? LKM_EXMODE : LKM_PRMODE;
1989 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
1990
c271c5c2
SM		 1991 if (!ocfs2_mount_local(osb))
1992 ocfs2_cluster_unlock(osb, lockres, level);
ccd979bd
MF		 1993}
1994
1995int ocfs2_rename_lock(struct ocfs2_super *osb)
1996{
1997 int status;
1998 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
1999
2000 if (ocfs2_is_hard_readonly(osb))
2001 return -EROFS;
2002
c271c5c2
SM		 2003 if (ocfs2_mount_local(osb))
2004 return 0;
2005
ccd979bd
MF		 2006 status = ocfs2_cluster_lock(osb, lockres, LKM_EXMODE, 0, 0);
2007 if (status < 0)
2008 mlog_errno(status);
2009
2010 return status;
2011}
2012
2013void ocfs2_rename_unlock(struct ocfs2_super *osb)
2014{
2015 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2016
c271c5c2
SM		 2017 if (!ocfs2_mount_local(osb))
2018 ocfs2_cluster_unlock(osb, lockres, LKM_EXMODE);
ccd979bd
MF		 2019}
2020
d680efe9
MF		 2021int ocfs2_dentry_lock(struct dentry *dentry, int ex)
2022{
2023 int ret;
2024 int level = ex ? LKM_EXMODE : LKM_PRMODE;
2025 struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
2026 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
2027
2028 BUG_ON(!dl);
2029
2030 if (ocfs2_is_hard_readonly(osb))
2031 return -EROFS;
2032
c271c5c2
SM		 2033 if (ocfs2_mount_local(osb))
2034 return 0;
2035
d680efe9
MF		 2036 ret = ocfs2_cluster_lock(osb, &dl->dl_lockres, level, 0, 0);
2037 if (ret < 0)
2038 mlog_errno(ret);
2039
2040 return ret;
2041}
2042
2043void ocfs2_dentry_unlock(struct dentry *dentry, int ex)
2044{
2045 int level = ex ? LKM_EXMODE : LKM_PRMODE;
2046 struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
2047 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
2048
c271c5c2
SM		 2049 if (!ocfs2_mount_local(osb))
2050 ocfs2_cluster_unlock(osb, &dl->dl_lockres, level);
d680efe9
MF		 2051}
2052
ccd979bd
MF		 2053/* Reference counting of the dlm debug structure. We want this because
2054 * open references on the debug inodes can live on after a mount, so
2055 * we can't rely on the ocfs2_super to always exist. */
2056static void ocfs2_dlm_debug_free(struct kref *kref)
2057{
2058 struct ocfs2_dlm_debug *dlm_debug;
2059
2060 dlm_debug = container_of(kref, struct ocfs2_dlm_debug, d_refcnt);
2061
2062 kfree(dlm_debug);
2063}
2064
2065void ocfs2_put_dlm_debug(struct ocfs2_dlm_debug *dlm_debug)
2066{
2067 if (dlm_debug)
2068 kref_put(&dlm_debug->d_refcnt, ocfs2_dlm_debug_free);
2069}
2070
2071static void ocfs2_get_dlm_debug(struct ocfs2_dlm_debug *debug)
2072{
2073 kref_get(&debug->d_refcnt);
2074}
2075
2076struct ocfs2_dlm_debug *ocfs2_new_dlm_debug(void)
2077{
2078 struct ocfs2_dlm_debug *dlm_debug;
2079
2080 dlm_debug = kmalloc(sizeof(struct ocfs2_dlm_debug), GFP_KERNEL);
2081 if (!dlm_debug) {
2082 mlog_errno(-ENOMEM);
2083 goto out;
2084 }
2085
2086 kref_init(&dlm_debug->d_refcnt);
2087 INIT_LIST_HEAD(&dlm_debug->d_lockres_tracking);
2088 dlm_debug->d_locking_state = NULL;
2089out:
2090 return dlm_debug;
2091}
2092
2093/* Access to this is arbitrated for us via seq_file->sem. */
2094struct ocfs2_dlm_seq_priv {
2095 struct ocfs2_dlm_debug *p_dlm_debug;
2096 struct ocfs2_lock_res p_iter_res;
2097 struct ocfs2_lock_res p_tmp_res;
2098};
2099
2100static struct ocfs2_lock_res *ocfs2_dlm_next_res(struct ocfs2_lock_res *start,
2101 struct ocfs2_dlm_seq_priv *priv)
2102{
2103 struct ocfs2_lock_res *iter, *ret = NULL;
2104 struct ocfs2_dlm_debug *dlm_debug = priv->p_dlm_debug;
2105
2106 assert_spin_locked(&ocfs2_dlm_tracking_lock);
2107
2108 list_for_each_entry(iter, &start->l_debug_list, l_debug_list) {
2109 /* discover the head of the list */
2110 if (&iter->l_debug_list == &dlm_debug->d_lockres_tracking) {
2111 mlog(0, "End of list found, %p\n", ret);
2112 break;
2113 }
2114
2115 /* We track our "dummy" iteration lockres' by a NULL
2116 * l_ops field. */
2117 if (iter->l_ops != NULL) {
2118 ret = iter;
2119 break;
2120 }
2121 }
2122
2123 return ret;
2124}
2125
2126static void *ocfs2_dlm_seq_start(struct seq_file *m, loff_t *pos)
2127{
2128 struct ocfs2_dlm_seq_priv *priv = m->private;
2129 struct ocfs2_lock_res *iter;
2130
2131 spin_lock(&ocfs2_dlm_tracking_lock);
2132 iter = ocfs2_dlm_next_res(&priv->p_iter_res, priv);
2133 if (iter) {
2134 /* Since lockres' have the lifetime of their container
2135 * (which can be inodes, ocfs2_supers, etc) we want to
2136 * copy this out to a temporary lockres while still
2137 * under the spinlock. Obviously after this we can't
2138 * trust any pointers on the copy returned, but that's
2139 * ok as the information we want isn't typically held
2140 * in them. */
2141 priv->p_tmp_res = *iter;
2142 iter = &priv->p_tmp_res;
2143 }
2144 spin_unlock(&ocfs2_dlm_tracking_lock);
2145
2146 return iter;
2147}
2148
2149static void ocfs2_dlm_seq_stop(struct seq_file *m, void *v)
2150{
2151}
2152
2153static void *ocfs2_dlm_seq_next(struct seq_file *m, void *v, loff_t *pos)
2154{
2155 struct ocfs2_dlm_seq_priv *priv = m->private;
2156 struct ocfs2_lock_res *iter = v;
2157 struct ocfs2_lock_res *dummy = &priv->p_iter_res;
2158
2159 spin_lock(&ocfs2_dlm_tracking_lock);
2160 iter = ocfs2_dlm_next_res(iter, priv);
2161 list_del_init(&dummy->l_debug_list);
2162 if (iter) {
2163 list_add(&dummy->l_debug_list, &iter->l_debug_list);
2164 priv->p_tmp_res = *iter;
2165 iter = &priv->p_tmp_res;
2166 }
2167 spin_unlock(&ocfs2_dlm_tracking_lock);
2168
2169 return iter;
2170}
2171
2172/* So that debugfs.ocfs2 can determine which format is being used */
2173#define OCFS2_DLM_DEBUG_STR_VERSION 1
2174static int ocfs2_dlm_seq_show(struct seq_file *m, void *v)
2175{
2176 int i;
2177 char *lvb;
2178 struct ocfs2_lock_res *lockres = v;
2179
2180 if (!lockres)
2181 return -EINVAL;
2182
d680efe9
MF		 2183 seq_printf(m, "0x%x\t", OCFS2_DLM_DEBUG_STR_VERSION);
2184
2185 if (lockres->l_type == OCFS2_LOCK_TYPE_DENTRY)
2186 seq_printf(m, "%.*s%08x\t", OCFS2_DENTRY_LOCK_INO_START - 1,
2187 lockres->l_name,
2188 (unsigned int)ocfs2_get_dentry_lock_ino(lockres));
2189 else
2190 seq_printf(m, "%.*s\t", OCFS2_LOCK_ID_MAX_LEN, lockres->l_name);
2191
2192 seq_printf(m, "%d\t"
ccd979bd
MF		 2193 "0x%lx\t"
2194 "0x%x\t"
2195 "0x%x\t"
2196 "%u\t"
2197 "%u\t"
2198 "%d\t"
2199 "%d\t",
ccd979bd
MF		 2200 lockres->l_level,
2201 lockres->l_flags,
2202 lockres->l_action,
2203 lockres->l_unlock_action,
2204 lockres->l_ro_holders,
2205 lockres->l_ex_holders,
2206 lockres->l_requested,
2207 lockres->l_blocking);
2208
2209 /* Dump the raw LVB */
2210 lvb = lockres->l_lksb.lvb;
2211 for(i = 0; i < DLM_LVB_LEN; i++)
2212 seq_printf(m, "0x%x\t", lvb[i]);
2213
2214 /* End the line */
2215 seq_printf(m, "\n");
2216 return 0;
2217}
2218
2219static struct seq_operations ocfs2_dlm_seq_ops = {
2220 .start = ocfs2_dlm_seq_start,
2221 .stop = ocfs2_dlm_seq_stop,
2222 .next = ocfs2_dlm_seq_next,
2223 .show = ocfs2_dlm_seq_show,
2224};
2225
2226static int ocfs2_dlm_debug_release(struct inode *inode, struct file *file)
2227{
2228 struct seq_file *seq = (struct seq_file *) file->private_data;
2229 struct ocfs2_dlm_seq_priv *priv = seq->private;
2230 struct ocfs2_lock_res *res = &priv->p_iter_res;
2231
2232 ocfs2_remove_lockres_tracking(res);
2233 ocfs2_put_dlm_debug(priv->p_dlm_debug);
2234 return seq_release_private(inode, file);
2235}
2236
2237static int ocfs2_dlm_debug_open(struct inode *inode, struct file *file)
2238{
2239 int ret;
2240 struct ocfs2_dlm_seq_priv *priv;
2241 struct seq_file *seq;
2242 struct ocfs2_super *osb;
2243
2244 priv = kzalloc(sizeof(struct ocfs2_dlm_seq_priv), GFP_KERNEL);
2245 if (!priv) {
2246 ret = -ENOMEM;
2247 mlog_errno(ret);
2248 goto out;
2249 }
8e18e294 2250 osb = inode->i_private;
ccd979bd
MF		 2251 ocfs2_get_dlm_debug(osb->osb_dlm_debug);
2252 priv->p_dlm_debug = osb->osb_dlm_debug;
2253 INIT_LIST_HEAD(&priv->p_iter_res.l_debug_list);
2254
2255 ret = seq_open(file, &ocfs2_dlm_seq_ops);
2256 if (ret) {
2257 kfree(priv);
2258 mlog_errno(ret);
2259 goto out;
2260 }
2261
2262 seq = (struct seq_file *) file->private_data;
2263 seq->private = priv;
2264
2265 ocfs2_add_lockres_tracking(&priv->p_iter_res,
2266 priv->p_dlm_debug);
2267
2268out:
2269 return ret;
2270}
2271
4b6f5d20 2272static const struct file_operations ocfs2_dlm_debug_fops = {
ccd979bd
MF		 2273 .open = ocfs2_dlm_debug_open,
2274 .release = ocfs2_dlm_debug_release,
2275 .read = seq_read,
2276 .llseek = seq_lseek,
2277};
2278
2279static int ocfs2_dlm_init_debug(struct ocfs2_super *osb)
2280{
2281 int ret = 0;
2282 struct ocfs2_dlm_debug *dlm_debug = osb->osb_dlm_debug;
2283
2284 dlm_debug->d_locking_state = debugfs_create_file("locking_state",
2285 S_IFREG|S_IRUSR,
2286 osb->osb_debug_root,
2287 osb,
2288 &ocfs2_dlm_debug_fops);
2289 if (!dlm_debug->d_locking_state) {
2290 ret = -EINVAL;
2291 mlog(ML_ERROR,
2292 "Unable to create locking state debugfs file.\n");
2293 goto out;
2294 }
2295
2296 ocfs2_get_dlm_debug(dlm_debug);
2297out:
2298 return ret;
2299}
2300
2301static void ocfs2_dlm_shutdown_debug(struct ocfs2_super *osb)
2302{
2303 struct ocfs2_dlm_debug *dlm_debug = osb->osb_dlm_debug;
2304
2305 if (dlm_debug) {
2306 debugfs_remove(dlm_debug->d_locking_state);
2307 ocfs2_put_dlm_debug(dlm_debug);
2308 }
2309}
2310
2311int ocfs2_dlm_init(struct ocfs2_super *osb)
2312{
c271c5c2 2313 int status = 0;
ccd979bd 2314 u32 dlm_key;
c271c5c2 2315 struct dlm_ctxt *dlm = NULL;
ccd979bd
MF		 2316
2317 mlog_entry_void();
2318
c271c5c2
SM		 2319 if (ocfs2_mount_local(osb))
2320 goto local;
2321
ccd979bd
MF		 2322 status = ocfs2_dlm_init_debug(osb);
2323 if (status < 0) {
2324 mlog_errno(status);
2325 goto bail;
2326 }
2327
2328 /* launch vote thread */
78427043 2329 osb->vote_task = kthread_run(ocfs2_vote_thread, osb, "ocfs2vote");
ccd979bd
MF		 2330 if (IS_ERR(osb->vote_task)) {
2331 status = PTR_ERR(osb->vote_task);
2332 osb->vote_task = NULL;
2333 mlog_errno(status);
2334 goto bail;
2335 }
2336
2337 /* used by the dlm code to make message headers unique, each
2338 * node in this domain must agree on this. */
2339 dlm_key = crc32_le(0, osb->uuid_str, strlen(osb->uuid_str));
2340
2341 /* for now, uuid == domain */
2342 dlm = dlm_register_domain(osb->uuid_str, dlm_key);
2343 if (IS_ERR(dlm)) {
2344 status = PTR_ERR(dlm);
2345 mlog_errno(status);
2346 goto bail;
2347 }
2348
c271c5c2
SM		 2349 dlm_register_eviction_cb(dlm, &osb->osb_eviction_cb);
2350
2351local:
ccd979bd
MF		 2352 ocfs2_super_lock_res_init(&osb->osb_super_lockres, osb);
2353 ocfs2_rename_lock_res_init(&osb->osb_rename_lockres, osb);
2354
ccd979bd
MF		 2355 osb->dlm = dlm;
2356
2357 status = 0;
2358bail:
2359 if (status < 0) {
2360 ocfs2_dlm_shutdown_debug(osb);
2361 if (osb->vote_task)
2362 kthread_stop(osb->vote_task);
2363 }
2364
2365 mlog_exit(status);
2366 return status;
2367}
2368
2369void ocfs2_dlm_shutdown(struct ocfs2_super *osb)
2370{
2371 mlog_entry_void();
2372
2373 dlm_unregister_eviction_cb(&osb->osb_eviction_cb);
2374
2375 ocfs2_drop_osb_locks(osb);
2376
2377 if (osb->vote_task) {
2378 kthread_stop(osb->vote_task);
2379 osb->vote_task = NULL;
2380 }
2381
2382 ocfs2_lock_res_free(&osb->osb_super_lockres);
2383 ocfs2_lock_res_free(&osb->osb_rename_lockres);
2384
2385 dlm_unregister_domain(osb->dlm);
2386 osb->dlm = NULL;
2387
2388 ocfs2_dlm_shutdown_debug(osb);
2389
2390 mlog_exit_void();
2391}
2392
2a45f2d1 2393static void ocfs2_unlock_ast(void *opaque, enum dlm_status status)
ccd979bd
MF		 2394{
2395 struct ocfs2_lock_res *lockres = opaque;
2396 unsigned long flags;
2397
2398 mlog_entry_void();
2399
2400 mlog(0, "UNLOCK AST called on lock %s, action = %d\n", lockres->l_name,
2401 lockres->l_unlock_action);
2402
2403 spin_lock_irqsave(&lockres->l_lock, flags);
2404 /* We tried to cancel a convert request, but it was already
2405 * granted. All we want to do here is clear our unlock
2406 * state. The wake_up call done at the bottom is redundant
2407 * (ocfs2_prepare_cancel_convert doesn't sleep on this) but doesn't
2408 * hurt anything anyway */
2409 if (status == DLM_CANCELGRANT &&
2410 lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
2411 mlog(0, "Got cancelgrant for %s\n", lockres->l_name);
2412
2413 /* We don't clear the busy flag in this case as it
2414 * should have been cleared by the ast which the dlm
2415 * has called. */
2416 goto complete_unlock;
2417 }
2418
2419 if (status != DLM_NORMAL) {
2420 mlog(ML_ERROR, "Dlm passes status %d for lock %s, "
2421 "unlock_action %d\n", status, lockres->l_name,
2422 lockres->l_unlock_action);
2423 spin_unlock_irqrestore(&lockres->l_lock, flags);
2424 return;
2425 }
2426
2427 switch(lockres->l_unlock_action) {
2428 case OCFS2_UNLOCK_CANCEL_CONVERT:
2429 mlog(0, "Cancel convert success for %s\n", lockres->l_name);
2430 lockres->l_action = OCFS2_AST_INVALID;
2431 break;
2432 case OCFS2_UNLOCK_DROP_LOCK:
2433 lockres->l_level = LKM_IVMODE;
2434 break;
2435 default:
2436 BUG();
2437 }
2438
2439 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
2440complete_unlock:
2441 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
2442 spin_unlock_irqrestore(&lockres->l_lock, flags);
2443
2444 wake_up(&lockres->l_event);
2445
2446 mlog_exit_void();
2447}
2448
ccd979bd 2449static int ocfs2_drop_lock(struct ocfs2_super *osb,
0d5dc6c2 2450 struct ocfs2_lock_res *lockres)
ccd979bd
MF		 2451{
2452 enum dlm_status status;
2453 unsigned long flags;
b80fc012 2454 int lkm_flags = 0;
ccd979bd
MF		 2455
2456 /* We didn't get anywhere near actually using this lockres. */
2457 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED))
2458 goto out;
2459
b80fc012
MF		 2460 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
2461 lkm_flags |= LKM_VALBLK;
2462
ccd979bd
MF		 2463 spin_lock_irqsave(&lockres->l_lock, flags);
2464
2465 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_FREEING),
2466 "lockres %s, flags 0x%lx\n",
2467 lockres->l_name, lockres->l_flags);
2468
2469 while (lockres->l_flags & OCFS2_LOCK_BUSY) {
2470 mlog(0, "waiting on busy lock \"%s\": flags = %lx, action = "
2471 "%u, unlock_action = %u\n",
2472 lockres->l_name, lockres->l_flags, lockres->l_action,
2473 lockres->l_unlock_action);
2474
2475 spin_unlock_irqrestore(&lockres->l_lock, flags);
2476
2477 /* XXX: Today we just wait on any busy
2478 * locks... Perhaps we need to cancel converts in the
2479 * future? */
2480 ocfs2_wait_on_busy_lock(lockres);
2481
2482 spin_lock_irqsave(&lockres->l_lock, flags);
2483 }
2484
0d5dc6c2
MF		 2485 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
2486 if (lockres->l_flags & OCFS2_LOCK_ATTACHED &&
2487 lockres->l_level == LKM_EXMODE &&
2488 !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
2489 lockres->l_ops->set_lvb(lockres);
2490 }
ccd979bd
MF		 2491
2492 if (lockres->l_flags & OCFS2_LOCK_BUSY)
2493 mlog(ML_ERROR, "destroying busy lock: \"%s\"\n",
2494 lockres->l_name);
2495 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
2496 mlog(0, "destroying blocked lock: \"%s\"\n", lockres->l_name);
2497
2498 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
2499 spin_unlock_irqrestore(&lockres->l_lock, flags);
2500 goto out;
2501 }
2502
2503 lockres_clear_flags(lockres, OCFS2_LOCK_ATTACHED);
2504
2505 /* make sure we never get here while waiting for an ast to
2506 * fire. */
2507 BUG_ON(lockres->l_action != OCFS2_AST_INVALID);
2508
2509 /* is this necessary? */
2510 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
2511 lockres->l_unlock_action = OCFS2_UNLOCK_DROP_LOCK;
2512 spin_unlock_irqrestore(&lockres->l_lock, flags);
2513
2514 mlog(0, "lock %s\n", lockres->l_name);
2515
b80fc012 2516 status = dlmunlock(osb->dlm, &lockres->l_lksb, lkm_flags,
2a45f2d1 2517 ocfs2_unlock_ast, lockres);
ccd979bd
MF		 2518 if (status != DLM_NORMAL) {
2519 ocfs2_log_dlm_error("dlmunlock", status, lockres);
2520 mlog(ML_ERROR, "lockres flags: %lu\n", lockres->l_flags);
2521 dlm_print_one_lock(lockres->l_lksb.lockid);
2522 BUG();
2523 }
2524 mlog(0, "lock %s, successfull return from dlmunlock\n",
2525 lockres->l_name);
2526
2527 ocfs2_wait_on_busy_lock(lockres);
2528out:
2529 mlog_exit(0);
2530 return 0;
2531}
2532
2533/* Mark the lockres as being dropped. It will no longer be
2534 * queued if blocking, but we still may have to wait on it
2535 * being dequeued from the vote thread before we can consider
2536 * it safe to drop.
2537 *
2538 * You can *not* attempt to call cluster_lock on this lockres anymore. */
2539void ocfs2_mark_lockres_freeing(struct ocfs2_lock_res *lockres)
2540{
2541 int status;
2542 struct ocfs2_mask_waiter mw;
2543 unsigned long flags;
2544
2545 ocfs2_init_mask_waiter(&mw);
2546
2547 spin_lock_irqsave(&lockres->l_lock, flags);
2548 lockres->l_flags |= OCFS2_LOCK_FREEING;
2549 while (lockres->l_flags & OCFS2_LOCK_QUEUED) {
2550 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_QUEUED, 0);
2551 spin_unlock_irqrestore(&lockres->l_lock, flags);
2552
2553 mlog(0, "Waiting on lockres %s\n", lockres->l_name);
2554
2555 status = ocfs2_wait_for_mask(&mw);
2556 if (status)
2557 mlog_errno(status);
2558
2559 spin_lock_irqsave(&lockres->l_lock, flags);
2560 }
2561 spin_unlock_irqrestore(&lockres->l_lock, flags);
2562}
2563
d680efe9
MF		 2564void ocfs2_simple_drop_lockres(struct ocfs2_super *osb,
2565 struct ocfs2_lock_res *lockres)
ccd979bd 2566{
d680efe9 2567 int ret;
ccd979bd 2568
d680efe9 2569 ocfs2_mark_lockres_freeing(lockres);
0d5dc6c2 2570 ret = ocfs2_drop_lock(osb, lockres);
d680efe9
MF		 2571 if (ret)
2572 mlog_errno(ret);
2573}
ccd979bd 2574
d680efe9
MF		 2575static void ocfs2_drop_osb_locks(struct ocfs2_super *osb)
2576{
2577 ocfs2_simple_drop_lockres(osb, &osb->osb_super_lockres);
2578 ocfs2_simple_drop_lockres(osb, &osb->osb_rename_lockres);
ccd979bd
MF		 2579}
2580
ccd979bd
MF		 2581int ocfs2_drop_inode_locks(struct inode *inode)
2582{
2583 int status, err;
ccd979bd
MF		 2584
2585 mlog_entry_void();
2586
2587 /* No need to call ocfs2_mark_lockres_freeing here -
2588 * ocfs2_clear_inode has done it for us. */
2589
2590 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
50008630 2591 &OCFS2_I(inode)->ip_open_lockres);
ccd979bd
MF		 2592 if (err < 0)
2593 mlog_errno(err);
2594
2595 status = err;
2596
50008630
TY		 2597 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
2598 &OCFS2_I(inode)->ip_data_lockres);
2599 if (err < 0)
2600 mlog_errno(err);
2601 if (err < 0 && !status)
2602 status = err;
2603
ccd979bd 2604 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
0d5dc6c2 2605 &OCFS2_I(inode)->ip_meta_lockres);
ccd979bd
MF		 2606 if (err < 0)
2607 mlog_errno(err);
2608 if (err < 0 && !status)
2609 status = err;
2610
2611 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
0d5dc6c2 2612 &OCFS2_I(inode)->ip_rw_lockres);
ccd979bd
MF		 2613 if (err < 0)
2614 mlog_errno(err);
2615 if (err < 0 && !status)
2616 status = err;
2617
2618 mlog_exit(status);
2619 return status;
2620}
2621
2622static void ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
2623 int new_level)
2624{
2625 assert_spin_locked(&lockres->l_lock);
2626
2627 BUG_ON(lockres->l_blocking <= LKM_NLMODE);
2628
2629 if (lockres->l_level <= new_level) {
2630 mlog(ML_ERROR, "lockres->l_level (%u) <= new_level (%u)\n",
2631 lockres->l_level, new_level);
2632 BUG();
2633 }
2634
2635 mlog(0, "lock %s, new_level = %d, l_blocking = %d\n",
2636 lockres->l_name, new_level, lockres->l_blocking);
2637
2638 lockres->l_action = OCFS2_AST_DOWNCONVERT;
2639 lockres->l_requested = new_level;
2640 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
2641}
2642
2643static int ocfs2_downconvert_lock(struct ocfs2_super *osb,
2644 struct ocfs2_lock_res *lockres,
2645 int new_level,
2646 int lvb)
2647{
2648 int ret, dlm_flags = LKM_CONVERT;
2649 enum dlm_status status;
2650
2651 mlog_entry_void();
2652
2653 if (lvb)
2654 dlm_flags |= LKM_VALBLK;
2655
2656 status = dlmlock(osb->dlm,
2657 new_level,
2658 &lockres->l_lksb,
2659 dlm_flags,
2660 lockres->l_name,
f0681062 2661 OCFS2_LOCK_ID_MAX_LEN - 1,
e92d57df 2662 ocfs2_locking_ast,
ccd979bd 2663 lockres,
aa2623ad 2664 ocfs2_blocking_ast);
ccd979bd
MF		 2665 if (status != DLM_NORMAL) {
2666 ocfs2_log_dlm_error("dlmlock", status, lockres);
2667 ret = -EINVAL;
2668 ocfs2_recover_from_dlm_error(lockres, 1);
2669 goto bail;
2670 }
2671
2672 ret = 0;
2673bail:
2674 mlog_exit(ret);
2675 return ret;
2676}
2677
2678/* returns 1 when the caller should unlock and call dlmunlock */
2679static int ocfs2_prepare_cancel_convert(struct ocfs2_super *osb,
2680 struct ocfs2_lock_res *lockres)
2681{
2682 assert_spin_locked(&lockres->l_lock);
2683
2684 mlog_entry_void();
2685 mlog(0, "lock %s\n", lockres->l_name);
2686
2687 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
2688 /* If we're already trying to cancel a lock conversion
2689 * then just drop the spinlock and allow the caller to
2690 * requeue this lock. */
2691
2692 mlog(0, "Lockres %s, skip convert\n", lockres->l_name);
2693 return 0;
2694 }
2695
2696 /* were we in a convert when we got the bast fire? */
2697 BUG_ON(lockres->l_action != OCFS2_AST_CONVERT &&
2698 lockres->l_action != OCFS2_AST_DOWNCONVERT);
2699 /* set things up for the unlockast to know to just
2700 * clear out the ast_action and unset busy, etc. */
2701 lockres->l_unlock_action = OCFS2_UNLOCK_CANCEL_CONVERT;
2702
2703 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_BUSY),
2704 "lock %s, invalid flags: 0x%lx\n",
2705 lockres->l_name, lockres->l_flags);
2706
2707 return 1;
2708}
2709
2710static int ocfs2_cancel_convert(struct ocfs2_super *osb,
2711 struct ocfs2_lock_res *lockres)
2712{
2713 int ret;
2714 enum dlm_status status;
2715
2716 mlog_entry_void();
2717 mlog(0, "lock %s\n", lockres->l_name);
2718
2719 ret = 0;
2720 status = dlmunlock(osb->dlm,
2721 &lockres->l_lksb,
2722 LKM_CANCEL,
2a45f2d1 2723 ocfs2_unlock_ast,
ccd979bd
MF		 2724 lockres);
2725 if (status != DLM_NORMAL) {
2726 ocfs2_log_dlm_error("dlmunlock", status, lockres);
2727 ret = -EINVAL;
2728 ocfs2_recover_from_dlm_error(lockres, 0);
2729 }
2730
2731 mlog(0, "lock %s return from dlmunlock\n", lockres->l_name);
2732
ccd979bd
MF		 2733 mlog_exit(ret);
2734 return ret;
2735}
2736
b5e500e2
MF		 2737static int ocfs2_unblock_lock(struct ocfs2_super *osb,
2738 struct ocfs2_lock_res *lockres,
2739 struct ocfs2_unblock_ctl *ctl)
ccd979bd
MF		 2740{
2741 unsigned long flags;
2742 int blocking;
2743 int new_level;
2744 int ret = 0;
5ef0d4ea 2745 int set_lvb = 0;
ccd979bd
MF		 2746
2747 mlog_entry_void();
2748
2749 spin_lock_irqsave(&lockres->l_lock, flags);
2750
2751 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
2752
2753recheck:
2754 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
d680efe9 2755 ctl->requeue = 1;
ccd979bd
MF		 2756 ret = ocfs2_prepare_cancel_convert(osb, lockres);
2757 spin_unlock_irqrestore(&lockres->l_lock, flags);
2758 if (ret) {
2759 ret = ocfs2_cancel_convert(osb, lockres);
2760 if (ret < 0)
2761 mlog_errno(ret);
2762 }
2763 goto leave;
2764 }
2765
2766 /* if we're blocking an exclusive and we have *any* holders,
2767 * then requeue. */
2768 if ((lockres->l_blocking == LKM_EXMODE)
f7fbfdd1
MF		 2769 && (lockres->l_ex_holders || lockres->l_ro_holders))
2770 goto leave_requeue;
ccd979bd
MF		 2771
2772 /* If it's a PR we're blocking, then only
2773 * requeue if we've got any EX holders */
2774 if (lockres->l_blocking == LKM_PRMODE &&
f7fbfdd1
MF		 2775 lockres->l_ex_holders)
2776 goto leave_requeue;
2777
2778 /*
2779 * Can we get a lock in this state if the holder counts are
2780 * zero? The meta data unblock code used to check this.
2781 */
2782 if ((lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
2783 && (lockres->l_flags & OCFS2_LOCK_REFRESHING))
2784 goto leave_requeue;
ccd979bd 2785
16d5b956
MF		 2786 new_level = ocfs2_highest_compat_lock_level(lockres->l_blocking);
2787
2788 if (lockres->l_ops->check_downconvert
2789 && !lockres->l_ops->check_downconvert(lockres, new_level))
2790 goto leave_requeue;
2791
ccd979bd
MF		 2792 /* If we get here, then we know that there are no more
2793 * incompatible holders (and anyone asking for an incompatible
2794 * lock is blocked). We can now downconvert the lock */
cc567d89 2795 if (!lockres->l_ops->downconvert_worker)
ccd979bd
MF		 2796 goto downconvert;
2797
2798 /* Some lockres types want to do a bit of work before
2799 * downconverting a lock. Allow that here. The worker function
2800 * may sleep, so we save off a copy of what we're blocking as
2801 * it may change while we're not holding the spin lock. */
2802 blocking = lockres->l_blocking;
2803 spin_unlock_irqrestore(&lockres->l_lock, flags);
2804
cc567d89 2805 ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking);
d680efe9
MF		 2806
2807 if (ctl->unblock_action == UNBLOCK_STOP_POST)
2808 goto leave;
ccd979bd
MF		 2809
2810 spin_lock_irqsave(&lockres->l_lock, flags);
2811 if (blocking != lockres->l_blocking) {
2812 /* If this changed underneath us, then we can't drop
2813 * it just yet. */
2814 goto recheck;
2815 }
2816
2817downconvert:
d680efe9 2818 ctl->requeue = 0;
ccd979bd 2819
5ef0d4ea
MF		 2820 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
2821 if (lockres->l_level == LKM_EXMODE)
2822 set_lvb = 1;
2823
2824 /*
2825 * We only set the lvb if the lock has been fully
2826 * refreshed - otherwise we risk setting stale
2827 * data. Otherwise, there's no need to actually clear
2828 * out the lvb here as it's value is still valid.
2829 */
2830 if (set_lvb && !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
2831 lockres->l_ops->set_lvb(lockres);
2832 }
2833
ccd979bd
MF		 2834 ocfs2_prepare_downconvert(lockres, new_level);
2835 spin_unlock_irqrestore(&lockres->l_lock, flags);
5ef0d4ea 2836 ret = ocfs2_downconvert_lock(osb, lockres, new_level, set_lvb);
ccd979bd
MF		 2837leave:
2838 mlog_exit(ret);
2839 return ret;
f7fbfdd1
MF		 2840
2841leave_requeue:
2842 spin_unlock_irqrestore(&lockres->l_lock, flags);
2843 ctl->requeue = 1;
2844
2845 mlog_exit(0);
2846 return 0;
ccd979bd
MF		 2847}
2848
d680efe9
MF		 2849static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
2850 int blocking)
ccd979bd
MF		 2851{
2852 struct inode *inode;
2853 struct address_space *mapping;
2854
ccd979bd
MF		 2855 inode = ocfs2_lock_res_inode(lockres);
2856 mapping = inode->i_mapping;
2857
7f4a2a97
MF		 2858 /*
2859 * We need this before the filemap_fdatawrite() so that it can
2860 * transfer the dirty bit from the PTE to the
2861 * page. Unfortunately this means that even for EX->PR
2862 * downconverts, we'll lose our mappings and have to build
2863 * them up again.
2864 */
2865 unmap_mapping_range(mapping, 0, 0, 0);
2866
ccd979bd 2867 if (filemap_fdatawrite(mapping)) {
b0697053
MF		 2868 mlog(ML_ERROR, "Could not sync inode %llu for downconvert!",
2869 (unsigned long long)OCFS2_I(inode)->ip_blkno);
ccd979bd
MF		 2870 }
2871 sync_mapping_buffers(mapping);
2872 if (blocking == LKM_EXMODE) {
2873 truncate_inode_pages(mapping, 0);
ccd979bd
MF		 2874 } else {
2875 /* We only need to wait on the I/O if we're not also
2876 * truncating pages because truncate_inode_pages waits
2877 * for us above. We don't truncate pages if we're
2878 * blocking anything < EXMODE because we want to keep
2879 * them around in that case. */
2880 filemap_fdatawait(mapping);
2881 }
2882
d680efe9 2883 return UNBLOCK_CONTINUE;
ccd979bd
MF		 2884}
2885
810d5aeb
MF		 2886static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
2887 int new_level)
2888{
2889 struct inode *inode = ocfs2_lock_res_inode(lockres);
2890 int checkpointed = ocfs2_inode_fully_checkpointed(inode);
2891
2892 BUG_ON(new_level != LKM_NLMODE && new_level != LKM_PRMODE);
2893 BUG_ON(lockres->l_level != LKM_EXMODE && !checkpointed);
2894
2895 if (checkpointed)
2896 return 1;
2897
2898 ocfs2_start_checkpoint(OCFS2_SB(inode->i_sb));
2899 return 0;
2900}
2901
2902static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres)
2903{
2904 struct inode *inode = ocfs2_lock_res_inode(lockres);
2905
2906 __ocfs2_stuff_meta_lvb(inode);
2907}
2908
d680efe9
MF		 2909/*
2910 * Does the final reference drop on our dentry lock. Right now this
2911 * happens in the vote thread, but we could choose to simplify the
2912 * dlmglue API and push these off to the ocfs2_wq in the future.
2913 */
2914static void ocfs2_dentry_post_unlock(struct ocfs2_super *osb,
2915 struct ocfs2_lock_res *lockres)
2916{
2917 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
2918 ocfs2_dentry_lock_put(osb, dl);
2919}
2920
2921/*
2922 * d_delete() matching dentries before the lock downconvert.
2923 *
2924 * At this point, any process waiting to destroy the
2925 * dentry_lock due to last ref count is stopped by the
2926 * OCFS2_LOCK_QUEUED flag.
2927 *
2928 * We have two potential problems
2929 *
2930 * 1) If we do the last reference drop on our dentry_lock (via dput)
2931 * we'll wind up in ocfs2_release_dentry_lock(), waiting on
2932 * the downconvert to finish. Instead we take an elevated
2933 * reference and push the drop until after we've completed our
2934 * unblock processing.
2935 *
2936 * 2) There might be another process with a final reference,
2937 * waiting on us to finish processing. If this is the case, we
2938 * detect it and exit out - there's no more dentries anyway.
2939 */
2940static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
2941 int blocking)
2942{
2943 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
2944 struct ocfs2_inode_info *oi = OCFS2_I(dl->dl_inode);
2945 struct dentry *dentry;
2946 unsigned long flags;
2947 int extra_ref = 0;
2948
2949 /*
2950 * This node is blocking another node from getting a read
2951 * lock. This happens when we've renamed within a
2952 * directory. We've forced the other nodes to d_delete(), but
2953 * we never actually dropped our lock because it's still
2954 * valid. The downconvert code will retain a PR for this node,
2955 * so there's no further work to do.
2956 */
2957 if (blocking == LKM_PRMODE)
2958 return UNBLOCK_CONTINUE;
2959
2960 /*
2961 * Mark this inode as potentially orphaned. The code in
2962 * ocfs2_delete_inode() will figure out whether it actually
2963 * needs to be freed or not.
2964 */
2965 spin_lock(&oi->ip_lock);
2966 oi->ip_flags |= OCFS2_INODE_MAYBE_ORPHANED;
2967 spin_unlock(&oi->ip_lock);
2968
2969 /*
2970 * Yuck. We need to make sure however that the check of
2971 * OCFS2_LOCK_FREEING and the extra reference are atomic with
2972 * respect to a reference decrement or the setting of that
2973 * flag.
2974 */
2975 spin_lock_irqsave(&lockres->l_lock, flags);
2976 spin_lock(&dentry_attach_lock);
2977 if (!(lockres->l_flags & OCFS2_LOCK_FREEING)
2978 && dl->dl_count) {
2979 dl->dl_count++;
2980 extra_ref = 1;
2981 }
2982 spin_unlock(&dentry_attach_lock);
2983 spin_unlock_irqrestore(&lockres->l_lock, flags);
2984
2985 mlog(0, "extra_ref = %d\n", extra_ref);
2986
2987 /*
2988 * We have a process waiting on us in ocfs2_dentry_iput(),
2989 * which means we can't have any more outstanding
2990 * aliases. There's no need to do any more work.
2991 */
2992 if (!extra_ref)
2993 return UNBLOCK_CONTINUE;
2994
2995 spin_lock(&dentry_attach_lock);
2996 while (1) {
2997 dentry = ocfs2_find_local_alias(dl->dl_inode,
2998 dl->dl_parent_blkno, 1);
2999 if (!dentry)
3000 break;
3001 spin_unlock(&dentry_attach_lock);
3002
3003 mlog(0, "d_delete(%.*s);\n", dentry->d_name.len,
3004 dentry->d_name.name);
3005
3006 /*
3007 * The following dcache calls may do an
3008 * iput(). Normally we don't want that from the
3009 * downconverting thread, but in this case it's ok
3010 * because the requesting node already has an
3011 * exclusive lock on the inode, so it can't be queued
3012 * for a downconvert.
3013 */
3014 d_delete(dentry);
3015 dput(dentry);
3016
3017 spin_lock(&dentry_attach_lock);
3018 }
3019 spin_unlock(&dentry_attach_lock);
3020
3021 /*
3022 * If we are the last holder of this dentry lock, there is no
3023 * reason to downconvert so skip straight to the unlock.
3024 */
3025 if (dl->dl_count == 1)
3026 return UNBLOCK_STOP_POST;
3027
3028 return UNBLOCK_CONTINUE_POST;
3029}
3030
ccd979bd
MF		 3031void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
3032 struct ocfs2_lock_res *lockres)
3033{
3034 int status;
d680efe9 3035 struct ocfs2_unblock_ctl ctl = {0, 0,};
ccd979bd
MF		 3036 unsigned long flags;
3037
3038 /* Our reference to the lockres in this function can be
3039 * considered valid until we remove the OCFS2_LOCK_QUEUED
3040 * flag. */
3041
3042 mlog_entry_void();
3043
3044 BUG_ON(!lockres);
3045 BUG_ON(!lockres->l_ops);
ccd979bd
MF		 3046
3047 mlog(0, "lockres %s blocked.\n", lockres->l_name);
3048
3049 /* Detect whether a lock has been marked as going away while
3050 * the vote thread was processing other things. A lock can
3051 * still be marked with OCFS2_LOCK_FREEING after this check,
3052 * but short circuiting here will still save us some
3053 * performance. */
3054 spin_lock_irqsave(&lockres->l_lock, flags);
3055 if (lockres->l_flags & OCFS2_LOCK_FREEING)
3056 goto unqueue;
3057 spin_unlock_irqrestore(&lockres->l_lock, flags);
3058
b5e500e2 3059 status = ocfs2_unblock_lock(osb, lockres, &ctl);
ccd979bd
MF		 3060 if (status < 0)
3061 mlog_errno(status);
3062
3063 spin_lock_irqsave(&lockres->l_lock, flags);
3064unqueue:
d680efe9 3065 if (lockres->l_flags & OCFS2_LOCK_FREEING || !ctl.requeue) {
ccd979bd
MF		 3066 lockres_clear_flags(lockres, OCFS2_LOCK_QUEUED);
3067 } else
3068 ocfs2_schedule_blocked_lock(osb, lockres);
3069
3070 mlog(0, "lockres %s, requeue = %s.\n", lockres->l_name,
d680efe9 3071 ctl.requeue ? "yes" : "no");
ccd979bd
MF		 3072 spin_unlock_irqrestore(&lockres->l_lock, flags);
3073
d680efe9
MF		 3074 if (ctl.unblock_action != UNBLOCK_CONTINUE
3075 && lockres->l_ops->post_unlock)
3076 lockres->l_ops->post_unlock(osb, lockres);
3077
ccd979bd
MF		 3078 mlog_exit_void();
3079}
3080
3081static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
3082 struct ocfs2_lock_res *lockres)
3083{
3084 mlog_entry_void();
3085
3086 assert_spin_locked(&lockres->l_lock);
3087
3088 if (lockres->l_flags & OCFS2_LOCK_FREEING) {
3089 /* Do not schedule a lock for downconvert when it's on
3090 * the way to destruction - any nodes wanting access
3091 * to the resource will get it soon. */
3092 mlog(0, "Lockres %s won't be scheduled: flags 0x%lx\n",
3093 lockres->l_name, lockres->l_flags);
3094 return;
3095 }
3096
3097 lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
3098
3099 spin_lock(&osb->vote_task_lock);
3100 if (list_empty(&lockres->l_blocked_list)) {
3101 list_add_tail(&lockres->l_blocked_list,
3102 &osb->blocked_lock_list);
3103 osb->blocked_lock_count++;
3104 }
3105 spin_unlock(&osb->vote_task_lock);
3106
3107 mlog_exit_void();
3108}
kernel source for telekom puls (alcatel/mediatek)