Home | History | Annotate | Line # | Download | only in puffs 
      1 /*	$NetBSD: t_basic.c,v 1.14 2017/01/13 21:30:40 christos Exp $	*/
      2 
      3 #include <sys/types.h>
      4 #include <sys/mount.h>
      5 #include <sys/socket.h>
      6 
      7 #include <assert.h>
      8 #include <atf-c.h>
      9 #include <err.h>
     10 #include <errno.h>
     11 #include <fcntl.h>
     12 #include <pthread.h>
     13 #include <puffs.h>
     14 #include <puffsdump.h>
     15 #include <stdio.h>
     16 #include <unistd.h>
     17 #include <string.h>
     18 #include <stdlib.h>
     19 
     20 #include <rump/rump.h>
     21 #include <rump/rump_syscalls.h>
     22 
     23 #include "h_macros.h"
     24 #include "../common/h_fsmacros.h"
     25 
     26 /*
     27  * Do a synchronous operation.  When this returns, all FAF operations
     28  * have at least been delivered to the file system.
     29  *
     30  * XXX: is this really good enough considering puffs(9)-issued
     31  * callback operations?
     32  */
     33 static void
     34 syncbar(const char *fs)
     35 {
     36 	struct statvfs svb;
     37 
     38 	if (rump_sys_statvfs1(fs, &svb, ST_WAIT) == -1)
     39 		atf_tc_fail_errno("statvfs");
     40 }
     41 
     42 #ifdef PUFFSDUMP
     43 static void __unused
     44 dumpopcount(struct puffstestargs *args)
     45 {
     46 	size_t i;
     47 
     48 	printf("VFS OPS:\n");
     49 	for (i = 0; i < MIN(puffsdump_vfsop_count, PUFFS_VFS_MAX); i++) {
     50 		printf("\t%s: %d\n",
     51 		    puffsdump_vfsop_revmap[i], args->pta_vfs_toserv_ops[i]);
     52 	}
     53 
     54 	printf("VN OPS:\n");
     55 	for (i = 0; i < MIN(puffsdump_vnop_count, PUFFS_VN_MAX); i++) {
     56 		printf("\t%s: %d\n",
     57 		    puffsdump_vnop_revmap[i], args->pta_vn_toserv_ops[i]);
     58 	}
     59 }
     60 #endif
     61 
     62 ATF_TC(mount);
     63 ATF_TC_HEAD(mount, tc)
     64 {
     65 
     66 	atf_tc_set_md_var(tc, "descr", "puffs+dtfs un/mount test");
     67 }
     68 
     69 ATF_TC_BODY(mount, tc)
     70 {
     71 	void *args;
     72 
     73 	FSTEST_CONSTRUCTOR(tc, puffs, args);
     74 	FSTEST_DESTRUCTOR(tc, puffs, args);
     75 }
     76 
     77 ATF_TC(root_reg);
     78 ATF_TC_HEAD(root_reg, tc)
     79 {
     80 	atf_tc_set_md_var(tc, "descr", "root is a regular file");
     81 }
     82 
     83 #define MAKEOPTS(...) \
     84     char *theopts[] = {NULL, "-s", __VA_ARGS__, "dtfs", "n/a", NULL}
     85 
     86 ATF_TC_BODY(root_reg, tc)
     87 {
     88 	MAKEOPTS("-r", "reg");
     89 	void *args;
     90 	int fd, rv;
     91 
     92 	FSTEST_CONSTRUCTOR_FSPRIV(tc, puffs, args, theopts);
     93 
     94 	fd = rump_sys_open(FSTEST_MNTNAME, O_RDWR);
     95 	if (fd == -1)
     96 		atf_tc_fail_errno("open root");
     97 	if (rump_sys_write(fd, &fd, sizeof(fd)) != sizeof(fd))
     98 		atf_tc_fail_errno("write to root");
     99 	rv = rump_sys_mkdir(FSTEST_MNTNAME "/test", 0777);
    100 	ATF_REQUIRE(errno == ENOTDIR);
    101 	ATF_REQUIRE(rv == -1);
    102 	rump_sys_close(fd);
    103 
    104 	FSTEST_DESTRUCTOR(tc, puffs, args);
    105 }
    106 
    107 ATF_TC(root_lnk);
    108 ATF_TC_HEAD(root_lnk, tc)
    109 {
    110 
    111 	atf_tc_set_md_var(tc, "descr", "root is a symbolic link");
    112 }
    113 
    114 #define LINKSTR "/path/to/nowhere"
    115 ATF_TC_BODY(root_lnk, tc)
    116 {
    117 	MAKEOPTS("-r", "lnk " LINKSTR);
    118 	void *args;
    119 	char buf[PATH_MAX];
    120 	ssize_t len;
    121 
    122 	FSTEST_CONSTRUCTOR_FSPRIV(tc, puffs, args, theopts);
    123 
    124 	if ((len = rump_sys_readlink(FSTEST_MNTNAME, buf, sizeof(buf)-1)) == -1)
    125 		atf_tc_fail_errno("readlink");
    126 	buf[len] = '\0';
    127 
    128 	ATF_REQUIRE_STREQ(buf, LINKSTR);
    129 
    130 #if 0 /* XXX: unmount uses FOLLOW */
    131 	if (rump_sys_unmount("/mp", 0) == -1)
    132 		atf_tc_fail_errno("unmount");
    133 #endif
    134 }
    135 
    136 ATF_TC(root_fifo);
    137 ATF_TC_HEAD(root_fifo, tc)
    138 {
    139 
    140 	atf_tc_set_md_var(tc, "descr", "root is a symbolic link");
    141 }
    142 
    143 #define MAGICSTR "nakit ja muusiperunat maustevoilla"
    144 static void *
    145 dofifow(void *arg)
    146 {
    147 	int fd = (int)(uintptr_t)arg;
    148 	char buf[512];
    149 
    150 	printf("writing\n");
    151 	strcpy(buf, MAGICSTR);
    152 	if (rump_sys_write(fd, buf, strlen(buf)+1) != strlen(buf)+1)
    153 		atf_tc_fail_errno("write to fifo");
    154 
    155 	return NULL;
    156 }
    157 
    158 ATF_TC_BODY(root_fifo, tc)
    159 {
    160 	MAKEOPTS("-r", "fifo");
    161 	void *args;
    162 	pthread_t pt;
    163 	char buf[512];
    164 	int fd;
    165 
    166 	FSTEST_CONSTRUCTOR_FSPRIV(tc, puffs, args, theopts);
    167 
    168 	fd = rump_sys_open(FSTEST_MNTNAME, O_RDWR);
    169 	if (fd == -1)
    170 		atf_tc_fail_errno("open fifo");
    171 
    172 	pthread_create(&pt, NULL, dofifow, (void *)(uintptr_t)fd);
    173 
    174 	memset(buf, 0, sizeof(buf));
    175 	if (rump_sys_read(fd, buf, sizeof(buf)) == -1)
    176 		atf_tc_fail_errno("read fifo");
    177 
    178 	ATF_REQUIRE_STREQ(buf, MAGICSTR);
    179 	rump_sys_close(fd);
    180 
    181 	FSTEST_DESTRUCTOR(tc, puffs, args);
    182 }
    183 
    184 ATF_TC(root_chrdev);
    185 ATF_TC_HEAD(root_chrdev, tc)
    186 {
    187 
    188 	atf_tc_set_md_var(tc, "descr", "root is /dev/null");
    189 }
    190 
    191 ATF_TC_BODY(root_chrdev, tc)
    192 {
    193 	MAKEOPTS("-r", "chr 2 2");
    194 	void *args;
    195 	ssize_t rv;
    196 	char buf[512];
    197 	int fd;
    198 
    199 	FSTEST_CONSTRUCTOR_FSPRIV(tc, puffs, args, theopts);
    200 
    201 	fd = rump_sys_open(FSTEST_MNTNAME, O_RDWR);
    202 	if (fd == -1)
    203 		atf_tc_fail_errno("open null");
    204 
    205 	rv = rump_sys_write(fd, buf, sizeof(buf));
    206 	ATF_REQUIRE(rv == sizeof(buf));
    207 
    208 	rv = rump_sys_read(fd, buf, sizeof(buf));
    209 	ATF_REQUIRE(rv == 0);
    210 
    211 	rump_sys_close(fd);
    212 
    213 	FSTEST_DESTRUCTOR(tc, puffs, args);
    214 }
    215 
    216 /*
    217  * Inactive/reclaim tests
    218  */
    219 
    220 ATF_TC(inactive_basic);
    221 ATF_TC_HEAD(inactive_basic, tc)
    222 {
    223 
    224 	atf_tc_set_md_var(tc, "descr", "inactive gets called");
    225 }
    226 
    227 ATF_TC_BODY(inactive_basic, tc)
    228 {
    229 	struct puffstestargs *pargs;
    230 	void *args;
    231 	int fd;
    232 
    233 	FSTEST_CONSTRUCTOR(tc, puffs, args);
    234 	FSTEST_ENTER();
    235 	pargs = args;
    236 
    237 	fd = rump_sys_open("file", O_CREAT | O_RDWR, 0777);
    238 	if (fd == -1)
    239 		atf_tc_fail_errno("create");
    240 
    241 	/* none yet */
    242 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE], 0);
    243 
    244 	rump_sys_close(fd);
    245 
    246 	/* one for file */
    247 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE], 1);
    248 
    249 	FSTEST_EXIT();
    250 
    251 	/* another for the mountpoint */
    252 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE], 2);
    253 
    254 	FSTEST_DESTRUCTOR(tc, puffs, args);
    255 }
    256 
    257 ATF_TC(inactive_reclaim);
    258 ATF_TC_HEAD(inactive_reclaim, tc)
    259 {
    260 
    261 	atf_tc_set_md_var(tc, "descr", "inactive/reclaim gets called");
    262 }
    263 
    264 ATF_TC_BODY(inactive_reclaim, tc)
    265 {
    266 	struct puffstestargs *pargs;
    267 	void *args;
    268 	int fd;
    269 
    270 	FSTEST_CONSTRUCTOR(tc, puffs, args);
    271 	FSTEST_ENTER();
    272 	pargs = args;
    273 
    274 	fd = rump_sys_open("file", O_CREAT | O_RDWR, 0777);
    275 	if (fd == -1)
    276 		atf_tc_fail_errno("create");
    277 
    278 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE], 0);
    279 
    280 	if (rump_sys_unlink("file") == -1)
    281 		atf_tc_fail_errno("remove");
    282 
    283 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE], 0);
    284 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 0);
    285 
    286 	rump_sys_close(fd);
    287 	syncbar(FSTEST_MNTNAME);
    288 
    289 	ATF_REQUIRE(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE] > 0);
    290 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 1);
    291 
    292 	FSTEST_EXIT();
    293 	FSTEST_DESTRUCTOR(tc, puffs, args);
    294 }
    295 
    296 ATF_TC(reclaim_hardlink);
    297 ATF_TC_HEAD(reclaim_hardlink, tc)
    298 {
    299 
    300 	atf_tc_set_md_var(tc, "descr", "reclaim gets called only after "
    301 	    "final link is gone");
    302 }
    303 
    304 ATF_TC_BODY(reclaim_hardlink, tc)
    305 {
    306 	struct puffstestargs *pargs;
    307 	void *args;
    308 	int fd;
    309 	int ianow;
    310 
    311 	FSTEST_CONSTRUCTOR(tc, puffs, args);
    312 	FSTEST_ENTER();
    313 	pargs = args;
    314 
    315 	fd = rump_sys_open("file", O_CREAT | O_RDWR, 0777);
    316 	if (fd == -1)
    317 		atf_tc_fail_errno("create");
    318 
    319 	if (rump_sys_link("file", "anotherfile") == -1)
    320 		atf_tc_fail_errno("create link");
    321 	rump_sys_close(fd);
    322 
    323 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 0);
    324 
    325 	/* unlink first hardlink */
    326 	if (rump_sys_unlink("file") == -1)
    327 		atf_tc_fail_errno("unlink 1");
    328 
    329 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 0);
    330 	ianow = pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE];
    331 
    332 	/* unlink second hardlink */
    333 	if (rump_sys_unlink("anotherfile") == -1)
    334 		atf_tc_fail_errno("unlink 2");
    335 
    336 	syncbar(FSTEST_MNTNAME);
    337 
    338 	ATF_REQUIRE(ianow < pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE]);
    339 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 1);
    340 
    341 	FSTEST_EXIT();
    342 	FSTEST_DESTRUCTOR(tc, puffs, args);
    343 }
    344 
    345 ATF_TC(unlink_accessible);
    346 ATF_TC_HEAD(unlink_accessible, tc)
    347 {
    348 
    349 	atf_tc_set_md_var(tc, "descr", "open file is accessible after "
    350 	    "having been unlinked");
    351 }
    352 
    353 ATF_TC_BODY(unlink_accessible, tc)
    354 {
    355 	MAKEOPTS("-i", "-o", "nopagecache");
    356 	struct puffstestargs *pargs;
    357 	void *args;
    358 	char buf[512];
    359 	int fd, ianow;
    360 
    361 	assert(sizeof(buf) > sizeof(MAGICSTR));
    362 
    363 	FSTEST_CONSTRUCTOR_FSPRIV(tc, puffs, args, theopts);
    364 	FSTEST_ENTER();
    365 	pargs = args;
    366 
    367 	fd = rump_sys_open("file", O_CREAT | O_RDWR, 0777);
    368 	if (fd == -1)
    369 		atf_tc_fail_errno("create");
    370 
    371 	if (rump_sys_write(fd, MAGICSTR, sizeof(MAGICSTR)) != sizeof(MAGICSTR))
    372 		atf_tc_fail_errno("write");
    373 	if (rump_sys_unlink("file") == -1)
    374 		atf_tc_fail_errno("unlink");
    375 
    376 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 0);
    377 	ianow = pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE];
    378 
    379 	if (rump_sys_pread(fd, buf, sizeof(buf), 0) == -1)
    380 		atf_tc_fail_errno("read");
    381 	rump_sys_close(fd);
    382 
    383 	syncbar(FSTEST_MNTNAME);
    384 
    385 	ATF_REQUIRE_EQ(pargs->pta_vn_toserv_ops[PUFFS_VN_RECLAIM], 1);
    386 	ATF_REQUIRE(pargs->pta_vn_toserv_ops[PUFFS_VN_INACTIVE] > ianow);
    387 
    388 	ATF_REQUIRE_STREQ(buf, MAGICSTR);
    389 
    390 	FSTEST_EXIT();
    391 	FSTEST_DESTRUCTOR(tc, puffs, args);
    392 }
    393 
    394 ATF_TC(signals);
    395 ATF_TC_HEAD(signals, tc)
    396 {
    397 
    398 	atf_tc_set_md_var(tc, "descr", "Checks that sending a signal can "
    399 	    "cause an interrupt to puffs wait");
    400 }
    401 
    402 extern struct proc *rumpns_initproc;
    403 extern void rumpns_psignal(struct proc *, int);
    404 extern void rumpns_sigclearall(struct proc *, void *, void *);
    405 ATF_TC_BODY(signals, tc)
    406 {
    407 	struct stat sb;
    408 	void *args;
    409 
    410 	rump_boot_setsigmodel(RUMP_SIGMODEL_RECORD);
    411 
    412 	FSTEST_CONSTRUCTOR(tc, puffs, args);
    413 	FSTEST_ENTER();
    414 	RL(rump_sys_stat(".", &sb));
    415 
    416 	/* send SIGUSR1, should not affect puffs ops */
    417 	rump_schedule();
    418 	rumpns_psignal(rumpns_initproc, SIGUSR1);
    419 	rump_unschedule();
    420 	RL(rump_sys_stat(".", &sb));
    421 
    422 	/* send SIGTERM, should get EINTR */
    423 	rump_schedule();
    424 	rumpns_psignal(rumpns_initproc, SIGTERM);
    425 	rump_unschedule();
    426 	ATF_REQUIRE_ERRNO(EINTR, rump_sys_stat(".", &sb) == -1);
    427 
    428 	/* clear sigmask so that we can unmount */
    429 	rump_schedule();
    430 	rumpns_sigclearall(rumpns_initproc, NULL, NULL);
    431 	rump_unschedule();
    432 
    433 	FSTEST_EXIT();
    434 	FSTEST_DESTRUCTOR(tc, puffs, args);
    435 }
    436 
    437 ATF_TP_ADD_TCS(tp)
    438 {
    439 
    440 	ATF_TP_ADD_TC(tp, mount);
    441 
    442 	ATF_TP_ADD_TC(tp, root_fifo);
    443 	ATF_TP_ADD_TC(tp, root_lnk);
    444 	ATF_TP_ADD_TC(tp, root_reg);
    445 	ATF_TP_ADD_TC(tp, root_chrdev);
    446 
    447 	ATF_TP_ADD_TC(tp, inactive_basic);
    448 	ATF_TP_ADD_TC(tp, inactive_reclaim);
    449 	ATF_TP_ADD_TC(tp, reclaim_hardlink);
    450 	ATF_TP_ADD_TC(tp, unlink_accessible);
    451 
    452 	ATF_TP_ADD_TC(tp, signals);
    453 
    454 	return atf_no_error();
    455 }
    456