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

@@ -1260,10 +1260,17 @@
                 if (disk->writeProtectEnable) {
                         sbdLu->slu_write_protected = 1;
                 }
         }
 
+        if (disk->unmapValid) {
+                sbdLu->slu_unmap_valid = 1;
+                if (disk->unmap) {
+                        sbdLu->slu_unmap = 1;
+                }
+        }
+
         if (disk->writebackCacheDisableValid) {
                 sbdLu->slu_writeback_cache_disable_valid = 1;
                 if (disk->writebackCacheDisable) {
                         sbdLu->slu_writeback_cache_disable = 1;
                 }

@@ -1511,10 +1518,13 @@
                         *ret = STMF_ERROR_LU_BUSY;
                         break;
                 case SBD_RET_WRITE_CACHE_SET_FAILED:
                         *ret = STMF_ERROR_WRITE_CACHE_SET;
                         break;
+                case SBD_RET_UNMAP_SET_FAILED:
+                        *ret = STMF_ERROR_UNMAP_SET;
+                        break;
                 case SBD_RET_ACCESS_STATE_FAILED:
                         *ret = STMF_ERROR_ACCESS_STATE_SET;
                         break;
                 default:
                         *ret = STMF_STATUS_ERROR;

@@ -1820,10 +1830,11 @@
                 case STMF_LU_PROP_ALIAS:
                 case STMF_LU_PROP_SIZE:
                 case STMF_LU_PROP_MGMT_URL:
                 case STMF_LU_PROP_WRITE_PROTECT:
                 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
+                case STMF_LU_PROP_UNMAP:
                         return (STMF_STATUS_SUCCESS);
                         break;
                 default:
                         return (STMF_STATUS_ERROR);
                         break;

@@ -1904,10 +1915,16 @@
         if (disk->luSizeValid) {
                 sbdLu->mlu_lu_size_valid = 1;
                 sbdLu->mlu_lu_size = disk->luSize;
         }
 
+        if (disk->unmapValid) {
+                sbdLu->mlu_unmap_valid = 1;
+                if (disk->unmap)
+                        sbdLu->mlu_unmap = 1;
+        }
+
         if (disk->writeProtectEnableValid) {
                 sbdLu->mlu_write_protected_valid = 1;
                 if (disk->writeProtectEnable) {
                         sbdLu->mlu_write_protected = 1;
                 }

@@ -2341,10 +2358,14 @@
         bcopy(sbdProps->slp_pid, diskLu->pid, sizeof (diskLu->pid));
 
         diskLu->revValid = B_TRUE;
         bcopy(sbdProps->slp_rev, diskLu->rev, sizeof (diskLu->rev));
 
+        diskLu->unmapValid = B_TRUE;
+        if (sbdProps->slp_unmap_cur)
+                diskLu->unmap = B_TRUE;
+
         diskLu->writeProtectEnableValid = B_TRUE;
         if (sbdProps->slp_write_protected) {
                 diskLu->writeProtectEnable = B_TRUE;
         }
 

@@ -2815,10 +2836,27 @@
                                         *propLen = reqLen + 1;
                                         return (STMF_ERROR_INVALID_ARG);
                                 }
                         }
                         break;
+                case STMF_LU_PROP_UNMAP:
+                        if (!diskLu->unmapValid)
+                                return (STMF_ERROR_NO_PROP);
+                        if (diskLu->unmap) {
+                                if ((reqLen = strlcpy(propVal, "true",
+                                    *propLen)) >= *propLen) {
+                                        *propLen = reqLen + 1;
+                                        return (STMF_ERROR_INVALID_ARG);
+                                }
+                        } else {
+                                if ((reqLen = strlcpy(propVal, "false",
+                                    *propLen)) >= *propLen) {
+                                        *propLen = reqLen + 1;
+                                        return (STMF_ERROR_INVALID_ARG);
+                                }
+                        }
+                        break;
                 case STMF_LU_PROP_WRITE_CACHE_DISABLE:
                         if (diskLu->writebackCacheDisableValid == B_FALSE) {
                                 return (STMF_ERROR_NO_PROP);
                         }
                         if (diskLu->writebackCacheDisable) {

@@ -3034,10 +3072,20 @@
                         } else {
                                 return (STMF_ERROR_INVALID_ARG);
                         }
                         diskLu->writebackCacheDisableValid = B_TRUE;
                         break;
+                case STMF_LU_PROP_UNMAP:
+                        if (strcasecmp(propVal, "TRUE") == 0) {
+                                diskLu->unmap = B_TRUE;
+                        } else if (strcasecmp(propVal, "FALSE") == 0) {
+                                diskLu->unmap = B_FALSE;
+                        } else {
+                                return (STMF_ERROR_INVALID_ARG);
+                        }
+                        diskLu->unmapValid = B_TRUE;
+                        break;
                 case STMF_LU_PROP_ACCESS_STATE:
                         ret = STMF_ERROR_INVALID_PROP;
                         break;
                 default:
                         ret = STMF_ERROR_INVALID_PROP;