Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
locking/local_lock, mm: replace localtry_ helpers with local_trylock_t type
Partially revert commit 0aaddfb06882 ("locking/local_lock: Introduce
localtry_lock_t"). Remove localtry_*() helpers, since localtry_lock()
name might be misinterpreted as "try lock".
Introduce local_trylock[_irqsave]() helpers that only work with newly
introduced local_trylock_t type. Note that attempt to use
local_trylock[_irqsave]() with local_lock_t will cause compilation
failure.
Usage and behavior in !PREEMPT_RT:
local_lock_t lock; // sizeof(lock) == 0
local_lock(&lock); // preempt disable
local_lock_irqsave(&lock, ...); // irq save
if (local_trylock_irqsave(&lock, ...)) // compilation error
local_trylock_t lock; // sizeof(lock) == 4
local_lock(&lock); // preempt disable, acquired = 1
local_lock_irqsave(&lock, ...); // irq save, acquired = 1
if (local_trylock(&lock)) // if (!acquired) preempt disable, acquired = 1
if (local_trylock_irqsave(&lock, ...)) // if (!acquired) irq save, acquired = 1
The existing local_lock_*() macros can be used either with local_lock_t or
local_trylock_t. With local_trylock_t they set acquired = 1 while
local_unlock_*() clears it.
In !PREEMPT_RT local_lock_irqsave(local_lock_t *) disables interrupts to
protect critical section, but it doesn't prevent NMI, so the fully
reentrant code cannot use local_lock_irqsave(local_lock_t *) for exclusive
access.
The local_lock_irqsave(local_trylock_t *) helper disables interrupts and
sets acquired=1, so local_trylock_irqsave(local_trylock_t *) from NMI
attempting to acquire the same lock will return false.
In PREEMPT_RT local_lock_irqsave() maps to preemptible spin_lock(). Map
local_trylock_irqsave() to preemptible spin_trylock(). When in hard IRQ
or NMI return false right away, since spin_trylock() is not safe due to
explicit locking in the underneath rt_spin_trylock() implementation.
Removing this explicit locking and attempting only "trylock" is undesired
due to PI implications.
The local_trylock() without _irqsave can be used to avoid the cost of
disabling/enabling interrupts by only disabling preemption, so
local_trylock() in an interrupt attempting to acquire the same lock will
return false.
Note there is no need to use local_inc for acquired variable, since it's a
percpu variable with strict nesting scopes.
Note that guard(local_lock)(&lock) works only for "local_lock_t lock".
The patch also makes sure that local_lock_release(l) is called before
WRITE_ONCE(l->acquired, 0). Though IRQs are disabled at this point the
local_trylock() from NMI will succeed and local_lock_acquire(l) will warn.
Link: https://lkml.kernel.org/r/20250403025514.41186-1-alexei.starovoitov@gmail.com
Fixes: 0aaddfb06882 ("locking/local_lock: Introduce localtry_lock_t")
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Reviewed-by: Shakeel Butt <shakeel.butt@linux.dev>
Cc: Daniel Borkman <daniel@iogearbox.net>
Cc: Linus Torvalds <torvalds@linuxfoundation.org>
Cc: Martin KaFai Lau <martin.lau@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
authored by
Alexei Starovoitov
and committed by
Andrew Morton
51339d99
a30951d0
+116
-192
+8
-50
include/linux/local_lock.h
+8
-50
include/linux/local_lock.h
···
52
52
__local_unlock_irqrestore(lock, flags)
53
53
54
54
/**
55
-
* localtry_lock_init - Runtime initialize a lock instance
55
+
* local_lock_init - Runtime initialize a lock instance
56
56
*/
57
-
#define localtry_lock_init(lock) __localtry_lock_init(lock)
57
+
#define local_trylock_init(lock) __local_trylock_init(lock)
58
58
59
59
/**
60
-
* localtry_lock - Acquire a per CPU local lock
61
-
* @lock: The lock variable
62
-
*/
63
-
#define localtry_lock(lock) __localtry_lock(lock)
64
-
65
-
/**
66
-
* localtry_lock_irq - Acquire a per CPU local lock and disable interrupts
67
-
* @lock: The lock variable
68
-
*/
69
-
#define localtry_lock_irq(lock) __localtry_lock_irq(lock)
70
-
71
-
/**
72
-
* localtry_lock_irqsave - Acquire a per CPU local lock, save and disable
73
-
* interrupts
74
-
* @lock: The lock variable
75
-
* @flags: Storage for interrupt flags
76
-
*/
77
-
#define localtry_lock_irqsave(lock, flags) \
78
-
__localtry_lock_irqsave(lock, flags)
79
-
80
-
/**
81
-
* localtry_trylock - Try to acquire a per CPU local lock.
60
+
* local_trylock - Try to acquire a per CPU local lock
82
61
* @lock: The lock variable
83
62
*
84
63
* The function can be used in any context such as NMI or HARDIRQ. Due to
85
64
* locking constrains it will _always_ fail to acquire the lock in NMI or
86
65
* HARDIRQ context on PREEMPT_RT.
87
66
*/
88
-
#define localtry_trylock(lock) __localtry_trylock(lock)
67
+
#define local_trylock(lock) __local_trylock(lock)
89
68
90
69
/**
91
-
* localtry_trylock_irqsave - Try to acquire a per CPU local lock, save and disable
92
-
* interrupts if acquired
70
+
* local_trylock_irqsave - Try to acquire a per CPU local lock, save and disable
71
+
* interrupts if acquired
93
72
* @lock: The lock variable
94
73
* @flags: Storage for interrupt flags
95
74
*
···
76
97
* locking constrains it will _always_ fail to acquire the lock in NMI or
77
98
* HARDIRQ context on PREEMPT_RT.
78
99
*/
79
-
#define localtry_trylock_irqsave(lock, flags) \
80
-
__localtry_trylock_irqsave(lock, flags)
81
-
82
-
/**
83
-
* local_unlock - Release a per CPU local lock
84
-
* @lock: The lock variable
85
-
*/
86
-
#define localtry_unlock(lock) __localtry_unlock(lock)
87
-
88
-
/**
89
-
* local_unlock_irq - Release a per CPU local lock and enable interrupts
90
-
* @lock: The lock variable
91
-
*/
92
-
#define localtry_unlock_irq(lock) __localtry_unlock_irq(lock)
93
-
94
-
/**
95
-
* localtry_unlock_irqrestore - Release a per CPU local lock and restore
96
-
* interrupt flags
97
-
* @lock: The lock variable
98
-
* @flags: Interrupt flags to restore
99
-
*/
100
-
#define localtry_unlock_irqrestore(lock, flags) \
101
-
__localtry_unlock_irqrestore(lock, flags)
100
+
#define local_trylock_irqsave(lock, flags) \
101
+
__local_trylock_irqsave(lock, flags)
102
102
103
103
DEFINE_GUARD(local_lock, local_lock_t __percpu*,
104
104
local_lock(_T),
+89
-122
include/linux/local_lock_internal.h
+89
-122
include/linux/local_lock_internal.h
···
15
15
#endif
16
16
} local_lock_t;
17
17
18
+
/* local_trylock() and local_trylock_irqsave() only work with local_trylock_t */
18
19
typedef struct {
19
20
local_lock_t llock;
20
-
unsigned int acquired;
21
-
} localtry_lock_t;
21
+
u8 acquired;
22
+
} local_trylock_t;
22
23
23
24
#ifdef CONFIG_DEBUG_LOCK_ALLOC
24
25
# define LOCAL_LOCK_DEBUG_INIT(lockname) \
···
29
28
.lock_type = LD_LOCK_PERCPU, \
30
29
}, \
31
30
.owner = NULL,
31
+
32
+
# define LOCAL_TRYLOCK_DEBUG_INIT(lockname) \
33
+
.llock = { LOCAL_LOCK_DEBUG_INIT((lockname).llock) },
32
34
33
35
static inline void local_lock_acquire(local_lock_t *l)
34
36
{
···
60
56
}
61
57
#else /* CONFIG_DEBUG_LOCK_ALLOC */
62
58
# define LOCAL_LOCK_DEBUG_INIT(lockname)
59
+
# define LOCAL_TRYLOCK_DEBUG_INIT(lockname)
63
60
static inline void local_lock_acquire(local_lock_t *l) { }
64
61
static inline void local_trylock_acquire(local_lock_t *l) { }
65
62
static inline void local_lock_release(local_lock_t *l) { }
···
68
63
#endif /* !CONFIG_DEBUG_LOCK_ALLOC */
69
64
70
65
#define INIT_LOCAL_LOCK(lockname) { LOCAL_LOCK_DEBUG_INIT(lockname) }
71
-
#define INIT_LOCALTRY_LOCK(lockname) { .llock = { LOCAL_LOCK_DEBUG_INIT(lockname.llock) }}
66
+
#define INIT_LOCAL_TRYLOCK(lockname) { LOCAL_TRYLOCK_DEBUG_INIT(lockname) }
72
67
73
68
#define __local_lock_init(lock) \
74
69
do { \
···
81
76
local_lock_debug_init(lock); \
82
77
} while (0)
83
78
79
+
#define __local_trylock_init(lock) __local_lock_init(lock.llock)
80
+
84
81
#define __spinlock_nested_bh_init(lock) \
85
82
do { \
86
83
static struct lock_class_key __key; \
···
94
87
local_lock_debug_init(lock); \
95
88
} while (0)
96
89
90
+
#define __local_lock_acquire(lock) \
91
+
do { \
92
+
local_trylock_t *tl; \
93
+
local_lock_t *l; \
94
+
\
95
+
l = (local_lock_t *)this_cpu_ptr(lock); \
96
+
tl = (local_trylock_t *)l; \
97
+
_Generic((lock), \
98
+
local_trylock_t *: ({ \
99
+
lockdep_assert(tl->acquired == 0); \
100
+
WRITE_ONCE(tl->acquired, 1); \
101
+
}), \
102
+
default:(void)0); \
103
+
local_lock_acquire(l); \
104
+
} while (0)
105
+
97
106
#define __local_lock(lock) \
98
107
do { \
99
108
preempt_disable(); \
100
-
local_lock_acquire(this_cpu_ptr(lock)); \
109
+
__local_lock_acquire(lock); \
101
110
} while (0)
102
111
103
112
#define __local_lock_irq(lock) \
104
113
do { \
105
114
local_irq_disable(); \
106
-
local_lock_acquire(this_cpu_ptr(lock)); \
115
+
__local_lock_acquire(lock); \
107
116
} while (0)
108
117
109
118
#define __local_lock_irqsave(lock, flags) \
110
119
do { \
111
120
local_irq_save(flags); \
112
-
local_lock_acquire(this_cpu_ptr(lock)); \
121
+
__local_lock_acquire(lock); \
122
+
} while (0)
123
+
124
+
#define __local_trylock(lock) \
125
+
({ \
126
+
local_trylock_t *tl; \
127
+
\
128
+
preempt_disable(); \
129
+
tl = this_cpu_ptr(lock); \
130
+
if (READ_ONCE(tl->acquired)) { \
131
+
preempt_enable(); \
132
+
tl = NULL; \
133
+
} else { \
134
+
WRITE_ONCE(tl->acquired, 1); \
135
+
local_trylock_acquire( \
136
+
(local_lock_t *)tl); \
137
+
} \
138
+
!!tl; \
139
+
})
140
+
141
+
#define __local_trylock_irqsave(lock, flags) \
142
+
({ \
143
+
local_trylock_t *tl; \
144
+
\
145
+
local_irq_save(flags); \
146
+
tl = this_cpu_ptr(lock); \
147
+
if (READ_ONCE(tl->acquired)) { \
148
+
local_irq_restore(flags); \
149
+
tl = NULL; \
150
+
} else { \
151
+
WRITE_ONCE(tl->acquired, 1); \
152
+
local_trylock_acquire( \
153
+
(local_lock_t *)tl); \
154
+
} \
155
+
!!tl; \
156
+
})
157
+
158
+
#define __local_lock_release(lock) \
159
+
do { \
160
+
local_trylock_t *tl; \
161
+
local_lock_t *l; \
162
+
\
163
+
l = (local_lock_t *)this_cpu_ptr(lock); \
164
+
tl = (local_trylock_t *)l; \
165
+
local_lock_release(l); \
166
+
_Generic((lock), \
167
+
local_trylock_t *: ({ \
168
+
lockdep_assert(tl->acquired == 1); \
169
+
WRITE_ONCE(tl->acquired, 0); \
170
+
}), \
171
+
default:(void)0); \
113
172
} while (0)
114
173
115
174
#define __local_unlock(lock) \
116
175
do { \
117
-
local_lock_release(this_cpu_ptr(lock)); \
176
+
__local_lock_release(lock); \
118
177
preempt_enable(); \
119
178
} while (0)
120
179
121
180
#define __local_unlock_irq(lock) \
122
181
do { \
123
-
local_lock_release(this_cpu_ptr(lock)); \
182
+
__local_lock_release(lock); \
124
183
local_irq_enable(); \
125
184
} while (0)
126
185
127
186
#define __local_unlock_irqrestore(lock, flags) \
128
187
do { \
129
-
local_lock_release(this_cpu_ptr(lock)); \
188
+
__local_lock_release(lock); \
130
189
local_irq_restore(flags); \
131
190
} while (0)
132
191
···
205
132
#define __local_unlock_nested_bh(lock) \
206
133
local_lock_release(this_cpu_ptr(lock))
207
134
208
-
/* localtry_lock_t variants */
209
-
210
-
#define __localtry_lock_init(lock) \
211
-
do { \
212
-
__local_lock_init(&(lock)->llock); \
213
-
WRITE_ONCE((lock)->acquired, 0); \
214
-
} while (0)
215
-
216
-
#define __localtry_lock(lock) \
217
-
do { \
218
-
localtry_lock_t *lt; \
219
-
preempt_disable(); \
220
-
lt = this_cpu_ptr(lock); \
221
-
local_lock_acquire(<->llock); \
222
-
WRITE_ONCE(lt->acquired, 1); \
223
-
} while (0)
224
-
225
-
#define __localtry_lock_irq(lock) \
226
-
do { \
227
-
localtry_lock_t *lt; \
228
-
local_irq_disable(); \
229
-
lt = this_cpu_ptr(lock); \
230
-
local_lock_acquire(<->llock); \
231
-
WRITE_ONCE(lt->acquired, 1); \
232
-
} while (0)
233
-
234
-
#define __localtry_lock_irqsave(lock, flags) \
235
-
do { \
236
-
localtry_lock_t *lt; \
237
-
local_irq_save(flags); \
238
-
lt = this_cpu_ptr(lock); \
239
-
local_lock_acquire(<->llock); \
240
-
WRITE_ONCE(lt->acquired, 1); \
241
-
} while (0)
242
-
243
-
#define __localtry_trylock(lock) \
244
-
({ \
245
-
localtry_lock_t *lt; \
246
-
bool _ret; \
247
-
\
248
-
preempt_disable(); \
249
-
lt = this_cpu_ptr(lock); \
250
-
if (!READ_ONCE(lt->acquired)) { \
251
-
WRITE_ONCE(lt->acquired, 1); \
252
-
local_trylock_acquire(<->llock); \
253
-
_ret = true; \
254
-
} else { \
255
-
_ret = false; \
256
-
preempt_enable(); \
257
-
} \
258
-
_ret; \
259
-
})
260
-
261
-
#define __localtry_trylock_irqsave(lock, flags) \
262
-
({ \
263
-
localtry_lock_t *lt; \
264
-
bool _ret; \
265
-
\
266
-
local_irq_save(flags); \
267
-
lt = this_cpu_ptr(lock); \
268
-
if (!READ_ONCE(lt->acquired)) { \
269
-
WRITE_ONCE(lt->acquired, 1); \
270
-
local_trylock_acquire(<->llock); \
271
-
_ret = true; \
272
-
} else { \
273
-
_ret = false; \
274
-
local_irq_restore(flags); \
275
-
} \
276
-
_ret; \
277
-
})
278
-
279
-
#define __localtry_unlock(lock) \
280
-
do { \
281
-
localtry_lock_t *lt; \
282
-
lt = this_cpu_ptr(lock); \
283
-
WRITE_ONCE(lt->acquired, 0); \
284
-
local_lock_release(<->llock); \
285
-
preempt_enable(); \
286
-
} while (0)
287
-
288
-
#define __localtry_unlock_irq(lock) \
289
-
do { \
290
-
localtry_lock_t *lt; \
291
-
lt = this_cpu_ptr(lock); \
292
-
WRITE_ONCE(lt->acquired, 0); \
293
-
local_lock_release(<->llock); \
294
-
local_irq_enable(); \
295
-
} while (0)
296
-
297
-
#define __localtry_unlock_irqrestore(lock, flags) \
298
-
do { \
299
-
localtry_lock_t *lt; \
300
-
lt = this_cpu_ptr(lock); \
301
-
WRITE_ONCE(lt->acquired, 0); \
302
-
local_lock_release(<->llock); \
303
-
local_irq_restore(flags); \
304
-
} while (0)
305
-
306
135
#else /* !CONFIG_PREEMPT_RT */
307
136
308
137
/*
···
212
237
* critical section while staying preemptible.
213
238
*/
214
239
typedef spinlock_t local_lock_t;
215
-
typedef spinlock_t localtry_lock_t;
240
+
typedef spinlock_t local_trylock_t;
216
241
217
242
#define INIT_LOCAL_LOCK(lockname) __LOCAL_SPIN_LOCK_UNLOCKED((lockname))
218
-
#define INIT_LOCALTRY_LOCK(lockname) INIT_LOCAL_LOCK(lockname)
243
+
#define INIT_LOCAL_TRYLOCK(lockname) __LOCAL_SPIN_LOCK_UNLOCKED((lockname))
219
244
220
245
#define __local_lock_init(l) \
221
246
do { \
222
247
local_spin_lock_init((l)); \
223
248
} while (0)
249
+
250
+
#define __local_trylock_init(l) __local_lock_init(l)
224
251
225
252
#define __local_lock(__lock) \
226
253
do { \
···
260
283
spin_unlock(this_cpu_ptr((lock))); \
261
284
} while (0)
262
285
263
-
/* localtry_lock_t variants */
264
-
265
-
#define __localtry_lock_init(lock) __local_lock_init(lock)
266
-
#define __localtry_lock(lock) __local_lock(lock)
267
-
#define __localtry_lock_irq(lock) __local_lock(lock)
268
-
#define __localtry_lock_irqsave(lock, flags) __local_lock_irqsave(lock, flags)
269
-
#define __localtry_unlock(lock) __local_unlock(lock)
270
-
#define __localtry_unlock_irq(lock) __local_unlock(lock)
271
-
#define __localtry_unlock_irqrestore(lock, flags) __local_unlock_irqrestore(lock, flags)
272
-
273
-
#define __localtry_trylock(lock) \
286
+
#define __local_trylock(lock) \
274
287
({ \
275
288
int __locked; \
276
289
\
···
275
308
__locked; \
276
309
})
277
310
278
-
#define __localtry_trylock_irqsave(lock, flags) \
311
+
#define __local_trylock_irqsave(lock, flags) \
279
312
({ \
280
313
typecheck(unsigned long, flags); \
281
314
flags = 0; \
282
-
__localtry_trylock(lock); \
315
+
__local_trylock(lock); \
283
316
})
284
317
285
318
#endif /* CONFIG_PREEMPT_RT */
+19
-20
mm/memcontrol.c
+19
-20
mm/memcontrol.c
···
1759
1759
}
1760
1760
1761
1761
struct memcg_stock_pcp {
1762
-
localtry_lock_t stock_lock;
1762
+
local_trylock_t stock_lock;
1763
1763
struct mem_cgroup *cached; /* this never be root cgroup */
1764
1764
unsigned int nr_pages;
1765
1765
···
1774
1774
#define FLUSHING_CACHED_CHARGE 0
1775
1775
};
1776
1776
static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock) = {
1777
-
.stock_lock = INIT_LOCALTRY_LOCK(stock_lock),
1777
+
.stock_lock = INIT_LOCAL_TRYLOCK(stock_lock),
1778
1778
};
1779
1779
static DEFINE_MUTEX(percpu_charge_mutex);
1780
1780
···
1805
1805
if (nr_pages > MEMCG_CHARGE_BATCH)
1806
1806
return ret;
1807
1807
1808
-
if (!localtry_trylock_irqsave(&memcg_stock.stock_lock, flags)) {
1809
-
if (!gfpflags_allow_spinning(gfp_mask))
1810
-
return ret;
1811
-
localtry_lock_irqsave(&memcg_stock.stock_lock, flags);
1812
-
}
1808
+
if (gfpflags_allow_spinning(gfp_mask))
1809
+
local_lock_irqsave(&memcg_stock.stock_lock, flags);
1810
+
else if (!local_trylock_irqsave(&memcg_stock.stock_lock, flags))
1811
+
return ret;
1813
1812
1814
1813
stock = this_cpu_ptr(&memcg_stock);
1815
1814
stock_pages = READ_ONCE(stock->nr_pages);
···
1817
1818
ret = true;
1818
1819
}
1819
1820
1820
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1821
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1821
1822
1822
1823
return ret;
1823
1824
}
···
1856
1857
* drain_stock races is that we always operate on local CPU stock
1857
1858
* here with IRQ disabled
1858
1859
*/
1859
-
localtry_lock_irqsave(&memcg_stock.stock_lock, flags);
1860
+
local_lock_irqsave(&memcg_stock.stock_lock, flags);
1860
1861
1861
1862
stock = this_cpu_ptr(&memcg_stock);
1862
1863
old = drain_obj_stock(stock);
1863
1864
drain_stock(stock);
1864
1865
clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags);
1865
1866
1866
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1867
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1867
1868
obj_cgroup_put(old);
1868
1869
}
1869
1870
···
1893
1894
{
1894
1895
unsigned long flags;
1895
1896
1896
-
if (!localtry_trylock_irqsave(&memcg_stock.stock_lock, flags)) {
1897
+
if (!local_trylock_irqsave(&memcg_stock.stock_lock, flags)) {
1897
1898
/*
1898
1899
* In case of unlikely failure to lock percpu stock_lock
1899
1900
* uncharge memcg directly.
···
1906
1907
return;
1907
1908
}
1908
1909
__refill_stock(memcg, nr_pages);
1909
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1910
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1910
1911
}
1911
1912
1912
1913
/*
···
1963
1964
stock = &per_cpu(memcg_stock, cpu);
1964
1965
1965
1966
/* drain_obj_stock requires stock_lock */
1966
-
localtry_lock_irqsave(&memcg_stock.stock_lock, flags);
1967
+
local_lock_irqsave(&memcg_stock.stock_lock, flags);
1967
1968
old = drain_obj_stock(stock);
1968
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1969
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
1969
1970
1970
1971
drain_stock(stock);
1971
1972
obj_cgroup_put(old);
···
2786
2787
unsigned long flags;
2787
2788
int *bytes;
2788
2789
2789
-
localtry_lock_irqsave(&memcg_stock.stock_lock, flags);
2790
+
local_lock_irqsave(&memcg_stock.stock_lock, flags);
2790
2791
stock = this_cpu_ptr(&memcg_stock);
2791
2792
2792
2793
/*
···
2835
2836
if (nr)
2836
2837
__mod_objcg_mlstate(objcg, pgdat, idx, nr);
2837
2838
2838
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2839
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2839
2840
obj_cgroup_put(old);
2840
2841
}
2841
2842
···
2845
2846
unsigned long flags;
2846
2847
bool ret = false;
2847
2848
2848
-
localtry_lock_irqsave(&memcg_stock.stock_lock, flags);
2849
+
local_lock_irqsave(&memcg_stock.stock_lock, flags);
2849
2850
2850
2851
stock = this_cpu_ptr(&memcg_stock);
2851
2852
if (objcg == READ_ONCE(stock->cached_objcg) && stock->nr_bytes >= nr_bytes) {
···
2853
2854
ret = true;
2854
2855
}
2855
2856
2856
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2857
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2857
2858
2858
2859
return ret;
2859
2860
}
···
2945
2946
unsigned long flags;
2946
2947
unsigned int nr_pages = 0;
2947
2948
2948
-
localtry_lock_irqsave(&memcg_stock.stock_lock, flags);
2949
+
local_lock_irqsave(&memcg_stock.stock_lock, flags);
2949
2950
2950
2951
stock = this_cpu_ptr(&memcg_stock);
2951
2952
if (READ_ONCE(stock->cached_objcg) != objcg) { /* reset if necessary */
···
2959
2960
stock->nr_bytes &= (PAGE_SIZE - 1);
2960
2961
}
2961
2962
2962
-
localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2963
+
local_unlock_irqrestore(&memcg_stock.stock_lock, flags);
2963
2964
obj_cgroup_put(old);
2964
2965
2965
2966
if (nr_pages)