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(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(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); }
/* 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(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(bpfwriteleak, tc) { char buf[28]; /* sizeof(garbage) > etherhdrlen */ struct ifreq ifr; int ifnum, bpfd; RZ(rump_init()); RZ(rump_pub_shmif_create(NULL, &ifnum)); sprintf(ifr.ifr_name, "shmif%d", ifnum); RL(bpfd = rump_sys_open("/dev/bpf", O_RDWR)); RL(rump_sys_ioctl(bpfd, BIOCSETIF, &ifr)); RL(rump_sys_ioctl(bpfd, BIOCSFEEDBACK, &ifr)); if (getmtdata() != 0) atf_tc_fail("test precondition failed: MT_DATA mbufs != 0"); ATF_REQUIRE_ERRNO(ENETDOWN, rump_sys_write(bpfd, buf, sizeof(buf))==-1); ATF_REQUIRE_EQ(getmtdata(), 0); }
/* * 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(RNDADDDATA2, tc) { rnddata_t rd; int fd; rump_init(); fd = rump_sys_open("/dev/random", O_RDWR, 0); if (fd == -1) atf_tc_fail_errno("cannot open /dev/random"); rd.entropy = 1; rd.len = -1; ATF_REQUIRE_ERRNO(EINVAL, rump_sys_ioctl(fd, RNDADDDATA, &rd) == -1); }
int main(int argc, char *argv[]) { pthread_t pt; struct md_conf md; int fd, error; if (argc != 2) exit(1); md.md_addr = calloc(1, MDSIZE); md.md_size = MDSIZE; md.md_type = MD_UMEM_SERVER; error = rump_daemonize_begin(); REQUIRE(error, "rump_daemonize_begin"); error = rump_init(); REQUIRE(error, "rump_init"); error = rump_init_server("unix://commsock"); REQUIRE(error, "init server"); if ((fd = rump_sys_open(argv[1], O_RDWR)) == -1) err(1, "open"); /* * Now, configuring the md driver also causes our process * to start acting as the worker for the md. Splitting it * into two steps in the driver is not easy, since md is * supposed to be unconfigured when the process dies * (process may exit between calling ioctl1 and ioctl2). * So, start a probe thread which attempts to read the md * and declares the md as configured when the read is * succesful. */ error = pthread_create(&pt, NULL, prober, argv[1]); REQUIRE(error, "pthread_create"); pthread_detach(pt); if (rump_sys_ioctl(fd, MD_SETCONF, &md) == -1) { rump_daemonize_done(errno); exit(1); } return 0; }
/* ioctls */ kern_return_t S_oioctl_sndctl_dsp_speed (trivfs_protid_t reqport, int *rate) { audio_info_t info; AUDIO_INITINFO(&info); info.play.sample_rate = *rate; 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; } *rate = info.play.sample_rate; return 0; }
ATF_TC_BODY(noisyeject, tc) { static char fname[] = "/dev/rcd0_"; int part, fd, arg = 0; RL(part = getrawpartition()); fname[strlen(fname)-1] = 'a' + part; rump_init(); /* * Rump CD emulation has been fixed, so no longer a problem. * atf_tc_expect_signal(SIGSEGV, "PR kern/47646: Broken test or " "a real problem in rump or the driver"); */ RL(fd = rump_sys_open(fname, O_RDWR)); RL(rump_sys_ioctl(fd, DIOCEJECT, &arg)); ATF_REQUIRE_EQ(rump_scsitest_err[RUMP_SCSITEST_NOISYSYNC], 0); RL(rump_sys_close(fd)); // atf_tc_expect_fail("PR kern/43785"); ATF_REQUIRE_EQ(rump_scsitest_err[RUMP_SCSITEST_NOISYSYNC], 0); }
ATF_TC_BODY(bpfwritetrunc, tc) { int bpfd; struct ifreq ifr; struct iovec *iov; size_t iovlen, sz; const size_t extra_bytes = 28; const size_t total = extra_bytes + UINT_MAX + 1; long iov_max, vm_page_size; /* round_page wants vm_page_size variable */ memset(&ifr, 0, sizeof(ifr)); iov_max = sysconf(_SC_IOV_MAX); vm_page_size = sysconf(_SC_PAGE_SIZE); ATF_REQUIRE(iov_max > 1 && vm_page_size > 1); /* * Minimize memory consumption by using many iovecs * all pointing to one memory region. */ iov = calloc(iov_max, sizeof(struct iovec)); ATF_REQUIRE(iov != NULL); sz = round_page((total + (iov_max - 1)) / iov_max); iov[0].iov_len = sz; iov[0].iov_base = mmap(NULL, sz, PROT_READ, MAP_ANON, -1, 0); ATF_REQUIRE(iov[0].iov_base != MAP_FAILED); iovlen = 1; while (sz + iov[0].iov_len <= total) { iov[iovlen].iov_len = iov[0].iov_len; iov[iovlen].iov_base = iov[0].iov_base; sz += iov[0].iov_len; iovlen++; } if (sz < total) { iov[iovlen].iov_len = total - sz; iov[iovlen].iov_base = iov[0].iov_base; iovlen++; } /* Sanity checks */ ATF_REQUIRE(iovlen >= 1 && iovlen <= (size_t)iov_max); ATF_REQUIRE_EQ(iov[iovlen-1].iov_len, total % iov[0].iov_len); RZ(rump_init()); netcfg_rump_makeshmif("bpfwritetrunc", ifr.ifr_name); netcfg_rump_if(ifr.ifr_name, "10.1.1.1", "255.0.0.0"); RL(bpfd = rump_sys_open("/dev/bpf", O_RDWR)); RL(rump_sys_ioctl(bpfd, BIOCSETIF, &ifr)); ATF_CHECK_ERRNO(EMSGSIZE, rump_sys_writev(bpfd, iov, iovlen) == -1); munmap(iov[0].iov_base, iov[0].iov_len); free(iov); }
/* * This function is heart of NetBSD libdevmapper-> device-mapper kernel protocol * It creates proplib_dictionary from dm task structure and sends it to NetBSD * kernel driver. After succesfull ioctl it create dmi structure from returned * proplib dictionary. This way I keep number of changes in NetBSD version of * libdevmapper as small as posible. */ static struct dm_ioctl *_do_dm_ioctl(struct dm_task *dmt, unsigned command) { struct dm_ioctl *dmi; prop_dictionary_t dm_dict_in, dm_dict_out; uint32_t flags; dm_dict_in = NULL; dm_dict_in = prop_dictionary_create(); /* Dictionary send to kernel */ dm_dict_out = prop_dictionary_create(); /* Dictionary received from kernel */ /* Set command name to dictionary */ prop_dictionary_set_cstring(dm_dict_in, DM_IOCTL_COMMAND, _cmd_data_v4[dmt->type].name); /* Parse dmi from libdevmapper to dictionary */ if (_flatten(dmt, dm_dict_in) < 0) goto bad; prop_dictionary_get_uint32(dm_dict_in, DM_IOCTL_FLAGS, &flags); if (dmt->type == DM_DEVICE_TABLE) flags |= DM_STATUS_TABLE_FLAG; if (dmt->no_open_count) flags |= DM_SKIP_BDGET_FLAG; flags |= DM_EXISTS_FLAG; /* Set flags to dictionary. */ prop_dictionary_set_uint32(dm_dict_in,DM_IOCTL_FLAGS,flags); prop_dictionary_externalize_to_file(dm_dict_in,"/tmp/test_in"); log_very_verbose("Ioctl type %s --- flags %d",_cmd_data_v4[dmt->type].name,flags); //printf("name %s, major %d minor %d\n uuid %s\n", //dm_task_get_name(dmt), dmt->minor, dmt->major, dm_task_get_uuid(dmt)); /* Send dictionary to kernel and wait for reply. */ #ifdef RUMP_ACTION struct plistref prefp; int err; prop_dictionary_externalize_to_pref(dm_dict_in, &prefp); if (rump_sys_ioctl(_control_fd, NETBSD_DM_IOCTL, &prefp) != 0) { dm_dict_out = prop_dictionary_internalize(prefp.pref_plist); #else if (prop_dictionary_sendrecv_ioctl(dm_dict_in,_control_fd, NETBSD_DM_IOCTL,&dm_dict_out) != 0) { #endif if (errno == ENOENT && ((dmt->type == DM_DEVICE_INFO) || (dmt->type == DM_DEVICE_MKNODES) || (dmt->type == DM_DEVICE_STATUS))) { /* * Linux version doesn't fail when ENOENT is returned * for nonexisting device after info, deps, mknodes call. * It returns dmi sent to kernel with DM_EXISTS_FLAG = 0; */ dmi = nbsd_dm_dict_to_dmi(dm_dict_in,_cmd_data_v4[dmt->type].cmd); dmi->flags &= ~DM_EXISTS_FLAG; prop_object_release(dm_dict_in); prop_object_release(dm_dict_out); goto out; } else { log_error("ioctl %s call failed with errno %d\n", _cmd_data_v4[dmt->type].name, errno); prop_object_release(dm_dict_in); prop_object_release(dm_dict_out); goto bad; } } #ifdef RUMP_ACTION dm_dict_out = prop_dictionary_internalize(prefp.pref_plist); #endif prop_dictionary_externalize_to_file(dm_dict_out,"/tmp/test_out"); /* Parse kernel dictionary to dmi structure and return it to libdevmapper. */ dmi = nbsd_dm_dict_to_dmi(dm_dict_out,_cmd_data_v4[dmt->type].cmd); prop_object_release(dm_dict_in); prop_object_release(dm_dict_out); out: return dmi; bad: return NULL; } /* Create new edvice nodes in mapper/ dir. */ void dm_task_update_nodes(void) { update_devs(); } /* Run dm command which is descirbed in dm_task structure. */ int dm_task_run(struct dm_task *dmt) { struct dm_ioctl *dmi; unsigned command; if ((unsigned) dmt->type >= (sizeof(_cmd_data_v4) / sizeof(*_cmd_data_v4))) { log_error("Internal error: unknown device-mapper task %d", dmt->type); return 0; } command = _cmd_data_v4[dmt->type].cmd; /* Old-style creation had a table supplied */ if (dmt->type == DM_DEVICE_CREATE && dmt->head) return _create_and_load_v4(dmt); if (dmt->type == DM_DEVICE_MKNODES && !dmt->dev_name && !dmt->uuid && dmt->major <= 0) return _mknodes_v4(dmt); if ((dmt->type == DM_DEVICE_RELOAD) && dmt->suppress_identical_reload) return _reload_with_suppression_v4(dmt); if (!_open_control()) return 0; if (!(dmi = _do_dm_ioctl(dmt, command))) return 0; switch (dmt->type) { case DM_DEVICE_CREATE: add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev), dmt->uid, dmt->gid, dmt->mode, 0); break; case DM_DEVICE_REMOVE: /* FIXME Kernel needs to fill in dmi->name */ if (dmt->dev_name) rm_dev_node(dmt->dev_name, 0); break; case DM_DEVICE_RENAME: /* FIXME Kernel needs to fill in dmi->name */ if (dmt->dev_name) rename_dev_node(dmt->dev_name, dmt->newname, 0); break; case DM_DEVICE_RESUME: /* FIXME Kernel needs to fill in dmi->name */ set_dev_node_read_ahead(dmt->dev_name, dmt->read_ahead, dmt->read_ahead_flags); break; case DM_DEVICE_MKNODES: if (dmi->flags & DM_EXISTS_FLAG) add_dev_node(dmi->name, MAJOR(dmi->dev), MINOR(dmi->dev), dmt->uid, dmt->gid, dmt->mode, 0); else if (dmt->dev_name) rm_dev_node(dmt->dev_name, 0); break; case DM_DEVICE_STATUS: case DM_DEVICE_TABLE: case DM_DEVICE_WAITEVENT: if (!_unmarshal_status(dmt, dmi)) goto bad; break; } /* Was structure reused? */ if (dmt->dmi.v4) dm_free(dmt->dmi.v4); dmt->dmi.v4 = dmi; return 1; bad: dm_free(dmi); return 0; } void dm_lib_release(void) { if (_control_fd != -1) { close(_control_fd); _control_fd = -1; } update_devs(); } void dm_lib_exit(void) { dm_lib_release(); dm_dump_memory(); _version_ok = 1; _version_checked = 0; }