xref: /xnu-8792.41.9/bsd/sys/kern_control.h (revision 5c2921b07a2480ab43ec66f5b9e41cb872bc554f)

/*
 * Copyright (c) 2000-2004, 2012-2016 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*!
 *       @header kern_control.h
 *       This header defines an API to communicate between a kernel
 *       extension and a process outside of the kernel.
 */

#ifndef KPI_KERN_CONTROL_H
#define KPI_KERN_CONTROL_H


#include <sys/appleapiopts.h>
#include <sys/_types/_u_char.h>
#include <sys/_types/_u_int16_t.h>
#include <sys/_types/_u_int32_t.h>

/*
 * Define Controller event subclass, and associated events.
 * Subclass of KEV_SYSTEM_CLASS
 */

/*!
 *       @defined KEV_CTL_SUBCLASS
 *   @discussion The kernel event subclass for kernel control events.
 */
#define KEV_CTL_SUBCLASS        2

/*!
 *       @defined KEV_CTL_REGISTERED
 *   @discussion The event code indicating a new controller was
 *       registered. The data portion will contain a ctl_event_data.
 */
#define KEV_CTL_REGISTERED      1       /* a new controller appears */

/*!
 *       @defined KEV_CTL_DEREGISTERED
 *   @discussion The event code indicating a controller was unregistered.
 *       The data portion will contain a ctl_event_data.
 */
#define KEV_CTL_DEREGISTERED    2       /* a controller disappears */

/*!
 *       @struct ctl_event_data
 *       @discussion This structure is used for KEV_CTL_SUBCLASS kernel
 *               events.
 *       @field ctl_id The kernel control id.
 *       @field ctl_unit The kernel control unit.
 */
struct ctl_event_data {
	u_int32_t   ctl_id;             /* Kernel Controller ID */
	u_int32_t   ctl_unit;
};

/*
 * Controls destined to the Controller Manager.
 */

/*!
 *       @defined CTLIOCGCOUNT
 *   @discussion The CTLIOCGCOUNT ioctl can be used to determine the
 *       number of kernel controllers registered.
 */
#define CTLIOCGCOUNT    _IOR('N', 2, int)               /* get number of control structures registered */

/*!
 *       @defined CTLIOCGINFO
 *   @discussion The CTLIOCGINFO ioctl can be used to convert a kernel
 *       control name to a kernel control id.
 */
#define CTLIOCGINFO     _IOWR('N', 3, struct ctl_info)  /* get id from name */


/*!
 *       @defined MAX_KCTL_NAME
 *   @discussion Kernel control names must be no longer than
 *       MAX_KCTL_NAME.
 */
#define MAX_KCTL_NAME   96

/*
 * Controls destined to the Controller Manager.
 */

/*!
 *       @struct ctl_info
 *       @discussion This structure is used with the CTLIOCGINFO ioctl to
 *               translate from a kernel control name to a control id.
 *       @field ctl_id The kernel control id, filled out upon return.
 *       @field ctl_name The kernel control name to find.
 */
struct ctl_info {
	u_int32_t   ctl_id;                             /* Kernel Controller ID  */
	char        ctl_name[MAX_KCTL_NAME];            /* Kernel Controller Name (a C string) */
};


/*!
 *       @struct sockaddr_ctl
 *       @discussion The controller address structure is used to establish
 *               contact between a user client and a kernel controller. The
 *               sc_id/sc_unit uniquely identify each controller. sc_id is a
 *               unique identifier assigned to the controller. The identifier can
 *               be assigned by the system at registration time or be a 32-bit
 *               creator code obtained from Apple Computer. sc_unit is a unit
 *               number for this sc_id, and is privately used by the kernel
 *               controller to identify several instances of the controller.
 *       @field sc_len The length of the structure.
 *       @field sc_family AF_SYSTEM.
 *       @field ss_sysaddr AF_SYS_KERNCONTROL.
 *       @field sc_id Controller unique identifier.
 *       @field sc_unit Kernel controller private unit number.
 *       @field sc_reserved Reserved, must be set to zero.
 */
struct sockaddr_ctl {
	u_char      sc_len;     /* depends on size of bundle ID string */
	u_char      sc_family;  /* AF_SYSTEM */
	u_int16_t   ss_sysaddr; /* AF_SYS_KERNCONTROL */
	u_int32_t   sc_id;      /* Controller unique identifier  */
	u_int32_t   sc_unit;    /* Developer private unit number */
	u_int32_t   sc_reserved[5];
};

#ifdef PRIVATE

struct xkctl_reg {
	u_int32_t       xkr_len;
	u_int32_t       xkr_kind;
	u_int32_t       xkr_id;
	u_int32_t       xkr_reg_unit;
	u_int32_t       xkr_flags;
	u_int64_t       xkr_kctlref;
	u_int32_t       xkr_recvbufsize;
	u_int32_t       xkr_sendbufsize;
	u_int32_t       xkr_lastunit;
	u_int32_t       xkr_pcbcount;
	u_int64_t       xkr_connect;
	u_int64_t       xkr_disconnect;
	u_int64_t       xkr_send;
	u_int64_t       xkr_send_list;
	u_int64_t       xkr_setopt;
	u_int64_t       xkr_getopt;
	u_int64_t       xkr_rcvd;
	char            xkr_name[MAX_KCTL_NAME];
};

struct xkctlpcb {
	u_int32_t       xkp_len;
	u_int32_t       xkp_kind;
	u_int64_t       xkp_kctpcb;
	u_int32_t       xkp_unit;
	u_int32_t       xkp_kctlid;
	u_int64_t       xkp_kctlref;
	char            xkp_kctlname[MAX_KCTL_NAME];
};

struct kctlstat {
	u_int64_t       kcs_reg_total __attribute__((aligned(8)));
	u_int64_t       kcs_reg_count __attribute__((aligned(8)));
	u_int64_t       kcs_pcbcount __attribute__((aligned(8)));
	u_int64_t       kcs_gencnt __attribute__((aligned(8)));
	u_int64_t       kcs_connections __attribute__((aligned(8)));
	u_int64_t       kcs_conn_fail __attribute__((aligned(8)));
	u_int64_t       kcs_send_fail __attribute__((aligned(8)));
	u_int64_t       kcs_send_list_fail __attribute__((aligned(8)));
	u_int64_t       kcs_enqueue_fail __attribute__((aligned(8)));
	u_int64_t       kcs_enqueue_fullsock __attribute__((aligned(8)));
	u_int64_t       kcs_bad_kctlref __attribute__((aligned(8)));
	u_int64_t       kcs_tbl_size_too_big __attribute__((aligned(8)));
	u_int64_t       kcs_enqdata_mb_alloc_fail __attribute__((aligned(8)));
	u_int64_t       kcs_enqdata_sbappend_fail __attribute__((aligned(8)));
};

#endif /* PRIVATE */

#ifdef KERNEL

#include <sys/kpi_mbuf.h>

/*!
 *       @typedef kern_ctl_ref
 *       @discussion A control reference is used to track an attached kernel
 *               control. Registering a kernel control will create a kernel
 *               control reference. This reference is required for sending data
 *               or removing the kernel control. This reference will be passed to
 *               callbacks for that kernel control.
 */
typedef void * kern_ctl_ref;

/*!
 *       @defined CTL_FLAG_PRIVILEGED
 *   @discussion The CTL_FLAG_PRIVILEGED flag is passed in ctl_flags. If
 *       this flag is set, only privileged processes may attach to this
 *       kernel control.
 */
#define CTL_FLAG_PRIVILEGED     0x1
/*!
 *       @defined CTL_FLAG_REG_ID_UNIT
 *   @discussion The CTL_FLAG_REG_ID_UNIT flag is passed to indicate that
 *       the ctl_id specified should be used. If this flag is not
 *       present, a unique ctl_id will be dynamically assigned to your
 *       kernel control. The CTLIOCGINFO ioctl can be used by the client
 *       to find the dynamically assigned id based on the control name
 *       specified in ctl_name.
 */
#define CTL_FLAG_REG_ID_UNIT    0x2
/*!
 *       @defined CTL_FLAG_REG_SOCK_STREAM
 *   @discussion Use the CTL_FLAG_REG_SOCK_STREAM flag when client need to open
 *       socket of type SOCK_STREAM to communicate with the kernel control.
 *       By default kernel control sockets are of type SOCK_DGRAM.
 */
#define CTL_FLAG_REG_SOCK_STREAM        0x4

#ifdef KERNEL_PRIVATE
/*!
 *       @defined CTL_FLAG_REG_EXTENDED
 *   @discussion This flag indicates that this kernel control utilizes the
 *       the extended fields within the kern_ctl_reg structure.
 */
#define CTL_FLAG_REG_EXTENDED   0x8

/*!
 *       @defined CTL_FLAG_REG_CRIT
 *   @discussion This flag indicates that this kernel control utilizes the
 *       the extended fields within the kern_ctl_reg structure.
 */
#define CTL_FLAG_REG_CRIT       0x10

/*!
 *       @defined CTL_FLAG_REG_SETUP
 *   @discussion This flag indicates that this kernel control utilizes the
 *       the setup callback field within the kern_ctl_reg structure.
 */
#define CTL_FLAG_REG_SETUP      0x20
#endif /* KERNEL_PRIVATE */

/* Data flags for controllers */
/*!
 *       @defined CTL_DATA_NOWAKEUP
 *   @discussion The CTL_DATA_NOWAKEUP flag can be used for the enqueue
 *       data and enqueue mbuf functions to indicate that the process
 *       should not be woken up yet. This is useful when you want to
 *       enqueue data using more than one call but only want to wake up
 *       the client after all of the data has been enqueued.
 */
#define CTL_DATA_NOWAKEUP       0x1

/*!
 *       @defined CTL_DATA_EOR
 *   @discussion The CTL_DATA_EOR flag can be used for the enqueue
 *       data and enqueue mbuf functions to mark the end of a record.
 */
#define CTL_DATA_EOR            0x2

#ifdef KERNEL_PRIVATE
/*!
 *       @defined CTL_DATA_CRIT
 *       @discussion This flag indicates the data is critical to the client
 *               and that it needs to be forced into the socket buffer
 *               by resizing it if needed.
 */
#define CTL_DATA_CRIT   0x4
#endif /* KERNEL_PRIVATE */

__BEGIN_DECLS

/*!
 *       @typedef ctl_connect_func
 *       @discussion The ctl_connect_func is used to receive
 *               notification of a client connecting to the kernel control.
 *       @param kctlref The control ref for the kernel control the client is
 *               connecting to.
 *       @param sac The address used to connect to this control. The field sc_unit
 *               contains the unit number of the kernel control instance the client is
 *               connecting to. If CTL_FLAG_REG_ID_UNIT was set when the kernel control
 *               was registered, sc_unit is the ctl_unit of the kern_ctl_reg structure.
 *               If CTL_FLAG_REG_ID_UNIT was not set when the kernel control was
 *               registered, sc_unit is the dynamically allocated unit number of
 *               the new kernel control instance that is used for this connection.
 *       @param unitinfo A placeholder for a pointer to the optional user-defined
 *               private data associated with this kernel control instance.  This
 *               opaque info will be provided to the user when the rest of the
 *               callback routines are executed.  For example, it can be used
 *               to pass a pointer to an instance-specific data structure in
 *               order for the user to keep track of the states related to this
 *               kernel control instance.
 */
typedef errno_t (*ctl_connect_func)(kern_ctl_ref kctlref,
    struct sockaddr_ctl *sac,
    void **unitinfo);

/*!
 *       @typedef ctl_disconnect_func
 *       @discussion The ctl_disconnect_func is used to receive notification
 *               that a client has disconnected from the kernel control. This
 *               usually happens when the socket is closed. If this is the last
 *               socket attached to your kernel control, you may unregister your
 *               kernel control from this callback.
 *       @param kctlref The control ref for the kernel control instance the client has
 *               disconnected from.
 *       @param unit The unit number of the kernel control instance the client has
 *               disconnected from.
 *       @param unitinfo The user-defined private data initialized by the
 *               ctl_connect_func callback.
 */
typedef errno_t (*ctl_disconnect_func)(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo);

/*!
 *       @typedef ctl_send_func
 *       @discussion The ctl_send_func is used to receive data sent from
 *               the client to the kernel control.
 *       @param kctlref The control ref of the kernel control.
 *       @param unit The unit number of the kernel control instance the client has
 *               connected to.
 *       @param unitinfo The user-defined private data initialized by the
 *               ctl_connect_func callback.
 *       @param m The data sent by the client to the kernel control in an
 *               mbuf chain. Your function is responsible for releasing the
 *               mbuf chain.
 *       @param flags The flags specified by the client when calling
 *               send/sendto/sendmsg (MSG_OOB/MSG_DONTROUTE).
 */
typedef errno_t (*ctl_send_func)(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo,
    mbuf_t m, int flags);

/*!
 *       @typedef ctl_setopt_func
 *       @discussion The ctl_setopt_func is used to handle set socket option
 *               calls for the SYSPROTO_CONTROL option level.
 *       @param kctlref The control ref of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param unitinfo The user-defined private data initialized by the
 *               ctl_connect_func callback.
 *       @param opt The socket option.
 *       @param data A pointer to the socket option data. The data has
 *               already been copied in to the kernel for you.
 *       @param len The length of the socket option data.
 */
typedef errno_t (*ctl_setopt_func)(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo,
    int opt, void *data, size_t len);

/*!
 *       @typedef ctl_getopt_func
 *       @discussion The ctl_getopt_func is used to handle client get socket
 *               option requests for the SYSPROTO_CONTROL option level. A buffer
 *               is allocated for storage and passed to your function. The length
 *               of that buffer is also passed. Upon return, you should set *len
 *               to length of the buffer used. In some cases, data may be NULL.
 *               When this happens, *len should be set to the length you would
 *               have returned had data not been NULL. If the buffer is too small,
 *               return an error.
 *       @param kctlref The control ref of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param unitinfo The user-defined private data initialized by the
 *               ctl_connect_func callback.
 *       @param opt The socket option.
 *       @param data A buffer to copy the results in to. May be NULL, see
 *               discussion.
 *       @param len A pointer to the length of the buffer. This should be set
 *               to the length of the buffer used before returning.
 */
typedef errno_t (*ctl_getopt_func)(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo,
    int opt, void *data, size_t *len);

#ifdef KERNEL_PRIVATE
/*!
 *       @typedef ctl_rcvd_func
 *       @discussion The ctl_rcvd_func is called when the client reads data from
 *               the kernel control socket. The kernel control can use this callback
 *               in combination with ctl_getenqueuespace() to avoid overflowing
 *               the socket's receive buffer. When ctl_getenqueuespace() returns
 *               0 or ctl_enqueuedata()/ctl_enqueuembuf() return ENOBUFS, the
 *               kernel control can wait until this callback is called before
 *               trying to enqueue the data again.
 *       @param kctlref The control ref of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param unitinfo The user-defined private data initialized by the
 *               ctl_connect_func callback.
 *       @param flags The recv flags. See the recv(2) man page.
 */
typedef void (*ctl_rcvd_func)(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo,
    int flags);

/*!
 *       @typedef ctl_send_list_func
 *       @discussion The ctl_send_list_func is used to receive data sent from
 *               the client to the kernel control.
 *       @param kctlref The control ref of the kernel control.
 *       @param unit The unit number of the kernel control instance the client has
 *               connected to.
 *       @param unitinfo The user-defined private data initialized by the
 *               ctl_connect_func callback.
 *       @param m The data sent by the client to the kernel control in an
 *               mbuf packet chain. Your function is responsible for releasing
 *               mbuf packet chain.
 *       @param flags The flags specified by the client when calling
 *               send/sendto/sendmsg (MSG_OOB/MSG_DONTROUTE).
 */
typedef errno_t (*ctl_send_list_func)(kern_ctl_ref kctlref, u_int32_t unit, void *unitinfo,
    mbuf_t m, int flags);

/*!
 *       @typedef ctl_bind_func
 *       @discussion The ctl_bind_func is an optional function that allows the client
 *               to set up their unitinfo prior to connecting.
 *       @param kctlref The control ref for the kernel control the client is
 *               binding to.
 *       @param sac The address used to connect to this control. The field sc_unit
 *               contains the unit number of the kernel control instance the client is
 *               binding to. If CTL_FLAG_REG_ID_UNIT was set when the kernel control
 *               was registered, sc_unit is the ctl_unit of the kern_ctl_reg structure.
 *               If CTL_FLAG_REG_ID_UNIT was not set when the kernel control was
 *               registered, sc_unit is the dynamically allocated unit number of
 *               the new kernel control instance that is used for this connection.
 *       @param unitinfo A placeholder for a pointer to the optional user-defined
 *               private data associated with this kernel control instance.  This
 *               opaque info will be provided to the user when the rest of the
 *               callback routines are executed.  For example, it can be used
 *               to pass a pointer to an instance-specific data structure in
 *               order for the user to keep track of the states related to this
 *               kernel control instance.
 */
typedef errno_t (*ctl_bind_func)(kern_ctl_ref kctlref,
    struct sockaddr_ctl *sac,
    void **unitinfo);

/*!
 *       @typedef ctl_setup_func
 *       @discussion The ctl_setup_func is an optional function that allows the client
 *               to pick a unit number in the case that the caller hasn't specified one
 *       @param unit A placeholder for a pointer to the unit number that is selected with
 *               this kernel control instance
 *       @param unitinfo A placeholder for a pointer to the optional user-defined
 *               private data associated with this kernel control instance.  This
 *               opaque info will be provided to the user when the rest of the
 *               callback routines are executed.  For example, it can be used
 *               to pass a pointer to an instance-specific data structure in
 *               order for the user to keep track of the states related to this
 *               kernel control instance.
 */
typedef errno_t (*ctl_setup_func)(u_int32_t *unit, void **unitinfo);
#endif /* KERNEL_PRIVATE */

/*!
 *       @struct kern_ctl_reg
 *       @discussion This structure defines the properties of a kernel
 *               control being registered.
 *       @field ctl_name A Bundle ID string of up to MAX_KCTL_NAME bytes (including the ending zero).
 *               This string should not be empty.
 *       @field ctl_id The control ID may be dynamically assigned or it can be a
 *               32-bit creator code assigned by DTS.
 *               For a DTS assigned creator code the CTL_FLAG_REG_ID_UNIT flag must be set.
 *               For a dynamically assigned control ID, do not set the CTL_FLAG_REG_ID_UNIT flag.
 *               The  value of the dynamically assigned control ID is set to this field
 *               when the registration succeeds.
 *       @field ctl_unit A separate unit number to register multiple units that
 *               share the same control ID with DTS assigned creator code when
 *               the CTL_FLAG_REG_ID_UNIT flag is set.
 *               This field is ignored for a dynamically assigned control ID.
 *       @field ctl_flags CTL_FLAG_PRIVILEGED and/or CTL_FLAG_REG_ID_UNIT.
 *       @field ctl_sendsize Override the default send size. If set to zero,
 *               the default send size will be used, and this default value
 *               is set to this field to be retrieved by the caller.
 *       @field ctl_recvsize Override the default receive size. If set to
 *               zero, the default receive size will be used, and this default value
 *               is set to this field to be retrieved by the caller.
 *       @field ctl_connect Specify the  function to be called whenever a client
 *               connects to the kernel control. This field must be specified.
 *       @field ctl_disconnect Specify a function to be called whenever a
 *               client disconnects from the kernel control.
 *       @field ctl_send Specify a function to handle data send from the
 *               client to the kernel control.
 *       @field ctl_setopt Specify a function to handle set socket option
 *               operations for the kernel control.
 *       @field ctl_getopt Specify a function to handle get socket option
 *               operations for the kernel control.
 */
struct kern_ctl_reg {
	/* control information */
	char            ctl_name[MAX_KCTL_NAME];
	u_int32_t       ctl_id;
	u_int32_t       ctl_unit;

	/* control settings */
	u_int32_t   ctl_flags;
	u_int32_t   ctl_sendsize;
	u_int32_t   ctl_recvsize;

	/* Dispatch functions */
	ctl_connect_func    ctl_connect;
	ctl_disconnect_func ctl_disconnect;
	ctl_send_func               ctl_send;
	ctl_setopt_func             ctl_setopt;
	ctl_getopt_func             ctl_getopt;
#ifdef KERNEL_PRIVATE
	ctl_rcvd_func               ctl_rcvd;   /* Only valid if CTL_FLAG_REG_EXTENDED is set */
	ctl_send_list_func          ctl_send_list;/* Only valid if CTL_FLAG_REG_EXTENDED is set */
	ctl_bind_func           ctl_bind;
	ctl_setup_func                  ctl_setup;
#endif /* KERNEL_PRIVATE */
};

/*!
 *       @function ctl_register
 *       @discussion Register a kernel control. This will enable clients to
 *               connect to the kernel control using a PF_SYSTEM socket.
 *       @param userkctl A structure defining the kernel control to be
 *               attached. The ctl_connect callback must be specified, the other callbacks
 *               are optional. If ctl_connect is set to zero, ctl_register fails with
 *               the error code EINVAL.
 *       @param kctlref Upon successful return, the kctlref will contain a
 *               reference to the attached kernel control. This reference is used
 *               to unregister the kernel control. This reference will also be
 *               passed in to the callbacks each time they are called.
 *       @result 0 - Kernel control was registered.
 *               EINVAL - The registration structure was not valid.
 *               ENOMEM - There was insufficient memory.
 *               EEXIST - A controller with that id/unit is already registered.
 */
errno_t
ctl_register(struct kern_ctl_reg *userkctl, kern_ctl_ref *kctlref);

/*!
 *       @function ctl_deregister
 *       @discussion Unregister a kernel control. A kernel extension must
 *               unregister it's kernel control(s) before unloading. If a kernel
 *               control has clients attached, this call will fail.
 *       @param kctlref The control reference of the control to unregister.
 *       @result 0 - Kernel control was unregistered.
 *               EINVAL - The kernel control reference was invalid.
 *               EBUSY - The kernel control has clients still attached.
 */
errno_t
ctl_deregister(kern_ctl_ref kctlref);

/*!
 *       @function ctl_enqueuedata
 *       @discussion Send data from the kernel control to the client.
 *       @param kctlref The control reference of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param data A pointer to the data to send.
 *       @param len The length of data to send.
 *       @param flags Send flags. CTL_DATA_NOWAKEUP and CTL_DATA_EOR are currently
 *               the only supported flags.
 *       @result 0 - Data was enqueued to be read by the client.
 *               EINVAL - Invalid parameters.
 *               EMSGSIZE - The buffer is too large.
 *               ENOBUFS - The queue is full or there are no free mbufs.
 */
errno_t
ctl_enqueuedata(kern_ctl_ref kctlref, u_int32_t unit, void *data, size_t len, u_int32_t flags);

/*!
 *       @function ctl_enqueuembuf
 *       @discussion Send data stored in an mbuf chain from the kernel
 *               control to the client. The caller is responsible for freeing
 *               the mbuf chain if ctl_enqueuembuf returns an error.
 *       @param kctlref The control reference of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param m An mbuf chain containing the data to send to the client.
 *       @param flags Send flags. CTL_DATA_NOWAKEUP and CTL_DATA_EOR are currently
 *               the only supported flags.
 *       @result 0 - Data was enqueued to be read by the client.
 *               EINVAL - Invalid parameters.
 *               ENOBUFS - The queue is full.
 */
errno_t
ctl_enqueuembuf(kern_ctl_ref kctlref, u_int32_t unit, mbuf_t m, u_int32_t flags);

#ifdef PRIVATE
/*!
 *       @function ctl_enqueuembuf_list
 *       @discussion Send data stored in an mbuf packet chain from the kernel
 *               control to the client. The caller is responsible for freeing
 *               the mbuf chain if ctl_enqueuembuf returns an error.
 *               Not valid if ctl_flags contains CTL_FLAG_REG_SOCK_STREAM.
 *       @param kctlref The control reference of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param m_list An mbuf chain containing the data to send to the client.
 *       @param flags Send flags. CTL_DATA_NOWAKEUP is
 *               the only supported flags.
 *       @param m_remain A pointer to the list of mbuf packets in the chain that
 *               could not be enqueued.
 *       @result 0 - Data was enqueued to be read by the client.
 *               EINVAL - Invalid parameters.
 *               ENOBUFS - The queue is full.
 */
errno_t
ctl_enqueuembuf_list(kern_ctl_ref kctlref, u_int32_t unit, mbuf_t m_list,
    u_int32_t flags, mbuf_t *m_remain);

/*!
 *       @function ctl_getenqueuepacketcount
 *       @discussion Retrieve the number of packets in the socket
 *               receive buffer.
 *       @param kctlref The control reference of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param pcnt The address where to return the current count.
 *       @result 0 - Success; the packet count is returned to caller.
 *               EINVAL - Invalid parameters.
 */
errno_t
ctl_getenqueuepacketcount(kern_ctl_ref kctlref, u_int32_t unit, u_int32_t *pcnt);

#endif /* PRIVATE */

/*!
 *       @function ctl_getenqueuespace
 *       @discussion Retrieve the amount of space currently available for data to be sent
 *               from the kernel control to the client.
 *       @param kctlref The control reference of the kernel control.
 *       @param unit The unit number of the kernel control instance.
 *       @param space The address where to return the current space available
 *       @result 0 - Success; the amount of space is returned to caller.
 *               EINVAL - Invalid parameters.
 */
errno_t
ctl_getenqueuespace(kern_ctl_ref kctlref, u_int32_t unit, size_t *space);

/*!
 *  @function ctl_getenqueuereadable
 *  @discussion Retrieve the difference between enqueued bytes and
 *       low-water mark for the socket receive buffer.
 *  @param kctlref The control reference of the kernel control.
 *  @param unit The unit number of the kernel control instance.
 *  @param difference The address at which to return the current difference
 *       between the low-water mark for the socket and the number of bytes
 *       enqueued. 0 indicates that the socket is readable by the client
 *       (the number of bytes in the buffer is above the low-water mark).
 *  @result 0 - Success; the difference is returned to caller.
 *  EINVAL - Invalid parameters.
 */
errno_t
ctl_getenqueuereadable(kern_ctl_ref kctlref, u_int32_t unit, u_int32_t *difference);

#ifdef KERNEL_PRIVATE

#include <sys/queue.h>
#include <libkern/locks.h>

/*
 * internal structure maintained for each register controller
 */
struct ctl_cb;
struct kctl;
struct socket;
struct socket_info;

void kctl_fill_socketinfo(struct socket *, struct socket_info *);

u_int32_t ctl_id_by_name(const char *name);
errno_t ctl_name_by_id(u_int32_t id, char *out_name, size_t maxsize);

extern const u_int32_t ctl_maxunit;
#endif /* KERNEL_PRIVATE */

__END_DECLS
#endif /* KERNEL */

#endif /* KPI_KERN_CONTROL_H */