 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_diskqueue.c,v 1.58 2020/06/19 19:32:03 jdolecek Exp $	*/
+/*	$NetBSD: rf_diskqueue.c,v 1.59 2021/07/23 00:26:19 oster Exp $	*/
 /*
  * Copyright (c) 1995 Carnegie-Mellon University.
  * All rights reserved.
+ *
  * Author: Mark Holland
+ *
  * Permission to use, copy, modify and distribute this software and
  * its documentation is hereby granted, provided that both the copyright
  * notice and this permission notice appear in all copies of the
  * software, derivative works or modified versions, and any portions
  * thereof, and that both notices appear in supporting documentation.
+ *
  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 @@ -56,44 +56,46 @@
+ *
  * Unfortunately, the code is different in the 3 different operating
  * states (user level, kernel, simulator).  In the kernel, I/O is
  * non-blocking, and we have no disk threads to dispatch for us.
  * Therefore, we have to dispatch new I/Os to the scsi driver at the
  * time of enqueue, and also at the time of completion.  At user
  * level, I/O is blocking, and so only the disk threads may dispatch
  * I/Os.  Thus at user level, all we can do at enqueue time is enqueue
  * and wake up the disk thread to do the dispatch.
+ *
  ****************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_diskqueue.c,v 1.58 2020/06/19 19:32:03 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_diskqueue.c,v 1.59 2021/07/23 00:26:19 oster Exp $");
 #include <dev/raidframe/raidframevar.h>
 #include "rf_threadstuff.h"
 #include "rf_raid.h"
 #include "rf_diskqueue.h"
 #include "rf_alloclist.h"
 #include "rf_acctrace.h"
 #include "rf_etimer.h"
 #include "rf_general.h"
 #include "rf_debugprint.h"
 #include "rf_shutdown.h"
 #include "rf_cvscan.h"
 #include "rf_sstf.h"
 #include "rf_fifo.h"
 #include "rf_kintf.h"
 #include <sys/buf.h>
 static void rf_ShutdownDiskQueueSystem(void *);
 #ifndef RF_DEBUG_DISKQUEUE
 #define RF_DEBUG_DISKQUEUE 0
 #endif
 #if RF_DEBUG_DISKQUEUE
 #define Dprintf1(s,a)         if (rf_queueDebug) rf_debug_printf(s,(void *)((unsigned long)a),NULL,NULL,NULL,NULL,NULL,NULL,NULL)
 #define Dprintf2(s,a,b)       if (rf_queueDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),NULL,NULL,NULL,NULL,NULL,NULL)
 #define Dprintf3(s,a,b,c)     if (rf_queueDebug) rf_debug_printf(s,(void *)((unsigned long)a),(void *)((unsigned long)b),(void *)((unsigned long)c),NULL,NULL,NULL,NULL,NULL)
 #else
 #define Dprintf1(s,a)
 #define Dprintf2(s,a,b)
 @@ -137,30 +139,35 @@ static const RF_DiskQueueSW_t diskqueues
 		rf_ScanPeek,
 	rf_SstfPromote},
 	{"cscan",		/* CSCAN (one-way elevator) */
 		rf_CscanCreate,
 		rf_SstfEnqueue,
 		rf_CscanDequeue,
 		rf_CscanPeek,
 	rf_SstfPromote},
 };
 #define NUM_DISK_QUEUE_TYPES (sizeof(diskqueuesw)/sizeof(RF_DiskQueueSW_t))
 #define RF_MAX_FREE_DQD 256
 #define RF_MIN_FREE_DQD  64
-#include <sys/buf.h>
+/* XXX: scale these... */
 #define RF_MAX_FREE_BUFIO 256
 #define RF_MIN_FREE_BUFIO  64
 /* configures a single disk queue */
 static void
 rf_ShutdownDiskQueue(void *arg)
+{
 	RF_DiskQueue_t *diskqueue = arg;
 	rf_destroy_mutex2(diskqueue->mutex);
+}
 int
 rf_ConfigureDiskQueue(RF_Raid_t *raidPtr, RF_DiskQueue_t *diskqueue,
 @@ -179,34 +186,37 @@ rf_ConfigureDiskQueue(RF_Raid_t *raidPtr
 	diskqueue->curPriority = RF_IO_NORMAL_PRIORITY;
 	diskqueue->flags = 0;
 	diskqueue->raidPtr = raidPtr;
 	diskqueue->rf_cinfo = &raidPtr->raid_cinfo[c];
 	rf_init_mutex2(diskqueue->mutex, IPL_VM);
 	rf_ShutdownCreate(listp, rf_ShutdownDiskQueue, diskqueue);
 	return (0);
+}
 static void
 rf_ShutdownDiskQueueSystem(void *ignored)
+{
 	pool_destroy(&rf_pools.dqd);
 	pool_destroy(&rf_pools.bufio);
+}
 int
 rf_ConfigureDiskQueueSystem(RF_ShutdownList_t **listp)
+{
 	rf_pool_init(&rf_pools.dqd, sizeof(RF_DiskQueueData_t),
 		     "rf_dqd_pl", RF_MIN_FREE_DQD, RF_MAX_FREE_DQD);
 	rf_pool_init(&rf_pools.bufio, sizeof(buf_t),
 		     "rf_bufio_pl", RF_MIN_FREE_BUFIO, RF_MAX_FREE_BUFIO);
 	rf_ShutdownCreate(listp, rf_ShutdownDiskQueueSystem, NULL);
 	return (0);
+}
 int
 rf_ConfigureDiskQueues(RF_ShutdownList_t **listp, RF_Raid_t *raidPtr,
 		       RF_Config_t *cfgPtr)
+{
 	RF_DiskQueue_t *diskQueues, *spareQueues;
 	const RF_DiskQueueSW_t *p;
 	RF_RowCol_t r,c;
 	int     rc, i;
 @@ -357,54 +367,55 @@ rf_DiskIOPromote(RF_DiskQueue_t *queue,
 RF_DiskQueueData_t *
 rf_CreateDiskQueueData(RF_IoType_t typ, RF_SectorNum_t ssect,
 		       RF_SectorCount_t nsect, void *bf,
 		       RF_StripeNum_t parityStripeID,
 		       RF_ReconUnitNum_t which_ru,
 		       void (*wakeF) (void *, int), void *arg,
 		       RF_AccTraceEntry_t *tracerec, RF_Raid_t *raidPtr,
 		       RF_DiskQueueDataFlags_t flags, const struct buf *mbp,
 		       int waitflag)
+{
 	RF_DiskQueueData_t *p;
-	p = pool_get(&rf_pools.dqd, waitflag | PR_ZERO);
+	p = pool_get(&rf_pools.dqd, PR_WAITOK | PR_ZERO);
-	if (p == NULL)
+	KASSERT(p != NULL);
 		return (NULL);
-	if (waitflag == PR_WAITOK) {
+	/* Obtain a buffer from our own pool.  It is possible for the
-		p->bp = getiobuf(NULL, true);
+	   regular getiobuf() to run out of memory and return NULL.
-	} else {
+	   We need to guarantee that never happens, as RAIDframe
-		p->bp = getiobuf(NULL, false);
+	   doesn't have a good way to recover if memory allocation
 	   fails here.
-	if (p->bp == NULL) {
+	*/
-		pool_put(&rf_pools.dqd, p);
+	p->bp = pool_get(&rf_pools.bufio, PR_WAITOK | PR_ZERO);
-		return (NULL);
+	KASSERT(p->bp != NULL);
 	buf_init(p->bp);
 	SET(p->bp->b_cflags, BC_BUSY);	/* mark buffer busy */
 	if (mbp) {
 		SET(p->bp->b_flags, mbp->b_flags & rf_b_pass);
 		p->bp->b_proc = mbp->b_proc;
+	}
 	p->sectorOffset = ssect + rf_protectedSectors;
 	p->numSector = nsect;
 	p->type = typ;
 	p->buf = bf;
 	p->parityStripeID = parityStripeID;
 	p->which_ru = which_ru;
 	p->CompleteFunc = wakeF;
 	p->argument = arg;
 	p->next = NULL;
 	p->tracerec = tracerec;
 	p->priority = RF_IO_NORMAL_PRIORITY;
 	p->raidPtr = raidPtr;
 	p->flags = flags;
 	return (p);
+}
 void
 rf_FreeDiskQueueData(RF_DiskQueueData_t *p)
+{
-	putiobuf(p->bp);
+	pool_put(&rf_pools.bufio, p->bp);
 	pool_put(&rf_pools.dqd, p);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsd.h,v 1.35 2020/06/19 19:29:39 jdolecek Exp $	*/
+/*	$NetBSD: rf_netbsd.h,v 1.36 2021/07/23 00:26:19 oster Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Greg Oster; Jason R. Thorpe.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -51,26 +51,27 @@ struct raidcinfo {
 	size_t  ci_pathlen;	/* length of component path */
 #endif
 };
 /* a little structure to serve as a container for all the various
    global pools used in RAIDframe */
 struct RF_Pools_s {
 	struct pool alloclist;   /* AllocList */
 	struct pool asm_hdr;     /* Access Stripe Map Header */
 	struct pool asmap;       /* Access Stripe Map */
 	struct pool asmhle;      /* Access Stripe Map Header List Elements */
 	struct pool bufio;       /* Buffer IO Pool */
 	struct pool callbackf;   /* Callback function descriptors */
 	struct pool callbackv;   /* Callback value descriptors */
 	struct pool dagh;        /* DAG headers */
 	struct pool dagnode;     /* DAG nodes */
 	struct pool daglist;     /* DAG lists */
 	struct pool dagpcache;   /* DAG pointer/param cache */
 	struct pool dqd;         /* Disk Queue Data */
 	struct pool fss;         /* Failed Stripe Structures */
 	struct pool funclist;    /* Function Lists */
 	struct pool mcpair;      /* Mutex/Cond Pairs */
 	struct pool pda;         /* Physical Disk Access structures */
 	struct pool pss;         /* Parity Stripe Status */
 	struct pool pss_issued;  /* Parity Stripe Status Issued */