NEX-8020 illumos nvme changes
Reviewed by: Dan Fields <dan.fields@nexenta.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
NEX-6131 support EUI64 in blkdev
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
NEX-5236 harmless off-by-one in blkdev
Reviewed by: Dan Fields <dan.fields@nexenta.com>
NEX-4427 blkdev should provide the device_error kstat for iostat -E
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Reviewed by: Garrett D'Amore <garrett@damore.org>
NEX-4424 kstat module needs cleanup
Reviewed by: Richard Elling <Richard.Elling@RichardElling.com>
Reviewed by: Garrett D'Amore <garrett@damore.org>
NEX-4420 format(1M) should be able to use device inquiry properties
Reviewed by: Dan McDonald <danmcd@omniti.com>
NEX-4419 blkdev and blkdev drivers should provide inquiry properties
Reviewed by: Garrett D'Amore <garrett@damore.org>
Reviewed by: Josef 'Jeff' Sipek <josef.sipek@nexenta.com>
port of illumos-3878
    3878 blkdev needs to support DKIOCGMEDIAINFOEXT
    Reviewed by: Saso Kiselkov <skiselkov.ml@gmail.com>
    Reviewed by: Garrett D'Amore <garrett@damore.org>
    Approved by: Garrett D'Amore <garrett@damore.org>
port of illumos-2911
    2911 blkdev-related panic on DEBUG kernels
    Reviewed by: Richard Lowe <richlowe@richlowe.net>
    Reviewed by: Garrett D'Amore <garrett@damore.org>
    Approved by: Garrett D'Amore <garrett@damore.org>
Adding AoE support to nza-kernel

@@ -48,10 +48,11 @@
 #include <sys/kstat.h>
 #include <sys/fs/dv_node.h>
 #include <sys/ddi.h>
 #include <sys/sunddi.h>
 #include <sys/note.h>
+#include <sys/mhd.h>
 #include <sys/blkdev.h>
 #include <sys/scsi/impl/inquiry.h>
 
 #define BD_MAXPART      64
 #define BDINST(dev)     (getminor(dev) / BD_MAXPART)

@@ -170,10 +171,11 @@
 static void bd_submit(bd_t *, bd_xfer_impl_t *);
 static void bd_runq_exit(bd_xfer_impl_t *, int);
 static void bd_update_state(bd_t *);
 static int bd_check_state(bd_t *, enum dkio_state *);
 static int bd_flush_write_cache(bd_t *, struct dk_callback *);
+static int bd_reserve(bd_t *bd, int);
 static int bd_check_uio(dev_t, struct uio *);
 
 struct cmlb_tg_ops bd_tg_ops = {
         TG_DK_OPS_VERSION_1,
         bd_tg_rdwr,

@@ -873,10 +875,11 @@
         uint64_t        mask;
         boolean_t       ndelay;
         int             rv;
         diskaddr_t      nblks;
         diskaddr_t      lba;
+        int             i;
 
         _NOTE(ARGUNUSED(credp));
 
         part = BDPART(dev);
         inst = BDINST(dev);

@@ -945,11 +948,11 @@
         if (flag & FEXCL) {
                 if (bd->d_open_lyr[part]) {
                         rv = EBUSY;
                         goto done;
                 }
-                for (int i = 0; i < OTYP_LYR; i++) {
+                for (i = 0; i < OTYP_LYR; i++) {
                         if (bd->d_open_reg[i] & mask) {
                                 rv = EBUSY;
                                 goto done;
                         }
                 }

@@ -978,10 +981,11 @@
         bd_t            *bd;
         minor_t         inst;
         minor_t         part;
         uint64_t        mask;
         boolean_t       last = B_TRUE;
+        int             i;
 
         _NOTE(ARGUNUSED(flag));
         _NOTE(ARGUNUSED(credp));
 
         part = BDPART(dev);

@@ -1004,16 +1008,16 @@
         if (otyp == OTYP_LYR) {
                 bd->d_open_lyr[part]--;
         } else {
                 bd->d_open_reg[otyp] &= ~mask;
         }
-        for (int i = 0; i < 64; i++) {
+        for (i = 0; i < 64; i++) {
                 if (bd->d_open_lyr[part]) {
                         last = B_FALSE;
                 }
         }
-        for (int i = 0; last && (i < OTYP_LYR); i++) {
+        for (i = 0; last && (i < OTYP_LYR); i++) {
                 if (bd->d_open_reg[i]) {
                         last = B_FALSE;
                 }
         }
         mutex_exit(&bd->d_ocmutex);

@@ -1387,10 +1391,38 @@
 
                 rv = bd_flush_write_cache(bd, dkc);
                 return (rv);
         }
 
+        case MHIOCTKOWN:
+        {
+                return (bd_reserve(bd, BD_XFER_MHD_TKOWN));
+        }
+
+        case MHIOCRELEASE:
+        {
+                return (bd_reserve(bd, BD_XFER_MHD_RELEASE));
+        }
+
+        case MHIOCSTATUS:
+        {
+                rv = bd_reserve(bd, BD_XFER_MHD_STATUS);
+                if (rvalp != NULL)
+                        *rvalp = rv == 0 ? 0: 1;
+                return (0);
+        }
+
+        case MHIOCQRESERVE:
+        {
+                return (bd_reserve(bd, BD_XFER_MHD_QRESERVE));
+        }
+
+        case MHIOCENFAILFAST:
+        {
+                return (bd_reserve(bd, BD_XFER_MHD_ENFAILFAST));
+        }
+
         default:
                 break;
 
         }
         return (ENOTTY);

@@ -1748,10 +1780,45 @@
 
         /* In case there is no callback, perform a synchronous flush */
         bd_submit(bd, xi);
         (void) biowait(bp);
         rv = geterror(bp);
+        freerbuf(bp);
+
+        return (rv);
+}
+
+static int
+bd_reserve(bd_t *bd, int flag)
+{
+        buf_t                   *bp;
+        bd_xfer_impl_t          *xi;
+        int                     rv;
+
+        if (bd->d_ops.o_reserve == NULL) {
+                return (ENOTSUP);
+        }
+        if ((bp = getrbuf(KM_SLEEP)) == NULL) {
+                return (ENOMEM);
+        }
+        bp->b_resid = 0;
+        bp->b_bcount = 0;
+
+        xi = bd_xfer_alloc(bd, bp, bd->d_ops.o_reserve, KM_SLEEP);
+        if (xi == NULL) {
+                rv = geterror(bp);
+                freerbuf(bp);
+                return (rv);
+        }
+
+        xi->i_flags = flag;
+
+        bd_submit(bd, xi);
+
+        /* wait synchronously */
+        (void) biowait(bp);
+        rv = geterror(bp);
         freerbuf(bp);
 
         return (rv);
 }