Lines Matching refs:lockres
59 static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres);
60 static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres);
61 static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres);
62 static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres);
89 static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
91 static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres);
93 static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
96 static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
100 struct ocfs2_lock_res *lockres);
102 static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres);
104 static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
106 static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
115 struct ocfs2_lock_res *lockres)
117 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
120 lockres->l_name, function, line);
159 * successful downconvert. The lockres will not be referenced
176 * Called with the lockres spinlock held.
187 * Called with the lockres spinlock held.
213 * individual lockres l_flags member from the ast function. It is
287 static inline int ocfs2_is_inode_lock(struct ocfs2_lock_res *lockres)
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;
299 static inline struct inode *ocfs2_lock_res_inode(struct ocfs2_lock_res *lockres)
301 BUG_ON(!ocfs2_is_inode_lock(lockres));
303 return (struct inode *) lockres->l_priv;
306 static inline struct ocfs2_dentry_lock *ocfs2_lock_res_dl(struct ocfs2_lock_res *lockres)
308 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_DENTRY);
310 return (struct ocfs2_dentry_lock *)lockres->l_priv;
313 static inline struct ocfs2_mem_dqinfo *ocfs2_lock_res_qinfo(struct ocfs2_lock_res *lockres)
315 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_QINFO);
317 return (struct ocfs2_mem_dqinfo *)lockres->l_priv;
326 static inline struct ocfs2_super *ocfs2_get_lockres_osb(struct ocfs2_lock_res *lockres)
328 if (lockres->l_ops->get_osb)
329 return lockres->l_ops->get_osb(lockres);
331 return (struct ocfs2_super *)lockres->l_priv;
335 struct ocfs2_lock_res *lockres,
338 static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
341 struct ocfs2_lock_res *lockres,
344 struct ocfs2_lock_res *lockres,
347 __ocfs2_cluster_unlock(osb, lockres, level, _RET_IP_);
350 static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres);
351 static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres);
352 static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres);
353 static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, int level);
355 struct ocfs2_lock_res *lockres);
356 static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
369 struct ocfs2_lock_res *lockres);
374 static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
377 struct ocfs2_lock_res *lockres,
382 struct ocfs2_lock_res *lockres);
384 struct ocfs2_lock_res *lockres);
410 mlog(0, "Add tracking for lockres %s\n", res->l_name);
468 static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
470 lockres->l_lock_refresh++;
473 static inline void ocfs2_track_lock_wait(struct ocfs2_lock_res *lockres)
477 if (list_empty(&lockres->l_mask_waiters)) {
478 lockres->l_lock_wait = 0;
482 mw = list_first_entry(&lockres->l_mask_waiters,
484 lockres->l_lock_wait =
500 static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
503 static inline void ocfs2_track_lock_wait(struct ocfs2_lock_res *lockres)
580 static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres)
582 struct inode *inode = ocfs2_lock_res_inode(lockres);
587 static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres)
589 struct ocfs2_mem_dqinfo *info = lockres->l_priv;
594 static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres)
596 struct ocfs2_file_private *fp = lockres->l_priv;
601 static __u64 ocfs2_get_dentry_lock_ino(struct ocfs2_lock_res *lockres)
605 memcpy(&inode_blkno_be, &lockres->l_name[OCFS2_DENTRY_LOCK_INO_START],
611 static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres)
613 struct ocfs2_dentry_lock *dl = lockres->l_priv;
624 struct ocfs2_lock_res *lockres = &dl->dl_lockres;
626 ocfs2_lock_res_init_once(lockres);
643 len = snprintf(lockres->l_name, OCFS2_DENTRY_LOCK_INO_START,
650 memcpy(&lockres->l_name[OCFS2_DENTRY_LOCK_INO_START], &inode_blkno_be,
653 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
661 /* Superblock lockres doesn't come from a slab so we call init
673 /* Rename lockres doesn't come from a slab so we call init
684 /* nfs_sync lockres doesn't come from a slab so we call init
700 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
705 ocfs2_lock_res_init_once(lockres);
706 ocfs2_build_lock_name(OCFS2_LOCK_TYPE_TRIM_FS, 0, 0, lockres->l_name);
707 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_TRIM_FS,
713 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
715 ocfs2_simple_drop_lockres(osb, lockres);
716 ocfs2_lock_res_free(lockres);
730 void ocfs2_file_lock_res_init(struct ocfs2_lock_res *lockres,
736 ocfs2_lock_res_init_once(lockres);
738 inode->i_generation, lockres->l_name);
739 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
742 lockres->l_flags |= OCFS2_LOCK_NOCACHE;
745 void ocfs2_qinfo_lock_res_init(struct ocfs2_lock_res *lockres,
748 ocfs2_lock_res_init_once(lockres);
750 0, lockres->l_name);
751 ocfs2_lock_res_init_common(OCFS2_SB(info->dqi_gi.dqi_sb), lockres,
756 void ocfs2_refcount_lock_res_init(struct ocfs2_lock_res *lockres,
760 ocfs2_lock_res_init_once(lockres);
762 generation, lockres->l_name);
763 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_REFCOUNT,
797 * Keep a list of processes who have interest in a lockres.
800 static inline void ocfs2_add_holder(struct ocfs2_lock_res *lockres,
806 spin_lock(&lockres->l_lock);
807 list_add_tail(&oh->oh_list, &lockres->l_holders);
808 spin_unlock(&lockres->l_lock);
812 ocfs2_pid_holder(struct ocfs2_lock_res *lockres,
817 spin_lock(&lockres->l_lock);
818 list_for_each_entry(oh, &lockres->l_holders, oh_list) {
820 spin_unlock(&lockres->l_lock);
824 spin_unlock(&lockres->l_lock);
828 static inline void ocfs2_remove_holder(struct ocfs2_lock_res *lockres,
831 spin_lock(&lockres->l_lock);
833 spin_unlock(&lockres->l_lock);
839 static inline void ocfs2_inc_holders(struct ocfs2_lock_res *lockres,
842 BUG_ON(!lockres);
846 lockres->l_ex_holders++;
849 lockres->l_ro_holders++;
856 static inline void ocfs2_dec_holders(struct ocfs2_lock_res *lockres,
859 BUG_ON(!lockres);
863 BUG_ON(!lockres->l_ex_holders);
864 lockres->l_ex_holders--;
867 BUG_ON(!lockres->l_ro_holders);
868 lockres->l_ro_holders--;
889 static void lockres_set_flags(struct ocfs2_lock_res *lockres,
894 assert_spin_locked(&lockres->l_lock);
896 lockres->l_flags = newflags;
898 list_for_each_entry_safe(mw, tmp, &lockres->l_mask_waiters, mw_item) {
899 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
905 ocfs2_track_lock_wait(lockres);
908 static void lockres_or_flags(struct ocfs2_lock_res *lockres, unsigned long or)
910 lockres_set_flags(lockres, lockres->l_flags | or);
912 static void lockres_clear_flags(struct ocfs2_lock_res *lockres,
915 lockres_set_flags(lockres, lockres->l_flags & ~clear);
918 static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres)
920 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
921 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
922 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
923 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
925 lockres->l_level = lockres->l_requested;
926 if (lockres->l_level <=
927 ocfs2_highest_compat_lock_level(lockres->l_blocking)) {
928 lockres->l_blocking = DLM_LOCK_NL;
929 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
931 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
934 static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres)
936 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
937 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
943 if (lockres->l_level == DLM_LOCK_NL &&
944 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
945 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
947 lockres->l_level = lockres->l_requested;
956 if (!(lockres->l_flags & OCFS2_LOCK_NONBLOCK_FINISHED))
957 lockres_or_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
959 lockres_clear_flags(lockres, OCFS2_LOCK_NONBLOCK_FINISHED);
961 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
964 static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres)
966 BUG_ON((!(lockres->l_flags & OCFS2_LOCK_BUSY)));
967 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
969 if (lockres->l_requested > DLM_LOCK_NL &&
970 !(lockres->l_flags & OCFS2_LOCK_LOCAL) &&
971 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
972 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
974 lockres->l_level = lockres->l_requested;
975 lockres_or_flags(lockres, OCFS2_LOCK_ATTACHED);
976 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
979 static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres,
984 assert_spin_locked(&lockres->l_lock);
986 if (level > lockres->l_blocking) {
992 ocfs2_highest_compat_lock_level(lockres->l_blocking))
995 lockres->l_blocking = level;
998 mlog(ML_BASTS, "lockres %s, block %d, level %d, l_block %d, dwn %d\n",
999 lockres->l_name, level, lockres->l_level, lockres->l_blocking,
1003 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
1058 * number that matches the lockres. lockres_set_pending() will return the
1067 static void __lockres_clear_pending(struct ocfs2_lock_res *lockres,
1071 assert_spin_locked(&lockres->l_lock);
1077 if (!(lockres->l_flags & OCFS2_LOCK_PENDING) ||
1078 (lockres->l_pending_gen != generation))
1081 lockres_clear_flags(lockres, OCFS2_LOCK_PENDING);
1082 lockres->l_pending_gen++;
1088 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1093 static void lockres_clear_pending(struct ocfs2_lock_res *lockres,
1099 spin_lock_irqsave(&lockres->l_lock, flags);
1100 __lockres_clear_pending(lockres, generation, osb);
1101 spin_unlock_irqrestore(&lockres->l_lock, flags);
1104 static unsigned int lockres_set_pending(struct ocfs2_lock_res *lockres)
1106 assert_spin_locked(&lockres->l_lock);
1107 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
1109 lockres_or_flags(lockres, OCFS2_LOCK_PENDING);
1111 return lockres->l_pending_gen;
1116 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1117 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1123 mlog(ML_BASTS, "BAST fired for lockres %s, blocking %d, level %d, "
1124 "type %s\n", lockres->l_name, level, lockres->l_level,
1125 ocfs2_lock_type_string(lockres->l_type));
1131 if (lockres->l_flags & OCFS2_LOCK_NOCACHE)
1134 spin_lock_irqsave(&lockres->l_lock, flags);
1135 needs_downconvert = ocfs2_generic_handle_bast(lockres, level);
1137 ocfs2_schedule_blocked_lock(osb, lockres);
1138 spin_unlock_irqrestore(&lockres->l_lock, flags);
1140 wake_up(&lockres->l_event);
1147 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1148 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1152 spin_lock_irqsave(&lockres->l_lock, flags);
1154 status = ocfs2_dlm_lock_status(&lockres->l_lksb);
1157 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1162 mlog(ML_ERROR, "lockres %s: lksb status value of %d!\n",
1163 lockres->l_name, status);
1164 spin_unlock_irqrestore(&lockres->l_lock, flags);
1168 mlog(ML_BASTS, "AST fired for lockres %s, action %d, unlock %d, "
1169 "level %d => %d\n", lockres->l_name, lockres->l_action,
1170 lockres->l_unlock_action, lockres->l_level, lockres->l_requested);
1172 switch(lockres->l_action) {
1174 ocfs2_generic_handle_attach_action(lockres);
1175 lockres_clear_flags(lockres, OCFS2_LOCK_LOCAL);
1178 ocfs2_generic_handle_convert_action(lockres);
1181 ocfs2_generic_handle_downconvert_action(lockres);
1184 mlog(ML_ERROR, "lockres %s: AST fired with invalid action: %u, "
1186 lockres->l_name, lockres->l_action, lockres->l_flags,
1187 lockres->l_unlock_action);
1193 lockres->l_action = OCFS2_AST_INVALID;
1196 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT)
1197 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1203 * can use lockres->l_pending_gen.
1205 __lockres_clear_pending(lockres, lockres->l_pending_gen, osb);
1207 wake_up(&lockres->l_event);
1208 spin_unlock_irqrestore(&lockres->l_lock, flags);
1213 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1216 mlog(ML_BASTS, "UNLOCK AST fired for lockres %s, action = %d\n",
1217 lockres->l_name, lockres->l_unlock_action);
1219 spin_lock_irqsave(&lockres->l_lock, flags);
1222 "unlock_action %d\n", error, lockres->l_name,
1223 lockres->l_unlock_action);
1224 spin_unlock_irqrestore(&lockres->l_lock, flags);
1228 switch(lockres->l_unlock_action) {
1230 mlog(0, "Cancel convert success for %s\n", lockres->l_name);
1231 lockres->l_action = OCFS2_AST_INVALID;
1234 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1235 ocfs2_wake_downconvert_thread(ocfs2_get_lockres_osb(lockres));
1238 lockres->l_level = DLM_LOCK_IV;
1244 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1245 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1246 wake_up(&lockres->l_event);
1247 spin_unlock_irqrestore(&lockres->l_lock, flags);
1288 static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
1293 spin_lock_irqsave(&lockres->l_lock, flags);
1294 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1295 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1297 lockres->l_action = OCFS2_AST_INVALID;
1299 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1300 spin_unlock_irqrestore(&lockres->l_lock, flags);
1302 wake_up(&lockres->l_event);
1310 struct ocfs2_lock_res *lockres,
1318 mlog(0, "lock %s, level = %d, flags = %u\n", lockres->l_name, level,
1321 spin_lock_irqsave(&lockres->l_lock, flags);
1322 if ((lockres->l_flags & OCFS2_LOCK_ATTACHED) ||
1323 (lockres->l_flags & OCFS2_LOCK_BUSY)) {
1324 spin_unlock_irqrestore(&lockres->l_lock, flags);
1328 lockres->l_action = OCFS2_AST_ATTACH;
1329 lockres->l_requested = level;
1330 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1331 gen = lockres_set_pending(lockres);
1332 spin_unlock_irqrestore(&lockres->l_lock, flags);
1336 &lockres->l_lksb,
1338 lockres->l_name,
1340 lockres_clear_pending(lockres, gen, osb);
1342 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
1343 ocfs2_recover_from_dlm_error(lockres, 1);
1346 mlog(0, "lock %s, return from ocfs2_dlm_lock\n", lockres->l_name);
1352 static inline int ocfs2_check_wait_flag(struct ocfs2_lock_res *lockres,
1358 spin_lock_irqsave(&lockres->l_lock, flags);
1359 ret = lockres->l_flags & flag;
1360 spin_unlock_irqrestore(&lockres->l_lock, flags);
1365 static inline void ocfs2_wait_on_busy_lock(struct ocfs2_lock_res *lockres)
1368 wait_event(lockres->l_event,
1369 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_BUSY));
1372 static inline void ocfs2_wait_on_refreshing_lock(struct ocfs2_lock_res *lockres)
1375 wait_event(lockres->l_event,
1376 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_REFRESHING));
1382 static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
1385 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
1387 return wanted <= ocfs2_highest_compat_lock_level(lockres->l_blocking);
1405 static void lockres_add_mask_waiter(struct ocfs2_lock_res *lockres,
1412 assert_spin_locked(&lockres->l_lock);
1414 list_add_tail(&mw->mw_item, &lockres->l_mask_waiters);
1417 ocfs2_track_lock_wait(lockres);
1422 static int __lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1427 assert_spin_locked(&lockres->l_lock);
1429 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
1434 ocfs2_track_lock_wait(lockres);
1440 static int lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1446 spin_lock_irqsave(&lockres->l_lock, flags);
1447 ret = __lockres_remove_mask_waiter(lockres, mw);
1448 spin_unlock_irqrestore(&lockres->l_lock, flags);
1455 struct ocfs2_lock_res *lockres)
1461 lockres_remove_mask_waiter(lockres, mw);
1470 struct ocfs2_lock_res *lockres,
1486 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED)) {
1493 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
1499 spin_lock_irqsave(&lockres->l_lock, flags);
1506 mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING,
1507 "Cluster lock called on freeing lockres %s! flags "
1508 "0x%lx\n", lockres->l_name, lockres->l_flags);
1513 if (lockres->l_flags & OCFS2_LOCK_BUSY &&
1514 level > lockres->l_level) {
1517 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1522 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) {
1537 if (level <= lockres->l_level)
1541 if (lockres->l_flags & OCFS2_LOCK_BLOCKED &&
1542 !ocfs2_may_continue_on_blocked_lock(lockres, level)) {
1545 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BLOCKED, 0);
1550 if (level > lockres->l_level) {
1558 if (lockres->l_action != OCFS2_AST_INVALID)
1559 mlog(ML_ERROR, "lockres %s has action %u pending\n",
1560 lockres->l_name, lockres->l_action);
1562 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1563 lockres->l_action = OCFS2_AST_ATTACH;
1566 lockres->l_action = OCFS2_AST_CONVERT;
1570 lockres->l_requested = level;
1571 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1572 gen = lockres_set_pending(lockres);
1573 spin_unlock_irqrestore(&lockres->l_lock, flags);
1578 mlog(ML_BASTS, "lockres %s, convert from %d to %d\n",
1579 lockres->l_name, lockres->l_level, level);
1584 &lockres->l_lksb,
1586 lockres->l_name,
1588 lockres_clear_pending(lockres, gen, osb);
1593 ret, lockres);
1595 ocfs2_recover_from_dlm_error(lockres, 1);
1601 lockres->l_name);
1613 ocfs2_inc_holders(lockres, level);
1617 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1620 kick_dc = (lockres->l_flags & OCFS2_LOCK_BLOCKED);
1622 spin_unlock_irqrestore(&lockres->l_lock, flags);
1637 spin_lock_irqsave(&lockres->l_lock, flags);
1638 if (__lockres_remove_mask_waiter(lockres, &mw)) {
1640 lockres_or_flags(lockres,
1642 spin_unlock_irqrestore(&lockres->l_lock, flags);
1645 spin_unlock_irqrestore(&lockres->l_lock, flags);
1655 ocfs2_update_lock_stats(lockres, level, &mw, ret);
1658 if (!ret && lockres->l_lockdep_map.key != NULL) {
1660 rwsem_acquire_read(&lockres->l_lockdep_map, l_subclass,
1664 rwsem_acquire(&lockres->l_lockdep_map, l_subclass,
1673 struct ocfs2_lock_res *lockres,
1678 return __ocfs2_cluster_lock(osb, lockres, level, lkm_flags, arg_flags,
1684 struct ocfs2_lock_res *lockres,
1690 spin_lock_irqsave(&lockres->l_lock, flags);
1691 ocfs2_dec_holders(lockres, level);
1692 ocfs2_downconvert_on_unlock(osb, lockres);
1693 spin_unlock_irqrestore(&lockres->l_lock, flags);
1695 if (lockres->l_lockdep_map.key != NULL)
1696 rwsem_release(&lockres->l_lockdep_map, caller_ip);
1701 struct ocfs2_lock_res *lockres,
1709 spin_lock_irqsave(&lockres->l_lock, flags);
1710 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
1711 lockres_or_flags(lockres, OCFS2_LOCK_LOCAL);
1712 spin_unlock_irqrestore(&lockres->l_lock, flags);
1714 return ocfs2_lock_create(osb, lockres, level, lkm_flags);
1767 struct ocfs2_lock_res *lockres;
1777 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1781 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
1791 struct ocfs2_lock_res *lockres;
1801 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1805 status = ocfs2_cluster_lock(osb, lockres, level, DLM_LKF_NOQUEUE, 0);
1812 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_rw_lockres;
1820 ocfs2_cluster_unlock(osb, lockres, level);
1829 struct ocfs2_lock_res *lockres;
1838 lockres = &OCFS2_I(inode)->ip_open_lockres;
1840 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_PR, 0, 0);
1851 struct ocfs2_lock_res *lockres;
1867 lockres = &OCFS2_I(inode)->ip_open_lockres;
1877 status = ocfs2_cluster_lock(osb, lockres, level, DLM_LKF_NOQUEUE, 0);
1888 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_open_lockres;
1897 if(lockres->l_ro_holders)
1898 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_PR);
1899 if(lockres->l_ex_holders)
1900 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
1906 static int ocfs2_flock_handle_signal(struct ocfs2_lock_res *lockres,
1910 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1917 spin_lock_irqsave(&lockres->l_lock, flags);
1918 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
1919 ret = ocfs2_prepare_cancel_convert(osb, lockres);
1921 spin_unlock_irqrestore(&lockres->l_lock, flags);
1922 ret = ocfs2_cancel_convert(osb, lockres);
1929 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1930 spin_unlock_irqrestore(&lockres->l_lock, flags);
1941 if (lockres->l_level == level)
1945 lockres->l_flags, lockres->l_level, lockres->l_action);
1947 spin_unlock_irqrestore(&lockres->l_lock, flags);
1970 * - Access to any flock lockres doesn't require concurrency, so we
1980 struct ocfs2_lock_res *lockres = &fp->fp_flock;
1986 if ((lockres->l_flags & OCFS2_LOCK_BUSY) ||
1987 (lockres->l_level > DLM_LOCK_NL)) {
1990 "level: %u\n", lockres->l_name, lockres->l_flags,
1991 lockres->l_level);
1995 spin_lock_irqsave(&lockres->l_lock, flags);
1996 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1997 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1998 spin_unlock_irqrestore(&lockres->l_lock, flags);
2004 ret = ocfs2_lock_create(osb, lockres, DLM_LOCK_NL, 0);
2015 spin_lock_irqsave(&lockres->l_lock, flags);
2018 lockres->l_action = OCFS2_AST_CONVERT;
2020 lockres->l_requested = level;
2021 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
2023 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2024 spin_unlock_irqrestore(&lockres->l_lock, flags);
2026 ret = ocfs2_dlm_lock(osb->cconn, level, &lockres->l_lksb, lkm_flags,
2027 lockres->l_name, OCFS2_LOCK_ID_MAX_LEN - 1);
2030 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
2034 ocfs2_recover_from_dlm_error(lockres, 1);
2035 lockres_remove_mask_waiter(lockres, &mw);
2039 ret = ocfs2_wait_for_mask_interruptible(&mw, lockres);
2056 ret = ocfs2_flock_handle_signal(lockres, level);
2057 } else if (!ret && (level > lockres->l_level)) {
2066 lockres->l_name, ex, trylock, ret);
2076 struct ocfs2_lock_res *lockres = &fp->fp_flock;
2082 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED))
2085 if (lockres->l_level == DLM_LOCK_NL)
2089 lockres->l_name, lockres->l_flags, lockres->l_level,
2090 lockres->l_action);
2092 spin_lock_irqsave(&lockres->l_lock, flags);
2096 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
2097 lockres->l_blocking = DLM_LOCK_EX;
2099 gen = ocfs2_prepare_downconvert(lockres, DLM_LOCK_NL);
2100 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2101 spin_unlock_irqrestore(&lockres->l_lock, flags);
2103 ret = ocfs2_downconvert_lock(osb, lockres, DLM_LOCK_NL, 0, gen);
2115 struct ocfs2_lock_res *lockres)
2122 if (lockres->l_flags & OCFS2_LOCK_BLOCKED) {
2123 switch(lockres->l_blocking) {
2125 if (!lockres->l_ex_holders && !lockres->l_ro_holders)
2129 if (!lockres->l_ex_holders)
2158 /* Call this with the lockres locked. I am reasonably sure we don't
2164 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;
2213 mlog_meta_lvb(0, lockres);
2215 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2217 /* We're safe here without the lockres lock... */
2246 struct ocfs2_lock_res *lockres)
2248 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2250 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb)
2264 static int ocfs2_should_refresh_lock_res(struct ocfs2_lock_res *lockres)
2270 spin_lock_irqsave(&lockres->l_lock, flags);
2271 if (!(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH)) {
2272 spin_unlock_irqrestore(&lockres->l_lock, flags);
2276 if (lockres->l_flags & OCFS2_LOCK_REFRESHING) {
2277 spin_unlock_irqrestore(&lockres->l_lock, flags);
2279 ocfs2_wait_on_refreshing_lock(lockres);
2284 lockres_or_flags(lockres, OCFS2_LOCK_REFRESHING);
2285 spin_unlock_irqrestore(&lockres->l_lock, flags);
2295 static inline void ocfs2_complete_lock_res_refresh(struct ocfs2_lock_res *lockres,
2300 spin_lock_irqsave(&lockres->l_lock, flags);
2301 lockres_clear_flags(lockres, OCFS2_LOCK_REFRESHING);
2303 lockres_clear_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
2304 spin_unlock_irqrestore(&lockres->l_lock, flags);
2306 wake_up(&lockres->l_event);
2315 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2333 if (!ocfs2_should_refresh_lock_res(lockres))
2342 if (ocfs2_meta_lvb_is_trustable(inode, lockres)) {
2380 ocfs2_track_lock_refresh(lockres);
2385 ocfs2_complete_lock_res_refresh(lockres, status);
2424 struct ocfs2_lock_res *lockres = NULL;
2449 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2455 status = __ocfs2_cluster_lock(osb, lockres, level, dlm_flags,
2482 if (lockres)
2483 ocfs2_complete_lock_res_refresh(lockres, 0);
2611 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_inode_lockres;
2620 ocfs2_cluster_unlock(osb, lockres, level);
2670 struct ocfs2_lock_res *lockres;
2675 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2676 tmp_oh = ocfs2_pid_holder(lockres, pid);
2691 ocfs2_add_holder(lockres, oh);
2726 struct ocfs2_lock_res *lockres;
2728 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2736 ocfs2_remove_holder(lockres, oh);
2742 struct ocfs2_lock_res *lockres;
2752 lockres = &osb->osb_orphan_scan.os_lockres;
2753 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2757 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2758 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2769 struct ocfs2_lock_res *lockres;
2773 lockres = &osb->osb_orphan_scan.os_lockres;
2774 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2777 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2786 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2794 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
2804 status = ocfs2_should_refresh_lock_res(lockres);
2808 ocfs2_complete_lock_res_refresh(lockres, status);
2811 ocfs2_cluster_unlock(osb, lockres, level);
2814 ocfs2_track_lock_refresh(lockres);
2824 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2827 ocfs2_cluster_unlock(osb, lockres, level);
2833 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2841 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2850 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2853 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2859 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2872 status = ocfs2_cluster_lock(osb, lockres, ex ? LKM_EXMODE : LKM_PRMODE,
2888 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2891 ocfs2_cluster_unlock(osb, lockres,
2904 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
2915 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX,
2924 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2925 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2944 struct ocfs2_lock_res *lockres = &osb->osb_trim_fs_lockres;
2950 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2960 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
3060 /* We track our "dummy" iteration lockres' by a NULL
3079 /* Since lockres' have the lifetime of their container
3081 * copy this out to a temporary lockres while still
3132 struct ocfs2_lock_res *lockres = v;
3139 if (!lockres)
3143 if (!lockres->l_lock_wait && dlm_debug->d_filter_secs) {
3145 if (lockres->l_lock_prmode.ls_last >
3146 lockres->l_lock_exmode.ls_last)
3147 last = lockres->l_lock_prmode.ls_last;
3149 last = lockres->l_lock_exmode.ls_last;
3163 if (lockres->l_type == OCFS2_LOCK_TYPE_DENTRY)
3165 lockres->l_name,
3166 (unsigned int)ocfs2_get_dentry_lock_ino(lockres));
3168 seq_printf(m, "%.*s\t", OCFS2_LOCK_ID_MAX_LEN, lockres->l_name);
3178 lockres->l_level,
3179 lockres->l_flags,
3180 lockres->l_action,
3181 lockres->l_unlock_action,
3182 lockres->l_ro_holders,
3183 lockres->l_ex_holders,
3184 lockres->l_requested,
3185 lockres->l_blocking);
3188 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
3232 lock_num_prmode(lockres),
3233 lock_num_exmode(lockres),
3234 lock_num_prmode_failed(lockres),
3235 lock_num_exmode_failed(lockres),
3236 lock_total_prmode(lockres),
3237 lock_total_exmode(lockres),
3238 lock_max_prmode(lockres),
3239 lock_max_exmode(lockres),
3240 lock_refresh(lockres),
3241 lock_last_prmode(lockres),
3242 lock_last_exmode(lockres),
3243 lock_wait(lockres));
3408 struct ocfs2_lock_res *lockres)
3414 /* We didn't get anywhere near actually using this lockres. */
3415 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED))
3418 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3421 spin_lock_irqsave(&lockres->l_lock, flags);
3423 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_FREEING),
3424 "lockres %s, flags 0x%lx\n",
3425 lockres->l_name, lockres->l_flags);
3427 while (lockres->l_flags & OCFS2_LOCK_BUSY) {
3430 lockres->l_name, lockres->l_flags, lockres->l_action,
3431 lockres->l_unlock_action);
3433 spin_unlock_irqrestore(&lockres->l_lock, flags);
3438 ocfs2_wait_on_busy_lock(lockres);
3440 spin_lock_irqsave(&lockres->l_lock, flags);
3443 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3444 if (lockres->l_flags & OCFS2_LOCK_ATTACHED &&
3445 lockres->l_level == DLM_LOCK_EX &&
3446 !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3447 lockres->l_ops->set_lvb(lockres);
3450 if (lockres->l_flags & OCFS2_LOCK_BUSY)
3452 lockres->l_name);
3453 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
3454 mlog(0, "destroying blocked lock: \"%s\"\n", lockres->l_name);
3456 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
3457 spin_unlock_irqrestore(&lockres->l_lock, flags);
3461 lockres_clear_flags(lockres, OCFS2_LOCK_ATTACHED);
3465 BUG_ON(lockres->l_action != OCFS2_AST_INVALID);
3468 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3469 lockres->l_unlock_action = OCFS2_UNLOCK_DROP_LOCK;
3470 spin_unlock_irqrestore(&lockres->l_lock, flags);
3472 mlog(0, "lock %s\n", lockres->l_name);
3474 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb, lkm_flags);
3476 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3477 mlog(ML_ERROR, "lockres flags: %lu\n", lockres->l_flags);
3478 ocfs2_dlm_dump_lksb(&lockres->l_lksb);
3482 lockres->l_name);
3484 ocfs2_wait_on_busy_lock(lockres);
3490 struct ocfs2_lock_res *lockres);
3492 /* Mark the lockres as being dropped. It will no longer be
3497 * You can *not* attempt to call cluster_lock on this lockres anymore. */
3499 struct ocfs2_lock_res *lockres)
3507 spin_lock_irqsave(&lockres->l_lock, flags);
3508 lockres->l_flags |= OCFS2_LOCK_FREEING;
3509 if (lockres->l_flags & OCFS2_LOCK_QUEUED && current == osb->dc_task) {
3527 spin_unlock_irqrestore(&lockres->l_lock, flags);
3529 list_del_init(&lockres->l_blocked_list);
3538 WARN_ON_ONCE(lockres->l_ops->post_unlock);
3540 ocfs2_process_blocked_lock(osb, lockres);
3543 while (lockres->l_flags & OCFS2_LOCK_QUEUED) {
3544 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_QUEUED, 0);
3545 spin_unlock_irqrestore(&lockres->l_lock, flags);
3547 mlog(0, "Waiting on lockres %s\n", lockres->l_name);
3553 spin_lock_irqsave(&lockres->l_lock, flags);
3555 spin_unlock_irqrestore(&lockres->l_lock, flags);
3559 struct ocfs2_lock_res *lockres)
3563 ocfs2_mark_lockres_freeing(osb, lockres);
3564 ret = ocfs2_drop_lock(osb, lockres);
3608 static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
3611 assert_spin_locked(&lockres->l_lock);
3613 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
3615 if (lockres->l_level <= new_level) {
3616 mlog(ML_ERROR, "lockres %s, lvl %d <= %d, blcklst %d, mask %d, "
3618 "block %d, pgen %d\n", lockres->l_name, lockres->l_level,
3619 new_level, list_empty(&lockres->l_blocked_list),
3620 list_empty(&lockres->l_mask_waiters), lockres->l_type,
3621 lockres->l_flags, lockres->l_ro_holders,
3622 lockres->l_ex_holders, lockres->l_action,
3623 lockres->l_unlock_action, lockres->l_requested,
3624 lockres->l_blocking, lockres->l_pending_gen);
3628 mlog(ML_BASTS, "lockres %s, level %d => %d, blocking %d\n",
3629 lockres->l_name, lockres->l_level, new_level, lockres->l_blocking);
3631 lockres->l_action = OCFS2_AST_DOWNCONVERT;
3632 lockres->l_requested = new_level;
3633 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3634 return lockres_set_pending(lockres);
3638 struct ocfs2_lock_res *lockres,
3646 mlog(ML_BASTS, "lockres %s, level %d => %d\n", lockres->l_name,
3647 lockres->l_level, new_level);
3656 lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3664 &lockres->l_lksb,
3666 lockres->l_name,
3668 lockres_clear_pending(lockres, generation, osb);
3670 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
3671 ocfs2_recover_from_dlm_error(lockres, 1);
3682 struct ocfs2_lock_res *lockres)
3684 assert_spin_locked(&lockres->l_lock);
3686 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
3690 mlog(ML_BASTS, "lockres %s, skip convert\n", lockres->l_name);
3695 BUG_ON(lockres->l_action != OCFS2_AST_CONVERT &&
3696 lockres->l_action != OCFS2_AST_DOWNCONVERT);
3699 lockres->l_unlock_action = OCFS2_UNLOCK_CANCEL_CONVERT;
3701 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_BUSY),
3703 lockres->l_name, lockres->l_flags);
3705 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3711 struct ocfs2_lock_res *lockres)
3715 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb,
3718 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3719 ocfs2_recover_from_dlm_error(lockres, 0);
3722 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3728 struct ocfs2_lock_res *lockres,
3739 spin_lock_irqsave(&lockres->l_lock, flags);
3745 if (!(lockres->l_flags & OCFS2_LOCK_BLOCKED)) {
3746 BUG_ON(lockres->l_blocking != DLM_LOCK_NL);
3747 spin_unlock_irqrestore(&lockres->l_lock, flags);
3752 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
3776 if (lockres->l_flags & OCFS2_LOCK_PENDING) {
3777 mlog(ML_BASTS, "lockres %s, ReQ: Pending\n",
3778 lockres->l_name);
3783 ret = ocfs2_prepare_cancel_convert(osb, lockres);
3784 spin_unlock_irqrestore(&lockres->l_lock, flags);
3786 ret = ocfs2_cancel_convert(osb, lockres);
3802 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING)
3810 if (lockres->l_level == DLM_LOCK_NL) {
3811 BUG_ON(lockres->l_ex_holders || lockres->l_ro_holders);
3812 mlog(ML_BASTS, "lockres %s, Aborting dc\n", lockres->l_name);
3813 lockres->l_blocking = DLM_LOCK_NL;
3814 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
3815 spin_unlock_irqrestore(&lockres->l_lock, flags);
3821 if ((lockres->l_blocking == DLM_LOCK_EX)
3822 && (lockres->l_ex_holders || lockres->l_ro_holders)) {
3823 mlog(ML_BASTS, "lockres %s, ReQ: EX/PR Holders %u,%u\n",
3824 lockres->l_name, lockres->l_ex_holders,
3825 lockres->l_ro_holders);
3831 if (lockres->l_blocking == DLM_LOCK_PR &&
3832 lockres->l_ex_holders) {
3833 mlog(ML_BASTS, "lockres %s, ReQ: EX Holders %u\n",
3834 lockres->l_name, lockres->l_ex_holders);
3842 if ((lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
3843 && (lockres->l_flags & OCFS2_LOCK_REFRESHING)) {
3844 mlog(ML_BASTS, "lockres %s, ReQ: Lock Refreshing\n",
3845 lockres->l_name);
3849 new_level = ocfs2_highest_compat_lock_level(lockres->l_blocking);
3851 if (lockres->l_ops->check_downconvert
3852 && !lockres->l_ops->check_downconvert(lockres, new_level)) {
3853 mlog(ML_BASTS, "lockres %s, ReQ: Checkpointing\n",
3854 lockres->l_name);
3861 if (!lockres->l_ops->downconvert_worker)
3864 /* Some lockres types want to do a bit of work before
3868 blocking = lockres->l_blocking;
3869 level = lockres->l_level;
3870 spin_unlock_irqrestore(&lockres->l_lock, flags);
3872 ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking);
3875 mlog(ML_BASTS, "lockres %s, UNBLOCK_STOP_POST\n",
3876 lockres->l_name);
3880 spin_lock_irqsave(&lockres->l_lock, flags);
3881 if ((blocking != lockres->l_blocking) || (level != lockres->l_level)) {
3884 mlog(ML_BASTS, "lockres %s, block=%d:%d, level=%d:%d, "
3885 "Recheck\n", lockres->l_name, blocking,
3886 lockres->l_blocking, level, lockres->l_level);
3893 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3894 if (lockres->l_level == DLM_LOCK_EX)
3903 if (set_lvb && !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3904 lockres->l_ops->set_lvb(lockres);
3907 gen = ocfs2_prepare_downconvert(lockres, new_level);
3908 spin_unlock_irqrestore(&lockres->l_lock, flags);
3909 ret = ocfs2_downconvert_lock(osb, lockres, new_level, set_lvb,
3918 spin_unlock_irqrestore(&lockres->l_lock, flags);
3924 static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
3931 inode = ocfs2_lock_res_inode(lockres);
3977 struct ocfs2_lock_res *lockres,
3983 BUG_ON(lockres->l_level != DLM_LOCK_EX && !checkpointed);
3992 static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
3995 struct inode *inode = ocfs2_lock_res_inode(lockres);
3997 return ocfs2_ci_checkpointed(INODE_CACHE(inode), lockres, new_level);
4000 static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres)
4002 struct inode *inode = ocfs2_lock_res_inode(lockres);
4013 struct ocfs2_lock_res *lockres)
4015 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
4038 static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
4041 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
4073 spin_lock_irqsave(&lockres->l_lock, flags);
4075 if (!(lockres->l_flags & OCFS2_LOCK_FREEING)
4081 spin_unlock_irqrestore(&lockres->l_lock, flags);
4131 static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
4135 ocfs2_lock_res_refcount_tree(lockres);
4137 return ocfs2_ci_checkpointed(&tree->rf_ci, lockres, new_level);
4140 static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
4144 ocfs2_lock_res_refcount_tree(lockres);
4151 static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres)
4154 struct ocfs2_mem_dqinfo *oinfo = ocfs2_lock_res_qinfo(lockres);
4158 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
4170 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4175 ocfs2_cluster_unlock(osb, lockres, level);
4182 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4183 struct ocfs2_qinfo_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
4188 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
4214 ocfs2_track_lock_refresh(lockres);
4225 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
4239 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
4244 if (!ocfs2_should_refresh_lock_res(lockres))
4250 ocfs2_complete_lock_res_refresh(lockres, status);
4259 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
4260 struct ocfs2_super *osb = lockres->l_priv;
4269 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
4279 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
4280 struct ocfs2_super *osb = lockres->l_priv;
4283 ocfs2_cluster_unlock(osb, lockres, level);
4287 struct ocfs2_lock_res *lockres)
4293 /* Our reference to the lockres in this function can be
4297 BUG_ON(!lockres);
4298 BUG_ON(!lockres->l_ops);
4300 mlog(ML_BASTS, "lockres %s blocked\n", lockres->l_name);
4307 spin_lock_irqsave(&lockres->l_lock, flags);
4308 if (lockres->l_flags & OCFS2_LOCK_FREEING)
4310 spin_unlock_irqrestore(&lockres->l_lock, flags);
4312 status = ocfs2_unblock_lock(osb, lockres, &ctl);
4316 spin_lock_irqsave(&lockres->l_lock, flags);
4318 if (lockres->l_flags & OCFS2_LOCK_FREEING || !ctl.requeue) {
4319 lockres_clear_flags(lockres, OCFS2_LOCK_QUEUED);
4321 ocfs2_schedule_blocked_lock(osb, lockres);
4323 mlog(ML_BASTS, "lockres %s, requeue = %s.\n", lockres->l_name,
4325 spin_unlock_irqrestore(&lockres->l_lock, flags);
4328 && lockres->l_ops->post_unlock)
4329 lockres->l_ops->post_unlock(osb, lockres);
4333 struct ocfs2_lock_res *lockres)
4337 assert_spin_locked(&lockres->l_lock);
4339 if (lockres->l_flags & OCFS2_LOCK_FREEING) {
4343 mlog(ML_BASTS, "lockres %s won't be scheduled: flags 0x%lx\n",
4344 lockres->l_name, lockres->l_flags);
4348 lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
4351 if (list_empty(&lockres->l_blocked_list)) {
4352 list_add_tail(&lockres->l_blocked_list,
4363 struct ocfs2_lock_res *lockres;
4378 lockres = list_entry(osb->blocked_lock_list.next,
4380 list_del_init(&lockres->l_blocked_list);
4387 ocfs2_process_blocked_lock(osb, lockres);