1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*
* Copyright 2021 The Emscripten Authors. All rights reserved.
* Emscripten is available under two separate licenses, the MIT license and the
* University of Illinois/NCSA Open Source License. Both these licenses can be
* found in the LICENSE file.
*/
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include <utime.h>
// FIXME: Individual test to verify fstat in isolation. May get merged with
// others later.
int main() {
// Attempt to call fstat on an invalid fd.
errno = 0;
struct stat invalid;
int result = fstat(-1, &invalid);
assert(result == -1);
assert(errno == EBADF);
// Test opening a file and calling fstat.
struct stat file;
int fd = open("/dev/stdout/", O_WRONLY);
assert(fd >= 0);
assert(fstat(fd, &file) != -1);
off_t fileInode = file.st_ino;
assert(file.st_size == 0);
assert((file.st_mode & S_IFMT) == S_IFCHR);
assert(file.st_dev);
assert(file.st_nlink);
assert(file.st_uid == 0);
assert(file.st_gid == 0);
#ifdef WASMFS
assert(file.st_rdev == 0);
#endif
assert(file.st_blocks == 0);
assert(file.st_blksize == 4096);
close(fd);
// Check to see if the previous inode number matches.
int newfd = open("/dev/stdout/", O_WRONLY);
struct stat newFile;
assert(newfd >= 0);
assert(fstat(newfd, &newFile) != -1);
assert(fileInode == newFile.st_ino);
close(newfd);
// Test opening a directory and calling fstat.
struct stat directory;
int fd2 = open("/dev", O_RDONLY | O_DIRECTORY);
assert(fd2 >= 0);
assert(fstat(fd2, &directory) != -1);
off_t dirInode = directory.st_ino;
assert(directory.st_size == 4096);
assert((directory.st_mode & S_IFMT) == S_IFDIR);
assert(directory.st_dev);
assert(directory.st_nlink);
assert(directory.st_uid == 0);
assert(directory.st_gid == 0);
assert(directory.st_rdev == 0);
#ifdef WASMFS
// blkcnt_t st_blocks; /* Number of 512B blocks allocated */
assert(directory.st_blocks == 8);
#else
assert(directory.st_rdev == 0);
// The JS file system calculates st_blocks using Math.ceil(attr.size /
// attr.blksize);
assert(directory.st_blocks == 1);
#endif
assert(directory.st_blksize == 4096);
close(fd2);
// Check to see if the previous inode number matches.
int newfd2 = open("/dev", O_RDONLY | O_DIRECTORY);
struct stat newFile2;
assert(newfd2 >= 0);
assert(fstat(newfd2, &newFile2) != -1);
assert(dirInode == newFile2.st_ino);
close(newfd2);
// Test calling stat without opening a file.
struct stat statFile;
assert(stat("/dev/stdout/", &statFile) != -1);
assert(statFile.st_size == 0);
assert((statFile.st_mode & S_IFMT) == S_IFCHR);
assert(statFile.st_dev);
assert(statFile.st_nlink);
assert(statFile.st_uid == 0);
assert(statFile.st_gid == 0);
#ifdef WASMFS
assert(statFile.st_rdev == 0);
#endif
assert(statFile.st_blocks == 0);
assert(statFile.st_blksize == 4096);
// Test calling stat without opening a directory.
struct stat statDirectory;
assert(stat("/dev", &statDirectory) != -1);
assert(statDirectory.st_size == 4096);
assert((statDirectory.st_mode & S_IFMT) == S_IFDIR);
assert(statDirectory.st_dev);
assert(statDirectory.st_nlink);
assert(statDirectory.st_uid == 0);
assert(statDirectory.st_gid == 0);
assert(statDirectory.st_rdev == 0);
#ifdef WASMFS
// blkcnt_t st_blocks; /* Number of 512B blocks allocated */
assert(statDirectory.st_blocks == 8);
#else
assert(statDirectory.st_blocks == 1);
#endif
assert(statDirectory.st_blksize == 4096);
// Test calling stat with an empty path.
errno = 0;
assert(stat("", &invalid));
assert(errno == ENOENT);
// Test calling stat with a non-existent path.
errno = 0;
assert(stat("/non-existent", &invalid));
assert(errno == ENOENT);
// Test calling lstat without opening a file.
struct stat lstatFile;
errno = 0;
assert(lstat("/dev/stdout", &lstatFile) != -1);
assert(lstatFile.st_dev);
// TODO: When symlinks are added, this WasmFS should return S_IFLNK.
#ifdef WASMFS
assert((lstatFile.st_mode & S_IFMT) == S_IFCHR);
#else
assert((lstatFile.st_mode & S_IFMT) == S_IFLNK);
#endif
assert(lstatFile.st_nlink);
assert(lstatFile.st_uid == 0);
assert(lstatFile.st_gid == 0);
assert(lstatFile.st_blksize == 4096);
assert(lstatFile.st_rdev == 0);
#ifdef WASMFS
assert(lstatFile.st_size == 0);
assert(lstatFile.st_blocks == 0);
#else
// dev/stdout is a symlink to dev/tty.
// TODO: When symlinks are added, one should return stat info on the symlink.
assert(lstatFile.st_size == 8);
assert(lstatFile.st_blocks == 1);
#endif
// Test calling lstat without opening a directory.
struct stat lstatDirectory;
assert(lstat("/dev", &lstatDirectory) != -1);
assert(lstatDirectory.st_size == 4096);
assert((lstatDirectory.st_mode & S_IFMT) == S_IFDIR);
assert(lstatDirectory.st_dev);
assert(lstatDirectory.st_nlink);
assert(lstatDirectory.st_uid == 0);
assert(lstatDirectory.st_gid == 0);
assert(lstatDirectory.st_rdev == 0);
#ifdef WASMFS
// blkcnt_t st_blocks; /* Number of 512B blocks allocated */
assert(lstatDirectory.st_blocks == 8);
#else
assert(lstatDirectory.st_blocks == 1);
#endif
assert(lstatDirectory.st_blksize == 4096);
// write to a file and check that mtime is updated
const long long TEST_TIME = 1ll << 34;
struct utimbuf t = {TEST_TIME, TEST_TIME};
fd = open("file", O_WRONLY | O_CREAT | O_EXCL, 0777);
assert(utime("file", &t) != -1);
write(fd, 0, 0);
assert(fstat(fd, &statFile) != -1);
assert(statFile.st_mtime == TEST_TIME);
const char* buffer = "abcdef";
write(fd, buffer, sizeof(buffer));
assert(fstat(fd, &statFile) != -1);
assert(statFile.st_mtime != TEST_TIME);
close(fd);
return 0;
}
|
