1 /*
2 * This application is Copyright 2012 Red Hat, Inc.
3 * Doug Ledford <dledford@redhat.com>
4 *
5 * mq_open_tests is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, version 3.
8 *
9 * mq_open_tests is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * For the full text of the license, see <http://www.gnu.org/licenses/>.
15 *
16 * mq_open_tests.c
17 * Tests the various situations that should either succeed or fail to
18 * open a posix message queue and then reports whether or not they
19 * did as they were supposed to.
20 *
21 */
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <string.h>
27 #include <limits.h>
28 #include <errno.h>
29 #include <sys/types.h>
30 #include <sys/time.h>
31 #include <sys/resource.h>
32 #include <sys/stat.h>
33 #include <mqueue.h>
34 #include <error.h>
35
36 #include "../kselftest.h"
37
38 static char *usage =
39 "Usage:\n"
40 " %s path\n"
41 "\n"
42 " path Path name of the message queue to create\n"
43 "\n"
44 " Note: this program must be run as root in order to enable all tests\n"
45 "\n";
46
47 char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
48 char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
49 char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
50 char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
51
52 int default_settings;
53 struct rlimit saved_limits, cur_limits;
54 int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
55 int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
56 FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
57 char *queue_path;
58 char *default_queue_path = "/test1";
59 mqd_t queue = -1;
60
61 static inline void __set(FILE *stream, int value, char *err_msg);
62 void shutdown(int exit_val, char *err_cause, int line_no);
63 static inline int get(FILE *stream);
64 static inline void set(FILE *stream, int value);
65 static inline void getr(int type, struct rlimit *rlim);
66 static inline void setr(int type, struct rlimit *rlim);
67 void validate_current_settings();
68 static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
69 static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);
70
__set(FILE * stream,int value,char * err_msg)71 static inline void __set(FILE *stream, int value, char *err_msg)
72 {
73 rewind(stream);
74 if (fprintf(stream, "%d", value) < 0)
75 perror(err_msg);
76 }
77
78
shutdown(int exit_val,char * err_cause,int line_no)79 void shutdown(int exit_val, char *err_cause, int line_no)
80 {
81 static int in_shutdown = 0;
82
83 /* In case we get called recursively by a set() call below */
84 if (in_shutdown++)
85 return;
86
87 if (seteuid(0) == -1)
88 perror("seteuid() failed");
89
90 if (queue != -1)
91 if (mq_close(queue))
92 perror("mq_close() during shutdown");
93 if (queue_path)
94 /*
95 * Be silent if this fails, if we cleaned up already it's
96 * expected to fail
97 */
98 mq_unlink(queue_path);
99 if (default_settings) {
100 if (saved_def_msgs)
101 __set(def_msgs, saved_def_msgs,
102 "failed to restore saved_def_msgs");
103 if (saved_def_msgsize)
104 __set(def_msgsize, saved_def_msgsize,
105 "failed to restore saved_def_msgsize");
106 }
107 if (saved_max_msgs)
108 __set(max_msgs, saved_max_msgs,
109 "failed to restore saved_max_msgs");
110 if (saved_max_msgsize)
111 __set(max_msgsize, saved_max_msgsize,
112 "failed to restore saved_max_msgsize");
113 if (exit_val)
114 error(exit_val, errno, "%s at %d", err_cause, line_no);
115 exit(0);
116 }
117
get(FILE * stream)118 static inline int get(FILE *stream)
119 {
120 int value;
121 rewind(stream);
122 if (fscanf(stream, "%d", &value) != 1)
123 shutdown(4, "Error reading /proc entry", __LINE__ - 1);
124 return value;
125 }
126
set(FILE * stream,int value)127 static inline void set(FILE *stream, int value)
128 {
129 int new_value;
130
131 rewind(stream);
132 if (fprintf(stream, "%d", value) < 0)
133 return shutdown(5, "Failed writing to /proc file",
134 __LINE__ - 1);
135 new_value = get(stream);
136 if (new_value != value)
137 return shutdown(5, "We didn't get what we wrote to /proc back",
138 __LINE__ - 1);
139 }
140
getr(int type,struct rlimit * rlim)141 static inline void getr(int type, struct rlimit *rlim)
142 {
143 if (getrlimit(type, rlim))
144 shutdown(6, "getrlimit()", __LINE__ - 1);
145 }
146
setr(int type,struct rlimit * rlim)147 static inline void setr(int type, struct rlimit *rlim)
148 {
149 if (setrlimit(type, rlim))
150 shutdown(7, "setrlimit()", __LINE__ - 1);
151 }
152
validate_current_settings()153 void validate_current_settings()
154 {
155 int rlim_needed;
156
157 if (cur_limits.rlim_cur < 4096) {
158 printf("Current rlimit value for POSIX message queue bytes is "
159 "unreasonably low,\nincreasing.\n\n");
160 cur_limits.rlim_cur = 8192;
161 cur_limits.rlim_max = 16384;
162 setr(RLIMIT_MSGQUEUE, &cur_limits);
163 }
164
165 if (default_settings) {
166 rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
167 2 * sizeof(void *));
168 if (rlim_needed > cur_limits.rlim_cur) {
169 printf("Temporarily lowering default queue parameters "
170 "to something that will work\n"
171 "with the current rlimit values.\n\n");
172 set(def_msgs, 10);
173 cur_def_msgs = 10;
174 set(def_msgsize, 128);
175 cur_def_msgsize = 128;
176 }
177 } else {
178 rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
179 2 * sizeof(void *));
180 if (rlim_needed > cur_limits.rlim_cur) {
181 printf("Temporarily lowering maximum queue parameters "
182 "to something that will work\n"
183 "with the current rlimit values in case this is "
184 "a kernel that ties the default\n"
185 "queue parameters to the maximum queue "
186 "parameters.\n\n");
187 set(max_msgs, 10);
188 cur_max_msgs = 10;
189 set(max_msgsize, 128);
190 cur_max_msgsize = 128;
191 }
192 }
193 }
194
195 /*
196 * test_queue - Test opening a queue, shutdown if we fail. This should
197 * only be called in situations that should never fail. We clean up
198 * after ourselves and return the queue attributes in *result.
199 */
test_queue(struct mq_attr * attr,struct mq_attr * result)200 static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
201 {
202 int flags = O_RDWR | O_EXCL | O_CREAT;
203 int perms = DEFFILEMODE;
204
205 if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
206 shutdown(1, "mq_open()", __LINE__);
207 if (mq_getattr(queue, result))
208 shutdown(1, "mq_getattr()", __LINE__);
209 if (mq_close(queue))
210 shutdown(1, "mq_close()", __LINE__);
211 queue = -1;
212 if (mq_unlink(queue_path))
213 shutdown(1, "mq_unlink()", __LINE__);
214 }
215
216 /*
217 * Same as test_queue above, but failure is not fatal.
218 * Returns:
219 * 0 - Failed to create a queue
220 * 1 - Created a queue, attributes in *result
221 */
test_queue_fail(struct mq_attr * attr,struct mq_attr * result)222 static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result)
223 {
224 int flags = O_RDWR | O_EXCL | O_CREAT;
225 int perms = DEFFILEMODE;
226
227 if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
228 return 0;
229 if (mq_getattr(queue, result))
230 shutdown(1, "mq_getattr()", __LINE__);
231 if (mq_close(queue))
232 shutdown(1, "mq_close()", __LINE__);
233 queue = -1;
234 if (mq_unlink(queue_path))
235 shutdown(1, "mq_unlink()", __LINE__);
236 return 1;
237 }
238
main(int argc,char * argv[])239 int main(int argc, char *argv[])
240 {
241 struct mq_attr attr, result;
242
243 if (argc != 2) {
244 printf("Using Default queue path - %s\n", default_queue_path);
245 queue_path = default_queue_path;
246 } else {
247
248 /*
249 * Although we can create a msg queue with a non-absolute path name,
250 * unlink will fail. So, if the name doesn't start with a /, add one
251 * when we save it.
252 */
253 if (*argv[1] == '/')
254 queue_path = strdup(argv[1]);
255 else {
256 queue_path = malloc(strlen(argv[1]) + 2);
257 if (!queue_path) {
258 perror("malloc()");
259 exit(1);
260 }
261 queue_path[0] = '/';
262 queue_path[1] = 0;
263 strcat(queue_path, argv[1]);
264 }
265 }
266
267 if (getuid() != 0)
268 ksft_exit_skip("Not running as root, but almost all tests "
269 "require root in order to modify\nsystem settings. "
270 "Exiting.\n");
271
272 /* Find out what files there are for us to make tweaks in */
273 def_msgs = fopen(DEF_MSGS, "r+");
274 def_msgsize = fopen(DEF_MSGSIZE, "r+");
275 max_msgs = fopen(MAX_MSGS, "r+");
276 max_msgsize = fopen(MAX_MSGSIZE, "r+");
277
278 if (!max_msgs)
279 shutdown(2, "Failed to open msg_max", __LINE__);
280 if (!max_msgsize)
281 shutdown(2, "Failed to open msgsize_max", __LINE__);
282 if (def_msgs || def_msgsize)
283 default_settings = 1;
284
285 /* Load up the current system values for everything we can */
286 getr(RLIMIT_MSGQUEUE, &saved_limits);
287 cur_limits = saved_limits;
288 if (default_settings) {
289 saved_def_msgs = cur_def_msgs = get(def_msgs);
290 saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
291 }
292 saved_max_msgs = cur_max_msgs = get(max_msgs);
293 saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
294
295 /* Tell the user our initial state */
296 printf("\nInitial system state:\n");
297 printf("\tUsing queue path:\t\t%s\n", queue_path);
298 printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n",
299 (long) saved_limits.rlim_cur);
300 printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n",
301 (long) saved_limits.rlim_max);
302 printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
303 printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
304 if (default_settings) {
305 printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
306 printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
307 } else {
308 printf("\tDefault Message Size:\t\tNot Supported\n");
309 printf("\tDefault Queue Size:\t\tNot Supported\n");
310 }
311 printf("\n");
312
313 validate_current_settings();
314
315 printf("Adjusted system state for testing:\n");
316 printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n", (long) cur_limits.rlim_cur);
317 printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n", (long) cur_limits.rlim_max);
318 printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
319 printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
320 if (default_settings) {
321 printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
322 printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
323 }
324
325 printf("\n\nTest series 1, behavior when no attr struct "
326 "passed to mq_open:\n");
327 if (!default_settings) {
328 test_queue(NULL, &result);
329 printf("Given sane system settings, mq_open without an attr "
330 "struct succeeds:\tPASS\n");
331 if (result.mq_maxmsg != cur_max_msgs ||
332 result.mq_msgsize != cur_max_msgsize) {
333 printf("Kernel does not support setting the default "
334 "mq attributes,\nbut also doesn't tie the "
335 "defaults to the maximums:\t\t\tPASS\n");
336 } else {
337 set(max_msgs, ++cur_max_msgs);
338 set(max_msgsize, ++cur_max_msgsize);
339 test_queue(NULL, &result);
340 if (result.mq_maxmsg == cur_max_msgs &&
341 result.mq_msgsize == cur_max_msgsize)
342 printf("Kernel does not support setting the "
343 "default mq attributes and\n"
344 "also ties system wide defaults to "
345 "the system wide maximums:\t\t"
346 "FAIL\n");
347 else
348 printf("Kernel does not support setting the "
349 "default mq attributes,\n"
350 "but also doesn't tie the defaults to "
351 "the maximums:\t\t\tPASS\n");
352 }
353 } else {
354 printf("Kernel supports setting defaults separately from "
355 "maximums:\t\tPASS\n");
356 /*
357 * While we are here, go ahead and test that the kernel
358 * properly follows the default settings
359 */
360 test_queue(NULL, &result);
361 printf("Given sane values, mq_open without an attr struct "
362 "succeeds:\t\tPASS\n");
363 if (result.mq_maxmsg != cur_def_msgs ||
364 result.mq_msgsize != cur_def_msgsize)
365 printf("Kernel supports setting defaults, but does "
366 "not actually honor them:\tFAIL\n\n");
367 else {
368 set(def_msgs, ++cur_def_msgs);
369 set(def_msgsize, ++cur_def_msgsize);
370 /* In case max was the same as the default */
371 set(max_msgs, ++cur_max_msgs);
372 set(max_msgsize, ++cur_max_msgsize);
373 test_queue(NULL, &result);
374 if (result.mq_maxmsg != cur_def_msgs ||
375 result.mq_msgsize != cur_def_msgsize)
376 printf("Kernel supports setting defaults, but "
377 "does not actually honor them:\t"
378 "FAIL\n");
379 else
380 printf("Kernel properly honors default setting "
381 "knobs:\t\t\t\tPASS\n");
382 }
383 set(def_msgs, cur_max_msgs + 1);
384 cur_def_msgs = cur_max_msgs + 1;
385 set(def_msgsize, cur_max_msgsize + 1);
386 cur_def_msgsize = cur_max_msgsize + 1;
387 if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
388 cur_limits.rlim_cur) {
389 cur_limits.rlim_cur = (cur_def_msgs + 2) *
390 (cur_def_msgsize + 2 * sizeof(void *));
391 cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
392 setr(RLIMIT_MSGQUEUE, &cur_limits);
393 }
394 if (test_queue_fail(NULL, &result)) {
395 if (result.mq_maxmsg == cur_max_msgs &&
396 result.mq_msgsize == cur_max_msgsize)
397 printf("Kernel properly limits default values "
398 "to lesser of default/max:\t\tPASS\n");
399 else
400 printf("Kernel does not properly set default "
401 "queue parameters when\ndefaults > "
402 "max:\t\t\t\t\t\t\t\tFAIL\n");
403 } else
404 printf("Kernel fails to open mq because defaults are "
405 "greater than maximums:\tFAIL\n");
406 set(def_msgs, --cur_def_msgs);
407 set(def_msgsize, --cur_def_msgsize);
408 cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
409 cur_def_msgsize;
410 setr(RLIMIT_MSGQUEUE, &cur_limits);
411 if (test_queue_fail(NULL, &result))
412 printf("Kernel creates queue even though defaults "
413 "would exceed\nrlimit setting:"
414 "\t\t\t\t\t\t\t\tFAIL\n");
415 else
416 printf("Kernel properly fails to create queue when "
417 "defaults would\nexceed rlimit:"
418 "\t\t\t\t\t\t\t\tPASS\n");
419 }
420
421 /*
422 * Test #2 - open with an attr struct that exceeds rlimit
423 */
424 printf("\n\nTest series 2, behavior when attr struct is "
425 "passed to mq_open:\n");
426 cur_max_msgs = 32;
427 cur_max_msgsize = cur_limits.rlim_max >> 4;
428 set(max_msgs, cur_max_msgs);
429 set(max_msgsize, cur_max_msgsize);
430 attr.mq_maxmsg = cur_max_msgs;
431 attr.mq_msgsize = cur_max_msgsize;
432 if (test_queue_fail(&attr, &result))
433 printf("Queue open in excess of rlimit max when euid = 0 "
434 "succeeded:\t\tFAIL\n");
435 else
436 printf("Queue open in excess of rlimit max when euid = 0 "
437 "failed:\t\tPASS\n");
438 attr.mq_maxmsg = cur_max_msgs + 1;
439 attr.mq_msgsize = 10;
440 if (test_queue_fail(&attr, &result))
441 printf("Queue open with mq_maxmsg > limit when euid = 0 "
442 "succeeded:\t\tPASS\n");
443 else
444 printf("Queue open with mq_maxmsg > limit when euid = 0 "
445 "failed:\t\tFAIL\n");
446 attr.mq_maxmsg = 1;
447 attr.mq_msgsize = cur_max_msgsize + 1;
448 if (test_queue_fail(&attr, &result))
449 printf("Queue open with mq_msgsize > limit when euid = 0 "
450 "succeeded:\t\tPASS\n");
451 else
452 printf("Queue open with mq_msgsize > limit when euid = 0 "
453 "failed:\t\tFAIL\n");
454 attr.mq_maxmsg = 65536;
455 attr.mq_msgsize = 65536;
456 if (test_queue_fail(&attr, &result))
457 printf("Queue open with total size > 2GB when euid = 0 "
458 "succeeded:\t\tFAIL\n");
459 else
460 printf("Queue open with total size > 2GB when euid = 0 "
461 "failed:\t\t\tPASS\n");
462
463 if (seteuid(99) == -1) {
464 perror("seteuid() failed");
465 exit(1);
466 }
467
468 attr.mq_maxmsg = cur_max_msgs;
469 attr.mq_msgsize = cur_max_msgsize;
470 if (test_queue_fail(&attr, &result))
471 printf("Queue open in excess of rlimit max when euid = 99 "
472 "succeeded:\t\tFAIL\n");
473 else
474 printf("Queue open in excess of rlimit max when euid = 99 "
475 "failed:\t\tPASS\n");
476 attr.mq_maxmsg = cur_max_msgs + 1;
477 attr.mq_msgsize = 10;
478 if (test_queue_fail(&attr, &result))
479 printf("Queue open with mq_maxmsg > limit when euid = 99 "
480 "succeeded:\t\tFAIL\n");
481 else
482 printf("Queue open with mq_maxmsg > limit when euid = 99 "
483 "failed:\t\tPASS\n");
484 attr.mq_maxmsg = 1;
485 attr.mq_msgsize = cur_max_msgsize + 1;
486 if (test_queue_fail(&attr, &result))
487 printf("Queue open with mq_msgsize > limit when euid = 99 "
488 "succeeded:\t\tFAIL\n");
489 else
490 printf("Queue open with mq_msgsize > limit when euid = 99 "
491 "failed:\t\tPASS\n");
492 attr.mq_maxmsg = 65536;
493 attr.mq_msgsize = 65536;
494 if (test_queue_fail(&attr, &result))
495 printf("Queue open with total size > 2GB when euid = 99 "
496 "succeeded:\t\tFAIL\n");
497 else
498 printf("Queue open with total size > 2GB when euid = 99 "
499 "failed:\t\t\tPASS\n");
500
501 shutdown(0,"",0);
502 }
503