tests/unit/test_fd_tracker.c

   1 /*
   2  * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <stdlib.h>
   9 #include <inttypes.h>
  10 #include <stdbool.h>
  11 #include <assert.h>
  12 #include <string.h>
  13 #include <stdarg.h>
  14 #include <tap/tap.h>
  15 #include <sys/types.h>
  16 #include <dirent.h>
  17 #include <stdio.h>
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <sys/stat.h>
  21 #include <sys/types.h>
  22
  23 #include <urcu.h>
  24
  25 #include <common/compat/directory-handle.h>
  26 #include <common/compat/errno.h>
  27 #include <common/error.h>
  28 #include <common/fd-tracker/fd-tracker.h>
  29
  30 /* For error.h */
  31 int lttng_opt_quiet = 1;
  32 int lttng_opt_verbose;
  33 int lttng_opt_mi;
  34
  35 /* Number of TAP tests in this file */
  36 #define NUM_TESTS 61
  37 /* 3 for stdin, stdout, and stderr */
  38 #define STDIO_FD_COUNT 3
  39 #define TRACKER_FD_LIMIT 50
  40 #define TMP_DIR_PATTERN "/tmp/fd-tracker-XXXXXX"
  41 #define TEST_UNLINK_DIRECTORY_NAME "unlinked_files"
  42
  43 #ifdef __linux__
  44 #define SELF_FD_DIR "/proc/self/fd"
  45 #else
  46 /* Most Unices have /dev/fd */
  47 #define SELF_FD_DIR "/dev/fd"
  48 #endif
  49
  50 /*
  51  * Count of fds, beyond stdin, stderr, stdout that were open
  52  * at the launch of the test. This allows the test to succeed when
  53  * run by automake's test runner or valgrind which both open
  54  * fds behind our back.
  55  */
  56 int unknown_fds_count;
  57
  58 const char file_contents[] = "Bacon ipsum dolor amet jerky drumstick sirloin "
  59         "strip steak venison boudin filet mignon picanha doner shoulder. "
  60         "Strip steak brisket alcatra, venison beef chuck cupim pastrami. "
  61         "Landjaeger tri-tip salami leberkas ball tip, ham hock chuck sausage "
  62         "flank jerky cupim. Pig bacon chuck pancetta andouille.";
  63
  64 static
  65 void get_temporary_directories(char **_test_directory, char **_unlink_directory)
  66 {
  67         int ret;
  68         char tmp_path_pattern[] = TMP_DIR_PATTERN;
  69         char *output_dir;
  70
  71         output_dir = mkdtemp(tmp_path_pattern);
  72         if (!output_dir) {
  73                 diag("Failed to create temporary path of the form %s",
  74                                 TMP_DIR_PATTERN);
  75                 assert(0);
  76         }
  77
  78         *_test_directory = strdup(output_dir);
  79         assert(*_test_directory);
  80         ret = asprintf(_unlink_directory, "%s/%s", output_dir,
  81                         TEST_UNLINK_DIRECTORY_NAME);
  82         if (ret < 0) {
  83                 assert(0);
  84         }
  85 }
  86
  87 static
  88 int fd_count(void)
  89 {
  90         DIR *dir;
  91         struct dirent *entry;
  92         int count = 0;
  93
  94         dir = opendir(SELF_FD_DIR);
  95         if (!dir) {
  96                 perror("# Failed to enumerate " SELF_FD_DIR " to count the number of used file descriptors");
  97                 count = -1;
  98                 goto end;
  99         }
 100
 101         while ((entry = readdir(dir)) != NULL) {
 102                 if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
 103                         continue;
 104                 }
 105                 count++;
 106         }
 107         /* Don't account for the file descriptor opened by opendir(). */
 108         count--;
 109         if (closedir(dir)) {
 110                 perror("# Failed to close test program's " SELF_FD_DIR " directory file descriptor");
 111         }
 112 end:
 113         return count;
 114 }
 115
 116 static
 117 void check_fd_count(int expected_count)
 118 {
 119         int count = 0;
 120
 121         count = fd_count();
 122         ok(count == expected_count, "Expected %d open file descriptors (%d are open)",
 123                         expected_count, count);
 124 }
 125
 126 static
 127 int noop_open(void *data, int *fds)
 128 {
 129         *fds = *((int *) data);
 130         return 0;
 131 }
 132
 133 static
 134 int noop_close(void *data, int *fds)
 135 {
 136         return 0;
 137 }
 138
 139 static
 140 void track_std_fds(struct fd_tracker *tracker)
 141 {
 142         int i;
 143         struct { int fd; const char *name; } files[] = {
 144                 { .fd = fileno(stdin), .name = "stdin" },
 145                 { .fd = fileno(stdout), .name = "stdout" },
 146                 { .fd = fileno(stderr), .name = "stderr" },
 147         };
 148
 149         for (i = 0; i < sizeof(files) / sizeof(*files); i++) {
 150                 int out_fd, ret;
 151
 152                 ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 153                                 &files[i].name, 1, noop_open, &files[i].fd);
 154                 assert(out_fd == files[i].fd);
 155
 156                 ok(ret == 0, "Track unsuspendable fd %d (%s)", files[i].fd,
 157                                 files[i].name);
 158         }
 159 }
 160
 161 static
 162 void untrack_std_fds(struct fd_tracker *tracker)
 163 {
 164         int i;
 165         struct { int fd; const char *name; } files[] = {
 166                 { .fd = fileno(stdin), .name = "stdin" },
 167                 { .fd = fileno(stdout), .name = "stdout" },
 168                 { .fd = fileno(stderr), .name = "stderr" },
 169         };
 170         unsigned int fds_set_to_minus_1 = 0;
 171
 172         for (i = 0; i < sizeof(files) / sizeof(*files); i++) {
 173                 int fd = files[i].fd;
 174                 int ret = fd_tracker_close_unsuspendable_fd(tracker,
 175                                 &files[i].fd, 1, noop_close, NULL);
 176
 177                 ok(ret == 0, "Untrack unsuspendable fd %d (%s)", fd,
 178                                 files[i].name);
 179                 fds_set_to_minus_1 += (files[i].fd == -1);
 180         }
 181 }
 182
 183 /*
 184  * Basic test opening and closing three unsuspendable fds.
 185  */
 186 static
 187 void test_unsuspendable_basic(void)
 188 {
 189         int ret;
 190         struct fd_tracker *tracker;
 191         char *test_directory = NULL, *unlinked_files_directory = NULL;
 192
 193         get_temporary_directories(&test_directory, &unlinked_files_directory);
 194
 195         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 196         ok(tracker, "Created an fd tracker with a limit of %d simulateously opened file descriptors",
 197                         TRACKER_FD_LIMIT);
 198         if (!tracker) {
 199                 goto end;
 200         }
 201
 202         track_std_fds(tracker);
 203         untrack_std_fds(tracker);
 204
 205         fd_tracker_destroy(tracker);
 206         ret = rmdir(test_directory);
 207         ok(ret == 0, "Test directory is empty");
 208 end:
 209         free(test_directory);
 210         free(unlinked_files_directory);
 211 }
 212
 213 static
 214 int error_open(void *data, int *fds)
 215 {
 216         return *((int *) data);
 217 }
 218
 219 static
 220 int error_close(void *data, int *fds)
 221 {
 222         return *((int *) data);
 223 }
 224
 225 /*
 226  * Validate that user callback return values are returned to the
 227  * caller of the fd tracker.
 228  */
 229 static
 230 void test_unsuspendable_cb_return(void)
 231 {
 232         int ret, stdout_fd = fileno(stdout), out_fd = 42;
 233         struct fd_tracker *tracker;
 234         int expected_error = -ENETDOWN;
 235         char *test_directory = NULL, *unlinked_files_directory = NULL;
 236
 237         get_temporary_directories(&test_directory, &unlinked_files_directory);
 238
 239         tracker = fd_tracker_create(test_directory, TRACKER_FD_LIMIT);
 240         assert(tracker);
 241
 242         /* The error_open callback should fail and return 'expected_error'. */
 243         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 244                         NULL, 1, error_open, &expected_error);
 245         ok(ret == expected_error, "fd_tracker_open_unsuspendable_fd() forwards the user callback's error code");
 246         ok(out_fd == 42, "Output fd parameter is unaffected on error of fd_tracker_open_unsuspendable_fd()");
 247
 248         /*
 249          * Track a valid fd since we don't want the tracker to fail with an
 250          * invalid fd error for this test.
 251          */
 252         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 253                         NULL, 1, noop_open, &stdout_fd);
 254         ok(out_fd == stdout_fd, "fd_tracker_open_unsuspendable_fd() sets the output fd parameter to the newly-tracked fd's value");
 255         assert(!ret);
 256
 257         ret = fd_tracker_close_unsuspendable_fd(tracker,
 258                         &stdout_fd, 1, error_close, &expected_error);
 259         ok(ret == expected_error, "fd_tracker_close_unsuspendable_fd() forwards the user callback's error code");
 260         ret = fd_tracker_close_unsuspendable_fd(tracker,
 261                         &stdout_fd, 1, noop_close, &expected_error);
 262         assert(!ret);
 263
 264         fd_tracker_destroy(tracker);
 265         ret = rmdir(test_directory);
 266         ok(ret == 0, "Test directory is empty");
 267         free(test_directory);
 268         free(unlinked_files_directory);
 269 }
 270
 271 /*
 272  * Validate that the tracker refuses to track two identical unsuspendable
 273  * file descriptors.
 274  */
 275 static
 276 void test_unsuspendable_duplicate(void)
 277 {
 278         int ret, stdout_fd = fileno(stdout), out_fd;
 279         struct fd_tracker *tracker;
 280         char *test_directory = NULL, *unlinked_files_directory = NULL;
 281
 282         get_temporary_directories(&test_directory, &unlinked_files_directory);
 283
 284         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 285         assert(tracker);
 286
 287         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 288                         NULL, 1, noop_open, &stdout_fd);
 289         assert(!ret);
 290         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 291                         NULL, 1, noop_open, &stdout_fd);
 292         ok(ret == -EEXIST, "EEXIST reported on open of an already tracked file descriptor");
 293
 294         ret = fd_tracker_close_unsuspendable_fd(tracker,
 295                         &stdout_fd, 1, noop_close, NULL);
 296         assert(!ret);
 297
 298         fd_tracker_destroy(tracker);
 299         ret = rmdir(test_directory);
 300         ok(ret == 0, "Test directory is empty");
 301         free(test_directory);
 302         free(unlinked_files_directory);
 303 }
 304
 305 static
 306 int open_pipes(void *data, int *out_fds)
 307 {
 308         unsigned int i;
 309         const unsigned int pipe_count = TRACKER_FD_LIMIT / 2;
 310
 311         for (i = 0; i < pipe_count; i++) {
 312                 int ret = pipe(&out_fds[i * 2]);
 313
 314                 if (ret) {
 315                         return -errno;
 316                 }
 317         }
 318         return 0;
 319 }
 320
 321 static
 322 int close_pipes(void *data, int *fds)
 323 {
 324         int i;
 325         int *pipes = fds;
 326
 327         for (i = 0; i < TRACKER_FD_LIMIT; i++) {
 328                 int ret = close(pipes[i]);
 329
 330                 if (ret) {
 331                         return -errno;
 332                 }
 333         }
 334         return 0;
 335 }
 336
 337 /*
 338  * Validate that the tracker enforces the open file descriptor limit
 339  * when unsuspendable file descriptors are being opened.
 340  */
 341 static
 342 void test_unsuspendable_limit(void)
 343 {
 344         struct fd_tracker *tracker;
 345         int ret, stdout_fd = fileno(stdout), out_fd;
 346         int fds[TRACKER_FD_LIMIT];
 347         char *test_directory = NULL, *unlinked_files_directory = NULL;
 348
 349         get_temporary_directories(&test_directory, &unlinked_files_directory);
 350
 351         /* This test assumes TRACKER_FD_LIMIT is a multiple of 2. */
 352         assert((TRACKER_FD_LIMIT % 2 == 0) && TRACKER_FD_LIMIT);
 353
 354         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 355         assert(tracker);
 356
 357         ret = fd_tracker_open_unsuspendable_fd(tracker, fds,
 358                         NULL, TRACKER_FD_LIMIT, open_pipes, NULL);
 359         ok(ret == 0, "File descriptor tracker allowed the user to meet its limit with unsuspendable file descriptors (%d)",
 360                         TRACKER_FD_LIMIT);
 361
 362         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 363                         NULL, 1, noop_open, &stdout_fd);
 364         ok(ret == -EMFILE, "EMFILE reported when exceeding the file descriptor limit while opening an unsuspendable fd");
 365
 366         ret = fd_tracker_close_unsuspendable_fd(tracker,
 367                         fds, TRACKER_FD_LIMIT, close_pipes, NULL);
 368         assert(!ret);
 369
 370         fd_tracker_destroy(tracker);
 371         ret = rmdir(test_directory);
 372         ok(ret == 0, "Test directory is empty");
 373         free(test_directory);
 374         free(unlinked_files_directory);
 375 }
 376
 377 /*
 378  * Validate that the tracker refuses to track two identical unsuspendable
 379  * file descriptors.
 380  */
 381 static
 382 void test_unsuspendable_close_untracked(void)
 383 {
 384         int ret, stdout_fd = fileno(stdout), unknown_fds[2], out_fd;
 385         struct fd_tracker *tracker;
 386         char *test_directory = NULL, *unlinked_files_directory = NULL;
 387
 388         get_temporary_directories(&test_directory, &unlinked_files_directory);
 389
 390         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 391         if (!tracker) {
 392                 goto end;;
 393         }
 394
 395         ret = pipe(unknown_fds);
 396         assert(!ret);
 397         assert(close(unknown_fds[0]) == 0);
 398         assert(close(unknown_fds[1]) == 0);
 399
 400         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
 401                         NULL, 1, noop_open, &stdout_fd);
 402         assert(!ret);
 403
 404         ret = fd_tracker_close_unsuspendable_fd(tracker,
 405                         unknown_fds, 1, noop_close, NULL);
 406         ok(ret == -EINVAL, "EINVAL reported on close of an untracked file descriptor");
 407
 408         ret = fd_tracker_close_unsuspendable_fd(tracker,
 409                         &stdout_fd, 1, noop_close, NULL);
 410         assert(!ret);
 411
 412         fd_tracker_destroy(tracker);
 413         ret = rmdir(test_directory);
 414         ok(ret == 0, "Test directory is empty");
 415 end:
 416         free(test_directory);
 417         free(unlinked_files_directory);
 418 }
 419
 420 static int open_files(struct fd_tracker *tracker,
 421                 struct lttng_directory_handle *directory,
 422                 unsigned int count,
 423                 struct fs_handle **handles,
 424                 char **file_paths)
 425 {
 426         int ret = 0;
 427         unsigned int i;
 428
 429         for (i = 0; i < count; i++) {
 430                 int p_ret;
 431                 char *file_path;
 432                 struct fs_handle *handle;
 433                 mode_t mode = S_IWUSR | S_IRUSR;
 434
 435                 p_ret = asprintf(&file_path, "file-%u", i);
 436                 assert(p_ret >= 0);
 437                 file_paths[i] = file_path;
 438
 439                 handle = fd_tracker_open_fs_handle(tracker, directory, file_path,
 440                                 O_RDWR | O_CREAT, &mode);
 441                 if (!handle) {
 442                         ret = -1;
 443                         break;
 444                 }
 445                 handles[i] = handle;
 446         }
 447         return ret;
 448 }
 449
 450 static int open_same_file(struct fd_tracker *tracker,
 451                 struct lttng_directory_handle *directory,
 452                 const char *file,
 453                 unsigned int count,
 454                 struct fs_handle **handles)
 455 {
 456         int ret = 0;
 457         unsigned int i;
 458
 459         for (i = 0; i < count; i++) {
 460                 struct fs_handle *handle;
 461                 mode_t mode = S_IWUSR | S_IRUSR;
 462
 463                 handle = fd_tracker_open_fs_handle(tracker, directory, file,
 464                                 O_RDWR | O_CREAT, &mode);
 465                 if (!handle) {
 466                         ret = -1;
 467                         break;
 468                 }
 469                 handles[i] = handle;
 470         }
 471         return ret;
 472 }
 473
 474 static
 475 int cleanup_files(struct fd_tracker *tracker, const char *dir,
 476                 unsigned int count, struct fs_handle **handles,
 477                 char **file_paths)
 478 {
 479         int ret = 0;
 480         unsigned int i;
 481
 482         for (i = 0; i < count; i++) {
 483                 char *file_path = file_paths[i];
 484
 485                 if (!file_path) {
 486                         break;
 487                 }
 488                 if (fs_handle_unlink(handles[i])) {
 489                         diag("Failed to unlink fs_handle to file %s", file_path);
 490                         ret = -1;
 491                 }
 492                 if (fs_handle_close(handles[i])) {
 493                         diag("Failed to close fs_handle to file %s", file_path);
 494                         ret = -1;
 495                 }
 496                 free(file_path);
 497         }
 498         return ret;
 499 }
 500
 501 static
 502 void test_suspendable_limit(void)
 503 {
 504         int ret;
 505         const int files_to_create = TRACKER_FD_LIMIT * 10;
 506         struct fd_tracker *tracker;
 507         char *test_directory = NULL, *unlinked_files_directory = NULL;
 508         char *output_files[files_to_create];
 509         struct fs_handle *handles[files_to_create];
 510         struct lttng_directory_handle *dir_handle = NULL;
 511         int dir_handle_fd_count;
 512
 513         memset(output_files, 0, sizeof(output_files));
 514         memset(handles, 0, sizeof(handles));
 515
 516         get_temporary_directories(&test_directory, &unlinked_files_directory);
 517
 518         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 519         if (!tracker) {
 520                 goto end;
 521         }
 522
 523         dir_handle = lttng_directory_handle_create(test_directory);
 524         assert(dir_handle);
 525         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 526
 527         ret = open_files(tracker, dir_handle, files_to_create, handles,
 528                         output_files);
 529         ok(!ret, "Created %d files with a limit of %d simultaneously-opened file descriptor",
 530                         files_to_create, TRACKER_FD_LIMIT);
 531         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count +
 532                         dir_handle_fd_count);
 533
 534         ret = cleanup_files(tracker, test_directory, files_to_create, handles,
 535                         output_files);
 536         ok(!ret, "Close all opened filesystem handles");
 537         ret = rmdir(test_directory);
 538         ok(ret == 0, "Test directory is empty");
 539         fd_tracker_destroy(tracker);
 540         lttng_directory_handle_put(dir_handle);
 541 end:
 542         free(test_directory);
 543         free(unlinked_files_directory);
 544 }
 545
 546 static
 547 void test_mixed_limit(void)
 548 {
 549         int ret;
 550         const int files_to_create = TRACKER_FD_LIMIT;
 551         struct fd_tracker *tracker;
 552         char *test_directory = NULL, *unlinked_files_directory = NULL;
 553         char *output_files[files_to_create];
 554         struct fs_handle *handles[files_to_create];
 555         struct lttng_directory_handle *dir_handle = NULL;
 556         int dir_handle_fd_count;
 557
 558         memset(output_files, 0, sizeof(output_files));
 559         memset(handles, 0, sizeof(handles));
 560
 561         get_temporary_directories(&test_directory, &unlinked_files_directory);
 562
 563         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 564         if (!tracker) {
 565                 goto end;
 566         }
 567
 568         dir_handle = lttng_directory_handle_create(test_directory);
 569         assert(dir_handle);
 570         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 571
 572         ret = open_files(tracker, dir_handle, files_to_create, handles,
 573                         output_files);
 574         ok(!ret, "Created %d files with a limit of %d simultaneously-opened file descriptor",
 575                         files_to_create, TRACKER_FD_LIMIT);
 576         diag("Check file descriptor count after opening %u files", files_to_create);
 577         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count +
 578                         dir_handle_fd_count);
 579
 580         /*
 581          * Open unsuspendable fds (stdin, stdout, stderr) and verify that the fd
 582          * cap is still respected.
 583          */
 584         diag("Check file descriptor count after adding %d unsuspendable fds",
 585                         STDIO_FD_COUNT);
 586         track_std_fds(tracker);
 587         check_fd_count(TRACKER_FD_LIMIT + unknown_fds_count +
 588                         dir_handle_fd_count);
 589         diag("Untrack unsuspendable file descriptors");
 590         untrack_std_fds(tracker);
 591         check_fd_count(TRACKER_FD_LIMIT + unknown_fds_count +
 592                         dir_handle_fd_count);
 593
 594         ret = cleanup_files(tracker, test_directory, files_to_create, handles,
 595                         output_files);
 596         ok(!ret, "Close all opened filesystem handles");
 597         ret = rmdir(test_directory);
 598         ok(ret == 0, "Test directory is empty");
 599         fd_tracker_destroy(tracker);
 600         lttng_directory_handle_put(dir_handle);
 601 end:
 602         free(test_directory);
 603         free(unlinked_files_directory);
 604 }
 605
 606 /*
 607  * Open more files than allowed by the fd tracker's cap and write,
 608  * byte-by-byte, and in round-robin, a string. The goal is to force
 609  * the fd tracker to suspend and resume the fs_handles often and
 610  * verify that the fd cap is always respected.
 611  *
 612  * The content of the files is also verified at the end.
 613  */
 614 static
 615 void test_suspendable_restore(void)
 616 {
 617         int ret;
 618         const int files_to_create = TRACKER_FD_LIMIT * 10;
 619         struct fd_tracker *tracker;
 620         char *output_files[files_to_create];
 621         struct fs_handle *handles[files_to_create];
 622         size_t content_index;
 623         int handle_index;
 624         bool write_success = true;
 625         bool fd_cap_respected = true;
 626         bool content_ok = true;
 627         struct lttng_directory_handle *dir_handle = NULL;
 628         int dir_handle_fd_count;
 629         char *test_directory = NULL, *unlinked_files_directory = NULL;
 630
 631         memset(output_files, 0, sizeof(output_files));
 632         memset(handles, 0, sizeof(handles));
 633
 634         get_temporary_directories(&test_directory, &unlinked_files_directory);
 635
 636         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 637         if (!tracker) {
 638                 goto end;
 639         }
 640
 641         dir_handle = lttng_directory_handle_create(test_directory);
 642         assert(dir_handle);
 643         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 644
 645         ret = open_files(tracker, dir_handle, files_to_create, handles,
 646                         output_files);
 647         ok(!ret, "Created %d files with a limit of %d simultaneously-opened file descriptor",
 648                         files_to_create, TRACKER_FD_LIMIT);
 649         diag("Check file descriptor count after opening %u files", files_to_create);
 650         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count +
 651                         dir_handle_fd_count);
 652
 653         for (content_index = 0; content_index < sizeof(file_contents); content_index++) {
 654                 for (handle_index = 0; handle_index < files_to_create; handle_index++) {
 655                         int fd;
 656                         struct fs_handle *handle = handles[handle_index];
 657                         const char *path = output_files[handle_index];
 658
 659                         fd = fs_handle_get_fd(handle);
 660                         if (fd < 0) {
 661                                 write_success = false;
 662                                 diag("Failed to restore fs_handle to %s",
 663                                                 path);
 664                                 goto skip_write;
 665                         }
 666
 667                         do {
 668                                 ret = write(fd, file_contents + content_index, 1);
 669                         } while (ret < 0 && errno == EINTR);
 670
 671                         if (ret != 1) {
 672                                 write_success = false;
 673                                 PERROR("write() to %s failed", path);
 674                                 goto skip_write;
 675                         }
 676
 677                         if (fd_count() > (TRACKER_FD_LIMIT + STDIO_FD_COUNT +
 678                                                         unknown_fds_count +
 679                                                         dir_handle_fd_count)) {
 680                                 fd_cap_respected = false;
 681                         }
 682
 683                         fs_handle_put_fd(handle);
 684                 }
 685         }
 686 skip_write:
 687         ok(write_success, "Wrote reference string to %d files",
 688                         files_to_create);
 689         ok(fd_cap_respected, "FD tracker enforced the file descriptor cap");
 690
 691         /* Validate the contents of the files. */
 692         for (handle_index = 0; handle_index < files_to_create; handle_index++) {
 693                 struct stat fd_stat;
 694                 const char *path = output_files[handle_index];
 695                 char read_buf[sizeof(file_contents)];
 696                 char *read_pos;
 697                 size_t to_read = sizeof(read_buf);
 698                 int fd;
 699
 700                 fd = lttng_directory_handle_open_file(
 701                                 dir_handle, path, O_RDONLY, 0);
 702                 assert(fd >= 0);
 703                 ret = fstat(fd, &fd_stat);
 704                 assert(!ret);
 705                 if (fd_stat.st_size != sizeof(file_contents)) {
 706                         diag("Content size of file %s doesn't match, got %" PRId64 ", expected %zu",
 707                                         path, (int64_t) fd_stat.st_size,
 708                                         sizeof(file_contents));
 709                         content_ok = false;
 710                         (void) close(fd);
 711                         break;
 712                 }
 713
 714                 read_pos = read_buf;
 715                 do {
 716                         ret = read(fd, read_pos, to_read);
 717                         if (ret > 0) {
 718                                 to_read -= ret;
 719                                 read_pos += ret;
 720                         }
 721                 } while (to_read && (ret < 0 && errno == EINTR));
 722                 if (ret < 0) {
 723                         content_ok = false;
 724                         PERROR("Failed to read file %s", path);
 725                         (void) close(fd);
 726                         break;
 727                 }
 728
 729                 if (strcmp(file_contents, read_buf)) {
 730                         content_ok = false;
 731                         diag("File content doesn't match the expectated string");
 732                         (void) close(fd);
 733                         break;
 734                 }
 735                 (void) close(fd);
 736         }
 737         ok(content_ok, "Files contain the expected content");
 738         ret = cleanup_files(tracker, test_directory, files_to_create, handles,
 739                         output_files);
 740         ok(!ret, "Close all opened filesystem handles");
 741         ret = rmdir(test_directory);
 742         ok(ret == 0, "Test directory is empty");
 743         fd_tracker_destroy(tracker);
 744         lttng_directory_handle_put(dir_handle);
 745 end:
 746         free(test_directory);
 747         free(unlinked_files_directory);
 748 }
 749
 750 static
 751 void test_unlink(void)
 752 {
 753         int ret;
 754         struct fd_tracker *tracker;
 755         const int handles_to_open = 2;
 756         struct fs_handle *handles[handles_to_open];
 757         struct fs_handle *new_handle = NULL;
 758         struct stat statbuf;
 759         struct lttng_directory_handle *dir_handle = NULL;
 760         const char file_name[] = "my_file";
 761         char *test_directory = NULL, *unlinked_files_directory = NULL;
 762         char *unlinked_file_zero = NULL, *unlinked_file_one = NULL;
 763         int fd;
 764
 765         get_temporary_directories(&test_directory, &unlinked_files_directory);
 766         ret = asprintf(&unlinked_file_zero, "%s/%u", unlinked_files_directory,
 767                         0);
 768         assert(ret > 0);
 769         ret = asprintf(&unlinked_file_one, "%s/%u", unlinked_files_directory,
 770                         1);
 771         assert(ret > 0);
 772
 773         tracker = fd_tracker_create(unlinked_files_directory, 1);
 774         if (!tracker) {
 775                 goto end;
 776         }
 777
 778         dir_handle = lttng_directory_handle_create(test_directory);
 779         assert(dir_handle);
 780
 781         /* Open two handles to the same file. */
 782         ret = open_same_file(tracker, dir_handle, file_name, handles_to_open,
 783                         handles);
 784         ok(!ret, "Successfully opened %i handles to %s/%s", handles_to_open,
 785                         test_directory, file_name);
 786         if (ret) {
 787                 goto end;
 788         }
 789
 790         /*
 791          * Unlinking the first handle should cause the file to be renamed
 792          * to '0'.
 793          */
 794         ret = fs_handle_unlink(handles[0]);
 795         ok(!ret, "Successfully unlinked the first handle to %s/%s",
 796                         test_directory, file_name);
 797
 798         /*
 799          * The original file should no longer exist on the file system, and a
 800          * new file named '0' should exist.
 801          */
 802         ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 &&
 803                                         errno == ENOENT,
 804                         "%s no longer present on file system after unlink",
 805                         file_name);
 806         ok(lttng_directory_handle_stat(
 807                         dir_handle, unlinked_file_zero, &statbuf) == 0,
 808                         "%s exists on file system after unlink",
 809                         unlinked_file_zero);
 810
 811         /*
 812          * It should be possible to use the file descriptors of both handles.
 813          * Since only one file descriptor can be opened at once, this should
 814          * force the fd_tracker to suspend and restore the handles.
 815          */
 816         fd = fs_handle_get_fd(handles[0]);
 817         ok(fd >= 0, "Got fd from first handle");
 818
 819         fd = fs_handle_get_fd(handles[1]);
 820         ok (fd < 0, "fd tracker does not allow two fds to be used at once");
 821
 822         fs_handle_put_fd(handles[0]);
 823         fd = fs_handle_get_fd(handles[1]);
 824         ok(fd >= 0, "Got fd from second handle");
 825         fs_handle_put_fd(handles[1]);
 826
 827         /* The second unlink should fail with -ENOENT. */
 828         ret = fs_handle_unlink(handles[1]);
 829         ok(ret == -ENOENT,
 830                         "ENOENT is reported when attempting to unlink the second handle to %s/%s",
 831                         test_directory, file_name);
 832
 833         /*
 834          * Opening a new handle to 'my_file' should succeed.
 835          */
 836         ret = open_same_file(tracker, dir_handle, file_name, 1, &new_handle);
 837         ok(!ret, "Successfully opened a new handle to previously unlinked file %s/%s",
 838                         test_directory, file_name);
 839         assert(new_handle);
 840
 841         /*
 842          * Unlinking the new handle should cause the file to be renamed
 843          * to '1' since '0' already exists.
 844          */
 845         ret = fs_handle_unlink(new_handle);
 846         ok(!ret, "Successfully unlinked the new handle handle to %s/%s",
 847                         test_directory, file_name);
 848         ok(stat(unlinked_file_one, &statbuf) == 0,
 849                         "%s exists on file system after unlink",
 850                         unlinked_file_one);
 851
 852         ret = fs_handle_close(handles[0]);
 853         ok(!ret, "Successfully closed the first handle");
 854         ret = fs_handle_close(handles[1]);
 855         ok(!ret, "Successfully closed the second handle");
 856         ret = fs_handle_close(new_handle);
 857         ok(!ret, "Successfully closed the third handle");
 858
 859         ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 &&
 860                                         errno == ENOENT,
 861                         "%s no longer present on file system after handle close",
 862                         file_name);
 863         ok(lttng_directory_handle_stat(
 864                         dir_handle, unlinked_file_zero, &statbuf) == -1 &&
 865                                         errno == ENOENT,
 866                         "%s no longer present on file system after handle close",
 867                         unlinked_file_zero);
 868         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_one,
 869                         &statbuf) == -1 &&
 870                                         errno == ENOENT,
 871                         "%s no longer present on file system after handle close",
 872                         unlinked_file_one);
 873
 874         ret = rmdir(test_directory);
 875         ok(ret == 0, "Test directory is empty");
 876 end:
 877         fd_tracker_destroy(tracker);
 878         free(test_directory);
 879         free(unlinked_files_directory);
 880         free(unlinked_file_zero);
 881         free(unlinked_file_one);
 882         lttng_directory_handle_put(dir_handle);
 883 }
 884
 885 int main(int argc, char **argv)
 886 {
 887         plan_tests(NUM_TESTS);
 888         diag("File descriptor tracker unit tests");
 889
 890         rcu_register_thread();
 891
 892         unknown_fds_count = fd_count() - STDIO_FD_COUNT;
 893         assert(unknown_fds_count >= 0);
 894
 895         diag("Unsuspendable - basic");
 896         test_unsuspendable_basic();
 897         diag("Unsuspendable - callback return values");
 898         test_unsuspendable_cb_return();
 899         diag("Unsuspendable - duplicate file descriptors");
 900         test_unsuspendable_duplicate();
 901         diag("Unsuspendable - closing an untracked file descriptor");
 902         test_unsuspendable_close_untracked();
 903         diag("Unsuspendable - check that file descriptor limit is enforced");
 904         test_unsuspendable_limit();
 905
 906         diag("Suspendable - check that file descriptor limit is enforced");
 907         test_suspendable_limit();
 908         diag("Suspendable - restoration test");
 909         test_suspendable_restore();
 910
 911         diag("Mixed - check that file descriptor limit is enforced");
 912         test_mixed_limit();
 913
 914         diag("Suspendable - Unlinking test");
 915         test_unlink();
 916
 917         rcu_barrier();
 918         rcu_unregister_thread();
 919         return exit_status();
 920 }