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

*** 1260,1269 ****
--- 1260,1276 ----
                  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,1520 ****
--- 1518,1530 ----
                          *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,1829 ****
--- 1830,1840 ----
                  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,1913 ****
--- 1915,1930 ----
          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,2350 ****
--- 2358,2371 ----
          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,2824 ****
--- 2836,2862 ----
                                          *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,3043 ****
--- 3072,3091 ----
                          } 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;