locking/spinlocks: Mark spinlocks noinline when inline spinlocks are disabled

Andi Kleen · ingomolnar · commit 9aeaf5bc4e30 · 2022-08-04T11:05:43.000+02:00
Otherwise LTO will inline them anyways and cause a large kernel text increase. Since the explicit intention here is to not inline them marking them noinline is good documentation even for the non-LTO case. Signed-off-by: Andi Kleen <ak@linux.intel.com> Signed-off-by: Martin Liska <mliska@suse.cz> Signed-off-by: Jiri Slaby <jslaby@suse.cz> Signed-off-by: Ingo Molnar <mingo@kernel.org> Link: https://lore.kernel.org/r/20220719110548.1544-1-jslaby@suse.cz
diff --git a/kernel/locking/spinlock.c b/kernel/locking/spinlock.c
@@ -133,79 +133,79 @@ BUILD_LOCK_OPS(write, rwlock);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_TRYLOCK
-int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock)
+noinline int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock)
 {
 	return __raw_spin_trylock(lock);
 }
 EXPORT_SYMBOL(_raw_spin_trylock);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_TRYLOCK_BH
-int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock)
+noinline int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock)
 {
 	return __raw_spin_trylock_bh(lock);
 }
 EXPORT_SYMBOL(_raw_spin_trylock_bh);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_LOCK
-void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)
+noinline void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)
 {
 	__raw_spin_lock(lock);
 }
 EXPORT_SYMBOL(_raw_spin_lock);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_LOCK_IRQSAVE
-unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
+noinline unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)
 {
 	return __raw_spin_lock_irqsave(lock);
 }
 EXPORT_SYMBOL(_raw_spin_lock_irqsave);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_LOCK_IRQ
-void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
+noinline void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)
 {
 	__raw_spin_lock_irq(lock);
 }
 EXPORT_SYMBOL(_raw_spin_lock_irq);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_LOCK_BH
-void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)
+noinline void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)
 {
 	__raw_spin_lock_bh(lock);
 }
 EXPORT_SYMBOL(_raw_spin_lock_bh);
 #endif
 
 #ifdef CONFIG_UNINLINE_SPIN_UNLOCK
-void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)
+noinline void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)
 {
 	__raw_spin_unlock(lock);
 }
 EXPORT_SYMBOL(_raw_spin_unlock);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE
-void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
+noinline void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
 {
 	__raw_spin_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(_raw_spin_unlock_irqrestore);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQ
-void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)
+noinline void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)
 {
 	__raw_spin_unlock_irq(lock);
 }
 EXPORT_SYMBOL(_raw_spin_unlock_irq);
 #endif
 
 #ifndef CONFIG_INLINE_SPIN_UNLOCK_BH
-void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)
+noinline void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)
 {
 	__raw_spin_unlock_bh(lock);
 }
@@ -215,87 +215,87 @@ EXPORT_SYMBOL(_raw_spin_unlock_bh);
 #ifndef CONFIG_PREEMPT_RT
 
 #ifndef CONFIG_INLINE_READ_TRYLOCK
-int __lockfunc _raw_read_trylock(rwlock_t *lock)
+noinline int __lockfunc _raw_read_trylock(rwlock_t *lock)
 {
 	return __raw_read_trylock(lock);
 }
 EXPORT_SYMBOL(_raw_read_trylock);
 #endif
 
 #ifndef CONFIG_INLINE_READ_LOCK
-void __lockfunc _raw_read_lock(rwlock_t *lock)
+noinline void __lockfunc _raw_read_lock(rwlock_t *lock)
 {
 	__raw_read_lock(lock);
 }
 EXPORT_SYMBOL(_raw_read_lock);
 #endif
 
 #ifndef CONFIG_INLINE_READ_LOCK_IRQSAVE
-unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
+noinline unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)
 {
 	return __raw_read_lock_irqsave(lock);
 }
 EXPORT_SYMBOL(_raw_read_lock_irqsave);
 #endif
 
 #ifndef CONFIG_INLINE_READ_LOCK_IRQ
-void __lockfunc _raw_read_lock_irq(rwlock_t *lock)
+noinline void __lockfunc _raw_read_lock_irq(rwlock_t *lock)
 {
 	__raw_read_lock_irq(lock);
 }
 EXPORT_SYMBOL(_raw_read_lock_irq);
 #endif
 
 #ifndef CONFIG_INLINE_READ_LOCK_BH
-void __lockfunc _raw_read_lock_bh(rwlock_t *lock)
+noinline void __lockfunc _raw_read_lock_bh(rwlock_t *lock)
 {
 	__raw_read_lock_bh(lock);
 }
 EXPORT_SYMBOL(_raw_read_lock_bh);
 #endif
 
 #ifndef CONFIG_INLINE_READ_UNLOCK
-void __lockfunc _raw_read_unlock(rwlock_t *lock)
+noinline void __lockfunc _raw_read_unlock(rwlock_t *lock)
 {
 	__raw_read_unlock(lock);
 }
 EXPORT_SYMBOL(_raw_read_unlock);
 #endif
 
 #ifndef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE
-void __lockfunc _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+noinline void __lockfunc _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 {
 	__raw_read_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(_raw_read_unlock_irqrestore);
 #endif
 
 #ifndef CONFIG_INLINE_READ_UNLOCK_IRQ
-void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)
+noinline void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)
 {
 	__raw_read_unlock_irq(lock);
 }
 EXPORT_SYMBOL(_raw_read_unlock_irq);
 #endif
 
 #ifndef CONFIG_INLINE_READ_UNLOCK_BH
-void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)
+noinline void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)
 {
 	__raw_read_unlock_bh(lock);
 }
 EXPORT_SYMBOL(_raw_read_unlock_bh);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_TRYLOCK
-int __lockfunc _raw_write_trylock(rwlock_t *lock)
+noinline int __lockfunc _raw_write_trylock(rwlock_t *lock)
 {
 	return __raw_write_trylock(lock);
 }
 EXPORT_SYMBOL(_raw_write_trylock);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_LOCK
-void __lockfunc _raw_write_lock(rwlock_t *lock)
+noinline void __lockfunc _raw_write_lock(rwlock_t *lock)
 {
 	__raw_write_lock(lock);
 }
@@ -313,55 +313,55 @@ EXPORT_SYMBOL(_raw_write_lock_nested);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_LOCK_IRQSAVE
-unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
+noinline unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)
 {
 	return __raw_write_lock_irqsave(lock);
 }
 EXPORT_SYMBOL(_raw_write_lock_irqsave);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_LOCK_IRQ
-void __lockfunc _raw_write_lock_irq(rwlock_t *lock)
+noinline void __lockfunc _raw_write_lock_irq(rwlock_t *lock)
 {
 	__raw_write_lock_irq(lock);
 }
 EXPORT_SYMBOL(_raw_write_lock_irq);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_LOCK_BH
-void __lockfunc _raw_write_lock_bh(rwlock_t *lock)
+noinline void __lockfunc _raw_write_lock_bh(rwlock_t *lock)
 {
 	__raw_write_lock_bh(lock);
 }
 EXPORT_SYMBOL(_raw_write_lock_bh);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_UNLOCK
-void __lockfunc _raw_write_unlock(rwlock_t *lock)
+noinline void __lockfunc _raw_write_unlock(rwlock_t *lock)
 {
 	__raw_write_unlock(lock);
 }
 EXPORT_SYMBOL(_raw_write_unlock);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE
-void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
+noinline void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 {
 	__raw_write_unlock_irqrestore(lock, flags);
 }
 EXPORT_SYMBOL(_raw_write_unlock_irqrestore);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQ
-void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)
+noinline void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)
 {
 	__raw_write_unlock_irq(lock);
 }
 EXPORT_SYMBOL(_raw_write_unlock_irq);
 #endif
 
 #ifndef CONFIG_INLINE_WRITE_UNLOCK_BH
-void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)
+noinline void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)
 {
 	__raw_write_unlock_bh(lock);
 }

Original file line number	Diff line number	Diff line change
`@@ -133,79 +133,79 @@ BUILD_LOCK_OPS(write, rwlock);`
`133`	`133`	`#endif`
`134`	`134`
`135`	`135`	`#ifndef CONFIG_INLINE_SPIN_TRYLOCK`
`136`		`-int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock)`
	`136`	`+noinline int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock)`
`137`	`137`	`{`
`138`	`138`	`return __raw_spin_trylock(lock);`
`139`	`139`	`}`
`140`	`140`	`EXPORT_SYMBOL(_raw_spin_trylock);`
`141`	`141`	`#endif`
`142`	`142`
`143`	`143`	`#ifndef CONFIG_INLINE_SPIN_TRYLOCK_BH`
`144`		`-int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock)`
	`144`	`+noinline int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock)`
`145`	`145`	`{`
`146`	`146`	`return __raw_spin_trylock_bh(lock);`
`147`	`147`	`}`
`148`	`148`	`EXPORT_SYMBOL(_raw_spin_trylock_bh);`
`149`	`149`	`#endif`
`150`	`150`
`151`	`151`	`#ifndef CONFIG_INLINE_SPIN_LOCK`
`152`		`-void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)`
	`152`	`+noinline void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)`
`153`	`153`	`{`
`154`	`154`	`__raw_spin_lock(lock);`
`155`	`155`	`}`
`156`	`156`	`EXPORT_SYMBOL(_raw_spin_lock);`
`157`	`157`	`#endif`
`158`	`158`
`159`	`159`	`#ifndef CONFIG_INLINE_SPIN_LOCK_IRQSAVE`
`160`		`-unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)`
	`160`	`+noinline unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock)`
`161`	`161`	`{`
`162`	`162`	`return __raw_spin_lock_irqsave(lock);`
`163`	`163`	`}`
`164`	`164`	`EXPORT_SYMBOL(_raw_spin_lock_irqsave);`
`165`	`165`	`#endif`
`166`	`166`
`167`	`167`	`#ifndef CONFIG_INLINE_SPIN_LOCK_IRQ`
`168`		`-void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)`
	`168`	`+noinline void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock)`
`169`	`169`	`{`
`170`	`170`	`__raw_spin_lock_irq(lock);`
`171`	`171`	`}`
`172`	`172`	`EXPORT_SYMBOL(_raw_spin_lock_irq);`
`173`	`173`	`#endif`
`174`	`174`
`175`	`175`	`#ifndef CONFIG_INLINE_SPIN_LOCK_BH`
`176`		`-void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)`
	`176`	`+noinline void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock)`
`177`	`177`	`{`
`178`	`178`	`__raw_spin_lock_bh(lock);`
`179`	`179`	`}`
`180`	`180`	`EXPORT_SYMBOL(_raw_spin_lock_bh);`
`181`	`181`	`#endif`
`182`	`182`
`183`	`183`	`#ifdef CONFIG_UNINLINE_SPIN_UNLOCK`
`184`		`-void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)`
	`184`	`+noinline void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock)`
`185`	`185`	`{`
`186`	`186`	`__raw_spin_unlock(lock);`
`187`	`187`	`}`
`188`	`188`	`EXPORT_SYMBOL(_raw_spin_unlock);`
`189`	`189`	`#endif`
`190`	`190`
`191`	`191`	`#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQRESTORE`
`192`		`-void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)`
	`192`	`+noinline void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)`
`193`	`193`	`{`
`194`	`194`	`__raw_spin_unlock_irqrestore(lock, flags);`
`195`	`195`	`}`
`196`	`196`	`EXPORT_SYMBOL(_raw_spin_unlock_irqrestore);`
`197`	`197`	`#endif`
`198`	`198`
`199`	`199`	`#ifndef CONFIG_INLINE_SPIN_UNLOCK_IRQ`
`200`		`-void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)`
	`200`	`+noinline void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock)`
`201`	`201`	`{`
`202`	`202`	`__raw_spin_unlock_irq(lock);`
`203`	`203`	`}`
`204`	`204`	`EXPORT_SYMBOL(_raw_spin_unlock_irq);`
`205`	`205`	`#endif`
`206`	`206`
`207`	`207`	`#ifndef CONFIG_INLINE_SPIN_UNLOCK_BH`
`208`		`-void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)`
	`208`	`+noinline void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock)`
`209`	`209`	`{`
`210`	`210`	`__raw_spin_unlock_bh(lock);`
`211`	`211`	`}`
`@@ -215,87 +215,87 @@ EXPORT_SYMBOL(_raw_spin_unlock_bh);`
`215`	`215`	`#ifndef CONFIG_PREEMPT_RT`
`216`	`216`
`217`	`217`	`#ifndef CONFIG_INLINE_READ_TRYLOCK`
`218`		`-int __lockfunc _raw_read_trylock(rwlock_t *lock)`
	`218`	`+noinline int __lockfunc _raw_read_trylock(rwlock_t *lock)`
`219`	`219`	`{`
`220`	`220`	`return __raw_read_trylock(lock);`
`221`	`221`	`}`
`222`	`222`	`EXPORT_SYMBOL(_raw_read_trylock);`
`223`	`223`	`#endif`
`224`	`224`
`225`	`225`	`#ifndef CONFIG_INLINE_READ_LOCK`
`226`		`-void __lockfunc _raw_read_lock(rwlock_t *lock)`
	`226`	`+noinline void __lockfunc _raw_read_lock(rwlock_t *lock)`
`227`	`227`	`{`
`228`	`228`	`__raw_read_lock(lock);`
`229`	`229`	`}`
`230`	`230`	`EXPORT_SYMBOL(_raw_read_lock);`
`231`	`231`	`#endif`
`232`	`232`
`233`	`233`	`#ifndef CONFIG_INLINE_READ_LOCK_IRQSAVE`
`234`		`-unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)`
	`234`	`+noinline unsigned long __lockfunc _raw_read_lock_irqsave(rwlock_t *lock)`
`235`	`235`	`{`
`236`	`236`	`return __raw_read_lock_irqsave(lock);`
`237`	`237`	`}`
`238`	`238`	`EXPORT_SYMBOL(_raw_read_lock_irqsave);`
`239`	`239`	`#endif`
`240`	`240`
`241`	`241`	`#ifndef CONFIG_INLINE_READ_LOCK_IRQ`
`242`		`-void __lockfunc _raw_read_lock_irq(rwlock_t *lock)`
	`242`	`+noinline void __lockfunc _raw_read_lock_irq(rwlock_t *lock)`
`243`	`243`	`{`
`244`	`244`	`__raw_read_lock_irq(lock);`
`245`	`245`	`}`
`246`	`246`	`EXPORT_SYMBOL(_raw_read_lock_irq);`
`247`	`247`	`#endif`
`248`	`248`
`249`	`249`	`#ifndef CONFIG_INLINE_READ_LOCK_BH`
`250`		`-void __lockfunc _raw_read_lock_bh(rwlock_t *lock)`
	`250`	`+noinline void __lockfunc _raw_read_lock_bh(rwlock_t *lock)`
`251`	`251`	`{`
`252`	`252`	`__raw_read_lock_bh(lock);`
`253`	`253`	`}`
`254`	`254`	`EXPORT_SYMBOL(_raw_read_lock_bh);`
`255`	`255`	`#endif`
`256`	`256`
`257`	`257`	`#ifndef CONFIG_INLINE_READ_UNLOCK`
`258`		`-void __lockfunc _raw_read_unlock(rwlock_t *lock)`
	`258`	`+noinline void __lockfunc _raw_read_unlock(rwlock_t *lock)`
`259`	`259`	`{`
`260`	`260`	`__raw_read_unlock(lock);`
`261`	`261`	`}`
`262`	`262`	`EXPORT_SYMBOL(_raw_read_unlock);`
`263`	`263`	`#endif`
`264`	`264`
`265`	`265`	`#ifndef CONFIG_INLINE_READ_UNLOCK_IRQRESTORE`
`266`		`-void __lockfunc _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)`
	`266`	`+noinline void __lockfunc _raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)`
`267`	`267`	`{`
`268`	`268`	`__raw_read_unlock_irqrestore(lock, flags);`
`269`	`269`	`}`
`270`	`270`	`EXPORT_SYMBOL(_raw_read_unlock_irqrestore);`
`271`	`271`	`#endif`
`272`	`272`
`273`	`273`	`#ifndef CONFIG_INLINE_READ_UNLOCK_IRQ`
`274`		`-void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)`
	`274`	`+noinline void __lockfunc _raw_read_unlock_irq(rwlock_t *lock)`
`275`	`275`	`{`
`276`	`276`	`__raw_read_unlock_irq(lock);`
`277`	`277`	`}`
`278`	`278`	`EXPORT_SYMBOL(_raw_read_unlock_irq);`
`279`	`279`	`#endif`
`280`	`280`
`281`	`281`	`#ifndef CONFIG_INLINE_READ_UNLOCK_BH`
`282`		`-void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)`
	`282`	`+noinline void __lockfunc _raw_read_unlock_bh(rwlock_t *lock)`
`283`	`283`	`{`
`284`	`284`	`__raw_read_unlock_bh(lock);`
`285`	`285`	`}`
`286`	`286`	`EXPORT_SYMBOL(_raw_read_unlock_bh);`
`287`	`287`	`#endif`
`288`	`288`
`289`	`289`	`#ifndef CONFIG_INLINE_WRITE_TRYLOCK`
`290`		`-int __lockfunc _raw_write_trylock(rwlock_t *lock)`
	`290`	`+noinline int __lockfunc _raw_write_trylock(rwlock_t *lock)`
`291`	`291`	`{`
`292`	`292`	`return __raw_write_trylock(lock);`
`293`	`293`	`}`
`294`	`294`	`EXPORT_SYMBOL(_raw_write_trylock);`
`295`	`295`	`#endif`
`296`	`296`
`297`	`297`	`#ifndef CONFIG_INLINE_WRITE_LOCK`
`298`		`-void __lockfunc _raw_write_lock(rwlock_t *lock)`
	`298`	`+noinline void __lockfunc _raw_write_lock(rwlock_t *lock)`
`299`	`299`	`{`
`300`	`300`	`__raw_write_lock(lock);`
`301`	`301`	`}`
`@@ -313,55 +313,55 @@ EXPORT_SYMBOL(_raw_write_lock_nested);`
`313`	`313`	`#endif`
`314`	`314`
`315`	`315`	`#ifndef CONFIG_INLINE_WRITE_LOCK_IRQSAVE`
`316`		`-unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)`
	`316`	`+noinline unsigned long __lockfunc _raw_write_lock_irqsave(rwlock_t *lock)`
`317`	`317`	`{`
`318`	`318`	`return __raw_write_lock_irqsave(lock);`
`319`	`319`	`}`
`320`	`320`	`EXPORT_SYMBOL(_raw_write_lock_irqsave);`
`321`	`321`	`#endif`
`322`	`322`
`323`	`323`	`#ifndef CONFIG_INLINE_WRITE_LOCK_IRQ`
`324`		`-void __lockfunc _raw_write_lock_irq(rwlock_t *lock)`
	`324`	`+noinline void __lockfunc _raw_write_lock_irq(rwlock_t *lock)`
`325`	`325`	`{`
`326`	`326`	`__raw_write_lock_irq(lock);`
`327`	`327`	`}`
`328`	`328`	`EXPORT_SYMBOL(_raw_write_lock_irq);`
`329`	`329`	`#endif`
`330`	`330`
`331`	`331`	`#ifndef CONFIG_INLINE_WRITE_LOCK_BH`
`332`		`-void __lockfunc _raw_write_lock_bh(rwlock_t *lock)`
	`332`	`+noinline void __lockfunc _raw_write_lock_bh(rwlock_t *lock)`
`333`	`333`	`{`
`334`	`334`	`__raw_write_lock_bh(lock);`
`335`	`335`	`}`
`336`	`336`	`EXPORT_SYMBOL(_raw_write_lock_bh);`
`337`	`337`	`#endif`
`338`	`338`
`339`	`339`	`#ifndef CONFIG_INLINE_WRITE_UNLOCK`
`340`		`-void __lockfunc _raw_write_unlock(rwlock_t *lock)`
	`340`	`+noinline void __lockfunc _raw_write_unlock(rwlock_t *lock)`
`341`	`341`	`{`
`342`	`342`	`__raw_write_unlock(lock);`
`343`	`343`	`}`
`344`	`344`	`EXPORT_SYMBOL(_raw_write_unlock);`
`345`	`345`	`#endif`
`346`	`346`
`347`	`347`	`#ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQRESTORE`
`348`		`-void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)`
	`348`	`+noinline void __lockfunc _raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)`
`349`	`349`	`{`
`350`	`350`	`__raw_write_unlock_irqrestore(lock, flags);`
`351`	`351`	`}`
`352`	`352`	`EXPORT_SYMBOL(_raw_write_unlock_irqrestore);`
`353`	`353`	`#endif`
`354`	`354`
`355`	`355`	`#ifndef CONFIG_INLINE_WRITE_UNLOCK_IRQ`
`356`		`-void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)`
	`356`	`+noinline void __lockfunc _raw_write_unlock_irq(rwlock_t *lock)`
`357`	`357`	`{`
`358`	`358`	`__raw_write_unlock_irq(lock);`
`359`	`359`	`}`
`360`	`360`	`EXPORT_SYMBOL(_raw_write_unlock_irq);`
`361`	`361`	`#endif`
`362`	`362`
`363`	`363`	`#ifndef CONFIG_INLINE_WRITE_UNLOCK_BH`
`364`		`-void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)`
	`364`	`+noinline void __lockfunc _raw_write_unlock_bh(rwlock_t *lock)`
`365`	`365`	`{`
`366`	`366`	`__raw_write_unlock_bh(lock);`
`367`	`367`	`}`