nl_rule_t * npf_rule_create(const char *name, uint32_t attr, const char *ifname) { prop_dictionary_t rldict; nl_rule_t *rl; rl = malloc(sizeof(*rl)); if (rl == NULL) { return NULL; } rldict = prop_dictionary_create(); if (rldict == NULL) { free(rl); return NULL; } if (name) { prop_dictionary_set_cstring(rldict, "name", name); } prop_dictionary_set_uint32(rldict, "attributes", attr); if (ifname) { prop_dictionary_set_cstring(rldict, "interface", ifname); } rl->nrl_dict = rldict; return rl; }
/* * Get list of physical devices for active table. * Get dev_t from pdev vnode and insert it into cmd_array. * * XXX. This function is called from lvm2tools to get information * about physical devices, too e.g. during vgcreate. */ int dm_table_deps_ioctl(prop_dictionary_t dm_dict) { dm_dev_t *dmv; dm_table_t *tbl; dm_table_entry_t *table_en; prop_array_t cmd_array; const char *name, *uuid; uint32_t flags, minor; int table_type; name = NULL; uuid = NULL; dmv = NULL; flags = 0; prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); /* create array for dev_t's */ cmd_array = prop_array_create(); if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name); prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); aprint_debug("Getting table deps for device: %s\n", dmv->name); /* * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query * INACTIVE TABLE */ if (flags & DM_QUERY_INACTIVE_TABLE_FLAG) table_type = DM_TABLE_INACTIVE; else table_type = DM_TABLE_ACTIVE; tbl = dm_table_get_entry(&dmv->table_head, table_type); SLIST_FOREACH(table_en, tbl, next) table_en->target->deps(table_en, cmd_array); dm_table_release(&dmv->table_head, table_type); dm_dev_unbusy(dmv); prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array); prop_object_release(cmd_array); return 0; }
nl_rproc_t * npf_rproc_create(const char *name) { prop_dictionary_t rpdict; prop_array_t extcalls; nl_rproc_t *nrp; nrp = malloc(sizeof(nl_rproc_t)); if (nrp == NULL) { return NULL; } rpdict = prop_dictionary_create(); if (rpdict == NULL) { free(nrp); return NULL; } prop_dictionary_set_cstring(rpdict, "name", name); extcalls = prop_array_create(); if (extcalls == NULL) { prop_object_release(rpdict); free(nrp); return NULL; } prop_dictionary_set(rpdict, "extcalls", extcalls); prop_object_release(extcalls); nrp->nrp_dict = rpdict; return nrp; }
nl_table_t * npf_table_create(const char *name, u_int id, int type) { prop_dictionary_t tldict; prop_array_t tblents; nl_table_t *tl; tl = malloc(sizeof(*tl)); if (tl == NULL) { return NULL; } tldict = prop_dictionary_create(); if (tldict == NULL) { free(tl); return NULL; } prop_dictionary_set_cstring(tldict, "name", name); prop_dictionary_set_uint32(tldict, "id", id); prop_dictionary_set_int32(tldict, "type", type); tblents = prop_array_create(); if (tblents == NULL) { prop_object_release(tldict); free(tl); return NULL; } prop_dictionary_set(tldict, "entries", tblents); prop_object_release(tblents); tl->ntl_dict = tldict; return tl; }
int testcase_set_stderr_buf(prop_dictionary_t testcase, const char *buf) { prop_dictionary_t dict = testcase_get_result_dict(testcase); return !prop_dictionary_set_cstring(dict, "stderr_buf", buf); }
int _npf_ruleset_list(int fd, const char *rname, nl_config_t *ncf) { prop_dictionary_t rldict, ret; int error; rldict = prop_dictionary_create(); if (rldict == NULL) { return ENOMEM; } prop_dictionary_set_cstring(rldict, "ruleset-name", rname); prop_dictionary_set_uint32(rldict, "command", NPF_CMD_RULE_LIST); error = prop_dictionary_sendrecv_ioctl(rldict, fd, IOC_NPF_RULE, &ret); if (!error) { prop_array_t rules; rules = prop_dictionary_get(ret, "rules"); if (rules == NULL) { return EINVAL; } prop_object_release(ncf->ncf_rules_list); ncf->ncf_rules_list = rules; } return error; }
int npf_rule_setproc(nl_rule_t *rl, const char *name) { prop_dictionary_t rldict = rl->nrl_dict; prop_dictionary_set_cstring(rldict, "rproc", name); return 0; }
static void usbd_serialnumber(device_t dv, struct usbd_device *dev) { if (dev->ud_serial) { prop_dictionary_set_cstring(device_properties(dv), "serialnumber", dev->ud_serial); } }
/* * Rename selected devices old name is in struct dm_ioctl. * newname is taken from dictionary * * <key>cmd_data</key> * <array> * <string>...</string> * </array> */ int dm_dev_rename_ioctl(prop_dictionary_t dm_dict) { #if 0 prop_array_t cmd_array; dm_dev_t *dmv; const char *name, *uuid, *n_name; uint32_t flags, minor; name = NULL; uuid = NULL; minor = 0; /* Get needed values from dictionary. */ prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); dm_dbg_print_flags(flags); cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA); prop_array_get_cstring_nocopy(cmd_array, 0, &n_name); if (strlen(n_name) + 1 > DM_NAME_LEN) return EINVAL; if ((dmv = dm_dev_rem(NULL, name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } /* change device name */ /* * XXX How to deal with this change, name only used in * dm_dev_routines, should I add dm_dev_change_name which will run * under the dm_dev_list mutex ? */ strlcpy(dmv->name, n_name, DM_NAME_LEN); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); dm_dev_insert(dmv); #endif /* * XXX: the rename is not yet implemented. The main complication * here is devfs. We'd probably need a new function, rename_dev() * that would trigger a node rename in devfs. */ kprintf("dm_dev_rename_ioctl called, but not implemented!\n"); return 0; }
static void _dm_rename_kern(struct dm_task *dmt) { prop_dictionary_t dm_dict_in, dm_dict_out; dm_dict_in = prop_dictionary_create(); /* Dictionary send to kernel */ /* Set command name to dictionary */ prop_dictionary_set_cstring(dm_dict_in, DM_IOCTL_COMMAND, "nrename"); prop_dictionary_set_cstring(dm_dict_in, "dev_name", dmt->dev_name); prop_dictionary_set_cstring(dm_dict_in, "new_name", dmt->newname); /* Set flags to dictionary. */ prop_dictionary_set_uint32(dm_dict_in,DM_IOCTL_FLAGS,0); if (prop_dictionary_sendrecv_ioctl(dm_dict_in,_control_fd, NETBSD_DM_IOCTL,&dm_dict_out) != 0) { log_error("rename failed"); } }
int npf_ruleset_flush(int fd, const char *rname) { prop_dictionary_t rldict; rldict = prop_dictionary_create(); if (rldict == NULL) { return ENOMEM; } prop_dictionary_set_cstring(rldict, "ruleset-name", rname); prop_dictionary_set_uint32(rldict, "command", NPF_CMD_RULE_FLUSH); return prop_dictionary_send_ioctl(rldict, fd, IOC_NPF_RULE); }
int npf_ruleset_remove(int fd, const char *rname, uint64_t id) { prop_dictionary_t rldict; rldict = prop_dictionary_create(); if (rldict == NULL) { return ENOMEM; } prop_dictionary_set_cstring(rldict, "ruleset-name", rname); prop_dictionary_set_uint32(rldict, "command", NPF_CMD_RULE_REMOVE); prop_dictionary_set_uint64(rldict, "id", id); return prop_dictionary_send_ioctl(rldict, fd, IOC_NPF_RULE); }
int _npf_alg_load(nl_config_t *ncf, const char *name) { prop_dictionary_t al_dict; if (_npf_prop_array_lookup(ncf->ncf_alg_list, "name", name)) return EEXIST; al_dict = prop_dictionary_create(); prop_dictionary_set_cstring(al_dict, "name", name); prop_array_add(ncf->ncf_alg_list, al_dict); prop_object_release(al_dict); return 0; }
/* * Return actual state of device to libdevmapper. */ int dm_dev_status_ioctl(prop_dictionary_t dm_dict) { dm_dev_t *dmv; const char *name, *uuid; uint32_t flags, j, minor; name = NULL; uuid = NULL; flags = 0; j = 0; prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } dm_dbg_print_flags(dmv->flags); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); if (dmv->flags & DM_SUSPEND_FLAG) DM_ADD_FLAG(flags, DM_SUSPEND_FLAG); /* * Add status flags for tables I have to check both active and * inactive tables. */ if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))) { DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG); } else DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j); if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE)) DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG); else DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG); dm_dev_unbusy(dmv); return 0; }
int npf_ruleset_add(int fd, const char *rname, nl_rule_t *rl, uint64_t *id) { prop_dictionary_t rldict = rl->nrl_dict; prop_dictionary_t ret; int error; prop_dictionary_set_cstring(rldict, "ruleset-name", rname); prop_dictionary_set_uint32(rldict, "command", NPF_CMD_RULE_ADD); error = prop_dictionary_sendrecv_ioctl(rldict, fd, IOC_NPF_RULE, &ret); if (!error) { prop_dictionary_get_uint64(ret, "id", id); } return error; }
int npf_rproc_extcall(nl_rproc_t *rp, nl_ext_t *ext) { prop_dictionary_t rpdict = rp->nrp_dict; prop_dictionary_t extdict = ext->nxt_dict; prop_array_t extcalls; extcalls = prop_dictionary_get(rpdict, "extcalls"); if (_npf_prop_array_lookup(extcalls, "name", ext->nxt_name)) { return EEXIST; } prop_dictionary_set_cstring(extdict, "name", ext->nxt_name); prop_array_add(extcalls, extdict); return 0; }
/* * Rename selected devices old name is in struct dm_ioctl. * newname is taken from dictionary * * <key>cmd_data</key> * <array> * <string>...</string> * </array> */ int dm_dev_rename_ioctl(prop_dictionary_t dm_dict) { prop_array_t cmd_array; dm_dev_t *dmv; const char *name, *uuid, *n_name; uint32_t flags, minor; name = NULL; uuid = NULL; minor = 0; /* Get needed values from dictionary. */ prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); dm_dbg_print_flags(flags); cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA); prop_array_get_cstring_nocopy(cmd_array, 0, &n_name); if (strlen(n_name) + 1 > DM_NAME_LEN) return EINVAL; if ((dmv = dm_dev_rem(name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } /* change device name */ /* * XXX How to deal with this change, name only used in * dm_dev_routines, should I add dm_dev_change_name which will run * under the dm_dev_list mutex ? */ strlcpy(dmv->name, n_name, DM_NAME_LEN); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); dm_dev_insert(dmv); return 0; }
void _npf_debug_addif(nl_config_t *ncf, const char *ifname) { prop_dictionary_t ifdict, dbg = _npf_debug_initonce(ncf); prop_array_t iflist = prop_dictionary_get(dbg, "interfaces"); u_int if_idx = if_nametoindex(ifname); if (_npf_prop_array_lookup(iflist, "name", ifname)) { return; } ifdict = prop_dictionary_create(); prop_dictionary_set_cstring(ifdict, "name", ifname); prop_dictionary_set_uint32(ifdict, "index", if_idx); prop_array_add(iflist, ifdict); prop_object_release(ifdict); }
int npf_ruleset_remkey(int fd, const char *rname, const void *key, size_t len) { prop_dictionary_t rldict; prop_data_t keyobj; rldict = prop_dictionary_create(); if (rldict == NULL) { return ENOMEM; } prop_dictionary_set_cstring(rldict, "ruleset-name", rname); prop_dictionary_set_uint32(rldict, "command", NPF_CMD_RULE_REMKEY); keyobj = prop_data_create_data(key, len); if (keyobj == NULL) { prop_object_release(rldict); return ENOMEM; } prop_dictionary_set(rldict, "key", keyobj); prop_object_release(keyobj); return prop_dictionary_send_ioctl(rldict, fd, IOC_NPF_RULE); }
/* * Called back during autoconfiguration for each device found */ void device_register(device_t dev, void *aux) { device_t busdev = device_parent(dev); int ofnode = 0; /* * We don't know the type of 'aux' - it depends on the * bus this device attaches to. We are only interested in * certain bus types, this only is used to find the boot * device. */ if (busdev == NULL) { /* * Ignore mainbus0 itself, it certainly is not a boot * device. */ } else if (device_is_a(busdev, "mainbus")) { struct mainbus_attach_args *ma = aux; ofnode = ma->ma_node; } else if (device_is_a(busdev, "pci")) { struct pci_attach_args *pa = aux; ofnode = PCITAG_NODE(pa->pa_tag); } else if (device_is_a(busdev, "sbus") || device_is_a(busdev, "dma") || device_is_a(busdev, "ledma")) { struct sbus_attach_args *sa = aux; ofnode = sa->sa_node; } else if (device_is_a(busdev, "ebus")) { struct ebus_attach_args *ea = aux; ofnode = ea->ea_node; } else if (device_is_a(busdev, "iic")) { struct i2c_attach_args *ia = aux; if (ia->ia_name == NULL) /* indirect config */ return; ofnode = (int)ia->ia_cookie; } else if (device_is_a(dev, "sd") || device_is_a(dev, "cd")) { struct scsipibus_attach_args *sa = aux; struct scsipi_periph *periph = sa->sa_periph; int off = 0; /* * There are two "cd" attachments: * atapibus -> atabus -> controller * scsibus -> controller * We want the node of the controller. */ if (device_is_a(busdev, "atapibus")) { busdev = device_parent(busdev); /* * if the atapibus is connected to the secondary * channel of the atabus, we need an offset of 2 * to match OF's idea of the target number. * (i.e. on U5/U10 "cdrom" and "disk2" have the * same target encoding, though different names) */ if (periph->periph_channel->chan_channel == 1) off = 2; } ofnode = device_ofnode(device_parent(busdev)); dev_path_drive_match(dev, ofnode, periph->periph_target + off, 0, periph->periph_lun); return; } else if (device_is_a(dev, "wd")) { struct ata_device *adev = aux; ofnode = device_ofnode(device_parent(busdev)); dev_path_drive_match(dev, ofnode, adev->adev_channel*2+ adev->adev_drv_data->drive, 0, 0); return; } if (busdev == NULL) return; if (ofnode != 0) { uint8_t eaddr[ETHER_ADDR_LEN]; char tmpstr[32]; char tmpstr2[32]; int node; uint32_t id = 0; uint64_t nwwn = 0, pwwn = 0; prop_dictionary_t dict; prop_data_t blob; prop_number_t pwwnd = NULL, nwwnd = NULL; prop_number_t idd = NULL; device_setofnode(dev, ofnode); dev_path_exact_match(dev, ofnode); if (OF_getprop(ofnode, "name", tmpstr, sizeof(tmpstr)) <= 0) tmpstr[0] = 0; if (OF_getprop(ofnode, "device_type", tmpstr2, sizeof(tmpstr2)) <= 0) tmpstr2[0] = 0; /* * If this is a network interface, note the * mac address. */ if (strcmp(tmpstr, "network") == 0 || strcmp(tmpstr, "ethernet") == 0 || strcmp(tmpstr2, "network") == 0 || strcmp(tmpstr2, "ethernet") == 0 || OF_getprop(ofnode, "mac-address", &eaddr, sizeof(eaddr)) >= ETHER_ADDR_LEN || OF_getprop(ofnode, "local-mac-address", &eaddr, sizeof(eaddr)) >= ETHER_ADDR_LEN) { dict = device_properties(dev); /* * Is it a network interface with FCode? */ if (strcmp(tmpstr, "network") == 0 || strcmp(tmpstr2, "network") == 0) { prop_dictionary_set_bool(dict, "without-seeprom", true); prom_getether(ofnode, eaddr); } else { if (!prom_get_node_ether(ofnode, eaddr)) goto noether; } blob = prop_data_create_data(eaddr, ETHER_ADDR_LEN); prop_dictionary_set(dict, "mac-address", blob); prop_object_release(blob); of_to_dataprop(dict, ofnode, "shared-pins", "shared-pins"); } noether: /* is this a FC node? */ if (strcmp(tmpstr, "scsi-fcp") == 0) { dict = device_properties(dev); if (OF_getprop(ofnode, "port-wwn", &pwwn, sizeof(pwwn)) == sizeof(pwwn)) { pwwnd = prop_number_create_unsigned_integer(pwwn); prop_dictionary_set(dict, "port-wwn", pwwnd); prop_object_release(pwwnd); } if (OF_getprop(ofnode, "node-wwn", &nwwn, sizeof(nwwn)) == sizeof(nwwn)) { nwwnd = prop_number_create_unsigned_integer(nwwn); prop_dictionary_set(dict, "node-wwn", nwwnd); prop_object_release(nwwnd); } } /* is this an spi device? look for scsi-initiator-id */ if (strcmp(tmpstr2, "scsi") == 0 || strcmp(tmpstr2, "scsi-2") == 0) { dict = device_properties(dev); for (node = ofnode; node != 0; node = OF_parent(node)) { if (OF_getprop(node, "scsi-initiator-id", &id, sizeof(id)) <= 0) continue; idd = prop_number_create_unsigned_integer(id); prop_dictionary_set(dict, "scsi-initiator-id", idd); prop_object_release(idd); break; } } } /* * Check for I2C busses and add data for their direct configuration. */ if (device_is_a(dev, "iic")) { int busnode = device_ofnode(busdev); if (busnode) { prop_dictionary_t props = device_properties(busdev); prop_object_t cfg = prop_dictionary_get(props, "i2c-child-devices"); if (!cfg) { int node; const char *name; /* * pmu's i2c devices are under the "i2c" node, * so find it out. */ name = prom_getpropstring(busnode, "name"); if (strcmp(name, "pmu") == 0) { for (node = OF_child(busnode); node != 0; node = OF_peer(node)) { name = prom_getpropstring(node, "name"); if (strcmp(name, "i2c") == 0) { busnode = node; break; } } } of_enter_i2c_devs(props, busnode, sizeof(cell_t)); } } /* * Add SPARCle spdmem devices (0x50 and 0x51) that the * firmware does not know about. */ if (!strcmp(machine_model, "TAD,SPARCLE")) { prop_dictionary_t props = device_properties(busdev); prop_array_t cfg = prop_array_create(); int i; DPRINTF(ACDB_PROBE, ("\nAdding spdmem for SPARCle ")); for (i = 0x50; i <= 0x51; i++) { prop_dictionary_t spd = prop_dictionary_create(); prop_dictionary_set_cstring(spd, "name", "dimm-spd"); prop_dictionary_set_uint32(spd, "addr", i); prop_dictionary_set_uint64(spd, "cookie", 0); prop_array_add(cfg, spd); prop_object_release(spd); } prop_dictionary_set(props, "i2c-child-devices", cfg); prop_object_release(cfg); } } /* set properties for PCI framebuffers */ if (device_is_a(busdev, "pci")) { /* see if this is going to be console */ struct pci_attach_args *pa = aux; prop_dictionary_t dict; int sub; int console = 0; dict = device_properties(dev); /* we only care about display devices from here on */ if (PCI_CLASS(pa->pa_class) != PCI_CLASS_DISPLAY) return; console = (ofnode == console_node); if (!console) { /* * see if any child matches since OF attaches * nodes for each head and /chosen/stdout * points to the head rather than the device * itself in this case */ sub = OF_child(ofnode); while ((sub != 0) && (sub != console_node)) { sub = OF_peer(sub); } if (sub == console_node) { console = true; } } copyprops(busdev, ofnode, dict, console); if (console) { uint64_t cmap_cb; prop_dictionary_set_uint32(dict, "instance_handle", console_instance); gfb_cb.gcc_cookie = (void *)(intptr_t)console_instance; gfb_cb.gcc_set_mapreg = of_set_palette; cmap_cb = (uint64_t)(uintptr_t)&gfb_cb; prop_dictionary_set_uint64(dict, "cmap_callback", cmap_cb); } #ifdef notyet else { int width; /* * the idea is to 'open' display devices with no useful * properties, in the hope that the firmware will * properly initialize them and we can run things like * genfb on them */ if (OF_getprop(node, "width", &width, sizeof(width)) != 4) { instance = OF_open(name); #endif } } /* * Called back after autoconfiguration of a device is done */ void device_register_post_config(device_t dev, void *aux) { if (booted_device == NULL && device_is_a(dev, "sd")) { struct scsipibus_attach_args *sa = aux; struct scsipi_periph *periph = sa->sa_periph; uint64_t wwn = 0; int ofnode; /* * If this is a FC-AL drive it will have * aquired its WWN device property by now, * so we can properly match it. */ if (prop_dictionary_get_uint64(device_properties(dev), "port-wwn", &wwn)) { /* * Different to what we do in device_register, * we do not pass the "controller" ofnode, * because FC-AL devices attach below a "fp" node, * E.g.: /pci/SUNW,qlc@4/fp@0,0/disk * and we need the parent of "disk" here. */ ofnode = device_ofnode( device_parent(device_parent(dev))); for (ofnode = OF_child(ofnode); ofnode != 0 && booted_device == NULL; ofnode = OF_peer(ofnode)) { dev_path_drive_match(dev, ofnode, periph->periph_target, wwn, periph->periph_lun); } } } } static void copyprops(device_t busdev, int node, prop_dictionary_t dict, int is_console) { device_t cntrlr; prop_dictionary_t psycho; paddr_t fbpa, mem_base = 0; uint32_t temp, fboffset; uint32_t fbaddr = 0; int options; char output_device[256]; char *pos; cntrlr = device_parent(busdev); if (cntrlr != NULL) { psycho = device_properties(cntrlr); prop_dictionary_get_uint64(psycho, "mem_base", &mem_base); } if (is_console) prop_dictionary_set_bool(dict, "is_console", 1); of_to_uint32_prop(dict, node, "width", "width"); of_to_uint32_prop(dict, node, "height", "height"); of_to_uint32_prop(dict, node, "linebytes", "linebytes"); if (!of_to_uint32_prop(dict, node, "depth", "depth") && /* Some cards have an extra space in the property name */ !of_to_uint32_prop(dict, node, "depth ", "depth")) { /* * XXX we should check linebytes vs. width but those * FBs that don't have a depth property ( /chaos/control... ) * won't have linebytes either */ prop_dictionary_set_uint32(dict, "depth", 8); } OF_getprop(node, "address", &fbaddr, sizeof(fbaddr)); if (fbaddr != 0) { pmap_extract(pmap_kernel(), fbaddr, &fbpa); #ifdef DEBUG printf("membase: %lx fbpa: %lx\n", (unsigned long)mem_base, (unsigned long)fbpa); #endif if (mem_base == 0) { /* XXX this is guesswork */ fboffset = (uint32_t)(fbpa & 0xffffffff); } fboffset = (uint32_t)(fbpa - mem_base); prop_dictionary_set_uint32(dict, "address", fboffset); } if (!of_to_dataprop(dict, node, "EDID", "EDID")) of_to_dataprop(dict, node, "edid", "EDID"); temp = 0; if (OF_getprop(node, "ATY,RefCLK", &temp, sizeof(temp)) != 4) { OF_getprop(OF_parent(node), "ATY,RefCLK", &temp, sizeof(temp)); } if (temp != 0) prop_dictionary_set_uint32(dict, "refclk", temp / 10); /* * finally, let's see if there's a video mode specified in * output-device and pass it on so drivers like radeonfb * can do their thing */ if (!is_console) return; options = OF_finddevice("/options"); if ((options == 0) || (options == -1)) return; if (OF_getprop(options, "output-device", output_device, 256) == 0) return; /* find the mode string if there is one */ pos = strstr(output_device, ":r"); if (pos == NULL) return; prop_dictionary_set_cstring(dict, "videomode", pos + 2); } static void of_set_palette(void *cookie, int index, int r, int g, int b) { int ih = (int)((intptr_t)cookie); OF_call_method_1("color!", ih, 4, r, g, b, index); }
void cubie_device_register(device_t self, void *aux) { prop_dictionary_t dict = device_properties(self); if (device_is_a(self, "armperiph") && device_is_a(device_parent(self), "mainbus")) { /* * XXX KLUDGE ALERT XXX * The iot mainbus supplies is completely wrong since it scales * addresses by 2. The simpliest remedy is to replace with our * bus space used for the armcore regisers (which armperiph uses). */ struct mainbus_attach_args * const mb = aux; mb->mb_iot = &awin_bs_tag; return; } #if defined(CPU_CORTEXA7) || defined(CPU_CORTEXA15) if (device_is_a(self, "armgtmr")) { /* * The frequency of the generic timer is the reference * frequency. */ prop_dictionary_set_uint32(dict, "frequency", AWIN_REF_FREQ); return; } #endif if (device_is_a(self, "awinio")) { prop_dictionary_set_bool(dict, "no-awge", true); return; } if (device_is_a(self, "awingpio")) { /* * These are GPIOs being used for various functions. */ prop_dictionary_set_cstring(dict, "satapwren", ">PB8"); prop_dictionary_set_cstring(dict, "usb0drv", ">PB9"); prop_dictionary_set_cstring(dict, "usb2drv", ">PH3"); prop_dictionary_set_cstring(dict, "usb0iddet", "<PH4"); prop_dictionary_set_cstring(dict, "usb0vbusdet", "<PH5"); prop_dictionary_set_cstring(dict, "usb1drv", ">PH6"); prop_dictionary_set_cstring(dict, "hdd5ven", ">PH17"); prop_dictionary_set_cstring(dict, "emacpwren", ">PH19"); prop_dictionary_set_cstring(dict, "status-led1", ">PH21"); prop_dictionary_set_cstring(dict, "status-led2", ">PH20"); /* * These pins have no connections. */ prop_dictionary_set_uint32(dict, "nc-b", 0x0003d0e8); prop_dictionary_set_uint32(dict, "nc-c", 0x00ff0000); prop_dictionary_set_uint32(dict, "nc-h", 0x03c53f04); prop_dictionary_set_uint32(dict, "nc-i", 0x003fc03f); return; } if (device_is_a(self, "ehci")) { return; } if (device_is_a(self, "ahcisata")) { /* PIO PB<8> output */ prop_dictionary_set_cstring(dict, "power-gpio", "satapwren"); return; } if (device_is_a(self, "sdhc")) { #if 0 prop_dictionary_set_uint32(dict, "clkmask", 0); prop_dictionary_set_bool(dict, "8bit", true); #endif return; } if (device_is_a(self, "com")) { #if NAWIN_FB > 0 if (use_fb_console) prop_dictionary_set_bool(dict, "is_console", false); #endif return; } }
static void copyprops(struct device *busdev, int node, prop_dictionary_t dict) { struct device *cntrlr; prop_dictionary_t psycho; paddr_t fbpa, mem_base = 0; uint32_t temp, fboffset; uint32_t fbaddr = 0; int options; char output_device[256]; char *pos; cntrlr = device_parent(busdev); if (cntrlr != NULL) { psycho = device_properties(cntrlr); prop_dictionary_get_uint64(psycho, "mem_base", &mem_base); } prop_dictionary_set_bool(dict, "is_console", 1); if (!of_to_uint32_prop(dict, node, "width", "width")) { OF_interpret("screen-width", 0, 1, &temp); prop_dictionary_set_uint32(dict, "width", temp); } if (!of_to_uint32_prop(dict, console_node, "height", "height")) { OF_interpret("screen-height", 0, 1, &temp); prop_dictionary_set_uint32(dict, "height", temp); } of_to_uint32_prop(dict, console_node, "linebytes", "linebytes"); if (!of_to_uint32_prop(dict, console_node, "depth", "depth") && /* Some cards have an extra space in the property name */ !of_to_uint32_prop(dict, console_node, "depth ", "depth")) { /* * XXX we should check linebytes vs. width but those * FBs that don't have a depth property ( /chaos/control... ) * won't have linebytes either */ prop_dictionary_set_uint32(dict, "depth", 8); } OF_getprop(console_node, "address", &fbaddr, sizeof(fbaddr)); if (fbaddr == 0) OF_interpret("frame-buffer-adr", 0, 1, &fbaddr); if (fbaddr != 0) { pmap_extract(pmap_kernel(), fbaddr, &fbpa); #ifdef DEBUG printf("membase: %lx fbpa: %lx\n", (unsigned long)mem_base, (unsigned long)fbpa); #endif if (mem_base == 0) { /* XXX this is guesswork */ fboffset = (uint32_t)(fbpa & 0xffffffff); } fboffset = (uint32_t)(fbpa - mem_base); prop_dictionary_set_uint32(dict, "address", fboffset); } of_to_dataprop(dict, console_node, "EDID", "EDID"); temp = 0; if (OF_getprop(console_node, "ATY,RefCLK", &temp, sizeof(temp)) != 4) { OF_getprop(OF_parent(console_node), "ATY,RefCLK", &temp, sizeof(temp)); } if (temp != 0) prop_dictionary_set_uint32(dict, "refclk", temp / 10); /* * finally, let's see if there's a video mode specified in * output-device and pass it on so drivers like radeonfb * can do their thing */ options = OF_finddevice("/options"); if ((options == 0) || (options == -1)) return; if (OF_getprop(options, "output-device", output_device, 256) == 0) return; printf("output-device: %s\n", output_device); /* find the mode string if there is one */ pos = strstr(output_device, ":r"); if (pos == NULL) return; prop_dictionary_set_cstring(dict, "videomode", pos + 2); }
/* * Get description of all tables loaded to device from kernel * and send it to libdevmapper. * * Output dictionary for every table: * * <key>cmd_data</key> * <array> * <dict> * <key>type<key> * <string>...</string> * * <key>start</key> * <integer>...</integer> * * <key>length</key> * <integer>...</integer> * * <key>params</key> * <string>...</string> * </dict> * </array> * */ int dm_table_status_ioctl(prop_dictionary_t dm_dict) { dm_dev_t *dmv; dm_table_t *tbl; dm_table_entry_t *table_en; prop_array_t cmd_array; prop_dictionary_t target_dict; uint32_t rec_size, minor; const char *name, *uuid; char *params; int flags; int table_type; dmv = NULL; uuid = NULL; name = NULL; params = NULL; flags = 0; rec_size = 0; prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); cmd_array = prop_array_create(); if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } /* * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query * INACTIVE TABLE */ if (flags & DM_QUERY_INACTIVE_TABLE_FLAG) table_type = DM_TABLE_INACTIVE; else table_type = DM_TABLE_ACTIVE; if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE)) DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG); else { DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG); if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE)) DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG); else { DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG); } } if (dmv->flags & DM_SUSPEND_FLAG) DM_ADD_FLAG(flags, DM_SUSPEND_FLAG); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); aprint_debug("Status of device tables: %s--%d\n", name, dmv->table_head.cur_active_table); tbl = dm_table_get_entry(&dmv->table_head, table_type); SLIST_FOREACH(table_en, tbl, next) { target_dict = prop_dictionary_create(); aprint_debug("%016" PRIu64 ", length %016" PRIu64 ", target %s\n", table_en->start, table_en->length, table_en->target->name); prop_dictionary_set_uint64(target_dict, DM_TABLE_START, table_en->start); prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH, table_en->length); prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE, table_en->target->name); /* dm_table_get_cur_actv.table ?? */ prop_dictionary_set_int32(target_dict, DM_TABLE_STAT, dmv->table_head.cur_active_table); if (flags & DM_STATUS_TABLE_FLAG) { params = table_en->target->status (table_en->target_config); if (params != NULL) { prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS, params); kfree(params, M_DM); } } prop_array_add(cmd_array, target_dict); prop_object_release(target_dict); }
/* * 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; }
prop_dictionary_t testcase_from_struct(struct testcase *testcase) { int i, r; prop_dictionary_t dict, testcase_dict; prop_array_t a; char *s; testcase_dict = prop_dictionary_create(); if (testcase_dict == NULL) err(1, "could not create testcase dict"); r = prop_dictionary_set_cstring(testcase_dict, "name", testcase->name); if (r == 0) err(1, "prop_dictionary operation failed"); r = prop_dictionary_set_cstring(testcase_dict, "type", testcase->type_str); if (r == 0) err(1, "prop_dictionary operation failed"); a = prop_array_create_with_capacity(testcase->argc+1); if (a == NULL) err(1, "prop_array_create for argv failed"); s = strrchr(testcase->name, '/'); r = prop_array_set_cstring(a, 0, (s == NULL) ? testcase->name : s+1); if (r == 0) err(1, "prop_array_set_cstring operation failed"); for (i = 1; i <= testcase->argc; i++) { r = prop_array_set_cstring(a, i, testcase->argv[i-1]); if (r == 0) err(1, "prop_array_set_cstring operation failed"); } r = prop_dictionary_set(testcase_dict, "args", a); if (r == 0) err(1, "prop_dictionary_set \"args\" failed"); dict = prop_dictionary_create(); if (dict == NULL) err(1, "could not create dict"); r = prop_dictionary_set_int32(dict, "timeout_in_secs", (int32_t)testcase->opts.timeout_in_secs); if (r == 0) err(1, "prop_dictionary operation failed"); r = prop_dictionary_set_uint32(dict, "flags", testcase->opts.flags); if (r == 0) err(1, "prop_dictionary operation failed"); if (testcase->opts.pre_cmd != NULL) { r = prop_dictionary_set_cstring(dict, "pre_cmd", testcase->opts.pre_cmd); if (r == 0) err(1, "prop_dictionary operation failed"); } if (testcase->opts.post_cmd != NULL) { r = prop_dictionary_set_cstring(dict, "post_cmd", testcase->opts.post_cmd); if (r == 0) err(1, "prop_dictionary operation failed"); } r = prop_dictionary_set_uint32(dict, "runas_uid", (uint32_t)testcase->opts.runas_uid); if (r == 0) err(1, "prop_dictionary operation failed"); r = prop_dictionary_set_cstring(dict, "make_cmd", (testcase->opts.make_cmd != NULL) ? testcase->opts.make_cmd : "make"); if (r == 0) err(1, "prop_dictionary operation failed"); r = prop_dictionary_set(testcase_dict, "opts", dict); if (r == 0) err(1, "prop_dictionary operation failed"); return testcase_dict; }
/* * 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); 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. */ if (prop_dictionary_sendrecv_ioctl(dm_dict_in,_control_fd, NETBSD_DM_IOCTL,&dm_dict_out) != 0) { 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: %s\n", _cmd_data_v4[dmt->type].name, strerror(errno)); prop_object_release(dm_dict_in); prop_object_release(dm_dict_out); goto bad; } } /* 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; }
/* Parse given dm task structure to proplib dictionary. */ static int _flatten(struct dm_task *dmt, prop_dictionary_t dm_dict) { prop_array_t cmd_array; prop_dictionary_t target_spec; struct target *t; size_t len; char type[DM_MAX_TYPE_NAME]; uint32_t major, flags; int count = 0; char *str = NULL; const int (*version)[3]; flags = 0; version = &_cmd_data_v4[dmt->type].version; cmd_array = prop_array_create(); for (t = dmt->head; t; t = t->next) { target_spec = prop_dictionary_create(); prop_dictionary_set_uint64(target_spec,DM_TABLE_START,t->start); prop_dictionary_set_uint64(target_spec,DM_TABLE_LENGTH,t->length); strlcpy(type,t->type,DM_MAX_TYPE_NAME); prop_dictionary_set_cstring(target_spec,DM_TABLE_TYPE,type); prop_dictionary_set_cstring(target_spec,DM_TABLE_PARAMS,t->params); prop_dictionary_get_cstring(target_spec, DM_TABLE_PARAMS, (char **) &str); prop_array_set(cmd_array,count,target_spec); prop_object_release(target_spec); count++; } if (count && (dmt->sector || dmt->message)) { log_error("targets and message are incompatible"); return -1; } if (count && dmt->newname) { log_error("targets and newname are incompatible"); return -1; } if (count && dmt->geometry) { log_error("targets and geometry are incompatible"); return -1; } if (dmt->newname && (dmt->sector || dmt->message)) { log_error("message and newname are incompatible"); return -1; } if (dmt->newname && dmt->geometry) { log_error("geometry and newname are incompatible"); return -1; } if (dmt->geometry && (dmt->sector || dmt->message)) { log_error("geometry and message are incompatible"); return -1; } if (dmt->sector && !dmt->message) { log_error("message is required with sector"); return -1; } if (dmt->newname) len += strlen(dmt->newname) + 1; if (dmt->message) len += sizeof(struct dm_target_msg) + strlen(dmt->message) + 1; if (dmt->geometry) len += strlen(dmt->geometry) + 1; nbsd_dmi_add_version((*version), dm_dict); nbsd_get_dm_major(&major, DM_BLOCK_MAJOR); /* * Only devices with major which is equal to netbsd dm major * dm devices in NetBSD can't have more majors then one assigned to dm. */ if (dmt->major != major && dmt->major != -1) return -1; if (dmt->minor >= 0) { flags |= DM_PERSISTENT_DEV_FLAG; prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmt->minor); } /* Set values to dictionary. */ if (dmt->dev_name) prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmt->dev_name); if (dmt->uuid) prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmt->uuid); if (dmt->type == DM_DEVICE_SUSPEND) flags |= DM_SUSPEND_FLAG; if (dmt->no_flush) flags |= DM_NOFLUSH_FLAG; if (dmt->read_only) flags |= DM_READONLY_FLAG; if (dmt->skip_lockfs) flags |= DM_SKIP_LOCKFS_FLAG; if (dmt->query_inactive_table) { if (_dm_version_minor < 16) log_warn("WARNING: Inactive table query unsupported " "by kernel. It will use live table."); flags |= DM_QUERY_INACTIVE_TABLE_FLAG; } prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_EVENT, dmt->event_nr); if (dmt->newname) prop_array_set_cstring(cmd_array, 0, dmt->newname); /* Add array for all COMMAND specific data. */ prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array); prop_object_release(cmd_array); return 0; }
void npf_ext_param_string(nl_ext_t *ext, const char *key, const char *val) { prop_dictionary_t extdict = ext->nxt_dict; prop_dictionary_set_cstring(extdict, key, val); }