lustre/tests/llapi_fid_test.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22
  23 /*
  24  * Copyright 2014 Cray Inc, all rights reserved.
  25  *
  26  * Copyright (c) 2016, Intel Corporation.
  27  *
  28  * Author: Frank Zago.
  29  *
  30  * A few portions are extracted from llapi_layout_test.c
  31  *
  32  * The purpose of this test is to test the llapi fid related function
  33  * (fid2path, path2fid, ...)
  34  *
  35  * The program will exit as soon a non zero error code is returned.
  36  */
  37
  38 #include <stdlib.h>
  39 #include <errno.h>
  40 #include <getopt.h>
  41 #include <fcntl.h>
  42 #include <unistd.h>
  43 #include <poll.h>
  44 #include <sys/ioctl.h>
  45 #include <time.h>
  46
  47 #include <lustre/lustreapi.h>
  48 #include <linux/lustre/lustre_idl.h>
  49
  50 #define ERROR(fmt, ...)                                                 \
  51         fprintf(stderr, "%s: %s:%d: %s: " fmt "\n",                     \
  52                 program_invocation_short_name, __FILE__, __LINE__,      \
  53                 __func__, ## __VA_ARGS__);
  54
  55 #define DIE(fmt, ...)                  \
  56         do {                           \
  57                 ERROR(fmt, ## __VA_ARGS__);     \
  58                 exit(EXIT_FAILURE);             \
  59         } while (0)
  60
  61 #define ASSERTF(cond, fmt, ...)                                         \
  62         do {                                                            \
  63                 if (!(cond))                                            \
  64                         DIE("assertion '%s' failed: "fmt,               \
  65                             #cond, ## __VA_ARGS__);                     \
  66         } while (0)
  67
  68 #define PERFORM(testfn) \
  69         do {                                                            \
  70                 cleanup();                                              \
  71                 fprintf(stderr, "Starting test " #testfn " at %lld\n",  \
  72                         (unsigned long long)time(NULL));                \
  73                 testfn();                                               \
  74                 fprintf(stderr, "Finishing test " #testfn " at %lld\n", \
  75                        (unsigned long long)time(NULL));                 \
  76                 cleanup();                                              \
  77         } while (0)
  78
  79 /* Name of file/directory. Will be set once and will not change. */
  80 static char mainpath[PATH_MAX];
  81 static const char *maindir = "llapi_fid_test_name_9585766";
  82
  83 static char fsmountdir[PATH_MAX];       /* Lustre mountpoint */
  84 static char *lustre_dir;                /* Test directory inside Lustre */
  85
  86 /* Cleanup our test directory. */
  87 static void cleanup(void)
  88 {
  89         char cmd[PATH_MAX];
  90         int rc;
  91
  92         rc = snprintf(cmd, sizeof(cmd), "rm -rf -- '%s'", mainpath);
  93         ASSERTF(rc > 0 && rc < sizeof(cmd),
  94                 "invalid delete command for path '%s'", mainpath);
  95         rc = system(cmd);
  96         ASSERTF(rc != -1, "Cannot execute rm command");
  97         ASSERTF(WEXITSTATUS(rc) == 0,
  98                 "rm command returned %d", WEXITSTATUS(rc));
  99 }
 100
 101 /* Helper - call path2fid, fd2fid and fid2path against an existing
 102  * file/directory */
 103 static void helper_fid2path(const char *filename, int fd)
 104 {
 105         struct lu_fid fid;
 106         struct lu_fid fid2;
 107         struct lu_fid fid3;
 108         char fidstr[FID_LEN + 1];
 109         char path1[PATH_MAX];
 110         char path2[PATH_MAX];
 111         char path3[PATH_MAX];
 112         long long recno1;
 113         long long recno2;
 114         int linkno1;
 115         int linkno2;
 116         int rc;
 117
 118         rc = llapi_path2fid(filename, &fid);
 119         ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 120                 filename, strerror(-rc));
 121
 122         /* Without braces */
 123         snprintf(fidstr, sizeof(fidstr), DFID_NOBRACE, PFID(&fid));
 124         recno1 = -1;
 125         linkno1 = 0;
 126         rc = llapi_fid2path(lustre_dir, fidstr, path1,
 127                             sizeof(path1), &recno1, &linkno1);
 128         ASSERTF(rc == 0, "llapi_fid2path failed for fid %s: %s",
 129                 fidstr, strerror(-rc));
 130
 131         /* Same with braces */
 132         snprintf(fidstr, sizeof(fidstr), DFID, PFID(&fid));
 133         recno2 = -1;
 134         linkno2 = 0;
 135         rc = llapi_fid2path(lustre_dir, fidstr, path2,
 136                             sizeof(path2), &recno2, &linkno2);
 137         ASSERTF(rc == 0, "llapi_fid2path failed for fid %s: %s",
 138                 fidstr, strerror(-rc));
 139
 140         /* Make sure both calls to llapi_fid2path returned the same
 141          * data. */
 142         ASSERTF(strcmp(path1, path2) == 0, "paths are different: '%s' / '%s'",
 143                 path1, path2);
 144         ASSERTF(recno1 == recno2, "recnos are different: %lld / %lld",
 145                 recno1, recno2);
 146         ASSERTF(linkno1 == linkno2, "linknos are different: %d / %d",
 147                 linkno1, linkno2);
 148
 149         /* Try fd2fid and check that the result is still the same. */
 150         if (fd != -1) {
 151                 rc = llapi_fd2fid(fd, &fid3);
 152                 ASSERTF(rc == 0, "llapi_fd2fid failed for '%s': %s",
 153                         mainpath, strerror(-rc));
 154
 155                 ASSERTF(memcmp(&fid, &fid3, sizeof(fid)) == 0,
 156                         "fids are different");
 157         }
 158
 159         /* Pass the result back to fid2path and ensure the fid stays
 160          * the same. */
 161         rc = snprintf(path3, sizeof(path3), "%s/%s", fsmountdir, path1);
 162         ASSERTF((rc > 0 && rc < sizeof(path3)), "invalid name");
 163         rc = llapi_path2fid(path3, &fid2);
 164         ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 165                 path3, strerror(-rc));
 166         ASSERTF(memcmp(&fid, &fid2, sizeof(fid)) == 0, "fids are different");
 167 }
 168
 169 /* Test helper_fid2path */
 170 static void test10(void)
 171 {
 172         int rc;
 173         int fd;
 174         struct stat statbuf;
 175
 176         /* Against Lustre root */
 177         helper_fid2path(lustre_dir, -1);
 178
 179         /* Against a regular file */
 180         fd = creat(mainpath, 0);
 181         ASSERTF(fd >= 0, "creat failed for '%s': %s",
 182                 mainpath, strerror(errno));
 183         helper_fid2path(mainpath, fd);
 184         close(fd);
 185         rc = unlink(mainpath);
 186         ASSERTF(rc == 0, "unlink failed for '%s': %s",
 187                 mainpath, strerror(errno));
 188
 189         /* Against a pipe */
 190         rc = mkfifo(mainpath, 0);
 191         ASSERTF(rc == 0, "mkfifo failed for '%s': %s",
 192                 mainpath, strerror(errno));
 193         helper_fid2path(mainpath, -1);
 194         rc = unlink(mainpath);
 195         ASSERTF(rc == 0, "unlink failed for '%s': %s",
 196                 mainpath, strerror(errno));
 197
 198         /* Against a directory */
 199         rc = mkdir(mainpath, 0);
 200         ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 201                 mainpath, strerror(errno));
 202         helper_fid2path(mainpath, -1);
 203         rc = rmdir(mainpath);
 204         ASSERTF(rc == 0, "rmdir failed for '%s': %s",
 205                 mainpath, strerror(errno));
 206
 207         /* Against a char device. Use same as /dev/null in case things
 208          * go wrong. */
 209         rc = stat("/dev/null", &statbuf);
 210         ASSERTF(rc == 0, "stat failed for /dev/null: %s", strerror(errno));
 211         rc = mknod(mainpath, S_IFCHR, statbuf.st_rdev);
 212         ASSERTF(rc == 0, "mknod failed for '%s': %s",
 213                 mainpath, strerror(errno));
 214         helper_fid2path(mainpath, -1);
 215         rc = unlink(mainpath);
 216         ASSERTF(rc == 0, "unlink failed for '%s': %s",
 217                 mainpath, strerror(errno));
 218
 219         /* Against a block device device. Reuse same dev. */
 220         rc = mknod(mainpath, S_IFBLK, statbuf.st_rdev);
 221         ASSERTF(rc == 0, "mknod failed for '%s': %s",
 222                 mainpath, strerror(errno));
 223         helper_fid2path(mainpath, -1);
 224         rc = unlink(mainpath);
 225         ASSERTF(rc == 0, "unlink failed for '%s': %s",
 226                 mainpath, strerror(errno));
 227
 228         /* Against a socket. */
 229         rc = mknod(mainpath, S_IFSOCK, (dev_t)0);
 230         ASSERTF(rc == 0, "mknod failed for '%s': %s",
 231                 mainpath, strerror(errno));
 232         helper_fid2path(mainpath, -1);
 233         rc = unlink(mainpath);
 234         ASSERTF(rc == 0, "unlink failed for '%s': %s",
 235                 mainpath, strerror(errno));
 236 }
 237
 238 /* Test against deleted files. */
 239 static void test11(void)
 240 {
 241         int rc;
 242         int fd;
 243         struct lu_fid fid;
 244         char fidstr[FID_LEN + 1];
 245         char path[PATH_MAX];
 246         long long recno;
 247         int linkno;
 248
 249         /* Against a regular file */
 250         fd = creat(mainpath, 0);
 251         ASSERTF(fd >= 0, "creat failed for '%s': %s",
 252                 mainpath, strerror(errno));
 253         close(fd);
 254
 255         rc = llapi_path2fid(mainpath, &fid);
 256         ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 257                 mainpath, strerror(-rc));
 258
 259         rc = unlink(mainpath);
 260         ASSERTF(rc == 0, "unlink failed for '%s': %s",
 261                 mainpath, strerror(errno));
 262
 263         snprintf(fidstr, sizeof(fidstr), DFID_NOBRACE, PFID(&fid));
 264         recno = -1;
 265         linkno = 0;
 266         rc = llapi_fid2path(lustre_dir, fidstr, path,
 267                             sizeof(path), &recno, &linkno);
 268         ASSERTF(rc == -ENOENT, "llapi_fid2path failed for fid %s: %s",
 269                 fidstr, strerror(-rc));
 270 }
 271
 272 /* Test volatile file. */
 273 static void test12(void)
 274 {
 275         int rc;
 276         int fd;
 277         int fd2;
 278         int fd3;
 279         struct lu_fid fid;
 280
 281         /* Against a volatile file */
 282         rc = mkdir(mainpath, 0);
 283         ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 284                 mainpath, strerror(errno));
 285         fd = llapi_create_volatile_idx(mainpath, -1, 0);
 286         ASSERTF(fd >= 0, "creat failed for '%s': %s",
 287                 mainpath, strerror(errno));
 288
 289         rc = llapi_fd2fid(fd, &fid);
 290         ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 291                 mainpath, strerror(-rc));
 292
 293         /* No many ways to test, except to open by fid. */
 294         fd2 = llapi_open_by_fid(mainpath, &fid, O_RDONLY);
 295         ASSERTF(fd2 >= 0, "llapi_open_by_fid for " DFID_NOBRACE ": %s",
 296                 PFID(&fid), strerror(errno));
 297
 298         close(fd);
 299
 300         /* Check the file can still be opened, since fd2 is not
 301          * closed. */
 302         fd3 = llapi_open_by_fid(mainpath, &fid, O_RDONLY);
 303         ASSERTF(fd3 >= 0, "llapi_open_by_fid for " DFID_NOBRACE ": %s",
 304                 PFID(&fid), strerror(errno));
 305
 306         close(fd2);
 307         close(fd3);
 308
 309         /* The volatile file is gone now. */
 310         fd = llapi_open_by_fid(mainpath, &fid, O_RDONLY);
 311         ASSERTF(fd < 0, "llapi_open_by_fid for " DFID_NOBRACE ": %d",
 312                 PFID(&fid), fd);
 313 }
 314
 315 /* Test with sub directories */
 316 static void test20(void)
 317 {
 318         char testpath[PATH_MAX];
 319         size_t len;
 320         int dir_created = 0;
 321         int rc;
 322
 323         rc = snprintf(testpath, sizeof(testpath), "%s", mainpath);
 324         ASSERTF((rc > 0 && rc < sizeof(testpath)),
 325                 "invalid name for testpath '%s'", mainpath);
 326
 327         rc = mkdir(testpath, S_IRWXU);
 328         ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 329                 testpath, strerror(errno));
 330
 331         len = strlen(testpath);
 332
 333         /* Create subdirectories as long as we can. Each new subdir is
 334          * "/x", so we need at least 3 characters left in testpath. */
 335         while (len <= sizeof(testpath) - 3) {
 336                 strncat(testpath, "/x", sizeof(testpath) - 1);
 337
 338                 len += 2;
 339
 340                 rc = mkdir(testpath, S_IRWXU);
 341                 ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 342                         testpath, strerror(errno));
 343
 344                 dir_created++;
 345
 346                 helper_fid2path(testpath, -1);
 347         }
 348
 349         /* And test the last one. */
 350         helper_fid2path(testpath, -1);
 351
 352         /* Make sure we have created enough directories. Even with a
 353          * reasonably long mountpath, we should have created at least
 354          * 2000. */
 355         ASSERTF(dir_created >= 2000, "dir_created=%d -- '%s'",
 356                 dir_created, testpath);
 357 }
 358
 359 /* Test linkno from fid2path */
 360 static void test30(void)
 361 {
 362         /* Note that since the links are stored in the extended
 363          * attributes, only a few of these will fit (about 150 in this
 364          * test). Still, create more than that to ensure the system
 365          * doesn't break. See LU-5746. */
 366         const int num_links = 1000;
 367         struct {
 368                 char filename[PATH_MAX];
 369                 bool seen;
 370         } links[num_links];
 371         char buf[PATH_MAX];
 372         char buf2[PATH_MAX * 2];
 373         struct lu_fid fid;
 374         char fidstr[FID_LEN + 1];
 375         int rc;
 376         int i;
 377         int j;
 378         int fd;
 379         int linkno;
 380         bool past_link_limit = false;
 381
 382         /* Create the containing directory. */
 383         rc = mkdir(mainpath, 0);
 384         ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 385                 mainpath, strerror(errno));
 386
 387         /* Initializes the link array. */
 388         for (i = 0; i < num_links; i++) {
 389                 rc = snprintf(links[i].filename, sizeof(links[i].filename),
 390                               "%s/%s/link%04d", lustre_dir, maindir, i);
 391
 392                 ASSERTF((rc > 0 && rc < sizeof(links[i].filename)),
 393                         "invalid name for link");
 394
 395                 links[i].seen = false;
 396         }
 397
 398         /* Create the original file. */
 399         fd = creat(links[0].filename, 0);
 400         ASSERTF(fd >= 0, "create failed for '%s': %s",
 401                 links[0].filename, strerror(errno));
 402         close(fd);
 403
 404         rc = llapi_path2fid(links[0].filename, &fid);
 405         ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 406                 links[0].filename, strerror(-rc));
 407         snprintf(fidstr, sizeof(fidstr), DFID_NOBRACE, PFID(&fid));
 408
 409         /* Create the links */
 410         for (i = 1; i < num_links; i++) {
 411                 rc = link(links[0].filename, links[i].filename);
 412                 ASSERTF(rc == 0, "link failed for '%s' / '%s': %s",
 413                         links[0].filename, links[i].filename, strerror(errno));
 414         }
 415
 416         /* Query the links, making sure we got all of them */
 417         for (i = 0; i < num_links + 10; i++) {
 418                 long long recno;
 419                 bool found;
 420
 421                 /* Without braces */
 422                 recno = -1;
 423                 linkno = i;
 424                 rc = llapi_fid2path(links[0].filename, fidstr, buf,
 425                                     sizeof(buf), &recno, &linkno);
 426                 ASSERTF(rc == 0, "llapi_fid2path failed for fid %s: %s",
 427                         fidstr, strerror(-rc));
 428
 429                 snprintf(buf2, sizeof(buf2), "%s/%s", fsmountdir, buf);
 430
 431                 if (past_link_limit == false) {
 432                         /* Find the name in the links that were created */
 433                         found = false;
 434                         for (j = 0; j < num_links; j++) {
 435                                 if (strcmp(buf2, links[j].filename) == 0) {
 436                                         ASSERTF(links[j].seen == false,
 437                                                 "link '%s' already seen",
 438                                                 links[j].filename);
 439                                         links[j].seen = true;
 440                                         found = true;
 441                                         break;
 442                                 }
 443                         }
 444                         ASSERTF(found == true, "link '%s' not found", buf2);
 445
 446                         if (linkno == i) {
 447                                 /* The linkno hasn't changed. This
 448                                  * means it is the last entry
 449                                  * stored. */
 450                                 past_link_limit = true;
 451
 452                                 fprintf(stderr,
 453                                         "Was able to store %d links in the EA\n",
 454                                         i);
 455
 456                                 /* Also assume that some links were
 457                                  * returned. It's hard to compute the
 458                                  * exact value. */
 459                                 ASSERTF(i > 50,
 460                                         "not enough links were returned: %d",
 461                                         i);
 462                         }
 463                 } else {
 464                         /* Past the number of links stored in the EA,
 465                          * Lustre will simply return the original
 466                          * file. */
 467                         ASSERTF(strcmp(buf2, links[0].filename) == 0,
 468                                        "unexpected link for record %d: '%s' / '%s'",
 469                                        i, buf2, links[0].filename);
 470                 }
 471
 472         }
 473 }
 474
 475 /* Test llapi_fd2parent/llapi_path2parent on mainpath (whatever its
 476  * type). mainpath must exist. */
 477 static void help_test40(void)
 478 {
 479         struct lu_fid parent_fid;
 480         struct lu_fid fid2;
 481         char buf[PATH_MAX];
 482         int rc;
 483
 484         /* Successful call */
 485         memset(buf, 0x55, sizeof(buf));
 486         rc = llapi_path2parent(mainpath, 0, &parent_fid, buf, PATH_MAX);
 487         ASSERTF(rc == 0, "llapi_path2parent failed for '%s': %s",
 488                 mainpath, strerror(errno));
 489         ASSERTF(strcmp(buf, maindir) == 0, "paths are different: '%s' / '%s'",
 490                 buf, maindir);
 491
 492         /* By construction, mainpath is just under lustre_dir, so we
 493          * can check that the parent fid of mainpath is indeed the one
 494          * of lustre_dir. */
 495         rc = llapi_path2fid(lustre_dir, &fid2);
 496         ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 497                 lustre_dir, strerror(-rc));
 498         ASSERTF(memcmp(&parent_fid, &fid2, sizeof(fid2)) == 0,
 499                 "fids are different");
 500
 501         /* Name too short */
 502         rc = llapi_path2parent(mainpath, 0, &parent_fid, buf, 0);
 503         ASSERTF(rc == -EOVERFLOW, "llapi_path2parent error: %s", strerror(-rc));
 504
 505         rc = llapi_path2parent(mainpath, 0, &parent_fid, buf, 5);
 506         ASSERTF(rc == -EOVERFLOW, "llapi_path2parent error: %s", strerror(-rc));
 507
 508         rc = llapi_path2parent(mainpath, 0, &parent_fid, buf, strlen(maindir));
 509         ASSERTF(rc == -EOVERFLOW, "llapi_path2parent error: %s", strerror(-rc));
 510
 511         rc = llapi_path2parent(mainpath, 0, &parent_fid, buf,
 512                                strlen(maindir)+1);
 513         ASSERTF(rc == 0, "llapi_path2parent failed: %s", strerror(-rc));
 514 }
 515
 516 static void test40(void)
 517 {
 518         int fd;
 519         int rc;
 520
 521         /* Against a directory. */
 522         rc = mkdir(mainpath, 0);
 523         ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 524                 mainpath, strerror(errno));
 525         help_test40();
 526
 527         cleanup();
 528
 529         /* Against a regular file */
 530         fd = creat(mainpath, 0);
 531         ASSERTF(fd >= 0, "creat failed for '%s': %s",
 532                 mainpath, strerror(errno));
 533         close(fd);
 534 }
 535
 536 /* Test LL_IOC_GETPARENT directly */
 537 static void test41(void)
 538 {
 539         int rc;
 540         int fd;
 541         int i;
 542         union {
 543                 struct getparent gp;
 544                 char buf[1024];
 545         } u;
 546
 547         /* Against a regular file */
 548         fd = creat(mainpath, 0);
 549         ASSERTF(fd >= 0, "creat failed for '%s': %s",
 550                 mainpath, strerror(errno));
 551
 552         /* Ask a few times */
 553         for (i = 0; i < 256; i++) {
 554                 memset(u.buf, i, sizeof(u.buf)); /* poison */
 555                 u.gp.gp_linkno = 0;
 556                 u.gp.gp_name_size = 100;
 557
 558                 rc = ioctl(fd, LL_IOC_GETPARENT, &u.gp);
 559                 ASSERTF(rc == 0, "LL_IOC_GETPARENT failed: %s, rc=%d",
 560                         strerror(errno), rc);
 561                 ASSERTF(strcmp(u.gp.gp_name, maindir) == 0,
 562                         "strings are different: %zd, %zd",
 563                         strlen(u.gp.gp_name), strlen(maindir));
 564         }
 565
 566         close(fd);
 567 }
 568
 569 /* Test with linkno. Create sub directories, and put a link to the
 570  * original file in them. */
 571 static void test42(void)
 572 {
 573
 574         const int num_links = 100;
 575         struct {
 576                 char subdir[PATH_MAX];
 577                 struct lu_fid subdir_fid;
 578                 char filename[PATH_MAX];
 579                 bool seen;
 580         } links[num_links];
 581         char link0[PATH_MAX];
 582         char buf[PATH_MAX];
 583         int rc;
 584         int i;
 585         int fd;
 586         int linkno;
 587         struct lu_fid parent_fid;
 588
 589         /* Create the containing directory. */
 590         rc = mkdir(mainpath, 0);
 591         ASSERTF(rc == 0, "mkdir failed: for '%s': %s",
 592                 mainpath, strerror(errno));
 593
 594         /* Initializes the link array. */
 595         for (i = 0; i < num_links; i++) {
 596                 rc = snprintf(links[i].subdir, sizeof(links[i].subdir),
 597                               "%s/sub%04d", mainpath, i);
 598                 ASSERTF((rc > 0 && rc < sizeof(links[i].subdir)),
 599                         "invalid name for subdir");
 600
 601                 rc = snprintf(links[i].filename, sizeof(links[i].filename),
 602                               "link%04d", i);
 603                 ASSERTF((rc > 0 && rc < sizeof(links[i].filename)),
 604                         "invalid name for link");
 605
 606                 links[i].seen = false;
 607         }
 608
 609         /* Create the subdirectories. */
 610         for (i = 0; i < num_links; i++) {
 611                 rc = mkdir(links[i].subdir, S_IRWXU);
 612                 ASSERTF(rc == 0, "mkdir failed for '%s': %s",
 613                         links[i].subdir, strerror(errno));
 614
 615                 rc = llapi_path2fid(links[i].subdir, &links[i].subdir_fid);
 616                 ASSERTF(rc == 0, "llapi_path2fid failed for '%s': %s",
 617                         links[i].subdir, strerror(-rc));
 618         }
 619
 620         /* Create the original file. */
 621         rc = snprintf(link0, sizeof(link0), "%s/%s",
 622                       links[0].subdir, links[0].filename);
 623         ASSERTF((rc > 0 && rc < sizeof(link0)), "invalid name for file");
 624
 625         fd = creat(link0, 0);
 626         ASSERTF(fd >= 0, "create failed for '%s': %s", link0, strerror(errno));
 627         close(fd);
 628
 629         /* Create the links */
 630         for (i = 1; i < num_links; i++) {
 631                 rc = snprintf(buf, sizeof(buf), "%s/%s",
 632                               links[i].subdir, links[i].filename);
 633                 ASSERTF((rc > 0 && rc < sizeof(buf)),
 634                         "invalid name for link %d", i);
 635
 636                 rc = link(link0, buf);
 637                 ASSERTF(rc == 0, "link failed for '%s' / '%s': %s",
 638                         link0, buf, strerror(errno));
 639         }
 640
 641         /* Query the links, making sure we got all of them. Do it in
 642          * reverse order, just because! */
 643         for (linkno = num_links-1; linkno >= 0; linkno--) {
 644                 bool found;
 645
 646                 rc = llapi_path2parent(link0, linkno, &parent_fid, buf,
 647                                        sizeof(buf));
 648                 ASSERTF(rc == 0, "llapi_path2parent failed for '%s': %s",
 649                         link0, strerror(-rc));
 650
 651                 /* Find the name in the links that were created */
 652                 found = false;
 653                 for (i = 0; i < num_links; i++) {
 654                         if (memcmp(&parent_fid, &links[i].subdir_fid,
 655                                    sizeof(parent_fid)) != 0)
 656                                 continue;
 657
 658                         ASSERTF(strcmp(links[i].filename, buf) == 0,
 659                                 "name differ: '%s' / '%s'",
 660                                 links[i].filename, buf);
 661                         ASSERTF(links[i].seen == false,
 662                                 "link '%s' already seen", links[i].filename);
 663                         links[i].seen = true;
 664                         found = true;
 665                         break;
 666                 }
 667                 ASSERTF(found == true, "link '%s' not found", buf);
 668         }
 669
 670         /* check non existent n+1 link */
 671         rc = llapi_path2parent(link0, num_links, &parent_fid, buf, sizeof(buf));
 672         ASSERTF(rc == -ENODATA, "llapi_path2parent error for '%s': %s",
 673                 link0, strerror(-rc));
 674 }
 675
 676 static void usage(char *prog)
 677 {
 678         fprintf(stderr, "Usage: %s [-d lustre_dir]\n", prog);
 679         exit(EXIT_FAILURE);
 680 }
 681
 682 static void process_args(int argc, char *argv[])
 683 {
 684         int c;
 685
 686         while ((c = getopt(argc, argv, "d:")) != -1) {
 687                 switch (c) {
 688                 case 'd':
 689                         lustre_dir = optarg;
 690                         break;
 691                 case '?':
 692                 default:
 693                         fprintf(stderr, "Unknown option '%c'\n", optopt);
 694                         usage(argv[0]);
 695                 }
 696         }
 697 }
 698
 699 int main(int argc, char *argv[])
 700 {
 701         char fsname[8 + 1];
 702         int rc;
 703
 704         process_args(argc, argv);
 705         if (lustre_dir == NULL)
 706                 lustre_dir = "/mnt/lustre";
 707
 708         rc = llapi_search_mounts(lustre_dir, 0, fsmountdir, fsname);
 709         if (rc != 0) {
 710                 fprintf(stderr, "Error: %s: not a Lustre filesystem\n",
 711                         lustre_dir);
 712                 return EXIT_FAILURE;
 713         }
 714
 715         /* Play nice with Lustre test scripts. Non-line buffered output
 716          * stream under I/O redirection may appear incorrectly. */
 717         setvbuf(stdout, NULL, _IOLBF, 0);
 718
 719         /* Create a test filename and reuse it. Remove possibly old files. */
 720         rc = snprintf(mainpath, sizeof(mainpath), "%s/%s", lustre_dir, maindir);
 721         ASSERTF((rc > 0 && rc < sizeof(mainpath)), "invalid name for mainpath");
 722         cleanup();
 723
 724         atexit(cleanup);
 725
 726         PERFORM(test10);
 727         PERFORM(test11);
 728         PERFORM(test12);
 729         PERFORM(test20);
 730         PERFORM(test30);
 731         PERFORM(test40);
 732         PERFORM(test41);
 733         PERFORM(test42);
 734
 735         return EXIT_SUCCESS;
 736 }