1
2
3
4
5
6
7
8
9
10
11
12#include <linux/types.h>
13#include <linux/slab.h>
14#include <linux/highmem.h>
15#include <linux/mm.h>
16#include <linux/kthread.h>
17#include <linux/pagemap.h>
18#include <linux/debugfs.h>
19#include <linux/seq_file.h>
20#include <linux/time.h>
21#include <linux/quotaops.h>
22#include <linux/sched/signal.h>
23
24#define MLOG_MASK_PREFIX ML_DLM_GLUE
25#include <cluster/masklog.h>
26
27#include "ocfs2.h"
28#include "ocfs2_lockingver.h"
29
30#include "alloc.h"
31#include "dcache.h"
32#include "dlmglue.h"
33#include "extent_map.h"
34#include "file.h"
35#include "heartbeat.h"
36#include "inode.h"
37#include "journal.h"
38#include "stackglue.h"
39#include "slot_map.h"
40#include "super.h"
41#include "uptodate.h"
42#include "quota.h"
43#include "refcounttree.h"
44#include "acl.h"
45
46#include "buffer_head_io.h"
47
48struct ocfs2_mask_waiter {
49 struct list_head mw_item;
50 int mw_status;
51 struct completion mw_complete;
52 unsigned long mw_mask;
53 unsigned long mw_goal;
54#ifdef CONFIG_OCFS2_FS_STATS
55 ktime_t mw_lock_start;
56#endif
57};
58
59static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres);
60static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres);
61static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres);
62static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres);
63
64
65
66
67
68
69
70
71enum ocfs2_unblock_action {
72 UNBLOCK_CONTINUE = 0,
73 UNBLOCK_CONTINUE_POST = 1,
74
75 UNBLOCK_STOP_POST = 2,
76
77};
78
79struct ocfs2_unblock_ctl {
80 int requeue;
81 enum ocfs2_unblock_action unblock_action;
82};
83
84
85#ifdef CONFIG_DEBUG_LOCK_ALLOC
86static struct lock_class_key lockdep_keys[OCFS2_NUM_LOCK_TYPES];
87#endif
88
89static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
90 int new_level);
91static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres);
92
93static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
94 int blocking);
95
96static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
97 int blocking);
98
99static void ocfs2_dentry_post_unlock(struct ocfs2_super *osb,
100 struct ocfs2_lock_res *lockres);
101
102static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres);
103
104static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
105 int new_level);
106static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
107 int blocking);
108
109#define mlog_meta_lvb(__level, __lockres) ocfs2_dump_meta_lvb_info(__level, __PRETTY_FUNCTION__, __LINE__, __lockres)
110
111
112static void ocfs2_dump_meta_lvb_info(u64 level,
113 const char *function,
114 unsigned int line,
115 struct ocfs2_lock_res *lockres)
116{
117 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
118
119 mlog(level, "LVB information for %s (called from %s:%u):\n",
120 lockres->l_name, function, line);
121 mlog(level, "version: %u, clusters: %u, generation: 0x%x\n",
122 lvb->lvb_version, be32_to_cpu(lvb->lvb_iclusters),
123 be32_to_cpu(lvb->lvb_igeneration));
124 mlog(level, "size: %llu, uid %u, gid %u, mode 0x%x\n",
125 (unsigned long long)be64_to_cpu(lvb->lvb_isize),
126 be32_to_cpu(lvb->lvb_iuid), be32_to_cpu(lvb->lvb_igid),
127 be16_to_cpu(lvb->lvb_imode));
128 mlog(level, "nlink %u, atime_packed 0x%llx, ctime_packed 0x%llx, "
129 "mtime_packed 0x%llx iattr 0x%x\n", be16_to_cpu(lvb->lvb_inlink),
130 (long long)be64_to_cpu(lvb->lvb_iatime_packed),
131 (long long)be64_to_cpu(lvb->lvb_ictime_packed),
132 (long long)be64_to_cpu(lvb->lvb_imtime_packed),
133 be32_to_cpu(lvb->lvb_iattr));
134}
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150struct ocfs2_lock_res_ops {
151
152
153
154
155 struct ocfs2_super * (*get_osb)(struct ocfs2_lock_res *);
156
157
158
159
160
161
162
163
164
165
166 void (*post_unlock)(struct ocfs2_super *, struct ocfs2_lock_res *);
167
168
169
170
171
172
173
174
175
176
177
178 int (*check_downconvert)(struct ocfs2_lock_res *, int);
179
180
181
182
183
184
185
186
187
188
189 void (*set_lvb)(struct ocfs2_lock_res *);
190
191
192
193
194
195
196
197
198
199
200 int (*downconvert_worker)(struct ocfs2_lock_res *, int);
201
202
203
204
205
206 int flags;
207};
208
209
210
211
212
213
214
215
216
217#define LOCK_TYPE_REQUIRES_REFRESH 0x1
218
219
220
221
222
223#define LOCK_TYPE_USES_LVB 0x2
224
225static struct ocfs2_lock_res_ops ocfs2_inode_rw_lops = {
226 .get_osb = ocfs2_get_inode_osb,
227 .flags = 0,
228};
229
230static struct ocfs2_lock_res_ops ocfs2_inode_inode_lops = {
231 .get_osb = ocfs2_get_inode_osb,
232 .check_downconvert = ocfs2_check_meta_downconvert,
233 .set_lvb = ocfs2_set_meta_lvb,
234 .downconvert_worker = ocfs2_data_convert_worker,
235 .flags = LOCK_TYPE_REQUIRES_REFRESH|LOCK_TYPE_USES_LVB,
236};
237
238static struct ocfs2_lock_res_ops ocfs2_super_lops = {
239 .flags = LOCK_TYPE_REQUIRES_REFRESH,
240};
241
242static struct ocfs2_lock_res_ops ocfs2_rename_lops = {
243 .flags = 0,
244};
245
246static struct ocfs2_lock_res_ops ocfs2_nfs_sync_lops = {
247 .flags = 0,
248};
249
250static struct ocfs2_lock_res_ops ocfs2_trim_fs_lops = {
251 .flags = LOCK_TYPE_REQUIRES_REFRESH|LOCK_TYPE_USES_LVB,
252};
253
254static struct ocfs2_lock_res_ops ocfs2_orphan_scan_lops = {
255 .flags = LOCK_TYPE_REQUIRES_REFRESH|LOCK_TYPE_USES_LVB,
256};
257
258static struct ocfs2_lock_res_ops ocfs2_dentry_lops = {
259 .get_osb = ocfs2_get_dentry_osb,
260 .post_unlock = ocfs2_dentry_post_unlock,
261 .downconvert_worker = ocfs2_dentry_convert_worker,
262 .flags = 0,
263};
264
265static struct ocfs2_lock_res_ops ocfs2_inode_open_lops = {
266 .get_osb = ocfs2_get_inode_osb,
267 .flags = 0,
268};
269
270static struct ocfs2_lock_res_ops ocfs2_flock_lops = {
271 .get_osb = ocfs2_get_file_osb,
272 .flags = 0,
273};
274
275static struct ocfs2_lock_res_ops ocfs2_qinfo_lops = {
276 .set_lvb = ocfs2_set_qinfo_lvb,
277 .get_osb = ocfs2_get_qinfo_osb,
278 .flags = LOCK_TYPE_REQUIRES_REFRESH | LOCK_TYPE_USES_LVB,
279};
280
281static struct ocfs2_lock_res_ops ocfs2_refcount_block_lops = {
282 .check_downconvert = ocfs2_check_refcount_downconvert,
283 .downconvert_worker = ocfs2_refcount_convert_worker,
284 .flags = 0,
285};
286
287static inline int ocfs2_is_inode_lock(struct ocfs2_lock_res *lockres)
288{
289 return lockres->l_type == OCFS2_LOCK_TYPE_META ||
290 lockres->l_type == OCFS2_LOCK_TYPE_RW ||
291 lockres->l_type == OCFS2_LOCK_TYPE_OPEN;
292}
293
294static inline struct ocfs2_lock_res *ocfs2_lksb_to_lock_res(struct ocfs2_dlm_lksb *lksb)
295{
296 return container_of(lksb, struct ocfs2_lock_res, l_lksb);
297}
298
299static inline struct inode *ocfs2_lock_res_inode(struct ocfs2_lock_res *lockres)
300{
301 BUG_ON(!ocfs2_is_inode_lock(lockres));
302
303 return (struct inode *) lockres->l_priv;
304}
305
306static inline struct ocfs2_dentry_lock *ocfs2_lock_res_dl(struct ocfs2_lock_res *lockres)
307{
308 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_DENTRY);
309
310 return (struct ocfs2_dentry_lock *)lockres->l_priv;
311}
312
313static inline struct ocfs2_mem_dqinfo *ocfs2_lock_res_qinfo(struct ocfs2_lock_res *lockres)
314{
315 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_QINFO);
316
317 return (struct ocfs2_mem_dqinfo *)lockres->l_priv;
318}
319
320static inline struct ocfs2_refcount_tree *
321ocfs2_lock_res_refcount_tree(struct ocfs2_lock_res *res)
322{
323 return container_of(res, struct ocfs2_refcount_tree, rf_lockres);
324}
325
326static inline struct ocfs2_super *ocfs2_get_lockres_osb(struct ocfs2_lock_res *lockres)
327{
328 if (lockres->l_ops->get_osb)
329 return lockres->l_ops->get_osb(lockres);
330
331 return (struct ocfs2_super *)lockres->l_priv;
332}
333
334static int ocfs2_lock_create(struct ocfs2_super *osb,
335 struct ocfs2_lock_res *lockres,
336 int level,
337 u32 dlm_flags);
338static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
339 int wanted);
340static void __ocfs2_cluster_unlock(struct ocfs2_super *osb,
341 struct ocfs2_lock_res *lockres,
342 int level, unsigned long caller_ip);
343static inline void ocfs2_cluster_unlock(struct ocfs2_super *osb,
344 struct ocfs2_lock_res *lockres,
345 int level)
346{
347 __ocfs2_cluster_unlock(osb, lockres, level, _RET_IP_);
348}
349
350static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres);
351static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres);
352static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres);
353static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, int level);
354static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
355 struct ocfs2_lock_res *lockres);
356static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
357 int convert);
358#define ocfs2_log_dlm_error(_func, _err, _lockres) do { \
359 if ((_lockres)->l_type != OCFS2_LOCK_TYPE_DENTRY) \
360 mlog(ML_ERROR, "DLM error %d while calling %s on resource %s\n", \
361 _err, _func, _lockres->l_name); \
362 else \
363 mlog(ML_ERROR, "DLM error %d while calling %s on resource %.*s%08x\n", \
364 _err, _func, OCFS2_DENTRY_LOCK_INO_START - 1, (_lockres)->l_name, \
365 (unsigned int)ocfs2_get_dentry_lock_ino(_lockres)); \
366} while (0)
367static int ocfs2_downconvert_thread(void *arg);
368static void ocfs2_downconvert_on_unlock(struct ocfs2_super *osb,
369 struct ocfs2_lock_res *lockres);
370static int ocfs2_inode_lock_update(struct inode *inode,
371 struct buffer_head **bh);
372static void ocfs2_drop_osb_locks(struct ocfs2_super *osb);
373static inline int ocfs2_highest_compat_lock_level(int level);
374static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
375 int new_level);
376static int ocfs2_downconvert_lock(struct ocfs2_super *osb,
377 struct ocfs2_lock_res *lockres,
378 int new_level,
379 int lvb,
380 unsigned int generation);
381static int ocfs2_prepare_cancel_convert(struct ocfs2_super *osb,
382 struct ocfs2_lock_res *lockres);
383static int ocfs2_cancel_convert(struct ocfs2_super *osb,
384 struct ocfs2_lock_res *lockres);
385
386
387static void ocfs2_build_lock_name(enum ocfs2_lock_type type,
388 u64 blkno,
389 u32 generation,
390 char *name)
391{
392 int len;
393
394 BUG_ON(type >= OCFS2_NUM_LOCK_TYPES);
395
396 len = snprintf(name, OCFS2_LOCK_ID_MAX_LEN, "%c%s%016llx%08x",
397 ocfs2_lock_type_char(type), OCFS2_LOCK_ID_PAD,
398 (long long)blkno, generation);
399
400 BUG_ON(len != (OCFS2_LOCK_ID_MAX_LEN - 1));
401
402 mlog(0, "built lock resource with name: %s\n", name);
403}
404
405static DEFINE_SPINLOCK(ocfs2_dlm_tracking_lock);
406
407static void ocfs2_add_lockres_tracking(struct ocfs2_lock_res *res,
408 struct ocfs2_dlm_debug *dlm_debug)
409{
410 mlog(0, "Add tracking for lockres %s\n", res->l_name);
411
412 spin_lock(&ocfs2_dlm_tracking_lock);
413 list_add(&res->l_debug_list, &dlm_debug->d_lockres_tracking);
414 spin_unlock(&ocfs2_dlm_tracking_lock);
415}
416
417static void ocfs2_remove_lockres_tracking(struct ocfs2_lock_res *res)
418{
419 spin_lock(&ocfs2_dlm_tracking_lock);
420 if (!list_empty(&res->l_debug_list))
421 list_del_init(&res->l_debug_list);
422 spin_unlock(&ocfs2_dlm_tracking_lock);
423}
424
425#ifdef CONFIG_OCFS2_FS_STATS
426static void ocfs2_init_lock_stats(struct ocfs2_lock_res *res)
427{
428 res->l_lock_refresh = 0;
429 res->l_lock_wait = 0;
430 memset(&res->l_lock_prmode, 0, sizeof(struct ocfs2_lock_stats));
431 memset(&res->l_lock_exmode, 0, sizeof(struct ocfs2_lock_stats));
432}
433
434static void ocfs2_update_lock_stats(struct ocfs2_lock_res *res, int level,
435 struct ocfs2_mask_waiter *mw, int ret)
436{
437 u32 usec;
438 ktime_t kt;
439 struct ocfs2_lock_stats *stats;
440
441 if (level == LKM_PRMODE)
442 stats = &res->l_lock_prmode;
443 else if (level == LKM_EXMODE)
444 stats = &res->l_lock_exmode;
445 else
446 return;
447
448 kt = ktime_sub(ktime_get(), mw->mw_lock_start);
449 usec = ktime_to_us(kt);
450
451 stats->ls_gets++;
452 stats->ls_total += ktime_to_ns(kt);
453
454 if (unlikely(stats->ls_gets == 0)) {
455 stats->ls_gets++;
456 stats->ls_total = ktime_to_ns(kt);
457 }
458
459 if (stats->ls_max < usec)
460 stats->ls_max = usec;
461
462 if (ret)
463 stats->ls_fail++;
464
465 stats->ls_last = ktime_to_us(ktime_get_real());
466}
467
468static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
469{
470 lockres->l_lock_refresh++;
471}
472
473static inline void ocfs2_track_lock_wait(struct ocfs2_lock_res *lockres)
474{
475 struct ocfs2_mask_waiter *mw;
476
477 if (list_empty(&lockres->l_mask_waiters)) {
478 lockres->l_lock_wait = 0;
479 return;
480 }
481
482 mw = list_first_entry(&lockres->l_mask_waiters,
483 struct ocfs2_mask_waiter, mw_item);
484 lockres->l_lock_wait =
485 ktime_to_us(ktime_mono_to_real(mw->mw_lock_start));
486}
487
488static inline void ocfs2_init_start_time(struct ocfs2_mask_waiter *mw)
489{
490 mw->mw_lock_start = ktime_get();
491}
492#else
493static inline void ocfs2_init_lock_stats(struct ocfs2_lock_res *res)
494{
495}
496static inline void ocfs2_update_lock_stats(struct ocfs2_lock_res *res,
497 int level, struct ocfs2_mask_waiter *mw, int ret)
498{
499}
500static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
501{
502}
503static inline void ocfs2_track_lock_wait(struct ocfs2_lock_res *lockres)
504{
505}
506static inline void ocfs2_init_start_time(struct ocfs2_mask_waiter *mw)
507{
508}
509#endif
510
511static void ocfs2_lock_res_init_common(struct ocfs2_super *osb,
512 struct ocfs2_lock_res *res,
513 enum ocfs2_lock_type type,
514 struct ocfs2_lock_res_ops *ops,
515 void *priv)
516{
517 res->l_type = type;
518 res->l_ops = ops;
519 res->l_priv = priv;
520
521 res->l_level = DLM_LOCK_IV;
522 res->l_requested = DLM_LOCK_IV;
523 res->l_blocking = DLM_LOCK_IV;
524 res->l_action = OCFS2_AST_INVALID;
525 res->l_unlock_action = OCFS2_UNLOCK_INVALID;
526
527 res->l_flags = OCFS2_LOCK_INITIALIZED;
528
529 ocfs2_add_lockres_tracking(res, osb->osb_dlm_debug);
530
531 ocfs2_init_lock_stats(res);
532#ifdef CONFIG_DEBUG_LOCK_ALLOC
533 if (type != OCFS2_LOCK_TYPE_OPEN)
534 lockdep_init_map(&res->l_lockdep_map, ocfs2_lock_type_strings[type],
535 &lockdep_keys[type], 0);
536 else
537 res->l_lockdep_map.key = NULL;
538#endif
539}
540
541void ocfs2_lock_res_init_once(struct ocfs2_lock_res *res)
542{
543
544 memset(res, 0, sizeof(struct ocfs2_lock_res));
545 spin_lock_init(&res->l_lock);
546 init_waitqueue_head(&res->l_event);
547 INIT_LIST_HEAD(&res->l_blocked_list);
548 INIT_LIST_HEAD(&res->l_mask_waiters);
549 INIT_LIST_HEAD(&res->l_holders);
550}
551
552void ocfs2_inode_lock_res_init(struct ocfs2_lock_res *res,
553 enum ocfs2_lock_type type,
554 unsigned int generation,
555 struct inode *inode)
556{
557 struct ocfs2_lock_res_ops *ops;
558
559 switch(type) {
560 case OCFS2_LOCK_TYPE_RW:
561 ops = &ocfs2_inode_rw_lops;
562 break;
563 case OCFS2_LOCK_TYPE_META:
564 ops = &ocfs2_inode_inode_lops;
565 break;
566 case OCFS2_LOCK_TYPE_OPEN:
567 ops = &ocfs2_inode_open_lops;
568 break;
569 default:
570 mlog_bug_on_msg(1, "type: %d\n", type);
571 ops = NULL;
572 break;
573 };
574
575 ocfs2_build_lock_name(type, OCFS2_I(inode)->ip_blkno,
576 generation, res->l_name);
577 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), res, type, ops, inode);
578}
579
580static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres)
581{
582 struct inode *inode = ocfs2_lock_res_inode(lockres);
583
584 return OCFS2_SB(inode->i_sb);
585}
586
587static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres)
588{
589 struct ocfs2_mem_dqinfo *info = lockres->l_priv;
590
591 return OCFS2_SB(info->dqi_gi.dqi_sb);
592}
593
594static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres)
595{
596 struct ocfs2_file_private *fp = lockres->l_priv;
597
598 return OCFS2_SB(fp->fp_file->f_mapping->host->i_sb);
599}
600
601static __u64 ocfs2_get_dentry_lock_ino(struct ocfs2_lock_res *lockres)
602{
603 __be64 inode_blkno_be;
604
605 memcpy(&inode_blkno_be, &lockres->l_name[OCFS2_DENTRY_LOCK_INO_START],
606 sizeof(__be64));
607
608 return be64_to_cpu(inode_blkno_be);
609}
610
611static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres)
612{
613 struct ocfs2_dentry_lock *dl = lockres->l_priv;
614
615 return OCFS2_SB(dl->dl_inode->i_sb);
616}
617
618void ocfs2_dentry_lock_res_init(struct ocfs2_dentry_lock *dl,
619 u64 parent, struct inode *inode)
620{
621 int len;
622 u64 inode_blkno = OCFS2_I(inode)->ip_blkno;
623 __be64 inode_blkno_be = cpu_to_be64(inode_blkno);
624 struct ocfs2_lock_res *lockres = &dl->dl_lockres;
625
626 ocfs2_lock_res_init_once(lockres);
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643 len = snprintf(lockres->l_name, OCFS2_DENTRY_LOCK_INO_START,
644 "%c%016llx",
645 ocfs2_lock_type_char(OCFS2_LOCK_TYPE_DENTRY),
646 (long long)parent);
647
648 BUG_ON(len != (OCFS2_DENTRY_LOCK_INO_START - 1));
649
650 memcpy(&lockres->l_name[OCFS2_DENTRY_LOCK_INO_START], &inode_blkno_be,
651 sizeof(__be64));
652
653 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
654 OCFS2_LOCK_TYPE_DENTRY, &ocfs2_dentry_lops,
655 dl);
656}
657
658static void ocfs2_super_lock_res_init(struct ocfs2_lock_res *res,
659 struct ocfs2_super *osb)
660{
661
662
663 ocfs2_lock_res_init_once(res);
664 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_SUPER, OCFS2_SUPER_BLOCK_BLKNO,
665 0, res->l_name);
666 ocfs2_lock_res_init_common(osb, res, OCFS2_LOCK_TYPE_SUPER,
667 &ocfs2_super_lops, osb);
668}
669
670static void ocfs2_rename_lock_res_init(struct ocfs2_lock_res *res,
671 struct ocfs2_super *osb)
672{
673
674
675 ocfs2_lock_res_init_once(res);
676 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_RENAME, 0, 0, res->l_name);
677 ocfs2_lock_res_init_common(osb, res, OCFS2_LOCK_TYPE_RENAME,
678 &ocfs2_rename_lops, osb);
679}
680
681static void ocfs2_nfs_sync_lock_res_init(struct ocfs2_lock_res *res,
682 struct ocfs2_super *osb)
683{
684
685
686 ocfs2_lock_res_init_once(res);
687 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_NFS_SYNC, 0, 0, res->l_name);
688 ocfs2_lock_res_init_common(osb, res, OCFS2_LOCK_TYPE_NFS_SYNC,
689 &ocfs2_nfs_sync_lops, osb);
690}
691
692void ocfs2_trim_fs_lock_res_init(struct ocfs2_super *osb)
693{
694 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
695
696
697 mutex_lock(&osb->obs_trim_fs_mutex);
698
699 ocfs2_lock_res_init_once(lockres);
700 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_TRIM_FS, 0, 0, lockres->l_name);
701 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_TRIM_FS,
702 &ocfs2_trim_fs_lops, osb);
703}
704
705void ocfs2_trim_fs_lock_res_uninit(struct ocfs2_super *osb)
706{
707 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
708
709 ocfs2_simple_drop_lockres(osb, lockres);
710 ocfs2_lock_res_free(lockres);
711
712 mutex_unlock(&osb->obs_trim_fs_mutex);
713}
714
715static void ocfs2_orphan_scan_lock_res_init(struct ocfs2_lock_res *res,
716 struct ocfs2_super *osb)
717{
718 ocfs2_lock_res_init_once(res);
719 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_ORPHAN_SCAN, 0, 0, res->l_name);
720 ocfs2_lock_res_init_common(osb, res, OCFS2_LOCK_TYPE_ORPHAN_SCAN,
721 &ocfs2_orphan_scan_lops, osb);
722}
723
724void ocfs2_file_lock_res_init(struct ocfs2_lock_res *lockres,
725 struct ocfs2_file_private *fp)
726{
727 struct inode *inode = fp->fp_file->f_mapping->host;
728 struct ocfs2_inode_info *oi = OCFS2_I(inode);
729
730 ocfs2_lock_res_init_once(lockres);
731 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_FLOCK, oi->ip_blkno,
732 inode->i_generation, lockres->l_name);
733 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
734 OCFS2_LOCK_TYPE_FLOCK, &ocfs2_flock_lops,
735 fp);
736 lockres->l_flags |= OCFS2_LOCK_NOCACHE;
737}
738
739void ocfs2_qinfo_lock_res_init(struct ocfs2_lock_res *lockres,
740 struct ocfs2_mem_dqinfo *info)
741{
742 ocfs2_lock_res_init_once(lockres);
743 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_QINFO, info->dqi_gi.dqi_type,
744 0, lockres->l_name);
745 ocfs2_lock_res_init_common(OCFS2_SB(info->dqi_gi.dqi_sb), lockres,
746 OCFS2_LOCK_TYPE_QINFO, &ocfs2_qinfo_lops,
747 info);
748}
749
750void ocfs2_refcount_lock_res_init(struct ocfs2_lock_res *lockres,
751 struct ocfs2_super *osb, u64 ref_blkno,
752 unsigned int generation)
753{
754 ocfs2_lock_res_init_once(lockres);
755 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_REFCOUNT, ref_blkno,
756 generation, lockres->l_name);
757 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_REFCOUNT,
758 &ocfs2_refcount_block_lops, osb);
759}
760
761void ocfs2_lock_res_free(struct ocfs2_lock_res *res)
762{
763 if (!(res->l_flags & OCFS2_LOCK_INITIALIZED))
764 return;
765
766 ocfs2_remove_lockres_tracking(res);
767
768 mlog_bug_on_msg(!list_empty(&res->l_blocked_list),
769 "Lockres %s is on the blocked list\n",
770 res->l_name);
771 mlog_bug_on_msg(!list_empty(&res->l_mask_waiters),
772 "Lockres %s has mask waiters pending\n",
773 res->l_name);
774 mlog_bug_on_msg(spin_is_locked(&res->l_lock),
775 "Lockres %s is locked\n",
776 res->l_name);
777 mlog_bug_on_msg(res->l_ro_holders,
778 "Lockres %s has %u ro holders\n",
779 res->l_name, res->l_ro_holders);
780 mlog_bug_on_msg(res->l_ex_holders,
781 "Lockres %s has %u ex holders\n",
782 res->l_name, res->l_ex_holders);
783
784
785 memset(&res->l_lksb, 0, sizeof(res->l_lksb));
786
787 res->l_flags = 0UL;
788}
789
790
791
792
793
794static inline void ocfs2_add_holder(struct ocfs2_lock_res *lockres,
795 struct ocfs2_lock_holder *oh)
796{
797 INIT_LIST_HEAD(&oh->oh_list);
798 oh->oh_owner_pid = get_pid(task_pid(current));
799
800 spin_lock(&lockres->l_lock);
801 list_add_tail(&oh->oh_list, &lockres->l_holders);
802 spin_unlock(&lockres->l_lock);
803}
804
805static struct ocfs2_lock_holder *
806ocfs2_pid_holder(struct ocfs2_lock_res *lockres,
807 struct pid *pid)
808{
809 struct ocfs2_lock_holder *oh;
810
811 spin_lock(&lockres->l_lock);
812 list_for_each_entry(oh, &lockres->l_holders, oh_list) {
813 if (oh->oh_owner_pid == pid) {
814 spin_unlock(&lockres->l_lock);
815 return oh;
816 }
817 }
818 spin_unlock(&lockres->l_lock);
819 return NULL;
820}
821
822static inline void ocfs2_remove_holder(struct ocfs2_lock_res *lockres,
823 struct ocfs2_lock_holder *oh)
824{
825 spin_lock(&lockres->l_lock);
826 list_del(&oh->oh_list);
827 spin_unlock(&lockres->l_lock);
828
829 put_pid(oh->oh_owner_pid);
830}
831
832
833static inline void ocfs2_inc_holders(struct ocfs2_lock_res *lockres,
834 int level)
835{
836 BUG_ON(!lockres);
837
838 switch(level) {
839 case DLM_LOCK_EX:
840 lockres->l_ex_holders++;
841 break;
842 case DLM_LOCK_PR:
843 lockres->l_ro_holders++;
844 break;
845 default:
846 BUG();
847 }
848}
849
850static inline void ocfs2_dec_holders(struct ocfs2_lock_res *lockres,
851 int level)
852{
853 BUG_ON(!lockres);
854
855 switch(level) {
856 case DLM_LOCK_EX:
857 BUG_ON(!lockres->l_ex_holders);
858 lockres->l_ex_holders--;
859 break;
860 case DLM_LOCK_PR:
861 BUG_ON(!lockres->l_ro_holders);
862 lockres->l_ro_holders--;
863 break;
864 default:
865 BUG();
866 }
867}
868
869
870
871
872static inline int ocfs2_highest_compat_lock_level(int level)
873{
874 int new_level = DLM_LOCK_EX;
875
876 if (level == DLM_LOCK_EX)
877 new_level = DLM_LOCK_NL;
878 else if (level == DLM_LOCK_PR)
879 new_level = DLM_LOCK_PR;
880 return new_level;
881}
882
883static void lockres_set_flags(struct ocfs2_lock_res *lockres,
884 unsigned long newflags)
885{
886 struct ocfs2_mask_waiter *mw, *tmp;
887
888 assert_spin_locked(&lockres->l_lock);
889
890 lockres->l_flags = newflags;
891
892 list_for_each_entry_safe(mw, tmp, &lockres->l_mask_waiters, mw_item) {
893 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
894 continue;
895
896 list_del_init(&mw->mw_item);
897 mw->mw_status = 0;
898 complete(&mw->mw_complete);
899 ocfs2_track_lock_wait(lockres);
900 }
901}
902static void lockres_or_flags(struct ocfs2_lock_res *lockres, unsigned long or)
903{
904 lockres_set_flags(lockres, lockres->l_flags | or);
905}
906static void lockres_clear_flags(struct ocfs2_lock_res *lockres,
907 unsigned long clear)
908{
909 lockres_set_flags(lockres, lockres->l_flags & ~clear);
910}
911
912static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres)
913{
914 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
915 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
916 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
917 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
918
919 lockres->l_level = lockres->l_requested;
920 if (lockres->l_level <=
921 ocfs2_highest_compat_lock_level(lockres->l_blocking)) {
922 lockres->l_blocking = DLM_LOCK_NL;
923 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
924 }
925 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
926}
927
928static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres)
929{
930 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
931 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
932
933
934
935
936
937 if (lockres->l_level == DLM_LOCK_NL &&
938 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
939 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
940
941 lockres->l_level = lockres->l_requested;
942
943
944
945
946
947
948
949
950 if (!(lockres->l_flags & OCFS2_LOCK_NONBLOCK_FINISHED))
951 lockres_or_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
952 else
953 lockres_clear_flags(lockres, OCFS2_LOCK_NONBLOCK_FINISHED);
954
955 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
956}
957
958static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres)
959{
960 BUG_ON((!(lockres->l_flags & OCFS2_LOCK_BUSY)));
961 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
962
963 if (lockres->l_requested > DLM_LOCK_NL &&
964 !(lockres->l_flags & OCFS2_LOCK_LOCAL) &&
965 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
966 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
967
968 lockres->l_level = lockres->l_requested;
969 lockres_or_flags(lockres, OCFS2_LOCK_ATTACHED);
970 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
971}
972
973static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres,
974 int level)
975{
976 int needs_downconvert = 0;
977
978 assert_spin_locked(&lockres->l_lock);
979
980 if (level > lockres->l_blocking) {
981
982
983
984
985 if (ocfs2_highest_compat_lock_level(level) <
986 ocfs2_highest_compat_lock_level(lockres->l_blocking))
987 needs_downconvert = 1;
988
989 lockres->l_blocking = level;
990 }
991
992 mlog(ML_BASTS, "lockres %s, block %d, level %d, l_block %d, dwn %d\n",
993 lockres->l_name, level, lockres->l_level, lockres->l_blocking,
994 needs_downconvert);
995
996 if (needs_downconvert)
997 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
998 mlog(0, "needs_downconvert = %d\n", needs_downconvert);
999 return needs_downconvert;
1000}
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061static void __lockres_clear_pending(struct ocfs2_lock_res *lockres,
1062 unsigned int generation,
1063 struct ocfs2_super *osb)
1064{
1065 assert_spin_locked(&lockres->l_lock);
1066
1067
1068
1069
1070
1071 if (!(lockres->l_flags & OCFS2_LOCK_PENDING) ||
1072 (lockres->l_pending_gen != generation))
1073 return;
1074
1075 lockres_clear_flags(lockres, OCFS2_LOCK_PENDING);
1076 lockres->l_pending_gen++;
1077
1078
1079
1080
1081
1082 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1083 ocfs2_wake_downconvert_thread(osb);
1084}
1085
1086
1087static void lockres_clear_pending(struct ocfs2_lock_res *lockres,
1088 unsigned int generation,
1089 struct ocfs2_super *osb)
1090{
1091 unsigned long flags;
1092
1093 spin_lock_irqsave(&lockres->l_lock, flags);
1094 __lockres_clear_pending(lockres, generation, osb);
1095 spin_unlock_irqrestore(&lockres->l_lock, flags);
1096}
1097
1098static unsigned int lockres_set_pending(struct ocfs2_lock_res *lockres)
1099{
1100 assert_spin_locked(&lockres->l_lock);
1101 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
1102
1103 lockres_or_flags(lockres, OCFS2_LOCK_PENDING);
1104
1105 return lockres->l_pending_gen;
1106}
1107
1108static void ocfs2_blocking_ast(struct ocfs2_dlm_lksb *lksb, int level)
1109{
1110 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1111 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1112 int needs_downconvert;
1113 unsigned long flags;
1114
1115 BUG_ON(level <= DLM_LOCK_NL);
1116
1117 mlog(ML_BASTS, "BAST fired for lockres %s, blocking %d, level %d, "
1118 "type %s\n", lockres->l_name, level, lockres->l_level,
1119 ocfs2_lock_type_string(lockres->l_type));
1120
1121
1122
1123
1124
1125 if (lockres->l_flags & OCFS2_LOCK_NOCACHE)
1126 return;
1127
1128 spin_lock_irqsave(&lockres->l_lock, flags);
1129 needs_downconvert = ocfs2_generic_handle_bast(lockres, level);
1130 if (needs_downconvert)
1131 ocfs2_schedule_blocked_lock(osb, lockres);
1132 spin_unlock_irqrestore(&lockres->l_lock, flags);
1133
1134 wake_up(&lockres->l_event);
1135
1136 ocfs2_wake_downconvert_thread(osb);
1137}
1138
1139static void ocfs2_locking_ast(struct ocfs2_dlm_lksb *lksb)
1140{
1141 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1142 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1143 unsigned long flags;
1144 int status;
1145
1146 spin_lock_irqsave(&lockres->l_lock, flags);
1147
1148 status = ocfs2_dlm_lock_status(&lockres->l_lksb);
1149
1150 if (status == -EAGAIN) {
1151 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1152 goto out;
1153 }
1154
1155 if (status) {
1156 mlog(ML_ERROR, "lockres %s: lksb status value of %d!\n",
1157 lockres->l_name, status);
1158 spin_unlock_irqrestore(&lockres->l_lock, flags);
1159 return;
1160 }
1161
1162 mlog(ML_BASTS, "AST fired for lockres %s, action %d, unlock %d, "
1163 "level %d => %d\n", lockres->l_name, lockres->l_action,
1164 lockres->l_unlock_action, lockres->l_level, lockres->l_requested);
1165
1166 switch(lockres->l_action) {
1167 case OCFS2_AST_ATTACH:
1168 ocfs2_generic_handle_attach_action(lockres);
1169 lockres_clear_flags(lockres, OCFS2_LOCK_LOCAL);
1170 break;
1171 case OCFS2_AST_CONVERT:
1172 ocfs2_generic_handle_convert_action(lockres);
1173 break;
1174 case OCFS2_AST_DOWNCONVERT:
1175 ocfs2_generic_handle_downconvert_action(lockres);
1176 break;
1177 default:
1178 mlog(ML_ERROR, "lockres %s: AST fired with invalid action: %u, "
1179 "flags 0x%lx, unlock: %u\n",
1180 lockres->l_name, lockres->l_action, lockres->l_flags,
1181 lockres->l_unlock_action);
1182 BUG();
1183 }
1184out:
1185
1186
1187 lockres->l_action = OCFS2_AST_INVALID;
1188
1189
1190 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT)
1191 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1192
1193
1194
1195
1196
1197
1198
1199 __lockres_clear_pending(lockres, lockres->l_pending_gen, osb);
1200
1201 wake_up(&lockres->l_event);
1202 spin_unlock_irqrestore(&lockres->l_lock, flags);
1203}
1204
1205static void ocfs2_unlock_ast(struct ocfs2_dlm_lksb *lksb, int error)
1206{
1207 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1208 unsigned long flags;
1209
1210 mlog(ML_BASTS, "UNLOCK AST fired for lockres %s, action = %d\n",
1211 lockres->l_name, lockres->l_unlock_action);
1212
1213 spin_lock_irqsave(&lockres->l_lock, flags);
1214 if (error) {
1215 mlog(ML_ERROR, "Dlm passes error %d for lock %s, "
1216 "unlock_action %d\n", error, lockres->l_name,
1217 lockres->l_unlock_action);
1218 spin_unlock_irqrestore(&lockres->l_lock, flags);
1219 return;
1220 }
1221
1222 switch(lockres->l_unlock_action) {
1223 case OCFS2_UNLOCK_CANCEL_CONVERT:
1224 mlog(0, "Cancel convert success for %s\n", lockres->l_name);
1225 lockres->l_action = OCFS2_AST_INVALID;
1226
1227
1228 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1229 ocfs2_wake_downconvert_thread(ocfs2_get_lockres_osb(lockres));
1230 break;
1231 case OCFS2_UNLOCK_DROP_LOCK:
1232 lockres->l_level = DLM_LOCK_IV;
1233 break;
1234 default:
1235 BUG();
1236 }
1237
1238 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1239 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1240 wake_up(&lockres->l_event);
1241 spin_unlock_irqrestore(&lockres->l_lock, flags);
1242}
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267static struct ocfs2_locking_protocol lproto = {
1268 .lp_max_version = {
1269 .pv_major = OCFS2_LOCKING_PROTOCOL_MAJOR,
1270 .pv_minor = OCFS2_LOCKING_PROTOCOL_MINOR,
1271 },
1272 .lp_lock_ast = ocfs2_locking_ast,
1273 .lp_blocking_ast = ocfs2_blocking_ast,
1274 .lp_unlock_ast = ocfs2_unlock_ast,
1275};
1276
1277void ocfs2_set_locking_protocol(void)
1278{
1279 ocfs2_stack_glue_set_max_proto_version(&lproto.lp_max_version);
1280}
1281
1282static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
1283 int convert)
1284{
1285 unsigned long flags;
1286
1287 spin_lock_irqsave(&lockres->l_lock, flags);
1288 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1289 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1290 if (convert)
1291 lockres->l_action = OCFS2_AST_INVALID;
1292 else
1293 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1294 spin_unlock_irqrestore(&lockres->l_lock, flags);
1295
1296 wake_up(&lockres->l_event);
1297}
1298
1299
1300
1301
1302
1303static int ocfs2_lock_create(struct ocfs2_super *osb,
1304 struct ocfs2_lock_res *lockres,
1305 int level,
1306 u32 dlm_flags)
1307{
1308 int ret = 0;
1309 unsigned long flags;
1310 unsigned int gen;
1311
1312 mlog(0, "lock %s, level = %d, flags = %u\n", lockres->l_name, level,
1313 dlm_flags);
1314
1315 spin_lock_irqsave(&lockres->l_lock, flags);
1316 if ((lockres->l_flags & OCFS2_LOCK_ATTACHED) ||
1317 (lockres->l_flags & OCFS2_LOCK_BUSY)) {
1318 spin_unlock_irqrestore(&lockres->l_lock, flags);
1319 goto bail;
1320 }
1321
1322 lockres->l_action = OCFS2_AST_ATTACH;
1323 lockres->l_requested = level;
1324 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1325 gen = lockres_set_pending(lockres);
1326 spin_unlock_irqrestore(&lockres->l_lock, flags);
1327
1328 ret = ocfs2_dlm_lock(osb->cconn,
1329 level,
1330 &lockres->l_lksb,
1331 dlm_flags,
1332 lockres->l_name,
1333 OCFS2_LOCK_ID_MAX_LEN - 1);
1334 lockres_clear_pending(lockres, gen, osb);
1335 if (ret) {
1336 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
1337 ocfs2_recover_from_dlm_error(lockres, 1);
1338 }
1339
1340 mlog(0, "lock %s, return from ocfs2_dlm_lock\n", lockres->l_name);
1341
1342bail:
1343 return ret;
1344}
1345
1346static inline int ocfs2_check_wait_flag(struct ocfs2_lock_res *lockres,
1347 int flag)
1348{
1349 unsigned long flags;
1350 int ret;
1351
1352 spin_lock_irqsave(&lockres->l_lock, flags);
1353 ret = lockres->l_flags & flag;
1354 spin_unlock_irqrestore(&lockres->l_lock, flags);
1355
1356 return ret;
1357}
1358
1359static inline void ocfs2_wait_on_busy_lock(struct ocfs2_lock_res *lockres)
1360
1361{
1362 wait_event(lockres->l_event,
1363 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_BUSY));
1364}
1365
1366static inline void ocfs2_wait_on_refreshing_lock(struct ocfs2_lock_res *lockres)
1367
1368{
1369 wait_event(lockres->l_event,
1370 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_REFRESHING));
1371}
1372
1373
1374
1375
1376static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
1377 int wanted)
1378{
1379 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
1380
1381 return wanted <= ocfs2_highest_compat_lock_level(lockres->l_blocking);
1382}
1383
1384static void ocfs2_init_mask_waiter(struct ocfs2_mask_waiter *mw)
1385{
1386 INIT_LIST_HEAD(&mw->mw_item);
1387 init_completion(&mw->mw_complete);
1388 ocfs2_init_start_time(mw);
1389}
1390
1391static int ocfs2_wait_for_mask(struct ocfs2_mask_waiter *mw)
1392{
1393 wait_for_completion(&mw->mw_complete);
1394
1395 reinit_completion(&mw->mw_complete);
1396 return mw->mw_status;
1397}
1398
1399static void lockres_add_mask_waiter(struct ocfs2_lock_res *lockres,
1400 struct ocfs2_mask_waiter *mw,
1401 unsigned long mask,
1402 unsigned long goal)
1403{
1404 BUG_ON(!list_empty(&mw->mw_item));
1405
1406 assert_spin_locked(&lockres->l_lock);
1407
1408 list_add_tail(&mw->mw_item, &lockres->l_mask_waiters);
1409 mw->mw_mask = mask;
1410 mw->mw_goal = goal;
1411 ocfs2_track_lock_wait(lockres);
1412}
1413
1414
1415
1416static int __lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1417 struct ocfs2_mask_waiter *mw)
1418{
1419 int ret = 0;
1420
1421 assert_spin_locked(&lockres->l_lock);
1422 if (!list_empty(&mw->mw_item)) {
1423 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
1424 ret = -EBUSY;
1425
1426 list_del_init(&mw->mw_item);
1427 init_completion(&mw->mw_complete);
1428 ocfs2_track_lock_wait(lockres);
1429 }
1430
1431 return ret;
1432}
1433
1434static int lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1435 struct ocfs2_mask_waiter *mw)
1436{
1437 unsigned long flags;
1438 int ret = 0;
1439
1440 spin_lock_irqsave(&lockres->l_lock, flags);
1441 ret = __lockres_remove_mask_waiter(lockres, mw);
1442 spin_unlock_irqrestore(&lockres->l_lock, flags);
1443
1444 return ret;
1445
1446}
1447
1448static int ocfs2_wait_for_mask_interruptible(struct ocfs2_mask_waiter *mw,
1449 struct ocfs2_lock_res *lockres)
1450{
1451 int ret;
1452
1453 ret = wait_for_completion_interruptible(&mw->mw_complete);
1454 if (ret)
1455 lockres_remove_mask_waiter(lockres, mw);
1456 else
1457 ret = mw->mw_status;
1458
1459 reinit_completion(&mw->mw_complete);
1460 return ret;
1461}
1462
1463static int __ocfs2_cluster_lock(struct ocfs2_super *osb,
1464 struct ocfs2_lock_res *lockres,
1465 int level,
1466 u32 lkm_flags,
1467 int arg_flags,
1468 int l_subclass,
1469 unsigned long caller_ip)
1470{
1471 struct ocfs2_mask_waiter mw;
1472 int wait, catch_signals = !(osb->s_mount_opt & OCFS2_MOUNT_NOINTR);
1473 int ret = 0;
1474 unsigned long flags;
1475 unsigned int gen;
1476 int noqueue_attempted = 0;
1477 int dlm_locked = 0;
1478 int kick_dc = 0;
1479
1480 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED)) {
1481 mlog_errno(-EINVAL);
1482 return -EINVAL;
1483 }
1484
1485 ocfs2_init_mask_waiter(&mw);
1486
1487 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
1488 lkm_flags |= DLM_LKF_VALBLK;
1489
1490again:
1491 wait = 0;
1492
1493 spin_lock_irqsave(&lockres->l_lock, flags);
1494
1495 if (catch_signals && signal_pending(current)) {
1496 ret = -ERESTARTSYS;
1497 goto unlock;
1498 }
1499
1500 mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING,
1501 "Cluster lock called on freeing lockres %s! flags "
1502 "0x%lx\n", lockres->l_name, lockres->l_flags);
1503
1504
1505
1506
1507 if (lockres->l_flags & OCFS2_LOCK_BUSY &&
1508 level > lockres->l_level) {
1509
1510
1511 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1512 wait = 1;
1513 goto unlock;
1514 }
1515
1516 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) {
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531 if (level <= lockres->l_level)
1532 goto update_holders;
1533 }
1534
1535 if (lockres->l_flags & OCFS2_LOCK_BLOCKED &&
1536 !ocfs2_may_continue_on_blocked_lock(lockres, level)) {
1537
1538
1539 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BLOCKED, 0);
1540 wait = 1;
1541 goto unlock;
1542 }
1543
1544 if (level > lockres->l_level) {
1545 if (noqueue_attempted > 0) {
1546 ret = -EAGAIN;
1547 goto unlock;
1548 }
1549 if (lkm_flags & DLM_LKF_NOQUEUE)
1550 noqueue_attempted = 1;
1551
1552 if (lockres->l_action != OCFS2_AST_INVALID)
1553 mlog(ML_ERROR, "lockres %s has action %u pending\n",
1554 lockres->l_name, lockres->l_action);
1555
1556 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1557 lockres->l_action = OCFS2_AST_ATTACH;
1558 lkm_flags &= ~DLM_LKF_CONVERT;
1559 } else {
1560 lockres->l_action = OCFS2_AST_CONVERT;
1561 lkm_flags |= DLM_LKF_CONVERT;
1562 }
1563
1564 lockres->l_requested = level;
1565 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1566 gen = lockres_set_pending(lockres);
1567 spin_unlock_irqrestore(&lockres->l_lock, flags);
1568
1569 BUG_ON(level == DLM_LOCK_IV);
1570 BUG_ON(level == DLM_LOCK_NL);
1571
1572 mlog(ML_BASTS, "lockres %s, convert from %d to %d\n",
1573 lockres->l_name, lockres->l_level, level);
1574
1575
1576 ret = ocfs2_dlm_lock(osb->cconn,
1577 level,
1578 &lockres->l_lksb,
1579 lkm_flags,
1580 lockres->l_name,
1581 OCFS2_LOCK_ID_MAX_LEN - 1);
1582 lockres_clear_pending(lockres, gen, osb);
1583 if (ret) {
1584 if (!(lkm_flags & DLM_LKF_NOQUEUE) ||
1585 (ret != -EAGAIN)) {
1586 ocfs2_log_dlm_error("ocfs2_dlm_lock",
1587 ret, lockres);
1588 }
1589 ocfs2_recover_from_dlm_error(lockres, 1);
1590 goto out;
1591 }
1592 dlm_locked = 1;
1593
1594 mlog(0, "lock %s, successful return from ocfs2_dlm_lock\n",
1595 lockres->l_name);
1596
1597
1598
1599 catch_signals = 0;
1600
1601
1602 goto again;
1603 }
1604
1605update_holders:
1606
1607 ocfs2_inc_holders(lockres, level);
1608
1609 ret = 0;
1610unlock:
1611 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1612
1613
1614 kick_dc = (lockres->l_flags & OCFS2_LOCK_BLOCKED);
1615
1616 spin_unlock_irqrestore(&lockres->l_lock, flags);
1617 if (kick_dc)
1618 ocfs2_wake_downconvert_thread(osb);
1619out:
1620
1621
1622
1623
1624
1625
1626
1627
1628 if (wait && arg_flags & OCFS2_LOCK_NONBLOCK &&
1629 mw.mw_mask & (OCFS2_LOCK_BUSY|OCFS2_LOCK_BLOCKED)) {
1630 wait = 0;
1631 spin_lock_irqsave(&lockres->l_lock, flags);
1632 if (__lockres_remove_mask_waiter(lockres, &mw)) {
1633 if (dlm_locked)
1634 lockres_or_flags(lockres,
1635 OCFS2_LOCK_NONBLOCK_FINISHED);
1636 spin_unlock_irqrestore(&lockres->l_lock, flags);
1637 ret = -EAGAIN;
1638 } else {
1639 spin_unlock_irqrestore(&lockres->l_lock, flags);
1640 goto again;
1641 }
1642 }
1643 if (wait) {
1644 ret = ocfs2_wait_for_mask(&mw);
1645 if (ret == 0)
1646 goto again;
1647 mlog_errno(ret);
1648 }
1649 ocfs2_update_lock_stats(lockres, level, &mw, ret);
1650
1651#ifdef CONFIG_DEBUG_LOCK_ALLOC
1652 if (!ret && lockres->l_lockdep_map.key != NULL) {
1653 if (level == DLM_LOCK_PR)
1654 rwsem_acquire_read(&lockres->l_lockdep_map, l_subclass,
1655 !!(arg_flags & OCFS2_META_LOCK_NOQUEUE),
1656 caller_ip);
1657 else
1658 rwsem_acquire(&lockres->l_lockdep_map, l_subclass,
1659 !!(arg_flags & OCFS2_META_LOCK_NOQUEUE),
1660 caller_ip);
1661 }
1662#endif
1663 return ret;
1664}
1665
1666static inline int ocfs2_cluster_lock(struct ocfs2_super *osb,
1667 struct ocfs2_lock_res *lockres,
1668 int level,
1669 u32 lkm_flags,
1670 int arg_flags)
1671{
1672 return __ocfs2_cluster_lock(osb, lockres, level, lkm_flags, arg_flags,
1673 0, _RET_IP_);
1674}
1675
1676
1677static void __ocfs2_cluster_unlock(struct ocfs2_super *osb,
1678 struct ocfs2_lock_res *lockres,
1679 int level,
1680 unsigned long caller_ip)
1681{
1682 unsigned long flags;
1683
1684 spin_lock_irqsave(&lockres->l_lock, flags);
1685 ocfs2_dec_holders(lockres, level);
1686 ocfs2_downconvert_on_unlock(osb, lockres);
1687 spin_unlock_irqrestore(&lockres->l_lock, flags);
1688#ifdef CONFIG_DEBUG_LOCK_ALLOC
1689 if (lockres->l_lockdep_map.key != NULL)
1690 rwsem_release(&lockres->l_lockdep_map, 1, caller_ip);
1691#endif
1692}
1693
1694static int ocfs2_create_new_lock(struct ocfs2_super *osb,
1695 struct ocfs2_lock_res *lockres,
1696 int ex,
1697 int local)
1698{
1699 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
1700 unsigned long flags;
1701 u32 lkm_flags = local ? DLM_LKF_LOCAL : 0;
1702
1703 spin_lock_irqsave(&lockres->l_lock, flags);
1704 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
1705 lockres_or_flags(lockres, OCFS2_LOCK_LOCAL);
1706 spin_unlock_irqrestore(&lockres->l_lock, flags);
1707
1708 return ocfs2_lock_create(osb, lockres, level, lkm_flags);
1709}
1710
1711
1712
1713
1714
1715
1716
1717int ocfs2_create_new_inode_locks(struct inode *inode)
1718{
1719 int ret;
1720 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1721
1722 BUG_ON(!ocfs2_inode_is_new(inode));
1723
1724 mlog(0, "Inode %llu\n", (unsigned long long)OCFS2_I(inode)->ip_blkno);
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_rw_lockres, 1, 1);
1735 if (ret) {
1736 mlog_errno(ret);
1737 goto bail;
1738 }
1739
1740
1741
1742
1743
1744 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_inode_lockres, 1, 0);
1745 if (ret) {
1746 mlog_errno(ret);
1747 goto bail;
1748 }
1749
1750 ret = ocfs2_create_new_lock(osb, &OCFS2_I(inode)->ip_open_lockres, 0, 0);
1751 if (ret)
1752 mlog_errno(ret);
1753
1754bail:
1755 return ret;
1756}
1757
1758int ocfs2_rw_lock(struct inode *inode, int write)
1759{
1760 int status, level;
1761 struct ocfs2_lock_res *lockres;
1762 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1763
1764 mlog(0, "inode %llu take %s RW lock\n",
1765 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1766 write ? "EXMODE" : "PRMODE");
1767
1768 if (ocfs2_mount_local(osb))
1769 return 0;
1770
1771 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1772
1773 level = write ? DLM_LOCK_EX : DLM_LOCK_PR;
1774
1775 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
1776 if (status < 0)
1777 mlog_errno(status);
1778
1779 return status;
1780}
1781
1782int ocfs2_try_rw_lock(struct inode *inode, int write)
1783{
1784 int status, level;
1785 struct ocfs2_lock_res *lockres;
1786 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1787
1788 mlog(0, "inode %llu try to take %s RW lock\n",
1789 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1790 write ? "EXMODE" : "PRMODE");
1791
1792 if (ocfs2_mount_local(osb))
1793 return 0;
1794
1795 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1796
1797 level = write ? DLM_LOCK_EX : DLM_LOCK_PR;
1798
1799 status = ocfs2_cluster_lock(osb, lockres, level, DLM_LKF_NOQUEUE, 0);
1800 return status;
1801}
1802
1803void ocfs2_rw_unlock(struct inode *inode, int write)
1804{
1805 int level = write ? DLM_LOCK_EX : DLM_LOCK_PR;
1806 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_rw_lockres;
1807 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1808
1809 mlog(0, "inode %llu drop %s RW lock\n",
1810 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1811 write ? "EXMODE" : "PRMODE");
1812
1813 if (!ocfs2_mount_local(osb))
1814 ocfs2_cluster_unlock(osb, lockres, level);
1815}
1816
1817
1818
1819
1820int ocfs2_open_lock(struct inode *inode)
1821{
1822 int status = 0;
1823 struct ocfs2_lock_res *lockres;
1824 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1825
1826 mlog(0, "inode %llu take PRMODE open lock\n",
1827 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1828
1829 if (ocfs2_is_hard_readonly(osb) || ocfs2_mount_local(osb))
1830 goto out;
1831
1832 lockres = &OCFS2_I(inode)->ip_open_lockres;
1833
1834 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_PR, 0, 0);
1835 if (status < 0)
1836 mlog_errno(status);
1837
1838out:
1839 return status;
1840}
1841
1842int ocfs2_try_open_lock(struct inode *inode, int write)
1843{
1844 int status = 0, level;
1845 struct ocfs2_lock_res *lockres;
1846 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1847
1848 mlog(0, "inode %llu try to take %s open lock\n",
1849 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1850 write ? "EXMODE" : "PRMODE");
1851
1852 if (ocfs2_is_hard_readonly(osb)) {
1853 if (write)
1854 status = -EROFS;
1855 goto out;
1856 }
1857
1858 if (ocfs2_mount_local(osb))
1859 goto out;
1860
1861 lockres = &OCFS2_I(inode)->ip_open_lockres;
1862
1863 level = write ? DLM_LOCK_EX : DLM_LOCK_PR;
1864
1865
1866
1867
1868
1869
1870
1871 status = ocfs2_cluster_lock(osb, lockres, level, DLM_LKF_NOQUEUE, 0);
1872
1873out:
1874 return status;
1875}
1876
1877
1878
1879
1880void ocfs2_open_unlock(struct inode *inode)
1881{
1882 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_open_lockres;
1883 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1884
1885 mlog(0, "inode %llu drop open lock\n",
1886 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1887
1888 if (ocfs2_mount_local(osb))
1889 goto out;
1890
1891 if(lockres->l_ro_holders)
1892 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_PR);
1893 if(lockres->l_ex_holders)
1894 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
1895
1896out:
1897 return;
1898}
1899
1900static int ocfs2_flock_handle_signal(struct ocfs2_lock_res *lockres,
1901 int level)
1902{
1903 int ret;
1904 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1905 unsigned long flags;
1906 struct ocfs2_mask_waiter mw;
1907
1908 ocfs2_init_mask_waiter(&mw);
1909
1910retry_cancel:
1911 spin_lock_irqsave(&lockres->l_lock, flags);
1912 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
1913 ret = ocfs2_prepare_cancel_convert(osb, lockres);
1914 if (ret) {
1915 spin_unlock_irqrestore(&lockres->l_lock, flags);
1916 ret = ocfs2_cancel_convert(osb, lockres);
1917 if (ret < 0) {
1918 mlog_errno(ret);
1919 goto out;
1920 }
1921 goto retry_cancel;
1922 }
1923 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1924 spin_unlock_irqrestore(&lockres->l_lock, flags);
1925
1926 ocfs2_wait_for_mask(&mw);
1927 goto retry_cancel;
1928 }
1929
1930 ret = -ERESTARTSYS;
1931
1932
1933
1934
1935 if (lockres->l_level == level)
1936 ret = 0;
1937
1938 mlog(0, "Cancel returning %d. flags: 0x%lx, level: %d, act: %d\n", ret,
1939 lockres->l_flags, lockres->l_level, lockres->l_action);
1940
1941 spin_unlock_irqrestore(&lockres->l_lock, flags);
1942
1943out:
1944 return ret;
1945}
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968int ocfs2_file_lock(struct file *file, int ex, int trylock)
1969{
1970 int ret, level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
1971 unsigned int lkm_flags = trylock ? DLM_LKF_NOQUEUE : 0;
1972 unsigned long flags;
1973 struct ocfs2_file_private *fp = file->private_data;
1974 struct ocfs2_lock_res *lockres = &fp->fp_flock;
1975 struct ocfs2_super *osb = OCFS2_SB(file->f_mapping->host->i_sb);
1976 struct ocfs2_mask_waiter mw;
1977
1978 ocfs2_init_mask_waiter(&mw);
1979
1980 if ((lockres->l_flags & OCFS2_LOCK_BUSY) ||
1981 (lockres->l_level > DLM_LOCK_NL)) {
1982 mlog(ML_ERROR,
1983 "File lock \"%s\" has busy or locked state: flags: 0x%lx, "
1984 "level: %u\n", lockres->l_name, lockres->l_flags,
1985 lockres->l_level);
1986 return -EINVAL;
1987 }
1988
1989 spin_lock_irqsave(&lockres->l_lock, flags);
1990 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1991 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1992 spin_unlock_irqrestore(&lockres->l_lock, flags);
1993
1994
1995
1996
1997
1998 ret = ocfs2_lock_create(osb, lockres, DLM_LOCK_NL, 0);
1999 if (ret < 0) {
2000 mlog_errno(ret);
2001 goto out;
2002 }
2003
2004 ret = ocfs2_wait_for_mask(&mw);
2005 if (ret) {
2006 mlog_errno(ret);
2007 goto out;
2008 }
2009 spin_lock_irqsave(&lockres->l_lock, flags);
2010 }
2011
2012 lockres->l_action = OCFS2_AST_CONVERT;
2013 lkm_flags |= DLM_LKF_CONVERT;
2014 lockres->l_requested = level;
2015 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
2016
2017 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2018 spin_unlock_irqrestore(&lockres->l_lock, flags);
2019
2020 ret = ocfs2_dlm_lock(osb->cconn, level, &lockres->l_lksb, lkm_flags,
2021 lockres->l_name, OCFS2_LOCK_ID_MAX_LEN - 1);
2022 if (ret) {
2023 if (!trylock || (ret != -EAGAIN)) {
2024 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
2025 ret = -EINVAL;
2026 }
2027
2028 ocfs2_recover_from_dlm_error(lockres, 1);
2029 lockres_remove_mask_waiter(lockres, &mw);
2030 goto out;
2031 }
2032
2033 ret = ocfs2_wait_for_mask_interruptible(&mw, lockres);
2034 if (ret == -ERESTARTSYS) {
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050 ret = ocfs2_flock_handle_signal(lockres, level);
2051 } else if (!ret && (level > lockres->l_level)) {
2052
2053 BUG_ON(!trylock);
2054 ret = -EAGAIN;
2055 }
2056
2057out:
2058
2059 mlog(0, "Lock: \"%s\" ex: %d, trylock: %d, returns: %d\n",
2060 lockres->l_name, ex, trylock, ret);
2061 return ret;
2062}
2063
2064void ocfs2_file_unlock(struct file *file)
2065{
2066 int ret;
2067 unsigned int gen;
2068 unsigned long flags;
2069 struct ocfs2_file_private *fp = file->private_data;
2070 struct ocfs2_lock_res *lockres = &fp->fp_flock;
2071 struct ocfs2_super *osb = OCFS2_SB(file->f_mapping->host->i_sb);
2072 struct ocfs2_mask_waiter mw;
2073
2074 ocfs2_init_mask_waiter(&mw);
2075
2076 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED))
2077 return;
2078
2079 if (lockres->l_level == DLM_LOCK_NL)
2080 return;
2081
2082 mlog(0, "Unlock: \"%s\" flags: 0x%lx, level: %d, act: %d\n",
2083 lockres->l_name, lockres->l_flags, lockres->l_level,
2084 lockres->l_action);
2085
2086 spin_lock_irqsave(&lockres->l_lock, flags);
2087
2088
2089
2090 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
2091 lockres->l_blocking = DLM_LOCK_EX;
2092
2093 gen = ocfs2_prepare_downconvert(lockres, DLM_LOCK_NL);
2094 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2095 spin_unlock_irqrestore(&lockres->l_lock, flags);
2096
2097 ret = ocfs2_downconvert_lock(osb, lockres, DLM_LOCK_NL, 0, gen);
2098 if (ret) {
2099 mlog_errno(ret);
2100 return;
2101 }
2102
2103 ret = ocfs2_wait_for_mask(&mw);
2104 if (ret)
2105 mlog_errno(ret);
2106}
2107
2108static void ocfs2_downconvert_on_unlock(struct ocfs2_super *osb,
2109 struct ocfs2_lock_res *lockres)
2110{
2111 int kick = 0;
2112
2113
2114
2115
2116 if (lockres->l_flags & OCFS2_LOCK_BLOCKED) {
2117 switch(lockres->l_blocking) {
2118 case DLM_LOCK_EX:
2119 if (!lockres->l_ex_holders && !lockres->l_ro_holders)
2120 kick = 1;
2121 break;
2122 case DLM_LOCK_PR:
2123 if (!lockres->l_ex_holders)
2124 kick = 1;
2125 break;
2126 default:
2127 BUG();
2128 }
2129 }
2130
2131 if (kick)
2132 ocfs2_wake_downconvert_thread(osb);
2133}
2134
2135#define OCFS2_SEC_BITS 34
2136#define OCFS2_SEC_SHIFT (64 - 34)
2137#define OCFS2_NSEC_MASK ((1ULL << OCFS2_SEC_SHIFT) - 1)
2138
2139
2140
2141static u64 ocfs2_pack_timespec(struct timespec64 *spec)
2142{
2143 u64 res;
2144 u64 sec = clamp_t(time64_t, spec->tv_sec, 0, 0x3ffffffffull);
2145 u32 nsec = spec->tv_nsec;
2146
2147 res = (sec << OCFS2_SEC_SHIFT) | (nsec & OCFS2_NSEC_MASK);
2148
2149 return res;
2150}
2151
2152
2153
2154
2155static void __ocfs2_stuff_meta_lvb(struct inode *inode)
2156{
2157 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2158 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2159 struct ocfs2_meta_lvb *lvb;
2160
2161 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2162
2163
2164
2165
2166
2167
2168 if (oi->ip_flags & OCFS2_INODE_DELETED) {
2169 lvb->lvb_version = 0;
2170 goto out;
2171 }
2172
2173 lvb->lvb_version = OCFS2_LVB_VERSION;
2174 lvb->lvb_isize = cpu_to_be64(i_size_read(inode));
2175 lvb->lvb_iclusters = cpu_to_be32(oi->ip_clusters);
2176 lvb->lvb_iuid = cpu_to_be32(i_uid_read(inode));
2177 lvb->lvb_igid = cpu_to_be32(i_gid_read(inode));
2178 lvb->lvb_imode = cpu_to_be16(inode->i_mode);
2179 lvb->lvb_inlink = cpu_to_be16(inode->i_nlink);
2180 lvb->lvb_iatime_packed =
2181 cpu_to_be64(ocfs2_pack_timespec(&inode->i_atime));
2182 lvb->lvb_ictime_packed =
2183 cpu_to_be64(ocfs2_pack_timespec(&inode->i_ctime));
2184 lvb->lvb_imtime_packed =
2185 cpu_to_be64(ocfs2_pack_timespec(&inode->i_mtime));
2186 lvb->lvb_iattr = cpu_to_be32(oi->ip_attr);
2187 lvb->lvb_idynfeatures = cpu_to_be16(oi->ip_dyn_features);
2188 lvb->lvb_igeneration = cpu_to_be32(inode->i_generation);
2189
2190out:
2191 mlog_meta_lvb(0, lockres);
2192}
2193
2194static void ocfs2_unpack_timespec(struct timespec64 *spec,
2195 u64 packed_time)
2196{
2197 spec->tv_sec = packed_time >> OCFS2_SEC_SHIFT;
2198 spec->tv_nsec = packed_time & OCFS2_NSEC_MASK;
2199}
2200
2201static void ocfs2_refresh_inode_from_lvb(struct inode *inode)
2202{
2203 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2204 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2205 struct ocfs2_meta_lvb *lvb;
2206
2207 mlog_meta_lvb(0, lockres);
2208
2209 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2210
2211
2212 spin_lock(&oi->ip_lock);
2213 oi->ip_clusters = be32_to_cpu(lvb->lvb_iclusters);
2214 i_size_write(inode, be64_to_cpu(lvb->lvb_isize));
2215
2216 oi->ip_attr = be32_to_cpu(lvb->lvb_iattr);
2217 oi->ip_dyn_features = be16_to_cpu(lvb->lvb_idynfeatures);
2218 ocfs2_set_inode_flags(inode);
2219
2220
2221 if (S_ISLNK(inode->i_mode) && !oi->ip_clusters)
2222 inode->i_blocks = 0;
2223 else
2224 inode->i_blocks = ocfs2_inode_sector_count(inode);
2225
2226 i_uid_write(inode, be32_to_cpu(lvb->lvb_iuid));
2227 i_gid_write(inode, be32_to_cpu(lvb->lvb_igid));
2228 inode->i_mode = be16_to_cpu(lvb->lvb_imode);
2229 set_nlink(inode, be16_to_cpu(lvb->lvb_inlink));
2230 ocfs2_unpack_timespec(&inode->i_atime,
2231 be64_to_cpu(lvb->lvb_iatime_packed));
2232 ocfs2_unpack_timespec(&inode->i_mtime,
2233 be64_to_cpu(lvb->lvb_imtime_packed));
2234 ocfs2_unpack_timespec(&inode->i_ctime,
2235 be64_to_cpu(lvb->lvb_ictime_packed));
2236 spin_unlock(&oi->ip_lock);
2237}
2238
2239static inline int ocfs2_meta_lvb_is_trustable(struct inode *inode,
2240 struct ocfs2_lock_res *lockres)
2241{
2242 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2243
2244 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb)
2245 && lvb->lvb_version == OCFS2_LVB_VERSION
2246 && be32_to_cpu(lvb->lvb_igeneration) == inode->i_generation)
2247 return 1;
2248 return 0;
2249}
2250
2251
2252
2253
2254
2255
2256
2257
2258static int ocfs2_should_refresh_lock_res(struct ocfs2_lock_res *lockres)
2259{
2260 unsigned long flags;
2261 int status = 0;
2262
2263refresh_check:
2264 spin_lock_irqsave(&lockres->l_lock, flags);
2265 if (!(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH)) {
2266 spin_unlock_irqrestore(&lockres->l_lock, flags);
2267 goto bail;
2268 }
2269
2270 if (lockres->l_flags & OCFS2_LOCK_REFRESHING) {
2271 spin_unlock_irqrestore(&lockres->l_lock, flags);
2272
2273 ocfs2_wait_on_refreshing_lock(lockres);
2274 goto refresh_check;
2275 }
2276
2277
2278 lockres_or_flags(lockres, OCFS2_LOCK_REFRESHING);
2279 spin_unlock_irqrestore(&lockres->l_lock, flags);
2280
2281 status = 1;
2282bail:
2283 mlog(0, "status %d\n", status);
2284 return status;
2285}
2286
2287
2288
2289static inline void ocfs2_complete_lock_res_refresh(struct ocfs2_lock_res *lockres,
2290 int status)
2291{
2292 unsigned long flags;
2293
2294 spin_lock_irqsave(&lockres->l_lock, flags);
2295 lockres_clear_flags(lockres, OCFS2_LOCK_REFRESHING);
2296 if (!status)
2297 lockres_clear_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
2298 spin_unlock_irqrestore(&lockres->l_lock, flags);
2299
2300 wake_up(&lockres->l_event);
2301}
2302
2303
2304static int ocfs2_inode_lock_update(struct inode *inode,
2305 struct buffer_head **bh)
2306{
2307 int status = 0;
2308 struct ocfs2_inode_info *oi = OCFS2_I(inode);
2309 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2310 struct ocfs2_dinode *fe;
2311 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2312
2313 if (ocfs2_mount_local(osb))
2314 goto bail;
2315
2316 spin_lock(&oi->ip_lock);
2317 if (oi->ip_flags & OCFS2_INODE_DELETED) {
2318 mlog(0, "Orphaned inode %llu was deleted while we "
2319 "were waiting on a lock. ip_flags = 0x%x\n",
2320 (unsigned long long)oi->ip_blkno, oi->ip_flags);
2321 spin_unlock(&oi->ip_lock);
2322 status = -ENOENT;
2323 goto bail;
2324 }
2325 spin_unlock(&oi->ip_lock);
2326
2327 if (!ocfs2_should_refresh_lock_res(lockres))
2328 goto bail;
2329
2330
2331
2332 ocfs2_metadata_cache_purge(INODE_CACHE(inode));
2333
2334 ocfs2_extent_map_trunc(inode, 0);
2335
2336 if (ocfs2_meta_lvb_is_trustable(inode, lockres)) {
2337 mlog(0, "Trusting LVB on inode %llu\n",
2338 (unsigned long long)oi->ip_blkno);
2339 ocfs2_refresh_inode_from_lvb(inode);
2340 } else {
2341
2342
2343 status = ocfs2_read_inode_block(inode, bh);
2344 if (status < 0) {
2345 mlog_errno(status);
2346 goto bail_refresh;
2347 }
2348 fe = (struct ocfs2_dinode *) (*bh)->b_data;
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359 mlog_bug_on_msg(inode->i_generation !=
2360 le32_to_cpu(fe->i_generation),
2361 "Invalid dinode %llu disk generation: %u "
2362 "inode->i_generation: %u\n",
2363 (unsigned long long)oi->ip_blkno,
2364 le32_to_cpu(fe->i_generation),
2365 inode->i_generation);
2366 mlog_bug_on_msg(le64_to_cpu(fe->i_dtime) ||
2367 !(fe->i_flags & cpu_to_le32(OCFS2_VALID_FL)),
2368 "Stale dinode %llu dtime: %llu flags: 0x%x\n",
2369 (unsigned long long)oi->ip_blkno,
2370 (unsigned long long)le64_to_cpu(fe->i_dtime),
2371 le32_to_cpu(fe->i_flags));
2372
2373 ocfs2_refresh_inode(inode, fe);
2374 ocfs2_track_lock_refresh(lockres);
2375 }
2376
2377 status = 0;
2378bail_refresh:
2379 ocfs2_complete_lock_res_refresh(lockres, status);
2380bail:
2381 return status;
2382}
2383
2384static int ocfs2_assign_bh(struct inode *inode,
2385 struct buffer_head **ret_bh,
2386 struct buffer_head *passed_bh)
2387{
2388 int status;
2389
2390 if (passed_bh) {
2391
2392
2393 *ret_bh = passed_bh;
2394 get_bh(*ret_bh);
2395
2396 return 0;
2397 }
2398
2399 status = ocfs2_read_inode_block(inode, ret_bh);
2400 if (status < 0)
2401 mlog_errno(status);
2402
2403 return status;
2404}
2405
2406
2407
2408
2409
2410int ocfs2_inode_lock_full_nested(struct inode *inode,
2411 struct buffer_head **ret_bh,
2412 int ex,
2413 int arg_flags,
2414 int subclass)
2415{
2416 int status, level, acquired;
2417 u32 dlm_flags;
2418 struct ocfs2_lock_res *lockres = NULL;
2419 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2420 struct buffer_head *local_bh = NULL;
2421
2422 mlog(0, "inode %llu, take %s META lock\n",
2423 (unsigned long long)OCFS2_I(inode)->ip_blkno,
2424 ex ? "EXMODE" : "PRMODE");
2425
2426 status = 0;
2427 acquired = 0;
2428
2429
2430 if (ocfs2_is_hard_readonly(osb)) {
2431 if (ex)
2432 status = -EROFS;
2433 goto getbh;
2434 }
2435
2436 if ((arg_flags & OCFS2_META_LOCK_GETBH) ||
2437 ocfs2_mount_local(osb))
2438 goto update;
2439
2440 if (!(arg_flags & OCFS2_META_LOCK_RECOVERY))
2441 ocfs2_wait_for_recovery(osb);
2442
2443 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2444 level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2445 dlm_flags = 0;
2446 if (arg_flags & OCFS2_META_LOCK_NOQUEUE)
2447 dlm_flags |= DLM_LKF_NOQUEUE;
2448
2449 status = __ocfs2_cluster_lock(osb, lockres, level, dlm_flags,
2450 arg_flags, subclass, _RET_IP_);
2451 if (status < 0) {
2452 if (status != -EAGAIN)
2453 mlog_errno(status);
2454 goto bail;
2455 }
2456
2457
2458 acquired = 1;
2459
2460
2461
2462
2463
2464 if (!(arg_flags & OCFS2_META_LOCK_RECOVERY))
2465 ocfs2_wait_for_recovery(osb);
2466
2467update:
2468
2469
2470
2471
2472
2473
2474 if (inode->i_state & I_NEW) {
2475 status = 0;
2476 if (lockres)
2477 ocfs2_complete_lock_res_refresh(lockres, 0);
2478 goto bail;
2479 }
2480
2481
2482
2483
2484
2485
2486 status = ocfs2_inode_lock_update(inode, &local_bh);
2487 if (status < 0) {
2488 if (status != -ENOENT)
2489 mlog_errno(status);
2490 goto bail;
2491 }
2492getbh:
2493 if (ret_bh) {
2494 status = ocfs2_assign_bh(inode, ret_bh, local_bh);
2495 if (status < 0) {
2496 mlog_errno(status);
2497 goto bail;
2498 }
2499 }
2500
2501bail:
2502 if (status < 0) {
2503 if (ret_bh && (*ret_bh)) {
2504 brelse(*ret_bh);
2505 *ret_bh = NULL;
2506 }
2507 if (acquired)
2508 ocfs2_inode_unlock(inode, ex);
2509 }
2510
2511 if (local_bh)
2512 brelse(local_bh);
2513
2514 return status;
2515}
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533int ocfs2_inode_lock_with_page(struct inode *inode,
2534 struct buffer_head **ret_bh,
2535 int ex,
2536 struct page *page)
2537{
2538 int ret;
2539
2540 ret = ocfs2_inode_lock_full(inode, ret_bh, ex, OCFS2_LOCK_NONBLOCK);
2541 if (ret == -EAGAIN) {
2542 unlock_page(page);
2543
2544
2545
2546
2547
2548
2549
2550 if (ocfs2_inode_lock(inode, ret_bh, ex) == 0)
2551 ocfs2_inode_unlock(inode, ex);
2552 ret = AOP_TRUNCATED_PAGE;
2553 }
2554
2555 return ret;
2556}
2557
2558int ocfs2_inode_lock_atime(struct inode *inode,
2559 struct vfsmount *vfsmnt,
2560 int *level, int wait)
2561{
2562 int ret;
2563
2564 if (wait)
2565 ret = ocfs2_inode_lock(inode, NULL, 0);
2566 else
2567 ret = ocfs2_try_inode_lock(inode, NULL, 0);
2568
2569 if (ret < 0) {
2570 if (ret != -EAGAIN)
2571 mlog_errno(ret);
2572 return ret;
2573 }
2574
2575
2576
2577
2578
2579 if (ocfs2_should_update_atime(inode, vfsmnt)) {
2580 struct buffer_head *bh = NULL;
2581
2582 ocfs2_inode_unlock(inode, 0);
2583 if (wait)
2584 ret = ocfs2_inode_lock(inode, &bh, 1);
2585 else
2586 ret = ocfs2_try_inode_lock(inode, &bh, 1);
2587
2588 if (ret < 0) {
2589 if (ret != -EAGAIN)
2590 mlog_errno(ret);
2591 return ret;
2592 }
2593 *level = 1;
2594 if (ocfs2_should_update_atime(inode, vfsmnt))
2595 ocfs2_update_inode_atime(inode, bh);
2596 if (bh)
2597 brelse(bh);
2598 } else
2599 *level = 0;
2600
2601 return ret;
2602}
2603
2604void ocfs2_inode_unlock(struct inode *inode,
2605 int ex)
2606{
2607 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2608 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_inode_lockres;
2609 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2610
2611 mlog(0, "inode %llu drop %s META lock\n",
2612 (unsigned long long)OCFS2_I(inode)->ip_blkno,
2613 ex ? "EXMODE" : "PRMODE");
2614
2615 if (!ocfs2_is_hard_readonly(osb) &&
2616 !ocfs2_mount_local(osb))
2617 ocfs2_cluster_unlock(osb, lockres, level);
2618}
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661int ocfs2_inode_lock_tracker(struct inode *inode,
2662 struct buffer_head **ret_bh,
2663 int ex,
2664 struct ocfs2_lock_holder *oh)
2665{
2666 int status = 0;
2667 struct ocfs2_lock_res *lockres;
2668 struct ocfs2_lock_holder *tmp_oh;
2669 struct pid *pid = task_pid(current);
2670
2671
2672 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2673 tmp_oh = ocfs2_pid_holder(lockres, pid);
2674
2675 if (!tmp_oh) {
2676
2677
2678
2679
2680 status = ocfs2_inode_lock_full(inode, ret_bh, ex, 0);
2681 if (status < 0) {
2682 if (status != -ENOENT)
2683 mlog_errno(status);
2684 return status;
2685 }
2686
2687 oh->oh_ex = ex;
2688 ocfs2_add_holder(lockres, oh);
2689 return 0;
2690 }
2691
2692 if (unlikely(ex && !tmp_oh->oh_ex)) {
2693
2694
2695
2696 mlog(ML_ERROR, "Recursive locking is not permitted to "
2697 "upgrade to EX level from PR level.\n");
2698 dump_stack();
2699 return -EINVAL;
2700 }
2701
2702
2703
2704
2705
2706 if (ret_bh) {
2707 status = ocfs2_inode_lock_full(inode, ret_bh, ex,
2708 OCFS2_META_LOCK_GETBH);
2709 if (status < 0) {
2710 if (status != -ENOENT)
2711 mlog_errno(status);
2712 return status;
2713 }
2714 }
2715 return tmp_oh ? 1 : 0;
2716}
2717
2718void ocfs2_inode_unlock_tracker(struct inode *inode,
2719 int ex,
2720 struct ocfs2_lock_holder *oh,
2721 int had_lock)
2722{
2723 struct ocfs2_lock_res *lockres;
2724
2725 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2726
2727
2728
2729
2730
2731 if (!had_lock) {
2732 ocfs2_inode_unlock(inode, oh->oh_ex);
2733 ocfs2_remove_holder(lockres, oh);
2734 }
2735}
2736
2737int ocfs2_orphan_scan_lock(struct ocfs2_super *osb, u32 *seqno)
2738{
2739 struct ocfs2_lock_res *lockres;
2740 struct ocfs2_orphan_scan_lvb *lvb;
2741 int status = 0;
2742
2743 if (ocfs2_is_hard_readonly(osb))
2744 return -EROFS;
2745
2746 if (ocfs2_mount_local(osb))
2747 return 0;
2748
2749 lockres = &osb->osb_orphan_scan.os_lockres;
2750 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2751 if (status < 0)
2752 return status;
2753
2754 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2755 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2756 lvb->lvb_version == OCFS2_ORPHAN_LVB_VERSION)
2757 *seqno = be32_to_cpu(lvb->lvb_os_seqno);
2758 else
2759 *seqno = osb->osb_orphan_scan.os_seqno + 1;
2760
2761 return status;
2762}
2763
2764void ocfs2_orphan_scan_unlock(struct ocfs2_super *osb, u32 seqno)
2765{
2766 struct ocfs2_lock_res *lockres;
2767 struct ocfs2_orphan_scan_lvb *lvb;
2768
2769 if (!ocfs2_is_hard_readonly(osb) && !ocfs2_mount_local(osb)) {
2770 lockres = &osb->osb_orphan_scan.os_lockres;
2771 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2772 lvb->lvb_version = OCFS2_ORPHAN_LVB_VERSION;
2773 lvb->lvb_os_seqno = cpu_to_be32(seqno);
2774 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2775 }
2776}
2777
2778int ocfs2_super_lock(struct ocfs2_super *osb,
2779 int ex)
2780{
2781 int status = 0;
2782 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2783 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2784
2785 if (ocfs2_is_hard_readonly(osb))
2786 return -EROFS;
2787
2788 if (ocfs2_mount_local(osb))
2789 goto bail;
2790
2791 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
2792 if (status < 0) {
2793 mlog_errno(status);
2794 goto bail;
2795 }
2796
2797
2798
2799
2800
2801 status = ocfs2_should_refresh_lock_res(lockres);
2802 if (status) {
2803 status = ocfs2_refresh_slot_info(osb);
2804
2805 ocfs2_complete_lock_res_refresh(lockres, status);
2806
2807 if (status < 0) {
2808 ocfs2_cluster_unlock(osb, lockres, level);
2809 mlog_errno(status);
2810 }
2811 ocfs2_track_lock_refresh(lockres);
2812 }
2813bail:
2814 return status;
2815}
2816
2817void ocfs2_super_unlock(struct ocfs2_super *osb,
2818 int ex)
2819{
2820 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2821 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2822
2823 if (!ocfs2_mount_local(osb))
2824 ocfs2_cluster_unlock(osb, lockres, level);
2825}
2826
2827int ocfs2_rename_lock(struct ocfs2_super *osb)
2828{
2829 int status;
2830 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2831
2832 if (ocfs2_is_hard_readonly(osb))
2833 return -EROFS;
2834
2835 if (ocfs2_mount_local(osb))
2836 return 0;
2837
2838 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2839 if (status < 0)
2840 mlog_errno(status);
2841
2842 return status;
2843}
2844
2845void ocfs2_rename_unlock(struct ocfs2_super *osb)
2846{
2847 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2848
2849 if (!ocfs2_mount_local(osb))
2850 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2851}
2852
2853int ocfs2_nfs_sync_lock(struct ocfs2_super *osb, int ex)
2854{
2855 int status;
2856 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2857
2858 if (ocfs2_is_hard_readonly(osb))
2859 return -EROFS;
2860
2861 if (ocfs2_mount_local(osb))
2862 return 0;
2863
2864 status = ocfs2_cluster_lock(osb, lockres, ex ? LKM_EXMODE : LKM_PRMODE,
2865 0, 0);
2866 if (status < 0)
2867 mlog(ML_ERROR, "lock on nfs sync lock failed %d\n", status);
2868
2869 return status;
2870}
2871
2872void ocfs2_nfs_sync_unlock(struct ocfs2_super *osb, int ex)
2873{
2874 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2875
2876 if (!ocfs2_mount_local(osb))
2877 ocfs2_cluster_unlock(osb, lockres,
2878 ex ? LKM_EXMODE : LKM_PRMODE);
2879}
2880
2881int ocfs2_trim_fs_lock(struct ocfs2_super *osb,
2882 struct ocfs2_trim_fs_info *info, int trylock)
2883{
2884 int status;
2885 struct ocfs2_trim_fs_lvb *lvb;
2886 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
2887
2888 if (info)
2889 info->tf_valid = 0;
2890
2891 if (ocfs2_is_hard_readonly(osb))
2892 return -EROFS;
2893
2894 if (ocfs2_mount_local(osb))
2895 return 0;
2896
2897 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX,
2898 trylock ? DLM_LKF_NOQUEUE : 0, 0);
2899 if (status < 0) {
2900 if (status != -EAGAIN)
2901 mlog_errno(status);
2902 return status;
2903 }
2904
2905 if (info) {
2906 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2907 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2908 lvb->lvb_version == OCFS2_TRIMFS_LVB_VERSION) {
2909 info->tf_valid = 1;
2910 info->tf_success = lvb->lvb_success;
2911 info->tf_nodenum = be32_to_cpu(lvb->lvb_nodenum);
2912 info->tf_start = be64_to_cpu(lvb->lvb_start);
2913 info->tf_len = be64_to_cpu(lvb->lvb_len);
2914 info->tf_minlen = be64_to_cpu(lvb->lvb_minlen);
2915 info->tf_trimlen = be64_to_cpu(lvb->lvb_trimlen);
2916 }
2917 }
2918
2919 return status;
2920}
2921
2922void ocfs2_trim_fs_unlock(struct ocfs2_super *osb,
2923 struct ocfs2_trim_fs_info *info)
2924{
2925 struct ocfs2_trim_fs_lvb *lvb;
2926 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
2927
2928 if (ocfs2_mount_local(osb))
2929 return;
2930
2931 if (info) {
2932 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2933 lvb->lvb_version = OCFS2_TRIMFS_LVB_VERSION;
2934 lvb->lvb_success = info->tf_success;
2935 lvb->lvb_nodenum = cpu_to_be32(info->tf_nodenum);
2936 lvb->lvb_start = cpu_to_be64(info->tf_start);
2937 lvb->lvb_len = cpu_to_be64(info->tf_len);
2938 lvb->lvb_minlen = cpu_to_be64(info->tf_minlen);
2939 lvb->lvb_trimlen = cpu_to_be64(info->tf_trimlen);
2940 }
2941
2942 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2943}
2944
2945int ocfs2_dentry_lock(struct dentry *dentry, int ex)
2946{
2947 int ret;
2948 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2949 struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
2950 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
2951
2952 BUG_ON(!dl);
2953
2954 if (ocfs2_is_hard_readonly(osb)) {
2955 if (ex)
2956 return -EROFS;
2957 return 0;
2958 }
2959
2960 if (ocfs2_mount_local(osb))
2961 return 0;
2962
2963 ret = ocfs2_cluster_lock(osb, &dl->dl_lockres, level, 0, 0);
2964 if (ret < 0)
2965 mlog_errno(ret);
2966
2967 return ret;
2968}
2969
2970void ocfs2_dentry_unlock(struct dentry *dentry, int ex)
2971{
2972 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
2973 struct ocfs2_dentry_lock *dl = dentry->d_fsdata;
2974 struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);
2975
2976 if (!ocfs2_is_hard_readonly(osb) && !ocfs2_mount_local(osb))
2977 ocfs2_cluster_unlock(osb, &dl->dl_lockres, level);
2978}
2979
2980
2981
2982
2983static void ocfs2_dlm_debug_free(struct kref *kref)
2984{
2985 struct ocfs2_dlm_debug *dlm_debug;
2986
2987 dlm_debug = container_of(kref, struct ocfs2_dlm_debug, d_refcnt);
2988
2989 kfree(dlm_debug);
2990}
2991
2992void ocfs2_put_dlm_debug(struct ocfs2_dlm_debug *dlm_debug)
2993{
2994 if (dlm_debug)
2995 kref_put(&dlm_debug->d_refcnt, ocfs2_dlm_debug_free);
2996}
2997
2998static void ocfs2_get_dlm_debug(struct ocfs2_dlm_debug *debug)
2999{
3000 kref_get(&debug->d_refcnt);
3001}
3002
3003struct ocfs2_dlm_debug *ocfs2_new_dlm_debug(void)
3004{
3005 struct ocfs2_dlm_debug *dlm_debug;
3006
3007 dlm_debug = kmalloc(sizeof(struct ocfs2_dlm_debug), GFP_KERNEL);
3008 if (!dlm_debug) {
3009 mlog_errno(-ENOMEM);
3010 goto out;
3011 }
3012
3013 kref_init(&dlm_debug->d_refcnt);
3014 INIT_LIST_HEAD(&dlm_debug->d_lockres_tracking);
3015 dlm_debug->d_locking_state = NULL;
3016 dlm_debug->d_locking_filter = NULL;
3017 dlm_debug->d_filter_secs = 0;
3018out:
3019 return dlm_debug;
3020}
3021
3022
3023struct ocfs2_dlm_seq_priv {
3024 struct ocfs2_dlm_debug *p_dlm_debug;
3025 struct ocfs2_lock_res p_iter_res;
3026 struct ocfs2_lock_res p_tmp_res;
3027};
3028
3029static struct ocfs2_lock_res *ocfs2_dlm_next_res(struct ocfs2_lock_res *start,
3030 struct ocfs2_dlm_seq_priv *priv)
3031{
3032 struct ocfs2_lock_res *iter, *ret = NULL;
3033 struct ocfs2_dlm_debug *dlm_debug = priv->p_dlm_debug;
3034
3035 assert_spin_locked(&ocfs2_dlm_tracking_lock);
3036
3037 list_for_each_entry(iter, &start->l_debug_list, l_debug_list) {
3038
3039 if (&iter->l_debug_list == &dlm_debug->d_lockres_tracking) {
3040 mlog(0, "End of list found, %p\n", ret);
3041 break;
3042 }
3043
3044
3045
3046 if (iter->l_ops != NULL) {
3047 ret = iter;
3048 break;
3049 }
3050 }
3051
3052 return ret;
3053}
3054
3055static void *ocfs2_dlm_seq_start(struct seq_file *m, loff_t *pos)
3056{
3057 struct ocfs2_dlm_seq_priv *priv = m->private;
3058 struct ocfs2_lock_res *iter;
3059
3060 spin_lock(&ocfs2_dlm_tracking_lock);
3061 iter = ocfs2_dlm_next_res(&priv->p_iter_res, priv);
3062 if (iter) {
3063
3064
3065
3066
3067
3068
3069
3070 priv->p_tmp_res = *iter;
3071 iter = &priv->p_tmp_res;
3072 }
3073 spin_unlock(&ocfs2_dlm_tracking_lock);
3074
3075 return iter;
3076}
3077
3078static void ocfs2_dlm_seq_stop(struct seq_file *m, void *v)
3079{
3080}
3081
3082static void *ocfs2_dlm_seq_next(struct seq_file *m, void *v, loff_t *pos)
3083{
3084 struct ocfs2_dlm_seq_priv *priv = m->private;
3085 struct ocfs2_lock_res *iter = v;
3086 struct ocfs2_lock_res *dummy = &priv->p_iter_res;
3087
3088 spin_lock(&ocfs2_dlm_tracking_lock);
3089 iter = ocfs2_dlm_next_res(iter, priv);
3090 list_del_init(&dummy->l_debug_list);
3091 if (iter) {
3092 list_add(&dummy->l_debug_list, &iter->l_debug_list);
3093 priv->p_tmp_res = *iter;
3094 iter = &priv->p_tmp_res;
3095 }
3096 spin_unlock(&ocfs2_dlm_tracking_lock);
3097
3098 return iter;
3099}
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111#define OCFS2_DLM_DEBUG_STR_VERSION 4
3112static int ocfs2_dlm_seq_show(struct seq_file *m, void *v)
3113{
3114 int i;
3115 char *lvb;
3116 struct ocfs2_lock_res *lockres = v;
3117#ifdef CONFIG_OCFS2_FS_STATS
3118 u64 now, last;
3119 struct ocfs2_dlm_debug *dlm_debug =
3120 ((struct ocfs2_dlm_seq_priv *)m->private)->p_dlm_debug;
3121#endif
3122
3123 if (!lockres)
3124 return -EINVAL;
3125
3126#ifdef CONFIG_OCFS2_FS_STATS
3127 if (!lockres->l_lock_wait && dlm_debug->d_filter_secs) {
3128 now = ktime_to_us(ktime_get_real());
3129 if (lockres->l_lock_prmode.ls_last >
3130 lockres->l_lock_exmode.ls_last)
3131 last = lockres->l_lock_prmode.ls_last;
3132 else
3133 last = lockres->l_lock_exmode.ls_last;
3134
3135
3136
3137
3138
3139
3140 if (div_u64(now - last, 1000000) > dlm_debug->d_filter_secs)
3141 return 0;
3142 }
3143#endif
3144
3145 seq_printf(m, "0x%x\t", OCFS2_DLM_DEBUG_STR_VERSION);
3146
3147 if (lockres->l_type == OCFS2_LOCK_TYPE_DENTRY)
3148 seq_printf(m, "%.*s%08x\t", OCFS2_DENTRY_LOCK_INO_START - 1,
3149 lockres->l_name,
3150 (unsigned int)ocfs2_get_dentry_lock_ino(lockres));
3151 else
3152 seq_printf(m, "%.*s\t", OCFS2_LOCK_ID_MAX_LEN, lockres->l_name);
3153
3154 seq_printf(m, "%d\t"
3155 "0x%lx\t"
3156 "0x%x\t"
3157 "0x%x\t"
3158 "%u\t"
3159 "%u\t"
3160 "%d\t"
3161 "%d\t",
3162 lockres->l_level,
3163 lockres->l_flags,
3164 lockres->l_action,
3165 lockres->l_unlock_action,
3166 lockres->l_ro_holders,
3167 lockres->l_ex_holders,
3168 lockres->l_requested,
3169 lockres->l_blocking);
3170
3171
3172 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
3173 for(i = 0; i < DLM_LVB_LEN; i++)
3174 seq_printf(m, "0x%x\t", lvb[i]);
3175
3176#ifdef CONFIG_OCFS2_FS_STATS
3177# define lock_num_prmode(_l) ((_l)->l_lock_prmode.ls_gets)
3178# define lock_num_exmode(_l) ((_l)->l_lock_exmode.ls_gets)
3179# define lock_num_prmode_failed(_l) ((_l)->l_lock_prmode.ls_fail)
3180# define lock_num_exmode_failed(_l) ((_l)->l_lock_exmode.ls_fail)
3181# define lock_total_prmode(_l) ((_l)->l_lock_prmode.ls_total)
3182# define lock_total_exmode(_l) ((_l)->l_lock_exmode.ls_total)
3183# define lock_max_prmode(_l) ((_l)->l_lock_prmode.ls_max)
3184# define lock_max_exmode(_l) ((_l)->l_lock_exmode.ls_max)
3185# define lock_refresh(_l) ((_l)->l_lock_refresh)
3186# define lock_last_prmode(_l) ((_l)->l_lock_prmode.ls_last)
3187# define lock_last_exmode(_l) ((_l)->l_lock_exmode.ls_last)
3188# define lock_wait(_l) ((_l)->l_lock_wait)
3189#else
3190# define lock_num_prmode(_l) (0)
3191# define lock_num_exmode(_l) (0)
3192# define lock_num_prmode_failed(_l) (0)
3193# define lock_num_exmode_failed(_l) (0)
3194# define lock_total_prmode(_l) (0ULL)
3195# define lock_total_exmode(_l) (0ULL)
3196# define lock_max_prmode(_l) (0)
3197# define lock_max_exmode(_l) (0)
3198# define lock_refresh(_l) (0)
3199# define lock_last_prmode(_l) (0ULL)
3200# define lock_last_exmode(_l) (0ULL)
3201# define lock_wait(_l) (0ULL)
3202#endif
3203
3204 seq_printf(m, "%u\t"
3205 "%u\t"
3206 "%u\t"
3207 "%u\t"
3208 "%llu\t"
3209 "%llu\t"
3210 "%u\t"
3211 "%u\t"
3212 "%u\t"
3213 "%llu\t"
3214 "%llu\t"
3215 "%llu\t",
3216 lock_num_prmode(lockres),
3217 lock_num_exmode(lockres),
3218 lock_num_prmode_failed(lockres),
3219 lock_num_exmode_failed(lockres),
3220 lock_total_prmode(lockres),
3221 lock_total_exmode(lockres),
3222 lock_max_prmode(lockres),
3223 lock_max_exmode(lockres),
3224 lock_refresh(lockres),
3225 lock_last_prmode(lockres),
3226 lock_last_exmode(lockres),
3227 lock_wait(lockres));
3228
3229
3230 seq_printf(m, "\n");
3231 return 0;
3232}
3233
3234static const struct seq_operations ocfs2_dlm_seq_ops = {
3235 .start = ocfs2_dlm_seq_start,
3236 .stop = ocfs2_dlm_seq_stop,
3237 .next = ocfs2_dlm_seq_next,
3238 .show = ocfs2_dlm_seq_show,
3239};
3240
3241static int ocfs2_dlm_debug_release(struct inode *inode, struct file *file)
3242{
3243 struct seq_file *seq = file->private_data;
3244 struct ocfs2_dlm_seq_priv *priv = seq->private;
3245 struct ocfs2_lock_res *res = &priv->p_iter_res;
3246
3247 ocfs2_remove_lockres_tracking(res);
3248 ocfs2_put_dlm_debug(priv->p_dlm_debug);
3249 return seq_release_private(inode, file);
3250}
3251
3252static int ocfs2_dlm_debug_open(struct inode *inode, struct file *file)
3253{
3254 struct ocfs2_dlm_seq_priv *priv;
3255 struct ocfs2_super *osb;
3256
3257 priv = __seq_open_private(file, &ocfs2_dlm_seq_ops, sizeof(*priv));
3258 if (!priv) {
3259 mlog_errno(-ENOMEM);
3260 return -ENOMEM;
3261 }
3262
3263 osb = inode->i_private;
3264 ocfs2_get_dlm_debug(osb->osb_dlm_debug);
3265 priv->p_dlm_debug = osb->osb_dlm_debug;
3266 INIT_LIST_HEAD(&priv->p_iter_res.l_debug_list);
3267
3268 ocfs2_add_lockres_tracking(&priv->p_iter_res,
3269 priv->p_dlm_debug);
3270
3271 return 0;
3272}
3273
3274static const struct file_operations ocfs2_dlm_debug_fops = {
3275 .open = ocfs2_dlm_debug_open,
3276 .release = ocfs2_dlm_debug_release,
3277 .read = seq_read,
3278 .llseek = seq_lseek,
3279};
3280
3281static void ocfs2_dlm_init_debug(struct ocfs2_super *osb)
3282{
3283 struct ocfs2_dlm_debug *dlm_debug = osb->osb_dlm_debug;
3284
3285 dlm_debug->d_locking_state = debugfs_create_file("locking_state",
3286 S_IFREG|S_IRUSR,
3287 osb->osb_debug_root,
3288 osb,
3289 &ocfs2_dlm_debug_fops);
3290
3291 dlm_debug->d_locking_filter = debugfs_create_u32("locking_filter",
3292 0600,
3293 osb->osb_debug_root,
3294 &dlm_debug->d_filter_secs);
3295}
3296
3297static void ocfs2_dlm_shutdown_debug(struct ocfs2_super *osb)
3298{
3299 struct ocfs2_dlm_debug *dlm_debug = osb->osb_dlm_debug;
3300
3301 if (dlm_debug) {
3302 debugfs_remove(dlm_debug->d_locking_state);
3303 debugfs_remove(dlm_debug->d_locking_filter);
3304 ocfs2_put_dlm_debug(dlm_debug);
3305 }
3306}
3307
3308int ocfs2_dlm_init(struct ocfs2_super *osb)
3309{
3310 int status = 0;
3311 struct ocfs2_cluster_connection *conn = NULL;
3312
3313 if (ocfs2_mount_local(osb)) {
3314 osb->node_num = 0;
3315 goto local;
3316 }
3317
3318 ocfs2_dlm_init_debug(osb);
3319
3320
3321 osb->dc_task = kthread_run(ocfs2_downconvert_thread, osb, "ocfs2dc-%s",
3322 osb->uuid_str);
3323 if (IS_ERR(osb->dc_task)) {
3324 status = PTR_ERR(osb->dc_task);
3325 osb->dc_task = NULL;
3326 mlog_errno(status);
3327 goto bail;
3328 }
3329
3330
3331 status = ocfs2_cluster_connect(osb->osb_cluster_stack,
3332 osb->osb_cluster_name,
3333 strlen(osb->osb_cluster_name),
3334 osb->uuid_str,
3335 strlen(osb->uuid_str),
3336 &lproto, ocfs2_do_node_down, osb,
3337 &conn);
3338 if (status) {
3339 mlog_errno(status);
3340 goto bail;
3341 }
3342
3343 status = ocfs2_cluster_this_node(conn, &osb->node_num);
3344 if (status < 0) {
3345 mlog_errno(status);
3346 mlog(ML_ERROR,
3347 "could not find this host's node number\n");
3348 ocfs2_cluster_disconnect(conn, 0);
3349 goto bail;
3350 }
3351
3352local:
3353 ocfs2_super_lock_res_init(&osb->osb_super_lockres, osb);
3354 ocfs2_rename_lock_res_init(&osb->osb_rename_lockres, osb);
3355 ocfs2_nfs_sync_lock_res_init(&osb->osb_nfs_sync_lockres, osb);
3356 ocfs2_orphan_scan_lock_res_init(&osb->osb_orphan_scan.os_lockres, osb);
3357
3358 osb->cconn = conn;
3359bail:
3360 if (status < 0) {
3361 ocfs2_dlm_shutdown_debug(osb);
3362 if (osb->dc_task)
3363 kthread_stop(osb->dc_task);
3364 }
3365
3366 return status;
3367}
3368
3369void ocfs2_dlm_shutdown(struct ocfs2_super *osb,
3370 int hangup_pending)
3371{
3372 ocfs2_drop_osb_locks(osb);
3373
3374
3375
3376
3377
3378
3379
3380 if (osb->dc_task) {
3381 kthread_stop(osb->dc_task);
3382 osb->dc_task = NULL;
3383 }
3384
3385 ocfs2_lock_res_free(&osb->osb_super_lockres);
3386 ocfs2_lock_res_free(&osb->osb_rename_lockres);
3387 ocfs2_lock_res_free(&osb->osb_nfs_sync_lockres);
3388 ocfs2_lock_res_free(&osb->osb_orphan_scan.os_lockres);
3389
3390 ocfs2_cluster_disconnect(osb->cconn, hangup_pending);
3391 osb->cconn = NULL;
3392
3393 ocfs2_dlm_shutdown_debug(osb);
3394}
3395
3396static int ocfs2_drop_lock(struct ocfs2_super *osb,
3397 struct ocfs2_lock_res *lockres)
3398{
3399 int ret;
3400 unsigned long flags;
3401 u32 lkm_flags = 0;
3402
3403
3404 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED))
3405 goto out;
3406
3407 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3408 lkm_flags |= DLM_LKF_VALBLK;
3409
3410 spin_lock_irqsave(&lockres->l_lock, flags);
3411
3412 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_FREEING),
3413 "lockres %s, flags 0x%lx\n",
3414 lockres->l_name, lockres->l_flags);
3415
3416 while (lockres->l_flags & OCFS2_LOCK_BUSY) {
3417 mlog(0, "waiting on busy lock \"%s\": flags = %lx, action = "
3418 "%u, unlock_action = %u\n",
3419 lockres->l_name, lockres->l_flags, lockres->l_action,
3420 lockres->l_unlock_action);
3421
3422 spin_unlock_irqrestore(&lockres->l_lock, flags);
3423
3424
3425
3426
3427 ocfs2_wait_on_busy_lock(lockres);
3428
3429 spin_lock_irqsave(&lockres->l_lock, flags);
3430 }
3431
3432 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3433 if (lockres->l_flags & OCFS2_LOCK_ATTACHED &&
3434 lockres->l_level == DLM_LOCK_EX &&
3435 !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3436 lockres->l_ops->set_lvb(lockres);
3437 }
3438
3439 if (lockres->l_flags & OCFS2_LOCK_BUSY)
3440 mlog(ML_ERROR, "destroying busy lock: \"%s\"\n",
3441 lockres->l_name);
3442 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
3443 mlog(0, "destroying blocked lock: \"%s\"\n", lockres->l_name);
3444
3445 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
3446 spin_unlock_irqrestore(&lockres->l_lock, flags);
3447 goto out;
3448 }
3449
3450 lockres_clear_flags(lockres, OCFS2_LOCK_ATTACHED);
3451
3452
3453
3454 BUG_ON(lockres->l_action != OCFS2_AST_INVALID);
3455
3456
3457 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3458 lockres->l_unlock_action = OCFS2_UNLOCK_DROP_LOCK;
3459 spin_unlock_irqrestore(&lockres->l_lock, flags);
3460
3461 mlog(0, "lock %s\n", lockres->l_name);
3462
3463 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb, lkm_flags);
3464 if (ret) {
3465 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3466 mlog(ML_ERROR, "lockres flags: %lu\n", lockres->l_flags);
3467 ocfs2_dlm_dump_lksb(&lockres->l_lksb);
3468 BUG();
3469 }
3470 mlog(0, "lock %s, successful return from ocfs2_dlm_unlock\n",
3471 lockres->l_name);
3472
3473 ocfs2_wait_on_busy_lock(lockres);
3474out:
3475 return 0;
3476}
3477
3478static void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
3479 struct ocfs2_lock_res *lockres);
3480
3481
3482
3483
3484
3485
3486
3487void ocfs2_mark_lockres_freeing(struct ocfs2_super *osb,
3488 struct ocfs2_lock_res *lockres)
3489{
3490 int status;
3491 struct ocfs2_mask_waiter mw;
3492 unsigned long flags, flags2;
3493
3494 ocfs2_init_mask_waiter(&mw);
3495
3496 spin_lock_irqsave(&lockres->l_lock, flags);
3497 lockres->l_flags |= OCFS2_LOCK_FREEING;
3498 if (lockres->l_flags & OCFS2_LOCK_QUEUED && current == osb->dc_task) {
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516 spin_unlock_irqrestore(&lockres->l_lock, flags);
3517 spin_lock_irqsave(&osb->dc_task_lock, flags2);
3518 list_del_init(&lockres->l_blocked_list);
3519 osb->blocked_lock_count--;
3520 spin_unlock_irqrestore(&osb->dc_task_lock, flags2);
3521
3522
3523
3524
3525
3526
3527 WARN_ON_ONCE(lockres->l_ops->post_unlock);
3528
3529 ocfs2_process_blocked_lock(osb, lockres);
3530 return;
3531 }
3532 while (lockres->l_flags & OCFS2_LOCK_QUEUED) {
3533 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_QUEUED, 0);
3534 spin_unlock_irqrestore(&lockres->l_lock, flags);
3535
3536 mlog(0, "Waiting on lockres %s\n", lockres->l_name);
3537
3538 status = ocfs2_wait_for_mask(&mw);
3539 if (status)
3540 mlog_errno(status);
3541
3542 spin_lock_irqsave(&lockres->l_lock, flags);
3543 }
3544 spin_unlock_irqrestore(&lockres->l_lock, flags);
3545}
3546
3547void ocfs2_simple_drop_lockres(struct ocfs2_super *osb,
3548 struct ocfs2_lock_res *lockres)
3549{
3550 int ret;
3551
3552 ocfs2_mark_lockres_freeing(osb, lockres);
3553 ret = ocfs2_drop_lock(osb, lockres);
3554 if (ret)
3555 mlog_errno(ret);
3556}
3557
3558static void ocfs2_drop_osb_locks(struct ocfs2_super *osb)
3559{
3560 ocfs2_simple_drop_lockres(osb, &osb->osb_super_lockres);
3561 ocfs2_simple_drop_lockres(osb, &osb->osb_rename_lockres);
3562 ocfs2_simple_drop_lockres(osb, &osb->osb_nfs_sync_lockres);
3563 ocfs2_simple_drop_lockres(osb, &osb->osb_orphan_scan.os_lockres);
3564}
3565
3566int ocfs2_drop_inode_locks(struct inode *inode)
3567{
3568 int status, err;
3569
3570
3571
3572
3573 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
3574 &OCFS2_I(inode)->ip_open_lockres);
3575 if (err < 0)
3576 mlog_errno(err);
3577
3578 status = err;
3579
3580 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
3581 &OCFS2_I(inode)->ip_inode_lockres);
3582 if (err < 0)
3583 mlog_errno(err);
3584 if (err < 0 && !status)
3585 status = err;
3586
3587 err = ocfs2_drop_lock(OCFS2_SB(inode->i_sb),
3588 &OCFS2_I(inode)->ip_rw_lockres);
3589 if (err < 0)
3590 mlog_errno(err);
3591 if (err < 0 && !status)
3592 status = err;
3593
3594 return status;
3595}
3596
3597static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
3598 int new_level)
3599{
3600 assert_spin_locked(&lockres->l_lock);
3601
3602 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
3603
3604 if (lockres->l_level <= new_level) {
3605 mlog(ML_ERROR, "lockres %s, lvl %d <= %d, blcklst %d, mask %d, "
3606 "type %d, flags 0x%lx, hold %d %d, act %d %d, req %d, "
3607 "block %d, pgen %d\n", lockres->l_name, lockres->l_level,
3608 new_level, list_empty(&lockres->l_blocked_list),
3609 list_empty(&lockres->l_mask_waiters), lockres->l_type,
3610 lockres->l_flags, lockres->l_ro_holders,
3611 lockres->l_ex_holders, lockres->l_action,
3612 lockres->l_unlock_action, lockres->l_requested,
3613 lockres->l_blocking, lockres->l_pending_gen);
3614 BUG();
3615 }
3616
3617 mlog(ML_BASTS, "lockres %s, level %d => %d, blocking %d\n",
3618 lockres->l_name, lockres->l_level, new_level, lockres->l_blocking);
3619
3620 lockres->l_action = OCFS2_AST_DOWNCONVERT;
3621 lockres->l_requested = new_level;
3622 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3623 return lockres_set_pending(lockres);
3624}
3625
3626static int ocfs2_downconvert_lock(struct ocfs2_super *osb,
3627 struct ocfs2_lock_res *lockres,
3628 int new_level,
3629 int lvb,
3630 unsigned int generation)
3631{
3632 int ret;
3633 u32 dlm_flags = DLM_LKF_CONVERT;
3634
3635 mlog(ML_BASTS, "lockres %s, level %d => %d\n", lockres->l_name,
3636 lockres->l_level, new_level);
3637
3638
3639
3640
3641
3642
3643
3644 if (ocfs2_userspace_stack(osb) &&
3645 lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3646 lvb = 1;
3647
3648 if (lvb)
3649 dlm_flags |= DLM_LKF_VALBLK;
3650
3651 ret = ocfs2_dlm_lock(osb->cconn,
3652 new_level,
3653 &lockres->l_lksb,
3654 dlm_flags,
3655 lockres->l_name,
3656 OCFS2_LOCK_ID_MAX_LEN - 1);
3657 lockres_clear_pending(lockres, generation, osb);
3658 if (ret) {
3659 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
3660 ocfs2_recover_from_dlm_error(lockres, 1);
3661 goto bail;
3662 }
3663
3664 ret = 0;
3665bail:
3666 return ret;
3667}
3668
3669
3670static int ocfs2_prepare_cancel_convert(struct ocfs2_super *osb,
3671 struct ocfs2_lock_res *lockres)
3672{
3673 assert_spin_locked(&lockres->l_lock);
3674
3675 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
3676
3677
3678
3679 mlog(ML_BASTS, "lockres %s, skip convert\n", lockres->l_name);
3680 return 0;
3681 }
3682
3683
3684 BUG_ON(lockres->l_action != OCFS2_AST_CONVERT &&
3685 lockres->l_action != OCFS2_AST_DOWNCONVERT);
3686
3687
3688 lockres->l_unlock_action = OCFS2_UNLOCK_CANCEL_CONVERT;
3689
3690 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_BUSY),
3691 "lock %s, invalid flags: 0x%lx\n",
3692 lockres->l_name, lockres->l_flags);
3693
3694 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3695
3696 return 1;
3697}
3698
3699static int ocfs2_cancel_convert(struct ocfs2_super *osb,
3700 struct ocfs2_lock_res *lockres)
3701{
3702 int ret;
3703
3704 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb,
3705 DLM_LKF_CANCEL);
3706 if (ret) {
3707 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3708 ocfs2_recover_from_dlm_error(lockres, 0);
3709 }
3710
3711 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3712
3713 return ret;
3714}
3715
3716static int ocfs2_unblock_lock(struct ocfs2_super *osb,
3717 struct ocfs2_lock_res *lockres,
3718 struct ocfs2_unblock_ctl *ctl)
3719{
3720 unsigned long flags;
3721 int blocking;
3722 int new_level;
3723 int level;
3724 int ret = 0;
3725 int set_lvb = 0;
3726 unsigned int gen;
3727
3728 spin_lock_irqsave(&lockres->l_lock, flags);
3729
3730recheck:
3731
3732
3733
3734 if (!(lockres->l_flags & OCFS2_LOCK_BLOCKED)) {
3735 BUG_ON(lockres->l_blocking != DLM_LOCK_NL);
3736 spin_unlock_irqrestore(&lockres->l_lock, flags);
3737 ret = 0;
3738 goto leave;
3739 }
3740
3741 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765 if (lockres->l_flags & OCFS2_LOCK_PENDING) {
3766 mlog(ML_BASTS, "lockres %s, ReQ: Pending\n",
3767 lockres->l_name);
3768 goto leave_requeue;
3769 }
3770
3771 ctl->requeue = 1;
3772 ret = ocfs2_prepare_cancel_convert(osb, lockres);
3773 spin_unlock_irqrestore(&lockres->l_lock, flags);
3774 if (ret) {
3775 ret = ocfs2_cancel_convert(osb, lockres);
3776 if (ret < 0)
3777 mlog_errno(ret);
3778 }
3779 goto leave;
3780 }
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING)
3792 goto leave_requeue;
3793
3794
3795
3796
3797
3798
3799 if (lockres->l_level == DLM_LOCK_NL) {
3800 BUG_ON(lockres->l_ex_holders || lockres->l_ro_holders);
3801 mlog(ML_BASTS, "lockres %s, Aborting dc\n", lockres->l_name);
3802 lockres->l_blocking = DLM_LOCK_NL;
3803 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
3804 spin_unlock_irqrestore(&lockres->l_lock, flags);
3805 goto leave;
3806 }
3807
3808
3809
3810 if ((lockres->l_blocking == DLM_LOCK_EX)
3811 && (lockres->l_ex_holders || lockres->l_ro_holders)) {
3812 mlog(ML_BASTS, "lockres %s, ReQ: EX/PR Holders %u,%u\n",
3813 lockres->l_name, lockres->l_ex_holders,
3814 lockres->l_ro_holders);
3815 goto leave_requeue;
3816 }
3817
3818
3819
3820 if (lockres->l_blocking == DLM_LOCK_PR &&
3821 lockres->l_ex_holders) {
3822 mlog(ML_BASTS, "lockres %s, ReQ: EX Holders %u\n",
3823 lockres->l_name, lockres->l_ex_holders);
3824 goto leave_requeue;
3825 }
3826
3827
3828
3829
3830
3831 if ((lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
3832 && (lockres->l_flags & OCFS2_LOCK_REFRESHING)) {
3833 mlog(ML_BASTS, "lockres %s, ReQ: Lock Refreshing\n",
3834 lockres->l_name);
3835 goto leave_requeue;
3836 }
3837
3838 new_level = ocfs2_highest_compat_lock_level(lockres->l_blocking);
3839
3840 if (lockres->l_ops->check_downconvert
3841 && !lockres->l_ops->check_downconvert(lockres, new_level)) {
3842 mlog(ML_BASTS, "lockres %s, ReQ: Checkpointing\n",
3843 lockres->l_name);
3844 goto leave_requeue;
3845 }
3846
3847
3848
3849
3850 if (!lockres->l_ops->downconvert_worker)
3851 goto downconvert;
3852
3853
3854
3855
3856
3857 blocking = lockres->l_blocking;
3858 level = lockres->l_level;
3859 spin_unlock_irqrestore(&lockres->l_lock, flags);
3860
3861 ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking);
3862
3863 if (ctl->unblock_action == UNBLOCK_STOP_POST) {
3864 mlog(ML_BASTS, "lockres %s, UNBLOCK_STOP_POST\n",
3865 lockres->l_name);
3866 goto leave;
3867 }
3868
3869 spin_lock_irqsave(&lockres->l_lock, flags);
3870 if ((blocking != lockres->l_blocking) || (level != lockres->l_level)) {
3871
3872
3873 mlog(ML_BASTS, "lockres %s, block=%d:%d, level=%d:%d, "
3874 "Recheck\n", lockres->l_name, blocking,
3875 lockres->l_blocking, level, lockres->l_level);
3876 goto recheck;
3877 }
3878
3879downconvert:
3880 ctl->requeue = 0;
3881
3882 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3883 if (lockres->l_level == DLM_LOCK_EX)
3884 set_lvb = 1;
3885
3886
3887
3888
3889
3890
3891
3892 if (set_lvb && !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3893 lockres->l_ops->set_lvb(lockres);
3894 }
3895
3896 gen = ocfs2_prepare_downconvert(lockres, new_level);
3897 spin_unlock_irqrestore(&lockres->l_lock, flags);
3898 ret = ocfs2_downconvert_lock(osb, lockres, new_level, set_lvb,
3899 gen);
3900
3901leave:
3902 if (ret)
3903 mlog_errno(ret);
3904 return ret;
3905
3906leave_requeue:
3907 spin_unlock_irqrestore(&lockres->l_lock, flags);
3908 ctl->requeue = 1;
3909
3910 return 0;
3911}
3912
3913static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
3914 int blocking)
3915{
3916 struct inode *inode;
3917 struct address_space *mapping;
3918 struct ocfs2_inode_info *oi;
3919
3920 inode = ocfs2_lock_res_inode(lockres);
3921 mapping = inode->i_mapping;
3922
3923 if (S_ISDIR(inode->i_mode)) {
3924 oi = OCFS2_I(inode);
3925 oi->ip_dir_lock_gen++;
3926 mlog(0, "generation: %u\n", oi->ip_dir_lock_gen);
3927 goto out;
3928 }
3929
3930 if (!S_ISREG(inode->i_mode))
3931 goto out;
3932
3933
3934
3935
3936
3937
3938
3939
3940 unmap_mapping_range(mapping, 0, 0, 0);
3941
3942 if (filemap_fdatawrite(mapping)) {
3943 mlog(ML_ERROR, "Could not sync inode %llu for downconvert!",
3944 (unsigned long long)OCFS2_I(inode)->ip_blkno);
3945 }
3946 sync_mapping_buffers(mapping);
3947 if (blocking == DLM_LOCK_EX) {
3948 truncate_inode_pages(mapping, 0);
3949 } else {
3950
3951
3952
3953
3954
3955 filemap_fdatawait(mapping);
3956 }
3957
3958 forget_all_cached_acls(inode);
3959
3960out:
3961 return UNBLOCK_CONTINUE;
3962}
3963
3964static int ocfs2_ci_checkpointed(struct ocfs2_caching_info *ci,
3965 struct ocfs2_lock_res *lockres,
3966 int new_level)
3967{
3968 int checkpointed = ocfs2_ci_fully_checkpointed(ci);
3969
3970 BUG_ON(new_level != DLM_LOCK_NL && new_level != DLM_LOCK_PR);
3971 BUG_ON(lockres->l_level != DLM_LOCK_EX && !checkpointed);
3972
3973 if (checkpointed)
3974 return 1;
3975
3976 ocfs2_start_checkpoint(OCFS2_SB(ocfs2_metadata_cache_get_super(ci)));
3977 return 0;
3978}
3979
3980static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
3981 int new_level)
3982{
3983 struct inode *inode = ocfs2_lock_res_inode(lockres);
3984
3985 return ocfs2_ci_checkpointed(INODE_CACHE(inode), lockres, new_level);
3986}
3987
3988static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres)
3989{
3990 struct inode *inode = ocfs2_lock_res_inode(lockres);
3991
3992 __ocfs2_stuff_meta_lvb(inode);
3993}
3994
3995
3996
3997
3998
3999
4000static void ocfs2_dentry_post_unlock(struct ocfs2_super *osb,
4001 struct ocfs2_lock_res *lockres)
4002{
4003 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
4004 ocfs2_dentry_lock_put(osb, dl);
4005}
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
4027 int blocking)
4028{
4029 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
4030 struct ocfs2_inode_info *oi = OCFS2_I(dl->dl_inode);
4031 struct dentry *dentry;
4032 unsigned long flags;
4033 int extra_ref = 0;
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043 if (blocking == DLM_LOCK_PR)
4044 return UNBLOCK_CONTINUE;
4045
4046
4047
4048
4049
4050
4051 spin_lock(&oi->ip_lock);
4052 oi->ip_flags |= OCFS2_INODE_MAYBE_ORPHANED;
4053 spin_unlock(&oi->ip_lock);
4054
4055
4056
4057
4058
4059
4060
4061 spin_lock_irqsave(&lockres->l_lock, flags);
4062 spin_lock(&dentry_attach_lock);
4063 if (!(lockres->l_flags & OCFS2_LOCK_FREEING)
4064 && dl->dl_count) {
4065 dl->dl_count++;
4066 extra_ref = 1;
4067 }
4068 spin_unlock(&dentry_attach_lock);
4069 spin_unlock_irqrestore(&lockres->l_lock, flags);
4070
4071 mlog(0, "extra_ref = %d\n", extra_ref);
4072
4073
4074
4075
4076
4077
4078 if (!extra_ref)
4079 return UNBLOCK_CONTINUE;
4080
4081 spin_lock(&dentry_attach_lock);
4082 while (1) {
4083 dentry = ocfs2_find_local_alias(dl->dl_inode,
4084 dl->dl_parent_blkno, 1);
4085 if (!dentry)
4086 break;
4087 spin_unlock(&dentry_attach_lock);
4088
4089 if (S_ISDIR(dl->dl_inode->i_mode))
4090 shrink_dcache_parent(dentry);
4091
4092 mlog(0, "d_delete(%pd);\n", dentry);
4093
4094
4095
4096
4097
4098
4099
4100
4101
4102 d_delete(dentry);
4103 dput(dentry);
4104
4105 spin_lock(&dentry_attach_lock);
4106 }
4107 spin_unlock(&dentry_attach_lock);
4108
4109
4110
4111
4112
4113 if (dl->dl_count == 1)
4114 return UNBLOCK_STOP_POST;
4115
4116 return UNBLOCK_CONTINUE_POST;
4117}
4118
4119static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
4120 int new_level)
4121{
4122 struct ocfs2_refcount_tree *tree =
4123 ocfs2_lock_res_refcount_tree(lockres);
4124
4125 return ocfs2_ci_checkpointed(&tree->rf_ci, lockres, new_level);
4126}
4127
4128static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
4129 int blocking)
4130{
4131 struct ocfs2_refcount_tree *tree =
4132 ocfs2_lock_res_refcount_tree(lockres);
4133
4134 ocfs2_metadata_cache_purge(&tree->rf_ci);
4135
4136 return UNBLOCK_CONTINUE;
4137}
4138
4139static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres)
4140{
4141 struct ocfs2_qinfo_lvb *lvb;
4142 struct ocfs2_mem_dqinfo *oinfo = ocfs2_lock_res_qinfo(lockres);
4143 struct mem_dqinfo *info = sb_dqinfo(oinfo->dqi_gi.dqi_sb,
4144 oinfo->dqi_gi.dqi_type);
4145
4146 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
4147 lvb->lvb_version = OCFS2_QINFO_LVB_VERSION;
4148 lvb->lvb_bgrace = cpu_to_be32(info->dqi_bgrace);
4149 lvb->lvb_igrace = cpu_to_be32(info->dqi_igrace);
4150 lvb->lvb_syncms = cpu_to_be32(oinfo->dqi_syncms);
4151 lvb->lvb_blocks = cpu_to_be32(oinfo->dqi_gi.dqi_blocks);
4152 lvb->lvb_free_blk = cpu_to_be32(oinfo->dqi_gi.dqi_free_blk);
4153 lvb->lvb_free_entry = cpu_to_be32(oinfo->dqi_gi.dqi_free_entry);
4154}
4155
4156void ocfs2_qinfo_unlock(struct ocfs2_mem_dqinfo *oinfo, int ex)
4157{
4158 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4159 struct ocfs2_super *osb = OCFS2_SB(oinfo->dqi_gi.dqi_sb);
4160 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
4161
4162 if (!ocfs2_is_hard_readonly(osb) && !ocfs2_mount_local(osb))
4163 ocfs2_cluster_unlock(osb, lockres, level);
4164}
4165
4166static int ocfs2_refresh_qinfo(struct ocfs2_mem_dqinfo *oinfo)
4167{
4168 struct mem_dqinfo *info = sb_dqinfo(oinfo->dqi_gi.dqi_sb,
4169 oinfo->dqi_gi.dqi_type);
4170 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4171 struct ocfs2_qinfo_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
4172 struct buffer_head *bh = NULL;
4173 struct ocfs2_global_disk_dqinfo *gdinfo;
4174 int status = 0;
4175
4176 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
4177 lvb->lvb_version == OCFS2_QINFO_LVB_VERSION) {
4178 info->dqi_bgrace = be32_to_cpu(lvb->lvb_bgrace);
4179 info->dqi_igrace = be32_to_cpu(lvb->lvb_igrace);
4180 oinfo->dqi_syncms = be32_to_cpu(lvb->lvb_syncms);
4181 oinfo->dqi_gi.dqi_blocks = be32_to_cpu(lvb->lvb_blocks);
4182 oinfo->dqi_gi.dqi_free_blk = be32_to_cpu(lvb->lvb_free_blk);
4183 oinfo->dqi_gi.dqi_free_entry =
4184 be32_to_cpu(lvb->lvb_free_entry);
4185 } else {
4186 status = ocfs2_read_quota_phys_block(oinfo->dqi_gqinode,
4187 oinfo->dqi_giblk, &bh);
4188 if (status) {
4189 mlog_errno(status);
4190 goto bail;
4191 }
4192 gdinfo = (struct ocfs2_global_disk_dqinfo *)
4193 (bh->b_data + OCFS2_GLOBAL_INFO_OFF);
4194 info->dqi_bgrace = le32_to_cpu(gdinfo->dqi_bgrace);
4195 info->dqi_igrace = le32_to_cpu(gdinfo->dqi_igrace);
4196 oinfo->dqi_syncms = le32_to_cpu(gdinfo->dqi_syncms);
4197 oinfo->dqi_gi.dqi_blocks = le32_to_cpu(gdinfo->dqi_blocks);
4198 oinfo->dqi_gi.dqi_free_blk = le32_to_cpu(gdinfo->dqi_free_blk);
4199 oinfo->dqi_gi.dqi_free_entry =
4200 le32_to_cpu(gdinfo->dqi_free_entry);
4201 brelse(bh);
4202 ocfs2_track_lock_refresh(lockres);
4203 }
4204
4205bail:
4206 return status;
4207}
4208
4209
4210
4211int ocfs2_qinfo_lock(struct ocfs2_mem_dqinfo *oinfo, int ex)
4212{
4213 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4214 struct ocfs2_super *osb = OCFS2_SB(oinfo->dqi_gi.dqi_sb);
4215 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
4216 int status = 0;
4217
4218
4219 if (ocfs2_is_hard_readonly(osb)) {
4220 if (ex)
4221 status = -EROFS;
4222 goto bail;
4223 }
4224 if (ocfs2_mount_local(osb))
4225 goto bail;
4226
4227 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
4228 if (status < 0) {
4229 mlog_errno(status);
4230 goto bail;
4231 }
4232 if (!ocfs2_should_refresh_lock_res(lockres))
4233 goto bail;
4234
4235 status = ocfs2_refresh_qinfo(oinfo);
4236 if (status)
4237 ocfs2_qinfo_unlock(oinfo, ex);
4238 ocfs2_complete_lock_res_refresh(lockres, status);
4239bail:
4240 return status;
4241}
4242
4243int ocfs2_refcount_lock(struct ocfs2_refcount_tree *ref_tree, int ex)
4244{
4245 int status;
4246 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
4247 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
4248 struct ocfs2_super *osb = lockres->l_priv;
4249
4250
4251 if (ocfs2_is_hard_readonly(osb))
4252 return -EROFS;
4253
4254 if (ocfs2_mount_local(osb))
4255 return 0;
4256
4257 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
4258 if (status < 0)
4259 mlog_errno(status);
4260
4261 return status;
4262}
4263
4264void ocfs2_refcount_unlock(struct ocfs2_refcount_tree *ref_tree, int ex)
4265{
4266 int level = ex ? DLM_LOCK_EX : DLM_LOCK_PR;
4267 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
4268 struct ocfs2_super *osb = lockres->l_priv;
4269
4270 if (!ocfs2_mount_local(osb))
4271 ocfs2_cluster_unlock(osb, lockres, level);
4272}
4273
4274static void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
4275 struct ocfs2_lock_res *lockres)
4276{
4277 int status;
4278 struct ocfs2_unblock_ctl ctl = {0, 0,};
4279 unsigned long flags;
4280
4281
4282
4283
4284
4285 BUG_ON(!lockres);
4286 BUG_ON(!lockres->l_ops);
4287
4288 mlog(ML_BASTS, "lockres %s blocked\n", lockres->l_name);
4289
4290
4291
4292
4293
4294
4295 spin_lock_irqsave(&lockres->l_lock, flags);
4296 if (lockres->l_flags & OCFS2_LOCK_FREEING)
4297 goto unqueue;
4298 spin_unlock_irqrestore(&lockres->l_lock, flags);
4299
4300 status = ocfs2_unblock_lock(osb, lockres, &ctl);
4301 if (status < 0)
4302 mlog_errno(status);
4303
4304 spin_lock_irqsave(&lockres->l_lock, flags);
4305unqueue:
4306 if (lockres->l_flags & OCFS2_LOCK_FREEING || !ctl.requeue) {
4307 lockres_clear_flags(lockres, OCFS2_LOCK_QUEUED);
4308 } else
4309 ocfs2_schedule_blocked_lock(osb, lockres);
4310
4311 mlog(ML_BASTS, "lockres %s, requeue = %s.\n", lockres->l_name,
4312 ctl.requeue ? "yes" : "no");
4313 spin_unlock_irqrestore(&lockres->l_lock, flags);
4314
4315 if (ctl.unblock_action != UNBLOCK_CONTINUE
4316 && lockres->l_ops->post_unlock)
4317 lockres->l_ops->post_unlock(osb, lockres);
4318}
4319
4320static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
4321 struct ocfs2_lock_res *lockres)
4322{
4323 unsigned long flags;
4324
4325 assert_spin_locked(&lockres->l_lock);
4326
4327 if (lockres->l_flags & OCFS2_LOCK_FREEING) {
4328
4329
4330
4331 mlog(ML_BASTS, "lockres %s won't be scheduled: flags 0x%lx\n",
4332 lockres->l_name, lockres->l_flags);
4333 return;
4334 }
4335
4336 lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
4337
4338 spin_lock_irqsave(&osb->dc_task_lock, flags);
4339 if (list_empty(&lockres->l_blocked_list)) {
4340 list_add_tail(&lockres->l_blocked_list,
4341 &osb->blocked_lock_list);
4342 osb->blocked_lock_count++;
4343 }
4344 spin_unlock_irqrestore(&osb->dc_task_lock, flags);
4345}
4346
4347static void ocfs2_downconvert_thread_do_work(struct ocfs2_super *osb)
4348{
4349 unsigned long processed;
4350 unsigned long flags;
4351 struct ocfs2_lock_res *lockres;
4352
4353 spin_lock_irqsave(&osb->dc_task_lock, flags);
4354
4355
4356 osb->dc_work_sequence = osb->dc_wake_sequence;
4357
4358 processed = osb->blocked_lock_count;
4359
4360
4361
4362
4363
4364
4365 while (processed && !list_empty(&osb->blocked_lock_list)) {
4366 lockres = list_entry(osb->blocked_lock_list.next,
4367 struct ocfs2_lock_res, l_blocked_list);
4368 list_del_init(&lockres->l_blocked_list);
4369 osb->blocked_lock_count--;
4370 spin_unlock_irqrestore(&osb->dc_task_lock, flags);
4371
4372 BUG_ON(!processed);
4373 processed--;
4374
4375 ocfs2_process_blocked_lock(osb, lockres);
4376
4377 spin_lock_irqsave(&osb->dc_task_lock, flags);
4378 }
4379 spin_unlock_irqrestore(&osb->dc_task_lock, flags);
4380}
4381
4382static int ocfs2_downconvert_thread_lists_empty(struct ocfs2_super *osb)
4383{
4384 int empty = 0;
4385 unsigned long flags;
4386
4387 spin_lock_irqsave(&osb->dc_task_lock, flags);
4388 if (list_empty(&osb->blocked_lock_list))
4389 empty = 1;
4390
4391 spin_unlock_irqrestore(&osb->dc_task_lock, flags);
4392 return empty;
4393}
4394
4395static int ocfs2_downconvert_thread_should_wake(struct ocfs2_super *osb)
4396{
4397 int should_wake = 0;
4398 unsigned long flags;
4399
4400 spin_lock_irqsave(&osb->dc_task_lock, flags);
4401 if (osb->dc_work_sequence != osb->dc_wake_sequence)
4402 should_wake = 1;
4403 spin_unlock_irqrestore(&osb->dc_task_lock, flags);
4404
4405 return should_wake;
4406}
4407
4408static int ocfs2_downconvert_thread(void *arg)
4409{
4410 struct ocfs2_super *osb = arg;
4411
4412
4413
4414 while (!(kthread_should_stop() &&
4415 ocfs2_downconvert_thread_lists_empty(osb))) {
4416
4417 wait_event_interruptible(osb->dc_event,
4418 ocfs2_downconvert_thread_should_wake(osb) ||
4419 kthread_should_stop());
4420
4421 mlog(0, "downconvert_thread: awoken\n");
4422
4423 ocfs2_downconvert_thread_do_work(osb);
4424 }
4425
4426 osb->dc_task = NULL;
4427 return 0;
4428}
4429
4430void ocfs2_wake_downconvert_thread(struct ocfs2_super *osb)
4431{
4432 unsigned long flags;
4433
4434 spin_lock_irqsave(&osb->dc_task_lock, flags);
4435
4436
4437 osb->dc_wake_sequence++;
4438 spin_unlock_irqrestore(&osb->dc_task_lock, flags);
4439 wake_up(&osb->dc_event);
4440}
4441