The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/ipc_tt.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /* 
    2  * Mach Operating System
    3  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
    4  * All Rights Reserved.
    5  * 
    6  * Permission to use, copy, modify and distribute this software and its
    7  * documentation is hereby granted, provided that both the copyright
    8  * notice and this permission notice appear in all copies of the
    9  * software, derivative works or modified versions, and any portions
   10  * thereof, and that both notices appear in supporting documentation.
   11  * 
   12  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   13  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
   14  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   15  * 
   16  * Carnegie Mellon requests users of this software to return to
   17  * 
   18  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   19  *  School of Computer Science
   20  *  Carnegie Mellon University
   21  *  Pittsburgh PA 15213-3890
   22  * 
   23  * any improvements or extensions that they make and grant Carnegie Mellon
   24  * the rights to redistribute these changes.
   25  */
   26 /*
   27  * HISTORY
   28  * $Log:        ipc_tt.c,v $
   29  * Revision 2.14  92/08/03  17:37:42  jfriedl
   30  *      removed silly prototypes
   31  *      [92/08/02            jfriedl]
   32  * 
   33  * Revision 2.13  92/05/21  17:14:13  jfriedl
   34  *      Removed unsed var 'kr' from mach_ports_lookup().
   35  *      [92/05/16            jfriedl]
   36  * 
   37  * Revision 2.12  91/06/25  10:28:49  rpd
   38  *      Changed the convert_foo_to_bar functions
   39  *      to use ipc_port_t instead of mach_port_t.
   40  *      [91/05/27            rpd]
   41  * 
   42  * Revision 2.11  91/06/17  15:47:09  jsb
   43  *      Renamed NORMA conditionals. Moved norma code to norma/kern_task.c.
   44  *      [91/06/17  10:50:57  jsb]
   45  * 
   46  * Revision 2.10  91/06/06  17:07:15  jsb
   47  *      NORMA_TASK support.
   48  *      [91/05/14  09:17:09  jsb]
   49  * 
   50  * Revision 2.9  91/05/14  16:42:54  mrt
   51  *      Correcting copyright
   52  * 
   53  * Revision 2.8  91/03/16  14:50:24  rpd
   54  *      Removed ith_saved.
   55  *      [91/02/16            rpd]
   56  * 
   57  * Revision 2.7  91/02/05  17:27:08  mrt
   58  *      Changed to new Mach copyright
   59  *      [91/02/01  16:13:42  mrt]
   60  * 
   61  * Revision 2.6  91/01/08  15:16:05  rpd
   62  *      Added retrieve_task_self_fast, retrieve_thread_self_fast.
   63  *      [90/12/27            rpd]
   64  * 
   65  * Revision 2.5  90/11/05  14:31:08  rpd
   66  *      Changed ip_reference to ipc_port_reference.
   67  *      Use new ip_reference and ip_release.
   68  *      [90/10/29            rpd]
   69  * 
   70  * Revision 2.4  90/06/02  14:54:33  rpd
   71  *      Converted to new IPC.
   72  *      [90/03/26  22:05:07  rpd]
   73  * 
   74  *
   75  * Condensed history:
   76  *      Modified for pure kernel (dbg).
   77  *      Support thread_exception_abort (dlb).
   78  *      Added kernel monitor support (tfl).
   79  *      Added task/thread kernel port interposing (rpd).
   80  *      Improvements/fixes for task_secure (rpd).
   81  *      New translation cache (rpd).
   82  *      Move old stuff under MACH_IPC_XXXHACK (rpd).
   83  *      Created from mach_ipc.c (rpd).
   84  */
   85 
   86 /*
   87  * File:        ipc_tt.c
   88  * Purpose:
   89  *      Task and thread related IPC functions.
   90  */
   91 
   92 #include <mach_ipc_compat.h>
   93 
   94 #include <mach/boolean.h>
   95 #include <mach/kern_return.h>
   96 #include <mach/mach_param.h>
   97 #include <mach/task_special_ports.h>
   98 #include <mach/thread_special_ports.h>
   99 #include <vm/vm_kern.h>
  100 #include <kern/task.h>
  101 #include <kern/thread.h>
  102 #include <kern/ipc_kobject.h>
  103 #include <kern/ipc_tt.h>
  104 #include <ipc/ipc_space.h>
  105 #include <ipc/ipc_table.h>
  106 #include <ipc/ipc_port.h>
  107 #include <ipc/ipc_right.h>
  108 #include <ipc/ipc_entry.h>
  109 #include <ipc/ipc_object.h>
  110 
  111 
  112 
  113 /*
  114  *      Routine:        ipc_task_init
  115  *      Purpose:
  116  *              Initialize a task's IPC state.
  117  *
  118  *              If non-null, some state will be inherited from the parent.
  119  *              The parent must be appropriately initialized.
  120  *      Conditions:
  121  *              Nothing locked.
  122  */
  123 
  124 void
  125 ipc_task_init(task, parent)
  126         task_t task;
  127         task_t parent;
  128 {
  129         ipc_space_t space;
  130         ipc_port_t kport;
  131         kern_return_t kr;
  132         int i;
  133 
  134         kr = ipc_space_create(&ipc_table_entries[0], &space);
  135         if (kr != KERN_SUCCESS)
  136                 panic("ipc_task_init");
  137 
  138         kport = ipc_port_alloc_kernel();
  139         if (kport == IP_NULL)
  140                 panic("ipc_task_init");
  141 
  142         itk_lock_init(task);
  143         task->itk_self = kport;
  144         task->itk_sself = ipc_port_make_send(kport);
  145         task->itk_space = space;
  146 
  147         if (parent == TASK_NULL) {
  148                 task->itk_exception = IP_NULL;
  149                 task->itk_bootstrap = IP_NULL;
  150                 for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
  151                         task->itk_registered[i] = IP_NULL;
  152         } else {
  153                 itk_lock(parent);
  154                 assert(parent->itk_self != IP_NULL);
  155 
  156                 /* inherit registered ports */
  157 
  158                 for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
  159                         task->itk_registered[i] =
  160                                 ipc_port_copy_send(parent->itk_registered[i]);
  161 
  162                 /* inherit exception and bootstrap ports */
  163 
  164                 task->itk_exception =
  165                         ipc_port_copy_send(parent->itk_exception);
  166                 task->itk_bootstrap =
  167                         ipc_port_copy_send(parent->itk_bootstrap);
  168 
  169                 itk_unlock(parent);
  170         }
  171 }
  172 
  173 /*
  174  *      Routine:        ipc_task_enable
  175  *      Purpose:
  176  *              Enable a task for IPC access.
  177  *      Conditions:
  178  *              Nothing locked.
  179  */
  180 
  181 void
  182 ipc_task_enable(task)
  183         task_t task;
  184 {
  185         ipc_port_t kport;
  186 
  187         itk_lock(task);
  188         kport = task->itk_self;
  189         if (kport != IP_NULL)
  190                 ipc_kobject_set(kport, (ipc_kobject_t) task, IKOT_TASK);
  191         itk_unlock(task);
  192 }
  193 
  194 /*
  195  *      Routine:        ipc_task_disable
  196  *      Purpose:
  197  *              Disable IPC access to a task.
  198  *      Conditions:
  199  *              Nothing locked.
  200  */
  201 
  202 void
  203 ipc_task_disable(task)
  204         task_t task;
  205 {
  206         ipc_port_t kport;
  207 
  208         itk_lock(task);
  209         kport = task->itk_self;
  210         if (kport != IP_NULL)
  211                 ipc_kobject_set(kport, IKO_NULL, IKOT_NONE);
  212         itk_unlock(task);
  213 }
  214 
  215 /*
  216  *      Routine:        ipc_task_terminate
  217  *      Purpose:
  218  *              Clean up and destroy a task's IPC state.
  219  *      Conditions:
  220  *              Nothing locked.  The task must be suspended.
  221  *              (Or the current thread must be in the task.)
  222  */
  223 
  224 void
  225 ipc_task_terminate(task)
  226         task_t task;
  227 {
  228         ipc_port_t kport;
  229         int i;
  230 
  231         itk_lock(task);
  232         kport = task->itk_self;
  233 
  234         if (kport == IP_NULL) {
  235                 /* the task is already terminated (can this happen?) */
  236                 itk_unlock(task);
  237                 return;
  238         }
  239 
  240         task->itk_self = IP_NULL;
  241         itk_unlock(task);
  242 
  243         /* release the naked send rights */
  244 
  245         if (IP_VALID(task->itk_sself))
  246                 ipc_port_release_send(task->itk_sself);
  247         if (IP_VALID(task->itk_exception))
  248                 ipc_port_release_send(task->itk_exception);
  249         if (IP_VALID(task->itk_bootstrap))
  250                 ipc_port_release_send(task->itk_bootstrap);
  251 
  252         for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
  253                 if (IP_VALID(task->itk_registered[i]))
  254                         ipc_port_release_send(task->itk_registered[i]);
  255 
  256         /* destroy the space, leaving just a reference for it */
  257 
  258         ipc_space_destroy(task->itk_space);
  259 
  260         /* destroy the kernel port */
  261 
  262         ipc_port_dealloc_kernel(kport);
  263 }
  264 
  265 /*
  266  *      Routine:        ipc_thread_init
  267  *      Purpose:
  268  *              Initialize a thread's IPC state.
  269  *      Conditions:
  270  *              Nothing locked.
  271  */
  272 
  273 void
  274 ipc_thread_init(thread)
  275         thread_t thread;
  276 {
  277         ipc_port_t kport;
  278 
  279         kport = ipc_port_alloc_kernel();
  280         if (kport == IP_NULL)
  281                 panic("ipc_thread_init");
  282 
  283         ipc_thread_links_init(thread);
  284         ipc_kmsg_queue_init(&thread->ith_messages);
  285 
  286         ith_lock_init(thread);
  287         thread->ith_self = kport;
  288         thread->ith_sself = ipc_port_make_send(kport);
  289         thread->ith_exception = IP_NULL;
  290 
  291         thread->ith_mig_reply = MACH_PORT_NULL;
  292         thread->ith_rpc_reply = IP_NULL;
  293 
  294 #if     MACH_IPC_COMPAT
  295     {
  296         ipc_space_t space = thread->task->itk_space;
  297         ipc_port_t port;
  298         mach_port_t name;
  299         kern_return_t kr;
  300 
  301         kr = ipc_port_alloc_compat(space, &name, &port);
  302         if (kr != KERN_SUCCESS)
  303                 panic("ipc_thread_init");
  304         /* port is locked and active */
  305 
  306         /*
  307          *      Now we have a reply port.  We need to make a naked
  308          *      send right to stash in ith_reply.  We can't use
  309          *      ipc_port_make_send, because we can't unlock the port
  310          *      before making the right.  Also we don't want to
  311          *      increment ip_mscount.  The net effect of all this
  312          *      is the same as doing
  313          *              ipc_port_alloc_kernel           get the port
  314          *              ipc_port_make_send              make the send right
  315          *              ipc_object_copyin_from_kernel   grab receive right
  316          *              ipc_object_copyout_compat       and give to user
  317          */
  318 
  319         port->ip_srights++;
  320         ip_reference(port);
  321         ip_unlock(port);
  322 
  323         thread->ith_reply = port;
  324     }
  325 #endif  MACH_IPC_COMPAT
  326 }
  327 
  328 /*
  329  *      Routine:        ipc_thread_enable
  330  *      Purpose:
  331  *              Enable a thread for IPC access.
  332  *      Conditions:
  333  *              Nothing locked.
  334  */
  335 
  336 void
  337 ipc_thread_enable(thread)
  338         thread_t thread;
  339 {
  340         ipc_port_t kport;
  341 
  342         ith_lock(thread);
  343         kport = thread->ith_self;
  344         if (kport != IP_NULL)
  345                 ipc_kobject_set(kport, (ipc_kobject_t) thread, IKOT_THREAD);
  346         ith_unlock(thread);
  347 }
  348 
  349 /*
  350  *      Routine:        ipc_thread_disable
  351  *      Purpose:
  352  *              Disable IPC access to a thread.
  353  *      Conditions:
  354  *              Nothing locked.
  355  */
  356 
  357 void
  358 ipc_thread_disable(thread)
  359         thread_t thread;
  360 {
  361         ipc_port_t kport;
  362 
  363         ith_lock(thread);
  364         kport = thread->ith_self;
  365         if (kport != IP_NULL)
  366                 ipc_kobject_set(kport, IKO_NULL, IKOT_NONE);
  367         ith_unlock(thread);
  368 }
  369 
  370 /*
  371  *      Routine:        ipc_thread_terminate
  372  *      Purpose:
  373  *              Clean up and destroy a thread's IPC state.
  374  *      Conditions:
  375  *              Nothing locked.  The thread must be suspended.
  376  *              (Or be the current thread.)
  377  */
  378 
  379 void
  380 ipc_thread_terminate(thread)
  381         thread_t thread;
  382 {
  383         ipc_port_t kport;
  384 
  385         ith_lock(thread);
  386         kport = thread->ith_self;
  387 
  388         if (kport == IP_NULL) {
  389                 /* the thread is already terminated (can this happen?) */
  390                 ith_unlock(thread);
  391                 return;
  392         }
  393 
  394         thread->ith_self = IP_NULL;
  395         ith_unlock(thread);
  396 
  397         assert(ipc_kmsg_queue_empty(&thread->ith_messages));
  398 
  399         /* release the naked send rights */
  400 
  401         if (IP_VALID(thread->ith_sself))
  402                 ipc_port_release_send(thread->ith_sself);
  403         if (IP_VALID(thread->ith_exception))
  404                 ipc_port_release_send(thread->ith_exception);
  405 
  406 #if     MACH_IPC_COMPAT
  407         if (IP_VALID(thread->ith_reply)) {
  408                 ipc_space_t space = thread->task->itk_space;
  409                 ipc_port_t port = thread->ith_reply;
  410                 ipc_entry_t entry;
  411                 mach_port_t name;
  412 
  413                 /* destroy any rights the task may have for the port */
  414 
  415                 is_write_lock(space);
  416                 if (space->is_active &&
  417                     ipc_right_reverse(space, (ipc_object_t) port,
  418                                       &name, &entry)) {
  419                         /* reply port is locked and active */
  420                         ip_unlock(port);
  421 
  422                         (void) ipc_right_destroy(space, name, entry);
  423                         /* space is unlocked */
  424                 } else
  425                         is_write_unlock(space);
  426 
  427                 ipc_port_release_send(port);
  428         }
  429 
  430         /*
  431          *      Note we do *not* destroy any rights the space may have
  432          *      for the thread's kernel port.  The old IPC code did this,
  433          *      to avoid generating a notification when the port is
  434          *      destroyed.  However, this isn't a good idea when
  435          *      the kernel port is interposed, because then it doesn't
  436          *      happen, exposing the interposition to the task.
  437          *      Because we don't need the efficiency hack, I flushed
  438          *      this behaviour, introducing a small incompatibility
  439          *      with the old IPC code.
  440          */
  441 #endif  MACH_IPC_COMPAT
  442 
  443         /* destroy the kernel port */
  444 
  445         ipc_port_dealloc_kernel(kport);
  446 }
  447 
  448 #if     0
  449 /*
  450  *      Routine:        retrieve_task_self
  451  *      Purpose:
  452  *              Return a send right (possibly null/dead)
  453  *              for the task's user-visible self port.
  454  *      Conditions:
  455  *              Nothing locked.
  456  */
  457 
  458 ipc_port_t
  459 retrieve_task_self(task)
  460         task_t task;
  461 {
  462         ipc_port_t port;
  463 
  464         assert(task != TASK_NULL);
  465 
  466         itk_lock(task);
  467         if (task->itk_self != IP_NULL)
  468                 port = ipc_port_copy_send(task->itk_sself);
  469         else
  470                 port = IP_NULL;
  471         itk_unlock(task);
  472 
  473         return port;
  474 }
  475 
  476 /*
  477  *      Routine:        retrieve_thread_self
  478  *      Purpose:
  479  *              Return a send right (possibly null/dead)
  480  *              for the thread's user-visible self port.
  481  *      Conditions:
  482  *              Nothing locked.
  483  */
  484 
  485 ipc_port_t
  486 retrieve_thread_self(thread)
  487         thread_t thread;
  488 {
  489         ipc_port_t port;
  490 
  491         assert(thread != ITH_NULL);
  492 
  493         ith_lock(thread);
  494         if (thread->ith_self != IP_NULL)
  495                 port = ipc_port_copy_send(thread->ith_sself);
  496         else
  497                 port = IP_NULL;
  498         ith_unlock(thread);
  499 
  500         return port;
  501 }
  502 #endif  0
  503 
  504 /*
  505  *      Routine:        retrieve_task_self_fast
  506  *      Purpose:
  507  *              Optimized version of retrieve_task_self,
  508  *              that only works for the current task.
  509  *
  510  *              Return a send right (possibly null/dead)
  511  *              for the task's user-visible self port.
  512  *      Conditions:
  513  *              Nothing locked.
  514  */
  515 
  516 ipc_port_t
  517 retrieve_task_self_fast(task)
  518         register task_t task;
  519 {
  520         register ipc_port_t port;
  521 
  522         assert(task == current_task());
  523 
  524         itk_lock(task);
  525         assert(task->itk_self != IP_NULL);
  526 
  527         if ((port = task->itk_sself) == task->itk_self) {
  528                 /* no interposing */
  529 
  530                 ip_lock(port);
  531                 assert(ip_active(port));
  532                 ip_reference(port);
  533                 port->ip_srights++;
  534                 ip_unlock(port);
  535         } else
  536                 port = ipc_port_copy_send(port);
  537         itk_unlock(task);
  538 
  539         return port;
  540 }
  541 
  542 /*
  543  *      Routine:        retrieve_thread_self_fast
  544  *      Purpose:
  545  *              Optimized version of retrieve_thread_self,
  546  *              that only works for the current thread.
  547  *
  548  *              Return a send right (possibly null/dead)
  549  *              for the thread's user-visible self port.
  550  *      Conditions:
  551  *              Nothing locked.
  552  */
  553 
  554 ipc_port_t
  555 retrieve_thread_self_fast(thread)
  556         register thread_t thread;
  557 {
  558         register ipc_port_t port;
  559 
  560         assert(thread == current_thread());
  561 
  562         ith_lock(thread);
  563         assert(thread->ith_self != IP_NULL);
  564 
  565         if ((port = thread->ith_sself) == thread->ith_self) {
  566                 /* no interposing */
  567 
  568                 ip_lock(port);
  569                 assert(ip_active(port));
  570                 ip_reference(port);
  571                 port->ip_srights++;
  572                 ip_unlock(port);
  573         } else
  574                 port = ipc_port_copy_send(port);
  575         ith_unlock(thread);
  576 
  577         return port;
  578 }
  579 
  580 #if     0
  581 /*
  582  *      Routine:        retrieve_task_exception
  583  *      Purpose:
  584  *              Return a send right (possibly null/dead)
  585  *              for the task's exception port.
  586  *      Conditions:
  587  *              Nothing locked.
  588  */
  589 
  590 ipc_port_t
  591 retrieve_task_exception(task)
  592         task_t task;
  593 {
  594         ipc_port_t port;
  595 
  596         assert(task != TASK_NULL);
  597 
  598         itk_lock(task);
  599         if (task->itk_self != IP_NULL)
  600                 port = ipc_port_copy_send(task->itk_exception);
  601         else
  602                 port = IP_NULL;
  603         itk_unlock(task);
  604 
  605         return port;
  606 }
  607 
  608 /*
  609  *      Routine:        retrieve_thread_exception
  610  *      Purpose:
  611  *              Return a send right (possibly null/dead)
  612  *              for the thread's exception port.
  613  *      Conditions:
  614  *              Nothing locked.
  615  */
  616 
  617 ipc_port_t
  618 retrieve_thread_exception(thread)
  619         thread_t thread;
  620 {
  621         ipc_port_t port;
  622 
  623         assert(thread != ITH_NULL);
  624 
  625         ith_lock(thread);
  626         if (thread->ith_self != IP_NULL)
  627                 port = ipc_port_copy_send(thread->ith_exception);
  628         else
  629                 port = IP_NULL;
  630         ith_unlock(thread);
  631 
  632         return port;
  633 }
  634 #endif  0
  635 
  636 /*
  637  *      Routine:        mach_task_self [mach trap]
  638  *      Purpose:
  639  *              Give the caller send rights for his own task port.
  640  *      Conditions:
  641  *              Nothing locked.
  642  *      Returns:
  643  *              MACH_PORT_NULL if there are any resource failures
  644  *              or other errors.
  645  */
  646 
  647 mach_port_t
  648 mach_task_self()
  649 {
  650         task_t task = current_task();
  651         ipc_port_t sright;
  652 
  653         sright = retrieve_task_self_fast(task);
  654         return ipc_port_copyout_send(sright, task->itk_space);
  655 }
  656 
  657 /*
  658  *      Routine:        mach_thread_self [mach trap]
  659  *      Purpose:
  660  *              Give the caller send rights for his own thread port.
  661  *      Conditions:
  662  *              Nothing locked.
  663  *      Returns:
  664  *              MACH_PORT_NULL if there are any resource failures
  665  *              or other errors.
  666  */
  667 
  668 mach_port_t
  669 mach_thread_self()
  670 {
  671         thread_t thread = current_thread();
  672         task_t task = thread->task;
  673         ipc_port_t sright;
  674 
  675         sright = retrieve_thread_self_fast(thread);
  676         return ipc_port_copyout_send(sright, task->itk_space);
  677 }
  678 
  679 /*
  680  *      Routine:        mach_reply_port [mach trap]
  681  *      Purpose:
  682  *              Allocate a port for the caller.
  683  *      Conditions:
  684  *              Nothing locked.
  685  *      Returns:
  686  *              MACH_PORT_NULL if there are any resource failures
  687  *              or other errors.
  688  */
  689 
  690 mach_port_t
  691 mach_reply_port()
  692 {
  693         ipc_port_t port;
  694         mach_port_t name;
  695         kern_return_t kr;
  696 
  697         kr = ipc_port_alloc(current_task()->itk_space, &name, &port);
  698         if (kr == KERN_SUCCESS)
  699                 ip_unlock(port);
  700         else
  701                 name = MACH_PORT_NULL;
  702 
  703         return name;
  704 }
  705 
  706 #if     MACH_IPC_COMPAT
  707 
  708 /*
  709  *      Routine:        retrieve_task_notify
  710  *      Purpose:
  711  *              Return a reference (or null) for
  712  *              the task's notify port.
  713  *      Conditions:
  714  *              Nothing locked.
  715  */
  716 
  717 ipc_port_t
  718 retrieve_task_notify(task)
  719         task_t task;
  720 {
  721         ipc_space_t space = task->itk_space;
  722         ipc_port_t port;
  723 
  724         is_read_lock(space);
  725         if (space->is_active) {
  726                 port = space->is_notify;
  727                 if (IP_VALID(port))
  728                         ipc_port_reference(port);
  729         } else
  730                 port = IP_NULL;
  731         is_read_unlock(space);
  732 
  733         return port;
  734 }
  735 
  736 /*
  737  *      Routine:        retrieve_thread_reply
  738  *      Purpose:
  739  *              Return a reference (or null) for
  740  *              the thread's reply port.
  741  *      Conditions:
  742  *              Nothing locked.
  743  */
  744 
  745 ipc_port_t
  746 retrieve_thread_reply(thread)
  747         thread_t thread;
  748 {
  749         ipc_port_t port;
  750 
  751         ith_lock(thread);
  752         if (thread->ith_self != IP_NULL) {
  753                 port = thread->ith_reply;
  754                 if (IP_VALID(port))
  755                         ipc_port_reference(port);
  756         } else
  757                 port = IP_NULL;
  758         ith_unlock(thread);
  759 
  760         return port;
  761 }
  762 
  763 /*
  764  *      Routine:        task_self [mach trap]
  765  *      Purpose:
  766  *              Give the caller send rights for his task port.
  767  *              If new, the send right is marked with IE_BITS_COMPAT.
  768  *      Conditions:
  769  *              Nothing locked.
  770  *      Returns:
  771  *              MACH_PORT_NULL if there are any resource failures
  772  *              or other errors.
  773  */
  774 
  775 port_name_t
  776 task_self()
  777 {
  778         task_t task = current_task();
  779         ipc_port_t sright;
  780         mach_port_t name;
  781 
  782         sright = retrieve_task_self_fast(task);
  783         name = ipc_port_copyout_send_compat(sright, task->itk_space);
  784         return (port_name_t) name;
  785 }
  786 
  787 /*
  788  *      Routine:        task_notify [mach trap]
  789  *      Purpose:
  790  *              Give the caller the name of his own notify port.
  791  *      Conditions:
  792  *              Nothing locked.
  793  *      Returns:
  794  *              MACH_PORT_NULL if there isn't a notify port,
  795  *              if it is dead, or if the caller doesn't hold
  796  *              receive rights for it.
  797  */
  798 
  799 port_name_t
  800 task_notify()
  801 {
  802         task_t task = current_task();
  803         ipc_port_t notify;
  804         mach_port_t name;
  805 
  806         notify = retrieve_task_notify(task);
  807         name = ipc_port_copyout_receiver(notify, task->itk_space);
  808         return (port_name_t) name;
  809 }
  810 
  811 /*
  812  *      Routine:        thread_self [mach trap]
  813  *      Purpose:
  814  *              Give the caller send rights for his own thread port.
  815  *              If new, the send right is marked with IE_BITS_COMPAT.
  816  *      Conditions:
  817  *              Nothing locked.
  818  *      Returns:
  819  *              MACH_PORT_NULL if there are any resource failures
  820  *              or other errors.
  821  */
  822 
  823 port_name_t
  824 thread_self()
  825 {
  826         thread_t thread = current_thread();
  827         task_t task = thread->task;
  828         ipc_port_t sright;
  829         mach_port_t name;
  830 
  831         sright = retrieve_thread_self_fast(thread);
  832         name = ipc_port_copyout_send_compat(sright, task->itk_space);
  833         return (port_name_t) name;
  834 }
  835 
  836 /*
  837  *      Routine:        thread_reply [mach trap]
  838  *      Purpose:
  839  *              Give the caller the name of his own reply port.
  840  *      Conditions:
  841  *              Nothing locked.
  842  *      Returns:
  843  *              MACH_PORT_NULL if there isn't a reply port,
  844  *              if it is dead, or if the caller doesn't hold
  845  *              receive rights for it.
  846  */
  847 
  848 port_name_t
  849 thread_reply()
  850 {
  851         task_t task = current_task();
  852         thread_t thread = current_thread();
  853         ipc_port_t reply;
  854         mach_port_t name;
  855 
  856         reply = retrieve_thread_reply(thread);
  857         name = ipc_port_copyout_receiver(reply, task->itk_space);
  858         return (port_name_t) name;
  859 }
  860 
  861 #endif  MACH_IPC_COMPAT
  862 
  863 /*
  864  *      Routine:        task_get_special_port [kernel call]
  865  *      Purpose:
  866  *              Clones a send right for one of the task's
  867  *              special ports.
  868  *      Conditions:
  869  *              Nothing locked.
  870  *      Returns:
  871  *              KERN_SUCCESS            Extracted a send right.
  872  *              KERN_INVALID_ARGUMENT   The task is null.
  873  *              KERN_FAILURE            The task/space is dead.
  874  *              KERN_INVALID_ARGUMENT   Invalid special port.
  875  */
  876 
  877 kern_return_t
  878 task_get_special_port(task, which, portp)
  879         task_t task;
  880         int which;
  881         ipc_port_t *portp;
  882 {
  883         ipc_port_t *whichp;
  884         ipc_port_t port;
  885 
  886         if (task == TASK_NULL)
  887                 return KERN_INVALID_ARGUMENT;
  888 
  889         switch (which) {
  890 #if     MACH_IPC_COMPAT
  891             case TASK_NOTIFY_PORT: {
  892                 ipc_space_t space = task->itk_space;
  893 
  894                 is_read_lock(space);
  895                 if (!space->is_active) {
  896                         is_read_unlock(space);
  897                         return KERN_FAILURE;
  898                 }
  899 
  900                 port = ipc_port_copy_send(space->is_notify);
  901                 is_read_unlock(space);
  902 
  903                 *portp = port;
  904                 return KERN_SUCCESS;
  905             }
  906 #endif  MACH_IPC_COMPAT
  907 
  908             case TASK_KERNEL_PORT:
  909                 whichp = &task->itk_sself;
  910                 break;
  911 
  912             case TASK_EXCEPTION_PORT:
  913                 whichp = &task->itk_exception;
  914                 break;
  915 
  916             case TASK_BOOTSTRAP_PORT:
  917                 whichp = &task->itk_bootstrap;
  918                 break;
  919 
  920             default:
  921                 return KERN_INVALID_ARGUMENT;
  922         }
  923 
  924         itk_lock(task);
  925         if (task->itk_self == IP_NULL) {
  926                 itk_unlock(task);
  927                 return KERN_FAILURE;
  928         }
  929 
  930         port = ipc_port_copy_send(*whichp);
  931         itk_unlock(task);
  932 
  933         *portp = port;
  934         return KERN_SUCCESS;
  935 }
  936 
  937 /*
  938  *      Routine:        task_set_special_port [kernel call]
  939  *      Purpose:
  940  *              Changes one of the task's special ports,
  941  *              setting it to the supplied send right.
  942  *      Conditions:
  943  *              Nothing locked.  If successful, consumes
  944  *              the supplied send right.
  945  *      Returns:
  946  *              KERN_SUCCESS            Changed the special port.
  947  *              KERN_INVALID_ARGUMENT   The task is null.
  948  *              KERN_FAILURE            The task/space is dead.
  949  *              KERN_INVALID_ARGUMENT   Invalid special port.
  950  */
  951 
  952 kern_return_t
  953 task_set_special_port(task, which, port)
  954         task_t task;
  955         int which;
  956         ipc_port_t port;
  957 {
  958         ipc_port_t *whichp;
  959         ipc_port_t old;
  960 
  961         if (task == TASK_NULL)
  962                 return KERN_INVALID_ARGUMENT;
  963 
  964         switch (which) {
  965 #if     MACH_IPC_COMPAT
  966             case TASK_NOTIFY_PORT: {
  967                 ipc_space_t space = task->itk_space;
  968 
  969                 is_write_lock(space);
  970                 if (!space->is_active) {
  971                         is_write_unlock(space);
  972                         return KERN_FAILURE;
  973                 }
  974 
  975                 old = space->is_notify;
  976                 space->is_notify = port;
  977                 is_write_unlock(space);
  978 
  979                 if (IP_VALID(old))
  980                         ipc_port_release_send(old);
  981                 return KERN_SUCCESS;
  982             }
  983 #endif  MACH_IPC_COMPAT
  984 
  985             case TASK_KERNEL_PORT:
  986                 whichp = &task->itk_sself;
  987                 break;
  988 
  989             case TASK_EXCEPTION_PORT:
  990                 whichp = &task->itk_exception;
  991                 break;
  992 
  993             case TASK_BOOTSTRAP_PORT:
  994                 whichp = &task->itk_bootstrap;
  995                 break;
  996 
  997             default:
  998                 return KERN_INVALID_ARGUMENT;
  999         }
 1000 
 1001         itk_lock(task);
 1002         if (task->itk_self == IP_NULL) {
 1003                 itk_unlock(task);
 1004                 return KERN_FAILURE;
 1005         }
 1006 
 1007         old = *whichp;
 1008         *whichp = port;
 1009         itk_unlock(task);
 1010 
 1011         if (IP_VALID(old))
 1012                 ipc_port_release_send(old);
 1013         return KERN_SUCCESS;
 1014 }
 1015 
 1016 /*
 1017  *      Routine:        thread_get_special_port [kernel call]
 1018  *      Purpose:
 1019  *              Clones a send right for one of the thread's
 1020  *              special ports.
 1021  *      Conditions:
 1022  *              Nothing locked.
 1023  *      Returns:
 1024  *              KERN_SUCCESS            Extracted a send right.
 1025  *              KERN_INVALID_ARGUMENT   The thread is null.
 1026  *              KERN_FAILURE            The thread is dead.
 1027  *              KERN_INVALID_ARGUMENT   Invalid special port.
 1028  */
 1029 
 1030 kern_return_t
 1031 thread_get_special_port(thread, which, portp)
 1032         thread_t thread;
 1033         int which;
 1034         ipc_port_t *portp;
 1035 {
 1036         ipc_port_t *whichp;
 1037         ipc_port_t port;
 1038 
 1039         if (thread == ITH_NULL)
 1040                 return KERN_INVALID_ARGUMENT;
 1041 
 1042         switch (which) {
 1043 #if     MACH_IPC_COMPAT
 1044             case THREAD_REPLY_PORT:
 1045                 whichp = &thread->ith_reply;
 1046                 break;
 1047 #endif  MACH_IPC_COMPAT
 1048 
 1049             case THREAD_KERNEL_PORT:
 1050                 whichp = &thread->ith_sself;
 1051                 break;
 1052 
 1053             case THREAD_EXCEPTION_PORT:
 1054                 whichp = &thread->ith_exception;
 1055                 break;
 1056 
 1057             default:
 1058                 return KERN_INVALID_ARGUMENT;
 1059         }
 1060 
 1061         ith_lock(thread);
 1062         if (thread->ith_self == IP_NULL) {
 1063                 ith_unlock(thread);
 1064                 return KERN_FAILURE;
 1065         }
 1066 
 1067         port = ipc_port_copy_send(*whichp);
 1068         ith_unlock(thread);
 1069 
 1070         *portp = port;
 1071         return KERN_SUCCESS;
 1072 }
 1073 
 1074 /*
 1075  *      Routine:        thread_set_special_port [kernel call]
 1076  *      Purpose:
 1077  *              Changes one of the thread's special ports,
 1078  *              setting it to the supplied send right.
 1079  *      Conditions:
 1080  *              Nothing locked.  If successful, consumes
 1081  *              the supplied send right.
 1082  *      Returns:
 1083  *              KERN_SUCCESS            Changed the special port.
 1084  *              KERN_INVALID_ARGUMENT   The thread is null.
 1085  *              KERN_FAILURE            The thread is dead.
 1086  *              KERN_INVALID_ARGUMENT   Invalid special port.
 1087  */
 1088 
 1089 kern_return_t
 1090 thread_set_special_port(thread, which, port)
 1091         thread_t thread;
 1092         int which;
 1093         ipc_port_t port;
 1094 {
 1095         ipc_port_t *whichp;
 1096         ipc_port_t old;
 1097 
 1098         if (thread == ITH_NULL)
 1099                 return KERN_INVALID_ARGUMENT;
 1100 
 1101         switch (which) {
 1102 #if     MACH_IPC_COMPAT
 1103             case THREAD_REPLY_PORT:
 1104                 whichp = &thread->ith_reply;
 1105                 break;
 1106 #endif  MACH_IPC_COMPAT
 1107 
 1108             case THREAD_KERNEL_PORT:
 1109                 whichp = &thread->ith_sself;
 1110                 break;
 1111 
 1112             case THREAD_EXCEPTION_PORT:
 1113                 whichp = &thread->ith_exception;
 1114                 break;
 1115 
 1116             default:
 1117                 return KERN_INVALID_ARGUMENT;
 1118         }
 1119 
 1120         ith_lock(thread);
 1121         if (thread->ith_self == IP_NULL) {
 1122                 ith_unlock(thread);
 1123                 return KERN_FAILURE;
 1124         }
 1125 
 1126         old = *whichp;
 1127         *whichp = port;
 1128         ith_unlock(thread);
 1129 
 1130         if (IP_VALID(old))
 1131                 ipc_port_release_send(old);
 1132         return KERN_SUCCESS;
 1133 }
 1134 
 1135 /*
 1136  *      Routine:        mach_ports_register [kernel call]
 1137  *      Purpose:
 1138  *              Stash a handful of port send rights in the task.
 1139  *              Child tasks will inherit these rights, but they
 1140  *              must use mach_ports_lookup to acquire them.
 1141  *
 1142  *              The rights are supplied in a (wired) kalloc'd segment.
 1143  *              Rights which aren't supplied are assumed to be null.
 1144  *      Conditions:
 1145  *              Nothing locked.  If successful, consumes
 1146  *              the supplied rights and memory.
 1147  *      Returns:
 1148  *              KERN_SUCCESS            Stashed the port rights.
 1149  *              KERN_INVALID_ARGUMENT   The task is null.
 1150  *              KERN_INVALID_ARGUMENT   The task is dead.
 1151  *              KERN_INVALID_ARGUMENT   Too many port rights supplied.
 1152  */
 1153 
 1154 kern_return_t
 1155 mach_ports_register(task, memory, portsCnt)
 1156         task_t task;
 1157         ipc_port_t *memory;
 1158         mach_msg_type_number_t portsCnt;
 1159 {
 1160         ipc_port_t ports[TASK_PORT_REGISTER_MAX];
 1161         int i;
 1162 
 1163         if ((task == TASK_NULL) ||
 1164             (portsCnt > TASK_PORT_REGISTER_MAX))
 1165                 return KERN_INVALID_ARGUMENT;
 1166 
 1167         /*
 1168          *      Pad the port rights with nulls.
 1169          */
 1170 
 1171         for (i = 0; i < portsCnt; i++)
 1172                 ports[i] = memory[i];
 1173         for (; i < TASK_PORT_REGISTER_MAX; i++)
 1174                 ports[i] = IP_NULL;
 1175 
 1176         itk_lock(task);
 1177         if (task->itk_self == IP_NULL) {
 1178                 itk_unlock(task);
 1179                 return KERN_INVALID_ARGUMENT;
 1180         }
 1181 
 1182         /*
 1183          *      Replace the old send rights with the new.
 1184          *      Release the old rights after unlocking.
 1185          */
 1186 
 1187         for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) {
 1188                 ipc_port_t old;
 1189 
 1190                 old = task->itk_registered[i];
 1191                 task->itk_registered[i] = ports[i];
 1192                 ports[i] = old;
 1193         }
 1194 
 1195         itk_unlock(task);
 1196 
 1197         for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
 1198                 if (IP_VALID(ports[i]))
 1199                         ipc_port_release_send(ports[i]);
 1200 
 1201         /*
 1202          *      Now that the operation is known to be successful,
 1203          *      we can free the memory.
 1204          */
 1205 
 1206         if (portsCnt != 0)
 1207                 kfree((vm_offset_t) memory,
 1208                       (vm_size_t) (portsCnt * sizeof(mach_port_t)));
 1209 
 1210         return KERN_SUCCESS;
 1211 }
 1212 
 1213 /*
 1214  *      Routine:        mach_ports_lookup [kernel call]
 1215  *      Purpose:
 1216  *              Retrieves (clones) the stashed port send rights.
 1217  *      Conditions:
 1218  *              Nothing locked.  If successful, the caller gets
 1219  *              rights and memory.
 1220  *      Returns:
 1221  *              KERN_SUCCESS            Retrieved the send rights.
 1222  *              KERN_INVALID_ARGUMENT   The task is null.
 1223  *              KERN_INVALID_ARGUMENT   The task is dead.
 1224  *              KERN_RESOURCE_SHORTAGE  Couldn't allocate memory.
 1225  */
 1226 
 1227 kern_return_t
 1228 mach_ports_lookup(task, portsp, portsCnt)
 1229         task_t task;
 1230         ipc_port_t **portsp;
 1231         mach_msg_type_number_t *portsCnt;
 1232 {
 1233         vm_offset_t memory;
 1234         vm_size_t size;
 1235         ipc_port_t *ports;
 1236         int i;
 1237 
 1238         if (task == TASK_NULL)
 1239                 return KERN_INVALID_ARGUMENT;
 1240 
 1241         size = (vm_size_t) (TASK_PORT_REGISTER_MAX * sizeof(ipc_port_t));
 1242 
 1243         memory = kalloc(size);
 1244         if (memory == 0)
 1245                 return KERN_RESOURCE_SHORTAGE;
 1246 
 1247         itk_lock(task);
 1248         if (task->itk_self == IP_NULL) {
 1249                 itk_unlock(task);
 1250 
 1251                 kfree(memory, size);
 1252                 return KERN_INVALID_ARGUMENT;
 1253         }
 1254 
 1255         ports = (ipc_port_t *) memory;
 1256 
 1257         /*
 1258          *      Clone port rights.  Because kalloc'd memory
 1259          *      is wired, we won't fault while holding the task lock.
 1260          */
 1261 
 1262         for (i = 0; i < TASK_PORT_REGISTER_MAX; i++)
 1263                 ports[i] = ipc_port_copy_send(task->itk_registered[i]);
 1264 
 1265         itk_unlock(task);
 1266 
 1267         *portsp = ports;
 1268         *portsCnt = TASK_PORT_REGISTER_MAX;
 1269         return KERN_SUCCESS;
 1270 }
 1271 
 1272 /*
 1273  *      Routine:        convert_port_to_task
 1274  *      Purpose:
 1275  *              Convert from a port to a task.
 1276  *              Doesn't consume the port ref; produces a task ref,
 1277  *              which may be null.
 1278  *      Conditions:
 1279  *              Nothing locked.
 1280  */
 1281 
 1282 task_t
 1283 convert_port_to_task(port)
 1284         ipc_port_t port;
 1285 {
 1286         task_t task = TASK_NULL;
 1287 
 1288         if (IP_VALID(port)) {
 1289                 ip_lock(port);
 1290                 if (ip_active(port) &&
 1291                     (ip_kotype(port) == IKOT_TASK)) {
 1292                         task = (task_t) port->ip_kobject;
 1293                         task_reference(task);
 1294                 }
 1295                 ip_unlock(port);
 1296         }
 1297 
 1298         return task;
 1299 }
 1300 
 1301 /*
 1302  *      Routine:        convert_port_to_space
 1303  *      Purpose:
 1304  *              Convert from a port to a space.
 1305  *              Doesn't consume the port ref; produces a space ref,
 1306  *              which may be null.
 1307  *      Conditions:
 1308  *              Nothing locked.
 1309  */
 1310 
 1311 ipc_space_t
 1312 convert_port_to_space(port)
 1313         ipc_port_t port;
 1314 {
 1315         ipc_space_t space = IS_NULL;
 1316 
 1317         if (IP_VALID(port)) {
 1318                 ip_lock(port);
 1319                 if (ip_active(port) &&
 1320                     (ip_kotype(port) == IKOT_TASK)) {
 1321                         space = ((task_t) port->ip_kobject)->itk_space;
 1322                         is_reference(space);
 1323                 }
 1324                 ip_unlock(port);
 1325         }
 1326 
 1327         return space;
 1328 }
 1329 
 1330 /*
 1331  *      Routine:        convert_port_to_map
 1332  *      Purpose:
 1333  *              Convert from a port to a map.
 1334  *              Doesn't consume the port ref; produces a map ref,
 1335  *              which may be null.
 1336  *      Conditions:
 1337  *              Nothing locked.
 1338  */
 1339 
 1340 vm_map_t
 1341 convert_port_to_map(port)
 1342         ipc_port_t port;
 1343 {
 1344         vm_map_t map = VM_MAP_NULL;
 1345 
 1346         if (IP_VALID(port)) {
 1347                 ip_lock(port);
 1348                 if (ip_active(port) &&
 1349                     (ip_kotype(port) == IKOT_TASK)) {
 1350                         map = ((task_t) port->ip_kobject)->map;
 1351                         vm_map_reference(map);
 1352                 }
 1353                 ip_unlock(port);
 1354         }
 1355 
 1356         return map;
 1357 }
 1358 
 1359 /*
 1360  *      Routine:        convert_port_to_thread
 1361  *      Purpose:
 1362  *              Convert from a port to a thread.
 1363  *              Doesn't consume the port ref; produces a thread ref,
 1364  *              which may be null.
 1365  *      Conditions:
 1366  *              Nothing locked.
 1367  */
 1368 
 1369 thread_t
 1370 convert_port_to_thread(port)
 1371         ipc_port_t port;
 1372 {
 1373         thread_t thread = THREAD_NULL;
 1374 
 1375         if (IP_VALID(port)) {
 1376                 ip_lock(port);
 1377                 if (ip_active(port) &&
 1378                     (ip_kotype(port) == IKOT_THREAD)) {
 1379                         thread = (thread_t) port->ip_kobject;
 1380                         thread_reference(thread);
 1381                 }
 1382                 ip_unlock(port);
 1383         }
 1384 
 1385         return thread;
 1386 }
 1387 
 1388 /*
 1389  *      Routine:        convert_task_to_port
 1390  *      Purpose:
 1391  *              Convert from a task to a port.
 1392  *              Consumes a task ref; produces a naked send right
 1393  *              which may be invalid.  
 1394  *      Conditions:
 1395  *              Nothing locked.
 1396  */
 1397 
 1398 ipc_port_t
 1399 convert_task_to_port(task)
 1400         task_t task;
 1401 {
 1402         ipc_port_t port;
 1403 
 1404         itk_lock(task);
 1405         if (task->itk_self != IP_NULL)
 1406                 port = ipc_port_make_send(task->itk_self);
 1407         else
 1408                 port = IP_NULL;
 1409         itk_unlock(task);
 1410 
 1411         task_deallocate(task);
 1412         return port;
 1413 }
 1414 
 1415 /*
 1416  *      Routine:        convert_thread_to_port
 1417  *      Purpose:
 1418  *              Convert from a thread to a port.
 1419  *              Consumes a thread ref; produces a naked send right
 1420  *              which may be invalid.
 1421  *      Conditions:
 1422  *              Nothing locked.
 1423  */
 1424 
 1425 ipc_port_t
 1426 convert_thread_to_port(thread)
 1427         thread_t thread;
 1428 {
 1429         ipc_port_t port;
 1430 
 1431         ith_lock(thread);
 1432         if (thread->ith_self != IP_NULL)
 1433                 port = ipc_port_make_send(thread->ith_self);
 1434         else
 1435                 port = IP_NULL;
 1436         ith_unlock(thread);
 1437 
 1438         thread_deallocate(thread);
 1439         return port;
 1440 }
 1441 
 1442 /*
 1443  *      Routine:        space_deallocate
 1444  *      Purpose:
 1445  *              Deallocate a space ref produced by convert_port_to_space.
 1446  *      Conditions:
 1447  *              Nothing locked.
 1448  */
 1449 
 1450 void
 1451 space_deallocate(space)
 1452         ipc_space_t space;
 1453 {
 1454         if (space != IS_NULL)
 1455                 is_release(space);
 1456 }

Cache object: 3890c2892acb5410cd8a2bf6c2a2435c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.