glusterfs

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <errno.h>
4
#include <glusterfs/api/glfs.h>
5
#include <glusterfs/api/glfs-handles.h>
6
#include <string.h>
7
#include <time.h>
8

9
#define TEST_STR_LEN 2048
10

11
int
12
test_dirops(glfs_t *fs)
13
{
14
    glfs_fd_t *fd = NULL;
15
    char buf[2048];
16
    struct dirent *entry = NULL;
17

18
    fd = glfs_opendir(fs, "/");
19
    if (!fd) {
20
        fprintf(stderr, "/: %s\n", strerror(errno));
21
        return -1;
22
    }
23

24
    fprintf(stderr, "Entries:\n");
25
    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
26
        fprintf(stderr, "%s: %lu\n", entry->d_name, glfs_telldir(fd));
27
    }
28

29
    /* Should internally call fsyncdir(), hopefully */
30
    glfs_fsync(fd, NULL, NULL);
31

32
    glfs_closedir(fd);
33
    return 0;
34
}
35

36
int
37
test_xattr(glfs_t *fs)
38
{
39
    char *filename = "/filename2";
40
    char *linkfile = "/linkfile";
41
    glfs_fd_t *fd = NULL;
42
    char buf[512];
43
    char *ptr;
44
    int ret;
45

46
    ret = glfs_setxattr(fs, filename, "user.testkey", "testval", 8, 0);
47
    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
48

49
    ret = glfs_setxattr(fs, filename, "user.testkey2", "testval", 8, 0);
50
    fprintf(stderr, "setxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
51

52
    ret = glfs_getxattr(fs, filename, "user.testkey", buf, 512);
53
    fprintf(stderr, "getxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
54
    if (ret < 0)
55
        return -1;
56

57
    ret = glfs_listxattr(fs, filename, buf, 512);
58
    fprintf(stderr, "listxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
59
    if (ret < 0)
60
        return -1;
61

62
    ret = glfs_symlink(fs, "filename", linkfile);
63
    fprintf(stderr, "symlink(%s %s): %s\n", filename, linkfile,
64
            strerror(errno));
65
    if (ret < 0)
66
        return -1;
67

68
    ret = glfs_readlink(fs, linkfile, buf, 512);
69
    fprintf(stderr, "readlink(%s) : %d (%s)\n", filename, ret, strerror(errno));
70
    if (ret < 0)
71
        return -1;
72

73
    ret = glfs_lsetxattr(fs, filename, "user.testkey3", "testval", 8, 0);
74
    fprintf(stderr, "lsetxattr(%s) : %d (%s)\n", linkfile, ret,
75
            strerror(errno));
76
    if (ret < 0)
77
        return -1;
78

79
    ret = glfs_llistxattr(fs, linkfile, buf, 512);
80
    fprintf(stderr, "llistxattr(%s): %d (%s)\n", filename, ret,
81
            strerror(errno));
82
    if (ret < 0)
83
        return -1;
84

85
    ret = glfs_lgetxattr(fs, filename, "user.testkey3", buf, 512);
86
    fprintf(stderr, "lgetxattr(%s): %d (%s)\n", linkfile, ret, strerror(errno));
87
    if (ret < 0)
88
        return -1;
89

90
    for (ptr = buf; ptr < buf + ret; ptr++) {
91
        printf("key=%s\n", ptr);
92
        ptr += strlen(ptr);
93
    }
94

95
    ret = glfs_removexattr(fs, filename, "user.testkey2");
96
    fprintf(stderr, "removexattr(%s): %d (%s)\n", filename, ret,
97
            strerror(errno));
98

99
    fd = glfs_open(fs, filename, O_RDWR);
100
    fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
101

102
    ret = glfs_fsetxattr(fd, "user.testkey2", "testval", 8, 0);
103
    fprintf(stderr, "fsetxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
104

105
    ret = glfs_fgetxattr(fd, "user.testkey2", buf, 512);
106
    fprintf(stderr, "fgetxattr(%s): %d (%s)\n", filename, ret, strerror(errno));
107

108
    ret = glfs_flistxattr(fd, buf, 512);
109
    fprintf(stderr, "flistxattr(%s): %d (%s)\n", filename, ret,
110
            strerror(errno));
111
    if (ret < 0)
112
        return -1;
113

114
    for (ptr = buf; ptr < buf + ret; ptr++) {
115
        printf("key=%s\n", ptr);
116
        ptr += strlen(ptr);
117
    }
118

119
    ret = glfs_fremovexattr(fd, "user.testkey2");
120
    fprintf(stderr, "fremovexattr(%s): %d (%s)\n", filename, ret,
121
            strerror(errno));
122

123
    glfs_close(fd);
124

125
    return 0;
126
}
127

128
int
129
test_chdir(glfs_t *fs)
130
{
131
    int ret = -1;
132
    char *dir = "/dir";
133
    char *topdir = "/topdir";
134
    char *linkdir = "/linkdir";
135
    char *linkdir2 = "/linkdir2";
136
    char *subdir = "./subdir";
137
    char *respath = NULL;
138
    char pathbuf[4096];
139

140
    ret = glfs_mkdir(fs, topdir, 0755);
141
    fprintf(stderr, "mkdir(%s): %s\n", topdir, strerror(errno));
142
    if (ret)
143
        return -1;
144

145
    ret = glfs_mkdir(fs, dir, 0755);
146
    fprintf(stderr, "mkdir(%s): %s\n", dir, strerror(errno));
147
    if (ret)
148
        return -1;
149

150
    respath = glfs_getcwd(fs, pathbuf, 4096);
151
    fprintf(stdout, "getcwd() = %s\n", respath);
152

153
    ret = glfs_symlink(fs, "topdir", linkdir);
154
    if (ret) {
155
        fprintf(stderr, "symlink(%s, %s): %s\n", topdir, linkdir,
156
                strerror(errno));
157
        return -1;
158
    }
159

160
    ret = glfs_chdir(fs, linkdir);
161
    if (ret) {
162
        fprintf(stderr, "chdir(%s): %s\n", linkdir, strerror(errno));
163
        return -1;
164
    }
165

166
    respath = glfs_getcwd(fs, pathbuf, 4096);
167
    fprintf(stdout, "getcwd() = %s\n", respath);
168

169
    respath = glfs_realpath(fs, subdir, pathbuf);
170
    if (respath) {
171
        fprintf(stderr, "realpath(%s) worked unexpectedly: %s\n", subdir,
172
                respath);
173
        return -1;
174
    }
175

176
    ret = glfs_mkdir(fs, subdir, 0755);
177
    if (ret) {
178
        fprintf(stderr, "mkdir(%s): %s\n", subdir, strerror(errno));
179
        return -1;
180
    }
181

182
    respath = glfs_realpath(fs, subdir, pathbuf);
183
    if (!respath) {
184
        fprintf(stderr, "realpath(%s): %s\n", subdir, strerror(errno));
185
    } else {
186
        fprintf(stdout, "realpath(%s) = %s\n", subdir, respath);
187
    }
188

189
    ret = glfs_chdir(fs, subdir);
190
    if (ret) {
191
        fprintf(stderr, "chdir(%s): %s\n", subdir, strerror(errno));
192
        return -1;
193
    }
194

195
    respath = glfs_getcwd(fs, pathbuf, 4096);
196
    fprintf(stdout, "getcwd() = %s\n", respath);
197

198
    respath = glfs_realpath(fs, "/linkdir/subdir", pathbuf);
199
    if (!respath) {
200
        fprintf(stderr, "realpath(/linkdir/subdir): %s\n", strerror(errno));
201
    } else {
202
        fprintf(stdout, "realpath(/linkdir/subdir) = %s\n", respath);
203
    }
204

205
    return 0;
206
}
207

208
#ifdef DEBUG
209
static void
210
peek_stat(struct stat *sb)
211
{
212
    printf("Dumping stat information:\n");
213
    printf("File type:                ");
214

215
    switch (sb->st_mode & S_IFMT) {
216
        case S_IFBLK:
217
            printf("block device\n");
218
            break;
219
        case S_IFCHR:
220
            printf("character device\n");
221
            break;
222
        case S_IFDIR:
223
            printf("directory\n");
224
            break;
225
        case S_IFIFO:
226
            printf("FIFO/pipe\n");
227
            break;
228
        case S_IFLNK:
229
            printf("symlink\n");
230
            break;
231
        case S_IFREG:
232
            printf("regular file\n");
233
            break;
234
        case S_IFSOCK:
235
            printf("socket\n");
236
            break;
237
        default:
238
            printf("unknown?\n");
239
            break;
240
    }
241

242
    printf("I-node number:            %ld\n", (long)sb->st_ino);
243

244
    printf("Mode:                     %lo (octal)\n",
245
           (unsigned long)sb->st_mode);
246

247
    printf("Link count:               %ld\n", (long)sb->st_nlink);
248
    printf("Ownership:                UID=%ld   GID=%ld\n", (long)sb->st_uid,
249
           (long)sb->st_gid);
250

251
    printf("Preferred I/O block size: %ld bytes\n", (long)sb->st_blksize);
252
    printf("File size:                %lld bytes\n", (long long)sb->st_size);
253
    printf("Blocks allocated:         %lld\n", (long long)sb->st_blocks);
254

255
    printf("Last status change:       %s", ctime(&sb->st_ctime));
256
    printf("Last file access:         %s", ctime(&sb->st_atime));
257
    printf("Last file modification:   %s", ctime(&sb->st_mtime));
258

259
    return;
260
}
261

262
static void
263
peek_handle(unsigned char *glid)
264
{
265
    int i;
266

267
    for (i = 0; i < GFAPI_HANDLE_LENGTH; i++) {
268
        printf(":%02x:", glid[i]);
269
    }
270
    printf("\n");
271
}
272
#else  /* DEBUG */
273
static void
274
peek_stat(struct stat *sb)
275
{
276
    return;
277
}
278

279
static void
280
peek_handle(unsigned char *id)
281
{
282
    return;
283
}
284
#endif /* DEBUG */
285

286
glfs_t *fs = NULL;
287
char *full_parent_name = "/testdir", *parent_name = "testdir";
288

289
void
290
test_h_unlink(void)
291
{
292
    char *my_dir = "unlinkdir";
293
    char *my_file = "file.txt";
294
    char *my_subdir = "dir1";
295
    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL,
296
                       *subdir = NULL, *subleaf = NULL;
297
    struct stat sb;
298
    int ret;
299

300
    printf("glfs_h_unlink tests: In Progress\n");
301

302
    /* Prepare tests */
303
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
304
    if (parent == NULL) {
305
        fprintf(stderr,
306
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
307
                full_parent_name, NULL, strerror(errno));
308
        printf("glfs_h_lookupat tests: FAILED\n");
309
        goto out;
310
    }
311
    peek_stat(&sb);
312

313
    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
314
    if (dir == NULL) {
315
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
316
                my_dir, parent, strerror(errno));
317
        printf("glfs_h_unlink tests: FAILED\n");
318
        goto out;
319
    }
320

321
    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
322
    if (leaf == NULL) {
323
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
324
                my_file, dir, strerror(errno));
325
        printf("glfs_h_unlink tests: FAILED\n");
326
        goto out;
327
    }
328

329
    subdir = glfs_h_mkdir(fs, dir, my_subdir, 0755, &sb);
330
    if (subdir == NULL) {
331
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
332
                my_subdir, dir, strerror(errno));
333
        printf("glfs_h_unlink tests: FAILED\n");
334
        goto out;
335
    }
336

337
    subleaf = glfs_h_creat(fs, subdir, my_file, O_CREAT, 0644, &sb);
338
    if (subleaf == NULL) {
339
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
340
                my_file, subdir, strerror(errno));
341
        printf("glfs_h_unlink tests: FAILED\n");
342
        goto out;
343
    }
344

345
    /* unlink non empty directory */
346
    ret = glfs_h_unlink(fs, dir, my_subdir);
347
    if ((ret && errno != ENOTEMPTY) || (ret == 0)) {
348
        fprintf(stderr,
349
                "glfs_h_unlink: error unlinking %s: it is non empty: %s\n",
350
                my_subdir, strerror(errno));
351
        printf("glfs_h_unlink tests: FAILED\n");
352
        goto out;
353
    }
354

355
    /* unlink regular file */
356
    ret = glfs_h_unlink(fs, subdir, my_file);
357
    if (ret) {
358
        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
359
                my_file, subdir, strerror(errno));
360
        printf("glfs_h_unlink tests: FAILED\n");
361
        goto out;
362
    }
363

364
    /* unlink directory */
365
    ret = glfs_h_unlink(fs, dir, my_subdir);
366
    if (ret) {
367
        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
368
                my_subdir, dir, strerror(errno));
369
        printf("glfs_h_unlink tests: FAILED\n");
370
        goto out;
371
    }
372

373
    /* unlink regular file */
374
    ret = glfs_h_unlink(fs, dir, my_file);
375
    if (ret) {
376
        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
377
                my_file, dir, strerror(errno));
378
        printf("glfs_h_unlink tests: FAILED\n");
379
        goto out;
380
    }
381

382
    /* unlink non-existent regular file */
383
    ret = glfs_h_unlink(fs, dir, my_file);
384
    if ((ret && errno != ENOENT) || (ret == 0)) {
385
        fprintf(stderr,
386
                "glfs_h_unlink: error unlinking non-existent %s: invalid errno "
387
                ",%d, %s\n",
388
                my_file, ret, strerror(errno));
389
        printf("glfs_h_unlink tests: FAILED\n");
390
        goto out;
391
    }
392

393
    /* unlink non-existent directory */
394
    ret = glfs_h_unlink(fs, dir, my_subdir);
395
    if ((ret && errno != ENOENT) || (ret == 0)) {
396
        fprintf(stderr,
397
                "glfs_h_unlink: error unlinking non-existent %s:  invalid "
398
                "errno ,%d, %s\n",
399
                my_subdir, ret, strerror(errno));
400
        printf("glfs_h_unlink tests: FAILED\n");
401
        goto out;
402
    }
403

404
    /* unlink directory */
405
    ret = glfs_h_unlink(fs, parent, my_dir);
406
    if (ret) {
407
        fprintf(stderr, "glfs_h_unlink: error unlinking %s: from (%p),%s\n",
408
                my_dir, dir, strerror(errno));
409
        printf("glfs_h_unlink tests: FAILED\n");
410
        goto out;
411
    }
412

413
    printf("glfs_h_unlink tests: PASSED\n");
414

415
out:
416
    if (dir)
417
        glfs_h_close(dir);
418
    if (leaf)
419
        glfs_h_close(leaf);
420
    if (subdir)
421
        glfs_h_close(subdir);
422
    if (subleaf)
423
        glfs_h_close(subleaf);
424
    if (parent)
425
        glfs_h_close(parent);
426

427
    return;
428
}
429

430
void
431
test_h_getsetattrs(void)
432
{
433
    char *my_dir = "attrdir";
434
    char *my_file = "attrfile.txt";
435
    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
436
    struct stat sb, retsb;
437
    int ret, valid;
438
    struct timespec timestamp;
439

440
    printf("glfs_h_getattrs and setattrs tests: In Progress\n");
441

442
    /* Prepare tests */
443
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
444
    if (parent == NULL) {
445
        fprintf(stderr,
446
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
447
                full_parent_name, NULL, strerror(errno));
448
        printf("glfs_h_lookupat tests: FAILED\n");
449
        goto out;
450
    }
451
    peek_stat(&sb);
452

453
    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
454
    if (dir == NULL) {
455
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
456
                my_dir, parent, strerror(errno));
457
        printf("glfs_h_unlink tests: FAILED\n");
458
        goto out;
459
    }
460
    peek_stat(&sb);
461

462
    leaf = glfs_h_creat(fs, dir, my_file, O_CREAT, 0644, &sb);
463
    if (leaf == NULL) {
464
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
465
                my_file, dir, strerror(errno));
466
        printf("glfs_h_unlink tests: FAILED\n");
467
        goto out;
468
    }
469
    peek_stat(&sb);
470

471
    ret = glfs_h_getattrs(fs, dir, &retsb);
472
    if (ret != 0) {
473
        fprintf(stderr, "glfs_h_getattrs: error %s: from (%p),%s\n", my_dir,
474
                dir, strerror(errno));
475
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
476
        goto out;
477
    }
478
    peek_stat(&retsb);
479
    /* TODO: Compare stat information */
480

481
    retsb.st_mode = 00666;
482
    retsb.st_uid = 1000;
483
    retsb.st_gid = 1001;
484
    ret = clock_gettime(CLOCK_REALTIME, &timestamp);
485
    if (ret != 0) {
486
        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
487
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
488
        goto out;
489
    }
490
    retsb.st_atim = timestamp;
491
    retsb.st_mtim = timestamp;
492
    valid = GFAPI_SET_ATTR_MODE | GFAPI_SET_ATTR_UID | GFAPI_SET_ATTR_GID |
493
            GFAPI_SET_ATTR_ATIME | GFAPI_SET_ATTR_MTIME;
494
    peek_stat(&retsb);
495

496
    ret = glfs_h_setattrs(fs, dir, &retsb, valid);
497
    if (ret != 0) {
498
        fprintf(stderr, "glfs_h_setattrs: error %s: from (%p),%s\n", my_dir,
499
                dir, strerror(errno));
500
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
501
        goto out;
502
    }
503

504
    memset(&retsb, 0, sizeof(struct stat));
505
    ret = glfs_h_stat(fs, dir, &retsb);
506
    if (ret != 0) {
507
        fprintf(stderr, "glfs_h_stat: error %s: from (%p),%s\n", my_dir, dir,
508
                strerror(errno));
509
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
510
        goto out;
511
    }
512
    peek_stat(&retsb);
513

514
    printf("glfs_h_getattrs and setattrs tests: PASSED\n");
515
out:
516
    if (parent)
517
        glfs_h_close(parent);
518
    if (leaf)
519
        glfs_h_close(leaf);
520
    if (dir)
521
        glfs_h_close(dir);
522

523
    return;
524
}
525

526
void
527
test_h_truncate(void)
528
{
529
    char *my_dir = "truncatedir";
530
    char *my_file = "file.txt";
531
    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL;
532
    struct stat sb;
533
    glfs_fd_t *fd = NULL;
534
    char buf[32];
535
    off_t offset = 0;
536
    int ret = 0;
537

538
    printf("glfs_h_truncate tests: In Progress\n");
539

540
    /* Prepare tests */
541
    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
542
    if (root == NULL) {
543
        fprintf(stderr,
544
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
545
                full_parent_name, NULL, strerror(errno));
546
        printf("glfs_h_truncate tests: FAILED\n");
547
        goto out;
548
    }
549
    peek_stat(&sb);
550

551
    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
552
    if (parent == NULL) {
553
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
554
                my_dir, root, strerror(errno));
555
        printf("glfs_h_truncate tests: FAILED\n");
556
        goto out;
557
    }
558
    peek_stat(&sb);
559

560
    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
561
    if (leaf == NULL) {
562
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
563
                my_file, parent, strerror(errno));
564
        printf("glfs_h_truncate tests: FAILED\n");
565
        goto out;
566
    }
567
    peek_stat(&sb);
568

569
    fd = glfs_h_open(fs, leaf, O_RDWR);
570
    if (fd == NULL) {
571
        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n", my_file,
572
                strerror(errno));
573
        printf("glfs_h_truncate tests: FAILED\n");
574
        goto out;
575
    }
576

577
    memcpy(buf, "abcdefghijklmnopqrstuvwxyz012345", 32);
578
    ret = glfs_write(fd, buf, 32, 0);
579

580
    /* run tests */
581
    /* truncate lower */
582
    offset = 30;
583
    ret = glfs_h_truncate(fs, leaf, offset);
584
    if (ret != 0) {
585
        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
586
                my_file, parent, strerror(errno));
587
        printf("glfs_h_truncate tests: FAILED\n");
588
        goto out;
589
    }
590
    ret = glfs_h_getattrs(fs, leaf, &sb);
591
    if (ret != 0) {
592
        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
593
                leaf, strerror(errno));
594
        printf("glfs_h_truncate tests: FAILED\n");
595
        goto out;
596
    }
597
    if (sb.st_size != offset) {
598
        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
599
        printf("glfs_h_truncate tests: FAILED\n");
600
        goto out;
601
    }
602

603
    /* truncate higher */
604
    offset = 32;
605
    ret = glfs_h_truncate(fs, leaf, offset);
606
    if (ret != 0) {
607
        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
608
                my_file, parent, strerror(errno));
609
        printf("glfs_h_truncate tests: FAILED\n");
610
        goto out;
611
    }
612
    ret = glfs_h_getattrs(fs, leaf, &sb);
613
    if (ret != 0) {
614
        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
615
                leaf, strerror(errno));
616
        printf("glfs_h_truncate tests: FAILED\n");
617
        goto out;
618
    }
619
    if (sb.st_size != offset) {
620
        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
621
        printf("glfs_h_truncate tests: FAILED\n");
622
        goto out;
623
    }
624

625
    /* truncate equal */
626
    offset = 30;
627
    ret = glfs_h_truncate(fs, leaf, offset);
628
    if (ret != 0) {
629
        fprintf(stderr, "glfs_h_truncate: error creating %s: from (%p),%s\n",
630
                my_file, parent, strerror(errno));
631
        printf("glfs_h_truncate tests: FAILED\n");
632
        goto out;
633
    }
634
    ret = glfs_h_getattrs(fs, leaf, &sb);
635
    if (ret != 0) {
636
        fprintf(stderr, "glfs_h_getattrs: error for %s (%p),%s\n", my_file,
637
                leaf, strerror(errno));
638
        printf("glfs_h_truncate tests: FAILED\n");
639
        goto out;
640
    }
641
    if (sb.st_size != offset) {
642
        fprintf(stderr, "glfs_h_truncate: post size mismatch\n");
643
        printf("glfs_h_truncate tests: FAILED\n");
644
        goto out;
645
    }
646

647
    printf("glfs_h_truncate tests: PASSED\n");
648
out:
649
    if (fd)
650
        glfs_close(fd);
651
    if (root)
652
        glfs_h_close(root);
653
    if (parent)
654
        glfs_h_close(parent);
655
    if (leaf)
656
        glfs_h_close(leaf);
657

658
    return;
659
}
660

661
void
662
test_h_links(void)
663
{
664
    char *my_dir = "linkdir";
665
    char *my_file = "file.txt";
666
    char *my_symlnk = "slnk.txt";
667
    char *my_lnk = "lnk.txt";
668
    char *linksrc_dir = "dir1";
669
    char *linktgt_dir = "dir2";
670
    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
671
                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
672
    struct glfs_object *ln1 = NULL;
673
    struct stat sb;
674
    int ret;
675
    char *buf = NULL;
676

677
    printf("glfs_h_link(s) tests: In Progress\n");
678

679
    /* Prepare tests */
680
    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
681
    if (root == NULL) {
682
        fprintf(stderr,
683
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
684
                full_parent_name, NULL, strerror(errno));
685
        printf("glfs_h_link(s) tests: FAILED\n");
686
        goto out;
687
    }
688
    peek_stat(&sb);
689

690
    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
691
    if (parent == NULL) {
692
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
693
                my_dir, root, strerror(errno));
694
        printf("glfs_h_link(s) tests: FAILED\n");
695
        goto out;
696
    }
697
    peek_stat(&sb);
698

699
    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
700
    if (leaf == NULL) {
701
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
702
                my_file, parent, strerror(errno));
703
        printf("glfs_h_link(s) tests: FAILED\n");
704
        goto out;
705
    }
706
    peek_stat(&sb);
707

708
    dirsrc = glfs_h_mkdir(fs, parent, linksrc_dir, 0755, &sb);
709
    if (dirsrc == NULL) {
710
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
711
                linksrc_dir, parent, strerror(errno));
712
        printf("glfs_h_link(s) tests: FAILED\n");
713
        goto out;
714
    }
715
    peek_stat(&sb);
716

717
    dirtgt = glfs_h_mkdir(fs, parent, linktgt_dir, 0755, &sb);
718
    if (dirtgt == NULL) {
719
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
720
                linktgt_dir, parent, strerror(errno));
721
        printf("glfs_h_link(s) tests: FAILED\n");
722
        goto out;
723
    }
724
    peek_stat(&sb);
725

726
    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
727
    if (dleaf == NULL) {
728
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
729
                my_file, dirsrc, strerror(errno));
730
        printf("glfs_h_link(s) tests: FAILED\n");
731
        goto out;
732
    }
733
    peek_stat(&sb);
734

735
    /* run tests */
736
    /* sym link: /testdir/linkdir/file.txt to ./slnk.txt */
737
    ln1 = glfs_h_symlink(fs, parent, my_symlnk, "./file.txt", &sb);
738
    if (ln1 == NULL) {
739
        fprintf(stderr, "glfs_h_symlink: error creating %s: from (%p),%s\n",
740
                my_symlnk, parent, strerror(errno));
741
        printf("glfs_h_link(s) tests: FAILED\n");
742
        goto out;
743
    }
744
    peek_stat(&sb);
745

746
    buf = calloc(1024, sizeof(char));
747
    if (buf == NULL) {
748
        fprintf(stderr, "Error allocating memory\n");
749
        printf("glfs_h_link(s) tests: FAILED\n");
750
        goto out;
751
    }
752

753
    ret = glfs_h_readlink(fs, ln1, buf, 1024);
754
    if (ret <= 0) {
755
        fprintf(stderr, "glfs_h_readlink: error reading %s: from (%p),%s\n",
756
                my_symlnk, ln1, strerror(errno));
757
        printf("glfs_h_link(s) tests: FAILED\n");
758
        goto out;
759
    }
760
    if (!(strncmp(buf, my_symlnk, strlen(my_symlnk)))) {
761
        fprintf(stderr,
762
                "glfs_h_readlink: error mismatch in link name: actual %s: "
763
                "retrieved %s\n",
764
                my_symlnk, buf);
765
        printf("glfs_h_link(s) tests: FAILED\n");
766
        goto out;
767
    }
768

769
    /* link: /testdir/linkdir/file.txt to ./lnk.txt */
770
    ret = glfs_h_link(fs, leaf, parent, my_lnk);
771
    if (ret != 0) {
772
        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
773
                my_lnk, parent, strerror(errno));
774
        printf("glfs_h_link(s) tests: FAILED\n");
775
        goto out;
776
    }
777
    /* TODO: Should write content to a file and read from the link */
778

779
    /* link: /testdir/linkdir/dir1/file.txt to ../dir2/slnk.txt */
780
    ret = glfs_h_link(fs, dleaf, dirtgt, my_lnk);
781
    if (ret != 0) {
782
        fprintf(stderr, "glfs_h_link: error creating %s: from (%p),%s\n",
783
                my_lnk, dirtgt, strerror(errno));
784
        printf("glfs_h_link(s) tests: FAILED\n");
785
        goto out;
786
    }
787
    /* TODO: Should write content to a file and read from the link */
788

789
    printf("glfs_h_link(s) tests: PASSED\n");
790

791
out:
792
    if (root)
793
        glfs_h_close(root);
794
    if (parent)
795
        glfs_h_close(parent);
796
    if (leaf)
797
        glfs_h_close(leaf);
798
    if (dirsrc)
799
        glfs_h_close(dirsrc);
800
    if (dirtgt)
801
        glfs_h_close(dirtgt);
802
    if (dleaf)
803
        glfs_h_close(dleaf);
804
    if (ln1)
805
        glfs_h_close(ln1);
806
    if (buf)
807
        free(buf);
808

809
    return;
810
}
811

812
void
813
test_h_rename(void)
814
{
815
    char *my_dir = "renamedir";
816
    char *my_file = "file.txt";
817
    char *src_dir = "dir1";
818
    char *tgt_dir = "dir2";
819
    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL,
820
                       *dirsrc = NULL, *dirtgt = NULL, *dleaf = NULL;
821
    struct stat sb;
822
    int ret;
823

824
    printf("glfs_h_rename tests: In Progress\n");
825

826
    /* Prepare tests */
827
    root = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
828
    if (root == NULL) {
829
        fprintf(stderr,
830
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
831
                full_parent_name, NULL, strerror(errno));
832
        printf("glfs_h_rename tests: FAILED\n");
833
        goto out;
834
    }
835
    peek_stat(&sb);
836

837
    parent = glfs_h_mkdir(fs, root, my_dir, 0755, &sb);
838
    if (parent == NULL) {
839
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
840
                my_dir, root, strerror(errno));
841
        printf("glfs_h_rename tests: FAILED\n");
842
        goto out;
843
    }
844
    peek_stat(&sb);
845

846
    leaf = glfs_h_creat(fs, parent, my_file, O_CREAT, 0644, &sb);
847
    if (leaf == NULL) {
848
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
849
                my_file, parent, strerror(errno));
850
        printf("glfs_h_rename tests: FAILED\n");
851
        goto out;
852
    }
853
    peek_stat(&sb);
854

855
    dirsrc = glfs_h_mkdir(fs, parent, src_dir, 0755, &sb);
856
    if (dirsrc == NULL) {
857
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
858
                src_dir, parent, strerror(errno));
859
        printf("glfs_h_rename tests: FAILED\n");
860
        goto out;
861
    }
862
    peek_stat(&sb);
863

864
    dirtgt = glfs_h_mkdir(fs, parent, tgt_dir, 0755, &sb);
865
    if (dirtgt == NULL) {
866
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
867
                tgt_dir, parent, strerror(errno));
868
        printf("glfs_h_rename tests: FAILED\n");
869
        goto out;
870
    }
871
    peek_stat(&sb);
872

873
    dleaf = glfs_h_creat(fs, dirsrc, my_file, O_CREAT, 0644, &sb);
874
    if (dleaf == NULL) {
875
        fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
876
                my_file, dirsrc, strerror(errno));
877
        printf("glfs_h_rename tests: FAILED\n");
878
        goto out;
879
    }
880
    peek_stat(&sb);
881

882
    /* run tests */
883
    /* Rename file.txt -> file1.txt */
884
    ret = glfs_h_rename(fs, parent, "file.txt", parent, "file1.txt");
885
    if (ret != 0) {
886
        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
887
                "file.txt", "file1.txt", strerror(errno));
888
        printf("glfs_h_rename tests: FAILED\n");
889
        goto out;
890
    }
891

892
    /* rename dir1/file.txt -> file.txt */
893
    ret = glfs_h_rename(fs, dirsrc, "file.txt", parent, "file.txt");
894
    if (ret != 0) {
895
        fprintf(stderr, "glfs_h_rename: error renaming %s/%s to %s (%s)\n",
896
                src_dir, "file.txt", "file.txt", strerror(errno));
897
        printf("glfs_h_rename tests: FAILED\n");
898
        goto out;
899
    }
900

901
    /* rename file1.txt -> file.txt (exists) */
902
    ret = glfs_h_rename(fs, parent, "file1.txt", parent, "file.txt");
903
    if (ret != 0) {
904
        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n",
905
                "file.txt", "file.txt", strerror(errno));
906
        printf("glfs_h_rename tests: FAILED\n");
907
        goto out;
908
    }
909

910
    /* rename dir1 -> dir3 */
911
    ret = glfs_h_rename(fs, parent, "dir1", parent, "dir3");
912
    if (ret != 0) {
913
        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir1",
914
                "dir3", strerror(errno));
915
        printf("glfs_h_rename tests: FAILED\n");
916
        goto out;
917
    }
918

919
    /* rename dir2 ->dir3 (exists) */
920
    ret = glfs_h_rename(fs, parent, "dir2", parent, "dir3");
921
    if (ret != 0) {
922
        fprintf(stderr, "glfs_h_rename: error renaming %s to %s (%s)\n", "dir2",
923
                "dir3", strerror(errno));
924
        printf("glfs_h_rename tests: FAILED\n");
925
        goto out;
926
    }
927

928
    /* rename file.txt -> dir3 (fail) */
929
    ret = glfs_h_rename(fs, parent, "file.txt", parent, "dir3");
930
    if (ret == 0) {
931
        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
932
                "file.txt", "dir3", strerror(errno));
933
        printf("glfs_h_rename tests: FAILED\n");
934
        goto out;
935
    }
936

937
    /* rename dir3 -> file.txt (fail) */
938
    ret = glfs_h_rename(fs, parent, "dir3", parent, "file.txt");
939
    if (ret == 0) {
940
        fprintf(stderr, "glfs_h_rename: NO error renaming %s to %s (%s)\n",
941
                "dir3", "file.txt", strerror(errno));
942
        printf("glfs_h_rename tests: FAILED\n");
943
        goto out;
944
    }
945

946
    printf("glfs_h_rename tests: PASSED\n");
947

948
out:
949
    if (root)
950
        glfs_h_close(root);
951
    if (parent)
952
        glfs_h_close(parent);
953
    if (leaf)
954
        glfs_h_close(leaf);
955
    if (dirsrc)
956
        glfs_h_close(dirsrc);
957
    if (dirtgt)
958
        glfs_h_close(dirtgt);
959
    if (dleaf)
960
        glfs_h_close(dleaf);
961

962
    return;
963
}
964

965
void
966
assimilatetime(struct timespec *ts, struct timespec ts_st,
967
               struct timespec ts_ed)
968
{
969
    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
970
        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
971
        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
972
    } else {
973
        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
974
        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
975
    }
976

977
    if (ts->tv_nsec > 1000000000) {
978
        ts->tv_nsec = ts->tv_nsec - 1000000000;
979
        ts->tv_sec += 1;
980
    }
981

982
    return;
983
}
984

985
#define MAX_FILES_CREATE 10
986
#define MAXPATHNAME 512
987
void
988
test_h_performance(void)
989
{
990
    char *my_dir = "perftest", *full_dir_path = "/testdir/perftest";
991
    char *my_file = "file_", my_file_name[MAXPATHNAME];
992
    struct glfs_object *parent = NULL, *leaf = NULL, *dir = NULL;
993
    struct stat sb;
994
    int ret, i;
995
    struct glfs_fd *fd;
996
    struct timespec c_ts = {0, 0}, c_ts_st, c_ts_ed;
997
    struct timespec o_ts = {0, 0}, o_ts_st, o_ts_ed;
998

999
    printf("glfs_h_performance tests: In Progress\n");
1000

1001
    /* Prepare tests */
1002
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
1003
    if (parent == NULL) {
1004
        fprintf(stderr,
1005
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1006
                full_parent_name, NULL, strerror(errno));
1007
        printf("glfs_h_performance tests: FAILED\n");
1008
        goto out;
1009
    }
1010

1011
    dir = glfs_h_mkdir(fs, parent, my_dir, 0755, &sb);
1012
    if (dir == NULL) {
1013
        fprintf(stderr, "glfs_h_mkdir: error creating %s: from (%p),%s\n",
1014
                my_dir, parent, strerror(errno));
1015
        printf("glfs_h_performance tests: FAILED\n");
1016
        goto out;
1017
    }
1018
    peek_stat(&sb);
1019

1020
    /* create performance */
1021
    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
1022
    if (ret != 0) {
1023
        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1024
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1025
        goto out;
1026
    }
1027

1028
    for (i = 0; i < MAX_FILES_CREATE; i++) {
1029
        sprintf(my_file_name, "%s%d", my_file, i);
1030

1031
        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
1032
        if (ret != 0) {
1033
            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1034
            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1035
            goto out;
1036
        }
1037

1038
        leaf = glfs_h_lookupat(fs, dir, my_file_name, &sb, 0);
1039
        if (leaf != NULL) {
1040
            fprintf(stderr, "glfs_h_lookup: exists %s\n", my_file_name);
1041
            printf("glfs_h_performance tests: FAILED\n");
1042
            goto out;
1043
        }
1044

1045
        leaf = glfs_h_creat(fs, dir, my_file_name, O_CREAT, 0644, &sb);
1046
        if (leaf == NULL) {
1047
            fprintf(stderr, "glfs_h_creat: error creating %s: from (%p),%s\n",
1048
                    my_file, dir, strerror(errno));
1049
            printf("glfs_h_performance tests: FAILED\n");
1050
            goto out;
1051
        }
1052

1053
        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
1054
        if (ret != 0) {
1055
            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1056
            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1057
            goto out;
1058
        }
1059

1060
        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
1061
        glfs_h_close(leaf);
1062
        leaf = NULL;
1063
    }
1064

1065
    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
1066
    if (ret != 0) {
1067
        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1068
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1069
        goto out;
1070
    }
1071

1072
    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
1073

1074
    printf("Creation performance (handle based):\n\t# empty files:%d\n",
1075
           MAX_FILES_CREATE);
1076
    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
1077
           o_ts.tv_nsec);
1078
    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
1079
           c_ts.tv_sec, c_ts.tv_nsec);
1080

1081
    /* create using path */
1082
    c_ts.tv_sec = o_ts.tv_sec = 0;
1083
    c_ts.tv_nsec = o_ts.tv_nsec = 0;
1084

1085
    sprintf(my_file_name, "%s1", full_dir_path);
1086
    ret = glfs_mkdir(fs, my_file_name, 0755);
1087
    if (ret != 0) {
1088
        fprintf(stderr, "glfs_mkdir: error creating %s: from (%p),%s\n", my_dir,
1089
                parent, strerror(errno));
1090
        printf("glfs_h_performance tests: FAILED\n");
1091
        goto out;
1092
    }
1093
    peek_stat(&sb);
1094

1095
    ret = clock_gettime(CLOCK_REALTIME, &o_ts_st);
1096
    if (ret != 0) {
1097
        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1098
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1099
        goto out;
1100
    }
1101

1102
    for (i = 0; i < MAX_FILES_CREATE; i++) {
1103
        sprintf(my_file_name, "%s1/%sn%d", full_dir_path, my_file, i);
1104

1105
        ret = clock_gettime(CLOCK_REALTIME, &c_ts_st);
1106
        if (ret != 0) {
1107
            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1108
            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1109
            goto out;
1110
        }
1111

1112
        ret = glfs_stat(fs, my_file_name, &sb);
1113
        if (ret == 0) {
1114
            fprintf(stderr, "glfs_stat: exists %s\n", my_file_name);
1115
            printf("glfs_h_performance tests: FAILED\n");
1116
            goto out;
1117
        }
1118

1119
        fd = glfs_creat(fs, my_file_name, O_CREAT, 0644);
1120
        if (fd == NULL) {
1121
            fprintf(stderr, "glfs_creat: error creating %s: from (%p),%s\n",
1122
                    my_file, dir, strerror(errno));
1123
            printf("glfs_h_performance tests: FAILED\n");
1124
            goto out;
1125
        }
1126

1127
        ret = clock_gettime(CLOCK_REALTIME, &c_ts_ed);
1128
        if (ret != 0) {
1129
            fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1130
            printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1131
            goto out;
1132
        }
1133

1134
        assimilatetime(&c_ts, c_ts_st, c_ts_ed);
1135
        glfs_close(fd);
1136
    }
1137

1138
    ret = clock_gettime(CLOCK_REALTIME, &o_ts_ed);
1139
    if (ret != 0) {
1140
        fprintf(stderr, "clock_gettime: error %s\n", strerror(errno));
1141
        printf("glfs_h_getattrs and setattrs tests: FAILED\n");
1142
        goto out;
1143
    }
1144

1145
    assimilatetime(&o_ts, o_ts_st, o_ts_ed);
1146

1147
    printf("Creation performance (path based):\n\t# empty files:%d\n",
1148
           MAX_FILES_CREATE);
1149
    printf("\tOverall time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", o_ts.tv_sec,
1150
           o_ts.tv_nsec);
1151
    printf("\tcreate call time time:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
1152
           c_ts.tv_sec, c_ts.tv_nsec);
1153
out:
1154
    return;
1155
}
1156

1157
int
1158
test_handleops(int argc, char *argv[])
1159
{
1160
    int ret = 0;
1161
    glfs_fd_t *fd = NULL;
1162
    struct stat sb = {
1163
        0,
1164
    };
1165
    struct glfs_object *root = NULL, *parent = NULL, *leaf = NULL, *tmp = NULL;
1166
    char readbuf[32], writebuf[32];
1167
    unsigned char leaf_handle[GFAPI_HANDLE_LENGTH];
1168

1169
    char *full_leaf_name = "/testdir/testfile.txt", *leaf_name = "testfile.txt",
1170
         *relative_leaf_name = "testdir/testfile.txt";
1171
    char *leaf_name1 = "testfile1.txt";
1172
    char *full_newparent_name = "/testdir/dir1", *newparent_name = "dir1";
1173
    char *full_newnod_name = "/testdir/nod1", *newnod_name = "nod1";
1174

1175
    /* Initialize test area */
1176
    ret = glfs_mkdir(fs, full_parent_name, 0755);
1177
    if (ret != 0 && errno != EEXIST) {
1178
        fprintf(stderr, "%s: (%p) %s\n", full_parent_name, fd, strerror(errno));
1179
        printf("Test initialization failed on volume %s\n", argv[1]);
1180
        goto out;
1181
    } else if (ret != 0) {
1182
        printf("Found test directory %s to be existing\n", full_parent_name);
1183
        printf("Cleanup test directory and restart tests\n");
1184
        goto out;
1185
    }
1186

1187
    fd = glfs_creat(fs, full_leaf_name, O_CREAT, 0644);
1188
    if (fd == NULL) {
1189
        fprintf(stderr, "%s: (%p) %s\n", full_leaf_name, fd, strerror(errno));
1190
        printf("Test initialization failed on volume %s\n", argv[1]);
1191
        goto out;
1192
    }
1193
    glfs_close(fd);
1194

1195
    printf("Initialized the test area, within volume %s\n", argv[1]);
1196

1197
    /* Handle based APIs test area */
1198

1199
    /* glfs_lookupat test */
1200
    printf("glfs_h_lookupat tests: In Progress\n");
1201
    /* start at root of the volume */
1202
    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
1203
    if (root == NULL) {
1204
        fprintf(stderr,
1205
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
1206
                NULL, strerror(errno));
1207
        printf("glfs_h_lookupat tests: FAILED\n");
1208
        goto out;
1209
    }
1210
    peek_stat(&sb);
1211

1212
    /* lookup a parent within root */
1213
    parent = glfs_h_lookupat(fs, root, parent_name, &sb, 0);
1214
    if (parent == NULL) {
1215
        fprintf(stderr,
1216
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1217
                parent_name, root, strerror(errno));
1218
        printf("glfs_h_lookupat tests: FAILED\n");
1219
        goto out;
1220
    }
1221
    peek_stat(&sb);
1222

1223
    /* lookup a leaf/child within the parent */
1224
    leaf = glfs_h_lookupat(fs, parent, leaf_name, &sb, 0);
1225
    if (leaf == NULL) {
1226
        fprintf(stderr,
1227
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1228
                leaf_name, parent, strerror(errno));
1229
        printf("glfs_h_lookupat tests: FAILED\n");
1230
        goto out;
1231
    }
1232
    peek_stat(&sb);
1233

1234
    /* reset */
1235
    glfs_h_close(root);
1236
    root = NULL;
1237
    glfs_h_close(leaf);
1238
    leaf = NULL;
1239
    glfs_h_close(parent);
1240
    parent = NULL;
1241

1242
    /* check absolute paths */
1243
    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
1244
    if (root == NULL) {
1245
        fprintf(stderr,
1246
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n", "/",
1247
                NULL, strerror(errno));
1248
        printf("glfs_h_lookupat tests: FAILED\n");
1249
        goto out;
1250
    }
1251
    peek_stat(&sb);
1252

1253
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
1254
    if (parent == NULL) {
1255
        fprintf(stderr,
1256
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1257
                full_parent_name, root, strerror(errno));
1258
        printf("glfs_h_lookupat tests: FAILED\n");
1259
        goto out;
1260
    }
1261
    peek_stat(&sb);
1262

1263
    leaf = glfs_h_lookupat(fs, NULL, full_leaf_name, &sb, 0);
1264
    if (leaf == NULL) {
1265
        fprintf(stderr,
1266
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1267
                full_leaf_name, parent, strerror(errno));
1268
        printf("glfs_h_lookupat tests: FAILED\n");
1269
        goto out;
1270
    }
1271
    peek_stat(&sb);
1272

1273
    /* reset */
1274
    glfs_h_close(leaf);
1275
    leaf = NULL;
1276

1277
    /* check multiple component paths */
1278
    leaf = glfs_h_lookupat(fs, root, relative_leaf_name, &sb, 0);
1279
    if (leaf == NULL) {
1280
        fprintf(stderr,
1281
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1282
                relative_leaf_name, parent, strerror(errno));
1283
        goto out;
1284
    }
1285
    peek_stat(&sb);
1286

1287
    /* reset */
1288
    glfs_h_close(root);
1289
    root = NULL;
1290
    glfs_h_close(parent);
1291
    parent = NULL;
1292

1293
    /* check symlinks in path */
1294

1295
    /* TODO: -ve test cases */
1296
    /* parent invalid
1297
     * path invalid
1298
     * path does not exist after some components
1299
     * no parent, but relative path
1300
     * parent and full path? -ve?
1301
     */
1302

1303
    printf("glfs_h_lookupat tests: PASSED\n");
1304

1305
    /* glfs_openat test */
1306
    printf("glfs_h_open tests: In Progress\n");
1307
    fd = glfs_h_open(fs, leaf, O_RDWR);
1308
    if (fd == NULL) {
1309
        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
1310
                full_leaf_name, strerror(errno));
1311
        printf("glfs_h_open tests: FAILED\n");
1312
        goto out;
1313
    }
1314

1315
    /* test read/write based on fd */
1316
    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
1317
    ret = glfs_write(fd, writebuf, 32, 0);
1318

1319
    glfs_lseek(fd, 10, SEEK_SET);
1320

1321
    ret = glfs_read(fd, readbuf, 32, 0);
1322
    if (memcmp(readbuf, writebuf, 32)) {
1323
        printf("Failed to read what I wrote: %s %s\n", readbuf, writebuf);
1324
        glfs_close(fd);
1325
        printf("glfs_h_open tests: FAILED\n");
1326
        goto out;
1327
    }
1328

1329
    glfs_h_close(leaf);
1330
    leaf = NULL;
1331
    glfs_close(fd);
1332

1333
    printf("glfs_h_open tests: PASSED\n");
1334

1335
    /* Create tests */
1336
    printf("glfs_h_creat tests: In Progress\n");
1337
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
1338
    if (parent == NULL) {
1339
        fprintf(stderr,
1340
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1341
                full_parent_name, root, strerror(errno));
1342
        printf("glfs_h_creat tests: FAILED\n");
1343
        goto out;
1344
    }
1345
    peek_stat(&sb);
1346

1347
    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT, 0644, &sb);
1348
    if (leaf == NULL) {
1349
        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
1350
                leaf_name1, parent, strerror(errno));
1351
        printf("glfs_h_creat tests: FAILED\n");
1352
        goto out;
1353
    }
1354
    peek_stat(&sb);
1355

1356
    glfs_h_close(leaf);
1357
    leaf = NULL;
1358

1359
    leaf = glfs_h_creat(fs, parent, leaf_name1, O_CREAT | O_EXCL, 0644, &sb);
1360
    if (leaf != NULL || errno != EEXIST) {
1361
        fprintf(stderr,
1362
                "glfs_h_creat: existing file, leaf = (%p), errno = %s\n", leaf,
1363
                strerror(errno));
1364
        printf("glfs_h_creat tests: FAILED\n");
1365
        if (leaf != NULL) {
1366
            glfs_h_close(leaf);
1367
            leaf = NULL;
1368
        }
1369
    }
1370

1371
    tmp = glfs_h_creat(fs, root, parent_name, O_CREAT, 0644, &sb);
1372
    if (tmp != NULL || !(errno == EISDIR || errno == EINVAL)) {
1373
        fprintf(stderr, "glfs_h_creat: dir create, tmp = (%p), errno = %s\n",
1374
                leaf, strerror(errno));
1375
        printf("glfs_h_creat tests: FAILED\n");
1376
        if (tmp != NULL) {
1377
            glfs_h_close(tmp);
1378
            tmp = NULL;
1379
        }
1380
    }
1381

1382
    /* TODO: Other combinations and -ve cases as applicable */
1383
    printf("glfs_h_creat tests: PASSED\n");
1384

1385
    /* extract handle and create from handle test */
1386
    printf(
1387
        "glfs_h_extract_handle and glfs_h_create_from_handle tests: In "
1388
        "Progress\n");
1389
    /* TODO: Change the lookup to create below for a GIFD recovery failure,
1390
     * that needs to be fixed */
1391
    leaf = glfs_h_lookupat(fs, parent, leaf_name1, &sb, 0);
1392
    if (leaf == NULL) {
1393
        fprintf(stderr,
1394
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1395
                leaf_name1, parent, strerror(errno));
1396
        printf("glfs_h_extract_handle tests: FAILED\n");
1397
        goto out;
1398
    }
1399
    peek_stat(&sb);
1400

1401
    ret = glfs_h_extract_handle(leaf, leaf_handle, GFAPI_HANDLE_LENGTH);
1402
    if (ret < 0) {
1403
        fprintf(stderr,
1404
                "glfs_h_extract_handle: error extracting handle of %s: %s\n",
1405
                full_leaf_name, strerror(errno));
1406
        printf("glfs_h_extract_handle tests: FAILED\n");
1407
        goto out;
1408
    }
1409
    peek_handle(leaf_handle);
1410

1411
    glfs_h_close(leaf);
1412
    leaf = NULL;
1413

1414
    leaf = glfs_h_create_from_handle(fs, leaf_handle, GFAPI_HANDLE_LENGTH, &sb);
1415
    if (leaf == NULL) {
1416
        fprintf(
1417
            stderr,
1418
            "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n",
1419
            leaf_name1, leaf_handle, strerror(errno));
1420
        printf("glfs_h_create_from_handle tests: FAILED\n");
1421
        goto out;
1422
    }
1423
    peek_stat(&sb);
1424

1425
    fd = glfs_h_open(fs, leaf, O_RDWR);
1426
    if (fd == NULL) {
1427
        fprintf(stderr, "glfs_h_open: error on open of %s: %s\n",
1428
                full_leaf_name, strerror(errno));
1429
        printf("glfs_h_create_from_handle tests: FAILED\n");
1430
        goto out;
1431
    }
1432

1433
    /* test read/write based on fd */
1434
    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
1435
    ret = glfs_write(fd, writebuf, 32, 0);
1436

1437
    glfs_lseek(fd, 0, SEEK_SET);
1438

1439
    ret = glfs_read(fd, readbuf, 32, 0);
1440
    if (memcmp(readbuf, writebuf, 32)) {
1441
        printf("Failed to read what I wrote: %s %s\n", writebuf, writebuf);
1442
        printf("glfs_h_create_from_handle tests: FAILED\n");
1443
        glfs_close(fd);
1444
        goto out;
1445
    }
1446

1447
    glfs_close(fd);
1448
    glfs_h_close(leaf);
1449
    leaf = NULL;
1450
    glfs_h_close(parent);
1451
    parent = NULL;
1452

1453
    printf(
1454
        "glfs_h_extract_handle and glfs_h_create_from_handle tests: PASSED\n");
1455

1456
    /* Mkdir tests */
1457
    printf("glfs_h_mkdir tests: In Progress\n");
1458

1459
    ret = glfs_rmdir(fs, full_newparent_name);
1460
    if (ret && errno != ENOENT) {
1461
        fprintf(stderr, "glfs_rmdir: Failed for %s: %s\n", full_newparent_name,
1462
                strerror(errno));
1463
        printf("glfs_h_mkdir tests: FAILED\n");
1464
        goto out;
1465
    }
1466

1467
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
1468
    if (parent == NULL) {
1469
        fprintf(stderr,
1470
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1471
                full_parent_name, root, strerror(errno));
1472
        printf("glfs_h_mkdir tests: FAILED\n");
1473
        goto out;
1474
    }
1475
    peek_stat(&sb);
1476

1477
    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0755, &sb);
1478
    if (leaf == NULL) {
1479
        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
1480
                newparent_name, parent, strerror(errno));
1481
        printf("glfs_h_mkdir tests: FAILED\n");
1482
        goto out;
1483
    }
1484
    peek_stat(&sb);
1485

1486
    glfs_h_close(leaf);
1487
    leaf = NULL;
1488

1489
    leaf = glfs_h_mkdir(fs, parent, newparent_name, 0755, &sb);
1490
    if (leaf != NULL || errno != EEXIST) {
1491
        fprintf(stderr,
1492
                "glfs_h_mkdir: existing directory, leaf = (%p), errno = %s\n",
1493
                leaf, strerror(errno));
1494
        printf("glfs_h_mkdir tests: FAILED\n");
1495
        if (leaf != NULL) {
1496
            glfs_h_close(leaf);
1497
            leaf = NULL;
1498
        }
1499
    }
1500

1501
    glfs_h_close(parent);
1502
    parent = NULL;
1503

1504
    printf("glfs_h_mkdir tests: PASSED\n");
1505

1506
    /* Mknod tests */
1507
    printf("glfs_h_mknod tests: In Progress\n");
1508
    ret = glfs_unlink(fs, full_newnod_name);
1509
    if (ret && errno != ENOENT) {
1510
        fprintf(stderr, "glfs_unlink: Failed for %s: %s\n", full_newnod_name,
1511
                strerror(errno));
1512
        printf("glfs_h_mknod tests: FAILED\n");
1513
        goto out;
1514
    }
1515

1516
    parent = glfs_h_lookupat(fs, NULL, full_parent_name, &sb, 0);
1517
    if (parent == NULL) {
1518
        fprintf(stderr,
1519
                "glfs_h_lookupat: error on lookup of %s: from (%p),%s\n",
1520
                full_parent_name, root, strerror(errno));
1521
        printf("glfs_h_mknod tests: FAILED\n");
1522
        goto out;
1523
    }
1524
    peek_stat(&sb);
1525

1526
    leaf = glfs_h_mknod(fs, parent, newnod_name, S_IFIFO, 0, &sb);
1527
    if (leaf == NULL) {
1528
        fprintf(stderr, "glfs_h_mkdir: error on mkdir of %s: from (%p),%s\n",
1529
                newnod_name, parent, strerror(errno));
1530
        printf("glfs_h_mknod tests: FAILED\n");
1531
        goto out;
1532
    }
1533
    peek_stat(&sb);
1534

1535
    /* TODO: create op on a FIFO node hangs, need to check and fix
1536
    tmp = glfs_h_creat (fs, parent, newnod_name, O_CREAT, 0644, &sb);
1537
    if (tmp != NULL || errno != EINVAL) {
1538
            fprintf (stderr, "glfs_h_creat: node create, tmp = (%p), errno =
1539
    %s\n", tmp, strerror (errno)); printf ("glfs_h_creat/mknod tests:
1540
    FAILED\n"); if (tmp != NULL) { glfs_h_close(tmp); tmp = NULL;
1541
            }
1542
    } */
1543

1544
    glfs_h_close(leaf);
1545
    leaf = NULL;
1546

1547
    leaf = glfs_h_mknod(fs, parent, newnod_name, 0644, 0, &sb);
1548
    if (leaf != NULL || errno != EEXIST) {
1549
        fprintf(stderr,
1550
                "glfs_h_mknod: existing node, leaf = (%p), errno = %s\n", leaf,
1551
                strerror(errno));
1552
        printf("glfs_h_mknod tests: FAILED\n");
1553
        if (leaf != NULL) {
1554
            glfs_h_close(leaf);
1555
            leaf = NULL;
1556
        }
1557
    }
1558

1559
    glfs_h_close(parent);
1560
    parent = NULL;
1561

1562
    printf("glfs_h_mknod tests: PASSED\n");
1563

1564
    /* unlink tests */
1565
    test_h_unlink();
1566

1567
    /* TODO: opendir tests */
1568

1569
    /* getattr tests */
1570
    test_h_getsetattrs();
1571

1572
    /* TODO: setattr tests */
1573

1574
    /* truncate tests */
1575
    test_h_truncate();
1576

1577
    /* link tests */
1578
    test_h_links();
1579

1580
    /* rename tests */
1581
    test_h_rename();
1582

1583
    /* performance tests */
1584
    test_h_performance();
1585

1586
    /* END: New APIs test area */
1587

1588
out:
1589
    /* Cleanup glfs handles */
1590
    if (root)
1591
        glfs_h_close(root);
1592
    if (parent)
1593
        glfs_h_close(parent);
1594
    if (leaf)
1595
        glfs_h_close(leaf);
1596

1597
    return ret;
1598
}
1599

1600
int
1601
test_write_apis(glfs_t *fs)
1602
{
1603
    /* Add more content here */
1604
    /* Some apis we can get are */
1605
    /*
1606
      0. glfs_set_xlator_option()
1607

1608
      Read/Write combinations:
1609
      . glfs_{p,}readv/{p,}writev
1610
      . glfs_pread/pwrite
1611

1612
      tests/basic/gfapi/gfapi-async-calls-test.c
1613
      . glfs_read_async/write_async
1614
      . glfs_pread_async/pwrite_async
1615
      . glfs_readv_async/writev_async
1616
      . glfs_preadv_async/pwritev_async
1617

1618
      . ftruncate/ftruncate_async
1619
      . fsync/fsync_async
1620
      . fdatasync/fdatasync_async
1621

1622
    */
1623

1624
    glfs_fd_t *fd = NULL;
1625
    char *filename = "/filename2";
1626
    int flags = O_RDWR;
1627
    char *buf = "some bytes!";
1628
    char writestr[TEST_STR_LEN];
1629
    struct iovec iov = {&writestr, TEST_STR_LEN};
1630
    int ret, i;
1631

1632
    for (i = 0; i < TEST_STR_LEN; i++)
1633
        writestr[i] = 0x11;
1634

1635
    fd = glfs_open(fs, filename, flags);
1636
    if (!fd)
1637
        fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
1638

1639
    ret = glfs_writev(fd, &iov, 1, flags);
1640
    if (ret < 0) {
1641
        fprintf(stderr, "writev(%s): %d (%s)\n", filename, ret,
1642
                strerror(errno));
1643
    }
1644

1645
    ret = glfs_pwrite(fd, buf, 10, 4, flags, NULL, NULL);
1646
    if (ret < 0) {
1647
        fprintf(stderr, "pwrite(%s): %d (%s)\n", filename, ret,
1648
                strerror(errno));
1649
    }
1650

1651
    ret = glfs_pwritev(fd, &iov, 1, 4, flags);
1652
    if (ret < 0) {
1653
        fprintf(stderr, "pwritev(%s): %d (%s)\n", filename, ret,
1654
                strerror(errno));
1655
    }
1656

1657
    ret = glfs_fsync(fd, NULL, NULL);
1658
    if (ret < 0) {
1659
        fprintf(stderr, "fsync(%s): %d (%s)\n", filename, ret, strerror(errno));
1660
    }
1661

1662
    glfs_close(fd);
1663

1664
    return 0;
1665
}
1666

1667
int
1668
test_metadata_ops(glfs_t *fs, glfs_t *fs2)
1669
{
1670
    glfs_fd_t *fd = NULL;
1671
    glfs_fd_t *fd2 = NULL;
1672
    struct stat sb = {
1673
        0,
1674
    };
1675
    struct glfs_stat gsb = {
1676
        0,
1677
    };
1678
    struct statvfs sfs;
1679
    char readbuf[32];
1680
    char writebuf[11] = "helloworld";
1681

1682
    char *filename = "/filename2";
1683
    int ret;
1684

1685
    ret = glfs_lstat(fs, filename, &sb);
1686
    fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
1687

1688
    fd = glfs_creat(fs, filename, O_RDWR, 0644);
1689
    if (!fd)
1690
        fprintf(stderr, "creat(%s): (%p) %s\n", filename, fd, strerror(errno));
1691

1692
    fd2 = glfs_open(fs2, filename, O_RDWR);
1693
    if (!fd2)
1694
        fprintf(stderr, "open(%s): (%p) %s\n", filename, fd, strerror(errno));
1695

1696
    ret = glfs_lstat(fs, filename, &sb);
1697
    if (ret)
1698
        fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
1699

1700
    ret = glfs_write(fd, writebuf, 11, 0);
1701
    if (ret < 0) {
1702
        fprintf(stderr, "writev(%s): %d (%s)\n", filename, ret,
1703
                strerror(errno));
1704
    }
1705

1706
    glfs_fsync(fd, NULL, NULL);
1707

1708
    glfs_lseek(fd2, 5, SEEK_SET);
1709

1710
    ret = glfs_read(fd2, readbuf, 32, 0);
1711

1712
    printf("read %d, %s", ret, readbuf);
1713

1714
    /* get stat */
1715
    ret = glfs_fstat(fd2, &sb);
1716
    if (ret)
1717
        fprintf(stderr, "fstat(%s): %d (%s)\n", filename, ret, strerror(errno));
1718

1719
    ret = glfs_access(fs, filename, R_OK);
1720
    if (ret)
1721
        fprintf(stderr, "access(%s): %d (%s)\n", filename, ret,
1722
                strerror(errno));
1723

1724
    ret = glfs_fallocate(fd2, 1024, 1024, 1024);
1725
    if (ret)
1726
        fprintf(stderr, "fallocate(%s): %d (%s)\n", filename, ret,
1727
                strerror(errno));
1728

1729
    ret = glfs_discard(fd2, 1024, 512);
1730
    if (ret)
1731
        fprintf(stderr, "discard(%s): %d (%s)\n", filename, ret,
1732
                strerror(errno));
1733

1734
    ret = glfs_zerofill(fd2, 2048, 1024);
1735
    if (ret)
1736
        fprintf(stderr, "zerofill(%s): %d (%s)\n", filename, ret,
1737
                strerror(errno));
1738

1739
    /* set stat */
1740
    /* TODO: got some errors, need to fix */
1741
    ret = glfs_fsetattr(fd2, &gsb);
1742

1743
    glfs_close(fd);
1744
    glfs_close(fd2);
1745

1746
    filename = "/filename3";
1747
    ret = glfs_mknod(fs, filename, S_IFIFO, 0);
1748
    if (ret)
1749
        fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
1750

1751
    ret = glfs_lstat(fs, filename, &sb);
1752
    if (ret)
1753
        fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
1754

1755
    ret = glfs_rename(fs, filename, "/filename4");
1756
    if (ret)
1757
        fprintf(stderr, "rename(%s): (%d) %s\n", filename, ret,
1758
                strerror(errno));
1759

1760
    ret = glfs_unlink(fs, "/filename4");
1761
    if (ret)
1762
        fprintf(stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
1763
                strerror(errno));
1764

1765
    filename = "/dirname2";
1766
    ret = glfs_mkdir(fs, filename, 0);
1767
    if (ret)
1768
        fprintf(stderr, "%s: (%d) %s\n", filename, ret, strerror(errno));
1769

1770
    ret = glfs_lstat(fs, filename, &sb);
1771
    if (ret)
1772
        fprintf(stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror(errno));
1773

1774
    ret = glfs_rmdir(fs, filename);
1775
    if (ret)
1776
        fprintf(stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror(errno));
1777
}
1778
int
1779
main(int argc, char *argv[])
1780
{
1781
    glfs_t *fs2 = NULL;
1782
    int ret = 0;
1783
    glfs_fd_t *fd = NULL;
1784
    glfs_fd_t *fd2 = NULL;
1785
    struct stat sb = {
1786
        0,
1787
    };
1788
    struct glfs_stat gsb = {
1789
        0,
1790
    };
1791
    struct statvfs sfs;
1792
    char readbuf[32];
1793
    char writebuf[32];
1794
    char volumeid[64];
1795

1796
    char *filename = "/filename2";
1797

1798
    if ((argc < 2) || (argc > 3)) {
1799
        printf("Usage:\n\t%s <volname> <hostname>\n\t%s <volfile-path>",
1800
               argv[0], argv[0]);
1801
        return -1;
1802
    }
1803

1804
    if (argc == 2) {
1805
        /* Generally glfs_new() requires volume name as an argument */
1806
        fs = glfs_new("test-only");
1807
        if (!fs) {
1808
            fprintf(stderr, "glfs_new: returned NULL\n");
1809
            return 1;
1810
        }
1811
        ret = glfs_set_volfile(fs, argv[1]);
1812
        if (ret)
1813
            fprintf(stderr, "glfs_set_volfile failed\n");
1814
    } else {
1815
        fs = glfs_new(argv[1]);
1816
        if (!fs) {
1817
            fprintf(stderr, "glfs_new: returned NULL\n");
1818
            return 1;
1819
        }
1820
        // ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
1821
        ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007);
1822
        if (ret)
1823
            fprintf(stderr, "glfs_set_volfile_server failed\n");
1824
    }
1825

1826
    /* Change this to relevant file when running locally */
1827
    ret = glfs_set_logging(fs, "/dev/stderr", 5);
1828
    if (ret)
1829
        fprintf(stderr, "glfs_set_logging failed\n");
1830

1831
    ret = glfs_init(fs);
1832
    if (ret)
1833
        fprintf(stderr, "glfs_init: returned %d\n", ret);
1834

1835
    if (ret)
1836
        goto out;
1837

1838
    /* no major use for getting the volume id in this test, done for coverage */
1839
    ret = glfs_get_volumeid(fs, volumeid, 64);
1840
    if (ret) {
1841
        fprintf(stderr, "glfs_get_volumeid: returned %d\n", ret);
1842
    }
1843

1844
    sleep(2);
1845

1846
    if (argc == 2) {
1847
        /* Generally glfs_new() requires volume name as an argument */
1848
        fs2 = glfs_new("test_only_volume");
1849
        if (!fs2) {
1850
            fprintf(stderr, "glfs_new(fs2): returned NULL\n");
1851
            return 1;
1852
        }
1853
        ret = glfs_set_volfile(fs2, argv[1]);
1854
        if (ret)
1855
            fprintf(stderr, "glfs_set_volfile failed(fs2)\n");
1856
    } else {
1857
        fs2 = glfs_new(argv[1]);
1858
        if (!fs2) {
1859
            fprintf(stderr, "glfs_new(fs2): returned NULL\n");
1860
            return 1;
1861
        }
1862
        ret = glfs_set_volfile_server(fs2, "tcp", argv[2], 24007);
1863
        if (ret)
1864
            fprintf(stderr, "glfs_set_volfile_server failed(fs2)\n");
1865
    }
1866

1867
    ret = glfs_set_statedump_path(fs2, "/tmp");
1868
    if (ret) {
1869
        fprintf(stderr, "glfs_set_statedump_path: %s\n", strerror(errno));
1870
    }
1871

1872
    ret = glfs_init(fs2);
1873
    if (ret)
1874
        fprintf(stderr, "glfs_init: returned %d\n", ret);
1875

1876
    test_metadata_ops(fs, fs2);
1877

1878
    test_dirops(fs);
1879

1880
    test_xattr(fs);
1881

1882
    test_chdir(fs);
1883

1884
    test_handleops(argc, argv);
1885
    // done
1886

1887
    /* Test some extra apis */
1888
    test_write_apis(fs);
1889

1890
    glfs_statvfs(fs, "/", &sfs);
1891

1892
    glfs_unset_volfile_server(fs, "tcp", argv[2], 24007);
1893

1894
    glfs_fini(fs);
1895
    glfs_fini(fs2);
1896

1897
    ret = 0;
1898
out:
1899
    return ret;
1900
}
1901