1 #include <darwintest.h> 2 #include <signal.h> 3 #include <spawn.h> 4 #include <unistd.h> 5 6 #include <mach/mach.h> 7 #include <mach/mach_types.h> 8 #include <mach/task.h> 9 #include <mach/task_policy.h> 10 11 extern char **environ; 12 13 int task_inspect_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t); 14 int task_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t); 15 int task_name_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t); 16 17 T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true)); 18 19 #if defined(UNENTITLED) 20 21 T_DECL(task_policy_set_task_name, "task_policy_set with task name (not entitled)", T_META_TAG_VM_PREFERRED) 22 { 23 struct task_qos_policy qosinfo = { 24 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 25 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 26 }; 27 task_name_t task_name = TASK_NAME_NULL; 28 29 T_SETUPBEGIN; 30 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(), 31 &task_name), NULL); 32 T_SETUPEND; 33 34 T_ASSERT_MACH_ERROR(task_policy_set(task_name, 35 TASK_BASE_QOS_POLICY, 36 (task_policy_t)&qosinfo, 37 TASK_QOS_POLICY_COUNT), 38 KERN_INVALID_ARGUMENT, NULL); 39 } 40 41 T_DECL(task_policy_set_task, "task_policy_set with task (not entitled)", T_META_TAG_VM_PREFERRED) 42 { 43 struct task_qos_policy qosinfo = { 44 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 45 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 46 }; 47 48 T_ASSERT_MACH_SUCCESS(task_policy_set(mach_task_self(), 49 TASK_BASE_QOS_POLICY, 50 (task_policy_t)&qosinfo, 51 TASK_QOS_POLICY_COUNT), 52 NULL); 53 } 54 55 T_DECL(task_policy_set_inspect, "task_policy_set with task inspect (not entitled)", T_META_TAG_VM_PREFERRED) 56 { 57 struct task_qos_policy qosinfo = { 58 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 59 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 60 }; 61 task_inspect_t task_inspect = TASK_INSPECT_NULL; 62 63 T_SETUPBEGIN; 64 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(), 65 &task_inspect), NULL); 66 T_SETUPEND; 67 68 69 T_ASSERT_MACH_ERROR(task_policy_set(task_inspect, 70 TASK_BASE_QOS_POLICY, 71 (task_policy_t)&qosinfo, 72 TASK_QOS_POLICY_COUNT), 73 KERN_INVALID_ARGUMENT, NULL); 74 } 75 76 T_DECL(task_policy_set_foreign_task, "task_policy_set for foreign task (not entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 77 { 78 struct task_qos_policy qosinfo = { 79 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 80 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 81 }; 82 task_t task = TASK_NULL; 83 kern_return_t ret = KERN_FAILURE; 84 char *args[] = { "sleep", "10", NULL }; 85 pid_t pid = 0; 86 87 T_SETUPBEGIN; 88 89 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 90 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 91 92 T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid, 93 &task), NULL); 94 T_SETUPEND; 95 96 T_ASSERT_MACH_SUCCESS(task_policy_set(task, 97 TASK_BASE_QOS_POLICY, 98 (task_policy_t)&qosinfo, 99 TASK_QOS_POLICY_COUNT), 100 NULL); 101 102 ret = kill(pid, SIGTERM); 103 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 104 } 105 106 T_DECL(task_policy_set_foreign_task_name, "task_policy_set for foreign task name (not entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 107 { 108 struct task_qos_policy qosinfo = { 109 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 110 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 111 }; 112 task_name_t task_name = TASK_NAME_NULL; 113 kern_return_t ret = KERN_FAILURE; 114 char *args[] = { "sleep", "10", NULL }; 115 pid_t pid = 0; 116 117 T_SETUPBEGIN; 118 119 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 120 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 121 122 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid, 123 &task_name), NULL); 124 T_SETUPEND; 125 126 T_ASSERT_MACH_ERROR(task_policy_set(task_name, 127 TASK_BASE_QOS_POLICY, 128 (task_policy_t)&qosinfo, 129 TASK_QOS_POLICY_COUNT), 130 KERN_INVALID_ARGUMENT, NULL); 131 132 ret = kill(pid, SIGTERM); 133 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 134 } 135 136 T_DECL(task_policy_set_foreign_task_inspect, "task_policy_set for foreign task inspect (not entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 137 { 138 struct task_qos_policy qosinfo = { 139 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 140 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 141 }; 142 task_inspect_t task_inspect = TASK_INSPECT_NULL; 143 kern_return_t ret = KERN_FAILURE; 144 char *args[] = { "sleep", "10", NULL }; 145 pid_t pid = 0; 146 147 T_SETUPBEGIN; 148 149 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 150 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 151 152 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid, 153 &task_inspect), NULL); 154 T_SETUPEND; 155 156 T_ASSERT_MACH_ERROR(task_policy_set(task_inspect, 157 TASK_BASE_QOS_POLICY, 158 (task_policy_t)&qosinfo, 159 TASK_QOS_POLICY_COUNT), 160 KERN_INVALID_ARGUMENT, NULL); 161 162 ret = kill(pid, SIGTERM); 163 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 164 } 165 166 T_DECL(task_policy_get_name, "task_policy_get with task name (not entitled)", T_META_TAG_VM_PREFERRED) 167 { 168 task_name_t task_name = TASK_NAME_NULL; 169 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 170 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 171 boolean_t get_default = FALSE; 172 173 T_SETUPBEGIN; 174 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(), 175 &task_name), NULL); 176 T_SETUPEND; 177 178 T_ASSERT_MACH_ERROR(task_policy_get(task_name, 179 TASK_CATEGORY_POLICY, 180 (task_policy_t)role, 181 &count, 182 &get_default), 183 KERN_INVALID_ARGUMENT, NULL); 184 } 185 186 T_DECL(task_policy_get_task, "task_policy_get with task (not entitled)", T_META_TAG_VM_PREFERRED) 187 { 188 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 189 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 190 boolean_t get_default = FALSE; 191 192 T_ASSERT_MACH_SUCCESS(task_policy_get(mach_task_self(), 193 TASK_CATEGORY_POLICY, 194 (task_policy_t)role, 195 &count, 196 &get_default), 197 NULL); 198 } 199 200 T_DECL(task_policy_get_inspect, "task_policy_get with task inspect (not entitled)", T_META_TAG_VM_PREFERRED) 201 { 202 task_inspect_t task_inspect = TASK_INSPECT_NULL; 203 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 204 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 205 boolean_t get_default = FALSE; 206 207 T_SETUPBEGIN; 208 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(), 209 &task_inspect), NULL); 210 T_SETUPEND; 211 212 T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect, 213 TASK_CATEGORY_POLICY, 214 (task_policy_t)role, 215 &count, 216 &get_default), 217 NULL); 218 } 219 220 T_DECL(task_policy_get_foreign_task_inspect, "task_policy_get for foreign task inspect (not entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 221 { 222 task_inspect_t task_inspect = TASK_INSPECT_NULL; 223 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 224 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 225 boolean_t get_default = FALSE; 226 kern_return_t ret = KERN_FAILURE; 227 char *args[] = { "sleep", "10", NULL }; 228 pid_t pid = 0; 229 230 T_SETUPBEGIN; 231 232 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 233 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 234 235 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid, 236 &task_inspect), NULL); 237 T_SETUPEND; 238 239 T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect, 240 TASK_CATEGORY_POLICY, 241 (task_policy_t)role, 242 &count, 243 &get_default), 244 NULL); 245 246 ret = kill(pid, SIGTERM); 247 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 248 } 249 250 T_DECL(task_policy_get_foreign_task, "task_policy_get for foreign task (not entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 251 { 252 task_t task = TASK_NULL; 253 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 254 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 255 boolean_t get_default = FALSE; 256 kern_return_t ret = KERN_FAILURE; 257 char *args[] = { "sleep", "10", NULL }; 258 pid_t pid = 0; 259 260 T_SETUPBEGIN; 261 262 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 263 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 264 265 T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid, 266 &task), NULL); 267 T_SETUPEND; 268 269 T_ASSERT_MACH_SUCCESS(task_policy_get(task, 270 TASK_CATEGORY_POLICY, 271 (task_policy_t)role, 272 &count, 273 &get_default), 274 NULL); 275 276 ret = kill(pid, SIGTERM); 277 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 278 } 279 280 T_DECL(task_policy_get_foreign_task_name, "task_policy_get for foreign task name (not entitled)", T_META_TAG_VM_PREFERRED) 281 { 282 task_name_t task_name = TASK_NAME_NULL; 283 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 284 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 285 boolean_t get_default = FALSE; 286 kern_return_t ret = KERN_FAILURE; 287 char *args[] = { "sleep", "10", NULL }; 288 pid_t pid = 0; 289 290 T_SETUPBEGIN; 291 292 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 293 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 294 295 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid, 296 &task_name), NULL); 297 T_SETUPEND; 298 299 T_ASSERT_MACH_ERROR(task_policy_get(task_name, 300 TASK_CATEGORY_POLICY, 301 (task_policy_t)role, 302 &count, 303 &get_default), 304 KERN_INVALID_ARGUMENT, NULL); 305 306 ret = kill(pid, SIGTERM); 307 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 308 } 309 310 #else /* ENTITLED */ 311 312 T_DECL(task_policy_set_task_name_entitled, "task_policy_set with task name (entitled)", T_META_ASROOT(true), T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 313 { 314 struct task_qos_policy qosinfo = { 315 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 316 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 317 }; 318 task_name_t task_name = TASK_NAME_NULL; 319 320 T_SETUPBEGIN; 321 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(), 322 &task_name), NULL); 323 T_SETUPEND; 324 325 T_ASSERT_MACH_SUCCESS(task_policy_set(task_name, 326 TASK_BASE_QOS_POLICY, 327 (task_policy_t)&qosinfo, 328 TASK_QOS_POLICY_COUNT), 329 NULL); 330 } 331 332 T_DECL(task_policy_set_task_entitled, "task_policy_set with task (entitled)", T_META_TAG_VM_PREFERRED) 333 { 334 struct task_qos_policy qosinfo = { 335 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 336 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 337 }; 338 339 T_ASSERT_MACH_SUCCESS(task_policy_set(mach_task_self(), 340 TASK_BASE_QOS_POLICY, 341 (task_policy_t)&qosinfo, 342 TASK_QOS_POLICY_COUNT), 343 NULL); 344 } 345 346 T_DECL(task_policy_set_inspect_entitled, "task_policy_set with task inspect (entitled)", T_META_TAG_VM_PREFERRED) 347 { 348 struct task_qos_policy qosinfo = { 349 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 350 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 351 }; 352 task_inspect_t task_inspect = TASK_INSPECT_NULL; 353 354 T_SETUPBEGIN; 355 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(), 356 &task_inspect), NULL); 357 T_SETUPEND; 358 359 T_ASSERT_MACH_SUCCESS(task_policy_set(task_inspect, 360 TASK_BASE_QOS_POLICY, 361 (task_policy_t)&qosinfo, 362 TASK_QOS_POLICY_COUNT), 363 NULL); 364 } 365 366 T_DECL(task_policy_set_foreign_task_entitled, "task_policy_set for foreign task (entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 367 { 368 struct task_qos_policy qosinfo = { 369 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 370 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 371 }; 372 task_t task = TASK_NULL; 373 kern_return_t ret = KERN_FAILURE; 374 char *args[] = { "sleep", "10", NULL }; 375 pid_t pid = 0; 376 377 T_SETUPBEGIN; 378 379 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 380 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 381 382 T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid, 383 &task), NULL); 384 T_SETUPEND; 385 386 T_ASSERT_MACH_SUCCESS(task_policy_set(task, 387 TASK_BASE_QOS_POLICY, 388 (task_policy_t)&qosinfo, 389 TASK_QOS_POLICY_COUNT), 390 NULL); 391 392 ret = kill(pid, SIGTERM); 393 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 394 } 395 396 T_DECL(task_policy_set_foreign_task_name_entitled, "task_policy_set for foreign task name (entitled)", T_META_ASROOT(true), T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 397 { 398 struct task_qos_policy qosinfo = { 399 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 400 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 401 }; 402 task_name_t task_name = TASK_NAME_NULL; 403 kern_return_t ret = KERN_FAILURE; 404 char *args[] = { "sleep", "10", NULL }; 405 pid_t pid = 0; 406 407 T_SETUPBEGIN; 408 409 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 410 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 411 412 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid, 413 &task_name), NULL); 414 T_SETUPEND; 415 416 T_ASSERT_MACH_SUCCESS(task_policy_set(task_name, 417 TASK_BASE_QOS_POLICY, 418 (task_policy_t)&qosinfo, 419 TASK_QOS_POLICY_COUNT), 420 NULL); 421 422 ret = kill(pid, SIGTERM); 423 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 424 } 425 426 T_DECL(task_policy_set_foreign_task_inspect_entitled, "task_policy_set for foreign task inspect (entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 427 { 428 struct task_qos_policy qosinfo = { 429 .task_latency_qos_tier = LATENCY_QOS_TIER_0, 430 .task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0, 431 }; 432 task_inspect_t task_inspect = TASK_INSPECT_NULL; 433 kern_return_t ret = KERN_FAILURE; 434 char *args[] = { "sleep", "10", NULL }; 435 pid_t pid = 0; 436 437 T_SETUPBEGIN; 438 439 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 440 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 441 442 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid, 443 &task_inspect), NULL); 444 T_SETUPEND; 445 446 T_ASSERT_MACH_SUCCESS(task_policy_set(task_inspect, 447 TASK_BASE_QOS_POLICY, 448 (task_policy_t)&qosinfo, 449 TASK_QOS_POLICY_COUNT), 450 NULL); 451 452 ret = kill(pid, SIGTERM); 453 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 454 } 455 456 T_DECL(task_policy_get_name_entitled, "task_policy_get with task name (entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 457 { 458 task_name_t task_name = TASK_NAME_NULL; 459 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 460 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 461 boolean_t get_default = FALSE; 462 463 T_SETUPBEGIN; 464 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(), 465 &task_name), NULL); 466 T_SETUPEND; 467 468 T_ASSERT_MACH_SUCCESS(task_policy_get(task_name, 469 TASK_CATEGORY_POLICY, 470 (task_policy_t)role, 471 &count, 472 &get_default), 473 NULL); 474 } 475 476 T_DECL(task_policy_get_task_entitled, "task_policy_get with task (entitled)", T_META_TAG_VM_PREFERRED) 477 { 478 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 479 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 480 boolean_t get_default = FALSE; 481 482 T_ASSERT_MACH_SUCCESS(task_policy_get(mach_task_self(), 483 TASK_CATEGORY_POLICY, 484 (task_policy_t)role, 485 &count, 486 &get_default), 487 NULL); 488 } 489 490 T_DECL(task_policy_get_inspect_entitled, "task_policy_get with task inspect (entitled)", T_META_TAG_VM_PREFERRED) 491 { 492 task_inspect_t task_inspect = TASK_INSPECT_NULL; 493 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 494 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 495 boolean_t get_default = FALSE; 496 497 T_SETUPBEGIN; 498 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(), 499 &task_inspect), NULL); 500 T_SETUPEND; 501 502 T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect, 503 TASK_CATEGORY_POLICY, 504 (task_policy_t)role, 505 &count, 506 &get_default), 507 NULL); 508 } 509 510 T_DECL(task_policy_get_foreign_task_inspect_entitled, "task_policy_get for foreign task inspect (entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 511 { 512 task_inspect_t task_inspect = TASK_INSPECT_NULL; 513 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 514 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 515 boolean_t get_default = FALSE; 516 kern_return_t ret = KERN_FAILURE; 517 char *args[] = { "sleep", "10", NULL }; 518 pid_t pid = 0; 519 520 T_SETUPBEGIN; 521 522 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 523 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 524 525 T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid, 526 &task_inspect), NULL); 527 T_SETUPEND; 528 529 T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect, 530 TASK_CATEGORY_POLICY, 531 (task_policy_t)role, 532 &count, 533 &get_default), 534 NULL); 535 536 ret = kill(pid, SIGTERM); 537 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 538 } 539 540 T_DECL(task_policy_get_foreign_task_entitled, "task_policy_get for foreign task (entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 541 { 542 task_t task = TASK_NULL; 543 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 544 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 545 boolean_t get_default = FALSE; 546 kern_return_t ret = KERN_FAILURE; 547 char *args[] = { "sleep", "10", NULL }; 548 pid_t pid = 0; 549 550 T_SETUPBEGIN; 551 552 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 553 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 554 555 T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid, 556 &task), NULL); 557 T_SETUPEND; 558 559 T_ASSERT_MACH_SUCCESS(task_policy_get(task, 560 TASK_CATEGORY_POLICY, 561 (task_policy_t)role, 562 &count, 563 &get_default), 564 NULL); 565 566 ret = kill(pid, SIGTERM); 567 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 568 } 569 570 T_DECL(task_policy_get_foreign_task_name_entitled, "task_policy_get for foreign task name (entitled)", T_META_ASROOT(true), T_META_TAG_VM_PREFERRED) 571 { 572 task_name_t task_name = TASK_NAME_NULL; 573 struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT]; 574 mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT; 575 boolean_t get_default = FALSE; 576 kern_return_t ret = KERN_FAILURE; 577 char *args[] = { "sleep", "10", NULL }; 578 pid_t pid = 0; 579 580 T_SETUPBEGIN; 581 582 ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ); 583 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10"); 584 585 T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid, 586 &task_name), NULL); 587 T_SETUPEND; 588 589 T_ASSERT_MACH_SUCCESS(task_policy_get(task_name, 590 TASK_CATEGORY_POLICY, 591 (task_policy_t)role, 592 &count, 593 &get_default), 594 NULL); 595 596 ret = kill(pid, SIGTERM); 597 T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep"); 598 } 599 600 #endif /* UNENTITLED */ 601