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