Index: dsrc/external/gpl2/lvm2/dist/libdm/ioctl/libdm-nbsd-iface.c =================================================================== --- dsrc.orig/external/gpl2/lvm2/dist/libdm/ioctl/libdm-nbsd-iface.c 2011-01-12 09:16:23.000000000 +0100 +++ dsrc/external/gpl2/lvm2/dist/libdm/ioctl/libdm-nbsd-iface.c 2011-02-06 14:20:41.975818789 +0100 @@ -28,6 +28,7 @@ #include #include +#include #include #include @@ -38,8 +39,8 @@ #endif /* - * Ensure build compatibility. - * The hard-coded versions here are the highest present + * Ensure build compatibility. + * The hard-coded versions here are the highest present * in the _cmd_data arrays. */ @@ -104,9 +105,9 @@ { nbsd_get_dm_major(major, DM_CHAR_MAJOR); - + *minor = 0; - + return 1; } @@ -185,7 +186,7 @@ uint32_t dm_major; nbsd_get_dm_major(&dm_major, DM_BLOCK_MAJOR); - + if (major == dm_major) return 1; @@ -201,7 +202,7 @@ if (_control_fd != -1) return 1; -#ifdef RUMP_ACTION +#ifdef RUMP_ACTION rump_init(); #endif snprintf(control, sizeof(control), "%s/control", dm_dir()); @@ -297,7 +298,7 @@ } /* - * Find out device-mapper's major version number the first time + * Find out device-mapper's major version number the first time * this is called and whether or not we support it. */ int dm_check_version(void) @@ -422,14 +423,14 @@ dev_t dev; size_t val_len,i; struct kinfo_drivers *kd; - + mode = 0; - + nbsd_get_dm_major(&dm_major, DM_BLOCK_MAJOR); if (bufsize < 8) return 0; - + if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) { printf("sysctlbyname failed"); return 0; @@ -451,7 +452,7 @@ break; } } - + dev = MKDEV(major,dev_minor); mode |= S_IFBLK; @@ -489,10 +490,10 @@ info->target_count = dmt->dmi.v4->target_count; info->open_count = dmt->dmi.v4->open_count; info->event_nr = dmt->dmi.v4->event_nr; - + nbsd_get_dm_major(&info->major, DM_BLOCK_MAJOR); /* get netbsd dm device major number */ info->minor = MINOR(dmt->dmi.v4->dev); - + return 1; } @@ -657,44 +658,39 @@ } /* Parse given dm task structure to proplib dictionary. */ -static int _flatten(struct dm_task *dmt, prop_dictionary_t dm_dict) +static int _flatten(struct dm_task *dmt, libdm_task_t task) { - prop_array_t cmd_array; - prop_dictionary_t target_spec; - + libdm_cmd_t cmd; + libdm_table_t table; + struct target *t; - + size_t len; char type[DM_MAX_TYPE_NAME]; - + uint32_t major, flags; int count = 0; - const int (*version)[3]; - + flags = 0; - version = &_cmd_data_v4[dmt->type].version; - cmd_array = prop_array_create(); + cmd = libdm_cmd_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); + table = libdm_table_create(); + + libdm_table_set_start(t->start, table); + libdm_table_set_length(t->length, table); + libdm_table_set_target(type, table); + libdm_table_set_params(t->params, table); + libdm_cmd_set_table(table, cmd); - prop_array_set(cmd_array,count,target_spec); + libdm_table_destroy(table); - prop_object_release(target_spec); - count++; } - if (count && (dmt->sector || dmt->message)) { log_error("targets and message are incompatible"); return -1; @@ -739,29 +735,26 @@ 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 + /* + * 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); + libdm_task_set_minor(dmt->minor, task); } /* Set values to dictionary. */ if (dmt->dev_name) - prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmt->dev_name); + libdm_task_set_name(dmt->dev_name, task); if (dmt->uuid) - prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmt->uuid); - + libdm_task_set_uuid(dmt->uuid, task); + if (dmt->type == DM_DEVICE_SUSPEND) flags |= DM_SUSPEND_FLAG; if (dmt->no_flush) @@ -777,18 +770,18 @@ "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); + libdm_task_set_flags(flags, task); + +// prop_dictionary_set_uint32(dm_dict, DM_IOCTL_EVENT, dmt->event_nr); if (dmt->newname) - prop_array_set_cstring(cmd_array, 0, dmt->newname); - + libdm_dev_set_newname(dmt->newname, cmd); + /* Add array for all COMMAND specific data. */ - prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array); - prop_object_release(cmd_array); - + libdm_task_set_cmd(cmd, task); + libdm_cmd_destroy(cmd); + return 0; } @@ -874,7 +867,7 @@ int r; printf("create and load called \n"); - + /* Use new task struct to create the device */ if (!(task = dm_task_create(DM_DEVICE_CREATE))) { log_error("Failed to create device-mapper task struct"); @@ -958,7 +951,7 @@ struct dm_task *task; struct target *t1, *t2; int r; - + /* New task to get existing table information */ if (!(task = dm_task_create(DM_DEVICE_TABLE))) { log_error("Failed to create device-mapper task struct"); @@ -991,7 +984,7 @@ while (t2 && t2->next) t2 = t2->next; dmt->existing_table_size = t2 ? t2->start + t2->length : 0; - + if ((task->dmi.v4->flags & DM_READONLY_FLAG) ? 1 : 0 != dmt->read_only) goto no_match; @@ -1009,7 +1002,7 @@ t1 = t1->next; t2 = t2->next; } - + if (!t1 && !t2) { dmt->dmi.v4 = task->dmi.v4; task->dmi.v4 = NULL; @@ -1037,54 +1030,22 @@ 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); + libdm_task_t task; + + task = libdm_task_create(_cmd_data_v4[dmt->type].name); /* Parse dmi from libdevmapper to dictionary */ - if (_flatten(dmt, dm_dict_in) < 0) + if (_flatten(dmt, task) < 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; + libdm_task_set_status_flag(task); - if (dmt->no_open_count) - flags |= DM_SKIP_BDGET_FLAG; + libdm_task_set_exists_flag(task); - 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)); + log_very_verbose("Ioctl type %s --- flags %d",_cmd_data_v4[dmt->type].name, libdm_task_get_flags(task)); /* 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 (libdm_task_run(task) != 0) { if (errno == ENOENT && ((dmt->type == DM_DEVICE_INFO) || (dmt->type == DM_DEVICE_MKNODES) || @@ -1095,37 +1056,27 @@ * 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; + dmi = nbsd_dm_dict_to_dmi(task, _cmd_data_v4[dmt->type].cmd); + + libdm_task_del_exists_flag(task); - prop_object_release(dm_dict_in); - prop_object_release(dm_dict_out); + libdm_task_destroy(task); goto out; } else { - log_error("ioctl %s call failed with errno %d\n", + 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); - + libdm_task_destroy(task); 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); + dmi = nbsd_dm_dict_to_dmi(task, _cmd_data_v4[dmt->type].cmd); - prop_object_release(dm_dict_in); - prop_object_release(dm_dict_out); -out: + libdm_task_destroy(task); +out: return dmi; bad: return NULL; @@ -1162,7 +1113,7 @@ if ((dmt->type == DM_DEVICE_RELOAD) && dmt->suppress_identical_reload) return _reload_with_suppression_v4(dmt); - + if (!_open_control()) return 0; @@ -1192,7 +1143,7 @@ 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), Index: dsrc/external/gpl2/lvm2/dist/libdm/ioctl/libdm_netbsd.c =================================================================== --- dsrc.orig/external/gpl2/lvm2/dist/libdm/ioctl/libdm_netbsd.c 2010-12-23 12:22:51.000000000 +0100 +++ dsrc/external/gpl2/lvm2/dist/libdm/ioctl/libdm_netbsd.c 2011-02-06 14:33:33.768067664 +0100 @@ -42,6 +42,8 @@ #include #include +#include + #include #include @@ -51,10 +53,10 @@ #define DMI_SIZE 16 * 1024 -static int dm_list_versions(prop_dictionary_t, struct dm_ioctl *); -static int dm_list_devices(prop_dictionary_t, struct dm_ioctl *); -static int dm_dev_deps(prop_dictionary_t, struct dm_ioctl *); -static int dm_table_status(prop_dictionary_t, struct dm_ioctl *); +static int dm_list_versions(libdm_task_t, struct dm_ioctl *); +static int dm_list_devices(libdm_task_t, struct dm_ioctl *); +static int dm_dev_deps(libdm_task_t, struct dm_ioctl *); +static int dm_table_status(libdm_task_t, struct dm_ioctl *); int nbsd_get_dm_major(uint32_t *major, int type) @@ -78,8 +80,7 @@ } for (i = 0, val_len /= sizeof(*kd); i < val_len; i++) { - - if (strncmp(kd[i].d_name,DM_NAME,strlen(kd[i].d_name)) == 0){ + if (strncmp(kd[i].d_name,DM_NAME,strlen(kd[i].d_name)) == 0) { if (type == DM_CHAR_MAJOR) /* Set major to dm-driver char major number. */ @@ -87,7 +88,6 @@ else if (type == DM_BLOCK_MAJOR) *major = kd[i].d_bmajor; - free(kd); return 1; @@ -95,113 +95,89 @@ } free(kd); - - return 0; -} -int -nbsd_dmi_add_version(const int *version, prop_dictionary_t dm_dict) -{ - prop_array_t ver; - size_t i; - - if ((ver = prop_array_create()) == NULL) - return -1; - - for (i=0;i<3;i++) - prop_array_set_uint32(ver,i,version[i]); - - if ((prop_dictionary_set(dm_dict,"version",ver)) == false) - return -1; - - prop_object_release(ver); - return 0; } struct dm_ioctl* -nbsd_dm_dict_to_dmi(prop_dictionary_t dm_dict,const int cmd) +nbsd_dm_dict_to_dmi(libdm_task_t task, const int cmd) { struct dm_ioctl *dmi; - prop_array_t ver; - - size_t i; + int r; char *name, *uuid; uint32_t major,minor; - + name = NULL; uuid = NULL; minor = 0; - + nbsd_get_dm_major(&major, DM_BLOCK_MAJOR); - + if (!(dmi = dm_malloc(DMI_SIZE))) return NULL; - memset(dmi,0,DMI_SIZE); - - prop_dictionary_get_int32(dm_dict, DM_IOCTL_OPEN, &dmi->open_count); - prop_dictionary_get_uint32(dm_dict, DM_IOCTL_EVENT, &dmi->event_nr); - prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &dmi->flags); - prop_dictionary_get_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, - &dmi->target_count); + memset(dmi, 0, DMI_SIZE); + + dmi->open_count = libdm_task_get_open_num(task); + dmi->event_nr = libdm_task_get_event_num(task); + dmi->flags = libdm_task_get_flags(task); + dmi->target_count = libdm_task_get_target_num(task); + + minor = libdm_task_get_minor(task); - if (prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor)) + if (minor != 0) dmi->dev = MKDEV(major, minor); else dmi->dev = 0; - + + name = libdm_task_get_name(task); + uuid = libdm_task_get_uuid(task); + /* Copy name and uuid to dm_ioctl. */ - if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, - (const char **)&name)){ + if (name != NULL) strlcpy(dmi->name, name, DM_NAME_LEN); - } else + else dmi->name[0] = '\0'; - - if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, - (const char **)&uuid)){ + + if (uuid != NULL) strlcpy(dmi->uuid, uuid, DM_UUID_LEN); - } else + else dmi->uuid[0] = '\0'; /* dmi parsing values, size of dmi block and offset to data. */ dmi->data_size = DMI_SIZE; dmi->data_start = sizeof(struct dm_ioctl); - - /* Get kernel version from dm_dict. */ - ver = prop_dictionary_get(dm_dict,DM_IOCTL_VERSION); - - for(i=0; i<3; i++) - prop_array_get_uint32(ver,i,&dmi->version[i]); + + libdm_task_get_cmd_version(task, dmi->version, 3); switch (cmd){ case DM_LIST_VERSIONS: - r = dm_list_versions(dm_dict,dmi); + r = dm_list_versions(task, dmi); if (r >= 0) dmi->target_count = r; break; case DM_LIST_DEVICES: - r = dm_list_devices(dm_dict,dmi); + r = dm_list_devices(task, dmi); if (r >= 0) dmi->target_count = r; - break; + break; case DM_TABLE_STATUS: - r = dm_table_status(dm_dict,dmi); + r = dm_table_status(task, dmi); if (r >= 0) dmi->target_count = r; - break; + break; case DM_TABLE_DEPS: - r = dm_dev_deps(dm_dict,dmi); + r = dm_dev_deps(task, dmi); if (r >= 0) dmi->target_count = r; - break; - } - + break; + } + return dmi; } @@ -212,21 +188,22 @@ */ static int -dm_list_versions(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) +dm_list_versions(libdm_task_t task, struct dm_ioctl *dmi) { struct dm_target_versions *dmtv,*odmtv; - prop_array_t targets,ver; - prop_dictionary_t target_dict; - prop_object_iterator_t iter; - + libdm_cmd_t cmd; + libdm_iter_t iter; + libdm_target_t target; + uint32_t ver[3]; + char *name; size_t j,i,slen,rec_size; - + odmtv = NULL; name = NULL; j = 0; - + dmtv = (struct dm_target_versions *)((uint8_t *)dmi + dmi->data_start); /* printf("dmi: vers: %d.%d.%d data_size: %d data_start: %d name: %s t_count: %d\n", @@ -237,61 +214,56 @@ printf("dmtv: size: %p --- %p\n",dmtv,(struct dm_target_versions *)(dmi+312));*/ /* get prop_array of target_version dictionaries */ - if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ - iter = prop_array_iterator(targets); - if (!iter) - err(EXIT_FAILURE,"dm_list_versions %s",__func__); - - while((target_dict = prop_object_iterator_next(iter)) != NULL){ - j++; - - prop_dictionary_get_cstring_nocopy(target_dict, - DM_TARGETS_NAME,(const char **)&name); - - slen = strlen(name) + 1; - rec_size = sizeof(struct dm_target_versions) + slen + 1; - - if (rec_size > dmi->data_size) - return -ENOMEM; - - ver = prop_dictionary_get(target_dict,DM_TARGETS_VERSION); - - for (i=0; i<3; i++) - prop_array_get_uint32(ver,i,&dmtv->version[i]); - - dmtv->next = rec_size; - - strlcpy(dmtv->name,name,slen); - - odmtv = dmtv; - - dmtv =(struct dm_target_versions *)((uint8_t *)dmtv + rec_size); - } + if ((cmd = libdm_task_get_cmd(task)) == NULL) + return -ENOENT; + + iter = libdm_cmd_iter_create(cmd); - if (odmtv != NULL) - odmtv->next = 0; - } + while((target = libdm_cmd_get_target(iter)) != NULL){ + j++; + + name = libdm_target_get_name(target); + + slen = strlen(name) + 1; + rec_size = sizeof(struct dm_target_versions) + slen + 1; + + if (rec_size > dmi->data_size) + return -ENOMEM; + + libdm_target_get_version(target, dmtv->version, sizeof(ver)); + + dmtv->next = rec_size; + strlcpy(dmtv->name,name,slen); + odmtv = dmtv; + dmtv =(struct dm_target_versions *)((uint8_t *)dmtv + rec_size); + + libdm_target_destroy(target); + } + + if (odmtv != NULL) + odmtv->next = 0; + + libdm_iter_destroy(iter); - prop_object_iterator_release(iter); return j; } /* - * List all available dm devices in system. - */ + * List all available dm devices in system. + */ static int -dm_list_devices(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) +dm_list_devices(libdm_task_t task, struct dm_ioctl *dmi) { struct dm_name_list *dml,*odml; - - prop_array_t targets; - prop_dictionary_t target_dict; - prop_object_iterator_t iter; + + libdm_cmd_t cmd; + libdm_iter_t iter; + libdm_dev_t dev; uint32_t minor; uint32_t major; - + char *name; size_t j,slen,rec_size; @@ -300,170 +272,150 @@ minor = 0; j = 0; - nbsd_get_dm_major(&major,DM_BLOCK_MAJOR); - + nbsd_get_dm_major(&major, DM_BLOCK_MAJOR); + dml = (struct dm_name_list *)((uint8_t *)dmi + dmi->data_start); - if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ + if ((cmd = libdm_task_get_cmd(task)) == NULL) + return -ENOENT; - iter = prop_array_iterator(targets); - if (!iter) - err(EXIT_FAILURE,"dm_list_devices %s",__func__); - - while((target_dict = prop_object_iterator_next(iter)) != NULL){ - - prop_dictionary_get_cstring_nocopy(target_dict, - DM_DEV_NAME,(const char **)&name); - - prop_dictionary_get_uint32(target_dict,DM_DEV_DEV,&minor); - - dml->dev = MKDEV(major,minor); - - slen = strlen(name) + 1; - rec_size = sizeof(struct dm_name_list) + slen + 1; - - if (rec_size > dmi->data_size) - return -ENOMEM; - - dml->next = rec_size; - - strlcpy(dml->name,name,slen); - - odml = dml; - - dml =(struct dm_name_list *)((uint8_t *)dml + rec_size); + iter = libdm_cmd_iter_create(cmd); - j++; - } + while((dev = libdm_cmd_get_dev(iter)) != NULL){ - if (odml != NULL) - odml->next = 0; + name = libdm_dev_get_name(dev); + minor = libdm_dev_get_minor(dev); + dml->dev = MKDEV(major, minor); + + slen = strlen(name) + 1; + rec_size = sizeof(struct dm_name_list) + slen + 1; + + if (rec_size > dmi->data_size) + return -ENOMEM; + + dml->next = rec_size; + strlcpy(dml->name, name, slen); + odml = dml; + dml =(struct dm_name_list *)((uint8_t *)dml + rec_size); + j++; + + libdm_dev_destroy(dev); } - prop_object_iterator_release(iter); + + if (odml != NULL) + odml->next = 0; + + libdm_iter_destroy(iter); + return j; } /* - * Print status of each table, target arguments, start sector, + * Print status of each table, target arguments, start sector, * size and target name. */ static int -dm_table_status(prop_dictionary_t dm_dict,struct dm_ioctl *dmi) +dm_table_status(libdm_task_t task, struct dm_ioctl *dmi) { struct dm_target_spec *dmts, *odmts; - prop_array_t targets; - prop_dictionary_t target_dict; - prop_object_iterator_t iter; - - char *type,*params,*params_start; + libdm_cmd_t cmd; + libdm_table_t table; + libdm_iter_t iter; + uint32_t flags; - bool prm; - size_t j,plen,rec_size,next; + char *type, *params, *params_start; + size_t j, plen, rec_size, next; - j = 0; - next = 0; + j = next = rec_size = 0; params = NULL; odmts = NULL; - rec_size = 0; plen = -1; - prm = false; - - dmts = (struct dm_target_spec *)((uint8_t *)dmi + dmi->data_start); - - if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ - - iter = prop_array_iterator(targets); - if (!iter) - err(EXIT_FAILURE,"dm_table_status %s",__func__); - - while((target_dict = prop_object_iterator_next(iter)) != NULL){ - - prop_dictionary_get_cstring_nocopy(target_dict, - DM_TABLE_TYPE,(const char **)&type); - - prm = prop_dictionary_get_cstring_nocopy(target_dict, - DM_TABLE_PARAMS,(const char **)¶ms); - - prop_dictionary_get_uint64(target_dict,DM_TABLE_START,&dmts->sector_start); - prop_dictionary_get_uint64(target_dict,DM_TABLE_LENGTH,&dmts->length); - prop_dictionary_get_int32(target_dict,DM_TABLE_STAT,&dmts->status); - - if (prm) - plen = strlen(params) + 1; - - rec_size = sizeof(struct dm_target_spec) + plen; - - /* - * In linux when copying table status from kernel next is - * number of bytes from the start of the first dm_target_spec - * structure. I don't know why but, it has to be done this way. - */ - next += rec_size; - - if (rec_size > dmi->data_size) - return -ENOMEM; - - dmts->next = next; - - strlcpy(dmts->target_type, type, DM_MAX_TYPE_NAME); - params_start = (char *)dmts + sizeof(struct dm_target_spec); + dmts = (struct dm_target_spec *)((uint8_t *)dmi + dmi->data_start); - if (prm) - strlcpy(params_start, params, plen); - else - params_start = "\0"; + if ((cmd = libdm_task_get_cmd(task)) == NULL) + return ENOENT; - - odmts = dmts; - - dmts = (struct dm_target_spec *)((uint8_t *)dmts + rec_size); + iter = libdm_cmd_iter_create(cmd); - j++; - - } + while ((table = libdm_cmd_get_table(iter)) != NULL) { + dmts->sector_start = libdm_table_get_start(table); + dmts->length = libdm_table_get_length(table); + dmts->status = libdm_table_get_status(table); + + type = libdm_table_get_target(table); + params = libdm_table_get_params(table); + + if (params != NULL) + plen = strlen(params) + 1; + + rec_size = sizeof(struct dm_target_spec) + plen; + + /* + * In linux when copying table status from kernel next is + * number of bytes from the start of the first dm_target_spec + * structure. I don't know why but, it has to be done this way. + */ + next += rec_size; - if (odmts != NULL) - odmts->next = 0; - } - prop_object_iterator_release(iter); + if (rec_size > dmi->data_size) + return -ENOMEM; + + dmts->next = next; + strlcpy(dmts->target_type, type, DM_MAX_TYPE_NAME); + params_start = (char *)dmts + sizeof(struct dm_target_spec); + + if (params != NULL) + strlcpy(params_start, params, plen); + else + params_start = "\0"; + + odmts = dmts; + dmts = (struct dm_target_spec *)((uint8_t *)dmts + rec_size); + j++; + + libdm_table_destroy(table); + } + + if (odmts != NULL) + odmts->next = 0; + + libdm_iter_destroy(iter); return j; } /* - * Print dm device dependiences, get minor/major number for - * devices. From kernel I will receive major:minor number of - * block device used with target. I have to translate it to - * raw device numbers and use them, because all other parts of lvm2 - * uses raw devices internaly. + * Print dm device dependiences, get minor/major number for + * devices. From kernel I will receive major:minor number of + * block device used with target. I have to translate it to + * raw device numbers and use them, because all other parts of lvm2 + * uses raw devices internally. */ static int -dm_dev_deps(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) +dm_dev_deps(libdm_task_t task, struct dm_ioctl *dmi) { struct dm_target_deps *dmtd; struct kinfo_drivers *kd; - - prop_array_t targets; - prop_object_iterator_t iter; - + + libdm_cmd_t cmd; + libdm_iter_t iter; + dev_t dev_deps; + uint32_t major; - size_t val_len, i, j; - uint64_t dev_tmp; - - dev_tmp = 0; + dev_deps = 0; j = 0; i = 0; - + if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) { printf("sysctlbyname failed"); return 0; } - if ((kd = malloc (val_len)) == NULL){ + if ((kd = malloc(val_len)) == NULL){ printf("malloc kd info error\n"); return 0; } @@ -472,35 +424,31 @@ printf("sysctlbyname failed kd"); return 0; } - + dmtd = (struct dm_target_deps *)((uint8_t *)dmi + dmi->data_start); - if ((targets = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA))){ + if ((cmd = libdm_task_get_cmd(task)) == NULL) + return -ENOENT; - iter = prop_array_iterator(targets); - if (!iter) - err(EXIT_FAILURE,"dm_target_deps %s", __func__); - - while((prop_object_iterator_next(iter)) != NULL){ - - prop_array_get_uint64(targets, j, &dev_tmp); - - for (i = 0, val_len /= sizeof(*kd); i < val_len; i++){ - if (kd[i].d_bmajor == MAJOR(dev_tmp)) { - major = kd[i].d_cmajor; - break; - } + iter = libdm_cmd_iter_create(cmd); + + while((dev_deps = libdm_cmd_get_deps(iter)) != 0) { + for (i = 0, val_len /= sizeof(*kd); i < val_len; i++){ + if (kd[i].d_bmajor == MAJOR(dev_deps)) { + major = kd[i].d_cmajor; + break; } - - dmtd->dev[j] = MKDEV(major,MINOR(dev_tmp)); - - j++; } - } - + + dmtd->dev[j] = MKDEV(major, MINOR(dev_deps)); + + j++; + } + dmtd->count = j; - prop_object_iterator_release(iter); - + libdm_iter_destroy(iter); + free(kd); + return j; } Index: dsrc/external/gpl2/lvm2/sbin/dmsetup/Makefile =================================================================== --- dsrc.orig/external/gpl2/lvm2/sbin/dmsetup/Makefile 2010-12-23 12:51:05.000000000 +0100 +++ dsrc/external/gpl2/lvm2/sbin/dmsetup/Makefile 2011-02-06 14:33:57.942574519 +0100 @@ -13,6 +13,8 @@ BINDIR= /sbin +CFLAGS+= -g -O0 + CPPFLAGS+= -I${LIBDM_DISTDIR}/ -I${LIBDM_DISTDIR}/misc \ -I. -I${LIBDM_DISTDIR}/ioctl -I${LVM2_DISTDIR}/include @@ -22,8 +24,9 @@ LDADD+= -L${LIBDM_OBJDIR} -ldevmapper DPADD+= ${LIBDM_OBJDIR}/libdevmapper.a -LDADD+= -lprop +LDADD+= -ldm -lprop +LDSTATIC= -static .PATH: ${LVM2_DISTDIR}/tools .include Index: dsrc/external/gpl2/lvm2/sbin/lvm/Makefile =================================================================== --- dsrc.orig/external/gpl2/lvm2/sbin/lvm/Makefile 2010-11-24 17:31:06.000000000 +0100 +++ dsrc/external/gpl2/lvm2/sbin/lvm/Makefile 2011-02-06 14:33:29.552349146 +0100 @@ -99,7 +99,7 @@ LDADD+= -L${LIBDM_OBJDIR} -ldevmapper DPADD+= ${LIBDM_OBJDIR}/libdevmapper.a -LDADD+= -lprop -ledit -ltermcap +LDADD+= -ldm -lprop -ledit -ltermcap LDSTATIC= -static