?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove building with NOCRYPTO option
[minix3.git] / tests / fs / vfs / t_vnops.c
blob3a2bd80dd552e2d8b8c8cf61c85312458947eba3
1 /* $NetBSD: t_vnops.c,v 1.49 2015/04/09 19:47:05 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2010 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/stat.h>
30 #include <sys/statvfs.h>
31
32 #include <assert.h>
33 #include <atf-c.h>
34 #include <fcntl.h>
35 #include <libgen.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <unistd.h>
39
40 #include <rump/rump_syscalls.h>
41 #include <rump/rump.h>
42
43 #include "../common/h_fsmacros.h"
44 #include "../../h_macros.h"
45
46 #define TESTFILE "afile"
47
48 #define USES_DIRS \
49 if (FSTYPE_SYSVBFS(tc)) \
50 atf_tc_skip("directories not supported by file system")
51
52 #define USES_SYMLINKS \
53 if (FSTYPE_SYSVBFS(tc) || FSTYPE_MSDOS(tc)) \
54 atf_tc_skip("symlinks not supported by file system")
55
56 static char *
57 md(char *buf, const char *base, const char *tail)
58 {
59
60 sprintf(buf, "%s/%s", base, tail);
61 return buf;
62 }
63
64 static void
65 lookup_simple(const atf_tc_t *tc, const char *mountpath)
66 {
67 char pb[MAXPATHLEN], final[MAXPATHLEN];
68 struct stat sb1, sb2;
69
70 strcpy(final, mountpath);
71 sprintf(pb, "%s/../%s", mountpath, basename(final));
72 if (rump_sys_stat(pb, &sb1) == -1)
73 atf_tc_fail_errno("stat 1");
74
75 sprintf(pb, "%s/./../%s", mountpath, basename(final));
76 if (rump_sys_stat(pb, &sb2) == -1)
77 atf_tc_fail_errno("stat 2");
78
79 ATF_REQUIRE(memcmp(&sb1, &sb2, sizeof(sb1)) == 0);
80 }
81
82 static void
83 lookup_complex(const atf_tc_t *tc, const char *mountpath)
84 {
85 char pb[MAXPATHLEN];
86 struct stat sb1, sb2;
87
88 USES_DIRS;
89
90 if (FSTYPE_UDF(tc))
91 atf_tc_expect_fail("PR kern/49033");
92
93 sprintf(pb, "%s/dir", mountpath);
94 if (rump_sys_mkdir(pb, 0777) == -1)
95 atf_tc_fail_errno("mkdir");
96 if (rump_sys_stat(pb, &sb1) == -1)
97 atf_tc_fail_errno("stat 1");
98
99 sprintf(pb, "%s/./dir/../././dir/.", mountpath);
100 if (rump_sys_stat(pb, &sb2) == -1)
101 atf_tc_fail_errno("stat 2");
102
103 if (memcmp(&sb1, &sb2, sizeof(sb1)) != 0) {
104 printf("what\tsb1\t\tsb2\n");
105
106 #define FIELD(FN) \
107 printf(#FN "\t%lld\t%lld\n", \
108 (long long)sb1.FN, (long long)sb2.FN)
109 #define TIME(FN) \
110 printf(#FN "\t%lld.%ld\t%lld.%ld\n", \
111 (long long)sb1.FN.tv_sec, sb1.FN.tv_nsec, \
112 (long long)sb2.FN.tv_sec, sb2.FN.tv_nsec)
113
114 FIELD(st_dev);
115 FIELD(st_mode);
116 FIELD(st_ino);
117 FIELD(st_nlink);
118 FIELD(st_uid);
119 FIELD(st_gid);
120 FIELD(st_rdev);
121 TIME(st_atimespec);
122 TIME(st_mtimespec);
123 TIME(st_ctimespec);
124 TIME(st_birthtimespec);
125 FIELD(st_size);
126 FIELD(st_blocks);
127 FIELD(st_flags);
128 FIELD(st_gen);
129
130 #undef FIELD
131 #undef TIME
132
133 atf_tc_fail("stat results differ, see ouput for more details");
134 }
135 if (FSTYPE_UDF(tc))
136 atf_tc_fail("random failure of PR kern/49033 "
137 "did not happen this time");
138 }
139
140 static void
141 dir_simple(const atf_tc_t *tc, const char *mountpath)
142 {
143 char pb[MAXPATHLEN];
144 struct stat sb;
145
146 USES_DIRS;
147
148 /* check we can create directories */
149 sprintf(pb, "%s/dir", mountpath);
150 if (rump_sys_mkdir(pb, 0777) == -1)
151 atf_tc_fail_errno("mkdir");
152 if (rump_sys_stat(pb, &sb) == -1)
153 atf_tc_fail_errno("stat new directory");
154
155 /* check we can remove then and that it makes them unreachable */
156 if (rump_sys_rmdir(pb) == -1)
157 atf_tc_fail_errno("rmdir");
158 if (rump_sys_stat(pb, &sb) != -1 || errno != ENOENT)
159 atf_tc_fail("ENOENT expected from stat");
160 }
161
162 static void
163 dir_notempty(const atf_tc_t *tc, const char *mountpath)
164 {
165 char pb[MAXPATHLEN], pb2[MAXPATHLEN];
166 int fd, rv;
167
168 USES_DIRS;
169
170 /* check we can create directories */
171 sprintf(pb, "%s/dir", mountpath);
172 if (rump_sys_mkdir(pb, 0777) == -1)
173 atf_tc_fail_errno("mkdir");
174
175 sprintf(pb2, "%s/dir/file", mountpath);
176 fd = rump_sys_open(pb2, O_RDWR | O_CREAT, 0777);
177 if (fd == -1)
178 atf_tc_fail_errno("create file");
179 rump_sys_close(fd);
180
181 rv = rump_sys_rmdir(pb);
182 if (rv != -1 || errno != ENOTEMPTY)
183 atf_tc_fail("non-empty directory removed succesfully");
184
185 if (rump_sys_unlink(pb2) == -1)
186 atf_tc_fail_errno("cannot remove dir/file");
187
188 if (rump_sys_rmdir(pb) == -1)
189 atf_tc_fail_errno("remove directory");
190 }
191
192 static void
193 dir_rmdirdotdot(const atf_tc_t *tc, const char *mp)
194 {
195 char pb[MAXPATHLEN];
196 int xerrno;
197
198 USES_DIRS;
199
200 FSTEST_ENTER();
201 RL(rump_sys_mkdir("test", 0777));
202 RL(rump_sys_chdir("test"));
203
204 RL(rump_sys_mkdir("subtest", 0777));
205 RL(rump_sys_chdir("subtest"));
206
207 md(pb, mp, "test/subtest");
208 RL(rump_sys_rmdir(pb));
209 md(pb, mp, "test");
210 RL(rump_sys_rmdir(pb));
211
212 if (FSTYPE_NFS(tc))
213 xerrno = ESTALE;
214 else
215 xerrno = ENOENT;
216 ATF_REQUIRE_ERRNO(xerrno, rump_sys_chdir("..") == -1);
217 FSTEST_EXIT();
218 }
219
220 static void
221 checkfile(const char *path, struct stat *refp)
222 {
223 char buf[MAXPATHLEN];
224 struct stat sb;
225 static int n = 1;
226
227 md(buf, path, "file");
228 if (rump_sys_stat(buf, &sb) == -1)
229 atf_tc_fail_errno("cannot stat file %d (%s)", n, buf);
230 if (memcmp(&sb, refp, sizeof(sb)) != 0)
231 atf_tc_fail("stat mismatch %d", n);
232 n++;
233 }
234
235 static void
236 rename_dir(const atf_tc_t *tc, const char *mp)
237 {
238 char pb1[MAXPATHLEN], pb2[MAXPATHLEN], pb3[MAXPATHLEN];
239 struct stat ref, sb;
240
241 if (FSTYPE_RUMPFS(tc))
242 atf_tc_skip("rename not supported by file system");
243
244 USES_DIRS;
245
246 md(pb1, mp, "dir1");
247 if (rump_sys_mkdir(pb1, 0777) == -1)
248 atf_tc_fail_errno("mkdir 1");
249
250 md(pb2, mp, "dir2");
251 if (rump_sys_mkdir(pb2, 0777) == -1)
252 atf_tc_fail_errno("mkdir 2");
253 md(pb2, mp, "dir2/subdir");
254 if (rump_sys_mkdir(pb2, 0777) == -1)
255 atf_tc_fail_errno("mkdir 3");
256
257 md(pb3, mp, "dir1/file");
258 if (rump_sys_mknod(pb3, S_IFREG | 0777, -1) == -1)
259 atf_tc_fail_errno("create file");
260 if (rump_sys_stat(pb3, &ref) == -1)
261 atf_tc_fail_errno("stat of file");
262
263 /*
264 * First try ops which should succeed.
265 */
266
267 /* rename within directory */
268 md(pb3, mp, "dir3");
269 if (rump_sys_rename(pb1, pb3) == -1)
270 atf_tc_fail_errno("rename 1");
271 checkfile(pb3, &ref);
272
273 /* rename directory onto itself (two ways, should fail) */
274 md(pb1, mp, "dir3/.");
275 if (rump_sys_rename(pb1, pb3) != -1 || errno != EINVAL)
276 atf_tc_fail_errno("rename 2");
277 if (rump_sys_rename(pb3, pb1) != -1 || errno != EISDIR)
278 atf_tc_fail_errno("rename 3");
279
280 checkfile(pb3, &ref);
281
282 /* rename father of directory into directory */
283 md(pb1, mp, "dir2/dir");
284 md(pb2, mp, "dir2");
285 if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL)
286 atf_tc_fail_errno("rename 4");
287
288 /* same for grandfather */
289 md(pb1, mp, "dir2/subdir/dir2");
290 if (rump_sys_rename(pb2, pb1) != -1 || errno != EINVAL)
291 atf_tc_fail("rename 5");
292
293 checkfile(pb3, &ref);
294
295 /* rename directory over a non-empty directory */
296 if (rump_sys_rename(pb2, pb3) != -1 || errno != ENOTEMPTY)
297 atf_tc_fail("rename 6");
298
299 /* cross-directory rename */
300 md(pb1, mp, "dir3");
301 md(pb2, mp, "dir2/somedir");
302 if (rump_sys_rename(pb1, pb2) == -1)
303 atf_tc_fail_errno("rename 7");
304 checkfile(pb2, &ref);
305
306 /* move to parent directory */
307 md(pb1, mp, "dir2/somedir/../../dir3");
308 if (rump_sys_rename(pb2, pb1) == -1)
309 atf_tc_fail_errno("rename 8");
310 md(pb1, mp, "dir2/../dir3");
311 checkfile(pb1, &ref);
312
313 /* atomic cross-directory rename */
314 md(pb3, mp, "dir2/subdir");
315 if (rump_sys_rename(pb1, pb3) == -1)
316 atf_tc_fail_errno("rename 9");
317 checkfile(pb3, &ref);
318
319 /* rename directory over an empty directory */
320 md(pb1, mp, "parent");
321 md(pb2, mp, "parent/dir1");
322 md(pb3, mp, "parent/dir2");
323 RL(rump_sys_mkdir(pb1, 0777));
324 RL(rump_sys_mkdir(pb2, 0777));
325 RL(rump_sys_mkdir(pb3, 0777));
326 RL(rump_sys_rename(pb2, pb3));
327
328 RL(rump_sys_stat(pb1, &sb));
329 if (! FSTYPE_MSDOS(tc))
330 ATF_CHECK_EQ(sb.st_nlink, 3);
331 RL(rump_sys_rmdir(pb3));
332 RL(rump_sys_rmdir(pb1));
333 }
334
335 static void
336 rename_dotdot(const atf_tc_t *tc, const char *mp)
337 {
338
339 if (FSTYPE_RUMPFS(tc))
340 atf_tc_skip("rename not supported by file system");
341
342 USES_DIRS;
343
344 if (rump_sys_chdir(mp) == -1)
345 atf_tc_fail_errno("chdir mountpoint");
346
347 if (rump_sys_mkdir("dir1", 0777) == -1)
348 atf_tc_fail_errno("mkdir 1");
349 if (rump_sys_mkdir("dir2", 0777) == -1)
350 atf_tc_fail_errno("mkdir 2");
351
352 if (rump_sys_rename("dir1", "dir1/..") != -1 || errno != EINVAL)
353 atf_tc_fail_errno("self-dotdot to");
354
355 if (rump_sys_rename("dir1/..", "sometarget") != -1 || errno != EINVAL)
356 atf_tc_fail_errno("self-dotdot from");
357
358 if (rump_sys_rename("dir1", "dir2/..") != -1 || errno != EINVAL)
359 atf_tc_fail("other-dotdot");
360
361 rump_sys_chdir("/");
362 }
363
364 static void
365 rename_reg_nodir(const atf_tc_t *tc, const char *mp)
366 {
367 bool haslinks;
368 struct stat sb;
369 ino_t f1ino;
370
371 if (FSTYPE_RUMPFS(tc))
372 atf_tc_skip("rename not supported by file system");
373
374 if (rump_sys_chdir(mp) == -1)
375 atf_tc_fail_errno("chdir mountpoint");
376
377 if (FSTYPE_MSDOS(tc) || FSTYPE_SYSVBFS(tc))
378 haslinks = false;
379 else
380 haslinks = true;
381
382 if (rump_sys_mknod("file1", S_IFREG | 0777, -1) == -1)
383 atf_tc_fail_errno("create file");
384 if (rump_sys_mknod("file2", S_IFREG | 0777, -1) == -1)
385 atf_tc_fail_errno("create file");
386
387 if (rump_sys_stat("file1", &sb) == -1)
388 atf_tc_fail_errno("stat");
389 f1ino = sb.st_ino;
390
391 if (haslinks) {
392 if (rump_sys_link("file1", "file_link") == -1)
393 atf_tc_fail_errno("link");
394 if (rump_sys_stat("file_link", &sb) == -1)
395 atf_tc_fail_errno("stat");
396 ATF_REQUIRE_EQ(sb.st_ino, f1ino);
397 ATF_REQUIRE_EQ(sb.st_nlink, 2);
398 }
399
400 if (rump_sys_stat("file2", &sb) == -1)
401 atf_tc_fail_errno("stat");
402
403 if (rump_sys_rename("file1", "file3") == -1)
404 atf_tc_fail_errno("rename 1");
405 if (rump_sys_stat("file3", &sb) == -1)
406 atf_tc_fail_errno("stat 1");
407 if (haslinks) {
408 ATF_REQUIRE_EQ(sb.st_ino, f1ino);
409 }
410 if (rump_sys_stat("file1", &sb) != -1 || errno != ENOENT)
411 atf_tc_fail_errno("source 1");
412
413 if (rump_sys_rename("file3", "file2") == -1)
414 atf_tc_fail_errno("rename 2");
415 if (rump_sys_stat("file2", &sb) == -1)
416 atf_tc_fail_errno("stat 2");
417 if (haslinks) {
418 ATF_REQUIRE_EQ(sb.st_ino, f1ino);
419 }
420
421 if (rump_sys_stat("file3", &sb) != -1 || errno != ENOENT)
422 atf_tc_fail_errno("source 2");
423
424 if (haslinks) {
425 if (rump_sys_rename("file2", "file_link") == -1)
426 atf_tc_fail_errno("rename hardlink");
427 if (rump_sys_stat("file2", &sb) != -1 || errno != ENOENT)
428 atf_tc_fail_errno("source 3");
429 if (rump_sys_stat("file_link", &sb) == -1)
430 atf_tc_fail_errno("stat 2");
431 ATF_REQUIRE_EQ(sb.st_ino, f1ino);
432 ATF_REQUIRE_EQ(sb.st_nlink, 1);
433 }
434
435 ATF_CHECK_ERRNO(EFAULT, rump_sys_rename("file2", NULL) == -1);
436 ATF_CHECK_ERRNO(EFAULT, rump_sys_rename(NULL, "file2") == -1);
437
438 rump_sys_chdir("/");
439 }
440
441 static void
442 create_nametoolong(const atf_tc_t *tc, const char *mp)
443 {
444 char *name;
445 int fd;
446 long val;
447 size_t len;
448
449 if (rump_sys_chdir(mp) == -1)
450 atf_tc_fail_errno("chdir mountpoint");
451
452 val = rump_sys_pathconf(".", _PC_NAME_MAX);
453 if (val == -1)
454 atf_tc_fail_errno("pathconf");
455
456 len = val + 1;
457 name = malloc(len+1);
458 if (name == NULL)
459 atf_tc_fail_errno("malloc");
460
461 memset(name, 'a', len);
462 *(name+len) = '\0';
463
464 val = rump_sys_pathconf(".", _PC_NO_TRUNC);
465 if (val == -1)
466 atf_tc_fail_errno("pathconf");
467
468 fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666);
469 if (val != 0 && (fd != -1 || errno != ENAMETOOLONG))
470 atf_tc_fail_errno("open");
471
472 if (val == 0 && rump_sys_close(fd) == -1)
473 atf_tc_fail_errno("close");
474 if (val == 0 && rump_sys_unlink(name) == -1)
475 atf_tc_fail_errno("unlink");
476
477 free(name);
478
479 rump_sys_chdir("/");
480 }
481
482 static void
483 create_exist(const atf_tc_t *tc, const char *mp)
484 {
485 const char *name = "hoge";
486 int fd;
487
488 RL(rump_sys_chdir(mp));
489 RL(fd = rump_sys_open(name, O_RDWR|O_CREAT|O_EXCL, 0666));
490 RL(rump_sys_close(fd));
491 RL(rump_sys_unlink(name));
492 RL(fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666));
493 RL(rump_sys_close(fd));
494 RL(fd = rump_sys_open(name, O_RDWR|O_CREAT, 0666));
495 RL(rump_sys_close(fd));
496 ATF_REQUIRE_ERRNO(EEXIST,
497 (fd = rump_sys_open(name, O_RDWR|O_CREAT|O_EXCL, 0666)));
498 RL(rump_sys_unlink(name));
499 RL(rump_sys_chdir("/"));
500 }
501
502 static void
503 rename_nametoolong(const atf_tc_t *tc, const char *mp)
504 {
505 char *name;
506 int res, fd;
507 long val;
508 size_t len;
509
510 if (FSTYPE_RUMPFS(tc))
511 atf_tc_skip("rename not supported by file system");
512
513 if (rump_sys_chdir(mp) == -1)
514 atf_tc_fail_errno("chdir mountpoint");
515
516 val = rump_sys_pathconf(".", _PC_NAME_MAX);
517 if (val == -1)
518 atf_tc_fail_errno("pathconf");
519
520 len = val + 1;
521 name = malloc(len+1);
522 if (name == NULL)
523 atf_tc_fail_errno("malloc");
524
525 memset(name, 'a', len);
526 *(name+len) = '\0';
527
528 fd = rump_sys_open("dummy", O_RDWR|O_CREAT, 0666);
529 if (fd == -1)
530 atf_tc_fail_errno("open");
531 if (rump_sys_close(fd) == -1)
532 atf_tc_fail_errno("close");
533
534 val = rump_sys_pathconf(".", _PC_NO_TRUNC);
535 if (val == -1)
536 atf_tc_fail_errno("pathconf");
537
538 res = rump_sys_rename("dummy", name);
539 if (val != 0 && (res != -1 || errno != ENAMETOOLONG))
540 atf_tc_fail_errno("rename");
541
542 if (val == 0 && rump_sys_unlink(name) == -1)
543 atf_tc_fail_errno("unlink");
544
545 free(name);
546
547 rump_sys_chdir("/");
548 }
549
550 /*
551 * Test creating a symlink whose length is "len" bytes, not including
552 * the terminating NUL.
553 */
554 static void
555 symlink_len(const atf_tc_t *tc, const char *mp, size_t len)
556 {
557 char *buf;
558 int r;
559
560 USES_SYMLINKS;
561
562 RL(rump_sys_chdir(mp));
563
564 buf = malloc(len + 1);
565 ATF_REQUIRE(buf);
566 memset(buf, 'a', len);
567 buf[len] = '\0';
568 r = rump_sys_symlink(buf, "afile");
569 if (r == -1) {
570 ATF_REQUIRE_ERRNO(ENAMETOOLONG, r);
571 } else {
572 RL(rump_sys_unlink("afile"));
573 }
574 free(buf);
575
576 RL(rump_sys_chdir("/"));
577 }
578
579 static void
580 symlink_zerolen(const atf_tc_t *tc, const char *mp)
581 {
582 symlink_len(tc, mp, 0);
583 }
584
585 static void
586 symlink_long(const atf_tc_t *tc, const char *mp)
587 {
588 /*
589 * Test lengths close to powers of two, as those are likely
590 * to be edge cases.
591 */
592 size_t len;
593 int fuzz;
594 for (len = 2; len <= 65536; len *= 2) {
595 for (fuzz = -1; fuzz <= 1; fuzz++) {
596 symlink_len(tc, mp, len + fuzz);
597 }
598 }
599 }
600
601 static void
602 symlink_root(const atf_tc_t *tc, const char *mp)
603 {
604
605 USES_SYMLINKS;
606
607 RL(rump_sys_chdir(mp));
608 RL(rump_sys_symlink("/", "foo"));
609 RL(rump_sys_chdir("foo"));
610 }
611
612 static void
613 attrs(const atf_tc_t *tc, const char *mp)
614 {
615 struct stat sb, sb2;
616 struct timeval tv[2];
617 int fd;
618
619 FSTEST_ENTER();
620 RL(fd = rump_sys_open(TESTFILE, O_RDWR | O_CREAT, 0755));
621 RL(rump_sys_close(fd));
622 RL(rump_sys_stat(TESTFILE, &sb));
623 if (!(FSTYPE_MSDOS(tc) || FSTYPE_SYSVBFS(tc))) {
624 RL(rump_sys_chown(TESTFILE, 1, 2));
625 sb.st_uid = 1;
626 sb.st_gid = 2;
627 RL(rump_sys_chmod(TESTFILE, 0123));
628 sb.st_mode = (sb.st_mode & ~ACCESSPERMS) | 0123;
629 }
630
631 tv[0].tv_sec = 1000000000; /* need something >1980 for msdosfs */
632 tv[0].tv_usec = 1;
633 tv[1].tv_sec = 1000000002; /* need even seconds for msdosfs */
634 tv[1].tv_usec = 3;
635 RL(rump_sys_utimes(TESTFILE, tv));
636 RL(rump_sys_utimes(TESTFILE, tv)); /* XXX: utimes & birthtime */
637 sb.st_atimespec.tv_sec = 1000000000;
638 sb.st_atimespec.tv_nsec = 1000;
639 sb.st_mtimespec.tv_sec = 1000000002;
640 sb.st_mtimespec.tv_nsec = 3000;
641
642 RL(rump_sys_stat(TESTFILE, &sb2));
643 #define CHECK(a) ATF_REQUIRE_EQ(sb.a, sb2.a)
644 if (!(FSTYPE_MSDOS(tc) || FSTYPE_SYSVBFS(tc))) {
645 CHECK(st_uid);
646 CHECK(st_gid);
647 CHECK(st_mode);
648 }
649 if (!FSTYPE_MSDOS(tc)) {
650 /* msdosfs has only access date, not time */
651 CHECK(st_atimespec.tv_sec);
652 }
653 CHECK(st_mtimespec.tv_sec);
654 if (!(FSTYPE_EXT2FS(tc) || FSTYPE_MSDOS(tc) ||
655 FSTYPE_SYSVBFS(tc) || FSTYPE_V7FS(tc))) {
656 CHECK(st_atimespec.tv_nsec);
657 CHECK(st_mtimespec.tv_nsec);
658 }
659 #undef CHECK
660
661 FSTEST_EXIT();
662 }
663
664 static void
665 fcntl_lock(const atf_tc_t *tc, const char *mp)
666 {
667 int fd, fd2;
668 struct flock l;
669 struct lwp *lwp1, *lwp2;
670
671 FSTEST_ENTER();
672 l.l_pid = 0;
673 l.l_start = l.l_len = 1024;
674 l.l_type = F_RDLCK | F_WRLCK;
675 l.l_whence = SEEK_END;
676
677 lwp1 = rump_pub_lwproc_curlwp();
678 RL(fd = rump_sys_open(TESTFILE, O_RDWR | O_CREAT, 0755));
679 RL(rump_sys_ftruncate(fd, 8192));
680
681 RL(rump_sys_fcntl(fd, F_SETLK, &l));
682
683 /* Next, we fork and try to lock the same area */
684 RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
685 lwp2 = rump_pub_lwproc_curlwp();
686 RL(fd2 = rump_sys_open(TESTFILE, O_RDWR, 0));
687 ATF_REQUIRE_ERRNO(EAGAIN, rump_sys_fcntl(fd2, F_SETLK, &l));
688
689 /* Switch back and unlock... */
690 rump_pub_lwproc_switch(lwp1);
691 l.l_type = F_UNLCK;
692 RL(rump_sys_fcntl(fd, F_SETLK, &l));
693
694 /* ... and try to lock again */
695 rump_pub_lwproc_switch(lwp2);
696 l.l_type = F_RDLCK | F_WRLCK;
697 RL(rump_sys_fcntl(fd2, F_SETLK, &l));
698
699 RL(rump_sys_close(fd2));
700 rump_pub_lwproc_releaselwp();
701
702 RL(rump_sys_close(fd));
703
704 FSTEST_EXIT();
705 }
706
707 static int
708 flock_compare(const void *p, const void *q)
709 {
710 int a = ((const struct flock *)p)->l_start;
711 int b = ((const struct flock *)q)->l_start;
712 return a < b ? -1 : (a > b ? 1 : 0);
713 }
714
715 /*
716 * Find all locks set by fcntl_getlock_pids test
717 * using GETLK for a range [start, start+end], and,
718 * if there is a blocking lock, recursively find
719 * all locks to the left (toward the beginning of
720 * a file) and to the right of the lock.
721 * The function also understands "until end of file"
722 * convention when len==0.
723 */
724 static unsigned int
725 fcntl_getlocks(int fildes, off_t start, off_t len,
726 struct flock *lock, struct flock *end)
727 {
728 unsigned int rv = 0;
729 const struct flock l = { start, len, 0, F_RDLCK, SEEK_SET };
730
731 if (lock == end)
732 return rv;
733
734 RL(rump_sys_fcntl(fildes, F_GETLK, &l));
735
736 if (l.l_type == F_UNLCK)
737 return rv;
738
739 *lock++ = l;
740 rv += 1;
741
742 ATF_REQUIRE(l.l_whence == SEEK_SET);
743
744 if (l.l_start > start) {
745 unsigned int n =
746 fcntl_getlocks(fildes, start, l.l_start - start, lock, end);
747 rv += n;
748 lock += n;
749 if (lock == end)
750 return rv;
751 }
752
753 if (l.l_len == 0) /* does l spans until the end? */
754 return rv;
755
756 if (len == 0) /* are we looking for locks until the end? */ {
757 rv += fcntl_getlocks(fildes, l.l_start + l.l_len, len, lock, end);
758 } else if (l.l_start + l.l_len < start + len) {
759 len -= l.l_start + l.l_len - start;
760 rv += fcntl_getlocks(fildes, l.l_start + l.l_len, len, lock, end);
761 }
762
763 return rv;
764 }
765
766 static void
767 fcntl_getlock_pids(const atf_tc_t *tc, const char *mp)
768 {
769 /* test non-overlaping ranges */
770 struct flock expect[4];
771 const struct flock lock[4] = {
772 { 0, 2, 0, F_WRLCK, SEEK_SET },
773 { 2, 1, 0, F_WRLCK, SEEK_SET },
774 { 7, 5, 0, F_WRLCK, SEEK_SET },
775 { 4, 3, 0, F_WRLCK, SEEK_SET },
776 };
777
778 /* Add extra element to make sure recursion does't stop at array end */
779 struct flock result[5];
780
781 /* Add 5th process */
782 int fd[5];
783 pid_t pid[5];
784 struct lwp *lwp[5];
785
786 unsigned int i, j;
787 const off_t sz = 8192;
788 int omode = 0755;
789 int oflags = O_RDWR | O_CREAT;
790
791 memcpy(expect, lock, sizeof(lock));
792
793 FSTEST_ENTER();
794
795 /*
796 * First, we create 4 processes and let each lock a range of the
797 * file. Note that the third and fourth processes lock in
798 * "reverse" order, i.e. the greater pid locks a range before
799 * the lesser pid.
800 * Then, we create 5th process which doesn't lock anything.
801 */
802 for (i = 0; i < __arraycount(lwp); i++) {
803 RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG));
804
805 lwp[i] = rump_pub_lwproc_curlwp();
806 pid[i] = rump_sys_getpid();
807
808 RL(fd[i] = rump_sys_open(TESTFILE, oflags, omode));
809 oflags = O_RDWR;
810 omode = 0;
811
812 RL(rump_sys_ftruncate(fd[i], sz));
813
814 if (i < __arraycount(lock)) {
815 RL(rump_sys_fcntl(fd[i], F_SETLK, &lock[i]));
816 expect[i].l_pid = pid[i];
817 }
818 }
819
820 qsort(expect, __arraycount(expect), sizeof(expect[0]), &flock_compare);
821
822 /*
823 * In the context of each process, recursively find all locks
824 * that would block the current process. Processes 1-4 don't
825 * see their own lock, we insert it to simplify checks.
826 * Process 5 sees all 4 locks.
827 */
828 for (i = 0; i < __arraycount(lwp); i++) {
829 unsigned int nlocks;
830
831 rump_pub_lwproc_switch(lwp[i]);
832
833 memset(result, 0, sizeof(result));
834 nlocks = fcntl_getlocks(fd[i], 0, sz,
835 result, result + __arraycount(result));
836
837 if (i < __arraycount(lock)) {
838 ATF_REQUIRE(nlocks < __arraycount(result));
839 result[nlocks] = lock[i];
840 result[nlocks].l_pid = pid[i];
841 nlocks++;
842 }
843
844 ATF_CHECK_EQ(nlocks, __arraycount(expect));
845
846 qsort(result, nlocks, sizeof(result[0]), &flock_compare);
847
848 for (j = 0; j < nlocks; j++) {
849 ATF_CHECK_EQ(result[j].l_start, expect[j].l_start );
850 ATF_CHECK_EQ(result[j].l_len, expect[j].l_len );
851 ATF_CHECK_EQ(result[j].l_pid, expect[j].l_pid );
852 ATF_CHECK_EQ(result[j].l_type, expect[j].l_type );
853 ATF_CHECK_EQ(result[j].l_whence, expect[j].l_whence);
854 }
855 }
856
857 /*
858 * Release processes. This also releases the fds and locks
859 * making fs unmount possible
860 */
861 for (i = 0; i < __arraycount(lwp); i++) {
862 rump_pub_lwproc_switch(lwp[i]);
863 rump_pub_lwproc_releaselwp();
864 }
865
866 FSTEST_EXIT();
867 }
868
869 static void
870 access_simple(const atf_tc_t *tc, const char *mp)
871 {
872 int fd;
873 int tmode;
874
875 FSTEST_ENTER();
876 RL(fd = rump_sys_open("tfile", O_CREAT | O_RDWR, 0777));
877 RL(rump_sys_close(fd));
878
879 #define ALLACC (F_OK | X_OK | W_OK | R_OK)
880 if (FSTYPE_SYSVBFS(tc) || FSTYPE_MSDOS(tc))
881 tmode = F_OK;
882 else
883 tmode = ALLACC;
884
885 RL(rump_sys_access("tfile", tmode));
886
887 /* PR kern/44648 */
888 ATF_REQUIRE_ERRNO(EINVAL, rump_sys_access("tfile", ALLACC+1) == -1);
889 #undef ALLACC
890 FSTEST_EXIT();
891 }
892
893 static void
894 read_directory(const atf_tc_t *tc, const char *mp)
895 {
896 char buf[1024];
897 int fd, res;
898 ssize_t size;
899
900 FSTEST_ENTER();
901 fd = rump_sys_open(".", O_DIRECTORY | O_RDONLY, 0777);
902 ATF_REQUIRE(fd != -1);
903
904 size = rump_sys_pread(fd, buf, sizeof(buf), 0);
905 ATF_CHECK(size != -1 || errno == EISDIR);
906 size = rump_sys_read(fd, buf, sizeof(buf));
907 ATF_CHECK(size != -1 || errno == EISDIR);
908
909 res = rump_sys_close(fd);
910 ATF_REQUIRE(res != -1);
911 FSTEST_EXIT();
912 }
913
914 static void
915 lstat_symlink(const atf_tc_t *tc, const char *mp)
916 {
917 const char *src, *dst;
918 int res;
919 struct stat st;
920
921 USES_SYMLINKS;
922
923 FSTEST_ENTER();
924
925 src = "source";
926 dst = "destination";
927
928 res = rump_sys_symlink(src, dst);
929 ATF_REQUIRE(res != -1);
930 res = rump_sys_lstat(dst, &st);
931 ATF_REQUIRE(res != -1);
932
933 ATF_CHECK(S_ISLNK(st.st_mode) != 0);
934 ATF_CHECK(st.st_size == (off_t)strlen(src));
935
936 FSTEST_EXIT();
937 }
938
939 ATF_TC_FSAPPLY(lookup_simple, "simple lookup (./.. on root)");
940 ATF_TC_FSAPPLY(lookup_complex, "lookup of non-dot entries");
941 ATF_TC_FSAPPLY(dir_simple, "mkdir/rmdir");
942 ATF_TC_FSAPPLY(dir_notempty, "non-empty directories cannot be removed");
943 ATF_TC_FSAPPLY(dir_rmdirdotdot, "remove .. and try to cd out (PR kern/44657)");
944 ATF_TC_FSAPPLY(rename_dir, "exercise various directory renaming ops "
945 "(PR kern/44288)");
946 ATF_TC_FSAPPLY(rename_dotdot, "rename dir .. (PR kern/43617)");
947 ATF_TC_FSAPPLY(rename_reg_nodir, "rename regular files, no subdirectories");
948 ATF_TC_FSAPPLY(create_nametoolong, "create file with name too long");
949 ATF_TC_FSAPPLY(create_exist, "create with O_EXCL");
950 ATF_TC_FSAPPLY(rename_nametoolong, "rename to file with name too long");
951 ATF_TC_FSAPPLY(symlink_zerolen, "symlink with target of length 0");
952 ATF_TC_FSAPPLY(symlink_long, "symlink with target of length > 0");
953 ATF_TC_FSAPPLY(symlink_root, "symlink to root directory");
954 ATF_TC_FSAPPLY(attrs, "check setting attributes works");
955 ATF_TC_FSAPPLY(fcntl_lock, "check fcntl F_SETLK");
956 ATF_TC_FSAPPLY(fcntl_getlock_pids,"fcntl F_GETLK w/ many procs, PR kern/44494");
957 ATF_TC_FSAPPLY(access_simple, "access(2)");
958 ATF_TC_FSAPPLY(read_directory, "read(2) on directories");
959 ATF_TC_FSAPPLY(lstat_symlink, "lstat(2) values for symbolic links");
960
961 ATF_TP_ADD_TCS(tp)
962 {
963
964 ATF_TP_FSAPPLY(lookup_simple);
965 ATF_TP_FSAPPLY(lookup_complex);
966 ATF_TP_FSAPPLY(dir_simple);
967 ATF_TP_FSAPPLY(dir_notempty);
968 ATF_TP_FSAPPLY(dir_rmdirdotdot);
969 ATF_TP_FSAPPLY(rename_dir);
970 ATF_TP_FSAPPLY(rename_dotdot);
971 ATF_TP_FSAPPLY(rename_reg_nodir);
972 ATF_TP_FSAPPLY(create_nametoolong);
973 ATF_TP_FSAPPLY(create_exist);
974 ATF_TP_FSAPPLY(rename_nametoolong);
975 ATF_TP_FSAPPLY(symlink_zerolen);
976 ATF_TP_FSAPPLY(symlink_long);
977 ATF_TP_FSAPPLY(symlink_root);
978 ATF_TP_FSAPPLY(attrs);
979 ATF_TP_FSAPPLY(fcntl_lock);
980 ATF_TP_FSAPPLY(fcntl_getlock_pids);
981 ATF_TP_FSAPPLY(access_simple);
982 ATF_TP_FSAPPLY(read_directory);
983 ATF_TP_FSAPPLY(lstat_symlink);
984
985 return atf_no_error();
986 }
MINIX 3 (repo.or.cz mirror)