tools/testing/selftests/mqueue/mq_open_tests.c

   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
  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
  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
 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
 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
 141 static inline void getr(int type, struct rlimit *rlim)
 142 {
 143         if (getrlimit(type, rlim))
 144                 shutdown(6, "getrlimit()", __LINE__ - 1);
 145 }
 146
 147 static inline void setr(int type, struct rlimit *rlim)
 148 {
 149         if (setrlimit(type, rlim))
 150                 shutdown(7, "setrlimit()", __LINE__ - 1);
 151 }
 152
 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  */
 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  */
 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
 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 }