1 /* $NetBSD: prop_kern.c,v 1.17 2011/09/30 22:08:18 jym Exp $ */ 2 3 /*- 4 * Copyright (c) 2006, 2009 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 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 #if defined(__NetBSD__) 33 34 #include <sys/types.h> 35 #include <sys/ioctl.h> 36 37 #include <prop/proplib.h> 38 39 #if !defined(_KERNEL) && !defined(_STANDALONE) 40 #include <sys/mman.h> 41 #include <errno.h> 42 #include <string.h> 43 #include <stdlib.h> 44 #include <stdio.h> 45 46 #ifdef RUMP_ACTION 47 #include <rump/rump_syscalls.h> 48 #define ioctl(a,b,c) rump_sys_ioctl(a,b,c) 49 #endif 50 51 static int 52 _prop_object_externalize_to_pref(prop_object_t obj, struct plistref *pref, 53 char **bufp) 54 { 55 char *buf; 56 57 switch (prop_object_type(obj)) { 58 case PROP_TYPE_DICTIONARY: 59 buf = prop_dictionary_externalize(obj); 60 break; 61 case PROP_TYPE_ARRAY: 62 buf = prop_array_externalize(obj); 63 break; 64 default: 65 return (ENOTSUP); 66 } 67 if (buf == NULL) { 68 /* Assume we ran out of memory. */ 69 return (ENOMEM); 70 } 71 pref->pref_plist = buf; 72 pref->pref_len = strlen(buf) + 1; 73 74 *bufp = buf; 75 76 return (0); 77 } 78 79 bool 80 prop_array_externalize_to_pref(prop_array_t array, struct plistref *prefp) 81 { 82 char *buf; 83 int rv; 84 85 rv = _prop_object_externalize_to_pref(array, prefp, &buf); 86 if (rv != 0) 87 errno = rv; /* pass up error value in errno */ 88 return (rv == 0); 89 } 90 91 /* 92 * prop_array_externalize_to_pref -- 93 * Externalize an array into a plistref for sending to the kernel. 94 */ 95 int 96 prop_array_send_syscall(prop_array_t array, struct plistref *prefp) 97 { 98 if (prop_array_externalize_to_pref(array, prefp)) 99 return 0; 100 else 101 return errno; 102 } 103 104 bool 105 prop_dictionary_externalize_to_pref(prop_dictionary_t dict, 106 struct plistref *prefp) 107 { 108 char *buf; 109 int rv; 110 111 rv = _prop_object_externalize_to_pref(dict, prefp, &buf); 112 if (rv != 0) 113 errno = rv; /* pass up error value in errno */ 114 return (rv == 0); 115 } 116 117 /* 118 * prop_dictionary_externalize_to_pref -- 119 * Externalize an dictionary into a plistref for sending to the kernel. 120 */ 121 int 122 prop_dictionary_send_syscall(prop_dictionary_t dict, 123 struct plistref *prefp) 124 { 125 if (prop_dictionary_externalize_to_pref(dict, prefp)) 126 return 0; 127 else 128 return errno; 129 } 130 131 static int 132 _prop_object_send_ioctl(prop_object_t obj, int fd, unsigned long cmd) 133 { 134 struct plistref pref; 135 char *buf; 136 int error; 137 138 error = _prop_object_externalize_to_pref(obj, &pref, &buf); 139 if (error) 140 return (error); 141 142 if (ioctl(fd, cmd, &pref) == -1) 143 error = errno; 144 else 145 error = 0; 146 147 free(buf); 148 149 return (error); 150 } 151 152 /* 153 * prop_array_send_ioctl -- 154 * Send an array to the kernel using the specified ioctl. 155 */ 156 int 157 prop_array_send_ioctl(prop_array_t array, int fd, unsigned long cmd) 158 { 159 int rv; 160 161 rv = _prop_object_send_ioctl(array, fd, cmd); 162 if (rv != 0) { 163 errno = rv; /* pass up error value in errno */ 164 return rv; 165 } else 166 return 0; 167 } 168 169 /* 170 * prop_dictionary_send_ioctl -- 171 * Send a dictionary to the kernel using the specified ioctl. 172 */ 173 int 174 prop_dictionary_send_ioctl(prop_dictionary_t dict, int fd, unsigned long cmd) 175 { 176 int rv; 177 178 rv = _prop_object_send_ioctl(dict, fd, cmd); 179 if (rv != 0) { 180 errno = rv; /* pass up error value in errno */ 181 return rv; 182 } else 183 return 0; 184 } 185 186 static int 187 _prop_object_internalize_from_pref(const struct plistref *pref, 188 prop_type_t type, prop_object_t *objp) 189 { 190 prop_object_t obj = NULL; 191 char *buf; 192 int error = 0; 193 194 if (pref->pref_len == 0) { 195 /* 196 * This should never happen; we should always get the XML 197 * for an empty dictionary if it's really empty. 198 */ 199 error = EIO; 200 goto out; 201 } else { 202 buf = pref->pref_plist; 203 buf[pref->pref_len - 1] = '\0'; /* extra insurance */ 204 switch (type) { 205 case PROP_TYPE_DICTIONARY: 206 obj = prop_dictionary_internalize(buf); 207 break; 208 case PROP_TYPE_ARRAY: 209 obj = prop_array_internalize(buf); 210 break; 211 default: 212 error = ENOTSUP; 213 } 214 (void) munmap(buf, pref->pref_len); 215 if (obj == NULL && error == 0) 216 error = EIO; 217 } 218 219 out: 220 if (error == 0) 221 *objp = obj; 222 return (error); 223 } 224 225 /* 226 * prop_array_internalize_from_pref -- 227 * Internalize a pref into a prop_array_t object. 228 */ 229 bool 230 prop_array_internalize_from_pref(const struct plistref *prefp, 231 prop_array_t *arrayp) 232 { 233 int rv; 234 235 rv = _prop_object_internalize_from_pref(prefp, PROP_TYPE_ARRAY, 236 (prop_object_t *)arrayp); 237 if (rv != 0) 238 errno = rv; /* pass up error value in errno */ 239 return (rv == 0); 240 } 241 242 /* 243 * prop_array_recv_syscall -- 244 * Internalize an array received from the kernel as pref. 245 */ 246 int 247 prop_array_recv_syscall(const struct plistref *prefp, 248 prop_array_t *arrayp) 249 { 250 if (prop_array_internalize_from_pref(prefp, arrayp)) 251 return 0; 252 else 253 return errno; 254 } 255 256 /* 257 * prop_dictionary_internalize_from_pref -- 258 * Internalize a pref into a prop_dictionary_t object. 259 */ 260 bool 261 prop_dictionary_internalize_from_pref(const struct plistref *prefp, 262 prop_dictionary_t *dictp) 263 { 264 int rv; 265 266 rv = _prop_object_internalize_from_pref(prefp, PROP_TYPE_DICTIONARY, 267 (prop_object_t *)dictp); 268 if (rv != 0) 269 errno = rv; /* pass up error value in errno */ 270 return (rv == 0); 271 } 272 273 /* 274 * prop_dictionary_recv_syscall -- 275 * Internalize a dictionary received from the kernel as pref. 276 */ 277 int 278 prop_dictionary_recv_syscall(const struct plistref *prefp, 279 prop_dictionary_t *dictp) 280 { 281 if (prop_dictionary_internalize_from_pref(prefp, dictp)) 282 return 0; 283 else 284 return errno; 285 } 286 287 288 /* 289 * prop_array_recv_ioctl -- 290 * Receive an array from the kernel using the specified ioctl. 291 */ 292 int 293 prop_array_recv_ioctl(int fd, unsigned long cmd, prop_array_t *arrayp) 294 { 295 int rv; 296 struct plistref pref; 297 298 rv = ioctl(fd, cmd, &pref); 299 if (rv == -1) 300 return errno; 301 302 rv = _prop_object_internalize_from_pref(&pref, PROP_TYPE_ARRAY, 303 (prop_object_t *)arrayp); 304 if (rv != 0) { 305 errno = rv; /* pass up error value in errno */ 306 return rv; 307 } else 308 return 0; 309 } 310 311 /* 312 * prop_dictionary_recv_ioctl -- 313 * Receive a dictionary from the kernel using the specified ioctl. 314 */ 315 int 316 prop_dictionary_recv_ioctl(int fd, unsigned long cmd, prop_dictionary_t *dictp) 317 { 318 int rv; 319 struct plistref pref; 320 321 rv = ioctl(fd, cmd, &pref); 322 if (rv == -1) 323 return errno; 324 325 rv = _prop_object_internalize_from_pref(&pref, PROP_TYPE_DICTIONARY, 326 (prop_object_t *)dictp); 327 if (rv != 0) { 328 errno = rv; /* pass up error value in errno */ 329 return rv; 330 } else 331 return 0; 332 } 333 334 /* 335 * prop_dictionary_sendrecv_ioctl -- 336 * Combination send/receive a dictionary to/from the kernel using 337 * the specified ioctl. 338 */ 339 int 340 prop_dictionary_sendrecv_ioctl(prop_dictionary_t dict, int fd, 341 unsigned long cmd, prop_dictionary_t *dictp) 342 { 343 struct plistref pref; 344 char *buf; 345 int error; 346 347 error = _prop_object_externalize_to_pref(dict, &pref, &buf); 348 if (error != 0) { 349 errno = error; 350 return error; 351 } 352 353 if (ioctl(fd, cmd, &pref) == -1) 354 error = errno; 355 else 356 error = 0; 357 358 free(buf); 359 360 if (error != 0) 361 return error; 362 363 error = _prop_object_internalize_from_pref(&pref, PROP_TYPE_DICTIONARY, 364 (prop_object_t *)dictp); 365 if (error != 0) { 366 errno = error; /* pass up error value in errno */ 367 return error; 368 } else 369 return 0; 370 } 371 #endif /* !_KERNEL && !_STANDALONE */ 372 373 #if defined(_KERNEL) 374 #include <sys/param.h> 375 #include <sys/mman.h> 376 #include <sys/errno.h> 377 #include <sys/malloc.h> 378 #include <sys/systm.h> 379 #include <sys/proc.h> 380 #include <sys/resource.h> 381 #include <sys/pool.h> 382 383 #include <uvm/uvm.h> 384 385 #include "prop_object_impl.h" 386 387 /* Arbitrary limit ioctl input to 64KB */ 388 unsigned int prop_object_copyin_limit = 65536; 389 390 /* initialize proplib for use in the kernel */ 391 void 392 prop_kern_init(void) 393 { 394 __link_set_decl(prop_linkpools, struct prop_pool_init); 395 struct prop_pool_init * const *pi; 396 397 __link_set_foreach(pi, prop_linkpools) 398 pool_init((*pi)->pp, (*pi)->size, 0, 0, 0, (*pi)->wchan, 399 &pool_allocator_nointr, IPL_NONE); 400 } 401 402 static int 403 _prop_object_copyin(const struct plistref *pref, const prop_type_t type, 404 prop_object_t *objp) 405 { 406 prop_object_t obj = NULL; 407 char *buf; 408 int error; 409 410 /* 411 * Allocate an extra byte so we can guarantee NUL-termination. 412 * 413 * Allow malloc to fail in case pmap would be exhausted. 414 */ 415 buf = malloc(pref->pref_len + 1, M_TEMP, M_WAITOK | M_CANFAIL); 416 if (buf == NULL) 417 return (ENOMEM); 418 error = copyin(pref->pref_plist, buf, pref->pref_len); 419 if (error) { 420 free(buf, M_TEMP); 421 return (error); 422 } 423 buf[pref->pref_len] = '\0'; 424 425 switch (type) { 426 case PROP_TYPE_ARRAY: 427 obj = prop_array_internalize(buf); 428 break; 429 case PROP_TYPE_DICTIONARY: 430 obj = prop_dictionary_internalize(buf); 431 break; 432 default: 433 error = ENOTSUP; 434 } 435 436 free(buf, M_TEMP); 437 if (obj == NULL) { 438 if (error == 0) 439 error = EIO; 440 } else { 441 *objp = obj; 442 } 443 return (error); 444 } 445 446 447 static int 448 _prop_object_copyin_ioctl(const struct plistref *pref, const prop_type_t type, 449 const u_long cmd, prop_object_t *objp) 450 { 451 if ((cmd & IOC_IN) == 0) 452 return (EFAULT); 453 454 return _prop_object_copyin(pref, type, objp); 455 } 456 457 /* 458 * prop_array_copyin -- 459 * Copy in an array passed as a syscall arg. 460 */ 461 int 462 prop_array_copyin(const struct plistref *pref, prop_array_t *arrayp) 463 { 464 return (_prop_object_copyin(pref, PROP_TYPE_ARRAY, 465 (prop_object_t *)arrayp)); 466 } 467 468 /* 469 * prop_dictionary_copyin -- 470 * Copy in a dictionary passed as a syscall arg. 471 */ 472 int 473 prop_dictionary_copyin(const struct plistref *pref, prop_dictionary_t *dictp) 474 { 475 return (_prop_object_copyin(pref, PROP_TYPE_DICTIONARY, 476 (prop_object_t *)dictp)); 477 } 478 479 480 /* 481 * prop_array_copyin_ioctl -- 482 * Copy in an array send with an ioctl. 483 */ 484 int 485 prop_array_copyin_ioctl(const struct plistref *pref, const u_long cmd, 486 prop_array_t *arrayp) 487 { 488 return (_prop_object_copyin_ioctl(pref, PROP_TYPE_ARRAY, 489 cmd, (prop_object_t *)arrayp)); 490 } 491 492 /* 493 * prop_dictionary_copyin_ioctl -- 494 * Copy in a dictionary sent with an ioctl. 495 */ 496 int 497 prop_dictionary_copyin_ioctl(const struct plistref *pref, const u_long cmd, 498 prop_dictionary_t *dictp) 499 { 500 return (_prop_object_copyin_ioctl(pref, PROP_TYPE_DICTIONARY, 501 cmd, (prop_object_t *)dictp)); 502 } 503 504 static int 505 _prop_object_copyout(struct plistref *pref, prop_object_t obj) 506 { 507 struct lwp *l = curlwp; /* XXX */ 508 struct proc *p = l->l_proc; 509 char *buf; 510 size_t len, rlen; 511 int error = 0; 512 vaddr_t uaddr; 513 514 switch (prop_object_type(obj)) { 515 case PROP_TYPE_ARRAY: 516 buf = prop_array_externalize(obj); 517 break; 518 case PROP_TYPE_DICTIONARY: 519 buf = prop_dictionary_externalize(obj); 520 break; 521 default: 522 return (ENOTSUP); 523 } 524 if (buf == NULL) 525 return (ENOMEM); 526 527 len = strlen(buf) + 1; 528 rlen = round_page(len); 529 530 /* 531 * See sys_mmap() in sys/uvm/uvm_mmap.c. 532 * Let's act as if we were calling mmap(0, ...) 533 */ 534 uaddr = p->p_emul->e_vm_default_addr(p, 535 (vaddr_t)p->p_vmspace->vm_daddr, rlen); 536 537 error = uvm_mmap(&p->p_vmspace->vm_map, 538 &uaddr, rlen, 539 VM_PROT_READ|VM_PROT_WRITE, 540 VM_PROT_READ|VM_PROT_WRITE, 541 MAP_PRIVATE|MAP_ANON, 542 NULL, 0, 543 p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur); 544 545 if (error == 0) { 546 error = copyout(buf, (char *)uaddr, len); 547 if (error == 0) { 548 pref->pref_plist = (char *)uaddr; 549 pref->pref_len = len; 550 } 551 } 552 553 free(buf, M_TEMP); 554 555 return (error); 556 } 557 558 /* 559 * prop_array_copyout -- 560 * Copy out an array to a syscall arg. 561 */ 562 int 563 prop_array_copyout(struct plistref *pref, prop_array_t array) 564 { 565 return (_prop_object_copyout(pref, array)); 566 } 567 568 /* 569 * prop_dictionary_copyout -- 570 * Copy out a dictionary to a syscall arg. 571 */ 572 int 573 prop_dictionary_copyout(struct plistref *pref, prop_dictionary_t dict) 574 { 575 return (_prop_object_copyout(pref, dict)); 576 } 577 578 static int 579 _prop_object_copyout_ioctl(struct plistref *pref, const u_long cmd, 580 prop_object_t obj) 581 { 582 if ((cmd & IOC_OUT) == 0) 583 return (EFAULT); 584 return _prop_object_copyout(pref, obj); 585 } 586 587 588 /* 589 * prop_array_copyout_ioctl -- 590 * Copy out an array being received with an ioctl. 591 */ 592 int 593 prop_array_copyout_ioctl(struct plistref *pref, const u_long cmd, 594 prop_array_t array) 595 { 596 return (_prop_object_copyout_ioctl(pref, cmd, array)); 597 } 598 599 /* 600 * prop_dictionary_copyout_ioctl -- 601 * Copy out a dictionary being received with an ioctl. 602 */ 603 int 604 prop_dictionary_copyout_ioctl(struct plistref *pref, const u_long cmd, 605 prop_dictionary_t dict) 606 { 607 return ( 608 _prop_object_copyout_ioctl(pref, cmd, dict)); 609 } 610 #endif /* _KERNEL */ 611 612 #endif /* __NetBSD__ */ 613