blob: a09d3e63546b600eeb33022315d1a74b4c0fde2d [file] [log] [blame]
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or
* See the License for the specific language governing permissions
* and limitations under the License.
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
#ifdef __cplusplus
extern "C" {
#if defined(_KERNEL) || defined(_KMEMUSER)
#include <sys/note.h>
#include <sys/taskq.h>
#if (defined(__fibre))
* These #defines are to avoid namespace collisions that occur because this
* code is currently used to compile two seperate driver modules: sd and ssd.
* All function names need to be treated this way (even if declared static)
* in order to allow the debugger to resolve the names properly.
* It is anticipated that in the near future the ssd module will be obsoleted,
* at which time this ugliness should go away.
#define ddi_xbuf_attr_create ssd_ddi_xbuf_attr_create
#define ddi_xbuf_attr_destroy ssd_ddi_xbuf_attr_destroy
#define ddi_xbuf_attr_register_devinfo ssd_ddi_xbuf_attr_register_devinfo
#define ddi_xbuf_attr_unregister_devinfo \
#define ddi_xbuf_qstrategy ssd_ddi_xbuf_qstrategy
#define ddi_xbuf_done ssd_ddi_xbuf_done
#define ddi_xbuf_get ssd_ddi_xbuf_get
#define xbuf_iostart ssd_xbuf_iostart
#define xbuf_dispatch ssd_xbuf_dispatch
#define xbuf_restart_callback ssd_xbuf_restart_callback
#define xbuf_tq ssd_xbuf_tq
#define xbuf_attr_tq_minalloc ssd_xbuf_attr_tq_minalloc
#define xbuf_attr_tq_maxalloc ssd_xbuf_attr_tq_maxalloc
#define xbuf_mutex ssd_xbuf_mutex
#define xbuf_refcount ssd_xbuf_refcount
#define ddi_xbuf_dispatch ssd_ddi_xbuf_dispatch
#define ddi_xbuf_flushq ssd_ddi_xbuf_flushq
#define ddi_xbuf_attr_setup_brk ssd_ddi_xbuf_attr_setup_brk
typedef void * ddi_xbuf_t;
* Primary attribute struct for buf extensions.
struct __ddi_xbuf_attr {
kmutex_t xa_mutex;
size_t xa_allocsize;
uint32_t xa_pending; /* call to xbuf_iostart() is iminent */
uint32_t xa_active_limit;
uint32_t xa_active_count;
uint32_t xa_active_lowater;
struct buf *xa_headp; /* FIFO buf queue head ptr */
struct buf *xa_tailp; /* FIFO buf queue tail ptr */
kmutex_t xa_reserve_mutex;
uint32_t xa_reserve_limit;
uint32_t xa_reserve_count;
void *xa_reserve_headp;
void (*xa_strategy)(struct buf *, ddi_xbuf_t, void *);
void *xa_attr_arg;
timeout_id_t xa_timeid;
taskq_t *xa_tq;
struct buf *xa_flush_headp;
struct buf *xa_flush_tailp;
size_t xa_brksize;
typedef struct __ddi_xbuf_attr *ddi_xbuf_attr_t;
#define DDII
DDII ddi_xbuf_attr_t ddi_xbuf_attr_create(size_t xsize,
void (*xa_strategy)(struct buf *bp, ddi_xbuf_t xp, void *attr_arg),
void *attr_arg, uint32_t active_limit, uint32_t reserve_limit,
major_t major, int flags);
DDII void ddi_xbuf_attr_destroy(ddi_xbuf_attr_t xap);
DDII void ddi_xbuf_attr_register_devinfo(ddi_xbuf_attr_t xbuf_attr,
dev_info_t *dip);
DDII void ddi_xbuf_attr_unregister_devinfo(ddi_xbuf_attr_t xbuf_attr,
dev_info_t *dip);
DDII int ddi_xbuf_qstrategy(struct buf *bp, ddi_xbuf_attr_t xap);
DDII int ddi_xbuf_done(struct buf *bp, ddi_xbuf_attr_t xap);
DDII ddi_xbuf_t ddi_xbuf_get(struct buf *bp, ddi_xbuf_attr_t xap);
DDII void ddi_xbuf_dispatch(ddi_xbuf_attr_t xap);
DDII void ddi_xbuf_flushq(ddi_xbuf_attr_t xap, int (*funcp)(struct buf *));
DDII int ddi_xbuf_attr_setup_brk(ddi_xbuf_attr_t xap, size_t size);
* The buf extension facility utilizes an internal pool of threads to perform
* callbacks into the given xa_strategy routines. Clients of the facility
* do not need to be concerned with the management of these threads as this is
* handled by the framework. However clients may recommend certain operational
* parameters for the framework to consider in performing its thread mangement
* by specifying one of the following flags to ddi_xbuf_attr_create():
* DDI_XBUF_QTHREAD_SYSTEM: This should be specified when the client driver
* provides an xa_strategy routine that is "well behaved", ie, does not
* block for memory, shared resources, or device states that may take a long
* or indeterminate amount of time to satisfy. The 'major' argument to
* ddi_xbuf_attr_create() may be zero if this flag is specified. (?)
* DDI_XBUF_QTHREAD_DRIVER: This should be specified when the client driver
* performs blocking operations within its xa_strategy routine that would
* make it unsuitable for being called from a shared system thread. The
* 'major' argument to ddi_xbuf_attr_create() must be the return value of
* ddi_driver_major() when this flag is specified.
* DDI_XBUF_QTHREAD_PRIVATE: This should be specified when the client driver
* would prefer to have a dedicated thread for a given ddi_xbuf_attr_t
* instantiation. The 'major' argument to ddi_xbuf_attr_create() must be
* the return value of ddi_driver_major() when this flag is specified. Note
* that this option ought to be used judiciously in order to avoid excessive
* consumption of system resources, especially if the client driver has a
* large number of ddi_xbuf_attr_t instantiations.
* Note that the above flags are mutually exclusive. Also note that the
* behaviors specified by these flags are merely advisory to the framework,
* and the framework is still free to implement its internal thread management
* policies as necessary and that these policies are opaque to drivers.
#endif /* defined(_KERNEL) || defined(_KMEMUSER) */
#ifdef __cplusplus