Revert r323516 (iflib rollup)

This was really too big of a commit even if everything worked, but there
are multiple new issues introduced in the one huge commit, so it's not
worth keeping this until it's fixed.

I'll work on splitting this up into logical chunks and introduce them one
at a time over the next week or two.

Approved by:	sbruno (mentor)
Sponsored by:	Limelight Networks

1 files changed, 41 insertions, 293 deletions

diff --git a/sys/kern/subr_gtaskqueue.c b/sys/kern/subr_gtaskqueue.c
index 716aef6b1053..6a39a3aac14a 100644
--- a/sys/kern/subr_gtaskqueue.c
+++ b/sys/kern/subr_gtaskqueue.c
@@ -48,26 +48,17 @@ __FBSDID("$FreeBSD$");
 #include <sys/unistd.h>
 #include <machine/stdarg.h>
 
-static MALLOC_DEFINE(M_GTASKQUEUE, "gtaskqueue", "Group Task Queues");
+static MALLOC_DEFINE(M_GTASKQUEUE, "taskqueue", "Task Queues");
 static void	gtaskqueue_thread_enqueue(void *);
 static void	gtaskqueue_thread_loop(void *arg);
-static int	_taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread, int pri);
-TASKQGROUP_DEFINE(softirq, mp_ncpus, 1, false, PI_SOFT);
+
+TASKQGROUP_DEFINE(softirq, mp_ncpus, 1);
 
 struct gtaskqueue_busy {
 	struct gtask	*tb_running;
 	TAILQ_ENTRY(gtaskqueue_busy) tb_link;
 };
 
-struct gt_intr_thread {
-	int	git_flags;		/* (j) IT_* flags. */
-	int	git_need;		/* Needs service. */
-};
-
-/* Interrupt thread flags kept in it_flags */
-#define	IT_DEAD		0x000001	/* Thread is waiting to exit. */
-#define	IT_WAIT		0x000002	/* Thread is waiting for completion. */
-
 static struct gtask * const TB_DRAIN_WAITER = (struct gtask *)0x1;
 
 struct gtaskqueue {
@@ -78,7 +69,6 @@ struct gtaskqueue {
 	TAILQ_HEAD(, gtaskqueue_busy) tq_active;
 	struct mtx		tq_mutex;
 	struct thread		**tq_threads;
-	struct gt_intr_thread *tq_gt_intrs;
 	int			tq_tcount;
 	int			tq_spin;
 	int			tq_flags;
@@ -90,7 +80,6 @@ struct gtaskqueue {
 #define	TQ_FLAGS_ACTIVE		(1 << 0)
 #define	TQ_FLAGS_BLOCKED	(1 << 1)
 #define	TQ_FLAGS_UNLOCKED_ENQUEUE	(1 << 2)
-#define	TQ_FLAGS_INTR		(1 << 3)
 
 #define	DT_CALLOUT_ARMED	(1 << 0)
 
@@ -191,32 +180,6 @@ gtaskqueue_free(struct gtaskqueue *queue)
 	free(queue, M_GTASKQUEUE);
 }
 
-static void
-schedule_ithread(struct gtaskqueue *queue)
-{
-	struct proc *p;
-	struct thread *td;
-	struct gt_intr_thread *git;
-
-	MPASS(queue->tq_tcount == 1);
-	td = queue->tq_threads[0];
-	git = &queue->tq_gt_intrs[0];
-	p = td->td_proc;
-
-	atomic_store_rel_int(&git->git_need, 1);
-	thread_lock(td);
-	if (TD_AWAITING_INTR(td)) {
-		CTR3(KTR_INTR, "%s: schedule pid %d (%s)", __func__, p->p_pid,
-		    td->td_name);
-		TD_CLR_IWAIT(td);
-		sched_add(td, SRQ_INTR);
-	} else {
-		CTR5(KTR_INTR, "%s: pid %d (%s): it_need %d, state %d",
-		    __func__, p->p_pid, td->td_name, git->git_need, td->td_state);
-	}
-	thread_unlock(td);
-}
-
 int
 grouptaskqueue_enqueue(struct gtaskqueue *queue, struct gtask *gtask)
 {
@@ -234,13 +197,8 @@ grouptaskqueue_enqueue(struct gtaskqueue *queue, struct gtask *gtask)
 	STAILQ_INSERT_TAIL(&queue->tq_queue, gtask, ta_link);
 	gtask->ta_flags |= TASK_ENQUEUED;
 	TQ_UNLOCK(queue);
-	if ((queue->tq_flags & TQ_FLAGS_BLOCKED) == 0) {
-		if (queue->tq_flags & TQ_FLAGS_INTR) {
-			schedule_ithread(queue);
-		} else {
-			queue->tq_enqueue(queue->tq_context);
-		}
-	}
+	if ((queue->tq_flags & TQ_FLAGS_BLOCKED) == 0)
+		queue->tq_enqueue(queue->tq_context);
 	return (0);
 }
 
@@ -445,7 +403,7 @@ gtaskqueue_drain_all(struct gtaskqueue *queue)
 
 static int
 _gtaskqueue_start_threads(struct gtaskqueue **tqp, int count, int pri,
-    cpuset_t *mask, bool intr, const char *name, va_list ap)
+    cpuset_t *mask, const char *name, va_list ap)
 {
 	char ktname[MAXCOMLEN + 1];
 	struct thread *td;
@@ -464,12 +422,6 @@ _gtaskqueue_start_threads(struct gtaskqueue **tqp, int count, int pri,
 		printf("%s: no memory for %s threads\n", __func__, ktname);
 		return (ENOMEM);
 	}
-	tq->tq_gt_intrs = malloc(sizeof(struct gt_intr_thread) * count, M_GTASKQUEUE,
-	    M_NOWAIT | M_ZERO);
-	if (tq->tq_gt_intrs == NULL) {
-		printf("%s: no memory for %s intr info\n", __func__, ktname);
-		return (ENOMEM);
-	}
 
 	for (i = 0; i < count; i++) {
 		if (count == 1)
@@ -487,9 +439,6 @@ _gtaskqueue_start_threads(struct gtaskqueue **tqp, int count, int pri,
 		} else
 			tq->tq_tcount++;
 	}
-	if (intr)
-		tq->tq_flags |= TQ_FLAGS_INTR;
-
 	for (i = 0; i < count; i++) {
 		if (tq->tq_threads[i] == NULL)
 			continue;
@@ -509,14 +458,7 @@ _gtaskqueue_start_threads(struct gtaskqueue **tqp, int count, int pri,
 		}
 		thread_lock(td);
 		sched_prio(td, pri);
-		if (intr) {
-			/* we need to schedule the thread from the interrupt handler for this to work */
-			TD_SET_IWAIT(td);
-			sched_class(td, PRI_ITHD);
-			td->td_pflags |= TDP_ITHREAD;
-		} else {
-			sched_add(td, SRQ_BORING);
-		}
+		sched_add(td, SRQ_BORING);
 		thread_unlock(td);
 	}
 
@@ -525,13 +467,13 @@ _gtaskqueue_start_threads(struct gtaskqueue **tqp, int count, int pri,
 
 static int
 gtaskqueue_start_threads(struct gtaskqueue **tqp, int count, int pri,
-   bool intr, const char *name, ...)
+    const char *name, ...)
 {
 	va_list ap;
 	int error;
 
 	va_start(ap, name);
-	error = _gtaskqueue_start_threads(tqp, count, pri, NULL, intr, name, ap);
+	error = _gtaskqueue_start_threads(tqp, count, pri, NULL, name, ap);
 	va_end(ap);
 	return (error);
 }
@@ -549,58 +491,16 @@ gtaskqueue_run_callback(struct gtaskqueue *tq,
 }
 
 static void
-intr_thread_loop(struct gtaskqueue *tq)
+gtaskqueue_thread_loop(void *arg)
 {
-	struct gt_intr_thread *git;
-	struct thread *td;
-
-	git = &tq->tq_gt_intrs[0];
-	td = tq->tq_threads[0];
-	MPASS(tq->tq_tcount == 1);
-
-	while ((tq->tq_flags & TQ_FLAGS_ACTIVE) != 0) {
-		THREAD_NO_SLEEPING();
-		while (atomic_cmpset_acq_int(&git->git_need, 1, 0) != 0) {
-			gtaskqueue_run_locked(tq);
-		}
-		THREAD_SLEEPING_OK();
-
-		/*
-		 * Because taskqueue_run() can drop tq_mutex, we need to
-		 * check if the TQ_FLAGS_ACTIVE flag wasn't removed in the
-		 * meantime, which means we missed a wakeup.
-		 */
-		if ((tq->tq_flags & TQ_FLAGS_ACTIVE) == 0)
-			break;
-
-		TQ_UNLOCK(tq);
-		WITNESS_WARN(WARN_PANIC, NULL, "suspending ithread");
-		mtx_assert(&Giant, MA_NOTOWNED);
-		thread_lock(td);
-		if (atomic_load_acq_int(&git->git_need) == 0 &&
-		    (git->git_flags & (IT_DEAD | IT_WAIT)) == 0) {
-			TD_SET_IWAIT(td);
-			mi_switch(SW_VOL | SWT_IWAIT, NULL);
-		}
-#if 0
-		/* XXX is this something we want? */
-		if (git->git_flags & IT_WAIT) {
-			wake = 1;
-			git->git_flags &= ~IT_WAIT;
-		}
-#endif
-		thread_unlock(td);
-		TQ_LOCK(tq);
-	}
-	THREAD_NO_SLEEPING();
-	gtaskqueue_run_locked(tq);
-	THREAD_SLEEPING_OK();
-}
+	struct gtaskqueue **tqp, *tq;
 
-static void
-timeshare_thread_loop(struct gtaskqueue *tq)
-{
+	tqp = arg;
+	tq = *tqp;
+	gtaskqueue_run_callback(tq, TASKQUEUE_CALLBACK_TYPE_INIT);
+	TQ_LOCK(tq);
 	while ((tq->tq_flags & TQ_FLAGS_ACTIVE) != 0) {
+		/* XXX ? */
 		gtaskqueue_run_locked(tq);
 		/*
 		 * Because taskqueue_run() can drop tq_mutex, we need to
@@ -612,23 +512,6 @@ timeshare_thread_loop(struct gtaskqueue *tq)
 		TQ_SLEEP(tq, tq, &tq->tq_mutex, 0, "-", 0);
 	}
 	gtaskqueue_run_locked(tq);
-}
-
-static void
-gtaskqueue_thread_loop(void *arg)
-{
-	struct gtaskqueue **tqp, *tq;
-
-	tqp = arg;
-	tq = *tqp;
-	gtaskqueue_run_callback(tq, TASKQUEUE_CALLBACK_TYPE_INIT);
-	TQ_LOCK(tq);
-	if (curthread->td_pflags & TDP_ITHREAD) {
-		intr_thread_loop(tq);
-	} else {
-		timeshare_thread_loop(tq);
-	}
-
 	/*
 	 * This thread is on its way out, so just drop the lock temporarily
 	 * in order to call the shutdown callback.  This allows the callback
@@ -675,17 +558,11 @@ struct taskqgroup_cpu {
 struct taskqgroup {
 	struct taskqgroup_cpu tqg_queue[MAXCPU];
 	struct mtx	tqg_lock;
-	void (*adjust_func)(void*);
 	char *		tqg_name;
 	int		tqg_adjusting;
 	int		tqg_stride;
 	int		tqg_cnt;
-	int		tqg_pri;
-	int		tqg_flags;
-	bool		tqg_intr;
 };
-#define TQG_NEED_ADJUST	0x1
-#define TQG_ADJUSTED		0x2
 
 struct taskq_bind_task {
 	struct gtask bt_task;
@@ -693,16 +570,16 @@ struct taskq_bind_task {
 };
 
 static void
-taskqgroup_cpu_create(struct taskqgroup *qgroup, int idx, int cpu, bool intr, int pri)
+taskqgroup_cpu_create(struct taskqgroup *qgroup, int idx, int cpu)
 {
 	struct taskqgroup_cpu *qcpu;
 
 	qcpu = &qgroup->tqg_queue[idx];
 	LIST_INIT(&qcpu->tgc_tasks);
-	qcpu->tgc_taskq = gtaskqueue_create_fast(NULL, M_WAITOK | M_ZERO,
+	qcpu->tgc_taskq = gtaskqueue_create_fast(NULL, M_WAITOK,
 	    taskqueue_thread_enqueue, &qcpu->tgc_taskq);
-	gtaskqueue_start_threads(&qcpu->tgc_taskq, 1, pri,
-	    intr, "%s_%d", qgroup->tqg_name, idx);
+	gtaskqueue_start_threads(&qcpu->tgc_taskq, 1, PI_SOFT,
+	    "%s_%d", qgroup->tqg_name, idx);
 	qcpu->tgc_cpu = cpu;
 }
 
@@ -786,20 +663,12 @@ taskqgroup_attach(struct taskqgroup *qgroup, struct grouptask *gtask,
     void *uniq, int irq, char *name)
 {
 	cpuset_t mask;
-	int qid, error;
+	int qid;
 
 	gtask->gt_uniq = uniq;
 	gtask->gt_name = name;
 	gtask->gt_irq = irq;
 	gtask->gt_cpu = -1;
-
-	mtx_lock(&qgroup->tqg_lock);
-	qgroup->tqg_flags |= TQG_NEED_ADJUST;
-	mtx_unlock(&qgroup->tqg_lock);
-
-	if (tqg_smp_started && !(qgroup->tqg_flags & TQG_ADJUSTED))
-		qgroup->adjust_func(NULL);
-
 	mtx_lock(&qgroup->tqg_lock);
 	qid = taskqgroup_find(qgroup, uniq);
 	qgroup->tqg_queue[qid].tgc_cnt++;
@@ -810,9 +679,7 @@ taskqgroup_attach(struct taskqgroup *qgroup, struct grouptask *gtask,
 		CPU_ZERO(&mask);
 		CPU_SET(qgroup->tqg_queue[qid].tgc_cpu, &mask);
 		mtx_unlock(&qgroup->tqg_lock);
-		error = intr_setaffinity(irq, CPU_WHICH_INTRHANDLER, &mask);
-		if (error)
-			printf("taskqgroup_attach: setaffinity failed: %d\n", error);
+		intr_setaffinity(irq, CPU_WHICH_IRQ, &mask);
 	} else
 		mtx_unlock(&qgroup->tqg_lock);
 }
@@ -821,7 +688,7 @@ static void
 taskqgroup_attach_deferred(struct taskqgroup *qgroup, struct grouptask *gtask)
 {
 	cpuset_t mask;
-	int qid, cpu, error;
+	int qid, cpu;
 
 	mtx_lock(&qgroup->tqg_lock);
 	qid = taskqgroup_find(qgroup, gtask->gt_uniq);
@@ -831,10 +698,9 @@ taskqgroup_attach_deferred(struct taskqgroup *qgroup, struct grouptask *gtask)
 
 		CPU_ZERO(&mask);
 		CPU_SET(cpu, &mask);
-		error = intr_setaffinity(gtask->gt_irq, CPU_WHICH_INTRHANDLER, &mask);
+		intr_setaffinity(gtask->gt_irq, CPU_WHICH_IRQ, &mask);
+
 		mtx_lock(&qgroup->tqg_lock);
-		if (error)
-			printf("taskqgroup_attach_deferred: setaffinity failed: %d\n", error);
 	}
 	qgroup->tqg_queue[qid].tgc_cnt++;
 
@@ -845,79 +711,27 @@ taskqgroup_attach_deferred(struct taskqgroup *qgroup, struct grouptask *gtask)
 	mtx_unlock(&qgroup->tqg_lock);
 }
 
-static int
-taskqgroup_adjust_deferred(struct taskqgroup *qgroup, int cpu)
-{
-	int i, error = 0, cpu_max = -1;
-
-	mtx_lock(&qgroup->tqg_lock);
-	for (i = 0; i < qgroup->tqg_cnt; i++)
-		if (qgroup->tqg_queue[i].tgc_cpu > cpu_max)
-			cpu_max = qgroup->tqg_queue[i].tgc_cpu;
-	if (cpu_max >= cpu) {
-		mtx_unlock(&qgroup->tqg_lock);
-		return (0);
-	}
-	MPASS(cpu <= mp_maxid);
-	error = _taskqgroup_adjust(qgroup, cpu + 1, qgroup->tqg_stride,
-				   qgroup->tqg_intr, qgroup->tqg_pri);
-	if (error) {
-		printf("%s: _taskqgroup_adjust(%p, %d, %d, %d, %d) => %d\n\n",
-		       __func__, qgroup, cpu + 1, qgroup->tqg_stride, qgroup->tqg_intr,
-		       qgroup->tqg_pri, error);
-		goto out;
-	}
-	for (i = 0; i < qgroup->tqg_cnt; i++)
-		if (qgroup->tqg_queue[i].tgc_cpu > cpu_max)
-			cpu_max = qgroup->tqg_queue[i].tgc_cpu;
-	MPASS(cpu_max >= cpu);
-out:
-	mtx_unlock(&qgroup->tqg_lock);
-	return (error);
-}
-
 int
 taskqgroup_attach_cpu(struct taskqgroup *qgroup, struct grouptask *gtask,
 	void *uniq, int cpu, int irq, char *name)
 {
 	cpuset_t mask;
-	int i, error, qid;
+	int i, qid;
 
 	qid = -1;
 	gtask->gt_uniq = uniq;
 	gtask->gt_name = name;
 	gtask->gt_irq = irq;
 	gtask->gt_cpu = cpu;
-	MPASS(cpu >= 0);
-
-	mtx_lock(&qgroup->tqg_lock);
-	qgroup->tqg_flags |= TQG_NEED_ADJUST;
-	mtx_unlock(&qgroup->tqg_lock);
-
-	if (tqg_smp_started && !(qgroup->tqg_flags & TQG_ADJUSTED)) {
-		uintptr_t cpuid = cpu + 1;
-		qgroup->adjust_func((void *)cpuid);
-	}
-	if ((error = taskqgroup_adjust_deferred(qgroup, cpu)))
-		return (error);
-
 	mtx_lock(&qgroup->tqg_lock);
 	if (tqg_smp_started) {
-		for (i = 0; i < qgroup->tqg_cnt; i++) {
+		for (i = 0; i < qgroup->tqg_cnt; i++)
 			if (qgroup->tqg_queue[i].tgc_cpu == cpu) {
 				qid = i;
 				break;
 			}
-#ifdef INVARIANTS
-			else
-				printf("qgroup->tqg_queue[%d].tgc_cpu=0x%x tgc_cnt=0x%x\n",
-				       i, qgroup->tqg_queue[i].tgc_cpu, qgroup->tqg_queue[i].tgc_cnt);
-
-#endif
-		}
 		if (qid == -1) {
 			mtx_unlock(&qgroup->tqg_lock);
-			printf("%s: qid not found for cpu=%d\n", __func__, cpu);
 			return (EINVAL);
 		}
 	} else
@@ -930,11 +744,8 @@ taskqgroup_attach_cpu(struct taskqgroup *qgroup, struct grouptask *gtask,
 
 	CPU_ZERO(&mask);
 	CPU_SET(cpu, &mask);
-	if (irq != -1 && tqg_smp_started) {
-		error = intr_setaffinity(irq, CPU_WHICH_INTRHANDLER, &mask);
-		if (error)
-			printf("taskqgroup_attach_cpu: setaffinity failed: %d\n", error);
-	}
+	if (irq != -1 && tqg_smp_started)
+		intr_setaffinity(irq, CPU_WHICH_IRQ, &mask);
 	return (0);
 }
 
@@ -942,18 +753,13 @@ static int
 taskqgroup_attach_cpu_deferred(struct taskqgroup *qgroup, struct grouptask *gtask)
 {
 	cpuset_t mask;
-	int i, qid, irq, cpu, error;
+	int i, qid, irq, cpu;
 
 	qid = -1;
 	irq = gtask->gt_irq;
 	cpu = gtask->gt_cpu;
 	MPASS(tqg_smp_started);
-
-	if ((error = taskqgroup_adjust_deferred(qgroup, cpu)))
-		return (error);
 	mtx_lock(&qgroup->tqg_lock);
-	/* adjust as needed */
-	MPASS(cpu <= mp_maxid);
 	for (i = 0; i < qgroup->tqg_cnt; i++)
 		if (qgroup->tqg_queue[i].tgc_cpu == cpu) {
 			qid = i;
@@ -961,7 +767,6 @@ taskqgroup_attach_cpu_deferred(struct taskqgroup *qgroup, struct grouptask *gtas
 		}
 	if (qid == -1) {
 		mtx_unlock(&qgroup->tqg_lock);
-		printf("%s: qid not found for cpu=%d\n", __func__, cpu);
 		return (EINVAL);
 	}
 	qgroup->tqg_queue[qid].tgc_cnt++;
@@ -973,11 +778,8 @@ taskqgroup_attach_cpu_deferred(struct taskqgroup *qgroup, struct grouptask *gtas
 	CPU_ZERO(&mask);
 	CPU_SET(cpu, &mask);
 
-	if (irq != -1) {
-		error = intr_setaffinity(irq, CPU_WHICH_INTRHANDLER, &mask);
-		if (error)
-			printf("taskqgroup_attach_cpu: setaffinity failed: %d\n", error);
-	}
+	if (irq != -1)
+		intr_setaffinity(irq, CPU_WHICH_IRQ, &mask);
 	return (0);
 }
 
@@ -1016,25 +818,8 @@ taskqgroup_binder(void *ctx)
 		printf("taskqgroup_binder: setaffinity failed: %d\n",
 		    error);
 	free(gtask, M_DEVBUF);
-
 }
-static void
-taskqgroup_ithread_binder(void *ctx)
-{
-	struct taskq_bind_task *gtask = (struct taskq_bind_task *)ctx;
-	cpuset_t mask;
-	int error;
-
-	CPU_ZERO(&mask);
-	CPU_SET(gtask->bt_cpuid, &mask);
-	error = cpuset_setthread(curthread->td_tid, &mask);
 
-	if (error)
-		printf("taskqgroup_binder: setaffinity failed: %d\n",
-		    error);
-	free(gtask, M_DEVBUF);
-
-}
 static void
 taskqgroup_bind(struct taskqgroup *qgroup)
 {
@@ -1050,10 +835,7 @@ taskqgroup_bind(struct taskqgroup *qgroup)
 
 	for (i = 0; i < qgroup->tqg_cnt; i++) {
 		gtask = malloc(sizeof (*gtask), M_DEVBUF, M_WAITOK);
-		if (qgroup->tqg_intr)
-			GTASK_INIT(&gtask->bt_task, 0, 0, taskqgroup_ithread_binder, gtask);
-		else
-			GTASK_INIT(&gtask->bt_task, 0, 0, taskqgroup_binder, gtask);
+		GTASK_INIT(&gtask->bt_task, 0, 0, taskqgroup_binder, gtask);
 		gtask->bt_cpuid = qgroup->tqg_queue[i].tgc_cpu;
 		grouptaskqueue_enqueue(qgroup->tqg_queue[i].tgc_taskq,
 		    &gtask->bt_task);
@@ -1061,7 +843,7 @@ taskqgroup_bind(struct taskqgroup *qgroup)
 }
 
 static int
-_taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread, int pri)
+_taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride)
 {
 	LIST_HEAD(, grouptask) gtask_head = LIST_HEAD_INITIALIZER(NULL);
 	struct grouptask *gtask;
@@ -1076,22 +858,14 @@ _taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread,
 		return (EINVAL);
 	}
 	if (qgroup->tqg_adjusting) {
-		printf("%s: failed: adjusting\n", __func__);
+		printf("taskqgroup_adjust failed: adjusting\n");
 		return (EBUSY);
 	}
-	/* No work to be done */
-	if (qgroup->tqg_cnt == cnt)
-		return (0);
 	qgroup->tqg_adjusting = 1;
 	old_cnt = qgroup->tqg_cnt;
 	old_cpu = 0;
-	if (old_cnt < cnt) {
-		int old_max_idx = max(0, old_cnt-1);
-		old_cpu = qgroup->tqg_queue[old_max_idx].tgc_cpu;
-		if (old_cnt > 0)
-			for (k = 0; k < stride; k++)
-				old_cpu = CPU_NEXT(old_cpu);
-	}
+	if (old_cnt < cnt)
+		old_cpu = qgroup->tqg_queue[old_cnt].tgc_cpu;
 	mtx_unlock(&qgroup->tqg_lock);
 	/*
 	 * Set up queue for tasks added before boot.
@@ -1107,7 +881,7 @@ _taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread,
 	 */
 	cpu = old_cpu;
 	for (i = old_cnt; i < cnt; i++) {
-		taskqgroup_cpu_create(qgroup, i, cpu, ithread, pri);
+		taskqgroup_cpu_create(qgroup, i, cpu);
 
 		for (k = 0; k < stride; k++)
 			cpu = CPU_NEXT(cpu);
@@ -1115,8 +889,6 @@ _taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread,
 	mtx_lock(&qgroup->tqg_lock);
 	qgroup->tqg_cnt = cnt;
 	qgroup->tqg_stride = stride;
-	qgroup->tqg_intr = ithread;
-	qgroup->tqg_pri = pri;
 
 	/*
 	 * Adjust drivers to use new taskqs.
@@ -1162,34 +934,12 @@ _taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread,
 }
 
 int
-taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride, bool ithread, int pri)
+taskqgroup_adjust(struct taskqgroup *qgroup, int cnt, int stride)
 {
 	int error;
 
 	mtx_lock(&qgroup->tqg_lock);
-	error = _taskqgroup_adjust(qgroup, cnt, stride, ithread, pri);
-	mtx_unlock(&qgroup->tqg_lock);
-
-	return (error);
-}
-
-void
-taskqgroup_set_adjust(struct taskqgroup *qgroup, void (*adjust_func)(void*))
-{
-	qgroup-> adjust_func = adjust_func;
-}
-
-int
-taskqgroup_adjust_once(struct taskqgroup *qgroup, int cnt, int stride, bool ithread, int pri)
-{
-	int error = 0;
-
-	mtx_lock(&qgroup->tqg_lock);
-	if ((qgroup->tqg_flags & (TQG_ADJUSTED|TQG_NEED_ADJUST)) == TQG_NEED_ADJUST) {
-		qgroup->tqg_flags |= TQG_ADJUSTED;
-		error = _taskqgroup_adjust(qgroup, cnt, stride, ithread, pri);
-		MPASS(error == 0);
-	}
+	error = _taskqgroup_adjust(qgroup, cnt, stride);
 	mtx_unlock(&qgroup->tqg_lock);
 
 	return (error);
@@ -1204,9 +954,7 @@ taskqgroup_create(char *name)
 	mtx_init(&qgroup->tqg_lock, "taskqgroup", NULL, MTX_DEF);
 	qgroup->tqg_name = name;
 	LIST_INIT(&qgroup->tqg_queue[0].tgc_tasks);
-	MPASS(qgroup->tqg_queue[0].tgc_cnt == 0);
-	MPASS(qgroup->tqg_queue[0].tgc_cpu == 0);
-	MPASS(qgroup->tqg_queue[0].tgc_taskq == 0);
+
 	return (qgroup);
 }