1845 allow disable of UNMAP via stmfadm(1M).

@@ -1351,10 +1351,13 @@
                 sli->sli_flags |= SLI_WRITE_PROTECTED;
         }
         if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE) {
                 sli->sli_flags |= SLI_WRITEBACK_CACHE_DISABLE;
         }
+        if (sl->sl_flags & SL_SAVED_UNMAP_ENABLED) {
+                sli->sli_flags |= SLI_UNMAP_ENABLED;
+        }
         if (sl->sl_flags & SL_VID_VALID) {
                 bcopy(sl->sl_vendor_id, sli->sli_vid, 8);
                 sli->sli_flags |= SLI_VID_VALID;
         }
         if (sl->sl_flags & SL_PID_VALID) {

@@ -1387,30 +1390,40 @@
         kmem_free(sli, sizeof (*sli) + s);
         return (ret);
 }
 
 /*
- * Will scribble SL_UNMAP_ENABLED into sl_flags if we succeed.
+ * Will scribble SL_UNMAP_ENABLED on or off in sl_flags if we succeed.
+ * Returns B_TRUE if the LU is UNMAP-capable.
  */
-static void
-do_unmap_setup(sbd_lu_t *sl)
+static boolean_t
+do_unmap_setup(sbd_lu_t *sl, boolean_t enable)
 {
+        if ((sl->sl_flags & SL_ZFS_META) == 0) {
+                sl->sl_flags &= ~SL_SAVED_UNMAP_ENABLED;
         ASSERT((sl->sl_flags & SL_UNMAP_ENABLED) == 0);
+                return (B_FALSE);       /* No UNMAP for you. */
+        }
 
-        if ((sl->sl_flags & SL_ZFS_META) == 0)
-                return; /* No UNMAP for you. */
+        if (enable)
+                sl->sl_flags |= (SL_UNMAP_ENABLED | SL_SAVED_UNMAP_ENABLED);
+        else
+                sl->sl_flags &= ~(SL_UNMAP_ENABLED | SL_SAVED_UNMAP_ENABLED);
 
-        sl->sl_flags |= SL_UNMAP_ENABLED;
+        return (B_TRUE);
 }
 
 int
 sbd_populate_and_register_lu(sbd_lu_t *sl, uint32_t *err_ret)
 {
         stmf_lu_t *lu = sl->sl_lu;
         stmf_status_t ret;
 
-        do_unmap_setup(sl);
+#if 0
+        /* Always try and enable UNMAP upon bringup. */
+        (void) do_unmap_setup(sl, B_TRUE);
+#endif
 
         lu->lu_id = (scsi_devid_desc_t *)sl->sl_device_id;
         if (sl->sl_alias) {
                 lu->lu_alias = sl->sl_alias;
         } else {

@@ -1833,10 +1846,15 @@
                 sl->sl_flags |= SL_REV_VALID;
         }
         if (slu->slu_write_protected) {
                 sl->sl_flags |= SL_WRITE_PROTECTED;
         }
+
+        if (slu->slu_unmap) {
+                (void) do_unmap_setup(sl, B_TRUE);
+        }
+
         if (slu->slu_writeback_cache_disable) {
                 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE |
                     SL_SAVED_WRITE_CACHE_DISABLE;
         }
 

@@ -2475,10 +2493,13 @@
                     sli->sli_mgmt_url_offset);
         }
         if (sli->sli_flags & SLI_WRITE_PROTECTED) {
                 sl->sl_flags |= SL_WRITE_PROTECTED;
         }
+        if (sli->sli_flags & SLI_UNMAP_ENABLED) {
+                sl->sl_flags |= SL_UNMAP_ENABLED;
+        }
         if (sli->sli_flags & SLI_VID_VALID) {
                 sl->sl_flags |= SL_VID_VALID;
                 bcopy(sli->sli_vid, sl->sl_vendor_id, 8);
         }
         if (sli->sli_flags & SLI_PID_VALID) {

@@ -2695,10 +2716,21 @@
                 *err_ret = SBD_RET_ACCESS_STATE_FAILED;
                 ret = EINVAL;
                 goto smm_err_out;
         }
 
+        /* Change UNMAP status... */
+        if (mlu->mlu_unmap_valid) {
+                mutex_enter(&sl->sl_lock);
+                ASSERT(ret == 0);
+                if (!do_unmap_setup(sl, mlu->mlu_unmap))
+                        ret = EINVAL;
+                mutex_exit(&sl->sl_lock);
+                if (ret != 0)
+                        goto smm_err_out;
+        }
+
         /* check for write cache change */
         if (mlu->mlu_writeback_cache_disable_valid) {
                 /* set wce on device */
                 sret = sbd_wcd_set(mlu->mlu_writeback_cache_disable, sl);
                 if (!mlu->mlu_writeback_cache_disable && sret != SBD_SUCCESS) {

@@ -3329,10 +3361,14 @@
         } else {
                 bcopy(sbd_revision, oslp->slp_rev, 4);
         }
         bcopy(sl->sl_device_id + 4, oslp->slp_guid, 16);
 
+        if (sl->sl_flags & SL_UNMAP_ENABLED)
+                oslp->slp_unmap_cur = 1;
+        if (sl->sl_flags & SL_SAVED_UNMAP_ENABLED)
+                oslp->slp_unmap_saved = 1;
         if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE)
                 oslp->slp_writeback_cache_disable_cur = 1;
         if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE)
                 oslp->slp_writeback_cache_disable_saved = 1;
         if (sl->sl_flags & SL_WRITE_PROTECTED)