1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Generic pidhash and scalable, time-bounded PID allocator 4 * 5 * (C) 2002-2003 Nadia Yvette Chambers, IBM 6 * (C) 2004 Nadia Yvette Chambers, Oracle 7 * (C) 2002-2004 Ingo Molnar, Red Hat 8 * 9 * pid-structures are backing objects for tasks sharing a given ID to chain 10 * against. There is very little to them aside from hashing them and 11 * parking tasks using given ID's on a list. 12 * 13 * The hash is always changed with the tasklist_lock write-acquired, 14 * and the hash is only accessed with the tasklist_lock at least 15 * read-acquired, so there's no additional SMP locking needed here. 16 * 17 * We have a list of bitmap pages, which bitmaps represent the PID space. 18 * Allocating and freeing PIDs is completely lockless. The worst-case 19 * allocation scenario when all but one out of 1 million PIDs possible are 20 * allocated already: the scanning of 32 list entries and at most PAGE_SIZE 21 * bytes. The typical fastpath is a single successful setbit. Freeing is O(1). 22 * 23 * Pid namespaces: 24 * (C) 2007 Pavel Emelyanov <xemul@openvz.org>, OpenVZ, SWsoft Inc. 25 * (C) 2007 Sukadev Bhattiprolu <sukadev@us.ibm.com>, IBM 26 * Many thanks to Oleg Nesterov for comments and help 27 * 28 */ 29 30 #include <linux/mm.h> 31 #include <linux/export.h> 32 #include <linux/slab.h> 33 #include <linux/init.h> 34 #include <linux/rculist.h> 35 #include <linux/memblock.h> 36 #include <linux/pid_namespace.h> 37 #include <linux/init_task.h> 38 #include <linux/syscalls.h> 39 #include <linux/proc_ns.h> 40 #include <linux/refcount.h> 41 #include <linux/anon_inodes.h> 42 #include <linux/sched/signal.h> 43 #include <linux/sched/task.h> 44 #include <linux/idr.h> 45 #include <net/sock.h> 46 #include <uapi/linux/pidfd.h> 47 48 struct pid init_struct_pid = { 49 .count = REFCOUNT_INIT(1), 50 .tasks = { 51 { .first = NULL }, 52 { .first = NULL }, 53 { .first = NULL }, 54 }, 55 .level = 0, 56 .numbers = { { 57 .nr = 0, 58 .ns = &init_pid_ns, 59 }, } 60 }; 61 62 int pid_max = PID_MAX_DEFAULT; 63 64 #define RESERVED_PIDS 300 65 66 int pid_max_min = RESERVED_PIDS + 1; 67 int pid_max_max = PID_MAX_LIMIT; 68 69 /* 70 * PID-map pages start out as NULL, they get allocated upon 71 * first use and are never deallocated. This way a low pid_max 72 * value does not cause lots of bitmaps to be allocated, but 73 * the scheme scales to up to 4 million PIDs, runtime. 74 */ 75 struct pid_namespace init_pid_ns = { 76 .ns.count = REFCOUNT_INIT(2), 77 .idr = IDR_INIT(init_pid_ns.idr), 78 .pid_allocated = PIDNS_ADDING, 79 .level = 0, 80 .child_reaper = &init_task, 81 .user_ns = &init_user_ns, 82 .ns.inum = PROC_PID_INIT_INO, 83 #ifdef CONFIG_PID_NS 84 .ns.ops = &pidns_operations, 85 #endif 86 }; 87 EXPORT_SYMBOL_GPL(init_pid_ns); 88 89 /* 90 * Note: disable interrupts while the pidmap_lock is held as an 91 * interrupt might come in and do read_lock(&tasklist_lock). 92 * 93 * If we don't disable interrupts there is a nasty deadlock between 94 * detach_pid()->free_pid() and another cpu that does 95 * spin_lock(&pidmap_lock) followed by an interrupt routine that does 96 * read_lock(&tasklist_lock); 97 * 98 * After we clean up the tasklist_lock and know there are no 99 * irq handlers that take it we can leave the interrupts enabled. 100 * For now it is easier to be safe than to prove it can't happen. 101 */ 102 103 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(pidmap_lock); 104 105 void put_pid(struct pid *pid) 106 { 107 struct pid_namespace *ns; 108 109 if (!pid) 110 return; 111 112 ns = pid->numbers[pid->level].ns; 113 if (refcount_dec_and_test(&pid->count)) { 114 kmem_cache_free(ns->pid_cachep, pid); 115 put_pid_ns(ns); 116 } 117 } 118 EXPORT_SYMBOL_GPL(put_pid); 119 120 static void delayed_put_pid(struct rcu_head *rhp) 121 { 122 struct pid *pid = container_of(rhp, struct pid, rcu); 123 put_pid(pid); 124 } 125 126 void free_pid(struct pid *pid) 127 { 128 /* We can be called with write_lock_irq(&tasklist_lock) held */ 129 int i; 130 unsigned long flags; 131 132 spin_lock_irqsave(&pidmap_lock, flags); 133 for (i = 0; i <= pid->level; i++) { 134 struct upid *upid = pid->numbers + i; 135 struct pid_namespace *ns = upid->ns; 136 switch (--ns->pid_allocated) { 137 case 2: 138 case 1: 139 /* When all that is left in the pid namespace 140 * is the reaper wake up the reaper. The reaper 141 * may be sleeping in zap_pid_ns_processes(). 142 */ 143 wake_up_process(ns->child_reaper); 144 break; 145 case PIDNS_ADDING: 146 /* Handle a fork failure of the first process */ 147 WARN_ON(ns->child_reaper); 148 ns->pid_allocated = 0; 149 break; 150 } 151 152 idr_remove(&ns->idr, upid->nr); 153 } 154 spin_unlock_irqrestore(&pidmap_lock, flags); 155 156 call_rcu(&pid->rcu, delayed_put_pid); 157 } 158 159 struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid, 160 size_t set_tid_size) 161 { 162 struct pid *pid; 163 enum pid_type type; 164 int i, nr; 165 struct pid_namespace *tmp; 166 struct upid *upid; 167 int retval = -ENOMEM; 168 169 /* 170 * set_tid_size contains the size of the set_tid array. Starting at 171 * the most nested currently active PID namespace it tells alloc_pid() 172 * which PID to set for a process in that most nested PID namespace 173 * up to set_tid_size PID namespaces. It does not have to set the PID 174 * for a process in all nested PID namespaces but set_tid_size must 175 * never be greater than the current ns->level + 1. 176 */ 177 if (set_tid_size > ns->level + 1) 178 return ERR_PTR(-EINVAL); 179 180 pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL); 181 if (!pid) 182 return ERR_PTR(retval); 183 184 tmp = ns; 185 pid->level = ns->level; 186 187 for (i = ns->level; i >= 0; i--) { 188 int tid = 0; 189 190 if (set_tid_size) { 191 tid = set_tid[ns->level - i]; 192 193 retval = -EINVAL; 194 if (tid < 1 || tid >= pid_max) 195 goto out_free; 196 /* 197 * Also fail if a PID != 1 is requested and 198 * no PID 1 exists. 199 */ 200 if (tid != 1 && !tmp->child_reaper) 201 goto out_free; 202 retval = -EPERM; 203 if (!checkpoint_restore_ns_capable(tmp->user_ns)) 204 goto out_free; 205 set_tid_size--; 206 } 207 208 idr_preload(GFP_KERNEL); 209 spin_lock_irq(&pidmap_lock); 210 211 if (tid) { 212 nr = idr_alloc(&tmp->idr, NULL, tid, 213 tid + 1, GFP_ATOMIC); 214 /* 215 * If ENOSPC is returned it means that the PID is 216 * alreay in use. Return EEXIST in that case. 217 */ 218 if (nr == -ENOSPC) 219 nr = -EEXIST; 220 } else { 221 int pid_min = 1; 222 /* 223 * init really needs pid 1, but after reaching the 224 * maximum wrap back to RESERVED_PIDS 225 */ 226 if (idr_get_cursor(&tmp->idr) > RESERVED_PIDS) 227 pid_min = RESERVED_PIDS; 228 229 /* 230 * Store a null pointer so find_pid_ns does not find 231 * a partially initialized PID (see below). 232 */ 233 nr = idr_alloc_cyclic(&tmp->idr, NULL, pid_min, 234 pid_max, GFP_ATOMIC); 235 } 236 spin_unlock_irq(&pidmap_lock); 237 idr_preload_end(); 238 239 if (nr < 0) { 240 retval = (nr == -ENOSPC) ? -EAGAIN : nr; 241 goto out_free; 242 } 243 244 pid->numbers[i].nr = nr; 245 pid->numbers[i].ns = tmp; 246 tmp = tmp->parent; 247 } 248 249 /* 250 * ENOMEM is not the most obvious choice especially for the case 251 * where the child subreaper has already exited and the pid 252 * namespace denies the creation of any new processes. But ENOMEM 253 * is what we have exposed to userspace for a long time and it is 254 * documented behavior for pid namespaces. So we can't easily 255 * change it even if there were an error code better suited. 256 */ 257 retval = -ENOMEM; 258 259 get_pid_ns(ns); 260 refcount_set(&pid->count, 1); 261 spin_lock_init(&pid->lock); 262 for (type = 0; type < PIDTYPE_MAX; ++type) 263 INIT_HLIST_HEAD(&pid->tasks[type]); 264 265 init_waitqueue_head(&pid->wait_pidfd); 266 INIT_HLIST_HEAD(&pid->inodes); 267 268 upid = pid->numbers + ns->level; 269 spin_lock_irq(&pidmap_lock); 270 if (!(ns->pid_allocated & PIDNS_ADDING)) 271 goto out_unlock; 272 for ( ; upid >= pid->numbers; --upid) { 273 /* Make the PID visible to find_pid_ns. */ 274 idr_replace(&upid->ns->idr, pid, upid->nr); 275 upid->ns->pid_allocated++; 276 } 277 spin_unlock_irq(&pidmap_lock); 278 279 return pid; 280 281 out_unlock: 282 spin_unlock_irq(&pidmap_lock); 283 put_pid_ns(ns); 284 285 out_free: 286 spin_lock_irq(&pidmap_lock); 287 while (++i <= ns->level) { 288 upid = pid->numbers + i; 289 idr_remove(&upid->ns->idr, upid->nr); 290 } 291 292 /* On failure to allocate the first pid, reset the state */ 293 if (ns->pid_allocated == PIDNS_ADDING) 294 idr_set_cursor(&ns->idr, 0); 295 296 spin_unlock_irq(&pidmap_lock); 297 298 kmem_cache_free(ns->pid_cachep, pid); 299 return ERR_PTR(retval); 300 } 301 302 void disable_pid_allocation(struct pid_namespace *ns) 303 { 304 spin_lock_irq(&pidmap_lock); 305 ns->pid_allocated &= ~PIDNS_ADDING; 306 spin_unlock_irq(&pidmap_lock); 307 } 308 309 struct pid *find_pid_ns(int nr, struct pid_namespace *ns) 310 { 311 return idr_find(&ns->idr, nr); 312 } 313 EXPORT_SYMBOL_GPL(find_pid_ns); 314 315 struct pid *find_vpid(int nr) 316 { 317 return find_pid_ns(nr, task_active_pid_ns(current)); 318 } 319 EXPORT_SYMBOL_GPL(find_vpid); 320 321 static struct pid **task_pid_ptr(struct task_struct *task, enum pid_type type) 322 { 323 return (type == PIDTYPE_PID) ? 324 &task->thread_pid : 325 &task->signal->pids[type]; 326 } 327 328 /* 329 * attach_pid() must be called with the tasklist_lock write-held. 330 */ 331 void attach_pid(struct task_struct *task, enum pid_type type) 332 { 333 struct pid *pid = *task_pid_ptr(task, type); 334 hlist_add_head_rcu(&task->pid_links[type], &pid->tasks[type]); 335 } 336 337 static void __change_pid(struct task_struct *task, enum pid_type type, 338 struct pid *new) 339 { 340 struct pid **pid_ptr = task_pid_ptr(task, type); 341 struct pid *pid; 342 int tmp; 343 344 pid = *pid_ptr; 345 346 hlist_del_rcu(&task->pid_links[type]); 347 *pid_ptr = new; 348 349 for (tmp = PIDTYPE_MAX; --tmp >= 0; ) 350 if (pid_has_task(pid, tmp)) 351 return; 352 353 free_pid(pid); 354 } 355 356 void detach_pid(struct task_struct *task, enum pid_type type) 357 { 358 __change_pid(task, type, NULL); 359 } 360 361 void change_pid(struct task_struct *task, enum pid_type type, 362 struct pid *pid) 363 { 364 __change_pid(task, type, pid); 365 attach_pid(task, type); 366 } 367 368 void exchange_tids(struct task_struct *left, struct task_struct *right) 369 { 370 struct pid *pid1 = left->thread_pid; 371 struct pid *pid2 = right->thread_pid; 372 struct hlist_head *head1 = &pid1->tasks[PIDTYPE_PID]; 373 struct hlist_head *head2 = &pid2->tasks[PIDTYPE_PID]; 374 375 /* Swap the single entry tid lists */ 376 hlists_swap_heads_rcu(head1, head2); 377 378 /* Swap the per task_struct pid */ 379 rcu_assign_pointer(left->thread_pid, pid2); 380 rcu_assign_pointer(right->thread_pid, pid1); 381 382 /* Swap the cached value */ 383 WRITE_ONCE(left->pid, pid_nr(pid2)); 384 WRITE_ONCE(right->pid, pid_nr(pid1)); 385 } 386 387 /* transfer_pid is an optimization of attach_pid(new), detach_pid(old) */ 388 void transfer_pid(struct task_struct *old, struct task_struct *new, 389 enum pid_type type) 390 { 391 if (type == PIDTYPE_PID) 392 new->thread_pid = old->thread_pid; 393 hlist_replace_rcu(&old->pid_links[type], &new->pid_links[type]); 394 } 395 396 struct task_struct *pid_task(struct pid *pid, enum pid_type type) 397 { 398 struct task_struct *result = NULL; 399 if (pid) { 400 struct hlist_node *first; 401 first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]), 402 lockdep_tasklist_lock_is_held()); 403 if (first) 404 result = hlist_entry(first, struct task_struct, pid_links[(type)]); 405 } 406 return result; 407 } 408 EXPORT_SYMBOL(pid_task); 409 410 /* 411 * Must be called under rcu_read_lock(). 412 */ 413 struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns) 414 { 415 RCU_LOCKDEP_WARN(!rcu_read_lock_held(), 416 "find_task_by_pid_ns() needs rcu_read_lock() protection"); 417 return pid_task(find_pid_ns(nr, ns), PIDTYPE_PID); 418 } 419 420 struct task_struct *find_task_by_vpid(pid_t vnr) 421 { 422 return find_task_by_pid_ns(vnr, task_active_pid_ns(current)); 423 } 424 425 struct task_struct *find_get_task_by_vpid(pid_t nr) 426 { 427 struct task_struct *task; 428 429 rcu_read_lock(); 430 task = find_task_by_vpid(nr); 431 if (task) 432 get_task_struct(task); 433 rcu_read_unlock(); 434 435 return task; 436 } 437 438 struct pid *get_task_pid(struct task_struct *task, enum pid_type type) 439 { 440 struct pid *pid; 441 rcu_read_lock(); 442 pid = get_pid(rcu_dereference(*task_pid_ptr(task, type))); 443 rcu_read_unlock(); 444 return pid; 445 } 446 EXPORT_SYMBOL_GPL(get_task_pid); 447 448 struct task_struct *get_pid_task(struct pid *pid, enum pid_type type) 449 { 450 struct task_struct *result; 451 rcu_read_lock(); 452 result = pid_task(pid, type); 453 if (result) 454 get_task_struct(result); 455 rcu_read_unlock(); 456 return result; 457 } 458 EXPORT_SYMBOL_GPL(get_pid_task); 459 460 struct pid *find_get_pid(pid_t nr) 461 { 462 struct pid *pid; 463 464 rcu_read_lock(); 465 pid = get_pid(find_vpid(nr)); 466 rcu_read_unlock(); 467 468 return pid; 469 } 470 EXPORT_SYMBOL_GPL(find_get_pid); 471 472 pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns) 473 { 474 struct upid *upid; 475 pid_t nr = 0; 476 477 if (pid && ns->level <= pid->level) { 478 upid = &pid->numbers[ns->level]; 479 if (upid->ns == ns) 480 nr = upid->nr; 481 } 482 return nr; 483 } 484 EXPORT_SYMBOL_GPL(pid_nr_ns); 485 486 pid_t pid_vnr(struct pid *pid) 487 { 488 return pid_nr_ns(pid, task_active_pid_ns(current)); 489 } 490 EXPORT_SYMBOL_GPL(pid_vnr); 491 492 pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type, 493 struct pid_namespace *ns) 494 { 495 pid_t nr = 0; 496 497 rcu_read_lock(); 498 if (!ns) 499 ns = task_active_pid_ns(current); 500 nr = pid_nr_ns(rcu_dereference(*task_pid_ptr(task, type)), ns); 501 rcu_read_unlock(); 502 503 return nr; 504 } 505 EXPORT_SYMBOL(__task_pid_nr_ns); 506 507 struct pid_namespace *task_active_pid_ns(struct task_struct *tsk) 508 { 509 return ns_of_pid(task_pid(tsk)); 510 } 511 EXPORT_SYMBOL_GPL(task_active_pid_ns); 512 513 /* 514 * Used by proc to find the first pid that is greater than or equal to nr. 515 * 516 * If there is a pid at nr this function is exactly the same as find_pid_ns. 517 */ 518 struct pid *find_ge_pid(int nr, struct pid_namespace *ns) 519 { 520 return idr_get_next(&ns->idr, &nr); 521 } 522 523 struct pid *pidfd_get_pid(unsigned int fd, unsigned int *flags) 524 { 525 struct fd f; 526 struct pid *pid; 527 528 f = fdget(fd); 529 if (!f.file) 530 return ERR_PTR(-EBADF); 531 532 pid = pidfd_pid(f.file); 533 if (!IS_ERR(pid)) { 534 get_pid(pid); 535 *flags = f.file->f_flags; 536 } 537 538 fdput(f); 539 return pid; 540 } 541 542 /** 543 * pidfd_get_task() - Get the task associated with a pidfd 544 * 545 * @pidfd: pidfd for which to get the task 546 * @flags: flags associated with this pidfd 547 * 548 * Return the task associated with @pidfd. The function takes a reference on 549 * the returned task. The caller is responsible for releasing that reference. 550 * 551 * Currently, the process identified by @pidfd is always a thread-group leader. 552 * This restriction currently exists for all aspects of pidfds including pidfd 553 * creation (CLONE_PIDFD cannot be used with CLONE_THREAD) and pidfd polling 554 * (only supports thread group leaders). 555 * 556 * Return: On success, the task_struct associated with the pidfd. 557 * On error, a negative errno number will be returned. 558 */ 559 struct task_struct *pidfd_get_task(int pidfd, unsigned int *flags) 560 { 561 unsigned int f_flags; 562 struct pid *pid; 563 struct task_struct *task; 564 565 pid = pidfd_get_pid(pidfd, &f_flags); 566 if (IS_ERR(pid)) 567 return ERR_CAST(pid); 568 569 task = get_pid_task(pid, PIDTYPE_TGID); 570 put_pid(pid); 571 if (!task) 572 return ERR_PTR(-ESRCH); 573 574 *flags = f_flags; 575 return task; 576 } 577 578 /** 579 * pidfd_create() - Create a new pid file descriptor. 580 * 581 * @pid: struct pid that the pidfd will reference 582 * @flags: flags to pass 583 * 584 * This creates a new pid file descriptor with the O_CLOEXEC flag set. 585 * 586 * Note, that this function can only be called after the fd table has 587 * been unshared to avoid leaking the pidfd to the new process. 588 * 589 * This symbol should not be explicitly exported to loadable modules. 590 * 591 * Return: On success, a cloexec pidfd is returned. 592 * On error, a negative errno number will be returned. 593 */ 594 int pidfd_create(struct pid *pid, unsigned int flags) 595 { 596 int fd; 597 598 if (!pid || !pid_has_task(pid, PIDTYPE_TGID)) 599 return -EINVAL; 600 601 if (flags & ~(O_NONBLOCK | O_RDWR | O_CLOEXEC)) 602 return -EINVAL; 603 604 fd = anon_inode_getfd("[pidfd]", &pidfd_fops, get_pid(pid), 605 flags | O_RDWR | O_CLOEXEC); 606 if (fd < 0) 607 put_pid(pid); 608 609 return fd; 610 } 611 612 /** 613 * pidfd_open() - Open new pid file descriptor. 614 * 615 * @pid: pid for which to retrieve a pidfd 616 * @flags: flags to pass 617 * 618 * This creates a new pid file descriptor with the O_CLOEXEC flag set for 619 * the process identified by @pid. Currently, the process identified by 620 * @pid must be a thread-group leader. This restriction currently exists 621 * for all aspects of pidfds including pidfd creation (CLONE_PIDFD cannot 622 * be used with CLONE_THREAD) and pidfd polling (only supports thread group 623 * leaders). 624 * 625 * Return: On success, a cloexec pidfd is returned. 626 * On error, a negative errno number will be returned. 627 */ 628 SYSCALL_DEFINE2(pidfd_open, pid_t, pid, unsigned int, flags) 629 { 630 int fd; 631 struct pid *p; 632 633 if (flags & ~PIDFD_NONBLOCK) 634 return -EINVAL; 635 636 if (pid <= 0) 637 return -EINVAL; 638 639 p = find_get_pid(pid); 640 if (!p) 641 return -ESRCH; 642 643 fd = pidfd_create(p, flags); 644 645 put_pid(p); 646 return fd; 647 } 648 649 void __init pid_idr_init(void) 650 { 651 /* Verify no one has done anything silly: */ 652 BUILD_BUG_ON(PID_MAX_LIMIT >= PIDNS_ADDING); 653 654 /* bump default and minimum pid_max based on number of cpus */ 655 pid_max = min(pid_max_max, max_t(int, pid_max, 656 PIDS_PER_CPU_DEFAULT * num_possible_cpus())); 657 pid_max_min = max_t(int, pid_max_min, 658 PIDS_PER_CPU_MIN * num_possible_cpus()); 659 pr_info("pid_max: default: %u minimum: %u\n", pid_max, pid_max_min); 660 661 idr_init(&init_pid_ns.idr); 662 663 init_pid_ns.pid_cachep = KMEM_CACHE(pid, 664 SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT); 665 } 666 667 static struct file *__pidfd_fget(struct task_struct *task, int fd) 668 { 669 struct file *file; 670 int ret; 671 672 ret = down_read_killable(&task->signal->exec_update_lock); 673 if (ret) 674 return ERR_PTR(ret); 675 676 if (ptrace_may_access(task, PTRACE_MODE_ATTACH_REALCREDS)) 677 file = fget_task(task, fd); 678 else 679 file = ERR_PTR(-EPERM); 680 681 up_read(&task->signal->exec_update_lock); 682 683 return file ?: ERR_PTR(-EBADF); 684 } 685 686 static int pidfd_getfd(struct pid *pid, int fd) 687 { 688 struct task_struct *task; 689 struct file *file; 690 int ret; 691 692 task = get_pid_task(pid, PIDTYPE_PID); 693 if (!task) 694 return -ESRCH; 695 696 file = __pidfd_fget(task, fd); 697 put_task_struct(task); 698 if (IS_ERR(file)) 699 return PTR_ERR(file); 700 701 ret = receive_fd(file, O_CLOEXEC); 702 fput(file); 703 704 return ret; 705 } 706 707 /** 708 * sys_pidfd_getfd() - Get a file descriptor from another process 709 * 710 * @pidfd: the pidfd file descriptor of the process 711 * @fd: the file descriptor number to get 712 * @flags: flags on how to get the fd (reserved) 713 * 714 * This syscall gets a copy of a file descriptor from another process 715 * based on the pidfd, and file descriptor number. It requires that 716 * the calling process has the ability to ptrace the process represented 717 * by the pidfd. The process which is having its file descriptor copied 718 * is otherwise unaffected. 719 * 720 * Return: On success, a cloexec file descriptor is returned. 721 * On error, a negative errno number will be returned. 722 */ 723 SYSCALL_DEFINE3(pidfd_getfd, int, pidfd, int, fd, 724 unsigned int, flags) 725 { 726 struct pid *pid; 727 struct fd f; 728 int ret; 729 730 /* flags is currently unused - make sure it's unset */ 731 if (flags) 732 return -EINVAL; 733 734 f = fdget(pidfd); 735 if (!f.file) 736 return -EBADF; 737 738 pid = pidfd_pid(f.file); 739 if (IS_ERR(pid)) 740 ret = PTR_ERR(pid); 741 else 742 ret = pidfd_getfd(pid, fd); 743 744 fdput(f); 745 return ret; 746 } 747