1 /* $NetBSD: libdm_netbsd.c,v 1.5 2009/12/05 11:42:24 haad Exp $ */ 2 3 /* 4 * Copyright (c) 1996, 1997, 1998, 1999, 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Adam Hamsik. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 33 #include <sys/ioctl.h> 34 #include <sys/types.h> 35 #include <sys/sysctl.h> 36 37 #include <err.h> 38 #include <errno.h> 39 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <unistd.h> 43 44 #include <dev/dm/netbsd-dm.h> 45 46 #include <dm-ioctl.h> 47 48 #include "lib.h" 49 #include "libdm-netbsd.h" 50 51 #define DMI_SIZE 16 * 1024 52 53 static int dm_list_versions(prop_dictionary_t, struct dm_ioctl *); 54 static int dm_list_devices(prop_dictionary_t, struct dm_ioctl *); 55 static int dm_dev_deps(prop_dictionary_t, struct dm_ioctl *); 56 static int dm_table_status(prop_dictionary_t, struct dm_ioctl *); 57 58 int 59 nbsd_get_dm_major(uint32_t *major, int type) 60 { 61 size_t val_len,i; 62 struct kinfo_drivers *kd; 63 64 if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) { 65 printf("sysctlbyname failed"); 66 return 0; 67 } 68 69 if ((kd = malloc (val_len)) == NULL){ 70 printf("malloc kd info error\n"); 71 return 0; 72 } 73 74 if (sysctlbyname("kern.drivers", kd, &val_len, NULL, 0) < 0) { 75 printf("sysctlbyname failed kd"); 76 return 0; 77 } 78 79 for (i = 0, val_len /= sizeof(*kd); i < val_len; i++) { 80 81 if (strncmp(kd[i].d_name,DM_NAME,strlen(kd[i].d_name)) == 0){ 82 83 if (type == DM_CHAR_MAJOR) 84 /* Set major to dm-driver char major number. */ 85 *major = kd[i].d_cmajor; 86 else 87 if (type == DM_BLOCK_MAJOR) 88 *major = kd[i].d_bmajor; 89 90 free(kd); 91 92 return 1; 93 } 94 } 95 96 free(kd); 97 98 return 0; 99 } 100 101 int 102 nbsd_dmi_add_version(const int *version, prop_dictionary_t dm_dict) 103 { 104 prop_array_t ver; 105 size_t i; 106 107 if ((ver = prop_array_create()) == NULL) 108 return -1; 109 110 for (i=0;i<3;i++) 111 prop_array_set_uint32(ver,i,version[i]); 112 113 if ((prop_dictionary_set(dm_dict,"version",ver)) == false) 114 return -1; 115 116 prop_object_release(ver); 117 118 return 0; 119 } 120 121 struct dm_ioctl* 122 nbsd_dm_dict_to_dmi(prop_dictionary_t dm_dict,const int cmd) 123 { 124 struct dm_ioctl *dmi; 125 prop_array_t ver; 126 127 size_t i; 128 int r; 129 char *name, *uuid; 130 uint32_t major,minor; 131 132 name = NULL; 133 uuid = NULL; 134 minor = 0; 135 136 nbsd_get_dm_major(&major, DM_BLOCK_MAJOR); 137 138 if (!(dmi = dm_malloc(DMI_SIZE))) 139 return NULL; 140 141 memset(dmi,0,DMI_SIZE); 142 143 prop_dictionary_get_int32(dm_dict, DM_IOCTL_OPEN, &dmi->open_count); 144 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_EVENT, &dmi->event_nr); 145 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &dmi->flags); 146 prop_dictionary_get_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, 147 &dmi->target_count); 148 149 if (prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor)) 150 dmi->dev = MKDEV(major, minor); 151 else 152 dmi->dev = 0; 153 154 /* Copy name and uuid to dm_ioctl. */ 155 if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, 156 (const char **)&name)){ 157 strlcpy(dmi->name, name, DM_NAME_LEN); 158 } else 159 dmi->name[0] = '\0'; 160 161 if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, 162 (const char **)&uuid)){ 163 strlcpy(dmi->uuid, uuid, DM_UUID_LEN); 164 } else 165 dmi->uuid[0] = '\0'; 166 167 /* dmi parsing values, size of dmi block and offset to data. */ 168 dmi->data_size = DMI_SIZE; 169 dmi->data_start = sizeof(struct dm_ioctl); 170 171 /* Get kernel version from dm_dict. */ 172 ver = prop_dictionary_get(dm_dict,DM_IOCTL_VERSION); 173 174 for(i=0; i<3; i++) 175 prop_array_get_uint32(ver,i,&dmi->version[i]); 176 177 switch (cmd){ 178 179 case DM_LIST_VERSIONS: 180 r = dm_list_versions(dm_dict,dmi); 181 if (r >= 0) 182 dmi->target_count = r; 183 break; 184 185 case DM_LIST_DEVICES: 186 r = dm_list_devices(dm_dict,dmi); 187 if (r >= 0) 188 dmi->target_count = r; 189 break; 190 191 case DM_TABLE_STATUS: 192 r = dm_table_status(dm_dict,dmi); 193 if (r >= 0) 194 dmi->target_count = r; 195 break; 196 197 case DM_TABLE_DEPS: 198 r = dm_dev_deps(dm_dict,dmi); 199 if (r >= 0) 200 dmi->target_count = r; 201 break; 202 } 203 204 return dmi; 205 } 206 207 /* 208 * Parse dm_dict when targets command was called and fill dm_ioctl buffer with it. 209 * 210 * Return number of targets or if failed <0 error. 211 */ 212 213 static int 214 dm_list_versions(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) 215 { 216 struct dm_target_versions *dmtv,*odmtv; 217 218 prop_array_t targets,ver; 219 prop_dictionary_t target_dict; 220 prop_object_iterator_t iter; 221 222 char *name; 223 size_t j,i,slen,rec_size; 224 225 odmtv = NULL; 226 name = NULL; 227 j = 0; 228 229 dmtv = (struct dm_target_versions *)((uint8_t *)dmi + dmi->data_start); 230 231 /* printf("dmi: vers: %d.%d.%d data_size: %d data_start: %d name: %s t_count: %d\n", 232 dmi->version[0],dmi->version[1],dmi->version[2],dmi->data_size,dmi->data_start, 233 dmi->name,dmi->target_count); 234 235 printf("dmi: size: %d -- %p --- %p \n",sizeof(struct dm_ioctl),dmi,dmi+dmi->data_start); 236 printf("dmtv: size: %p --- %p\n",dmtv,(struct dm_target_versions *)(dmi+312));*/ 237 238 /* get prop_array of target_version dictionaries */ 239 if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ 240 241 iter = prop_array_iterator(targets); 242 if (!iter) 243 err(EXIT_FAILURE,"dm_list_versions %s",__func__); 244 245 while((target_dict = prop_object_iterator_next(iter)) != NULL){ 246 j++; 247 248 prop_dictionary_get_cstring_nocopy(target_dict, 249 DM_TARGETS_NAME,(const char **)&name); 250 251 slen = strlen(name) + 1; 252 rec_size = sizeof(struct dm_target_versions) + slen + 1; 253 254 if (rec_size > dmi->data_size) 255 return -ENOMEM; 256 257 ver = prop_dictionary_get(target_dict,DM_TARGETS_VERSION); 258 259 for (i=0; i<3; i++) 260 prop_array_get_uint32(ver,i,&dmtv->version[i]); 261 262 dmtv->next = rec_size; 263 264 strlcpy(dmtv->name,name,slen); 265 266 odmtv = dmtv; 267 268 dmtv =(struct dm_target_versions *)((uint8_t *)dmtv + rec_size); 269 } 270 271 if (odmtv != NULL) 272 odmtv->next = 0; 273 } 274 275 prop_object_iterator_release(iter); 276 return j; 277 } 278 279 /* 280 * List all available dm devices in system. 281 */ 282 static int 283 dm_list_devices(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) 284 { 285 struct dm_name_list *dml,*odml; 286 287 prop_array_t targets; 288 prop_dictionary_t target_dict; 289 prop_object_iterator_t iter; 290 291 uint32_t minor; 292 uint32_t major; 293 294 char *name; 295 size_t j,slen,rec_size; 296 297 odml = NULL; 298 name = NULL; 299 minor = 0; 300 j = 0; 301 302 nbsd_get_dm_major(&major,DM_BLOCK_MAJOR); 303 304 dml = (struct dm_name_list *)((uint8_t *)dmi + dmi->data_start); 305 306 if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ 307 308 iter = prop_array_iterator(targets); 309 if (!iter) 310 err(EXIT_FAILURE,"dm_list_devices %s",__func__); 311 312 while((target_dict = prop_object_iterator_next(iter)) != NULL){ 313 314 prop_dictionary_get_cstring_nocopy(target_dict, 315 DM_DEV_NAME,(const char **)&name); 316 317 prop_dictionary_get_uint32(target_dict,DM_DEV_DEV,&minor); 318 319 dml->dev = MKDEV(major,minor); 320 321 slen = strlen(name) + 1; 322 rec_size = sizeof(struct dm_name_list) + slen + 1; 323 324 if (rec_size > dmi->data_size) 325 return -ENOMEM; 326 327 dml->next = rec_size; 328 329 strlcpy(dml->name,name,slen); 330 331 odml = dml; 332 333 dml =(struct dm_name_list *)((uint8_t *)dml + rec_size); 334 335 j++; 336 } 337 338 if (odml != NULL) 339 odml->next = 0; 340 } 341 prop_object_iterator_release(iter); 342 return j; 343 } 344 345 /* 346 * Print status of each table, target arguments, start sector, 347 * size and target name. 348 */ 349 static int 350 dm_table_status(prop_dictionary_t dm_dict,struct dm_ioctl *dmi) 351 { 352 struct dm_target_spec *dmts, *odmts; 353 354 prop_array_t targets; 355 prop_dictionary_t target_dict; 356 prop_object_iterator_t iter; 357 358 char *type,*params,*params_start; 359 360 bool prm; 361 size_t j,plen,rec_size,next; 362 363 j = 0; 364 next = 0; 365 params = NULL; 366 odmts = NULL; 367 rec_size = 0; 368 plen = -1; 369 prm = false; 370 371 dmts = (struct dm_target_spec *)((uint8_t *)dmi + dmi->data_start); 372 373 if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ 374 375 iter = prop_array_iterator(targets); 376 if (!iter) 377 err(EXIT_FAILURE,"dm_table_status %s",__func__); 378 379 while((target_dict = prop_object_iterator_next(iter)) != NULL){ 380 381 prop_dictionary_get_cstring_nocopy(target_dict, 382 DM_TABLE_TYPE,(const char **)&type); 383 384 prm = prop_dictionary_get_cstring_nocopy(target_dict, 385 DM_TABLE_PARAMS,(const char **)¶ms); 386 387 prop_dictionary_get_uint64(target_dict,DM_TABLE_START,&dmts->sector_start); 388 prop_dictionary_get_uint64(target_dict,DM_TABLE_LENGTH,&dmts->length); 389 prop_dictionary_get_int32(target_dict,DM_TABLE_STAT,&dmts->status); 390 391 if (prm) 392 plen = strlen(params) + 1; 393 394 rec_size = sizeof(struct dm_target_spec) + plen; 395 396 /* 397 * In linux when copying table status from kernel next is 398 * number of bytes from the start of the first dm_target_spec 399 * structure. I don't know why but, it has to be done this way. 400 */ 401 next += rec_size; 402 403 if (rec_size > dmi->data_size) 404 return -ENOMEM; 405 406 dmts->next = next; 407 408 strlcpy(dmts->target_type, type, DM_MAX_TYPE_NAME); 409 410 params_start = (char *)dmts + sizeof(struct dm_target_spec); 411 412 if (prm) 413 strlcpy(params_start, params, plen); 414 else 415 params_start = "\0"; 416 417 418 odmts = dmts; 419 420 dmts = (struct dm_target_spec *)((uint8_t *)dmts + rec_size); 421 422 j++; 423 424 } 425 426 if (odmts != NULL) 427 odmts->next = 0; 428 } 429 prop_object_iterator_release(iter); 430 431 return j; 432 } 433 434 /* 435 * Print dm device dependiences, get minor/major number for 436 * devices. From kernel I will receive major:minor number of 437 * block device used with target. I have to translate it to 438 * raw device numbers and use them, because all other parts of lvm2 439 * uses raw devices internaly. 440 */ 441 static int 442 dm_dev_deps(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) 443 { 444 struct dm_target_deps *dmtd; 445 struct kinfo_drivers *kd; 446 447 prop_array_t targets; 448 prop_object_iterator_t iter; 449 450 uint32_t major; 451 452 size_t val_len, i, j; 453 454 uint64_t dev_tmp; 455 456 dev_tmp = 0; 457 j = 0; 458 i = 0; 459 460 if (sysctlbyname("kern.drivers",NULL,&val_len,NULL,0) < 0) { 461 printf("sysctlbyname failed"); 462 return 0; 463 } 464 465 if ((kd = malloc (val_len)) == NULL){ 466 printf("malloc kd info error\n"); 467 return 0; 468 } 469 470 if (sysctlbyname("kern.drivers", kd, &val_len, NULL, 0) < 0) { 471 printf("sysctlbyname failed kd"); 472 return 0; 473 } 474 475 dmtd = (struct dm_target_deps *)((uint8_t *)dmi + dmi->data_start); 476 477 if ((targets = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA))){ 478 479 iter = prop_array_iterator(targets); 480 if (!iter) 481 err(EXIT_FAILURE,"dm_target_deps %s", __func__); 482 483 while((prop_object_iterator_next(iter)) != NULL){ 484 485 prop_array_get_uint64(targets, j, &dev_tmp); 486 487 for (i = 0, val_len /= sizeof(*kd); i < val_len; i++){ 488 if (kd[i].d_bmajor == MAJOR(dev_tmp)) { 489 major = kd[i].d_cmajor; 490 break; 491 } 492 } 493 494 dmtd->dev[j] = MKDEV(major,MINOR(dev_tmp)); 495 496 j++; 497 } 498 } 499 500 dmtd->count = j; 501 502 prop_object_iterator_release(iter); 503 504 return j; 505 } 506