Cross Reference: /illumos-gate/usr/src/uts/common/io/sbp2/sbp2.c

Lines Matching defs:task
469  * Send task management request, one of:
546 	sbp2_task_t	*task = NULL;
557 	for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
558 		if (task->ts_state < SBP2_TASK_COMP) {
559 			task->ts_error = SBP2_TASK_ERR_LUN_RESET;
560 			task->ts_state = SBP2_TASK_COMP;
792 	 *	their associated task sets are cleared without
852 	sbp2_task_t	*task;
855 	for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
856 		if (task->ts_buf->bb_baddr == orbp) {
861 	return (task);
866  * 'task' argument is allowed to be NULL, in which case the task will be
867  * taken from the current task list.
870  * While SBP-2 allows dynamic task list updates and using DOORBELL register,
879 	sbp2_task_t	*task;		/* task actually being submitted */
892 	/* if task provided, append it to the list */
898 	/* if there is already a task in flight, exit */
916 	/* no active task, grab the first one on the list in INIT state */
923 	task = ap->a_active_task;
924 	task->ts_ses = sp;
925 	task->ts_state = SBP2_TASK_PEND;
928 	if (sbp2_agent_keepalive(ap, &task->ts_bus_error) != SBP2_SUCCESS) {
929 		task->ts_error = SBP2_TASK_ERR_DEAD;
934 	 * In theory, we should schedule task timeout after it's been submitted.
938 	ASSERT(task->ts_timeout_id == 0);
939 	task->ts_time_start = gethrtime();
940 	if (task->ts_timeout > 0) {
941 		task->ts_timeout_id = timeout(sbp2_task_timeout, task,
942 		    task->ts_timeout * drv_usectohz(1000000));
948 	ret = sbp2_agent_write_orbp(ap, task->ts_buf->bb_baddr,
949 	    &task->ts_bus_error);
957 		if (task->ts_timeout_id != 0) {
958 			timeout_id = task->ts_timeout_id;
959 			task->ts_timeout_id = 0;
962 		task->ts_error = SBP2_TASK_ERR_BUS;
973 	 * Return immediate error if failed task is the one being submitted,
977 	ASSERT(task == ap->a_active_task);
983 	 * Remove task from the list. It is important not to change task state
987 	ret = sbp2_ses_remove_task(sp, task);
989 	task->ts_state = SBP2_TASK_COMP;
992 		sp->s_status_cb(sp->s_status_cb_arg, task);
1007  * append task to the task list
1010 sbp2_ses_append_task(sbp2_ses_t *sp, sbp2_task_t *task)
1018 		task->ts_prev = task->ts_next = NULL;
1019 		sp->s_task_head = sp->s_task_tail = task;
1022 		task->ts_next = NULL;
1023 		task->ts_prev = sp->s_task_tail;
1024 		sp->s_task_tail->ts_next = task;
1025 		sp->s_task_tail = task;
1027 	ASSERT(task != task->ts_prev);
1028 	ASSERT(task != task->ts_next);
1038  * remove task from the task list
1041 sbp2_ses_remove_task_locked(sbp2_ses_t *sp, sbp2_task_t *task)
1044 	if (task == sp->s_task_head) {			/* first */
1045 		ASSERT(task->ts_prev == NULL);
1046 		if (task->ts_next == NULL) {		/*   and last */
1050 			sp->s_task_head = task->ts_next;
1053 	} else if (task == sp->s_task_tail) {		/* last but not first */
1054 		ASSERT(task->ts_next == NULL);
1055 		sp->s_task_tail = task->ts_prev;
1058 		task->ts_prev->ts_next = task->ts_next;
1059 		task->ts_next->ts_prev = task->ts_prev;
1061 	task->ts_prev = task->ts_next = NULL;
1068 sbp2_ses_remove_task(sbp2_ses_t *sp, sbp2_task_t *task)
1073 	ret = sbp2_ses_remove_task_locked(sp, task);
1080  * Return first task on the list in specified state.
1085 	sbp2_task_t	*task = NULL;
1088 	for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
1089 		if (task->ts_state == state) {
1095 	return (task);
1099  * Remove first task on the list. Returns pointer to the removed task or NULL.
1104 	sbp2_task_t	*task = NULL;
1107 	task = sp->s_task_head;
1108 	if (task != NULL) {
1109 		(void) sbp2_ses_remove_task_locked(sp, task);
1113 	return (task);
1117  * Remove first task on the list only if it's in specified state.
1118  * Returns pointer to the removed task or NULL.
1123 	sbp2_task_t	*task = NULL;
1127 		task = sp->s_task_head;
1128 		(void) sbp2_ses_remove_task_locked(sp, task);
1132 	return (task);
1136  * Remove first task on the list. If there's timeout, untimeout it.
1137  * Returns pointer to the removed task or NULL.
1142 	sbp2_task_t	*task = NULL;
1146 	task = sp->s_task_head;
1147 	if (task != NULL) {
1148 		(void) sbp2_ses_remove_task_locked(sp, task);
1152 	if ((task != NULL) && ((timeout_id = task->ts_timeout_id) != 0)) {
1153 		task->ts_timeout_id = 0;
1157 	return (task);
1167 	sbp2_task_t	*task = NULL;
1172 	for (task = sp->s_task_head; task != NULL; task = task->ts_next) {
1173 		task->ts_state = SBP2_TASK_INIT;
1176 		if ((timeout_id = task->ts_timeout_id) != 0) {
1177 			task->ts_timeout_id = 0;
1182 		orb = (sbp2_cmd_orb_t *)sbp2_task_orb_kaddr(task);
1184 		sbp2_task_orb_sync(sp->s_lun, task, DDI_DMA_SYNC_FORDEV);
1200 sbp2_ses_abort_task(sbp2_ses_t *sp, sbp2_task_t *task, int *berr)
1205 	sbp2_cmd_orb_t	*orb = (sbp2_cmd_orb_t *)task->ts_buf->bb_kaddr;
1211 	(void) SBP2_SYNC_BUF(tp, task->ts_buf, 0, 0, DDI_DMA_SYNC_FORDEV);
1214 	    SBP2_ORB_MGT_FUNC_ABORT_TASK, task->ts_buf->bb_baddr, berr);
1244 sbp2_orb_freelist_get(sbp2_lun_t *lp, sbp2_task_t *task, int len)
1310 sbp2_task_orb_alloc(sbp2_lun_t *lp, sbp2_task_t *task, int len)
1319 	if ((task->ts_buf = sbp2_orb_freelist_get(lp, task, buf_len)) != NULL) {
1324 	task->ts_buf = kmem_zalloc(sizeof (sbp2_bus_buf_t), KM_SLEEP);
1325 	task->ts_buf->bb_len = buf_len;
1326 	task->ts_buf->bb_flags = SBP2_BUS_BUF_DMA | SBP2_BUS_BUF_RD;
1327 	if ((ret = SBP2_ALLOC_BUF(tp, task->ts_buf)) != SBP2_SUCCESS) {
1328 		kmem_free(task->ts_buf, sizeof (sbp2_bus_buf_t));
1329 		task->ts_buf = NULL;
1336 sbp2_task_orb_free(sbp2_lun_t *lp, sbp2_task_t *task)
1340 	if (task->ts_buf != NULL) {
1341 		if (sbp2_orb_freelist_put(lp, task->ts_buf) != SBP2_SUCCESS) {
1342 			SBP2_FREE_BUF(tp, task->ts_buf);
1343 			kmem_free(task->ts_buf, sizeof (sbp2_bus_buf_t));
1345 		task->ts_buf = NULL;
1350 sbp2_task_orb_kaddr(sbp2_task_t *task)
1352 	return (task->ts_buf->bb_kaddr);
1356 sbp2_task_orb_sync(sbp2_lun_t *lp, sbp2_task_t *task, int flags)
1358 	(void) SBP2_SYNC_BUF(lp->l_tgt, task->ts_buf, 0, 0, flags);
1618 	sbp2_task_t	*task = arg;
1619 	sbp2_ses_t	*sp = task->ts_ses;
1625 	if (task->ts_timeout_id == 0) {
1629 	task->ts_timeout_id = 0;
1630 	task->ts_time_comp = gethrtime();
1633 	if (task->ts_state != SBP2_TASK_PEND) {
1638 	if (task == ap->a_active_task) {
1641 	task->ts_error = SBP2_TASK_ERR_TIMEOUT;
1642 	task->ts_state = SBP2_TASK_COMP;
1644 	/* we mark agent DEAD so it's reset before next task is submitted */
1649 	sp->s_status_cb(sp->s_status_cb_arg, task);
1666 	sbp2_task_t	*task;
1708 	/* find task corresponding to this ORB pointer */
1709 	if ((task = sbp2_ses_orbp2task(sp, orbp)) == NULL) {
1723 	bzero(&task->ts_status, sizeof (sbp2_status_t));
1724 	bcopy((*bpp)->b_rptr, &task->ts_status, len);
1730 	if ((timeout_id = task->ts_timeout_id) != 0) {
1731 		task->ts_timeout_id = 0;
1742 	if (task->ts_state != SBP2_TASK_PEND) {
1747 	if (task == ap->a_active_task) {
1750 	task->ts_error = SBP2_TASK_ERR_NONE;
1751 	task->ts_state = SBP2_TASK_COMP;
1755 	sp->s_status_cb(sp->s_status_cb_arg, task);	/* notify the driver */