glusterfs

1
#include <stdio.h>
2
#include <errno.h>
3
#include <string.h>
4
#include <stdbool.h>
5
#include <sys/types.h>
6
#include <sys/stat.h>
7
#include <unistd.h>
8
#include <glusterfs/api/glfs.h>
9

10
#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
11
    do {                                                                       \
12
        if (ret < 0) {                                                         \
13
            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
14
                    strerror(errno));                                          \
15
            goto label;                                                        \
16
        }                                                                      \
17
    } while (0)
18

19
#define GOTO_LABEL_ON_FALSE(compstr, ret, label)                               \
20
    do {                                                                       \
21
        if (ret == false) {                                                    \
22
            fprintf(stderr, "%s : comparison failed!\n", compstr);             \
23
            goto label;                                                        \
24
        }                                                                      \
25
    } while (0)
26

27
#define WRITE_SIZE 513
28
#define TRUNC_SIZE 4096
29

30
/* Using private function and hence providing a forward declation in sync with
31
code in glfs-internal.h */
32
int
33
glfs_statx(struct glfs *fs, const char *path, unsigned int mask,
34
           struct glfs_stat *statxbuf);
35

36
int
37
main(int argc, char *argv[])
38
{
39
    int ret = -1;
40
    int flags = O_RDWR | O_SYNC;
41
    glfs_t *fs = NULL;
42
    glfs_fd_t *fd1 = NULL;
43
    char *volname = NULL;
44
    char *logfile = NULL;
45
    const char *filename = "file_tmp";
46
    const char buff[WRITE_SIZE];
47
    struct stat sb;
48
    unsigned int mask;
49
    struct glfs_stat statx;
50
    bool bret;
51

52
    if (argc != 3) {
53
        fprintf(stderr, "Invalid argument\n");
54
        fprintf(stderr, "Usage: %s <volname> <logfile>\n", argv[0]);
55
        return 1;
56
    }
57

58
    volname = argv[1];
59
    logfile = argv[2];
60

61
    fs = glfs_new(volname);
62
    if (!fs)
63
        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
64

65
    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
66
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
67

68
    ret = glfs_set_logging(fs, logfile, 7);
69
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
70

71
    ret = glfs_init(fs);
72
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
73

74
    fd1 = glfs_creat(fs, filename, flags, 0644);
75
    if (fd1 == NULL) {
76
        ret = -1;
77
        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
78
    }
79

80
    ret = glfs_truncate(fs, filename, TRUNC_SIZE);
81
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_truncate", ret, out);
82

83
    ret = glfs_write(fd1, buff, WRITE_SIZE, flags);
84
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
85

86
    ret = glfs_fstat(fd1, &sb);
87
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_fstat", ret, out);
88

89
    if (sb.st_size != TRUNC_SIZE) {
90
        fprintf(stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size,
91
                (intmax_t)2048);
92
        ret = -1;
93
        goto out;
94
    }
95

96
    glfs_close(fd1);
97
    fd1 = NULL;
98

99
    /* TEST 1: Invalid mask to statx */
100
    mask = 0xfafadbdb;
101
    ret = glfs_statx(fs, filename, mask, NULL);
102
    if (ret == 0 || ((ret == -1) && (errno != EINVAL))) {
103
        fprintf(stderr,
104
                "Invalid args passed, but error returned is"
105
                " incorrect (ret - %d, errno - %d)\n",
106
                ret, errno);
107
        ret = -1;
108
        goto out;
109
    }
110
    ret = 0;
111

112
    /* TEST 2: Call statx and validate fields against prior fstat data */
113
    /* NOTE: This fails, as iatt->ia_flags are not carried through the stack,
114
     * for example if mdc_to_iatt is invoked to serve cached stat, we will loose
115
     * the flags. */
116
    mask = GLFS_STAT_ALL;
117
    ret = glfs_statx(fs, filename, mask, &statx);
118
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_statx", ret, out);
119

120
    if ((statx.glfs_st_mask & GLFS_STAT_BASIC_STATS) != GLFS_STAT_BASIC_STATS) {
121
        fprintf(stderr, "Invalid glfs_st_mask, expecting 0x%x got 0x%x\n",
122
                GLFS_STAT_ALL, statx.glfs_st_mask);
123
        ret = -1;
124
        goto out;
125
    }
126

127
    bret = (sb.st_ino == statx.glfs_st_ino);
128
    GOTO_LABEL_ON_FALSE("(sb.st_ino == statx.glfs_st_ino)", bret, out);
129

130
    bret = (sb.st_mode == statx.glfs_st_mode);
131
    GOTO_LABEL_ON_FALSE("(sb.st_mode == statx.glfs_st_mode)", bret, out);
132

133
    bret = (sb.st_nlink == statx.glfs_st_nlink);
134
    GOTO_LABEL_ON_FALSE("(sb.st_nlink == statx.glfs_st_nlink)", bret, out);
135

136
    bret = (sb.st_uid == statx.glfs_st_uid);
137
    GOTO_LABEL_ON_FALSE("(sb.st_uid == statx.glfs_st_uid)", bret, out);
138

139
    bret = (sb.st_gid == statx.glfs_st_gid);
140
    GOTO_LABEL_ON_FALSE("(sb.st_gid == statx.glfs_st_gid)", bret, out);
141

142
    bret = (sb.st_size == statx.glfs_st_size);
143
    GOTO_LABEL_ON_FALSE("(sb.st_size == statx.glfs_st_size)", bret, out);
144

145
    bret = (sb.st_blksize == statx.glfs_st_blksize);
146
    GOTO_LABEL_ON_FALSE("(sb.st_blksize == statx.glfs_st_blksize)", bret, out);
147

148
    bret = (sb.st_blocks == statx.glfs_st_blocks);
149
    GOTO_LABEL_ON_FALSE("(sb.st_blocks == statx.glfs_st_blocks)", bret, out);
150

151
    bret = (!memcmp(&sb.st_atim, &statx.glfs_st_atime,
152
                    sizeof(struct timespec)));
153
    GOTO_LABEL_ON_FALSE("(sb.st_atim == statx.glfs_st_atime)", bret, out);
154

155
    bret = (!memcmp(&sb.st_mtim, &statx.glfs_st_mtime,
156
                    sizeof(struct timespec)));
157
    GOTO_LABEL_ON_FALSE("(sb.st_mtim == statx.glfs_st_mtime)", bret, out);
158

159
    bret = (!memcmp(&sb.st_ctim, &statx.glfs_st_ctime,
160
                    sizeof(struct timespec)));
161
    GOTO_LABEL_ON_FALSE("(sb.st_ctim == statx.glfs_st_ctime)", bret, out);
162

163
    /* TEST 3: Check if partial masks are accepted */
164
    mask = GLFS_STAT_TYPE | GLFS_STAT_UID | GLFS_STAT_GID;
165
    ret = glfs_statx(fs, filename, mask, &statx);
166
    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_statx", ret, out);
167

168
    /* We currently still return all stats, as is acceptable based on the API
169
     * definition in the header (and in statx as well) */
170
    if ((statx.glfs_st_mask & GLFS_STAT_BASIC_STATS) != GLFS_STAT_BASIC_STATS) {
171
        fprintf(stderr, "Invalid glfs_st_mask, expecting 0x%x got 0x%x\n",
172
                GLFS_STAT_ALL, statx.glfs_st_mask);
173
        ret = -1;
174
        goto out;
175
    }
176
out:
177
    if (fd1 != NULL)
178
        glfs_close(fd1);
179
    if (fs) {
180
        (void)glfs_fini(fs);
181
    }
182

183
    return ret;
184
}
185