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