Merge tag 'parisc-for-6.0-2' of git://git.kernel.org/pub/scm/linux/kernel/git/deller...
[linux-2.6-microblaze.git] / mm / page_counter.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Lockless hierarchical page accounting & limiting
4  *
5  * Copyright (C) 2014 Red Hat, Inc., Johannes Weiner
6  */
7
8 #include <linux/page_counter.h>
9 #include <linux/atomic.h>
10 #include <linux/kernel.h>
11 #include <linux/string.h>
12 #include <linux/sched.h>
13 #include <linux/bug.h>
14 #include <asm/page.h>
15
16 static void propagate_protected_usage(struct page_counter *c,
17                                       unsigned long usage)
18 {
19         unsigned long protected, old_protected;
20         unsigned long low, min;
21         long delta;
22
23         if (!c->parent)
24                 return;
25
26         min = READ_ONCE(c->min);
27         if (min || atomic_long_read(&c->min_usage)) {
28                 protected = min(usage, min);
29                 old_protected = atomic_long_xchg(&c->min_usage, protected);
30                 delta = protected - old_protected;
31                 if (delta)
32                         atomic_long_add(delta, &c->parent->children_min_usage);
33         }
34
35         low = READ_ONCE(c->low);
36         if (low || atomic_long_read(&c->low_usage)) {
37                 protected = min(usage, low);
38                 old_protected = atomic_long_xchg(&c->low_usage, protected);
39                 delta = protected - old_protected;
40                 if (delta)
41                         atomic_long_add(delta, &c->parent->children_low_usage);
42         }
43 }
44
45 /**
46  * page_counter_cancel - take pages out of the local counter
47  * @counter: counter
48  * @nr_pages: number of pages to cancel
49  */
50 void page_counter_cancel(struct page_counter *counter, unsigned long nr_pages)
51 {
52         long new;
53
54         new = atomic_long_sub_return(nr_pages, &counter->usage);
55         /* More uncharges than charges? */
56         if (WARN_ONCE(new < 0, "page_counter underflow: %ld nr_pages=%lu\n",
57                       new, nr_pages)) {
58                 new = 0;
59                 atomic_long_set(&counter->usage, new);
60         }
61         propagate_protected_usage(counter, new);
62 }
63
64 /**
65  * page_counter_charge - hierarchically charge pages
66  * @counter: counter
67  * @nr_pages: number of pages to charge
68  *
69  * NOTE: This does not consider any configured counter limits.
70  */
71 void page_counter_charge(struct page_counter *counter, unsigned long nr_pages)
72 {
73         struct page_counter *c;
74
75         for (c = counter; c; c = c->parent) {
76                 long new;
77
78                 new = atomic_long_add_return(nr_pages, &c->usage);
79                 propagate_protected_usage(c, new);
80                 /*
81                  * This is indeed racy, but we can live with some
82                  * inaccuracy in the watermark.
83                  */
84                 if (new > READ_ONCE(c->watermark))
85                         WRITE_ONCE(c->watermark, new);
86         }
87 }
88
89 /**
90  * page_counter_try_charge - try to hierarchically charge pages
91  * @counter: counter
92  * @nr_pages: number of pages to charge
93  * @fail: points first counter to hit its limit, if any
94  *
95  * Returns %true on success, or %false and @fail if the counter or one
96  * of its ancestors has hit its configured limit.
97  */
98 bool page_counter_try_charge(struct page_counter *counter,
99                              unsigned long nr_pages,
100                              struct page_counter **fail)
101 {
102         struct page_counter *c;
103
104         for (c = counter; c; c = c->parent) {
105                 long new;
106                 /*
107                  * Charge speculatively to avoid an expensive CAS.  If
108                  * a bigger charge fails, it might falsely lock out a
109                  * racing smaller charge and send it into reclaim
110                  * early, but the error is limited to the difference
111                  * between the two sizes, which is less than 2M/4M in
112                  * case of a THP locking out a regular page charge.
113                  *
114                  * The atomic_long_add_return() implies a full memory
115                  * barrier between incrementing the count and reading
116                  * the limit.  When racing with page_counter_set_max(),
117                  * we either see the new limit or the setter sees the
118                  * counter has changed and retries.
119                  */
120                 new = atomic_long_add_return(nr_pages, &c->usage);
121                 if (new > c->max) {
122                         atomic_long_sub(nr_pages, &c->usage);
123                         /*
124                          * This is racy, but we can live with some
125                          * inaccuracy in the failcnt which is only used
126                          * to report stats.
127                          */
128                         data_race(c->failcnt++);
129                         *fail = c;
130                         goto failed;
131                 }
132                 propagate_protected_usage(c, new);
133                 /*
134                  * Just like with failcnt, we can live with some
135                  * inaccuracy in the watermark.
136                  */
137                 if (new > READ_ONCE(c->watermark))
138                         WRITE_ONCE(c->watermark, new);
139         }
140         return true;
141
142 failed:
143         for (c = counter; c != *fail; c = c->parent)
144                 page_counter_cancel(c, nr_pages);
145
146         return false;
147 }
148
149 /**
150  * page_counter_uncharge - hierarchically uncharge pages
151  * @counter: counter
152  * @nr_pages: number of pages to uncharge
153  */
154 void page_counter_uncharge(struct page_counter *counter, unsigned long nr_pages)
155 {
156         struct page_counter *c;
157
158         for (c = counter; c; c = c->parent)
159                 page_counter_cancel(c, nr_pages);
160 }
161
162 /**
163  * page_counter_set_max - set the maximum number of pages allowed
164  * @counter: counter
165  * @nr_pages: limit to set
166  *
167  * Returns 0 on success, -EBUSY if the current number of pages on the
168  * counter already exceeds the specified limit.
169  *
170  * The caller must serialize invocations on the same counter.
171  */
172 int page_counter_set_max(struct page_counter *counter, unsigned long nr_pages)
173 {
174         for (;;) {
175                 unsigned long old;
176                 long usage;
177
178                 /*
179                  * Update the limit while making sure that it's not
180                  * below the concurrently-changing counter value.
181                  *
182                  * The xchg implies two full memory barriers before
183                  * and after, so the read-swap-read is ordered and
184                  * ensures coherency with page_counter_try_charge():
185                  * that function modifies the count before checking
186                  * the limit, so if it sees the old limit, we see the
187                  * modified counter and retry.
188                  */
189                 usage = page_counter_read(counter);
190
191                 if (usage > nr_pages)
192                         return -EBUSY;
193
194                 old = xchg(&counter->max, nr_pages);
195
196                 if (page_counter_read(counter) <= usage)
197                         return 0;
198
199                 counter->max = old;
200                 cond_resched();
201         }
202 }
203
204 /**
205  * page_counter_set_min - set the amount of protected memory
206  * @counter: counter
207  * @nr_pages: value to set
208  *
209  * The caller must serialize invocations on the same counter.
210  */
211 void page_counter_set_min(struct page_counter *counter, unsigned long nr_pages)
212 {
213         struct page_counter *c;
214
215         WRITE_ONCE(counter->min, nr_pages);
216
217         for (c = counter; c; c = c->parent)
218                 propagate_protected_usage(c, atomic_long_read(&c->usage));
219 }
220
221 /**
222  * page_counter_set_low - set the amount of protected memory
223  * @counter: counter
224  * @nr_pages: value to set
225  *
226  * The caller must serialize invocations on the same counter.
227  */
228 void page_counter_set_low(struct page_counter *counter, unsigned long nr_pages)
229 {
230         struct page_counter *c;
231
232         WRITE_ONCE(counter->low, nr_pages);
233
234         for (c = counter; c; c = c->parent)
235                 propagate_protected_usage(c, atomic_long_read(&c->usage));
236 }
237
238 /**
239  * page_counter_memparse - memparse() for page counter limits
240  * @buf: string to parse
241  * @max: string meaning maximum possible value
242  * @nr_pages: returns the result in number of pages
243  *
244  * Returns -EINVAL, or 0 and @nr_pages on success.  @nr_pages will be
245  * limited to %PAGE_COUNTER_MAX.
246  */
247 int page_counter_memparse(const char *buf, const char *max,
248                           unsigned long *nr_pages)
249 {
250         char *end;
251         u64 bytes;
252
253         if (!strcmp(buf, max)) {
254                 *nr_pages = PAGE_COUNTER_MAX;
255                 return 0;
256         }
257
258         bytes = memparse(buf, &end);
259         if (*end != '\0')
260                 return -EINVAL;
261
262         *nr_pages = min(bytes / PAGE_SIZE, (u64)PAGE_COUNTER_MAX);
263
264         return 0;
265 }