ATF_TC_BODY(blockwait, tc) { sem_t semmarit[3]; pthread_t pt; int i; rump_init(); sem_init(&semmarit[0], 1, 0); sem_init(&semmarit[1], 1, 0); sem_init(&semmarit[2], 1, 0); pthread_create(&pt, NULL, hthread, semmarit); /* * Make a best-effort. Unless we're extremely unlucky, we should * at least one blocking wait. */ for (i = 0; i < 10; i++) { sem_wait(&semmarit[2]); usleep(1); sem_post(&semmarit[0]); sem_post(&semmarit[1]); } pthread_cancel(pt); pthread_join(pt, NULL); }
ATF_TC_BODY(range_blk, tc) { char buf[32000]; char cmpbuf[32000]; ssize_t n; int rv, tfd; /* create a 64000 byte file with 16 1's at offset = 32000 */ rv = system("dd if=/dev/zero of=disk.img bs=1000 count=64"); ATF_REQUIRE_EQ(rv, 0); rv = system("yes | tr '\\ny' '\\1' " "| dd of=disk.img conv=notrunc bs=1 count=16 seek=32000"); ATF_REQUIRE_EQ(rv, 0); /* map the file at [16000,48000]. this puts our 1's at offset 16000 */ rump_init(); ATF_REQUIRE_EQ(rump_pub_etfs_register_withsize(TESTPATH1, "disk.img", RUMP_ETFS_BLK, 16000, 32000), 0); tfd = rump_sys_open(TESTPATH1, O_RDWR); ATF_REQUIRE(tfd != -1); n = rump_sys_read(tfd, buf, sizeof(buf)); ATF_REQUIRE_EQ(n, sizeof(buf)); ATF_REQUIRE_EQ(rump_sys_close(tfd), 0); ATF_REQUIRE_EQ(rump_pub_etfs_remove(TESTPATH1), 0); /* check that we got what is expected */ memset(cmpbuf, 0, sizeof(cmpbuf)); memset(cmpbuf+16000, 1, 16); ATF_REQUIRE_EQ(memcmp(buf, cmpbuf, sizeof(buf)), 0); }
ATF_TC_BODY(multilayer, tc) { struct union_args unionargs; rump_init(); if (rump_sys_mkdir("/Tunion", 0777) == -1) atf_tc_fail_errno("mkdir mp1"); if (rump_sys_mkdir("/Tunion2", 0777) == -1) atf_tc_fail_errno("mkdir mp2"); if (rump_sys_mkdir("/Tunion2/A", 0777) == -1) atf_tc_fail_errno("mkdir A"); if (rump_sys_mkdir("/Tunion2/B", 0777) == -1) atf_tc_fail_errno("mkdir B"); unionargs.target = __UNCONST("/Tunion2/A"); unionargs.mntflags = UNMNT_BELOW; if (rump_sys_mount(MOUNT_UNION, "/Tunion", 0, &unionargs, sizeof(unionargs)) == -1) atf_tc_fail_errno("union mount"); unionargs.target = __UNCONST("/Tunion2/B"); unionargs.mntflags = UNMNT_BELOW; rump_sys_mount(MOUNT_UNION, "/Tunion", 0,&unionargs,sizeof(unionargs)); }
int main() { struct sockaddr_in client; struct sockaddr_in server; char msg[500]; char buf[65535]; socklen_t clen; ssize_t nn; ssize_t off; int size = 1024 * 1024; int s; rump_init(); rump_pub_lwproc_rfork(0); if (rump_pub_netconfig_ifcreate(IFNAME) != 0) errx(1, "failed to create " IFNAME); if (rump_pub_netconfig_ipv4_ifaddr(IFNAME, IF_ADDR, "255.255.255.0") != 0) errx(1, "failed to create " IFNAME); //rump_pub_netconfig_dhcp_ipv4_oneshot(IFNAME); s = rump_sys_socket(PF_INET, SOCK_DGRAM, 0); if (s == -1) err(1,"socket"); memset(&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(ECHOSERVER_RX_PORT); server.sin_addr.s_addr = inet_addr(IF_ADDR); rump_sys_setsockopt(s, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); if (rump_sys_bind(s, (struct sockaddr *)&server, sizeof(server)) == -1) err(1, "binded"); printf("socket binded\r\n"); printf("Waiting connection on port = %d\r\n",ECHOSERVER_RX_PORT); memset(&client, 0, sizeof(client)); while(1) { memset(msg,0,sizeof(msg)); clen = sizeof(client); nn = rump_sys_recvfrom(s,msg,sizeof(msg),0,(struct sockaddr *)&client,&clen); if (nn<0) { perror("Error receiving data"); } else { rump_sys_sendto(s,buf,nn,0,(struct sockaddr *)&client,clen); } } }
ATF_TC_BODY(proccreds, tc) { struct lwp *l1, *l2; rump_init(); RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG)); l1 = rump_pub_lwproc_curlwp(); RZ(rump_pub_lwproc_newlwp(rump_sys_getpid())); RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG)); l2 = rump_pub_lwproc_curlwp(); RL(rump_sys_setuid(22)); ATF_REQUIRE_EQ(rump_sys_getuid(), 22); rump_pub_lwproc_switch(l1); ATF_REQUIRE_EQ(rump_sys_getuid(), 0); /* from parent, proc0 */ RL(rump_sys_setuid(11)); ATF_REQUIRE_EQ(rump_sys_getuid(), 11); rump_pub_lwproc_switch(l2); ATF_REQUIRE_EQ(rump_sys_getuid(), 22); rump_pub_lwproc_newlwp(rump_sys_getpid()); ATF_REQUIRE_EQ(rump_sys_getuid(), 22); }
ATF_TC_BODY(OOSIOCGIFBRDADDR, tc) { int fd, ifnum; struct oifreq ifreq; struct sockaddr_in *sin; int rv; memset(&ifreq,'\0',sizeof ifreq); rump_init(); /* create an interface and give it netmask 0xffff0000 */ rv = rump_pub_shmif_create("bus", &ifnum); if (rv) atf_tc_fail("failed to create shmif: %s", strerror(rv)); sprintf(ifreq.ifr_name, "shmif%d", ifnum); netcfg_rump_if(ifreq.ifr_name, "1.7.64.10", "255.255.0.0"); /* query kernel for iface bcast */ RL(fd = rump_sys_socket(AF_INET, SOCK_DGRAM, 0)); RL(rump_sys_ioctl(fd, OOSIOCGIFBRDADDR, &ifreq)); /* make sure we got what we deserve */ sin = (struct sockaddr_in *)&ifreq.ifr_broadaddr; ATF_REQUIRE_EQ(sin->sin_addr.s_addr, htonl(0x0107ffff)); rump_sys_close(fd); }
int main(int argc, char *argv[]) { int fd; int err; prop_dictionary_t dict_in, dict_out; struct plistref prefp; char *xml; err = rump_init(); if (err != 0) printf("rump_init failed with %s\n", strerror(err)); fd = rump_sys_open("/dev/mapper/control", O_RDWR, 0); if (fd == -1) printf("Cannot open control device.\n"); dict_in = prop_dictionary_internalize_from_file("prop2.plist"); dict_out = prop_dictionary_create(); prop_dictionary_externalize_to_pref(dict_in, &prefp); err = rump_sys_ioctl(fd, NETBSD_DM_IOCTL, &prefp); if ( err < 0) printf("ioctl failed %d\n", err); dict_out = prop_dictionary_internalize(prefp.pref_plist); xml = prop_dictionary_externalize(dict_out); printf("%s\n",xml); rump_sys_close(fd); }
ATF_TC_BODY(lwps, tc) { struct lwp *l[LOOPS]; pid_t mypid; struct lwp *l_orig; int i; rump_init(); RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG)); mypid = rump_sys_getpid(); RL(rump_sys_setuid(375)); l_orig = rump_pub_lwproc_curlwp(); for (i = 0; i < LOOPS; i++) { mypid = rump_sys_getpid(); ATF_REQUIRE(mypid != -1 && mypid != 0); RZ(rump_pub_lwproc_newlwp(mypid)); l[i] = rump_pub_lwproc_curlwp(); ATF_REQUIRE_EQ(rump_sys_getuid(), 375); } rump_pub_lwproc_switch(l_orig); rump_pub_lwproc_releaselwp(); for (i = 0; i < LOOPS; i++) { rump_pub_lwproc_switch(l[i]); ATF_REQUIRE_EQ(rump_sys_getpid(), mypid); ATF_REQUIRE_EQ(rump_sys_getuid(), 375); rump_pub_lwproc_releaselwp(); ATF_REQUIRE_EQ(rump_sys_getpid(), 1); ATF_REQUIRE_EQ(rump_sys_getuid(), 0); } ATF_REQUIRE_EQ(rump_pub_lwproc_newlwp(mypid), ESRCH); }
void _netbsd_init(void) { thestrings.ps_argvstr = (void *)((char *)&myaux - 2); __ps_strings = &thestrings; pthread__stacksize = 2*STACK_SIZE; rump_boot_setsigmodel(RUMP_SIGMODEL_IGNORE); rump_init(); environ = the_env; _lwp_rumpxen_scheduler_init(); runinit(); _libc_init(); /* XXX: we should probably use csu, but this is quicker for now */ __progname = "rumpxenstack"; #ifdef RUMP_SYSPROXY rump_init_server("tcp://0:12345"); #endif /* * give all threads a chance to run, and ensure that the main * thread has gone through a context switch */ sched_yield(); }
ATF_TC_BODY(makecn, tc) { struct componentname *cn; char pathstr[MAXPATHLEN] = TESTFILE; struct vnode *vp; extern struct vnode *rumpns_rootvnode; rump_init(); /* * Strategy is to create a componentname, edit the passed * string, and then do a lookup with the componentname. */ RL(rump_sys_mkdir("/" TESTFILE, 0777)); /* need stable lwp for componentname */ RZ(rump_pub_lwproc_rfork(RUMP_RFCFDG)); /* try it once with the right path */ cn = rump_pub_makecn(RUMP_NAMEI_LOOKUP, 0, pathstr, strlen(pathstr), rump_pub_cred_create(0, 0, 0, NULL), rump_pub_lwproc_curlwp()); RZ(RUMP_VOP_LOOKUP(rumpns_rootvnode, &vp, cn)); rump_pub_freecn(cn, RUMPCN_FREECRED); /* and then with modification-in-the-middle */ cn = rump_pub_makecn(RUMP_NAMEI_LOOKUP, 0, pathstr, strlen(pathstr), rump_pub_cred_create(0, 0, 0, NULL), rump_pub_lwproc_curlwp()); strcpy(pathstr, "/muuta"); RZ(RUMP_VOP_LOOKUP(rumpns_rootvnode, &vp, cn)); rump_pub_freecn(cn, RUMPCN_FREECRED); }
ATF_TC_BODY(devnull2, tc) { struct union_args unionargs; int fd, res; rump_init(); if (rump_sys_mkdir("/mp", 0777) == -1) atf_tc_fail_errno("mkdir mp"); unionargs.target = __UNCONST("/dev"); unionargs.mntflags = UNMNT_BELOW; if (rump_sys_mount(MOUNT_UNION, "/mp", 0, &unionargs, sizeof(unionargs)) == -1) atf_tc_fail_errno("union mount"); fd = rump_sys_open("/mp/null", O_WRONLY | O_CREAT | O_APPEND); if (fd == -1) atf_tc_fail_errno("open"); res = rump_sys_write(fd, &fd, sizeof(fd)); if (res != sizeof(fd)) atf_tc_fail("write"); }
int rump_syspuffs_glueinit(int fd, int *newfd) { struct ptargs *pap; int rv; if ((rv = rump_init()) != 0) return rv; putterattach(); rv = puttercdopen(makedev(178, 0), 0, 0, curlwp); if (rv && rv != EMOVEFD) return rv; pap = kmem_alloc(sizeof(struct ptargs), KM_SLEEP); pap->comfd = fd; pap->fpfd = curlwp->l_dupfd; pap->fdp = curlwp->l_proc->p_fd; rv = kthread_create(PRI_NONE, 0, NULL, readthread, pap, NULL, "rputter"); if (rv) return rv; rv = kthread_create(PRI_NONE, 0, NULL, writethread, pap, NULL, "wputter"); if (rv) return rv; *newfd = curlwp->l_dupfd; return 0; }
void mainthread(void *cmdline) { int rv, fd; rv = rump_init(); bmk_printf("rump kernel init complete, rv %d\n", rv); writestr(1, "Hello, stdout!\n"); bmk_printf("open(/notexisting): "); fd = rump_sys_open("/notexisting", 0); if (fd == -1) { int errno = *bmk_sched_geterrno(); if (errno == RUMP_ENOENT) { bmk_printf("No such file or directory. All is well.\n"); } else { bmk_printf("Something went wrong. errno = %d\n", errno); } } else { bmk_printf("Success?! fd=%d\n", fd); } rump_sys_reboot(0, NULL); }
ATF_TC_BODY(key, tc) { RZ(rump_init()); RL(open("hostfile", O_RDWR | O_CREAT, 0777)); RZ(rump_pub_etfs_register("/key", "hostfile", RUMP_ETFS_REG)); ATF_REQUIRE_EQ(rump_pub_etfs_register("key", "hostfile", RUMP_ETFS_REG), EINVAL); RL(rump_sys_open("/key", O_RDONLY)); RL(rump_sys_open("////////key", O_RDONLY)); RZ(rump_pub_etfs_register("////key//with/slashes", "hostfile", RUMP_ETFS_REG)); RL(rump_sys_open("/key//with/slashes", O_RDONLY)); RL(rump_sys_open("key//with/slashes", O_RDONLY)); ATF_REQUIRE_ERRNO(ENOENT, rump_sys_open("/key/with/slashes", O_RDONLY) == -1); RL(rump_sys_mkdir("/a", 0777)); ATF_REQUIRE_ERRNO(ENOENT, rump_sys_open("/a/key//with/slashes", O_RDONLY) == -1); }
/* Open control device if doesn't exist create it. */ static int _open_control(void) { char control[PATH_MAX]; uint32_t major = 0, minor = 0; if (_control_fd != -1) return 1; #ifdef RUMP_ACTION rump_init(); #endif snprintf(control, sizeof(control), "%s/control", dm_dir()); if (!_control_device_number(&major, &minor)) log_error("Is device-mapper driver missing from kernel?"); if (!_control_exists(control, major, minor) && !_create_control(control, major, minor)) goto error; if ((_control_fd = open(control, O_RDWR)) < 0) { log_sys_error("open", control); goto error; } return 1; error: log_error("Failure to communicate with kernel device-mapper driver."); return 0; }
static void child(bool master) { char ifname[IFNAMSIZ]; struct carpreq cr; struct ifreq ifr; const char *carpif; int s; /* helps reading carp debug output */ if (master) carpif = "carp0"; else carpif = "carp1"; /* * Should use sysctl, bug debug is dabug. */ { //extern int rumpns_carp_opts[]; /* XXX */ //rumpns_carp_opts[CARPCTL_LOG] = 1; } rump_init(); memset(&ifr, 0, sizeof(ifr)); strlcpy(ifr.ifr_name, carpif, sizeof(ifr.ifr_name)); RL(s = rump_sys_socket(PF_INET, SOCK_DGRAM, 0)); RL(rump_sys_ioctl(s, SIOCIFCREATE, &ifr)); netcfg_rump_makeshmif(THEBUS, ifname); if (master) netcfg_rump_if(ifname, "10.1.1.1", "255.255.255.0"); else netcfg_rump_if(ifname, "10.1.1.2", "255.255.255.0"); /* configure the carp interface */ ifr.ifr_data = &cr; RL(rump_sys_ioctl(s, SIOCGVH, &ifr)); strlcpy(cr.carpr_carpdev, ifname, sizeof(cr.carpr_carpdev)); cr.carpr_vhid = 175; if (master) cr.carpr_advskew = 0; else cr.carpr_advskew = 200; cr.carpr_advbase = 1; strcpy((char *)cr.carpr_key, "s3cret"); RL(rump_sys_ioctl(s, SIOCSVH, &ifr)); netcfg_rump_if(carpif, "10.1.1.100", "255.255.255.0"); /* tassa pause()en enka muuta voi */ pause(); }
int main() { struct sockaddr_in sin; char buf[65535]; struct hostent *hp; ssize_t nn; ssize_t off; int s, e; hp = gethostbyname(DESTHOST); if (!hp || hp->h_addrtype != AF_INET) errx(1, "failed to resolve \"%s\"", DESTHOST); rump_init(); #ifndef USE_SOCKIN if ((e = rump_pub_netconfig_ifcreate("virt0")) != 0) die(e, "create virt0"); if ((e = rump_pub_netconfig_dhcp_ipv4_oneshot("virt0")) != 0) die(e, "dhcp address"); #endif s = rump_sys_socket(PF_INET, SOCK_STREAM, 0); if (s == -1) die(errno, "socket"); memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; #if 0 sin.sin_len = sizeof(sin); #endif sin.sin_port = htons(80); memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr)); if (rump_sys_connect(s, (struct sockaddr *)&sin, sizeof(sin)) == -1) die(errno, "connect"); printf("connected\n"); #define WANTHTML "GET / HTTP/1.1\nHost: www.netbsd.org\n\n" nn = rump_sys_write(s, WANTHTML, sizeof(WANTHTML)-1); printf("write rv %zd\n", nn); for (;;) { nn = rump_sys_read(s, buf, sizeof(buf)-1); if (nn == -1) die(errno, "read failed"); if (nn == 0) break; buf[nn] = '\0'; printf("%s", buf); } rump_sys_close(s); die(0, NULL); }
int main() { int rv; rv = rump_init(); printf("rump init returned: %d (%s)\n", rv, rv == 0 ? "success" : strerror(rv)); }
ATF_TC_BODY(bpfjit_extmem_side_effect, tc) { static struct bpf_insn insns[] = { BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 0), /* A <- P[0] */ BPF_STMT(BPF_LDX+BPF_W+BPF_IMM, 2), /* X <- 2 */ BPF_STMT(BPF_ST, 1), /* M[1] <- A */ BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0), /* A <- A + X */ BPF_STMT(BPF_STX, 2), /* M[2] <- X */ BPF_STMT(BPF_ST, 3), /* M[3] <- A */ BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 99), /* A <- P[99] */ BPF_STMT(BPF_RET+BPF_A, 0) /* ret A */ }; bpfjit_func_t code; uint8_t pkt[1] = { 1 }; uint32_t mem[ctx.extwords]; /* Pre-inited words. */ mem[0] = 0; mem[3] = 7; mem[1] = mem[2] = 0xdeadbeef; bpf_args_t args = { .pkt = pkt, .buflen = sizeof(pkt), .wirelen = sizeof(pkt), .mem = mem, }; size_t insn_count = sizeof(insns) / sizeof(insns[0]); RZ(rump_init()); rump_schedule(); code = rumpns_bpfjit_generate_code(&ctx, insns, insn_count); rump_unschedule(); ATF_REQUIRE(code != NULL); ATF_CHECK(code(&ctx, &args) == 0); rump_schedule(); rumpns_bpfjit_free_code(code); rump_unschedule(); ATF_CHECK(mem[0] == 0); ATF_CHECK(mem[1] == 1); ATF_CHECK(mem[2] == 2); ATF_CHECK(mem[3] == 3); } ATF_TC(bpfjit_extmem_invalid_store); ATF_TC_HEAD(bpfjit_extmem_invalid_store, tc) { atf_tc_set_md_var(tc, "descr", "Test that out-of-range store " "fails validation"); }
/* main */ int main (int argc, char *argv[]) { error_t err; mach_port_t bootstrap; struct trivfs_control *fsys; err = argp_parse(&argp, argc, argv, 0, NULL, NULL); if (err) { error(1, err, "argp_parse"); } task_get_bootstrap_port(mach_task_self(), &bootstrap); if (bootstrap == MACH_PORT_NULL) { error(1, 0, "must be started as translator"); } /* reply to our parent */ err = trivfs_startup(bootstrap, 0, NULL, NULL, NULL, NULL, &fsys); if (err) { error(3, err, "trivfs_startup"); } /* launch translator */ init_logging(); info("start oss translator"); info("init rump"); rump_init(); debug("open rump audio device"); audio_fd = rump_sys_open(RUMP_AUDIO_DEVICE, O_WRONLY); if (audio_fd < 0) { err("rump_open(%s, O_WRONLY): %s", RUMP_AUDIO_DEVICE, rump_strerror(errno)); return EIO; } /* set default parameters */ audio_info_t info; AUDIO_INITINFO(&info); info.play.sample_rate = 44100; info.play.channels = 1; info.play.precision = 16; info.play.encoding = AUDIO_ENCODING_LINEAR; info.play.samples = 0; if (rump_sys_ioctl(audio_fd, AUDIO_SETINFO, &info)) { err("rump_sys_ioctl AUDIO_SETINFO: %s", rump_strerror(errno)); return EIO; } /* wait for orders */ info("wait for orders"); ports_manage_port_operations_one_thread(fsys->pi.bucket, oss_demuxer, 0); return 0; }
ATF_TC_BODY(kthread, tc) { rump_init(); rump_schedule(); rumptest_threadjoin(); /* panics if fails */ rump_unschedule(); }
ATF_TC_BODY(nullrevoke, tc) { char path[MAXPATHLEN]; struct ptmget ptg; int ptm; rump_init(); /* * mount /dev/pts */ mountptyfs("/dev/pts", 0); /* * null mount /dev/pts to /null/dev/pts */ if (rump_sys_mkdir("/null", 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create /null"); } if (rump_sys_mkdir("/null/dev", 0777) == -1) { if (errno != EEXIST) atf_tc_fail_errno("null create /null/dev"); } mountnull("/dev/pts", "/null/dev/pts", 0); /* * get slave/master pair. */ ptm = rump_sys_open("/dev/ptm", O_RDWR); if (rump_sys_ioctl(ptm, TIOCPTMGET, &ptg) == -1) atf_tc_fail_errno("get pty"); /* * Build nullfs path to slave. */ strcpy(path, "/null"); strcat(path, ptg.sn); /* * Open slave tty via nullfs. */ if (rump_sys_open(path, O_RDWR) == -1) atf_tc_fail_errno("slave null open"); /* * Close slave opened with /dev/ptm. Need purely non-null refs to it. */ rump_sys_close(ptg.sfd); /* revoke slave tty. */ rump_sys_revoke(path); /* done */ }
ATF_TC_BODY(sigignore, tc) { rump_boot_setsigmodel(RUMP_SIGMODEL_IGNORE); rump_init(); rump_schedule(); rumptest_localsig(SIGKILL); rump_unschedule(); }
void rumprun_init() { int ret; ret = rump_init(); if (ret != 0) die("rump init failed"); _netbsd_init(isatty(STDOUT_FILENO)); }
int main() { int rv; setenv("RUMP_VERBOSE", "1", 1); rv = rump_init(); printf("rump kernel init complete, rv %d\n", rv); return rv; }
ATF_TC_BODY(nullswitch, tc) { struct lwp *l; rump_init(); RZ(rump_pub_lwproc_newlwp(0)); l = rump_pub_lwproc_curlwp(); rump_pub_lwproc_switch(NULL); /* if remains LP_RUNNING, next call will panic */ rump_pub_lwproc_switch(l); }
void bmk_mainthread(void *cmdline) { int rv; rump_boot_setsigmodel(RUMP_SIGMODEL_IGNORE); rv = rump_init(); bmk_printf("rump kernel init complete, rv %d\n", rv); while(1); }
/* * Prepare rump, configure interface and route to cause fragmentation */ static void setup(void) { char ifname[IFNAMSIZ]; struct { struct rt_msghdr m_rtm; struct sockaddr_in m_sin; } m_rtmsg; #define rtm m_rtmsg.m_rtm #define rsin m_rtmsg.m_sin struct ifreq ifr; int s; rump_init(); /* first, config lo0 & route */ strcpy(ifname, "lo0"); netcfg_rump_if(ifname, "127.0.0.1", "255.0.0.0"); netcfg_rump_route("127.0.0.1", "255.0.0.0", "127.0.0.1"); if ((s = rump_sys_socket(PF_ROUTE, SOCK_RAW, 0)) == -1) atf_tc_fail_errno("routing socket"); /* * set MTU for interface so that route MTU doesn't * get overridden by it. */ memset(&ifr, 0, sizeof(ifr)); strcpy(ifr.ifr_name, "lo0"); ifr.ifr_mtu = 1300; if (rump_sys_ioctl(s, SIOCSIFMTU, &ifr) == -1) atf_tc_fail_errno("set mtu"); /* change route MTU to 100 */ memset(&m_rtmsg, 0, sizeof(m_rtmsg)); rtm.rtm_type = RTM_CHANGE; rtm.rtm_flags = RTF_STATIC; rtm.rtm_version = RTM_VERSION; rtm.rtm_seq = 3; rtm.rtm_inits = RTV_MTU; rtm.rtm_addrs = RTA_DST; rtm.rtm_rmx.rmx_mtu = 100; rtm.rtm_msglen = sizeof(m_rtmsg); memset(&rsin, 0, sizeof(rsin)); rsin.sin_family = AF_INET; rsin.sin_len = sizeof(rsin); rsin.sin_addr.s_addr = inet_addr("127.0.0.1"); if (rump_sys_write(s, &m_rtmsg, sizeof(m_rtmsg)) != sizeof(m_rtmsg)) atf_tc_fail_errno("set route mtu"); rump_sys_close(s); }
ATF_TC_BODY(sigraise, tc) { signal(SIGUSR2, thehand); rump_boot_setsigmodel(RUMP_SIGMODEL_RAISE); rump_init(); rump_schedule(); rumptest_localsig(SIGUSR2); rump_unschedule(); ATF_REQUIRE_EQ(sigcnt, 1); }
ATF_TC_BODY(initvalue, tc) { sem_t sem; rump_init(); sem_init(&sem, 1, 4); ATF_REQUIRE_EQ(sem_trywait(&sem), 0); ATF_REQUIRE_EQ(sem_trywait(&sem), 0); ATF_REQUIRE_EQ(sem_trywait(&sem), 0); ATF_REQUIRE_EQ(sem_trywait(&sem), 0); ATF_REQUIRE_EQ(sem_trywait(&sem), -1); }