 @@ -1,14 +1,14 @@
-/*	$NetBSD: rf_netbsdkintf.c,v 1.265 2009/06/10 14:17:13 pooka Exp $	*/
+/*	$NetBSD: rf_netbsdkintf.c,v 1.266 2009/07/23 21:58:06 dyoung Exp $	*/
 /*-
  * Copyright (c) 1996, 1997, 1998, 2008 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.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -129,27 +129,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /***********************************************************
+ *
  * rf_kintf.c -- the kernel interface routines for RAIDframe
+ *
  ***********************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.265 2009/06/10 14:17:13 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rf_netbsdkintf.c,v 1.266 2009/07/23 21:58:06 dyoung Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_raid_autoconfig.h"
 #include "raid.h"
 #endif
 #include <sys/param.h>
 #include <sys/errno.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/disk.h>
 @@ -250,35 +250,37 @@ static struct dkdriver rf_dkdriver = { r
 struct raid_softc {
 	device_t sc_dev;
 	int     sc_flags;	/* flags */
 	int     sc_cflags;	/* configuration flags */
 	uint64_t sc_size;	/* size of the raid device */
 	char    sc_xname[20];	/* XXX external name */
 	struct disk sc_dkdev;	/* generic disk device info */
 	struct bufq_state *buf_queue;	/* used for the device queue */
 };
 /* sc_flags */
 #define RAIDF_INITED	0x01	/* unit has been initialized */
 #define RAIDF_WLABEL	0x02	/* label area is writable */
 #define RAIDF_LABELLING	0x04	/* unit is currently being labelled */
 #define RAIDF_SHUTDOWN	0x08	/* unit is being shutdown */
 #define RAIDF_WANTED	0x40	/* someone is waiting to obtain a lock */
 #define RAIDF_LOCKED	0x80	/* unit is locked */
 #define	raidunit(x)	DISKUNIT(x)
 int numraid = 0;
 extern struct cfdriver raid_cd;
-CFATTACH_DECL_NEW(raid, sizeof(struct raid_softc),
+CFATTACH_DECL3_NEW(raid, sizeof(struct raid_softc),
-    raid_match, raid_attach, raid_detach, NULL);
+    raid_match, raid_attach, raid_detach, NULL, NULL, NULL,
     DVF_DETACH_SHUTDOWN);
 /*
  * Allow RAIDOUTSTANDING number of simultaneous IO's to this RAID device.
  * Be aware that large numbers can allow the driver to consume a lot of
  * kernel memory, especially on writes, and in degraded mode reads.
+ *
  * For example: with a stripe width of 64 blocks (32k) and 5 disks,
  * a single 64K write will typically require 64K for the old data,
  * 64K for the old parity, and 64K for the new parity, for a total
  * of 192K (if the parity buffer is not re-used immediately).
  * Even it if is used immediately, that's still 128K, which when multiplied
  * by say 10 requests, is 1280K, *on top* of the 640K of incoming data.
+ *
 @@ -295,26 +297,28 @@ CFATTACH_DECL_NEW(raid, sizeof(struct ra
 	(MAKEDISKDEV(major((dev)), raidunit((dev)), RAW_PART))
 /* declared here, and made public, for the benefit of KVM stuff.. */
 struct raid_softc *raid_softc;
 static void raidgetdefaultlabel(RF_Raid_t *, struct raid_softc *,
 				     struct disklabel *);
 static void raidgetdisklabel(dev_t);
 static void raidmakedisklabel(struct raid_softc *);
 static int raidlock(struct raid_softc *);
 static void raidunlock(struct raid_softc *);
 static int raid_detach_unlocked(struct raid_softc *);
 static void rf_markalldirty(RF_Raid_t *);
 static void rf_set_properties(struct raid_softc *, RF_Raid_t *);
 void rf_ReconThread(struct rf_recon_req *);
 void rf_RewriteParityThread(RF_Raid_t *raidPtr);
 void rf_CopybackThread(RF_Raid_t *raidPtr);
 void rf_ReconstructInPlaceThread(struct rf_recon_req *);
 int rf_autoconfig(device_t);
 void rf_buildroothack(RF_ConfigSet_t *);
 RF_AutoConfig_t *rf_find_raid_components(void);
 RF_ConfigSet_t *rf_create_auto_sets(RF_AutoConfig_t *);
 static int rf_does_it_fit(RF_ConfigSet_t *,RF_AutoConfig_t *);
 @@ -719,26 +723,32 @@ raidopen(dev_t dev, int flags, int fmt,
+{
 	int     unit = raidunit(dev);
 	struct raid_softc *rs;
 	struct disklabel *lp;
 	int     part, pmask;
 	int     error = 0;
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((error = raidlock(rs)) != 0)
 		return (error);
 	if ((rs->sc_flags & RAIDF_SHUTDOWN) != 0) {
 		error = EBUSY;
 		goto bad;
+	}
 	lp = rs->sc_dkdev.dk_label;
 	part = DISKPART(dev);
 	/*
 	 * If there are wedges, and this is not RAW_PART, then we
 	 * need to fail.
 	 */
 	if (rs->sc_dkdev.dk_nwedges != 0 && part != RAW_PART) {
 		error = EBUSY;
 		goto bad;
+	}
 	pmask = (1 << part);
 @@ -787,27 +797,26 @@ raidopen(dev_t dev, int flags, int fmt,
 bad:
 	raidunlock(rs);
 	return (error);
+}
 /* ARGSUSED */
 int
 raidclose(dev_t dev, int flags, int fmt, struct lwp *l)
+{
 	int     unit = raidunit(dev);
 	cfdata_t cf;
 	struct raid_softc *rs;
 	int     error = 0;
 	int     part;
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((error = raidlock(rs)) != 0)
 		return (error);
 	part = DISKPART(dev);
 @@ -823,44 +832,30 @@ raidclose(dev_t dev, int flags, int fmt,
+	}
 	rs->sc_dkdev.dk_openmask =
 	    rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
 	if ((rs->sc_dkdev.dk_openmask == 0) &&
 	    ((rs->sc_flags & RAIDF_INITED) != 0)) {
 		/* Last one... device is not unconfigured yet.
 		   Device shutdown has taken care of setting the
 		   clean bits if RAIDF_INITED is not set
 		   mark things as clean... */
 		rf_update_component_labels(raidPtrs[unit],
 						 RF_FINAL_COMPONENT_UPDATE);
 		if (doing_shutdown) {
 			/* last one, and we're going down, so
 			   lights out for this RAID set too. */
 			error = rf_Shutdown(raidPtrs[unit]);
 			/* It's no longer initialized... */
 			rs->sc_flags &= ~RAIDF_INITED;
-			/* detach the device */
+		/* If the kernel is shutting down, it will detach
 		 * this RAID set soon enough.
-			cf = device_cfdata(rs->sc_dev);
+		 */
 			error = config_detach(rs->sc_dev, DETACH_QUIET);
 			free(cf, M_RAIDFRAME);
 			/* Detach the disk. */
 			disk_detach(&rs->sc_dkdev);
 			disk_destroy(&rs->sc_dkdev);
+	}
 	raidunlock(rs);
 	return (0);
+}
 void
 raidstrategy(struct buf *bp)
+{
 	int s;
 	unsigned int raidID = raidunit(bp->b_dev);
 @@ -954,26 +949,55 @@ raidwrite(dev_t dev, struct uio *uio, in
 	struct raid_softc *rs;
 	if (unit >= numraid)
 		return (ENXIO);
 	rs = &raid_softc[unit];
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		return (ENXIO);
 	return (physio(raidstrategy, NULL, dev, B_WRITE, minphys, uio));
+}
 static int
 raid_detach_unlocked(struct raid_softc *rs)
+{
 	int error;
 	RF_Raid_t *raidPtr;
 	raidPtr = raidPtrs[device_unit(rs->sc_dev)];
 	/*
 	 * If somebody has a partition mounted, we shouldn't
 	 * shutdown.
 	 */
 	if (rs->sc_dkdev.dk_openmask != 0)
 		return EBUSY;
 	if ((rs->sc_flags & RAIDF_INITED) == 0)
 		;	/* not initialized: nothing to do */
 	else if ((error = rf_Shutdown(raidPtr)) != 0)
 		return error;
 	else
 		rs->sc_flags &= ~(RAIDF_INITED|RAIDF_SHUTDOWN);
 	/* Detach the disk. */
 	disk_detach(&rs->sc_dkdev);
 	disk_destroy(&rs->sc_dkdev);
 	return 0;
+}
 int
 raidioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
+{
 	int     unit = raidunit(dev);
 	int     error = 0;
 	int     part, pmask;
 	cfdata_t cf;
 	struct raid_softc *rs;
 	RF_Config_t *k_cfg, *u_cfg;
 	RF_Raid_t *raidPtr;
 	RF_RaidDisk_t *diskPtr;
 	RF_AccTotals_t *totals;
 	RF_DeviceConfig_t *d_cfg, **ucfgp;
 @@ -1163,61 +1187,54 @@ raidioctl(dev_t dev, u_long cmd, void *d
 			rf_markalldirty(raidPtr);
+		}
 		/* free the buffers.  No return code here. */
 		if (k_cfg->layoutSpecificSize) {
 			RF_Free(specific_buf, k_cfg->layoutSpecificSize);
+		}
 		RF_Free(k_cfg, sizeof(RF_Config_t));
 		return (retcode);
 		/* shutdown the system */
 	case RAIDFRAME_SHUTDOWN:
 		part = DISKPART(dev);
 		pmask = (1 << part);
 		if ((error = raidlock(rs)) != 0)
 			return (error);
 		/*
 		 * If somebody has a partition mounted, we shouldn't
 		 * shutdown.
 		 */
 		part = DISKPART(dev);
 		pmask = (1 << part);
 		if ((rs->sc_dkdev.dk_openmask & ~pmask) ||
 		    ((rs->sc_dkdev.dk_bopenmask & pmask) &&
-			(rs->sc_dkdev.dk_copenmask & pmask))) {
+			(rs->sc_dkdev.dk_copenmask & pmask)))
-			raidunlock(rs);
+			retcode = EBUSY;
-			return (EBUSY);
+		else {
 			rs->sc_flags |= RAIDF_SHUTDOWN;
 			rs->sc_dkdev.dk_copenmask &= ~pmask;
 			rs->sc_dkdev.dk_bopenmask &= ~pmask;
 			rs->sc_dkdev.dk_openmask &= ~pmask;
 			retcode = 0;
+		}
-		retcode = rf_Shutdown(raidPtr);
+		raidunlock(rs);
-		/* It's no longer initialized... */
+		if (retcode != 0)
-		rs->sc_flags &= ~RAIDF_INITED;
+			return retcode;
 		/* free the pseudo device attach bits */
 		cf = device_cfdata(rs->sc_dev);
-		/* XXX this causes us to not return any errors
+		if ((retcode = config_detach(rs->sc_dev, DETACH_QUIET)) == 0)
-		   from the above call to rf_Shutdown() */
+			free(cf, M_RAIDFRAME);
 		retcode = config_detach(rs->sc_dev, DETACH_QUIET);
 		free(cf, M_RAIDFRAME);
 		/* Detach the disk. */
 		disk_detach(&rs->sc_dkdev);
 		disk_destroy(&rs->sc_dkdev);
 		raidunlock(rs);
 		return (retcode);
 	case RAIDFRAME_GET_COMPONENT_LABEL:
 		clabel_ptr = (RF_ComponentLabel_t **) data;
 		/* need to read the component label for the disk indicated
 		   by row,column in clabel */
 		/* For practice, let's get it directly fromdisk, rather
 		   than from the in-core copy */
 		RF_Malloc( clabel, sizeof( RF_ComponentLabel_t ),
 			   (RF_ComponentLabel_t *));
 		if (clabel == NULL)
 			return (ENOMEM);
 @@ -3610,32 +3627,37 @@ raid_match(device_t self, cfdata_t cfdat
 	return 1;
+}
 static void
 raid_attach(device_t parent, device_t self, void *aux)
+{
+}
 static int
 raid_detach(device_t self, int flags)
+{
-	struct raid_softc *rs = device_private(self);
+	int error;
 	struct raid_softc *rs = &raid_softc[device_unit(self)];
-	if (rs->sc_flags & RAIDF_INITED)
+	if ((error = raidlock(rs)) != 0)
-		return EBUSY;
+		return (error);
-	return 0;
+	error = raid_detach_unlocked(rs);
 	raidunlock(rs);
 	return error;
+}
 static void
 rf_set_properties(struct raid_softc *rs, RF_Raid_t *raidPtr)
+{
 	prop_dictionary_t disk_info, odisk_info, geom;
 	disk_info = prop_dictionary_create();
 	geom = prop_dictionary_create();
 	prop_dictionary_set_uint64(geom, "sectors-per-unit",
 				   raidPtr->totalSectors);
 	prop_dictionary_set_uint32(geom, "sector-size",
 				   raidPtr->bytesPerSector);