locking-selftest.c 52 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * lib/locking-selftest.c
  4. *
  5. * Testsuite for various locking APIs: spinlocks, rwlocks,
  6. * mutexes and rw-semaphores.
  7. *
  8. * It is checking both false positives and false negatives.
  9. *
  10. * Started by Ingo Molnar:
  11. *
  12. * Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  13. */
  14. #include <linux/rwsem.h>
  15. #include <linux/mutex.h>
  16. #include <linux/ww_mutex.h>
  17. #include <linux/sched.h>
  18. #include <linux/delay.h>
  19. #include <linux/lockdep.h>
  20. #include <linux/spinlock.h>
  21. #include <linux/kallsyms.h>
  22. #include <linux/interrupt.h>
  23. #include <linux/debug_locks.h>
  24. #include <linux/irqflags.h>
  25. #include <linux/rtmutex.h>
  26. /*
  27. * Change this to 1 if you want to see the failure printouts:
  28. */
  29. static unsigned int debug_locks_verbose;
  30. unsigned int force_read_lock_recursive;
  31. static DEFINE_WD_CLASS(ww_lockdep);
  32. static int __init setup_debug_locks_verbose(char *str)
  33. {
  34. get_option(&str, &debug_locks_verbose);
  35. return 1;
  36. }
  37. __setup("debug_locks_verbose=", setup_debug_locks_verbose);
  38. #define FAILURE 0
  39. #define SUCCESS 1
  40. #define LOCKTYPE_SPIN 0x1
  41. #define LOCKTYPE_RWLOCK 0x2
  42. #define LOCKTYPE_MUTEX 0x4
  43. #define LOCKTYPE_RWSEM 0x8
  44. #define LOCKTYPE_WW 0x10
  45. #define LOCKTYPE_RTMUTEX 0x20
  46. static struct ww_acquire_ctx t, t2;
  47. static struct ww_mutex o, o2, o3;
  48. /*
  49. * Normal standalone locks, for the circular and irq-context
  50. * dependency tests:
  51. */
  52. static DEFINE_RAW_SPINLOCK(lock_A);
  53. static DEFINE_RAW_SPINLOCK(lock_B);
  54. static DEFINE_RAW_SPINLOCK(lock_C);
  55. static DEFINE_RAW_SPINLOCK(lock_D);
  56. static DEFINE_RWLOCK(rwlock_A);
  57. static DEFINE_RWLOCK(rwlock_B);
  58. static DEFINE_RWLOCK(rwlock_C);
  59. static DEFINE_RWLOCK(rwlock_D);
  60. static DEFINE_MUTEX(mutex_A);
  61. static DEFINE_MUTEX(mutex_B);
  62. static DEFINE_MUTEX(mutex_C);
  63. static DEFINE_MUTEX(mutex_D);
  64. static DECLARE_RWSEM(rwsem_A);
  65. static DECLARE_RWSEM(rwsem_B);
  66. static DECLARE_RWSEM(rwsem_C);
  67. static DECLARE_RWSEM(rwsem_D);
  68. #ifdef CONFIG_RT_MUTEXES
  69. static DEFINE_RT_MUTEX(rtmutex_A);
  70. static DEFINE_RT_MUTEX(rtmutex_B);
  71. static DEFINE_RT_MUTEX(rtmutex_C);
  72. static DEFINE_RT_MUTEX(rtmutex_D);
  73. #endif
  74. /*
  75. * Locks that we initialize dynamically as well so that
  76. * e.g. X1 and X2 becomes two instances of the same class,
  77. * but X* and Y* are different classes. We do this so that
  78. * we do not trigger a real lockup:
  79. */
  80. static DEFINE_RAW_SPINLOCK(lock_X1);
  81. static DEFINE_RAW_SPINLOCK(lock_X2);
  82. static DEFINE_RAW_SPINLOCK(lock_Y1);
  83. static DEFINE_RAW_SPINLOCK(lock_Y2);
  84. static DEFINE_RAW_SPINLOCK(lock_Z1);
  85. static DEFINE_RAW_SPINLOCK(lock_Z2);
  86. static DEFINE_RWLOCK(rwlock_X1);
  87. static DEFINE_RWLOCK(rwlock_X2);
  88. static DEFINE_RWLOCK(rwlock_Y1);
  89. static DEFINE_RWLOCK(rwlock_Y2);
  90. static DEFINE_RWLOCK(rwlock_Z1);
  91. static DEFINE_RWLOCK(rwlock_Z2);
  92. static DEFINE_MUTEX(mutex_X1);
  93. static DEFINE_MUTEX(mutex_X2);
  94. static DEFINE_MUTEX(mutex_Y1);
  95. static DEFINE_MUTEX(mutex_Y2);
  96. static DEFINE_MUTEX(mutex_Z1);
  97. static DEFINE_MUTEX(mutex_Z2);
  98. static DECLARE_RWSEM(rwsem_X1);
  99. static DECLARE_RWSEM(rwsem_X2);
  100. static DECLARE_RWSEM(rwsem_Y1);
  101. static DECLARE_RWSEM(rwsem_Y2);
  102. static DECLARE_RWSEM(rwsem_Z1);
  103. static DECLARE_RWSEM(rwsem_Z2);
  104. #ifdef CONFIG_RT_MUTEXES
  105. static DEFINE_RT_MUTEX(rtmutex_X1);
  106. static DEFINE_RT_MUTEX(rtmutex_X2);
  107. static DEFINE_RT_MUTEX(rtmutex_Y1);
  108. static DEFINE_RT_MUTEX(rtmutex_Y2);
  109. static DEFINE_RT_MUTEX(rtmutex_Z1);
  110. static DEFINE_RT_MUTEX(rtmutex_Z2);
  111. #endif
  112. /*
  113. * non-inlined runtime initializers, to let separate locks share
  114. * the same lock-class:
  115. */
  116. #define INIT_CLASS_FUNC(class) \
  117. static noinline void \
  118. init_class_##class(raw_spinlock_t *lock, rwlock_t *rwlock, \
  119. struct mutex *mutex, struct rw_semaphore *rwsem)\
  120. { \
  121. raw_spin_lock_init(lock); \
  122. rwlock_init(rwlock); \
  123. mutex_init(mutex); \
  124. init_rwsem(rwsem); \
  125. }
  126. INIT_CLASS_FUNC(X)
  127. INIT_CLASS_FUNC(Y)
  128. INIT_CLASS_FUNC(Z)
  129. static void init_shared_classes(void)
  130. {
  131. #ifdef CONFIG_RT_MUTEXES
  132. static struct lock_class_key rt_X, rt_Y, rt_Z;
  133. __rt_mutex_init(&rtmutex_X1, __func__, &rt_X);
  134. __rt_mutex_init(&rtmutex_X2, __func__, &rt_X);
  135. __rt_mutex_init(&rtmutex_Y1, __func__, &rt_Y);
  136. __rt_mutex_init(&rtmutex_Y2, __func__, &rt_Y);
  137. __rt_mutex_init(&rtmutex_Z1, __func__, &rt_Z);
  138. __rt_mutex_init(&rtmutex_Z2, __func__, &rt_Z);
  139. #endif
  140. init_class_X(&lock_X1, &rwlock_X1, &mutex_X1, &rwsem_X1);
  141. init_class_X(&lock_X2, &rwlock_X2, &mutex_X2, &rwsem_X2);
  142. init_class_Y(&lock_Y1, &rwlock_Y1, &mutex_Y1, &rwsem_Y1);
  143. init_class_Y(&lock_Y2, &rwlock_Y2, &mutex_Y2, &rwsem_Y2);
  144. init_class_Z(&lock_Z1, &rwlock_Z1, &mutex_Z1, &rwsem_Z1);
  145. init_class_Z(&lock_Z2, &rwlock_Z2, &mutex_Z2, &rwsem_Z2);
  146. }
  147. /*
  148. * For spinlocks and rwlocks we also do hardirq-safe / softirq-safe tests.
  149. * The following functions use a lock from a simulated hardirq/softirq
  150. * context, causing the locks to be marked as hardirq-safe/softirq-safe:
  151. */
  152. #define HARDIRQ_DISABLE local_irq_disable
  153. #define HARDIRQ_ENABLE local_irq_enable
  154. #define HARDIRQ_ENTER() \
  155. local_irq_disable(); \
  156. __irq_enter(); \
  157. lockdep_hardirq_threaded(); \
  158. WARN_ON(!in_irq());
  159. #define HARDIRQ_EXIT() \
  160. __irq_exit(); \
  161. local_irq_enable();
  162. #define SOFTIRQ_DISABLE local_bh_disable
  163. #define SOFTIRQ_ENABLE local_bh_enable
  164. #define SOFTIRQ_ENTER() \
  165. local_bh_disable(); \
  166. local_irq_disable(); \
  167. lockdep_softirq_enter(); \
  168. WARN_ON(!in_softirq());
  169. #define SOFTIRQ_EXIT() \
  170. lockdep_softirq_exit(); \
  171. local_irq_enable(); \
  172. local_bh_enable();
  173. /*
  174. * Shortcuts for lock/unlock API variants, to keep
  175. * the testcases compact:
  176. */
  177. #define L(x) raw_spin_lock(&lock_##x)
  178. #define U(x) raw_spin_unlock(&lock_##x)
  179. #define LU(x) L(x); U(x)
  180. #define SI(x) raw_spin_lock_init(&lock_##x)
  181. #define WL(x) write_lock(&rwlock_##x)
  182. #define WU(x) write_unlock(&rwlock_##x)
  183. #define WLU(x) WL(x); WU(x)
  184. #define RL(x) read_lock(&rwlock_##x)
  185. #define RU(x) read_unlock(&rwlock_##x)
  186. #define RLU(x) RL(x); RU(x)
  187. #define RWI(x) rwlock_init(&rwlock_##x)
  188. #define ML(x) mutex_lock(&mutex_##x)
  189. #define MU(x) mutex_unlock(&mutex_##x)
  190. #define MI(x) mutex_init(&mutex_##x)
  191. #define RTL(x) rt_mutex_lock(&rtmutex_##x)
  192. #define RTU(x) rt_mutex_unlock(&rtmutex_##x)
  193. #define RTI(x) rt_mutex_init(&rtmutex_##x)
  194. #define WSL(x) down_write(&rwsem_##x)
  195. #define WSU(x) up_write(&rwsem_##x)
  196. #define RSL(x) down_read(&rwsem_##x)
  197. #define RSU(x) up_read(&rwsem_##x)
  198. #define RWSI(x) init_rwsem(&rwsem_##x)
  199. #ifndef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
  200. #define WWAI(x) ww_acquire_init(x, &ww_lockdep)
  201. #else
  202. #define WWAI(x) do { ww_acquire_init(x, &ww_lockdep); (x)->deadlock_inject_countdown = ~0U; } while (0)
  203. #endif
  204. #define WWAD(x) ww_acquire_done(x)
  205. #define WWAF(x) ww_acquire_fini(x)
  206. #define WWL(x, c) ww_mutex_lock(x, c)
  207. #define WWT(x) ww_mutex_trylock(x)
  208. #define WWL1(x) ww_mutex_lock(x, NULL)
  209. #define WWU(x) ww_mutex_unlock(x)
  210. #define LOCK_UNLOCK_2(x,y) LOCK(x); LOCK(y); UNLOCK(y); UNLOCK(x)
  211. /*
  212. * Generate different permutations of the same testcase, using
  213. * the same basic lock-dependency/state events:
  214. */
  215. #define GENERATE_TESTCASE(name) \
  216. \
  217. static void name(void) { E(); }
  218. #define GENERATE_PERMUTATIONS_2_EVENTS(name) \
  219. \
  220. static void name##_12(void) { E1(); E2(); } \
  221. static void name##_21(void) { E2(); E1(); }
  222. #define GENERATE_PERMUTATIONS_3_EVENTS(name) \
  223. \
  224. static void name##_123(void) { E1(); E2(); E3(); } \
  225. static void name##_132(void) { E1(); E3(); E2(); } \
  226. static void name##_213(void) { E2(); E1(); E3(); } \
  227. static void name##_231(void) { E2(); E3(); E1(); } \
  228. static void name##_312(void) { E3(); E1(); E2(); } \
  229. static void name##_321(void) { E3(); E2(); E1(); }
  230. /*
  231. * AA deadlock:
  232. */
  233. #define E() \
  234. \
  235. LOCK(X1); \
  236. LOCK(X2); /* this one should fail */
  237. /*
  238. * 6 testcases:
  239. */
  240. #include "locking-selftest-spin.h"
  241. GENERATE_TESTCASE(AA_spin)
  242. #include "locking-selftest-wlock.h"
  243. GENERATE_TESTCASE(AA_wlock)
  244. #include "locking-selftest-rlock.h"
  245. GENERATE_TESTCASE(AA_rlock)
  246. #include "locking-selftest-mutex.h"
  247. GENERATE_TESTCASE(AA_mutex)
  248. #include "locking-selftest-wsem.h"
  249. GENERATE_TESTCASE(AA_wsem)
  250. #include "locking-selftest-rsem.h"
  251. GENERATE_TESTCASE(AA_rsem)
  252. #ifdef CONFIG_RT_MUTEXES
  253. #include "locking-selftest-rtmutex.h"
  254. GENERATE_TESTCASE(AA_rtmutex);
  255. #endif
  256. #undef E
  257. /*
  258. * Special-case for read-locking, they are
  259. * allowed to recurse on the same lock class:
  260. */
  261. static void rlock_AA1(void)
  262. {
  263. RL(X1);
  264. RL(X1); // this one should NOT fail
  265. }
  266. static void rlock_AA1B(void)
  267. {
  268. RL(X1);
  269. RL(X2); // this one should NOT fail
  270. }
  271. static void rsem_AA1(void)
  272. {
  273. RSL(X1);
  274. RSL(X1); // this one should fail
  275. }
  276. static void rsem_AA1B(void)
  277. {
  278. RSL(X1);
  279. RSL(X2); // this one should fail
  280. }
  281. /*
  282. * The mixing of read and write locks is not allowed:
  283. */
  284. static void rlock_AA2(void)
  285. {
  286. RL(X1);
  287. WL(X2); // this one should fail
  288. }
  289. static void rsem_AA2(void)
  290. {
  291. RSL(X1);
  292. WSL(X2); // this one should fail
  293. }
  294. static void rlock_AA3(void)
  295. {
  296. WL(X1);
  297. RL(X2); // this one should fail
  298. }
  299. static void rsem_AA3(void)
  300. {
  301. WSL(X1);
  302. RSL(X2); // this one should fail
  303. }
  304. /*
  305. * read_lock(A)
  306. * spin_lock(B)
  307. * spin_lock(B)
  308. * write_lock(A)
  309. */
  310. static void rlock_ABBA1(void)
  311. {
  312. RL(X1);
  313. L(Y1);
  314. U(Y1);
  315. RU(X1);
  316. L(Y1);
  317. WL(X1);
  318. WU(X1);
  319. U(Y1); // should fail
  320. }
  321. static void rwsem_ABBA1(void)
  322. {
  323. RSL(X1);
  324. ML(Y1);
  325. MU(Y1);
  326. RSU(X1);
  327. ML(Y1);
  328. WSL(X1);
  329. WSU(X1);
  330. MU(Y1); // should fail
  331. }
  332. /*
  333. * read_lock(A)
  334. * spin_lock(B)
  335. * spin_lock(B)
  336. * write_lock(A)
  337. *
  338. * This test case is aimed at poking whether the chain cache prevents us from
  339. * detecting a read-lock/lock-write deadlock: if the chain cache doesn't differ
  340. * read/write locks, the following case may happen
  341. *
  342. * { read_lock(A)->lock(B) dependency exists }
  343. *
  344. * P0:
  345. * lock(B);
  346. * read_lock(A);
  347. *
  348. * { Not a deadlock, B -> A is added in the chain cache }
  349. *
  350. * P1:
  351. * lock(B);
  352. * write_lock(A);
  353. *
  354. * { B->A found in chain cache, not reported as a deadlock }
  355. *
  356. */
  357. static void rlock_chaincache_ABBA1(void)
  358. {
  359. RL(X1);
  360. L(Y1);
  361. U(Y1);
  362. RU(X1);
  363. L(Y1);
  364. RL(X1);
  365. RU(X1);
  366. U(Y1);
  367. L(Y1);
  368. WL(X1);
  369. WU(X1);
  370. U(Y1); // should fail
  371. }
  372. /*
  373. * read_lock(A)
  374. * spin_lock(B)
  375. * spin_lock(B)
  376. * read_lock(A)
  377. */
  378. static void rlock_ABBA2(void)
  379. {
  380. RL(X1);
  381. L(Y1);
  382. U(Y1);
  383. RU(X1);
  384. L(Y1);
  385. RL(X1);
  386. RU(X1);
  387. U(Y1); // should NOT fail
  388. }
  389. static void rwsem_ABBA2(void)
  390. {
  391. RSL(X1);
  392. ML(Y1);
  393. MU(Y1);
  394. RSU(X1);
  395. ML(Y1);
  396. RSL(X1);
  397. RSU(X1);
  398. MU(Y1); // should fail
  399. }
  400. /*
  401. * write_lock(A)
  402. * spin_lock(B)
  403. * spin_lock(B)
  404. * write_lock(A)
  405. */
  406. static void rlock_ABBA3(void)
  407. {
  408. WL(X1);
  409. L(Y1);
  410. U(Y1);
  411. WU(X1);
  412. L(Y1);
  413. WL(X1);
  414. WU(X1);
  415. U(Y1); // should fail
  416. }
  417. static void rwsem_ABBA3(void)
  418. {
  419. WSL(X1);
  420. ML(Y1);
  421. MU(Y1);
  422. WSU(X1);
  423. ML(Y1);
  424. WSL(X1);
  425. WSU(X1);
  426. MU(Y1); // should fail
  427. }
  428. /*
  429. * ABBA deadlock:
  430. */
  431. #define E() \
  432. \
  433. LOCK_UNLOCK_2(A, B); \
  434. LOCK_UNLOCK_2(B, A); /* fail */
  435. /*
  436. * 6 testcases:
  437. */
  438. #include "locking-selftest-spin.h"
  439. GENERATE_TESTCASE(ABBA_spin)
  440. #include "locking-selftest-wlock.h"
  441. GENERATE_TESTCASE(ABBA_wlock)
  442. #include "locking-selftest-rlock.h"
  443. GENERATE_TESTCASE(ABBA_rlock)
  444. #include "locking-selftest-mutex.h"
  445. GENERATE_TESTCASE(ABBA_mutex)
  446. #include "locking-selftest-wsem.h"
  447. GENERATE_TESTCASE(ABBA_wsem)
  448. #include "locking-selftest-rsem.h"
  449. GENERATE_TESTCASE(ABBA_rsem)
  450. #ifdef CONFIG_RT_MUTEXES
  451. #include "locking-selftest-rtmutex.h"
  452. GENERATE_TESTCASE(ABBA_rtmutex);
  453. #endif
  454. #undef E
  455. /*
  456. * AB BC CA deadlock:
  457. */
  458. #define E() \
  459. \
  460. LOCK_UNLOCK_2(A, B); \
  461. LOCK_UNLOCK_2(B, C); \
  462. LOCK_UNLOCK_2(C, A); /* fail */
  463. /*
  464. * 6 testcases:
  465. */
  466. #include "locking-selftest-spin.h"
  467. GENERATE_TESTCASE(ABBCCA_spin)
  468. #include "locking-selftest-wlock.h"
  469. GENERATE_TESTCASE(ABBCCA_wlock)
  470. #include "locking-selftest-rlock.h"
  471. GENERATE_TESTCASE(ABBCCA_rlock)
  472. #include "locking-selftest-mutex.h"
  473. GENERATE_TESTCASE(ABBCCA_mutex)
  474. #include "locking-selftest-wsem.h"
  475. GENERATE_TESTCASE(ABBCCA_wsem)
  476. #include "locking-selftest-rsem.h"
  477. GENERATE_TESTCASE(ABBCCA_rsem)
  478. #ifdef CONFIG_RT_MUTEXES
  479. #include "locking-selftest-rtmutex.h"
  480. GENERATE_TESTCASE(ABBCCA_rtmutex);
  481. #endif
  482. #undef E
  483. /*
  484. * AB CA BC deadlock:
  485. */
  486. #define E() \
  487. \
  488. LOCK_UNLOCK_2(A, B); \
  489. LOCK_UNLOCK_2(C, A); \
  490. LOCK_UNLOCK_2(B, C); /* fail */
  491. /*
  492. * 6 testcases:
  493. */
  494. #include "locking-selftest-spin.h"
  495. GENERATE_TESTCASE(ABCABC_spin)
  496. #include "locking-selftest-wlock.h"
  497. GENERATE_TESTCASE(ABCABC_wlock)
  498. #include "locking-selftest-rlock.h"
  499. GENERATE_TESTCASE(ABCABC_rlock)
  500. #include "locking-selftest-mutex.h"
  501. GENERATE_TESTCASE(ABCABC_mutex)
  502. #include "locking-selftest-wsem.h"
  503. GENERATE_TESTCASE(ABCABC_wsem)
  504. #include "locking-selftest-rsem.h"
  505. GENERATE_TESTCASE(ABCABC_rsem)
  506. #ifdef CONFIG_RT_MUTEXES
  507. #include "locking-selftest-rtmutex.h"
  508. GENERATE_TESTCASE(ABCABC_rtmutex);
  509. #endif
  510. #undef E
  511. /*
  512. * AB BC CD DA deadlock:
  513. */
  514. #define E() \
  515. \
  516. LOCK_UNLOCK_2(A, B); \
  517. LOCK_UNLOCK_2(B, C); \
  518. LOCK_UNLOCK_2(C, D); \
  519. LOCK_UNLOCK_2(D, A); /* fail */
  520. /*
  521. * 6 testcases:
  522. */
  523. #include "locking-selftest-spin.h"
  524. GENERATE_TESTCASE(ABBCCDDA_spin)
  525. #include "locking-selftest-wlock.h"
  526. GENERATE_TESTCASE(ABBCCDDA_wlock)
  527. #include "locking-selftest-rlock.h"
  528. GENERATE_TESTCASE(ABBCCDDA_rlock)
  529. #include "locking-selftest-mutex.h"
  530. GENERATE_TESTCASE(ABBCCDDA_mutex)
  531. #include "locking-selftest-wsem.h"
  532. GENERATE_TESTCASE(ABBCCDDA_wsem)
  533. #include "locking-selftest-rsem.h"
  534. GENERATE_TESTCASE(ABBCCDDA_rsem)
  535. #ifdef CONFIG_RT_MUTEXES
  536. #include "locking-selftest-rtmutex.h"
  537. GENERATE_TESTCASE(ABBCCDDA_rtmutex);
  538. #endif
  539. #undef E
  540. /*
  541. * AB CD BD DA deadlock:
  542. */
  543. #define E() \
  544. \
  545. LOCK_UNLOCK_2(A, B); \
  546. LOCK_UNLOCK_2(C, D); \
  547. LOCK_UNLOCK_2(B, D); \
  548. LOCK_UNLOCK_2(D, A); /* fail */
  549. /*
  550. * 6 testcases:
  551. */
  552. #include "locking-selftest-spin.h"
  553. GENERATE_TESTCASE(ABCDBDDA_spin)
  554. #include "locking-selftest-wlock.h"
  555. GENERATE_TESTCASE(ABCDBDDA_wlock)
  556. #include "locking-selftest-rlock.h"
  557. GENERATE_TESTCASE(ABCDBDDA_rlock)
  558. #include "locking-selftest-mutex.h"
  559. GENERATE_TESTCASE(ABCDBDDA_mutex)
  560. #include "locking-selftest-wsem.h"
  561. GENERATE_TESTCASE(ABCDBDDA_wsem)
  562. #include "locking-selftest-rsem.h"
  563. GENERATE_TESTCASE(ABCDBDDA_rsem)
  564. #ifdef CONFIG_RT_MUTEXES
  565. #include "locking-selftest-rtmutex.h"
  566. GENERATE_TESTCASE(ABCDBDDA_rtmutex);
  567. #endif
  568. #undef E
  569. /*
  570. * AB CD BC DA deadlock:
  571. */
  572. #define E() \
  573. \
  574. LOCK_UNLOCK_2(A, B); \
  575. LOCK_UNLOCK_2(C, D); \
  576. LOCK_UNLOCK_2(B, C); \
  577. LOCK_UNLOCK_2(D, A); /* fail */
  578. /*
  579. * 6 testcases:
  580. */
  581. #include "locking-selftest-spin.h"
  582. GENERATE_TESTCASE(ABCDBCDA_spin)
  583. #include "locking-selftest-wlock.h"
  584. GENERATE_TESTCASE(ABCDBCDA_wlock)
  585. #include "locking-selftest-rlock.h"
  586. GENERATE_TESTCASE(ABCDBCDA_rlock)
  587. #include "locking-selftest-mutex.h"
  588. GENERATE_TESTCASE(ABCDBCDA_mutex)
  589. #include "locking-selftest-wsem.h"
  590. GENERATE_TESTCASE(ABCDBCDA_wsem)
  591. #include "locking-selftest-rsem.h"
  592. GENERATE_TESTCASE(ABCDBCDA_rsem)
  593. #ifdef CONFIG_RT_MUTEXES
  594. #include "locking-selftest-rtmutex.h"
  595. GENERATE_TESTCASE(ABCDBCDA_rtmutex);
  596. #endif
  597. #undef E
  598. /*
  599. * Double unlock:
  600. */
  601. #define E() \
  602. \
  603. LOCK(A); \
  604. UNLOCK(A); \
  605. UNLOCK(A); /* fail */
  606. /*
  607. * 6 testcases:
  608. */
  609. #include "locking-selftest-spin.h"
  610. GENERATE_TESTCASE(double_unlock_spin)
  611. #include "locking-selftest-wlock.h"
  612. GENERATE_TESTCASE(double_unlock_wlock)
  613. #include "locking-selftest-rlock.h"
  614. GENERATE_TESTCASE(double_unlock_rlock)
  615. #include "locking-selftest-mutex.h"
  616. GENERATE_TESTCASE(double_unlock_mutex)
  617. #include "locking-selftest-wsem.h"
  618. GENERATE_TESTCASE(double_unlock_wsem)
  619. #include "locking-selftest-rsem.h"
  620. GENERATE_TESTCASE(double_unlock_rsem)
  621. #ifdef CONFIG_RT_MUTEXES
  622. #include "locking-selftest-rtmutex.h"
  623. GENERATE_TESTCASE(double_unlock_rtmutex);
  624. #endif
  625. #undef E
  626. /*
  627. * initializing a held lock:
  628. */
  629. #define E() \
  630. \
  631. LOCK(A); \
  632. INIT(A); /* fail */
  633. /*
  634. * 6 testcases:
  635. */
  636. #include "locking-selftest-spin.h"
  637. GENERATE_TESTCASE(init_held_spin)
  638. #include "locking-selftest-wlock.h"
  639. GENERATE_TESTCASE(init_held_wlock)
  640. #include "locking-selftest-rlock.h"
  641. GENERATE_TESTCASE(init_held_rlock)
  642. #include "locking-selftest-mutex.h"
  643. GENERATE_TESTCASE(init_held_mutex)
  644. #include "locking-selftest-wsem.h"
  645. GENERATE_TESTCASE(init_held_wsem)
  646. #include "locking-selftest-rsem.h"
  647. GENERATE_TESTCASE(init_held_rsem)
  648. #ifdef CONFIG_RT_MUTEXES
  649. #include "locking-selftest-rtmutex.h"
  650. GENERATE_TESTCASE(init_held_rtmutex);
  651. #endif
  652. #undef E
  653. /*
  654. * locking an irq-safe lock with irqs enabled:
  655. */
  656. #define E1() \
  657. \
  658. IRQ_ENTER(); \
  659. LOCK(A); \
  660. UNLOCK(A); \
  661. IRQ_EXIT();
  662. #define E2() \
  663. \
  664. LOCK(A); \
  665. UNLOCK(A);
  666. /*
  667. * Generate 24 testcases:
  668. */
  669. #include "locking-selftest-spin-hardirq.h"
  670. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_spin)
  671. #include "locking-selftest-rlock-hardirq.h"
  672. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_rlock)
  673. #include "locking-selftest-wlock-hardirq.h"
  674. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_hard_wlock)
  675. #include "locking-selftest-spin-softirq.h"
  676. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_spin)
  677. #include "locking-selftest-rlock-softirq.h"
  678. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_rlock)
  679. #include "locking-selftest-wlock-softirq.h"
  680. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe1_soft_wlock)
  681. #undef E1
  682. #undef E2
  683. /*
  684. * Enabling hardirqs with a softirq-safe lock held:
  685. */
  686. #define E1() \
  687. \
  688. SOFTIRQ_ENTER(); \
  689. LOCK(A); \
  690. UNLOCK(A); \
  691. SOFTIRQ_EXIT();
  692. #define E2() \
  693. \
  694. HARDIRQ_DISABLE(); \
  695. LOCK(A); \
  696. HARDIRQ_ENABLE(); \
  697. UNLOCK(A);
  698. /*
  699. * Generate 12 testcases:
  700. */
  701. #include "locking-selftest-spin.h"
  702. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_spin)
  703. #include "locking-selftest-wlock.h"
  704. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_wlock)
  705. #include "locking-selftest-rlock.h"
  706. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2A_rlock)
  707. #undef E1
  708. #undef E2
  709. /*
  710. * Enabling irqs with an irq-safe lock held:
  711. */
  712. #define E1() \
  713. \
  714. IRQ_ENTER(); \
  715. LOCK(A); \
  716. UNLOCK(A); \
  717. IRQ_EXIT();
  718. #define E2() \
  719. \
  720. IRQ_DISABLE(); \
  721. LOCK(A); \
  722. IRQ_ENABLE(); \
  723. UNLOCK(A);
  724. /*
  725. * Generate 24 testcases:
  726. */
  727. #include "locking-selftest-spin-hardirq.h"
  728. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_spin)
  729. #include "locking-selftest-rlock-hardirq.h"
  730. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_rlock)
  731. #include "locking-selftest-wlock-hardirq.h"
  732. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_hard_wlock)
  733. #include "locking-selftest-spin-softirq.h"
  734. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_spin)
  735. #include "locking-selftest-rlock-softirq.h"
  736. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_rlock)
  737. #include "locking-selftest-wlock-softirq.h"
  738. GENERATE_PERMUTATIONS_2_EVENTS(irqsafe2B_soft_wlock)
  739. #undef E1
  740. #undef E2
  741. /*
  742. * Acquiring a irq-unsafe lock while holding an irq-safe-lock:
  743. */
  744. #define E1() \
  745. \
  746. LOCK(A); \
  747. LOCK(B); \
  748. UNLOCK(B); \
  749. UNLOCK(A); \
  750. #define E2() \
  751. \
  752. LOCK(B); \
  753. UNLOCK(B);
  754. #define E3() \
  755. \
  756. IRQ_ENTER(); \
  757. LOCK(A); \
  758. UNLOCK(A); \
  759. IRQ_EXIT();
  760. /*
  761. * Generate 36 testcases:
  762. */
  763. #include "locking-selftest-spin-hardirq.h"
  764. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_spin)
  765. #include "locking-selftest-rlock-hardirq.h"
  766. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_rlock)
  767. #include "locking-selftest-wlock-hardirq.h"
  768. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_hard_wlock)
  769. #include "locking-selftest-spin-softirq.h"
  770. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_spin)
  771. #include "locking-selftest-rlock-softirq.h"
  772. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_rlock)
  773. #include "locking-selftest-wlock-softirq.h"
  774. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe3_soft_wlock)
  775. #undef E1
  776. #undef E2
  777. #undef E3
  778. /*
  779. * If a lock turns into softirq-safe, but earlier it took
  780. * a softirq-unsafe lock:
  781. */
  782. #define E1() \
  783. IRQ_DISABLE(); \
  784. LOCK(A); \
  785. LOCK(B); \
  786. UNLOCK(B); \
  787. UNLOCK(A); \
  788. IRQ_ENABLE();
  789. #define E2() \
  790. LOCK(B); \
  791. UNLOCK(B);
  792. #define E3() \
  793. IRQ_ENTER(); \
  794. LOCK(A); \
  795. UNLOCK(A); \
  796. IRQ_EXIT();
  797. /*
  798. * Generate 36 testcases:
  799. */
  800. #include "locking-selftest-spin-hardirq.h"
  801. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_spin)
  802. #include "locking-selftest-rlock-hardirq.h"
  803. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_rlock)
  804. #include "locking-selftest-wlock-hardirq.h"
  805. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_hard_wlock)
  806. #include "locking-selftest-spin-softirq.h"
  807. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_spin)
  808. #include "locking-selftest-rlock-softirq.h"
  809. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_rlock)
  810. #include "locking-selftest-wlock-softirq.h"
  811. GENERATE_PERMUTATIONS_3_EVENTS(irqsafe4_soft_wlock)
  812. #undef E1
  813. #undef E2
  814. #undef E3
  815. /*
  816. * read-lock / write-lock irq inversion.
  817. *
  818. * Deadlock scenario:
  819. *
  820. * CPU#1 is at #1, i.e. it has write-locked A, but has not
  821. * taken B yet.
  822. *
  823. * CPU#2 is at #2, i.e. it has locked B.
  824. *
  825. * Hardirq hits CPU#2 at point #2 and is trying to read-lock A.
  826. *
  827. * The deadlock occurs because CPU#1 will spin on B, and CPU#2
  828. * will spin on A.
  829. */
  830. #define E1() \
  831. \
  832. IRQ_DISABLE(); \
  833. WL(A); \
  834. LOCK(B); \
  835. UNLOCK(B); \
  836. WU(A); \
  837. IRQ_ENABLE();
  838. #define E2() \
  839. \
  840. LOCK(B); \
  841. UNLOCK(B);
  842. #define E3() \
  843. \
  844. IRQ_ENTER(); \
  845. RL(A); \
  846. RU(A); \
  847. IRQ_EXIT();
  848. /*
  849. * Generate 36 testcases:
  850. */
  851. #include "locking-selftest-spin-hardirq.h"
  852. GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_spin)
  853. #include "locking-selftest-rlock-hardirq.h"
  854. GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_rlock)
  855. #include "locking-selftest-wlock-hardirq.h"
  856. GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_hard_wlock)
  857. #include "locking-selftest-spin-softirq.h"
  858. GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_spin)
  859. #include "locking-selftest-rlock-softirq.h"
  860. GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_rlock)
  861. #include "locking-selftest-wlock-softirq.h"
  862. GENERATE_PERMUTATIONS_3_EVENTS(irq_inversion_soft_wlock)
  863. #undef E1
  864. #undef E2
  865. #undef E3
  866. /*
  867. * write-read / write-read / write-read deadlock even if read is recursive
  868. */
  869. #define E1() \
  870. \
  871. WL(X1); \
  872. RL(Y1); \
  873. RU(Y1); \
  874. WU(X1);
  875. #define E2() \
  876. \
  877. WL(Y1); \
  878. RL(Z1); \
  879. RU(Z1); \
  880. WU(Y1);
  881. #define E3() \
  882. \
  883. WL(Z1); \
  884. RL(X1); \
  885. RU(X1); \
  886. WU(Z1);
  887. #include "locking-selftest-rlock.h"
  888. GENERATE_PERMUTATIONS_3_EVENTS(W1R2_W2R3_W3R1)
  889. #undef E1
  890. #undef E2
  891. #undef E3
  892. /*
  893. * write-write / read-read / write-read deadlock even if read is recursive
  894. */
  895. #define E1() \
  896. \
  897. WL(X1); \
  898. WL(Y1); \
  899. WU(Y1); \
  900. WU(X1);
  901. #define E2() \
  902. \
  903. RL(Y1); \
  904. RL(Z1); \
  905. RU(Z1); \
  906. RU(Y1);
  907. #define E3() \
  908. \
  909. WL(Z1); \
  910. RL(X1); \
  911. RU(X1); \
  912. WU(Z1);
  913. #include "locking-selftest-rlock.h"
  914. GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_W3R1)
  915. #undef E1
  916. #undef E2
  917. #undef E3
  918. /*
  919. * write-write / read-read / read-write is not deadlock when read is recursive
  920. */
  921. #define E1() \
  922. \
  923. WL(X1); \
  924. WL(Y1); \
  925. WU(Y1); \
  926. WU(X1);
  927. #define E2() \
  928. \
  929. RL(Y1); \
  930. RL(Z1); \
  931. RU(Z1); \
  932. RU(Y1);
  933. #define E3() \
  934. \
  935. RL(Z1); \
  936. WL(X1); \
  937. WU(X1); \
  938. RU(Z1);
  939. #include "locking-selftest-rlock.h"
  940. GENERATE_PERMUTATIONS_3_EVENTS(W1R2_R2R3_W3W1)
  941. #undef E1
  942. #undef E2
  943. #undef E3
  944. /*
  945. * write-read / read-read / write-write is not deadlock when read is recursive
  946. */
  947. #define E1() \
  948. \
  949. WL(X1); \
  950. RL(Y1); \
  951. RU(Y1); \
  952. WU(X1);
  953. #define E2() \
  954. \
  955. RL(Y1); \
  956. RL(Z1); \
  957. RU(Z1); \
  958. RU(Y1);
  959. #define E3() \
  960. \
  961. WL(Z1); \
  962. WL(X1); \
  963. WU(X1); \
  964. WU(Z1);
  965. #include "locking-selftest-rlock.h"
  966. GENERATE_PERMUTATIONS_3_EVENTS(W1W2_R2R3_R3W1)
  967. #undef E1
  968. #undef E2
  969. #undef E3
  970. /*
  971. * read-lock / write-lock recursion that is actually safe.
  972. */
  973. #define E1() \
  974. \
  975. IRQ_DISABLE(); \
  976. WL(A); \
  977. WU(A); \
  978. IRQ_ENABLE();
  979. #define E2() \
  980. \
  981. RL(A); \
  982. RU(A); \
  983. #define E3() \
  984. \
  985. IRQ_ENTER(); \
  986. LOCK(A); \
  987. L(B); \
  988. U(B); \
  989. UNLOCK(A); \
  990. IRQ_EXIT();
  991. /*
  992. * Generate 24 testcases:
  993. */
  994. #include "locking-selftest-hardirq.h"
  995. #include "locking-selftest-rlock.h"
  996. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_rlock)
  997. #include "locking-selftest-wlock.h"
  998. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_hard_wlock)
  999. #include "locking-selftest-softirq.h"
  1000. #include "locking-selftest-rlock.h"
  1001. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_rlock)
  1002. #include "locking-selftest-wlock.h"
  1003. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft_wlock)
  1004. #undef E1
  1005. #undef E2
  1006. #undef E3
  1007. /*
  1008. * read-lock / write-lock recursion that is unsafe.
  1009. */
  1010. #define E1() \
  1011. \
  1012. IRQ_DISABLE(); \
  1013. L(B); \
  1014. LOCK(A); \
  1015. UNLOCK(A); \
  1016. U(B); \
  1017. IRQ_ENABLE();
  1018. #define E2() \
  1019. \
  1020. RL(A); \
  1021. RU(A); \
  1022. #define E3() \
  1023. \
  1024. IRQ_ENTER(); \
  1025. L(B); \
  1026. U(B); \
  1027. IRQ_EXIT();
  1028. /*
  1029. * Generate 24 testcases:
  1030. */
  1031. #include "locking-selftest-hardirq.h"
  1032. #include "locking-selftest-rlock.h"
  1033. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_rlock)
  1034. #include "locking-selftest-wlock.h"
  1035. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_hard_wlock)
  1036. #include "locking-selftest-softirq.h"
  1037. #include "locking-selftest-rlock.h"
  1038. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_rlock)
  1039. #include "locking-selftest-wlock.h"
  1040. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion2_soft_wlock)
  1041. #undef E1
  1042. #undef E2
  1043. #undef E3
  1044. /*
  1045. * read-lock / write-lock recursion that is unsafe.
  1046. *
  1047. * A is a ENABLED_*_READ lock
  1048. * B is a USED_IN_*_READ lock
  1049. *
  1050. * read_lock(A);
  1051. * write_lock(B);
  1052. * <interrupt>
  1053. * read_lock(B);
  1054. * write_lock(A); // if this one is read_lock(), no deadlock
  1055. */
  1056. #define E1() \
  1057. \
  1058. IRQ_DISABLE(); \
  1059. WL(B); \
  1060. LOCK(A); \
  1061. UNLOCK(A); \
  1062. WU(B); \
  1063. IRQ_ENABLE();
  1064. #define E2() \
  1065. \
  1066. RL(A); \
  1067. RU(A); \
  1068. #define E3() \
  1069. \
  1070. IRQ_ENTER(); \
  1071. RL(B); \
  1072. RU(B); \
  1073. IRQ_EXIT();
  1074. /*
  1075. * Generate 24 testcases:
  1076. */
  1077. #include "locking-selftest-hardirq.h"
  1078. #include "locking-selftest-rlock.h"
  1079. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_rlock)
  1080. #include "locking-selftest-wlock.h"
  1081. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_hard_wlock)
  1082. #include "locking-selftest-softirq.h"
  1083. #include "locking-selftest-rlock.h"
  1084. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_rlock)
  1085. #include "locking-selftest-wlock.h"
  1086. GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion3_soft_wlock)
  1087. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  1088. # define I_SPINLOCK(x) lockdep_reset_lock(&lock_##x.dep_map)
  1089. # define I_RWLOCK(x) lockdep_reset_lock(&rwlock_##x.dep_map)
  1090. # define I_MUTEX(x) lockdep_reset_lock(&mutex_##x.dep_map)
  1091. # define I_RWSEM(x) lockdep_reset_lock(&rwsem_##x.dep_map)
  1092. # define I_WW(x) lockdep_reset_lock(&x.dep_map)
  1093. #ifdef CONFIG_RT_MUTEXES
  1094. # define I_RTMUTEX(x) lockdep_reset_lock(&rtmutex_##x.dep_map)
  1095. #endif
  1096. #else
  1097. # define I_SPINLOCK(x)
  1098. # define I_RWLOCK(x)
  1099. # define I_MUTEX(x)
  1100. # define I_RWSEM(x)
  1101. # define I_WW(x)
  1102. #endif
  1103. #ifndef I_RTMUTEX
  1104. # define I_RTMUTEX(x)
  1105. #endif
  1106. #ifdef CONFIG_RT_MUTEXES
  1107. #define I2_RTMUTEX(x) rt_mutex_init(&rtmutex_##x)
  1108. #else
  1109. #define I2_RTMUTEX(x)
  1110. #endif
  1111. #define I1(x) \
  1112. do { \
  1113. I_SPINLOCK(x); \
  1114. I_RWLOCK(x); \
  1115. I_MUTEX(x); \
  1116. I_RWSEM(x); \
  1117. I_RTMUTEX(x); \
  1118. } while (0)
  1119. #define I2(x) \
  1120. do { \
  1121. raw_spin_lock_init(&lock_##x); \
  1122. rwlock_init(&rwlock_##x); \
  1123. mutex_init(&mutex_##x); \
  1124. init_rwsem(&rwsem_##x); \
  1125. I2_RTMUTEX(x); \
  1126. } while (0)
  1127. static void reset_locks(void)
  1128. {
  1129. local_irq_disable();
  1130. lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
  1131. lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
  1132. I1(A); I1(B); I1(C); I1(D);
  1133. I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
  1134. I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
  1135. lockdep_reset();
  1136. I2(A); I2(B); I2(C); I2(D);
  1137. init_shared_classes();
  1138. ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
  1139. memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
  1140. memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));
  1141. memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));
  1142. local_irq_enable();
  1143. }
  1144. #undef I
  1145. static int testcase_total;
  1146. static int testcase_successes;
  1147. static int expected_testcase_failures;
  1148. static int unexpected_testcase_failures;
  1149. static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
  1150. {
  1151. unsigned long saved_preempt_count = preempt_count();
  1152. WARN_ON(irqs_disabled());
  1153. testcase_fn();
  1154. /*
  1155. * Filter out expected failures:
  1156. */
  1157. #ifndef CONFIG_PROVE_LOCKING
  1158. if (expected == FAILURE && debug_locks) {
  1159. expected_testcase_failures++;
  1160. pr_cont("failed|");
  1161. }
  1162. else
  1163. #endif
  1164. if (debug_locks != expected) {
  1165. unexpected_testcase_failures++;
  1166. pr_cont("FAILED|");
  1167. } else {
  1168. testcase_successes++;
  1169. pr_cont(" ok |");
  1170. }
  1171. testcase_total++;
  1172. if (debug_locks_verbose)
  1173. pr_cont(" lockclass mask: %x, debug_locks: %d, expected: %d\n",
  1174. lockclass_mask, debug_locks, expected);
  1175. /*
  1176. * Some tests (e.g. double-unlock) might corrupt the preemption
  1177. * count, so restore it:
  1178. */
  1179. preempt_count_set(saved_preempt_count);
  1180. #ifdef CONFIG_TRACE_IRQFLAGS
  1181. if (softirq_count())
  1182. current->softirqs_enabled = 0;
  1183. else
  1184. current->softirqs_enabled = 1;
  1185. #endif
  1186. reset_locks();
  1187. }
  1188. #ifdef CONFIG_RT_MUTEXES
  1189. #define dotest_rt(fn, e, m) dotest((fn), (e), (m))
  1190. #else
  1191. #define dotest_rt(fn, e, m)
  1192. #endif
  1193. static inline void print_testname(const char *testname)
  1194. {
  1195. printk("%33s:", testname);
  1196. }
  1197. #define DO_TESTCASE_1(desc, name, nr) \
  1198. print_testname(desc"/"#nr); \
  1199. dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
  1200. pr_cont("\n");
  1201. #define DO_TESTCASE_1B(desc, name, nr) \
  1202. print_testname(desc"/"#nr); \
  1203. dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
  1204. pr_cont("\n");
  1205. #define DO_TESTCASE_1RR(desc, name, nr) \
  1206. print_testname(desc"/"#nr); \
  1207. pr_cont(" |"); \
  1208. dotest(name##_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
  1209. pr_cont("\n");
  1210. #define DO_TESTCASE_1RRB(desc, name, nr) \
  1211. print_testname(desc"/"#nr); \
  1212. pr_cont(" |"); \
  1213. dotest(name##_##nr, FAILURE, LOCKTYPE_RWLOCK); \
  1214. pr_cont("\n");
  1215. #define DO_TESTCASE_3(desc, name, nr) \
  1216. print_testname(desc"/"#nr); \
  1217. dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN); \
  1218. dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
  1219. dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
  1220. pr_cont("\n");
  1221. #define DO_TESTCASE_3RW(desc, name, nr) \
  1222. print_testname(desc"/"#nr); \
  1223. dotest(name##_spin_##nr, FAILURE, LOCKTYPE_SPIN|LOCKTYPE_RWLOCK);\
  1224. dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
  1225. dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
  1226. pr_cont("\n");
  1227. #define DO_TESTCASE_2RW(desc, name, nr) \
  1228. print_testname(desc"/"#nr); \
  1229. pr_cont(" |"); \
  1230. dotest(name##_wlock_##nr, FAILURE, LOCKTYPE_RWLOCK); \
  1231. dotest(name##_rlock_##nr, SUCCESS, LOCKTYPE_RWLOCK); \
  1232. pr_cont("\n");
  1233. #define DO_TESTCASE_2x2RW(desc, name, nr) \
  1234. DO_TESTCASE_2RW("hard-"desc, name##_hard, nr) \
  1235. DO_TESTCASE_2RW("soft-"desc, name##_soft, nr) \
  1236. #define DO_TESTCASE_6x2x2RW(desc, name) \
  1237. DO_TESTCASE_2x2RW(desc, name, 123); \
  1238. DO_TESTCASE_2x2RW(desc, name, 132); \
  1239. DO_TESTCASE_2x2RW(desc, name, 213); \
  1240. DO_TESTCASE_2x2RW(desc, name, 231); \
  1241. DO_TESTCASE_2x2RW(desc, name, 312); \
  1242. DO_TESTCASE_2x2RW(desc, name, 321);
  1243. #define DO_TESTCASE_6(desc, name) \
  1244. print_testname(desc); \
  1245. dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
  1246. dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
  1247. dotest(name##_rlock, FAILURE, LOCKTYPE_RWLOCK); \
  1248. dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
  1249. dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
  1250. dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
  1251. dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
  1252. pr_cont("\n");
  1253. #define DO_TESTCASE_6_SUCCESS(desc, name) \
  1254. print_testname(desc); \
  1255. dotest(name##_spin, SUCCESS, LOCKTYPE_SPIN); \
  1256. dotest(name##_wlock, SUCCESS, LOCKTYPE_RWLOCK); \
  1257. dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
  1258. dotest(name##_mutex, SUCCESS, LOCKTYPE_MUTEX); \
  1259. dotest(name##_wsem, SUCCESS, LOCKTYPE_RWSEM); \
  1260. dotest(name##_rsem, SUCCESS, LOCKTYPE_RWSEM); \
  1261. dotest_rt(name##_rtmutex, SUCCESS, LOCKTYPE_RTMUTEX); \
  1262. pr_cont("\n");
  1263. /*
  1264. * 'read' variant: rlocks must not trigger.
  1265. */
  1266. #define DO_TESTCASE_6R(desc, name) \
  1267. print_testname(desc); \
  1268. dotest(name##_spin, FAILURE, LOCKTYPE_SPIN); \
  1269. dotest(name##_wlock, FAILURE, LOCKTYPE_RWLOCK); \
  1270. dotest(name##_rlock, SUCCESS, LOCKTYPE_RWLOCK); \
  1271. dotest(name##_mutex, FAILURE, LOCKTYPE_MUTEX); \
  1272. dotest(name##_wsem, FAILURE, LOCKTYPE_RWSEM); \
  1273. dotest(name##_rsem, FAILURE, LOCKTYPE_RWSEM); \
  1274. dotest_rt(name##_rtmutex, FAILURE, LOCKTYPE_RTMUTEX); \
  1275. pr_cont("\n");
  1276. #define DO_TESTCASE_2I(desc, name, nr) \
  1277. DO_TESTCASE_1("hard-"desc, name##_hard, nr); \
  1278. DO_TESTCASE_1("soft-"desc, name##_soft, nr);
  1279. #define DO_TESTCASE_2IB(desc, name, nr) \
  1280. DO_TESTCASE_1B("hard-"desc, name##_hard, nr); \
  1281. DO_TESTCASE_1B("soft-"desc, name##_soft, nr);
  1282. #define DO_TESTCASE_6I(desc, name, nr) \
  1283. DO_TESTCASE_3("hard-"desc, name##_hard, nr); \
  1284. DO_TESTCASE_3("soft-"desc, name##_soft, nr);
  1285. #define DO_TESTCASE_6IRW(desc, name, nr) \
  1286. DO_TESTCASE_3RW("hard-"desc, name##_hard, nr); \
  1287. DO_TESTCASE_3RW("soft-"desc, name##_soft, nr);
  1288. #define DO_TESTCASE_2x3(desc, name) \
  1289. DO_TESTCASE_3(desc, name, 12); \
  1290. DO_TESTCASE_3(desc, name, 21);
  1291. #define DO_TESTCASE_2x6(desc, name) \
  1292. DO_TESTCASE_6I(desc, name, 12); \
  1293. DO_TESTCASE_6I(desc, name, 21);
  1294. #define DO_TESTCASE_6x2(desc, name) \
  1295. DO_TESTCASE_2I(desc, name, 123); \
  1296. DO_TESTCASE_2I(desc, name, 132); \
  1297. DO_TESTCASE_2I(desc, name, 213); \
  1298. DO_TESTCASE_2I(desc, name, 231); \
  1299. DO_TESTCASE_2I(desc, name, 312); \
  1300. DO_TESTCASE_2I(desc, name, 321);
  1301. #define DO_TESTCASE_6x2B(desc, name) \
  1302. DO_TESTCASE_2IB(desc, name, 123); \
  1303. DO_TESTCASE_2IB(desc, name, 132); \
  1304. DO_TESTCASE_2IB(desc, name, 213); \
  1305. DO_TESTCASE_2IB(desc, name, 231); \
  1306. DO_TESTCASE_2IB(desc, name, 312); \
  1307. DO_TESTCASE_2IB(desc, name, 321);
  1308. #define DO_TESTCASE_6x1RR(desc, name) \
  1309. DO_TESTCASE_1RR(desc, name, 123); \
  1310. DO_TESTCASE_1RR(desc, name, 132); \
  1311. DO_TESTCASE_1RR(desc, name, 213); \
  1312. DO_TESTCASE_1RR(desc, name, 231); \
  1313. DO_TESTCASE_1RR(desc, name, 312); \
  1314. DO_TESTCASE_1RR(desc, name, 321);
  1315. #define DO_TESTCASE_6x1RRB(desc, name) \
  1316. DO_TESTCASE_1RRB(desc, name, 123); \
  1317. DO_TESTCASE_1RRB(desc, name, 132); \
  1318. DO_TESTCASE_1RRB(desc, name, 213); \
  1319. DO_TESTCASE_1RRB(desc, name, 231); \
  1320. DO_TESTCASE_1RRB(desc, name, 312); \
  1321. DO_TESTCASE_1RRB(desc, name, 321);
  1322. #define DO_TESTCASE_6x6(desc, name) \
  1323. DO_TESTCASE_6I(desc, name, 123); \
  1324. DO_TESTCASE_6I(desc, name, 132); \
  1325. DO_TESTCASE_6I(desc, name, 213); \
  1326. DO_TESTCASE_6I(desc, name, 231); \
  1327. DO_TESTCASE_6I(desc, name, 312); \
  1328. DO_TESTCASE_6I(desc, name, 321);
  1329. #define DO_TESTCASE_6x6RW(desc, name) \
  1330. DO_TESTCASE_6IRW(desc, name, 123); \
  1331. DO_TESTCASE_6IRW(desc, name, 132); \
  1332. DO_TESTCASE_6IRW(desc, name, 213); \
  1333. DO_TESTCASE_6IRW(desc, name, 231); \
  1334. DO_TESTCASE_6IRW(desc, name, 312); \
  1335. DO_TESTCASE_6IRW(desc, name, 321);
  1336. static void ww_test_fail_acquire(void)
  1337. {
  1338. int ret;
  1339. WWAI(&t);
  1340. t.stamp++;
  1341. ret = WWL(&o, &t);
  1342. if (WARN_ON(!o.ctx) ||
  1343. WARN_ON(ret))
  1344. return;
  1345. /* No lockdep test, pure API */
  1346. ret = WWL(&o, &t);
  1347. WARN_ON(ret != -EALREADY);
  1348. ret = WWT(&o);
  1349. WARN_ON(ret);
  1350. t2 = t;
  1351. t2.stamp++;
  1352. ret = WWL(&o, &t2);
  1353. WARN_ON(ret != -EDEADLK);
  1354. WWU(&o);
  1355. if (WWT(&o))
  1356. WWU(&o);
  1357. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  1358. else
  1359. DEBUG_LOCKS_WARN_ON(1);
  1360. #endif
  1361. }
  1362. static void ww_test_normal(void)
  1363. {
  1364. int ret;
  1365. WWAI(&t);
  1366. /*
  1367. * None of the ww_mutex codepaths should be taken in the 'normal'
  1368. * mutex calls. The easiest way to verify this is by using the
  1369. * normal mutex calls, and making sure o.ctx is unmodified.
  1370. */
  1371. /* mutex_lock (and indirectly, mutex_lock_nested) */
  1372. o.ctx = (void *)~0UL;
  1373. mutex_lock(&o.base);
  1374. mutex_unlock(&o.base);
  1375. WARN_ON(o.ctx != (void *)~0UL);
  1376. /* mutex_lock_interruptible (and *_nested) */
  1377. o.ctx = (void *)~0UL;
  1378. ret = mutex_lock_interruptible(&o.base);
  1379. if (!ret)
  1380. mutex_unlock(&o.base);
  1381. else
  1382. WARN_ON(1);
  1383. WARN_ON(o.ctx != (void *)~0UL);
  1384. /* mutex_lock_killable (and *_nested) */
  1385. o.ctx = (void *)~0UL;
  1386. ret = mutex_lock_killable(&o.base);
  1387. if (!ret)
  1388. mutex_unlock(&o.base);
  1389. else
  1390. WARN_ON(1);
  1391. WARN_ON(o.ctx != (void *)~0UL);
  1392. /* trylock, succeeding */
  1393. o.ctx = (void *)~0UL;
  1394. ret = mutex_trylock(&o.base);
  1395. WARN_ON(!ret);
  1396. if (ret)
  1397. mutex_unlock(&o.base);
  1398. else
  1399. WARN_ON(1);
  1400. WARN_ON(o.ctx != (void *)~0UL);
  1401. /* trylock, failing */
  1402. o.ctx = (void *)~0UL;
  1403. mutex_lock(&o.base);
  1404. ret = mutex_trylock(&o.base);
  1405. WARN_ON(ret);
  1406. mutex_unlock(&o.base);
  1407. WARN_ON(o.ctx != (void *)~0UL);
  1408. /* nest_lock */
  1409. o.ctx = (void *)~0UL;
  1410. mutex_lock_nest_lock(&o.base, &t);
  1411. mutex_unlock(&o.base);
  1412. WARN_ON(o.ctx != (void *)~0UL);
  1413. }
  1414. static void ww_test_two_contexts(void)
  1415. {
  1416. WWAI(&t);
  1417. WWAI(&t2);
  1418. }
  1419. static void ww_test_diff_class(void)
  1420. {
  1421. WWAI(&t);
  1422. #ifdef CONFIG_DEBUG_MUTEXES
  1423. t.ww_class = NULL;
  1424. #endif
  1425. WWL(&o, &t);
  1426. }
  1427. static void ww_test_context_done_twice(void)
  1428. {
  1429. WWAI(&t);
  1430. WWAD(&t);
  1431. WWAD(&t);
  1432. WWAF(&t);
  1433. }
  1434. static void ww_test_context_unlock_twice(void)
  1435. {
  1436. WWAI(&t);
  1437. WWAD(&t);
  1438. WWAF(&t);
  1439. WWAF(&t);
  1440. }
  1441. static void ww_test_context_fini_early(void)
  1442. {
  1443. WWAI(&t);
  1444. WWL(&o, &t);
  1445. WWAD(&t);
  1446. WWAF(&t);
  1447. }
  1448. static void ww_test_context_lock_after_done(void)
  1449. {
  1450. WWAI(&t);
  1451. WWAD(&t);
  1452. WWL(&o, &t);
  1453. }
  1454. static void ww_test_object_unlock_twice(void)
  1455. {
  1456. WWL1(&o);
  1457. WWU(&o);
  1458. WWU(&o);
  1459. }
  1460. static void ww_test_object_lock_unbalanced(void)
  1461. {
  1462. WWAI(&t);
  1463. WWL(&o, &t);
  1464. t.acquired = 0;
  1465. WWU(&o);
  1466. WWAF(&t);
  1467. }
  1468. static void ww_test_object_lock_stale_context(void)
  1469. {
  1470. WWAI(&t);
  1471. o.ctx = &t2;
  1472. WWL(&o, &t);
  1473. }
  1474. static void ww_test_edeadlk_normal(void)
  1475. {
  1476. int ret;
  1477. mutex_lock(&o2.base);
  1478. o2.ctx = &t2;
  1479. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1480. WWAI(&t);
  1481. t2 = t;
  1482. t2.stamp--;
  1483. ret = WWL(&o, &t);
  1484. WARN_ON(ret);
  1485. ret = WWL(&o2, &t);
  1486. WARN_ON(ret != -EDEADLK);
  1487. o2.ctx = NULL;
  1488. mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
  1489. mutex_unlock(&o2.base);
  1490. WWU(&o);
  1491. WWL(&o2, &t);
  1492. }
  1493. static void ww_test_edeadlk_normal_slow(void)
  1494. {
  1495. int ret;
  1496. mutex_lock(&o2.base);
  1497. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1498. o2.ctx = &t2;
  1499. WWAI(&t);
  1500. t2 = t;
  1501. t2.stamp--;
  1502. ret = WWL(&o, &t);
  1503. WARN_ON(ret);
  1504. ret = WWL(&o2, &t);
  1505. WARN_ON(ret != -EDEADLK);
  1506. o2.ctx = NULL;
  1507. mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
  1508. mutex_unlock(&o2.base);
  1509. WWU(&o);
  1510. ww_mutex_lock_slow(&o2, &t);
  1511. }
  1512. static void ww_test_edeadlk_no_unlock(void)
  1513. {
  1514. int ret;
  1515. mutex_lock(&o2.base);
  1516. o2.ctx = &t2;
  1517. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1518. WWAI(&t);
  1519. t2 = t;
  1520. t2.stamp--;
  1521. ret = WWL(&o, &t);
  1522. WARN_ON(ret);
  1523. ret = WWL(&o2, &t);
  1524. WARN_ON(ret != -EDEADLK);
  1525. o2.ctx = NULL;
  1526. mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
  1527. mutex_unlock(&o2.base);
  1528. WWL(&o2, &t);
  1529. }
  1530. static void ww_test_edeadlk_no_unlock_slow(void)
  1531. {
  1532. int ret;
  1533. mutex_lock(&o2.base);
  1534. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1535. o2.ctx = &t2;
  1536. WWAI(&t);
  1537. t2 = t;
  1538. t2.stamp--;
  1539. ret = WWL(&o, &t);
  1540. WARN_ON(ret);
  1541. ret = WWL(&o2, &t);
  1542. WARN_ON(ret != -EDEADLK);
  1543. o2.ctx = NULL;
  1544. mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
  1545. mutex_unlock(&o2.base);
  1546. ww_mutex_lock_slow(&o2, &t);
  1547. }
  1548. static void ww_test_edeadlk_acquire_more(void)
  1549. {
  1550. int ret;
  1551. mutex_lock(&o2.base);
  1552. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1553. o2.ctx = &t2;
  1554. WWAI(&t);
  1555. t2 = t;
  1556. t2.stamp--;
  1557. ret = WWL(&o, &t);
  1558. WARN_ON(ret);
  1559. ret = WWL(&o2, &t);
  1560. WARN_ON(ret != -EDEADLK);
  1561. ret = WWL(&o3, &t);
  1562. }
  1563. static void ww_test_edeadlk_acquire_more_slow(void)
  1564. {
  1565. int ret;
  1566. mutex_lock(&o2.base);
  1567. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1568. o2.ctx = &t2;
  1569. WWAI(&t);
  1570. t2 = t;
  1571. t2.stamp--;
  1572. ret = WWL(&o, &t);
  1573. WARN_ON(ret);
  1574. ret = WWL(&o2, &t);
  1575. WARN_ON(ret != -EDEADLK);
  1576. ww_mutex_lock_slow(&o3, &t);
  1577. }
  1578. static void ww_test_edeadlk_acquire_more_edeadlk(void)
  1579. {
  1580. int ret;
  1581. mutex_lock(&o2.base);
  1582. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1583. o2.ctx = &t2;
  1584. mutex_lock(&o3.base);
  1585. mutex_release(&o3.base.dep_map, _THIS_IP_);
  1586. o3.ctx = &t2;
  1587. WWAI(&t);
  1588. t2 = t;
  1589. t2.stamp--;
  1590. ret = WWL(&o, &t);
  1591. WARN_ON(ret);
  1592. ret = WWL(&o2, &t);
  1593. WARN_ON(ret != -EDEADLK);
  1594. ret = WWL(&o3, &t);
  1595. WARN_ON(ret != -EDEADLK);
  1596. }
  1597. static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
  1598. {
  1599. int ret;
  1600. mutex_lock(&o2.base);
  1601. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1602. o2.ctx = &t2;
  1603. mutex_lock(&o3.base);
  1604. mutex_release(&o3.base.dep_map, _THIS_IP_);
  1605. o3.ctx = &t2;
  1606. WWAI(&t);
  1607. t2 = t;
  1608. t2.stamp--;
  1609. ret = WWL(&o, &t);
  1610. WARN_ON(ret);
  1611. ret = WWL(&o2, &t);
  1612. WARN_ON(ret != -EDEADLK);
  1613. ww_mutex_lock_slow(&o3, &t);
  1614. }
  1615. static void ww_test_edeadlk_acquire_wrong(void)
  1616. {
  1617. int ret;
  1618. mutex_lock(&o2.base);
  1619. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1620. o2.ctx = &t2;
  1621. WWAI(&t);
  1622. t2 = t;
  1623. t2.stamp--;
  1624. ret = WWL(&o, &t);
  1625. WARN_ON(ret);
  1626. ret = WWL(&o2, &t);
  1627. WARN_ON(ret != -EDEADLK);
  1628. if (!ret)
  1629. WWU(&o2);
  1630. WWU(&o);
  1631. ret = WWL(&o3, &t);
  1632. }
  1633. static void ww_test_edeadlk_acquire_wrong_slow(void)
  1634. {
  1635. int ret;
  1636. mutex_lock(&o2.base);
  1637. mutex_release(&o2.base.dep_map, _THIS_IP_);
  1638. o2.ctx = &t2;
  1639. WWAI(&t);
  1640. t2 = t;
  1641. t2.stamp--;
  1642. ret = WWL(&o, &t);
  1643. WARN_ON(ret);
  1644. ret = WWL(&o2, &t);
  1645. WARN_ON(ret != -EDEADLK);
  1646. if (!ret)
  1647. WWU(&o2);
  1648. WWU(&o);
  1649. ww_mutex_lock_slow(&o3, &t);
  1650. }
  1651. static void ww_test_spin_nest_unlocked(void)
  1652. {
  1653. raw_spin_lock_nest_lock(&lock_A, &o.base);
  1654. U(A);
  1655. }
  1656. static void ww_test_unneeded_slow(void)
  1657. {
  1658. WWAI(&t);
  1659. ww_mutex_lock_slow(&o, &t);
  1660. }
  1661. static void ww_test_context_block(void)
  1662. {
  1663. int ret;
  1664. WWAI(&t);
  1665. ret = WWL(&o, &t);
  1666. WARN_ON(ret);
  1667. WWL1(&o2);
  1668. }
  1669. static void ww_test_context_try(void)
  1670. {
  1671. int ret;
  1672. WWAI(&t);
  1673. ret = WWL(&o, &t);
  1674. WARN_ON(ret);
  1675. ret = WWT(&o2);
  1676. WARN_ON(!ret);
  1677. WWU(&o2);
  1678. WWU(&o);
  1679. }
  1680. static void ww_test_context_context(void)
  1681. {
  1682. int ret;
  1683. WWAI(&t);
  1684. ret = WWL(&o, &t);
  1685. WARN_ON(ret);
  1686. ret = WWL(&o2, &t);
  1687. WARN_ON(ret);
  1688. WWU(&o2);
  1689. WWU(&o);
  1690. }
  1691. static void ww_test_try_block(void)
  1692. {
  1693. bool ret;
  1694. ret = WWT(&o);
  1695. WARN_ON(!ret);
  1696. WWL1(&o2);
  1697. WWU(&o2);
  1698. WWU(&o);
  1699. }
  1700. static void ww_test_try_try(void)
  1701. {
  1702. bool ret;
  1703. ret = WWT(&o);
  1704. WARN_ON(!ret);
  1705. ret = WWT(&o2);
  1706. WARN_ON(!ret);
  1707. WWU(&o2);
  1708. WWU(&o);
  1709. }
  1710. static void ww_test_try_context(void)
  1711. {
  1712. int ret;
  1713. ret = WWT(&o);
  1714. WARN_ON(!ret);
  1715. WWAI(&t);
  1716. ret = WWL(&o2, &t);
  1717. WARN_ON(ret);
  1718. }
  1719. static void ww_test_block_block(void)
  1720. {
  1721. WWL1(&o);
  1722. WWL1(&o2);
  1723. }
  1724. static void ww_test_block_try(void)
  1725. {
  1726. bool ret;
  1727. WWL1(&o);
  1728. ret = WWT(&o2);
  1729. WARN_ON(!ret);
  1730. }
  1731. static void ww_test_block_context(void)
  1732. {
  1733. int ret;
  1734. WWL1(&o);
  1735. WWAI(&t);
  1736. ret = WWL(&o2, &t);
  1737. WARN_ON(ret);
  1738. }
  1739. static void ww_test_spin_block(void)
  1740. {
  1741. L(A);
  1742. U(A);
  1743. WWL1(&o);
  1744. L(A);
  1745. U(A);
  1746. WWU(&o);
  1747. L(A);
  1748. WWL1(&o);
  1749. WWU(&o);
  1750. U(A);
  1751. }
  1752. static void ww_test_spin_try(void)
  1753. {
  1754. bool ret;
  1755. L(A);
  1756. U(A);
  1757. ret = WWT(&o);
  1758. WARN_ON(!ret);
  1759. L(A);
  1760. U(A);
  1761. WWU(&o);
  1762. L(A);
  1763. ret = WWT(&o);
  1764. WARN_ON(!ret);
  1765. WWU(&o);
  1766. U(A);
  1767. }
  1768. static void ww_test_spin_context(void)
  1769. {
  1770. int ret;
  1771. L(A);
  1772. U(A);
  1773. WWAI(&t);
  1774. ret = WWL(&o, &t);
  1775. WARN_ON(ret);
  1776. L(A);
  1777. U(A);
  1778. WWU(&o);
  1779. L(A);
  1780. ret = WWL(&o, &t);
  1781. WARN_ON(ret);
  1782. WWU(&o);
  1783. U(A);
  1784. }
  1785. static void ww_tests(void)
  1786. {
  1787. printk(" --------------------------------------------------------------------------\n");
  1788. printk(" | Wound/wait tests |\n");
  1789. printk(" ---------------------\n");
  1790. print_testname("ww api failures");
  1791. dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);
  1792. dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
  1793. dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
  1794. pr_cont("\n");
  1795. print_testname("ww contexts mixing");
  1796. dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
  1797. dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
  1798. pr_cont("\n");
  1799. print_testname("finishing ww context");
  1800. dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
  1801. dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);
  1802. dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);
  1803. dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
  1804. pr_cont("\n");
  1805. print_testname("locking mismatches");
  1806. dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
  1807. dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
  1808. dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
  1809. pr_cont("\n");
  1810. print_testname("EDEADLK handling");
  1811. dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
  1812. dotest(ww_test_edeadlk_normal_slow, SUCCESS, LOCKTYPE_WW);
  1813. dotest(ww_test_edeadlk_no_unlock, FAILURE, LOCKTYPE_WW);
  1814. dotest(ww_test_edeadlk_no_unlock_slow, FAILURE, LOCKTYPE_WW);
  1815. dotest(ww_test_edeadlk_acquire_more, FAILURE, LOCKTYPE_WW);
  1816. dotest(ww_test_edeadlk_acquire_more_slow, FAILURE, LOCKTYPE_WW);
  1817. dotest(ww_test_edeadlk_acquire_more_edeadlk, FAILURE, LOCKTYPE_WW);
  1818. dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
  1819. dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
  1820. dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
  1821. pr_cont("\n");
  1822. print_testname("spinlock nest unlocked");
  1823. dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
  1824. pr_cont("\n");
  1825. printk(" -----------------------------------------------------\n");
  1826. printk(" |block | try |context|\n");
  1827. printk(" -----------------------------------------------------\n");
  1828. print_testname("context");
  1829. dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);
  1830. dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
  1831. dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
  1832. pr_cont("\n");
  1833. print_testname("try");
  1834. dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
  1835. dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
  1836. dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
  1837. pr_cont("\n");
  1838. print_testname("block");
  1839. dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
  1840. dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
  1841. dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
  1842. pr_cont("\n");
  1843. print_testname("spinlock");
  1844. dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
  1845. dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
  1846. dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
  1847. pr_cont("\n");
  1848. }
  1849. /*
  1850. * <in hardirq handler>
  1851. * read_lock(&A);
  1852. * <hardirq disable>
  1853. * spin_lock(&B);
  1854. * spin_lock(&B);
  1855. * read_lock(&A);
  1856. *
  1857. * is a deadlock.
  1858. */
  1859. static void queued_read_lock_hardirq_RE_Er(void)
  1860. {
  1861. HARDIRQ_ENTER();
  1862. read_lock(&rwlock_A);
  1863. LOCK(B);
  1864. UNLOCK(B);
  1865. read_unlock(&rwlock_A);
  1866. HARDIRQ_EXIT();
  1867. HARDIRQ_DISABLE();
  1868. LOCK(B);
  1869. read_lock(&rwlock_A);
  1870. read_unlock(&rwlock_A);
  1871. UNLOCK(B);
  1872. HARDIRQ_ENABLE();
  1873. }
  1874. /*
  1875. * <in hardirq handler>
  1876. * spin_lock(&B);
  1877. * <hardirq disable>
  1878. * read_lock(&A);
  1879. * read_lock(&A);
  1880. * spin_lock(&B);
  1881. *
  1882. * is not a deadlock.
  1883. */
  1884. static void queued_read_lock_hardirq_ER_rE(void)
  1885. {
  1886. HARDIRQ_ENTER();
  1887. LOCK(B);
  1888. read_lock(&rwlock_A);
  1889. read_unlock(&rwlock_A);
  1890. UNLOCK(B);
  1891. HARDIRQ_EXIT();
  1892. HARDIRQ_DISABLE();
  1893. read_lock(&rwlock_A);
  1894. LOCK(B);
  1895. UNLOCK(B);
  1896. read_unlock(&rwlock_A);
  1897. HARDIRQ_ENABLE();
  1898. }
  1899. /*
  1900. * <hardirq disable>
  1901. * spin_lock(&B);
  1902. * read_lock(&A);
  1903. * <in hardirq handler>
  1904. * spin_lock(&B);
  1905. * read_lock(&A);
  1906. *
  1907. * is a deadlock. Because the two read_lock()s are both non-recursive readers.
  1908. */
  1909. static void queued_read_lock_hardirq_inversion(void)
  1910. {
  1911. HARDIRQ_ENTER();
  1912. LOCK(B);
  1913. UNLOCK(B);
  1914. HARDIRQ_EXIT();
  1915. HARDIRQ_DISABLE();
  1916. LOCK(B);
  1917. read_lock(&rwlock_A);
  1918. read_unlock(&rwlock_A);
  1919. UNLOCK(B);
  1920. HARDIRQ_ENABLE();
  1921. read_lock(&rwlock_A);
  1922. read_unlock(&rwlock_A);
  1923. }
  1924. static void queued_read_lock_tests(void)
  1925. {
  1926. printk(" --------------------------------------------------------------------------\n");
  1927. printk(" | queued read lock tests |\n");
  1928. printk(" ---------------------------\n");
  1929. print_testname("hardirq read-lock/lock-read");
  1930. dotest(queued_read_lock_hardirq_RE_Er, FAILURE, LOCKTYPE_RWLOCK);
  1931. pr_cont("\n");
  1932. print_testname("hardirq lock-read/read-lock");
  1933. dotest(queued_read_lock_hardirq_ER_rE, SUCCESS, LOCKTYPE_RWLOCK);
  1934. pr_cont("\n");
  1935. print_testname("hardirq inversion");
  1936. dotest(queued_read_lock_hardirq_inversion, FAILURE, LOCKTYPE_RWLOCK);
  1937. pr_cont("\n");
  1938. }
  1939. void locking_selftest(void)
  1940. {
  1941. /*
  1942. * Got a locking failure before the selftest ran?
  1943. */
  1944. if (!debug_locks) {
  1945. printk("----------------------------------\n");
  1946. printk("| Locking API testsuite disabled |\n");
  1947. printk("----------------------------------\n");
  1948. return;
  1949. }
  1950. /*
  1951. * treats read_lock() as recursive read locks for testing purpose
  1952. */
  1953. force_read_lock_recursive = 1;
  1954. /*
  1955. * Run the testsuite:
  1956. */
  1957. printk("------------------------\n");
  1958. printk("| Locking API testsuite:\n");
  1959. printk("----------------------------------------------------------------------------\n");
  1960. printk(" | spin |wlock |rlock |mutex | wsem | rsem |\n");
  1961. printk(" --------------------------------------------------------------------------\n");
  1962. init_shared_classes();
  1963. debug_locks_silent = !debug_locks_verbose;
  1964. lockdep_set_selftest_task(current);
  1965. DO_TESTCASE_6R("A-A deadlock", AA);
  1966. DO_TESTCASE_6R("A-B-B-A deadlock", ABBA);
  1967. DO_TESTCASE_6R("A-B-B-C-C-A deadlock", ABBCCA);
  1968. DO_TESTCASE_6R("A-B-C-A-B-C deadlock", ABCABC);
  1969. DO_TESTCASE_6R("A-B-B-C-C-D-D-A deadlock", ABBCCDDA);
  1970. DO_TESTCASE_6R("A-B-C-D-B-D-D-A deadlock", ABCDBDDA);
  1971. DO_TESTCASE_6R("A-B-C-D-B-C-D-A deadlock", ABCDBCDA);
  1972. DO_TESTCASE_6("double unlock", double_unlock);
  1973. DO_TESTCASE_6("initialize held", init_held);
  1974. printk(" --------------------------------------------------------------------------\n");
  1975. print_testname("recursive read-lock");
  1976. pr_cont(" |");
  1977. dotest(rlock_AA1, SUCCESS, LOCKTYPE_RWLOCK);
  1978. pr_cont(" |");
  1979. dotest(rsem_AA1, FAILURE, LOCKTYPE_RWSEM);
  1980. pr_cont("\n");
  1981. print_testname("recursive read-lock #2");
  1982. pr_cont(" |");
  1983. dotest(rlock_AA1B, SUCCESS, LOCKTYPE_RWLOCK);
  1984. pr_cont(" |");
  1985. dotest(rsem_AA1B, FAILURE, LOCKTYPE_RWSEM);
  1986. pr_cont("\n");
  1987. print_testname("mixed read-write-lock");
  1988. pr_cont(" |");
  1989. dotest(rlock_AA2, FAILURE, LOCKTYPE_RWLOCK);
  1990. pr_cont(" |");
  1991. dotest(rsem_AA2, FAILURE, LOCKTYPE_RWSEM);
  1992. pr_cont("\n");
  1993. print_testname("mixed write-read-lock");
  1994. pr_cont(" |");
  1995. dotest(rlock_AA3, FAILURE, LOCKTYPE_RWLOCK);
  1996. pr_cont(" |");
  1997. dotest(rsem_AA3, FAILURE, LOCKTYPE_RWSEM);
  1998. pr_cont("\n");
  1999. print_testname("mixed read-lock/lock-write ABBA");
  2000. pr_cont(" |");
  2001. dotest(rlock_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
  2002. pr_cont(" |");
  2003. dotest(rwsem_ABBA1, FAILURE, LOCKTYPE_RWSEM);
  2004. print_testname("mixed read-lock/lock-read ABBA");
  2005. pr_cont(" |");
  2006. dotest(rlock_ABBA2, SUCCESS, LOCKTYPE_RWLOCK);
  2007. pr_cont(" |");
  2008. dotest(rwsem_ABBA2, FAILURE, LOCKTYPE_RWSEM);
  2009. print_testname("mixed write-lock/lock-write ABBA");
  2010. pr_cont(" |");
  2011. dotest(rlock_ABBA3, FAILURE, LOCKTYPE_RWLOCK);
  2012. pr_cont(" |");
  2013. dotest(rwsem_ABBA3, FAILURE, LOCKTYPE_RWSEM);
  2014. print_testname("chain cached mixed R-L/L-W ABBA");
  2015. pr_cont(" |");
  2016. dotest(rlock_chaincache_ABBA1, FAILURE, LOCKTYPE_RWLOCK);
  2017. DO_TESTCASE_6x1RRB("rlock W1R2/W2R3/W3R1", W1R2_W2R3_W3R1);
  2018. DO_TESTCASE_6x1RRB("rlock W1W2/R2R3/W3R1", W1W2_R2R3_W3R1);
  2019. DO_TESTCASE_6x1RR("rlock W1W2/R2R3/R3W1", W1W2_R2R3_R3W1);
  2020. DO_TESTCASE_6x1RR("rlock W1R2/R2R3/W3W1", W1R2_R2R3_W3W1);
  2021. printk(" --------------------------------------------------------------------------\n");
  2022. /*
  2023. * irq-context testcases:
  2024. */
  2025. DO_TESTCASE_2x6("irqs-on + irq-safe-A", irqsafe1);
  2026. DO_TESTCASE_2x3("sirq-safe-A => hirqs-on", irqsafe2A);
  2027. DO_TESTCASE_2x6("safe-A + irqs-on", irqsafe2B);
  2028. DO_TESTCASE_6x6("safe-A + unsafe-B #1", irqsafe3);
  2029. DO_TESTCASE_6x6("safe-A + unsafe-B #2", irqsafe4);
  2030. DO_TESTCASE_6x6RW("irq lock-inversion", irq_inversion);
  2031. DO_TESTCASE_6x2x2RW("irq read-recursion", irq_read_recursion);
  2032. DO_TESTCASE_6x2x2RW("irq read-recursion #2", irq_read_recursion2);
  2033. DO_TESTCASE_6x2x2RW("irq read-recursion #3", irq_read_recursion3);
  2034. ww_tests();
  2035. force_read_lock_recursive = 0;
  2036. /*
  2037. * queued_read_lock() specific test cases can be put here
  2038. */
  2039. if (IS_ENABLED(CONFIG_QUEUED_RWLOCKS))
  2040. queued_read_lock_tests();
  2041. if (unexpected_testcase_failures) {
  2042. printk("-----------------------------------------------------------------\n");
  2043. debug_locks = 0;
  2044. printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
  2045. unexpected_testcase_failures, testcase_total);
  2046. printk("-----------------------------------------------------------------\n");
  2047. } else if (expected_testcase_failures && testcase_successes) {
  2048. printk("--------------------------------------------------------\n");
  2049. printk("%3d out of %3d testcases failed, as expected. |\n",
  2050. expected_testcase_failures, testcase_total);
  2051. printk("----------------------------------------------------\n");
  2052. debug_locks = 1;
  2053. } else if (expected_testcase_failures && !testcase_successes) {
  2054. printk("--------------------------------------------------------\n");
  2055. printk("All %3d testcases failed, as expected. |\n",
  2056. expected_testcase_failures);
  2057. printk("----------------------------------------\n");
  2058. debug_locks = 1;
  2059. } else {
  2060. printk("-------------------------------------------------------\n");
  2061. printk("Good, all %3d testcases passed! |\n",
  2062. testcase_successes);
  2063. printk("---------------------------------\n");
  2064. debug_locks = 1;
  2065. }
  2066. lockdep_set_selftest_task(NULL);
  2067. debug_locks_silent = 0;
  2068. }