~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/vm/mlock-random-test.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * It tests the mlock/mlock2() when they are invoked
  4  * on randomly memory region.
  5  */
  6 #include <unistd.h>
  7 #include <sys/resource.h>
  8 #include <sys/capability.h>
  9 #include <sys/mman.h>
 10 #include <fcntl.h>
 11 #include <string.h>
 12 #include <sys/ipc.h>
 13 #include <sys/shm.h>
 14 #include <time.h>
 15 #include "mlock2.h"
 16 
 17 #define CHUNK_UNIT (128 * 1024)
 18 #define MLOCK_RLIMIT_SIZE (CHUNK_UNIT * 2)
 19 #define MLOCK_WITHIN_LIMIT_SIZE CHUNK_UNIT
 20 #define MLOCK_OUTOF_LIMIT_SIZE (CHUNK_UNIT * 3)
 21 
 22 #define TEST_LOOP 100
 23 #define PAGE_ALIGN(size, ps) (((size) + ((ps) - 1)) & ~((ps) - 1))
 24 
 25 int set_cap_limits(rlim_t max)
 26 {
 27         struct rlimit new;
 28         cap_t cap = cap_init();
 29 
 30         new.rlim_cur = max;
 31         new.rlim_max = max;
 32         if (setrlimit(RLIMIT_MEMLOCK, &new)) {
 33                 perror("setrlimit() returns error\n");
 34                 return -1;
 35         }
 36 
 37         /* drop capabilities including CAP_IPC_LOCK */
 38         if (cap_set_proc(cap)) {
 39                 perror("cap_set_proc() returns error\n");
 40                 return -2;
 41         }
 42 
 43         return 0;
 44 }
 45 
 46 int get_proc_locked_vm_size(void)
 47 {
 48         FILE *f;
 49         int ret = -1;
 50         char line[1024] = {0};
 51         unsigned long lock_size = 0;
 52 
 53         f = fopen("/proc/self/status", "r");
 54         if (!f) {
 55                 perror("fopen");
 56                 return -1;
 57         }
 58 
 59         while (fgets(line, 1024, f)) {
 60                 if (strstr(line, "VmLck")) {
 61                         ret = sscanf(line, "VmLck:\t%8lu kB", &lock_size);
 62                         if (ret <= 0) {
 63                                 printf("sscanf() on VmLck error: %s: %d\n",
 64                                                 line, ret);
 65                                 fclose(f);
 66                                 return -1;
 67                         }
 68                         fclose(f);
 69                         return (int)(lock_size << 10);
 70                 }
 71         }
 72 
 73         perror("cann't parse VmLck in /proc/self/status\n");
 74         fclose(f);
 75         return -1;
 76 }
 77 
 78 /*
 79  * Get the MMUPageSize of the memory region including input
 80  * address from proc file.
 81  *
 82  * return value: on error case, 0 will be returned.
 83  * Otherwise the page size(in bytes) is returned.
 84  */
 85 int get_proc_page_size(unsigned long addr)
 86 {
 87         FILE *smaps;
 88         char *line;
 89         unsigned long mmupage_size = 0;
 90         size_t size;
 91 
 92         smaps = seek_to_smaps_entry(addr);
 93         if (!smaps) {
 94                 printf("Unable to parse /proc/self/smaps\n");
 95                 return 0;
 96         }
 97 
 98         while (getline(&line, &size, smaps) > 0) {
 99                 if (!strstr(line, "MMUPageSize")) {
100                         free(line);
101                         line = NULL;
102                         size = 0;
103                         continue;
104                 }
105 
106                 /* found the MMUPageSize of this section */
107                 if (sscanf(line, "MMUPageSize:    %8lu kB",
108                                         &mmupage_size) < 1) {
109                         printf("Unable to parse smaps entry for Size:%s\n",
110                                         line);
111                         break;
112                 }
113 
114         }
115         free(line);
116         if (smaps)
117                 fclose(smaps);
118         return mmupage_size << 10;
119 }
120 
121 /*
122  * Test mlock/mlock2() on provided memory chunk.
123  * It expects the mlock/mlock2() to be successful (within rlimit)
124  *
125  * With allocated memory chunk [p, p + alloc_size), this
126  * test will choose start/len randomly to perform mlock/mlock2
127  * [start, start +  len] memory range. The range is within range
128  * of the allocated chunk.
129  *
130  * The memory region size alloc_size is within the rlimit.
131  * So we always expect a success of mlock/mlock2.
132  *
133  * VmLck is assumed to be 0 before this test.
134  *
135  *    return value: 0 - success
136  *    else: failure
137  */
138 int test_mlock_within_limit(char *p, int alloc_size)
139 {
140         int i;
141         int ret = 0;
142         int locked_vm_size = 0;
143         struct rlimit cur;
144         int page_size = 0;
145 
146         getrlimit(RLIMIT_MEMLOCK, &cur);
147         if (cur.rlim_cur < alloc_size) {
148                 printf("alloc_size[%d] < %u rlimit,lead to mlock failure\n",
149                                 alloc_size, (unsigned int)cur.rlim_cur);
150                 return -1;
151         }
152 
153         srand(time(NULL));
154         for (i = 0; i < TEST_LOOP; i++) {
155                 /*
156                  * - choose mlock/mlock2 randomly
157                  * - choose lock_size randomly but lock_size < alloc_size
158                  * - choose start_offset randomly but p+start_offset+lock_size
159                  *   < p+alloc_size
160                  */
161                 int is_mlock = !!(rand() % 2);
162                 int lock_size = rand() % alloc_size;
163                 int start_offset = rand() % (alloc_size - lock_size);
164 
165                 if (is_mlock)
166                         ret = mlock(p + start_offset, lock_size);
167                 else
168                         ret = mlock2_(p + start_offset, lock_size,
169                                        MLOCK_ONFAULT);
170 
171                 if (ret) {
172                         printf("%s() failure at |%p(%d)| mlock:|%p(%d)|\n",
173                                         is_mlock ? "mlock" : "mlock2",
174                                         p, alloc_size,
175                                         p + start_offset, lock_size);
176                         return ret;
177                 }
178         }
179 
180         /*
181          * Check VmLck left by the tests.
182          */
183         locked_vm_size = get_proc_locked_vm_size();
184         page_size = get_proc_page_size((unsigned long)p);
185         if (page_size == 0) {
186                 printf("cannot get proc MMUPageSize\n");
187                 return -1;
188         }
189 
190         if (locked_vm_size > PAGE_ALIGN(alloc_size, page_size) + page_size) {
191                 printf("test_mlock_within_limit() left VmLck:%d on %d chunk\n",
192                                 locked_vm_size, alloc_size);
193                 return -1;
194         }
195 
196         return 0;
197 }
198 
199 
200 /*
201  * We expect the mlock/mlock2() to be fail (outof limitation)
202  *
203  * With allocated memory chunk [p, p + alloc_size), this
204  * test will randomly choose start/len and perform mlock/mlock2
205  * on [start, start+len] range.
206  *
207  * The memory region size alloc_size is above the rlimit.
208  * And the len to be locked is higher than rlimit.
209  * So we always expect a failure of mlock/mlock2.
210  * No locked page number should be increased as a side effect.
211  *
212  *    return value: 0 - success
213  *    else: failure
214  */
215 int test_mlock_outof_limit(char *p, int alloc_size)
216 {
217         int i;
218         int ret = 0;
219         int locked_vm_size = 0, old_locked_vm_size = 0;
220         struct rlimit cur;
221 
222         getrlimit(RLIMIT_MEMLOCK, &cur);
223         if (cur.rlim_cur >= alloc_size) {
224                 printf("alloc_size[%d] >%u rlimit, violates test condition\n",
225                                 alloc_size, (unsigned int)cur.rlim_cur);
226                 return -1;
227         }
228 
229         old_locked_vm_size = get_proc_locked_vm_size();
230         srand(time(NULL));
231         for (i = 0; i < TEST_LOOP; i++) {
232                 int is_mlock = !!(rand() % 2);
233                 int lock_size = (rand() % (alloc_size - cur.rlim_cur))
234                         + cur.rlim_cur;
235                 int start_offset = rand() % (alloc_size - lock_size);
236 
237                 if (is_mlock)
238                         ret = mlock(p + start_offset, lock_size);
239                 else
240                         ret = mlock2_(p + start_offset, lock_size,
241                                         MLOCK_ONFAULT);
242                 if (ret == 0) {
243                         printf("%s() succeeds? on %p(%d) mlock%p(%d)\n",
244                                         is_mlock ? "mlock" : "mlock2",
245                                         p, alloc_size,
246                                         p + start_offset, lock_size);
247                         return -1;
248                 }
249         }
250 
251         locked_vm_size = get_proc_locked_vm_size();
252         if (locked_vm_size != old_locked_vm_size) {
253                 printf("tests leads to new mlocked page: old[%d], new[%d]\n",
254                                 old_locked_vm_size,
255                                 locked_vm_size);
256                 return -1;
257         }
258 
259         return 0;
260 }
261 
262 int main(int argc, char **argv)
263 {
264         char *p = NULL;
265         int ret = 0;
266 
267         if (set_cap_limits(MLOCK_RLIMIT_SIZE))
268                 return -1;
269 
270         p = malloc(MLOCK_WITHIN_LIMIT_SIZE);
271         if (p == NULL) {
272                 perror("malloc() failure\n");
273                 return -1;
274         }
275         ret = test_mlock_within_limit(p, MLOCK_WITHIN_LIMIT_SIZE);
276         if (ret)
277                 return ret;
278         munlock(p, MLOCK_WITHIN_LIMIT_SIZE);
279         free(p);
280 
281 
282         p = malloc(MLOCK_OUTOF_LIMIT_SIZE);
283         if (p == NULL) {
284                 perror("malloc() failure\n");
285                 return -1;
286         }
287         ret = test_mlock_outof_limit(p, MLOCK_OUTOF_LIMIT_SIZE);
288         if (ret)
289                 return ret;
290         munlock(p, MLOCK_OUTOF_LIMIT_SIZE);
291         free(p);
292 
293         return 0;
294 }
295 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp