Lines Matching defs:lockres
71 static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres);
72 static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres);
73 static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres);
74 static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres);
99 static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
101 static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres);
103 static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
106 static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
110 struct ocfs2_lock_res *lockres);
112 static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres);
114 static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
116 static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
125 struct ocfs2_lock_res *lockres)
127 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
130 lockres->l_name, function, line);
169 * successful downconvert. The lockres will not be referenced
186 * Called with the lockres spinlock held.
197 * Called with the lockres spinlock held.
223 * individual lockres l_flags member from the ast function. It is
293 static inline int ocfs2_is_inode_lock(struct ocfs2_lock_res *lockres)
295 return lockres->l_type == OCFS2_LOCK_TYPE_META ||
296 lockres->l_type == OCFS2_LOCK_TYPE_RW ||
297 lockres->l_type == OCFS2_LOCK_TYPE_OPEN;
305 static inline struct inode *ocfs2_lock_res_inode(struct ocfs2_lock_res *lockres)
307 BUG_ON(!ocfs2_is_inode_lock(lockres));
309 return (struct inode *) lockres->l_priv;
312 static inline struct ocfs2_dentry_lock *ocfs2_lock_res_dl(struct ocfs2_lock_res *lockres)
314 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_DENTRY);
316 return (struct ocfs2_dentry_lock *)lockres->l_priv;
319 static inline struct ocfs2_mem_dqinfo *ocfs2_lock_res_qinfo(struct ocfs2_lock_res *lockres)
321 BUG_ON(lockres->l_type != OCFS2_LOCK_TYPE_QINFO);
323 return (struct ocfs2_mem_dqinfo *)lockres->l_priv;
332 static inline struct ocfs2_super *ocfs2_get_lockres_osb(struct ocfs2_lock_res *lockres)
334 if (lockres->l_ops->get_osb)
335 return lockres->l_ops->get_osb(lockres);
337 return (struct ocfs2_super *)lockres->l_priv;
341 struct ocfs2_lock_res *lockres,
344 static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
347 struct ocfs2_lock_res *lockres,
350 struct ocfs2_lock_res *lockres,
353 __ocfs2_cluster_unlock(osb, lockres, level, _RET_IP_);
356 static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres);
357 static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres);
358 static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres);
359 static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres, int level);
361 struct ocfs2_lock_res *lockres);
362 static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
375 struct ocfs2_lock_res *lockres);
380 static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
383 struct ocfs2_lock_res *lockres,
388 struct ocfs2_lock_res *lockres);
390 struct ocfs2_lock_res *lockres);
420 mlog(0, "Add tracking for lockres %s\n", res->l_name);
478 static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
480 lockres->l_lock_refresh++;
496 static inline void ocfs2_track_lock_refresh(struct ocfs2_lock_res *lockres)
572 static struct ocfs2_super *ocfs2_get_inode_osb(struct ocfs2_lock_res *lockres)
574 struct inode *inode = ocfs2_lock_res_inode(lockres);
579 static struct ocfs2_super *ocfs2_get_qinfo_osb(struct ocfs2_lock_res *lockres)
581 struct ocfs2_mem_dqinfo *info = lockres->l_priv;
586 static struct ocfs2_super *ocfs2_get_file_osb(struct ocfs2_lock_res *lockres)
588 struct ocfs2_file_private *fp = lockres->l_priv;
593 static __u64 ocfs2_get_dentry_lock_ino(struct ocfs2_lock_res *lockres)
597 memcpy(&inode_blkno_be, &lockres->l_name[OCFS2_DENTRY_LOCK_INO_START],
603 static struct ocfs2_super *ocfs2_get_dentry_osb(struct ocfs2_lock_res *lockres)
605 struct ocfs2_dentry_lock *dl = lockres->l_priv;
616 struct ocfs2_lock_res *lockres = &dl->dl_lockres;
618 ocfs2_lock_res_init_once(lockres);
635 len = snprintf(lockres->l_name, OCFS2_DENTRY_LOCK_INO_START,
642 memcpy(&lockres->l_name[OCFS2_DENTRY_LOCK_INO_START], &inode_blkno_be,
645 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
653 /* Superblock lockres doesn't come from a slab so we call init
665 /* Rename lockres doesn't come from a slab so we call init
676 /* nfs_sync lockres doesn't come from a slab so we call init
693 void ocfs2_file_lock_res_init(struct ocfs2_lock_res *lockres,
699 ocfs2_lock_res_init_once(lockres);
701 inode->i_generation, lockres->l_name);
702 ocfs2_lock_res_init_common(OCFS2_SB(inode->i_sb), lockres,
705 lockres->l_flags |= OCFS2_LOCK_NOCACHE;
708 void ocfs2_qinfo_lock_res_init(struct ocfs2_lock_res *lockres,
711 ocfs2_lock_res_init_once(lockres);
713 0, lockres->l_name);
714 ocfs2_lock_res_init_common(OCFS2_SB(info->dqi_gi.dqi_sb), lockres,
719 void ocfs2_refcount_lock_res_init(struct ocfs2_lock_res *lockres,
723 ocfs2_lock_res_init_once(lockres);
725 generation, lockres->l_name);
726 ocfs2_lock_res_init_common(osb, lockres, OCFS2_LOCK_TYPE_REFCOUNT,
762 static inline void ocfs2_inc_holders(struct ocfs2_lock_res *lockres,
767 BUG_ON(!lockres);
771 lockres->l_ex_holders++;
774 lockres->l_ro_holders++;
783 static inline void ocfs2_dec_holders(struct ocfs2_lock_res *lockres,
788 BUG_ON(!lockres);
792 BUG_ON(!lockres->l_ex_holders);
793 lockres->l_ex_holders--;
796 BUG_ON(!lockres->l_ro_holders);
797 lockres->l_ro_holders--;
819 static void lockres_set_flags(struct ocfs2_lock_res *lockres,
824 assert_spin_locked(&lockres->l_lock);
826 lockres->l_flags = newflags;
828 list_for_each_entry_safe(mw, tmp, &lockres->l_mask_waiters, mw_item) {
829 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
837 static void lockres_or_flags(struct ocfs2_lock_res *lockres, unsigned long or)
839 lockres_set_flags(lockres, lockres->l_flags | or);
841 static void lockres_clear_flags(struct ocfs2_lock_res *lockres,
844 lockres_set_flags(lockres, lockres->l_flags & ~clear);
847 static inline void ocfs2_generic_handle_downconvert_action(struct ocfs2_lock_res *lockres)
851 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
852 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
853 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
854 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
856 lockres->l_level = lockres->l_requested;
857 if (lockres->l_level <=
858 ocfs2_highest_compat_lock_level(lockres->l_blocking)) {
859 lockres->l_blocking = DLM_LOCK_NL;
860 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
862 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
867 static inline void ocfs2_generic_handle_convert_action(struct ocfs2_lock_res *lockres)
871 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
872 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_ATTACHED));
878 if (lockres->l_level == DLM_LOCK_NL &&
879 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
880 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
882 lockres->l_level = lockres->l_requested;
889 lockres_or_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
891 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
896 static inline void ocfs2_generic_handle_attach_action(struct ocfs2_lock_res *lockres)
900 BUG_ON((!(lockres->l_flags & OCFS2_LOCK_BUSY)));
901 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
903 if (lockres->l_requested > DLM_LOCK_NL &&
904 !(lockres->l_flags & OCFS2_LOCK_LOCAL) &&
905 lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
906 lockres_or_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
908 lockres->l_level = lockres->l_requested;
909 lockres_or_flags(lockres, OCFS2_LOCK_ATTACHED);
910 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
915 static int ocfs2_generic_handle_bast(struct ocfs2_lock_res *lockres,
921 assert_spin_locked(&lockres->l_lock);
923 if (level > lockres->l_blocking) {
929 ocfs2_highest_compat_lock_level(lockres->l_blocking))
932 lockres->l_blocking = level;
935 mlog(ML_BASTS, "lockres %s, block %d, level %d, l_block %d, dwn %d\n",
936 lockres->l_name, level, lockres->l_level, lockres->l_blocking,
940 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
996 * number that matches the lockres. lockres_set_pending() will return the
1005 static void __lockres_clear_pending(struct ocfs2_lock_res *lockres,
1009 assert_spin_locked(&lockres->l_lock);
1015 if (!(lockres->l_flags & OCFS2_LOCK_PENDING) ||
1016 (lockres->l_pending_gen != generation))
1019 lockres_clear_flags(lockres, OCFS2_LOCK_PENDING);
1020 lockres->l_pending_gen++;
1026 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1031 static void lockres_clear_pending(struct ocfs2_lock_res *lockres,
1037 spin_lock_irqsave(&lockres->l_lock, flags);
1038 __lockres_clear_pending(lockres, generation, osb);
1039 spin_unlock_irqrestore(&lockres->l_lock, flags);
1042 static unsigned int lockres_set_pending(struct ocfs2_lock_res *lockres)
1044 assert_spin_locked(&lockres->l_lock);
1045 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BUSY));
1047 lockres_or_flags(lockres, OCFS2_LOCK_PENDING);
1049 return lockres->l_pending_gen;
1054 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1055 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1061 mlog(ML_BASTS, "BAST fired for lockres %s, blocking %d, level %d, "
1062 "type %s\n", lockres->l_name, level, lockres->l_level,
1063 ocfs2_lock_type_string(lockres->l_type));
1069 if (lockres->l_flags & OCFS2_LOCK_NOCACHE)
1072 spin_lock_irqsave(&lockres->l_lock, flags);
1073 needs_downconvert = ocfs2_generic_handle_bast(lockres, level);
1075 ocfs2_schedule_blocked_lock(osb, lockres);
1076 spin_unlock_irqrestore(&lockres->l_lock, flags);
1078 wake_up(&lockres->l_event);
1085 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1086 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1090 spin_lock_irqsave(&lockres->l_lock, flags);
1092 status = ocfs2_dlm_lock_status(&lockres->l_lksb);
1095 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1100 mlog(ML_ERROR, "lockres %s: lksb status value of %d!\n",
1101 lockres->l_name, status);
1102 spin_unlock_irqrestore(&lockres->l_lock, flags);
1106 mlog(ML_BASTS, "AST fired for lockres %s, action %d, unlock %d, "
1107 "level %d => %d\n", lockres->l_name, lockres->l_action,
1108 lockres->l_unlock_action, lockres->l_level, lockres->l_requested);
1110 switch(lockres->l_action) {
1112 ocfs2_generic_handle_attach_action(lockres);
1113 lockres_clear_flags(lockres, OCFS2_LOCK_LOCAL);
1116 ocfs2_generic_handle_convert_action(lockres);
1119 ocfs2_generic_handle_downconvert_action(lockres);
1122 mlog(ML_ERROR, "lockres %s: AST fired with invalid action: %u, "
1124 lockres->l_name, lockres->l_action, lockres->l_flags,
1125 lockres->l_unlock_action);
1131 lockres->l_action = OCFS2_AST_INVALID;
1134 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT)
1135 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1141 * can use lockres->l_pending_gen.
1143 __lockres_clear_pending(lockres, lockres->l_pending_gen, osb);
1145 wake_up(&lockres->l_event);
1146 spin_unlock_irqrestore(&lockres->l_lock, flags);
1151 struct ocfs2_lock_res *lockres = ocfs2_lksb_to_lock_res(lksb);
1156 mlog(ML_BASTS, "UNLOCK AST fired for lockres %s, action = %d\n",
1157 lockres->l_name, lockres->l_unlock_action);
1159 spin_lock_irqsave(&lockres->l_lock, flags);
1162 "unlock_action %d\n", error, lockres->l_name,
1163 lockres->l_unlock_action);
1164 spin_unlock_irqrestore(&lockres->l_lock, flags);
1169 switch(lockres->l_unlock_action) {
1171 mlog(0, "Cancel convert success for %s\n", lockres->l_name);
1172 lockres->l_action = OCFS2_AST_INVALID;
1175 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
1176 ocfs2_wake_downconvert_thread(ocfs2_get_lockres_osb(lockres));
1179 lockres->l_level = DLM_LOCK_IV;
1185 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1186 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1187 wake_up(&lockres->l_event);
1188 spin_unlock_irqrestore(&lockres->l_lock, flags);
1231 static inline void ocfs2_recover_from_dlm_error(struct ocfs2_lock_res *lockres,
1237 spin_lock_irqsave(&lockres->l_lock, flags);
1238 lockres_clear_flags(lockres, OCFS2_LOCK_BUSY);
1239 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1241 lockres->l_action = OCFS2_AST_INVALID;
1243 lockres->l_unlock_action = OCFS2_UNLOCK_INVALID;
1244 spin_unlock_irqrestore(&lockres->l_lock, flags);
1246 wake_up(&lockres->l_event);
1255 struct ocfs2_lock_res *lockres,
1265 mlog(0, "lock %s, level = %d, flags = %u\n", lockres->l_name, level,
1268 spin_lock_irqsave(&lockres->l_lock, flags);
1269 if ((lockres->l_flags & OCFS2_LOCK_ATTACHED) ||
1270 (lockres->l_flags & OCFS2_LOCK_BUSY)) {
1271 spin_unlock_irqrestore(&lockres->l_lock, flags);
1275 lockres->l_action = OCFS2_AST_ATTACH;
1276 lockres->l_requested = level;
1277 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1278 gen = lockres_set_pending(lockres);
1279 spin_unlock_irqrestore(&lockres->l_lock, flags);
1283 &lockres->l_lksb,
1285 lockres->l_name,
1287 lockres_clear_pending(lockres, gen, osb);
1289 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
1290 ocfs2_recover_from_dlm_error(lockres, 1);
1293 mlog(0, "lock %s, return from ocfs2_dlm_lock\n", lockres->l_name);
1300 static inline int ocfs2_check_wait_flag(struct ocfs2_lock_res *lockres,
1306 spin_lock_irqsave(&lockres->l_lock, flags);
1307 ret = lockres->l_flags & flag;
1308 spin_unlock_irqrestore(&lockres->l_lock, flags);
1313 static inline void ocfs2_wait_on_busy_lock(struct ocfs2_lock_res *lockres)
1316 wait_event(lockres->l_event,
1317 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_BUSY));
1320 static inline void ocfs2_wait_on_refreshing_lock(struct ocfs2_lock_res *lockres)
1323 wait_event(lockres->l_event,
1324 !ocfs2_check_wait_flag(lockres, OCFS2_LOCK_REFRESHING));
1330 static inline int ocfs2_may_continue_on_blocked_lock(struct ocfs2_lock_res *lockres,
1333 BUG_ON(!(lockres->l_flags & OCFS2_LOCK_BLOCKED));
1335 return wanted <= ocfs2_highest_compat_lock_level(lockres->l_blocking);
1353 static void lockres_add_mask_waiter(struct ocfs2_lock_res *lockres,
1360 assert_spin_locked(&lockres->l_lock);
1362 list_add_tail(&mw->mw_item, &lockres->l_mask_waiters);
1369 static int lockres_remove_mask_waiter(struct ocfs2_lock_res *lockres,
1375 spin_lock_irqsave(&lockres->l_lock, flags);
1377 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
1383 spin_unlock_irqrestore(&lockres->l_lock, flags);
1390 struct ocfs2_lock_res *lockres)
1396 lockres_remove_mask_waiter(lockres, mw);
1405 struct ocfs2_lock_res *lockres,
1423 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
1429 spin_lock_irqsave(&lockres->l_lock, flags);
1436 mlog_bug_on_msg(lockres->l_flags & OCFS2_LOCK_FREEING,
1437 "Cluster lock called on freeing lockres %s! flags "
1438 "0x%lx\n", lockres->l_name, lockres->l_flags);
1443 if (lockres->l_flags & OCFS2_LOCK_BUSY &&
1444 level > lockres->l_level) {
1447 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1452 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) {
1467 if (level <= lockres->l_level)
1471 if (lockres->l_flags & OCFS2_LOCK_BLOCKED &&
1472 !ocfs2_may_continue_on_blocked_lock(lockres, level)) {
1475 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BLOCKED, 0);
1480 if (level > lockres->l_level) {
1488 if (lockres->l_action != OCFS2_AST_INVALID)
1489 mlog(ML_ERROR, "lockres %s has action %u pending\n",
1490 lockres->l_name, lockres->l_action);
1492 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1493 lockres->l_action = OCFS2_AST_ATTACH;
1496 lockres->l_action = OCFS2_AST_CONVERT;
1500 lockres->l_requested = level;
1501 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1502 gen = lockres_set_pending(lockres);
1503 spin_unlock_irqrestore(&lockres->l_lock, flags);
1508 mlog(ML_BASTS, "lockres %s, convert from %d to %d\n",
1509 lockres->l_name, lockres->l_level, level);
1514 &lockres->l_lksb,
1516 lockres->l_name,
1518 lockres_clear_pending(lockres, gen, osb);
1523 ret, lockres);
1525 ocfs2_recover_from_dlm_error(lockres, 1);
1530 lockres->l_name);
1542 ocfs2_inc_holders(lockres, level);
1546 lockres_clear_flags(lockres, OCFS2_LOCK_UPCONVERT_FINISHING);
1548 spin_unlock_irqrestore(&lockres->l_lock, flags);
1553 if (lockres_remove_mask_waiter(lockres, &mw))
1564 ocfs2_update_lock_stats(lockres, level, &mw, ret);
1567 if (!ret && lockres->l_lockdep_map.key != NULL) {
1569 rwsem_acquire_read(&lockres->l_lockdep_map, l_subclass,
1573 rwsem_acquire(&lockres->l_lockdep_map, l_subclass,
1583 struct ocfs2_lock_res *lockres,
1588 return __ocfs2_cluster_lock(osb, lockres, level, lkm_flags, arg_flags,
1594 struct ocfs2_lock_res *lockres,
1601 spin_lock_irqsave(&lockres->l_lock, flags);
1602 ocfs2_dec_holders(lockres, level);
1603 ocfs2_downconvert_on_unlock(osb, lockres);
1604 spin_unlock_irqrestore(&lockres->l_lock, flags);
1606 if (lockres->l_lockdep_map.key != NULL)
1607 rwsem_release(&lockres->l_lockdep_map, 1, caller_ip);
1613 struct ocfs2_lock_res *lockres,
1621 spin_lock_irqsave(&lockres->l_lock, flags);
1622 BUG_ON(lockres->l_flags & OCFS2_LOCK_ATTACHED);
1623 lockres_or_flags(lockres, OCFS2_LOCK_LOCAL);
1624 spin_unlock_irqrestore(&lockres->l_lock, flags);
1626 return ocfs2_lock_create(osb, lockres, level, lkm_flags);
1685 struct ocfs2_lock_res *lockres;
1701 lockres = &OCFS2_I(inode)->ip_rw_lockres;
1705 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres, level, 0,
1717 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_rw_lockres;
1727 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
1738 struct ocfs2_lock_res *lockres;
1751 lockres = &OCFS2_I(inode)->ip_open_lockres;
1753 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres,
1766 struct ocfs2_lock_res *lockres;
1780 lockres = &OCFS2_I(inode)->ip_open_lockres;
1790 status = ocfs2_cluster_lock(OCFS2_SB(inode->i_sb), lockres,
1803 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_open_lockres;
1814 if(lockres->l_ro_holders)
1815 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres,
1817 if(lockres->l_ex_holders)
1818 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres,
1825 static int ocfs2_flock_handle_signal(struct ocfs2_lock_res *lockres,
1829 struct ocfs2_super *osb = ocfs2_get_lockres_osb(lockres);
1836 spin_lock_irqsave(&lockres->l_lock, flags);
1837 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
1838 ret = ocfs2_prepare_cancel_convert(osb, lockres);
1840 spin_unlock_irqrestore(&lockres->l_lock, flags);
1841 ret = ocfs2_cancel_convert(osb, lockres);
1848 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1849 spin_unlock_irqrestore(&lockres->l_lock, flags);
1860 if (lockres->l_level == level)
1864 lockres->l_flags, lockres->l_level, lockres->l_action);
1866 spin_unlock_irqrestore(&lockres->l_lock, flags);
1889 * - Access to any flock lockres doesn't require concurrency, so we
1899 struct ocfs2_lock_res *lockres = &fp->fp_flock;
1905 if ((lockres->l_flags & OCFS2_LOCK_BUSY) ||
1906 (lockres->l_level > DLM_LOCK_NL)) {
1909 "level: %u\n", lockres->l_name, lockres->l_flags,
1910 lockres->l_level);
1914 spin_lock_irqsave(&lockres->l_lock, flags);
1915 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
1916 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1917 spin_unlock_irqrestore(&lockres->l_lock, flags);
1923 ret = ocfs2_lock_create(osb, lockres, DLM_LOCK_NL, 0);
1934 spin_lock_irqsave(&lockres->l_lock, flags);
1937 lockres->l_action = OCFS2_AST_CONVERT;
1939 lockres->l_requested = level;
1940 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
1942 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
1943 spin_unlock_irqrestore(&lockres->l_lock, flags);
1945 ret = ocfs2_dlm_lock(osb->cconn, level, &lockres->l_lksb, lkm_flags,
1946 lockres->l_name, OCFS2_LOCK_ID_MAX_LEN - 1);
1949 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
1953 ocfs2_recover_from_dlm_error(lockres, 1);
1954 lockres_remove_mask_waiter(lockres, &mw);
1958 ret = ocfs2_wait_for_mask_interruptible(&mw, lockres);
1975 ret = ocfs2_flock_handle_signal(lockres, level);
1976 } else if (!ret && (level > lockres->l_level)) {
1985 lockres->l_name, ex, trylock, ret);
1995 struct ocfs2_lock_res *lockres = &fp->fp_flock;
2001 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED))
2004 if (lockres->l_level == DLM_LOCK_NL)
2008 lockres->l_name, lockres->l_flags, lockres->l_level,
2009 lockres->l_action);
2011 spin_lock_irqsave(&lockres->l_lock, flags);
2015 lockres_or_flags(lockres, OCFS2_LOCK_BLOCKED);
2016 lockres->l_blocking = DLM_LOCK_EX;
2018 gen = ocfs2_prepare_downconvert(lockres, DLM_LOCK_NL);
2019 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_BUSY, 0);
2020 spin_unlock_irqrestore(&lockres->l_lock, flags);
2022 ret = ocfs2_downconvert_lock(osb, lockres, DLM_LOCK_NL, 0, gen);
2034 struct ocfs2_lock_res *lockres)
2043 if (lockres->l_flags & OCFS2_LOCK_BLOCKED) {
2044 switch(lockres->l_blocking) {
2046 if (!lockres->l_ex_holders && !lockres->l_ro_holders)
2050 if (!lockres->l_ex_holders)
2081 /* Call this with the lockres locked. I am reasonably sure we don't
2087 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2092 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2122 mlog_meta_lvb(0, lockres);
2137 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2142 mlog_meta_lvb(0, lockres);
2144 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2146 /* We're safe here without the lockres lock... */
2177 struct ocfs2_lock_res *lockres)
2179 struct ocfs2_meta_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2181 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb)
2195 static int ocfs2_should_refresh_lock_res(struct ocfs2_lock_res *lockres)
2203 spin_lock_irqsave(&lockres->l_lock, flags);
2204 if (!(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH)) {
2205 spin_unlock_irqrestore(&lockres->l_lock, flags);
2209 if (lockres->l_flags & OCFS2_LOCK_REFRESHING) {
2210 spin_unlock_irqrestore(&lockres->l_lock, flags);
2212 ocfs2_wait_on_refreshing_lock(lockres);
2217 lockres_or_flags(lockres, OCFS2_LOCK_REFRESHING);
2218 spin_unlock_irqrestore(&lockres->l_lock, flags);
2228 static inline void ocfs2_complete_lock_res_refresh(struct ocfs2_lock_res *lockres,
2234 spin_lock_irqsave(&lockres->l_lock, flags);
2235 lockres_clear_flags(lockres, OCFS2_LOCK_REFRESHING);
2237 lockres_clear_flags(lockres, OCFS2_LOCK_NEEDS_REFRESH);
2238 spin_unlock_irqrestore(&lockres->l_lock, flags);
2240 wake_up(&lockres->l_event);
2251 struct ocfs2_lock_res *lockres = &oi->ip_inode_lockres;
2271 if (!ocfs2_should_refresh_lock_res(lockres))
2280 if (ocfs2_meta_lvb_is_trustable(inode, lockres)) {
2318 ocfs2_track_lock_refresh(lockres);
2323 ocfs2_complete_lock_res_refresh(lockres, status);
2363 struct ocfs2_lock_res *lockres = NULL;
2391 lockres = &OCFS2_I(inode)->ip_inode_lockres;
2397 status = __ocfs2_cluster_lock(osb, lockres, level, dlm_flags,
2424 if (lockres)
2425 ocfs2_complete_lock_res_refresh(lockres, 0);
2548 struct ocfs2_lock_res *lockres = &OCFS2_I(inode)->ip_inode_lockres;
2559 ocfs2_cluster_unlock(OCFS2_SB(inode->i_sb), lockres, level);
2566 struct ocfs2_lock_res *lockres;
2576 lockres = &osb->osb_orphan_scan.os_lockres;
2577 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2581 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2582 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
2593 struct ocfs2_lock_res *lockres;
2597 lockres = &osb->osb_orphan_scan.os_lockres;
2598 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2601 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2610 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2620 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
2630 status = ocfs2_should_refresh_lock_res(lockres);
2638 ocfs2_complete_lock_res_refresh(lockres, status);
2642 ocfs2_track_lock_refresh(lockres);
2653 struct ocfs2_lock_res *lockres = &osb->osb_super_lockres;
2656 ocfs2_cluster_unlock(osb, lockres, level);
2662 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2670 status = ocfs2_cluster_lock(osb, lockres, DLM_LOCK_EX, 0, 0);
2679 struct ocfs2_lock_res *lockres = &osb->osb_rename_lockres;
2682 ocfs2_cluster_unlock(osb, lockres, DLM_LOCK_EX);
2688 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2696 status = ocfs2_cluster_lock(osb, lockres, ex ? LKM_EXMODE : LKM_PRMODE,
2706 struct ocfs2_lock_res *lockres = &osb->osb_nfs_sync_lockres;
2709 ocfs2_cluster_unlock(osb, lockres,
2807 /* We track our "dummy" iteration lockres' by a NULL
2826 /* Since lockres' have the lifetime of their container
2828 * copy this out to a temporary lockres while still
2870 struct ocfs2_lock_res *lockres = v;
2872 if (!lockres)
2877 if (lockres->l_type == OCFS2_LOCK_TYPE_DENTRY)
2879 lockres->l_name,
2880 (unsigned int)ocfs2_get_dentry_lock_ino(lockres));
2882 seq_printf(m, "%.*s\t", OCFS2_LOCK_ID_MAX_LEN, lockres->l_name);
2892 lockres->l_level,
2893 lockres->l_flags,
2894 lockres->l_action,
2895 lockres->l_unlock_action,
2896 lockres->l_ro_holders,
2897 lockres->l_ex_holders,
2898 lockres->l_requested,
2899 lockres->l_blocking);
2902 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
2937 lock_num_prmode(lockres),
2938 lock_num_exmode(lockres),
2939 lock_num_prmode_failed(lockres),
2940 lock_num_exmode_failed(lockres),
2941 lock_total_prmode(lockres),
2942 lock_total_exmode(lockres),
2943 lock_max_prmode(lockres),
2944 lock_max_exmode(lockres),
2945 lock_refresh(lockres));
3143 struct ocfs2_lock_res *lockres)
3149 /* We didn't get anywhere near actually using this lockres. */
3150 if (!(lockres->l_flags & OCFS2_LOCK_INITIALIZED))
3153 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB)
3156 spin_lock_irqsave(&lockres->l_lock, flags);
3158 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_FREEING),
3159 "lockres %s, flags 0x%lx\n",
3160 lockres->l_name, lockres->l_flags);
3162 while (lockres->l_flags & OCFS2_LOCK_BUSY) {
3165 lockres->l_name, lockres->l_flags, lockres->l_action,
3166 lockres->l_unlock_action);
3168 spin_unlock_irqrestore(&lockres->l_lock, flags);
3170 ocfs2_wait_on_busy_lock(lockres);
3172 spin_lock_irqsave(&lockres->l_lock, flags);
3175 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3176 if (lockres->l_flags & OCFS2_LOCK_ATTACHED &&
3177 lockres->l_level == DLM_LOCK_EX &&
3178 !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3179 lockres->l_ops->set_lvb(lockres);
3182 if (lockres->l_flags & OCFS2_LOCK_BUSY)
3184 lockres->l_name);
3185 if (lockres->l_flags & OCFS2_LOCK_BLOCKED)
3186 mlog(0, "destroying blocked lock: \"%s\"\n", lockres->l_name);
3188 if (!(lockres->l_flags & OCFS2_LOCK_ATTACHED)) {
3189 spin_unlock_irqrestore(&lockres->l_lock, flags);
3193 lockres_clear_flags(lockres, OCFS2_LOCK_ATTACHED);
3197 BUG_ON(lockres->l_action != OCFS2_AST_INVALID);
3200 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3201 lockres->l_unlock_action = OCFS2_UNLOCK_DROP_LOCK;
3202 spin_unlock_irqrestore(&lockres->l_lock, flags);
3204 mlog(0, "lock %s\n", lockres->l_name);
3206 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb, lkm_flags);
3208 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3209 mlog(ML_ERROR, "lockres flags: %lu\n", lockres->l_flags);
3210 ocfs2_dlm_dump_lksb(&lockres->l_lksb);
3214 lockres->l_name);
3216 ocfs2_wait_on_busy_lock(lockres);
3222 /* Mark the lockres as being dropped. It will no longer be
3227 * You can *not* attempt to call cluster_lock on this lockres anymore. */
3228 void ocfs2_mark_lockres_freeing(struct ocfs2_lock_res *lockres)
3236 spin_lock_irqsave(&lockres->l_lock, flags);
3237 lockres->l_flags |= OCFS2_LOCK_FREEING;
3238 while (lockres->l_flags & OCFS2_LOCK_QUEUED) {
3239 lockres_add_mask_waiter(lockres, &mw, OCFS2_LOCK_QUEUED, 0);
3240 spin_unlock_irqrestore(&lockres->l_lock, flags);
3242 mlog(0, "Waiting on lockres %s\n", lockres->l_name);
3248 spin_lock_irqsave(&lockres->l_lock, flags);
3250 spin_unlock_irqrestore(&lockres->l_lock, flags);
3254 struct ocfs2_lock_res *lockres)
3258 ocfs2_mark_lockres_freeing(lockres);
3259 ret = ocfs2_drop_lock(osb, lockres);
3306 static unsigned int ocfs2_prepare_downconvert(struct ocfs2_lock_res *lockres,
3309 assert_spin_locked(&lockres->l_lock);
3311 BUG_ON(lockres->l_blocking <= DLM_LOCK_NL);
3313 if (lockres->l_level <= new_level) {
3314 mlog(ML_ERROR, "lockres %s, lvl %d <= %d, blcklst %d, mask %d, "
3316 "block %d, pgen %d\n", lockres->l_name, lockres->l_level,
3317 new_level, list_empty(&lockres->l_blocked_list),
3318 list_empty(&lockres->l_mask_waiters), lockres->l_type,
3319 lockres->l_flags, lockres->l_ro_holders,
3320 lockres->l_ex_holders, lockres->l_action,
3321 lockres->l_unlock_action, lockres->l_requested,
3322 lockres->l_blocking, lockres->l_pending_gen);
3326 mlog(ML_BASTS, "lockres %s, level %d => %d, blocking %d\n",
3327 lockres->l_name, lockres->l_level, new_level, lockres->l_blocking);
3329 lockres->l_action = OCFS2_AST_DOWNCONVERT;
3330 lockres->l_requested = new_level;
3331 lockres_or_flags(lockres, OCFS2_LOCK_BUSY);
3332 return lockres_set_pending(lockres);
3336 struct ocfs2_lock_res *lockres,
3346 mlog(ML_BASTS, "lockres %s, level %d => %d\n", lockres->l_name,
3347 lockres->l_level, new_level);
3354 &lockres->l_lksb,
3356 lockres->l_name,
3358 lockres_clear_pending(lockres, generation, osb);
3360 ocfs2_log_dlm_error("ocfs2_dlm_lock", ret, lockres);
3361 ocfs2_recover_from_dlm_error(lockres, 1);
3373 struct ocfs2_lock_res *lockres)
3375 assert_spin_locked(&lockres->l_lock);
3379 if (lockres->l_unlock_action == OCFS2_UNLOCK_CANCEL_CONVERT) {
3383 mlog(ML_BASTS, "lockres %s, skip convert\n", lockres->l_name);
3388 BUG_ON(lockres->l_action != OCFS2_AST_CONVERT &&
3389 lockres->l_action != OCFS2_AST_DOWNCONVERT);
3392 lockres->l_unlock_action = OCFS2_UNLOCK_CANCEL_CONVERT;
3394 mlog_bug_on_msg(!(lockres->l_flags & OCFS2_LOCK_BUSY),
3396 lockres->l_name, lockres->l_flags);
3398 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3404 struct ocfs2_lock_res *lockres)
3410 ret = ocfs2_dlm_unlock(osb->cconn, &lockres->l_lksb,
3413 ocfs2_log_dlm_error("ocfs2_dlm_unlock", ret, lockres);
3414 ocfs2_recover_from_dlm_error(lockres, 0);
3417 mlog(ML_BASTS, "lockres %s\n", lockres->l_name);
3424 struct ocfs2_lock_res *lockres,
3437 spin_lock_irqsave(&lockres->l_lock, flags);
3443 if (!(lockres->l_flags & OCFS2_LOCK_BLOCKED)) {
3444 BUG_ON(lockres->l_blocking != DLM_LOCK_NL);
3445 spin_unlock_irqrestore(&lockres->l_lock, flags);
3450 if (lockres->l_flags & OCFS2_LOCK_BUSY) {
3451 if (lockres->l_flags & OCFS2_LOCK_PENDING) {
3452 mlog(ML_BASTS, "lockres %s, ReQ: Pending\n",
3453 lockres->l_name);
3458 ret = ocfs2_prepare_cancel_convert(osb, lockres);
3459 spin_unlock_irqrestore(&lockres->l_lock, flags);
3461 ret = ocfs2_cancel_convert(osb, lockres);
3477 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING)
3485 if (lockres->l_level == DLM_LOCK_NL) {
3486 BUG_ON(lockres->l_ex_holders || lockres->l_ro_holders);
3487 mlog(ML_BASTS, "lockres %s, Aborting dc\n", lockres->l_name);
3488 lockres->l_blocking = DLM_LOCK_NL;
3489 lockres_clear_flags(lockres, OCFS2_LOCK_BLOCKED);
3490 spin_unlock_irqrestore(&lockres->l_lock, flags);
3496 if ((lockres->l_blocking == DLM_LOCK_EX)
3497 && (lockres->l_ex_holders || lockres->l_ro_holders)) {
3498 mlog(ML_BASTS, "lockres %s, ReQ: EX/PR Holders %u,%u\n",
3499 lockres->l_name, lockres->l_ex_holders,
3500 lockres->l_ro_holders);
3506 if (lockres->l_blocking == DLM_LOCK_PR &&
3507 lockres->l_ex_holders) {
3508 mlog(ML_BASTS, "lockres %s, ReQ: EX Holders %u\n",
3509 lockres->l_name, lockres->l_ex_holders);
3517 if ((lockres->l_ops->flags & LOCK_TYPE_REQUIRES_REFRESH)
3518 && (lockres->l_flags & OCFS2_LOCK_REFRESHING)) {
3519 mlog(ML_BASTS, "lockres %s, ReQ: Lock Refreshing\n",
3520 lockres->l_name);
3524 new_level = ocfs2_highest_compat_lock_level(lockres->l_blocking);
3526 if (lockres->l_ops->check_downconvert
3527 && !lockres->l_ops->check_downconvert(lockres, new_level)) {
3528 mlog(ML_BASTS, "lockres %s, ReQ: Checkpointing\n",
3529 lockres->l_name);
3536 if (!lockres->l_ops->downconvert_worker)
3539 /* Some lockres types want to do a bit of work before
3543 blocking = lockres->l_blocking;
3544 level = lockres->l_level;
3545 spin_unlock_irqrestore(&lockres->l_lock, flags);
3547 ctl->unblock_action = lockres->l_ops->downconvert_worker(lockres, blocking);
3550 mlog(ML_BASTS, "lockres %s, UNBLOCK_STOP_POST\n",
3551 lockres->l_name);
3555 spin_lock_irqsave(&lockres->l_lock, flags);
3556 if ((blocking != lockres->l_blocking) || (level != lockres->l_level)) {
3559 mlog(ML_BASTS, "lockres %s, block=%d:%d, level=%d:%d, "
3560 "Recheck\n", lockres->l_name, blocking,
3561 lockres->l_blocking, level, lockres->l_level);
3568 if (lockres->l_ops->flags & LOCK_TYPE_USES_LVB) {
3569 if (lockres->l_level == DLM_LOCK_EX)
3578 if (set_lvb && !(lockres->l_flags & OCFS2_LOCK_NEEDS_REFRESH))
3579 lockres->l_ops->set_lvb(lockres);
3582 gen = ocfs2_prepare_downconvert(lockres, new_level);
3583 spin_unlock_irqrestore(&lockres->l_lock, flags);
3584 ret = ocfs2_downconvert_lock(osb, lockres, new_level, set_lvb,
3592 spin_unlock_irqrestore(&lockres->l_lock, flags);
3599 static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
3605 inode = ocfs2_lock_res_inode(lockres);
3641 struct ocfs2_lock_res *lockres,
3647 BUG_ON(lockres->l_level != DLM_LOCK_EX && !checkpointed);
3656 static int ocfs2_check_meta_downconvert(struct ocfs2_lock_res *lockres,
3659 struct inode *inode = ocfs2_lock_res_inode(lockres);
3661 return ocfs2_ci_checkpointed(INODE_CACHE(inode), lockres, new_level);
3664 static void ocfs2_set_meta_lvb(struct ocfs2_lock_res *lockres)
3666 struct inode *inode = ocfs2_lock_res_inode(lockres);
3677 struct ocfs2_lock_res *lockres)
3679 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
3702 static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
3705 struct ocfs2_dentry_lock *dl = ocfs2_lock_res_dl(lockres);
3737 spin_lock_irqsave(&lockres->l_lock, flags);
3739 if (!(lockres->l_flags & OCFS2_LOCK_FREEING)
3745 spin_unlock_irqrestore(&lockres->l_lock, flags);
3793 static int ocfs2_check_refcount_downconvert(struct ocfs2_lock_res *lockres,
3797 ocfs2_lock_res_refcount_tree(lockres);
3799 return ocfs2_ci_checkpointed(&tree->rf_ci, lockres, new_level);
3802 static int ocfs2_refcount_convert_worker(struct ocfs2_lock_res *lockres,
3806 ocfs2_lock_res_refcount_tree(lockres);
3813 static void ocfs2_set_qinfo_lvb(struct ocfs2_lock_res *lockres)
3816 struct ocfs2_mem_dqinfo *oinfo = ocfs2_lock_res_qinfo(lockres);
3822 lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
3836 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
3842 ocfs2_cluster_unlock(osb, lockres, level);
3850 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
3851 struct ocfs2_qinfo_lvb *lvb = ocfs2_dlm_lvb(&lockres->l_lksb);
3856 if (ocfs2_dlm_lvb_valid(&lockres->l_lksb) &&
3882 ocfs2_track_lock_refresh(lockres);
3893 struct ocfs2_lock_res *lockres = &oinfo->dqi_gqlock;
3909 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
3914 if (!ocfs2_should_refresh_lock_res(lockres))
3920 ocfs2_complete_lock_res_refresh(lockres, status);
3930 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
3931 struct ocfs2_super *osb = lockres->l_priv;
3940 status = ocfs2_cluster_lock(osb, lockres, level, 0, 0);
3950 struct ocfs2_lock_res *lockres = &ref_tree->rf_lockres;
3951 struct ocfs2_super *osb = lockres->l_priv;
3954 ocfs2_cluster_unlock(osb, lockres, level);
3958 struct ocfs2_lock_res *lockres)
3964 /* Our reference to the lockres in this function can be
3970 BUG_ON(!lockres);
3971 BUG_ON(!lockres->l_ops);
3973 mlog(ML_BASTS, "lockres %s blocked\n", lockres->l_name);
3980 spin_lock_irqsave(&lockres->l_lock, flags);
3981 if (lockres->l_flags & OCFS2_LOCK_FREEING)
3983 spin_unlock_irqrestore(&lockres->l_lock, flags);
3985 status = ocfs2_unblock_lock(osb, lockres, &ctl);
3989 spin_lock_irqsave(&lockres->l_lock, flags);
3991 if (lockres->l_flags & OCFS2_LOCK_FREEING || !ctl.requeue) {
3992 lockres_clear_flags(lockres, OCFS2_LOCK_QUEUED);
3994 ocfs2_schedule_blocked_lock(osb, lockres);
3996 mlog(ML_BASTS, "lockres %s, requeue = %s.\n", lockres->l_name,
3998 spin_unlock_irqrestore(&lockres->l_lock, flags);
4001 && lockres->l_ops->post_unlock)
4002 lockres->l_ops->post_unlock(osb, lockres);
4008 struct ocfs2_lock_res *lockres)
4012 assert_spin_locked(&lockres->l_lock);
4014 if (lockres->l_flags & OCFS2_LOCK_FREEING) {
4018 mlog(ML_BASTS, "lockres %s won't be scheduled: flags 0x%lx\n",
4019 lockres->l_name, lockres->l_flags);
4023 lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
4026 if (list_empty(&lockres->l_blocked_list)) {
4027 list_add_tail(&lockres->l_blocked_list,
4039 struct ocfs2_lock_res *lockres;
4052 lockres = list_entry(osb->blocked_lock_list.next,
4054 list_del_init(&lockres->l_blocked_list);
4061 ocfs2_process_blocked_lock(osb, lockres);