Lines Matching refs:lockres
58 static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres);
59 static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres);
60 static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres);
61 static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres);
88 static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
90 static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres);
92 static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
95 static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
99 struct ocfs2_lock_res *lockres);
101 static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres);
103 static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
105 static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
114 struct ocfs2_lock_res *lockres)
116 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
119 lockres->l_name, function, line);
158 * successful downconvert. The lockres will not be referenced
175 * Called with the lockres spinlock held.
186 * Called with the lockres spinlock held.
212 * individual lockres l_flags member from the ast function. It is
286 static inline int ocfs2_is_inode_lock(struct ocfs2_lock_res *lockres)
288 return lockres->l_type == OCFS2_LOCK_TYPE_META ||
289 lockres->l_type == OCFS2_LOCK_TYPE_RW ||
290 lockres->l_type == OCFS2_LOCK_TYPE_OPEN;
298 static inline struct inode *ocfs2_lock_res_inode(struct ocfs2_lock_res *lockres)
300 BUG_ON(!ocfs2_is_inode_lock(lockres));
302 return (struct inode *) lockres->l_priv;
305 static inline struct ocfs2_dentry_lock *ocfs2_lock_res_dl(struct ocfs2_lock_res *lockres)
307 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_DENTRY);
309 return (struct ocfs2_dentry_lock *)lockres->l_priv;
312 static inline struct ocfs2_mem_dqinfo *ocfs2_lock_res_qinfo(struct ocfs2_lock_res *lockres)
314 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_QINFO);
316 return (struct ocfs2_mem_dqinfo *)lockres->l_priv;
325 static inline struct ocfs2_super *ocfs2_get_lockres_osb(struct ocfs2_lock_res *lockres)
327 if (lockres->l_ops->get_osb)
328 return lockres->l_ops->get_osb(lockres);
330 return (struct ocfs2_super *)lockres->l_priv;
334 struct ocfs2_lock_res *lockres,
337 static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
340 struct ocfs2_lock_res *lockres,
343 struct ocfs2_lock_res *lockres,
346 __ocfs2_cluster_unlock(osb, lockres, level, _RET_IP_);
349 static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres);
350 static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres);
351 static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres);
352 static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, int level);
354 struct ocfs2_lock_res *lockres);
355 static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
368 struct ocfs2_lock_res *lockres);
373 static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
376 struct ocfs2_lock_res *lockres,
381 struct ocfs2_lock_res *lockres);
383 struct ocfs2_lock_res *lockres);
409 mlog(0, "Add tracking for lockres %s\n", res->l_name);
467 static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
469 lockres->l_lock_refresh++;
472 static inline void ocfs2_track_lock_wait(struct ocfs2_lock_res *lockres)
476 if (list_empty(&lockres->l_mask_waiters)) {
477 lockres->l_lock_wait = 0;
481 mw = list_first_entry(&lockres->l_mask_waiters,
483 lockres->l_lock_wait =
499 static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
502 static inline void ocfs2_track_lock_wait(struct ocfs2_lock_res *lockres)
579 static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres)
581 struct inode *inode = ocfs2_lock_res_inode(lockres);
586 static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres)
588 struct ocfs2_mem_dqinfo *info = lockres->l_priv;
593 static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres)
595 struct ocfs2_file_private *fp = lockres->l_priv;
600 static __u64 ocfs2_get_dentry_lock_ino(struct ocfs2_lock_res *lockres)
604 memcpy(&inode_blkno_be, &lockres->l_name[OCFS2_DENTRY_LOCK_INO_START],
610 static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres)
612 struct ocfs2_dentry_lock *dl = lockres->l_priv;
623 struct ocfs2_lock_res *lockres = &dl->dl_lockres;
625 ocfs2_lock_res_init_once(lockres);
642 len = snprintf(lockres->l_name, OCFS2_DENTRY_LOCK_INO_START,
649 memcpy(&lockres->l_name[OCFS2_DENTRY_LOCK_INO_START], &inode_blkno_be,
652 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
660 /* Superblock lockres doesn't come from a slab so we call init
672 /* Rename lockres doesn't come from a slab so we call init
683 /* nfs_sync lockres doesn't come from a slab so we call init
699 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
704 ocfs2_lock_res_init_once(lockres);
705 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_TRIM_FS, 0, 0, lockres->l_name);
706 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_TRIM_FS,
712 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
714 ocfs2_simple_drop_lockres(osb, lockres);
715 ocfs2_lock_res_free(lockres);
729 void ocfs2_file_lock_res_init(struct ocfs2_lock_res *lockres,
735 ocfs2_lock_res_init_once(lockres);
737 inode->i_generation, lockres->l_name);
738 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
741 lockres->l_flags |= OCFS2_LOCK_NOCACHE;
744 void ocfs2_qinfo_lock_res_init(struct ocfs2_lock_res *lockres,
747 ocfs2_lock_res_init_once(lockres);
749 0, lockres->l_name);
750 ocfs2_lock_res_init_common(OCFS2_SB(info->dqi_gi.dqi_sb), lockres,
755 void ocfs2_refcount_lock_res_init(struct ocfs2_lock_res *lockres,
759 ocfs2_lock_res_init_once(lockres);
761 generation, lockres->l_name);
762 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_REFCOUNT,
796 * Keep a list of processes who have interest in a lockres.
799 static inline void ocfs2_add_holder(struct ocfs2_lock_res *lockres,
805 spin_lock(&lockres->l_lock);
806 list_add_tail(&oh->oh_list, &lockres->l_holders);
807 spin_unlock(&lockres->l_lock);
811 ocfs2_pid_holder(struct ocfs2_lock_res *lockres,
816 spin_lock(&lockres->l_lock);
817 list_for_each_entry(oh, &lockres->l_holders, oh_list) {
819 spin_unlock(&lockres->l_lock);
823 spin_unlock(&lockres->l_lock);
827 static inline void ocfs2_remove_holder(struct ocfs2_lock_res *lockres,
830 spin_lock(&lockres->l_lock);
832 spin_unlock(&lockres->l_lock);
838 static inline void ocfs2_inc_holders(struct ocfs2_lock_res *lockres,
841 BUG_ON(!lockres);
845 lockres->l_ex_holders++;
848 lockres->l_ro_holders++;
855 static inline void ocfs2_dec_holders(struct ocfs2_lock_res *lockres,
858 BUG_ON(!lockres);
862 BUG_ON(!lockres->l_ex_holders);
863 lockres->l_ex_holders--;
866 BUG_ON(!lockres->l_ro_holders);
867 lockres->l_ro_holders--;
888 static void lockres_set_flags(struct ocfs2_lock_res *lockres,
893 assert_spin_locked(&lockres->l_lock);
895 lockres->l_flags = newflags;
897 list_for_each_entry_safe(mw, tmp, &lockres->l_mask_waiters, mw_item) {
898 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
904 ocfs2_track_lock_wait(lockres);
907 static void lockres_or_flags(struct ocfs2_lock_res *lockres, unsigned long or)
909 lockres_set_flags(lockres, lockres->l_flags | or);
911 static void lockres_clear_flags(struct ocfs2_lock_res *lockres,
914 lockres_set_flags(lockres, lockres->l_flags & ~clear);
917 static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres)
919 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
920 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
921 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
922 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
924 lockres->l_level = lockres->l_requested;
925 if (lockres->l_level <=
926 ocfs2_highest_compat_lock_level(lockres->l_blocking)) {
927 lockres->l_blocking = DLM_LOCK_NL;
928 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
930 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
933 static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres)
935 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
936 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
942 if (lockres->l_level == DLM_LOCK_NL &&
943 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
944 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
946 lockres->l_level = lockres->l_requested;
955 if (!(lockres->l_flags & OCFS2_LOCK_NONBLOCK_FINISHED))
956 lockres_or_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
958 lockres_clear_flags(lockres, OCFS2_LOCK_NONBLOCK_FINISHED);
960 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
963 static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres)
965 BUG_ON((!(lockres->l_flags & OCFS2_LOCK_BUSY)));
966 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
968 if (lockres->l_requested > DLM_LOCK_NL &&
969 !(lockres->l_flags & OCFS2_LOCK_LOCAL) &&
970 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
971 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
973 lockres->l_level = lockres->l_requested;
974 lockres_or_flags(lockres, OCFS2_LOCK_ATTACHED);
975 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
978 static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres,
983 assert_spin_locked(&lockres->l_lock);
985 if (level > lockres->l_blocking) {
991 ocfs2_highest_compat_lock_level(lockres->l_blocking))
994 lockres->l_blocking = level;
997 mlog(ML_BASTS, "lockres %s, block %d, level %d, l_block %d, dwn %d\n",
998 lockres->l_name, level, lockres->l_level, lockres->l_blocking,
1002 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
1057 * number that matches the lockres. lockres_set_pending() will return the
1066 static void __lockres_clear_pending(struct ocfs2_lock_res *lockres,
1070 assert_spin_locked(&lockres->l_lock);
1076 if (!(lockres->l_flags & OCFS2_LOCK_PENDING) ||
1077 (lockres->l_pending_gen != generation))
1080 lockres_clear_flags(lockres, OCFS2_LOCK_PENDING);
1081 lockres->l_pending_gen++;
1087 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1092 static void lockres_clear_pending(struct ocfs2_lock_res *lockres,
1098 spin_lock_irqsave(&lockres->l_lock, flags);
1099 __lockres_clear_pending(lockres, generation, osb);
1100 spin_unlock_irqrestore(&lockres->l_lock, flags);
1103 static unsigned int lockres_set_pending(struct ocfs2_lock_res *lockres)
1105 assert_spin_locked(&lockres->l_lock);
1106 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
1108 lockres_or_flags(lockres, OCFS2_LOCK_PENDING);
1110 return lockres->l_pending_gen;
1115 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1116 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1122 mlog(ML_BASTS, "BAST fired for lockres %s, blocking %d, level %d, "
1123 "type %s\n", lockres->l_name, level, lockres->l_level,
1124 ocfs2_lock_type_string(lockres->l_type));
1130 if (lockres->l_flags & OCFS2_LOCK_NOCACHE)
1133 spin_lock_irqsave(&lockres->l_lock, flags);
1134 needs_downconvert = ocfs2_generic_handle_bast(lockres, level);
1136 ocfs2_schedule_blocked_lock(osb, lockres);
1137 spin_unlock_irqrestore(&lockres->l_lock, flags);
1139 wake_up(&lockres->l_event);
1146 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1147 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1151 spin_lock_irqsave(&lockres->l_lock, flags);
1153 status = ocfs2_dlm_lock_status(&lockres->l_lksb);
1156 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1161 mlog(ML_ERROR, "lockres %s: lksb status value of %d!\n",
1162 lockres->l_name, status);
1163 spin_unlock_irqrestore(&lockres->l_lock, flags);
1167 mlog(ML_BASTS, "AST fired for lockres %s, action %d, unlock %d, "
1168 "level %d => %d\n", lockres->l_name, lockres->l_action,
1169 lockres->l_unlock_action, lockres->l_level, lockres->l_requested);
1171 switch(lockres->l_action) {
1173 ocfs2_generic_handle_attach_action(lockres);
1174 lockres_clear_flags(lockres, OCFS2_LOCK_LOCAL);
1177 ocfs2_generic_handle_convert_action(lockres);
1180 ocfs2_generic_handle_downconvert_action(lockres);
1183 mlog(ML_ERROR, "lockres %s: AST fired with invalid action: %u, "
1185 lockres->l_name, lockres->l_action, lockres->l_flags,
1186 lockres->l_unlock_action);
1192 lockres->l_action = OCFS2_AST_INVALID;
1195 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT)
1196 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1202 * can use lockres->l_pending_gen.
1204 __lockres_clear_pending(lockres, lockres->l_pending_gen, osb);
1206 wake_up(&lockres->l_event);
1207 spin_unlock_irqrestore(&lockres->l_lock, flags);
1212 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1215 mlog(ML_BASTS, "UNLOCK AST fired for lockres %s, action = %d\n",
1216 lockres->l_name, lockres->l_unlock_action);
1218 spin_lock_irqsave(&lockres->l_lock, flags);
1221 "unlock_action %d\n", error, lockres->l_name,
1222 lockres->l_unlock_action);
1223 spin_unlock_irqrestore(&lockres->l_lock, flags);
1227 switch(lockres->l_unlock_action) {
1229 mlog(0, "Cancel convert success for %s\n", lockres->l_name);
1230 lockres->l_action = OCFS2_AST_INVALID;
1233 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1234 ocfs2_wake_downconvert_thread(ocfs2_get_lockres_osb(lockres));
1237 lockres->l_level = DLM_LOCK_IV;
1243 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1244 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1245 wake_up(&lockres->l_event);
1246 spin_unlock_irqrestore(&lockres->l_lock, flags);
1287 static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
1292 spin_lock_irqsave(&lockres->l_lock, flags);
1293 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1294 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1296 lockres->l_action = OCFS2_AST_INVALID;
1298 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1299 spin_unlock_irqrestore(&lockres->l_lock, flags);
1301 wake_up(&lockres->l_event);
1309 struct ocfs2_lock_res *lockres,
1317 mlog(0, "lock %s, level = %d, flags = %u\n", lockres->l_name, level,
1320 spin_lock_irqsave(&lockres->l_lock, flags);
1321 if ((lockres->l_flags & OCFS2_LOCK_ATTACHED) ||
1322 (lockres->l_flags & OCFS2_LOCK_BUSY)) {
1323 spin_unlock_irqrestore(&lockres->l_lock, flags);
1327 lockres->l_action = OCFS2_AST_ATTACH;
1328 lockres->l_requested = level;
1329 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1330 gen = lockres_set_pending(lockres);
1331 spin_unlock_irqrestore(&lockres->l_lock, flags);
1335 &lockres->l_lksb,
1337 lockres->l_name,
1339 lockres_clear_pending(lockres, gen, osb);
1341 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
1342 ocfs2_recover_from_dlm_error(lockres, 1);
1345 mlog(0, "lock %s, return from ocfs2_dlm_lock\n", lockres->l_name);
1351 static inline int ocfs2_check_wait_flag(struct ocfs2_lock_res *lockres,
1357 spin_lock_irqsave(&lockres->l_lock, flags);
1358 ret = lockres->l_flags & flag;
1359 spin_unlock_irqrestore(&lockres->l_lock, flags);
1364 static inline void ocfs2_wait_on_busy_lock(struct ocfs2_lock_res *lockres)
1367 wait_event(lockres->l_event,
1368 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_BUSY));
1371 static inline void ocfs2_wait_on_refreshing_lock(struct ocfs2_lock_res *lockres)
1374 wait_event(lockres->l_event,
1375 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_REFRESHING));
1381 static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
1384 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
1386 return wanted <= ocfs2_highest_compat_lock_level(lockres->l_blocking);
1404 static void lockres_add_mask_waiter(struct ocfs2_lock_res *lockres,
1411 assert_spin_locked(&lockres->l_lock);
1413 list_add_tail(&mw->mw_item, &lockres->l_mask_waiters);
1416 ocfs2_track_lock_wait(lockres);
1421 static int __lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1426 assert_spin_locked(&lockres->l_lock);
1428 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
1433 ocfs2_track_lock_wait(lockres);
1439 static int lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1445 spin_lock_irqsave(&lockres->l_lock, flags);
1446 ret = __lockres_remove_mask_waiter(lockres, mw);
1447 spin_unlock_irqrestore(&lockres->l_lock, flags);
1454 struct ocfs2_lock_res *lockres)
1460 lockres_remove_mask_waiter(lockres, mw);
1469 struct ocfs2_lock_res *lockres,
1485 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED)) {
1492 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
1498 spin_lock_irqsave(&lockres->l_lock, flags);
1505 mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING,
1506 "Cluster lock called on freeing lockres %s! flags "
1507 "0x%lx\n", lockres->l_name, lockres->l_flags);
1512 if (lockres->l_flags & OCFS2_LOCK_BUSY &&
1513 level > lockres->l_level) {
1516 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1521 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) {
1536 if (level <= lockres->l_level)
1540 if (lockres->l_flags & OCFS2_LOCK_BLOCKED &&
1541 !ocfs2_may_continue_on_blocked_lock(lockres, level)) {
1544 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BLOCKED, 0);
1549 if (level > lockres->l_level) {
1557 if (lockres->l_action != OCFS2_AST_INVALID)
1558 mlog(ML_ERROR, "lockres %s has action %u pending\n",
1559 lockres->l_name, lockres->l_action);
1561 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1562 lockres->l_action = OCFS2_AST_ATTACH;
1565 lockres->l_action = OCFS2_AST_CONVERT;
1569 lockres->l_requested = level;
1570 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1571 gen = lockres_set_pending(lockres);
1572 spin_unlock_irqrestore(&lockres->l_lock, flags);
1577 mlog(ML_BASTS, "lockres %s, convert from %d to %d\n",
1578 lockres->l_name, lockres->l_level, level);
1583 &lockres->l_lksb,
1585 lockres->l_name,
1587 lockres_clear_pending(lockres, gen, osb);
1592 ret, lockres);
1594 ocfs2_recover_from_dlm_error(lockres, 1);
1600 lockres->l_name);
1612 ocfs2_inc_holders(lockres, level);
1616 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1619 kick_dc = (lockres->l_flags & OCFS2_LOCK_BLOCKED);
1621 spin_unlock_irqrestore(&lockres->l_lock, flags);
1636 spin_lock_irqsave(&lockres->l_lock, flags);
1637 if (__lockres_remove_mask_waiter(lockres, &mw)) {
1639 lockres_or_flags(lockres,
1641 spin_unlock_irqrestore(&lockres->l_lock, flags);
1644 spin_unlock_irqrestore(&lockres->l_lock, flags);
1654 ocfs2_update_lock_stats(lockres, level, &mw, ret);
1657 if (!ret && lockres->l_lockdep_map.key != NULL) {
1659 rwsem_acquire_read(&lockres->l_lockdep_map, l_subclass,
1663 rwsem_acquire(&lockres->l_lockdep_map, l_subclass,
1672 struct ocfs2_lock_res *lockres,
1677 return __ocfs2_cluster_lock(osb, lockres, level, lkm_flags, arg_flags,
1683 struct ocfs2_lock_res *lockres,
1689 spin_lock_irqsave(&lockres->l_lock, flags);
1690 ocfs2_dec_holders(lockres, level);
1691 ocfs2_downconvert_on_unlock(osb, lockres);
1692 spin_unlock_irqrestore(&lockres->l_lock, flags);
1694 if (lockres->l_lockdep_map.key != NULL)
1695 rwsem_release(&lockres->l_lockdep_map, caller_ip);
1700 struct ocfs2_lock_res *lockres,
1708 spin_lock_irqsave(&lockres->l_lock, flags);
1709 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
1710 lockres_or_flags(lockres, OCFS2_LOCK_LOCAL);
1711 spin_unlock_irqrestore(&lockres->l_lock, flags);
1713 return ocfs2_lock_create(osb, lockres, level, lkm_flags);
1766 struct ocfs2_lock_res *lockres;
1776 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1780 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
1790 struct ocfs2_lock_res *lockres;
1800 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1804 status = ocfs2_cluster_lock(osb, lockres, level, DLM_LKF_NOQUEUE, 0);
1811 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_rw_lockres;
1819 ocfs2_cluster_unlock(osb, lockres, level);
1828 struct ocfs2_lock_res *lockres;
1837 lockres = &OCFS2_I(inode)->ip_open_lockres;
1839 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_PR, 0, 0);
1850 struct ocfs2_lock_res *lockres;
1866 lockres = &OCFS2_I(inode)->ip_open_lockres;
1876 status = ocfs2_cluster_lock(osb, lockres, level, DLM_LKF_NOQUEUE, 0);
1887 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_open_lockres;
1896 if(lockres->l_ro_holders)
1897 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_PR);
1898 if(lockres->l_ex_holders)
1899 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
1905 static int ocfs2_flock_handle_signal(struct ocfs2_lock_res *lockres,
1909 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1916 spin_lock_irqsave(&lockres->l_lock, flags);
1917 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
1918 ret = ocfs2_prepare_cancel_convert(osb, lockres);
1920 spin_unlock_irqrestore(&lockres->l_lock, flags);
1921 ret = ocfs2_cancel_convert(osb, lockres);
1928 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1929 spin_unlock_irqrestore(&lockres->l_lock, flags);
1940 if (lockres->l_level == level)
1944 lockres->l_flags, lockres->l_level, lockres->l_action);
1946 spin_unlock_irqrestore(&lockres->l_lock, flags);
1969 * - Access to any flock lockres doesn't require concurrency, so we
1979 struct ocfs2_lock_res *lockres = &fp->fp_flock;
1985 if ((lockres->l_flags & OCFS2_LOCK_BUSY) ||
1986 (lockres->l_level > DLM_LOCK_NL)) {
1989 "level: %u\n", lockres->l_name, lockres->l_flags,
1990 lockres->l_level);
1994 spin_lock_irqsave(&lockres->l_lock, flags);
1995 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1996 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1997 spin_unlock_irqrestore(&lockres->l_lock, flags);
2003 ret = ocfs2_lock_create(osb, lockres, DLM_LOCK_NL, 0);
2014 spin_lock_irqsave(&lockres->l_lock, flags);
2017 lockres->l_action = OCFS2_AST_CONVERT;
2019 lockres->l_requested = level;
2020 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
2022 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2023 spin_unlock_irqrestore(&lockres->l_lock, flags);
2025 ret = ocfs2_dlm_lock(osb->cconn, level, &lockres->l_lksb, lkm_flags,
2026 lockres->l_name, OCFS2_LOCK_ID_MAX_LEN - 1);
2029 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
2033 ocfs2_recover_from_dlm_error(lockres, 1);
2034 lockres_remove_mask_waiter(lockres, &mw);
2038 ret = ocfs2_wait_for_mask_interruptible(&mw, lockres);
2055 ret = ocfs2_flock_handle_signal(lockres, level);
2056 } else if (!ret && (level > lockres->l_level)) {
2065 lockres->l_name, ex, trylock, ret);
2075 struct ocfs2_lock_res *lockres = &fp->fp_flock;
2081 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED))
2084 if (lockres->l_level == DLM_LOCK_NL)
2088 lockres->l_name, lockres->l_flags, lockres->l_level,
2089 lockres->l_action);
2091 spin_lock_irqsave(&lockres->l_lock, flags);
2095 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
2096 lockres->l_blocking = DLM_LOCK_EX;
2098 gen = ocfs2_prepare_downconvert(lockres, DLM_LOCK_NL);
2099 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2100 spin_unlock_irqrestore(&lockres->l_lock, flags);
2102 ret = ocfs2_downconvert_lock(osb, lockres, DLM_LOCK_NL, 0, gen);
2114 struct ocfs2_lock_res *lockres)
2121 if (lockres->l_flags & OCFS2_LOCK_BLOCKED) {
2122 switch(lockres->l_blocking) {
2124 if (!lockres->l_ex_holders && !lockres->l_ro_holders)
2128 if (!lockres->l_ex_holders)
2157 /* Call this with the lockres locked. I am reasonably sure we don't
2163 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2167 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2197 mlog_meta_lvb(0, lockres);
2210 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2214 mlog_meta_lvb(0, lockres);
2216 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2220 /* We're safe here without the lockres lock... */
2251 struct ocfs2_lock_res *lockres)
2253 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2255 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb)
2269 static int ocfs2_should_refresh_lock_res(struct ocfs2_lock_res *lockres)
2275 spin_lock_irqsave(&lockres->l_lock, flags);
2276 if (!(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH)) {
2277 spin_unlock_irqrestore(&lockres->l_lock, flags);
2281 if (lockres->l_flags & OCFS2_LOCK_REFRESHING) {
2282 spin_unlock_irqrestore(&lockres->l_lock, flags);
2284 ocfs2_wait_on_refreshing_lock(lockres);
2289 lockres_or_flags(lockres, OCFS2_LOCK_REFRESHING);
2290 spin_unlock_irqrestore(&lockres->l_lock, flags);
2300 static inline void ocfs2_complete_lock_res_refresh(struct ocfs2_lock_res *lockres,
2305 spin_lock_irqsave(&lockres->l_lock, flags);
2306 lockres_clear_flags(lockres, OCFS2_LOCK_REFRESHING);
2308 lockres_clear_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
2309 spin_unlock_irqrestore(&lockres->l_lock, flags);
2311 wake_up(&lockres->l_event);
2320 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2338 if (!ocfs2_should_refresh_lock_res(lockres))
2347 if (ocfs2_meta_lvb_is_trustable(inode, lockres)) {
2390 ocfs2_track_lock_refresh(lockres);
2395 ocfs2_complete_lock_res_refresh(lockres, status);
2434 struct ocfs2_lock_res *lockres = NULL;
2459 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2465 status = __ocfs2_cluster_lock(osb, lockres, level, dlm_flags,
2492 if (lockres)
2493 ocfs2_complete_lock_res_refresh(lockres, 0);
2621 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_inode_lockres;
2630 ocfs2_cluster_unlock(osb, lockres, level);
2680 struct ocfs2_lock_res *lockres;
2685 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2686 tmp_oh = ocfs2_pid_holder(lockres, pid);
2701 ocfs2_add_holder(lockres, oh);
2736 struct ocfs2_lock_res *lockres;
2738 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2746 ocfs2_remove_holder(lockres, oh);
2752 struct ocfs2_lock_res *lockres;
2762 lockres = &osb->osb_orphan_scan.os_lockres;
2763 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2767 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2768 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2779 struct ocfs2_lock_res *lockres;
2783 lockres = &osb->osb_orphan_scan.os_lockres;
2784 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2787 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2796 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2804 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
2814 status = ocfs2_should_refresh_lock_res(lockres);
2818 ocfs2_complete_lock_res_refresh(lockres, status);
2821 ocfs2_cluster_unlock(osb, lockres, level);
2824 ocfs2_track_lock_refresh(lockres);
2834 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2837 ocfs2_cluster_unlock(osb, lockres, level);
2843 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2851 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2860 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2863 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2869 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2882 status = ocfs2_cluster_lock(osb, lockres, ex ? LKM_EXMODE : LKM_PRMODE,
2898 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2901 ocfs2_cluster_unlock(osb, lockres,
2914 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
2925 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX,
2934 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2935 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2954 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
2960 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2970 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
3070 /* We track our "dummy" iteration lockres' by a NULL
3089 /* Since lockres' have the lifetime of their container
3091 * copy this out to a temporary lockres while still
3142 struct ocfs2_lock_res *lockres = v;
3149 if (!lockres)
3153 if (!lockres->l_lock_wait && dlm_debug->d_filter_secs) {
3155 if (lockres->l_lock_prmode.ls_last >
3156 lockres->l_lock_exmode.ls_last)
3157 last = lockres->l_lock_prmode.ls_last;
3159 last = lockres->l_lock_exmode.ls_last;
3173 if (lockres->l_type == OCFS2_LOCK_TYPE_DENTRY)
3175 lockres->l_name,
3176 (unsigned int)ocfs2_get_dentry_lock_ino(lockres));
3178 seq_printf(m, "%.*s\t", OCFS2_LOCK_ID_MAX_LEN, lockres->l_name);
3188 lockres->l_level,
3189 lockres->l_flags,
3190 lockres->l_action,
3191 lockres->l_unlock_action,
3192 lockres->l_ro_holders,
3193 lockres->l_ex_holders,
3194 lockres->l_requested,
3195 lockres->l_blocking);
3198 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
3242 lock_num_prmode(lockres),
3243 lock_num_exmode(lockres),
3244 lock_num_prmode_failed(lockres),
3245 lock_num_exmode_failed(lockres),
3246 lock_total_prmode(lockres),
3247 lock_total_exmode(lockres),
3248 lock_max_prmode(lockres),
3249 lock_max_exmode(lockres),
3250 lock_refresh(lockres),
3251 lock_last_prmode(lockres),
3252 lock_last_exmode(lockres),
3253 lock_wait(lockres));
3418 struct ocfs2_lock_res *lockres)
3424 /* We didn't get anywhere near actually using this lockres. */
3425 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED))
3428 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3431 spin_lock_irqsave(&lockres->l_lock, flags);
3433 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_FREEING),
3434 "lockres %s, flags 0x%lx\n",
3435 lockres->l_name, lockres->l_flags);
3437 while (lockres->l_flags & OCFS2_LOCK_BUSY) {
3440 lockres->l_name, lockres->l_flags, lockres->l_action,
3441 lockres->l_unlock_action);
3443 spin_unlock_irqrestore(&lockres->l_lock, flags);
3448 ocfs2_wait_on_busy_lock(lockres);
3450 spin_lock_irqsave(&lockres->l_lock, flags);
3453 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3454 if (lockres->l_flags & OCFS2_LOCK_ATTACHED &&
3455 lockres->l_level == DLM_LOCK_EX &&
3456 !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3457 lockres->l_ops->set_lvb(lockres);
3460 if (lockres->l_flags & OCFS2_LOCK_BUSY)
3462 lockres->l_name);
3463 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
3464 mlog(0, "destroying blocked lock: \"%s\"\n", lockres->l_name);
3466 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
3467 spin_unlock_irqrestore(&lockres->l_lock, flags);
3471 lockres_clear_flags(lockres, OCFS2_LOCK_ATTACHED);
3475 BUG_ON(lockres->l_action != OCFS2_AST_INVALID);
3478 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3479 lockres->l_unlock_action = OCFS2_UNLOCK_DROP_LOCK;
3480 spin_unlock_irqrestore(&lockres->l_lock, flags);
3482 mlog(0, "lock %s\n", lockres->l_name);
3484 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb, lkm_flags);
3486 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3487 mlog(ML_ERROR, "lockres flags: %lu\n", lockres->l_flags);
3488 ocfs2_dlm_dump_lksb(&lockres->l_lksb);
3492 lockres->l_name);
3494 ocfs2_wait_on_busy_lock(lockres);
3500 struct ocfs2_lock_res *lockres);
3502 /* Mark the lockres as being dropped. It will no longer be
3507 * You can *not* attempt to call cluster_lock on this lockres anymore. */
3509 struct ocfs2_lock_res *lockres)
3517 spin_lock_irqsave(&lockres->l_lock, flags);
3518 lockres->l_flags |= OCFS2_LOCK_FREEING;
3519 if (lockres->l_flags & OCFS2_LOCK_QUEUED && current == osb->dc_task) {
3537 spin_unlock_irqrestore(&lockres->l_lock, flags);
3539 list_del_init(&lockres->l_blocked_list);
3548 WARN_ON_ONCE(lockres->l_ops->post_unlock);
3550 ocfs2_process_blocked_lock(osb, lockres);
3553 while (lockres->l_flags & OCFS2_LOCK_QUEUED) {
3554 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_QUEUED, 0);
3555 spin_unlock_irqrestore(&lockres->l_lock, flags);
3557 mlog(0, "Waiting on lockres %s\n", lockres->l_name);
3563 spin_lock_irqsave(&lockres->l_lock, flags);
3565 spin_unlock_irqrestore(&lockres->l_lock, flags);
3569 struct ocfs2_lock_res *lockres)
3573 ocfs2_mark_lockres_freeing(osb, lockres);
3574 ret = ocfs2_drop_lock(osb, lockres);
3618 static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
3621 assert_spin_locked(&lockres->l_lock);
3623 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
3625 if (lockres->l_level <= new_level) {
3626 mlog(ML_ERROR, "lockres %s, lvl %d <= %d, blcklst %d, mask %d, "
3628 "block %d, pgen %d\n", lockres->l_name, lockres->l_level,
3629 new_level, list_empty(&lockres->l_blocked_list),
3630 list_empty(&lockres->l_mask_waiters), lockres->l_type,
3631 lockres->l_flags, lockres->l_ro_holders,
3632 lockres->l_ex_holders, lockres->l_action,
3633 lockres->l_unlock_action, lockres->l_requested,
3634 lockres->l_blocking, lockres->l_pending_gen);
3638 mlog(ML_BASTS, "lockres %s, level %d => %d, blocking %d\n",
3639 lockres->l_name, lockres->l_level, new_level, lockres->l_blocking);
3641 lockres->l_action = OCFS2_AST_DOWNCONVERT;
3642 lockres->l_requested = new_level;
3643 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3644 return lockres_set_pending(lockres);
3648 struct ocfs2_lock_res *lockres,
3656 mlog(ML_BASTS, "lockres %s, level %d => %d\n", lockres->l_name,
3657 lockres->l_level, new_level);
3666 lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3674 &lockres->l_lksb,
3676 lockres->l_name,
3678 lockres_clear_pending(lockres, generation, osb);
3680 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
3681 ocfs2_recover_from_dlm_error(lockres, 1);
3692 struct ocfs2_lock_res *lockres)
3694 assert_spin_locked(&lockres->l_lock);
3696 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
3700 mlog(ML_BASTS, "lockres %s, skip convert\n", lockres->l_name);
3705 BUG_ON(lockres->l_action != OCFS2_AST_CONVERT &&
3706 lockres->l_action != OCFS2_AST_DOWNCONVERT);
3709 lockres->l_unlock_action = OCFS2_UNLOCK_CANCEL_CONVERT;
3711 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_BUSY),
3713 lockres->l_name, lockres->l_flags);
3715 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3721 struct ocfs2_lock_res *lockres)
3725 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb,
3728 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3729 ocfs2_recover_from_dlm_error(lockres, 0);
3732 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3738 struct ocfs2_lock_res *lockres,
3749 spin_lock_irqsave(&lockres->l_lock, flags);
3755 if (!(lockres->l_flags & OCFS2_LOCK_BLOCKED)) {
3756 BUG_ON(lockres->l_blocking != DLM_LOCK_NL);
3757 spin_unlock_irqrestore(&lockres->l_lock, flags);
3762 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
3786 if (lockres->l_flags & OCFS2_LOCK_PENDING) {
3787 mlog(ML_BASTS, "lockres %s, ReQ: Pending\n",
3788 lockres->l_name);
3793 ret = ocfs2_prepare_cancel_convert(osb, lockres);
3794 spin_unlock_irqrestore(&lockres->l_lock, flags);
3796 ret = ocfs2_cancel_convert(osb, lockres);
3812 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING)
3820 if (lockres->l_level == DLM_LOCK_NL) {
3821 BUG_ON(lockres->l_ex_holders || lockres->l_ro_holders);
3822 mlog(ML_BASTS, "lockres %s, Aborting dc\n", lockres->l_name);
3823 lockres->l_blocking = DLM_LOCK_NL;
3824 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
3825 spin_unlock_irqrestore(&lockres->l_lock, flags);
3831 if ((lockres->l_blocking == DLM_LOCK_EX)
3832 && (lockres->l_ex_holders || lockres->l_ro_holders)) {
3833 mlog(ML_BASTS, "lockres %s, ReQ: EX/PR Holders %u,%u\n",
3834 lockres->l_name, lockres->l_ex_holders,
3835 lockres->l_ro_holders);
3841 if (lockres->l_blocking == DLM_LOCK_PR &&
3842 lockres->l_ex_holders) {
3843 mlog(ML_BASTS, "lockres %s, ReQ: EX Holders %u\n",
3844 lockres->l_name, lockres->l_ex_holders);
3852 if ((lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
3853 && (lockres->l_flags & OCFS2_LOCK_REFRESHING)) {
3854 mlog(ML_BASTS, "lockres %s, ReQ: Lock Refreshing\n",
3855 lockres->l_name);
3859 new_level = ocfs2_highest_compat_lock_level(lockres->l_blocking);
3861 if (lockres->l_ops->check_downconvert
3862 && !lockres->l_ops->check_downconvert(lockres, new_level)) {
3863 mlog(ML_BASTS, "lockres %s, ReQ: Checkpointing\n",
3864 lockres->l_name);
3871 if (!lockres->l_ops->downconvert_worker)
3874 /* Some lockres types want to do a bit of work before
3878 blocking = lockres->l_blocking;
3879 level = lockres->l_level;
3880 spin_unlock_irqrestore(&lockres->l_lock, flags);
3882 ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking);
3885 mlog(ML_BASTS, "lockres %s, UNBLOCK_STOP_POST\n",
3886 lockres->l_name);
3890 spin_lock_irqsave(&lockres->l_lock, flags);
3891 if ((blocking != lockres->l_blocking) || (level != lockres->l_level)) {
3894 mlog(ML_BASTS, "lockres %s, block=%d:%d, level=%d:%d, "
3895 "Recheck\n", lockres->l_name, blocking,
3896 lockres->l_blocking, level, lockres->l_level);
3903 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3904 if (lockres->l_level == DLM_LOCK_EX)
3913 if (set_lvb && !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3914 lockres->l_ops->set_lvb(lockres);
3917 gen = ocfs2_prepare_downconvert(lockres, new_level);
3918 spin_unlock_irqrestore(&lockres->l_lock, flags);
3919 ret = ocfs2_downconvert_lock(osb, lockres, new_level, set_lvb,
3927 mlog(ML_BASTS, "lockres %s, ReQ: Downconvert busy\n",
3928 lockres->l_name);
3939 spin_unlock_irqrestore(&lockres->l_lock, flags);
3945 static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
3952 inode = ocfs2_lock_res_inode(lockres);
3998 struct ocfs2_lock_res *lockres,
4004 BUG_ON(lockres->l_level != DLM_LOCK_EX && !checkpointed);
4013 static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
4016 struct inode *inode = ocfs2_lock_res_inode(lockres);
4018 return ocfs2_ci_checkpointed(INODE_CACHE(inode), lockres, new_level);
4021 static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres)
4023 struct inode *inode = ocfs2_lock_res_inode(lockres);
4034 struct ocfs2_lock_res *lockres)
4036 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
4059 static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
4062 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
4094 spin_lock_irqsave(&lockres->l_lock, flags);
4096 if (!(lockres->l_flags & OCFS2_LOCK_FREEING)
4102 spin_unlock_irqrestore(&lockres->l_lock, flags);
4152 static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
4156 ocfs2_lock_res_refcount_tree(lockres);
4158 return ocfs2_ci_checkpointed(&tree->rf_ci, lockres, new_level);
4161 static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
4165 ocfs2_lock_res_refcount_tree(lockres);
4172 static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres)
4175 struct ocfs2_mem_dqinfo *oinfo = ocfs2_lock_res_qinfo(lockres);
4179 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
4191 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4196 ocfs2_cluster_unlock(osb, lockres, level);
4203 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4204 struct ocfs2_qinfo_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
4209 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
4235 ocfs2_track_lock_refresh(lockres);
4246 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4260 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
4265 if (!ocfs2_should_refresh_lock_res(lockres))
4271 ocfs2_complete_lock_res_refresh(lockres, status);
4280 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
4281 struct ocfs2_super *osb = lockres->l_priv;
4290 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
4300 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
4301 struct ocfs2_super *osb = lockres->l_priv;
4304 ocfs2_cluster_unlock(osb, lockres, level);
4308 struct ocfs2_lock_res *lockres)
4314 /* Our reference to the lockres in this function can be
4318 BUG_ON(!lockres);
4319 BUG_ON(!lockres->l_ops);
4321 mlog(ML_BASTS, "lockres %s blocked\n", lockres->l_name);
4328 spin_lock_irqsave(&lockres->l_lock, flags);
4329 if (lockres->l_flags & OCFS2_LOCK_FREEING)
4331 spin_unlock_irqrestore(&lockres->l_lock, flags);
4333 status = ocfs2_unblock_lock(osb, lockres, &ctl);
4337 spin_lock_irqsave(&lockres->l_lock, flags);
4339 if (lockres->l_flags & OCFS2_LOCK_FREEING || !ctl.requeue) {
4340 lockres_clear_flags(lockres, OCFS2_LOCK_QUEUED);
4342 ocfs2_schedule_blocked_lock(osb, lockres);
4344 mlog(ML_BASTS, "lockres %s, requeue = %s.\n", lockres->l_name,
4346 spin_unlock_irqrestore(&lockres->l_lock, flags);
4349 && lockres->l_ops->post_unlock)
4350 lockres->l_ops->post_unlock(osb, lockres);
4354 struct ocfs2_lock_res *lockres)
4358 assert_spin_locked(&lockres->l_lock);
4360 if (lockres->l_flags & OCFS2_LOCK_FREEING) {
4364 mlog(ML_BASTS, "lockres %s won't be scheduled: flags 0x%lx\n",
4365 lockres->l_name, lockres->l_flags);
4369 lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
4372 if (list_empty(&lockres->l_blocked_list)) {
4373 list_add_tail(&lockres->l_blocked_list,
4384 struct ocfs2_lock_res *lockres;
4399 lockres = list_entry(osb->blocked_lock_list.next,
4401 list_del_init(&lockres->l_blocked_list);
4408 ocfs2_process_blocked_lock(osb, lockres);