Lines Matching refs:ret
162 int ret = STMF_STATUS_ERROR;
165 ret = STMF_STATUS_SUCCESS;
168 ret = STMF_ERROR_BUSY;
170 ret = STMF_ERROR_PERM;
172 ret = STMF_STATUS_ERROR;
178 return (ret);
190 int ret = STMF_STATUS_ERROR;
193 ret = STMF_STATUS_SUCCESS;
196 ret = STMF_ERROR_BUSY;
198 ret = STMF_ERROR_PERM;
200 ret = STMF_STATUS_ERROR;
206 return (ret);
218 int ret = STMF_STATUS_ERROR;
221 ret = STMF_STATUS_SUCCESS;
224 ret = STMF_ERROR_BUSY;
226 ret = STMF_ERROR_PERM;
228 ret = STMF_STATUS_ERROR;
234 return (ret);
247 int ret;
251 ret = stmfGetState(&state);
252 if (ret != STMF_STATUS_SUCCESS) {
253 return (ret);
262 ret = stmfLoadConfig();
263 if (ret != STMF_STATUS_SUCCESS) {
265 "initializeConfig:stmfLoadConfig:error(%d)", ret);
266 return (ret);
269 ret = stmfGetState(&state);
270 if (ret != STMF_STATUS_SUCCESS) {
272 "initializeConfig:stmfGetState:error(%d)", ret);
273 return (ret);
279 ret = STMF_STATUS_ERROR;
282 return (ret);
297 int ret = STMF_STATUS_SUCCESS;
320 ret = STMF_ERROR_PERM;
326 ret = STMF_ERROR_EXISTS;
330 ret = STMF_ERROR_GROUP_IN_USE;
334 ret = STMF_ERROR_NOT_FOUND;
340 ret = STMF_STATUS_ERROR;
347 return (ret);
362 int ret = STMF_STATUS_SUCCESS;
389 ret = STMF_ERROR_TG_ONLINE;
392 ret = STMF_ERROR_BUSY;
398 ret = STMF_ERROR_PERM;
404 ret = STMF_ERROR_EXISTS;
408 ret =
413 ret =
421 ret = STMF_STATUS_ERROR;
428 return (ret);
481 int ret;
491 ret = initializeConfig();
492 if (ret != STMF_STATUS_SUCCESS) {
493 return (ret);
499 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
500 return (ret);
502 if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_HG_ENTRY, hostGroupName,
511 ret = psAddHostGroupMember((char *)hostGroupName,
513 switch (ret) {
515 ret = STMF_STATUS_SUCCESS;
518 ret = STMF_ERROR_EXISTS;
521 ret = STMF_ERROR_GROUP_NOT_FOUND;
524 ret = STMF_ERROR_BUSY;
527 ret = STMF_ERROR_SERVICE_NOT_FOUND;
530 ret = STMF_ERROR_SERVICE_DATA_VERSION;
535 ret);
536 ret = STMF_STATUS_ERROR;
542 return (ret);
556 int ret;
566 ret = initializeConfig();
567 if (ret != STMF_STATUS_SUCCESS) {
568 return (ret);
574 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
575 return (ret);
577 if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_TG_ENTRY,
586 ret = psAddTargetGroupMember((char *)targetGroupName,
588 switch (ret) {
590 ret = STMF_STATUS_SUCCESS;
593 ret = STMF_ERROR_EXISTS;
596 ret = STMF_ERROR_GROUP_NOT_FOUND;
599 ret = STMF_ERROR_BUSY;
602 ret = STMF_ERROR_SERVICE_NOT_FOUND;
605 ret = STMF_ERROR_SERVICE_DATA_VERSION;
610 "error(%d)", ret);
611 ret = STMF_STATUS_ERROR;
617 return (ret);
632 int ret = STMF_STATUS_SUCCESS;
678 ret = STMF_ERROR_BUSY;
681 ret = STMF_ERROR_PERM;
686 ret = STMF_ERROR_CONFIG_NONE;
689 ret = STMF_ERROR_PERM;
696 ret = STMF_ERROR_LUN_IN_USE;
699 ret = STMF_ERROR_VE_CONFLICT;
702 ret = STMF_ERROR_CONFIG_NONE;
705 ret = STMF_ERROR_INVALID_HG;
708 ret = STMF_ERROR_INVALID_TG;
715 ret = STMF_STATUS_ERROR;
732 return (ret);
746 int ret;
789 ret = initializeConfig();
790 if (ret != STMF_STATUS_SUCCESS) {
791 return (ret);
797 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
798 return (ret);
803 ret = addViewEntryIoctl(fd, lu, &iViewEntry);
804 if (ret != STMF_STATUS_SUCCESS) {
816 ret = psAddViewEntry(lu, &iViewEntry);
817 switch (ret) {
819 ret = STMF_STATUS_SUCCESS;
822 ret = STMF_ERROR_NOT_FOUND;
825 ret = STMF_ERROR_BUSY;
828 ret = STMF_ERROR_SERVICE_NOT_FOUND;
831 ret = STMF_ERROR_SERVICE_DATA_VERSION;
835 "stmfAddViewEntry:psAddViewEntry:error(%d)", ret);
836 ret = STMF_STATUS_ERROR;
843 if (ret == STMF_STATUS_SUCCESS) {
851 return (ret);
864 int ret;
872 ret = initializeConfig();
873 if (ret != STMF_STATUS_SUCCESS) {
874 return (ret);
889 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
890 return (ret);
904 ret = STMF_ERROR_INVALID_ARG;
919 ret = STMF_ERROR_BUSY;
923 ret = STMF_ERROR_PERM;
929 ret = STMF_STATUS_ERROR;
941 ret = psClearProviderData(providerName, providerType);
942 switch (ret) {
944 ret = STMF_STATUS_SUCCESS;
947 ret = STMF_ERROR_NOT_FOUND;
950 ret = STMF_ERROR_BUSY;
953 ret = STMF_ERROR_SERVICE_NOT_FOUND;
956 ret = STMF_ERROR_SERVICE_DATA_VERSION;
961 ":error(%d)", ret);
962 ret = STMF_STATUS_ERROR;
968 return (ret);
981 int ret;
996 ret = initializeConfig();
997 if (ret != STMF_STATUS_SUCCESS) {
998 return (ret);
1004 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
1005 return (ret);
1007 if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_HOST_GROUP,
1016 ret = psCreateHostGroup((char *)hostGroupName);
1017 switch (ret) {
1019 ret = STMF_STATUS_SUCCESS;
1022 ret = STMF_ERROR_EXISTS;
1025 ret = STMF_ERROR_BUSY;
1028 ret = STMF_ERROR_SERVICE_NOT_FOUND;
1031 ret = STMF_ERROR_SERVICE_DATA_VERSION;
1036 ret);
1037 ret = STMF_STATUS_ERROR;
1043 return (ret);
1059 int ret = STMF_STATUS_SUCCESS;
1067 ret = createDiskLu((diskResource *)luPropsHdl->resource,
1073 return (ret);
1089 int ret = STMF_STATUS_SUCCESS;
1100 ret = createDiskResource((luResourceImpl *)*hdl);
1101 if (ret != STMF_STATUS_SUCCESS) {
1103 return (ret);
1118 int ret = STMF_STATUS_SUCCESS;
1137 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
1138 return (ret);
1284 ret = STMF_ERROR_BUSY;
1288 ret = STMF_ERROR_PERM;
1291 diskError(sbdIoctl.stmf_error, &ret);
1292 if (ret == STMF_STATUS_ERROR) {
1302 if (ret != STMF_STATUS_SUCCESS) {
1317 ret = addGuidToDiskStore(&guid, disk->luMetaFileName);
1319 ret = addGuidToDiskStore(&guid, disk->luDataFileName);
1324 return (ret);
1345 int ret = STMF_STATUS_SUCCESS;
1348 ret = importDiskLu(fname, luGuid);
1353 return (ret);
1366 int ret = STMF_STATUS_SUCCESS;
1383 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
1384 return (ret);
1428 ret = STMF_ERROR_BUSY;
1432 ret = STMF_ERROR_PERM;
1435 diskError(sbdIoctl.stmf_error, &ret);
1436 if (ret == STMF_STATUS_ERROR) {
1447 if (ret != STMF_STATUS_SUCCESS) {
1458 ret = addGuidToDiskStore(createdGuid, fname);
1462 ret = addGuidToDiskStore(&iGuid, fname);
1467 return (ret);
1476 diskError(uint32_t stmfError, int *ret)
1481 *ret = STMF_ERROR_META_CREATION;
1484 *ret = STMF_ERROR_INVALID_BLKSIZE;
1487 *ret = STMF_ERROR_FILE_IN_USE;
1490 *ret = STMF_ERROR_GUID_IN_USE;
1497 *ret = STMF_ERROR_META_FILE_NAME;
1503 *ret = STMF_ERROR_DATA_FILE_NAME;
1506 *ret = STMF_ERROR_FILE_SIZE_INVALID;
1509 *ret = STMF_ERROR_SIZE_OUT_OF_RANGE;
1512 *ret = STMF_ERROR_LU_BUSY;
1515 *ret = STMF_ERROR_WRITE_CACHE_SET;
1518 *ret = STMF_ERROR_ACCESS_STATE_SET;
1521 *ret = STMF_STATUS_ERROR;
1558 int ret = STMF_STATUS_SUCCESS;
1566 if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
1568 return (ret);
1571 ret = deleteDiskLu(luGuid);
1579 return (ret);
1585 int ret = STMF_STATUS_SUCCESS;
1596 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
1597 return (ret);
1599 ret = removeGuidFromDiskStore(luGuid);
1600 if (ret != STMF_STATUS_SUCCESS) {
1615 ret = STMF_ERROR_BUSY;
1619 ret = STMF_ERROR_PERM;
1622 ret = STMF_ERROR_NOT_FOUND;
1628 ret = STMF_STATUS_ERROR;
1635 return (ret);
1649 int ret = STMF_STATUS_SUCCESS;
1657 if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
1659 return (ret);
1662 ret = setDiskStandby(luGuid);
1670 return (ret);
1676 int ret = STMF_STATUS_SUCCESS;
1686 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
1687 return (ret);
1700 ret = STMF_ERROR_BUSY;
1704 ret = STMF_ERROR_PERM;
1707 diskError(sbdIoctl.stmf_error, &ret);
1708 if (ret == STMF_STATUS_ERROR) {
1718 return (ret);
1734 int ret = STMF_STATUS_SUCCESS;
1742 if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
1744 return (ret);
1747 ret = modifyDiskLuProp(luGuid, NULL, prop, propVal);
1755 return (ret);
1775 int ret = STMF_STATUS_SUCCESS;
1781 ret = modifyDiskLuProp(NULL, fname, prop, propVal);
1786 return (ret);
1793 int ret = STMF_STATUS_SUCCESS;
1797 ret = stmfCreateLuResource(STMF_DISK, &hdl);
1798 if (ret != STMF_STATUS_SUCCESS) {
1799 return (ret);
1801 ret = validateModifyDiskProp(prop);
1802 if (ret != STMF_STATUS_SUCCESS) {
1806 ret = stmfSetLuProp(hdl, prop, propVal);
1807 if (ret != STMF_STATUS_SUCCESS) {
1809 return (ret);
1812 ret = modifyDiskLu((diskResource *)luPropsHdl->resource, luGuid, fname);
1814 return (ret);
1835 int ret = STMF_STATUS_SUCCESS;
1860 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
1861 return (ret);
1940 ret = STMF_ERROR_BUSY;
1944 ret = STMF_ERROR_PERM;
1947 diskError(sbdIoctl.stmf_error, &ret);
1948 if (ret == STMF_STATUS_ERROR) {
1958 if (ret != STMF_STATUS_SUCCESS) {
1965 return (ret);
2007 int ret = STMF_STATUS_SUCCESS;
2032 ret = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0);
2033 if (ret != 0) {
2036 ret);
2037 ret = STMF_STATUS_ERROR;
2047 ret = stmfRet;
2053 ret = nvlist_add_string(nvl, guidAsciiBuf, filename);
2055 ret = nvlist_remove(nvl, guidAsciiBuf,
2057 if (ret == ENOENT) {
2058 ret = 0;
2061 if (ret == 0) {
2074 ret = stmfRet;
2085 ret = stmfRet;
2092 ret = stmfRet;
2099 ret);
2100 ret = STMF_STATUS_ERROR;
2106 return (ret);
2124 int ret = STMF_STATUS_SUCCESS;
2131 ret = getDiskProp(luPropsHdl, prop, propVal, propLen);
2136 return (ret);
2149 int ret = STMF_STATUS_SUCCESS;
2157 if ((ret = stmfGetLogicalUnitProperties(luGuid, &luProps))
2159 return (ret);
2162 ret = getDiskAllProps(luGuid, hdl);
2170 return (ret);
2185 int ret = STMF_STATUS_SUCCESS;
2196 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
2197 return (ret);
2213 ret = createDiskResource((luResourceImpl *)*hdl);
2214 if (ret != STMF_STATUS_SUCCESS) {
2218 return (ret);
2234 ret = STMF_ERROR_BUSY;
2238 ret = STMF_ERROR_PERM;
2241 ret = STMF_ERROR_NOT_FOUND;
2247 ret = STMF_STATUS_ERROR;
2252 if (ret == STMF_STATUS_SUCCESS) {
2253 ret = loadDiskPropsFromDriver((luResourceImpl *)*hdl, sbdProps);
2258 return (ret);
2273 int ret = STMF_STATUS_SUCCESS;
2363 return (ret);
2376 int ret = STMF_STATUS_SUCCESS;
2381 ret = getDiskGlobalProp(prop, propVal, propLen);
2383 return (ret);
2395 int ret = STMF_STATUS_SUCCESS;
2417 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
2418 return (ret);
2436 ret = STMF_ERROR_BUSY;
2440 ret = STMF_ERROR_PERM;
2456 ret = STMF_ERROR_NOMEM;
2461 ret = STMF_ERROR_NOMEM;
2469 ret = STMF_STATUS_ERROR;
2476 if (ret != STMF_STATUS_SUCCESS) {
2483 ret = STMF_ERROR_NO_PROP;
2490 ret = STMF_ERROR_INVALID_ARG;
2499 return (ret);
2511 int ret = STMF_STATUS_SUCCESS;
2516 ret = setDiskGlobalProp(prop, propVal);
2518 return (ret);
2532 int ret = STMF_STATUS_SUCCESS;
2552 if ((ret = openSbd(OPEN_SBD, &fd)) != STMF_STATUS_SUCCESS)
2553 return (ret);
2578 ret = STMF_ERROR_NO_PROP;
2591 ret = STMF_ERROR_BUSY;
2595 ret = STMF_ERROR_PERM;
2598 diskError(sbdIoctl.stmf_error, &ret);
2599 if (ret == STMF_STATUS_ERROR) {
2612 return (ret);
2628 int ret = STMF_STATUS_SUCCESS;
2635 ret = setDiskProp(luPropsHdl, prop, propVal);
2640 return (ret);
2657 int ret = STMF_STATUS_SUCCESS;
2837 ret = STMF_ERROR_INVALID_PROP;
2841 return (ret);
2856 int ret = STMF_STATUS_SUCCESS;
3038 ret = STMF_ERROR_INVALID_PROP;
3041 ret = STMF_ERROR_INVALID_PROP;
3044 return (ret);
3088 int ret = STMF_STATUS_SUCCESS;
3096 return (ret);
3173 int ret;
3188 ret = initializeConfig();
3189 if (ret != STMF_STATUS_SUCCESS) {
3190 return (ret);
3196 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
3197 return (ret);
3202 if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_TARGET_GROUP,
3215 ret = psCreateTargetGroup((char *)targetGroupName);
3216 switch (ret) {
3218 ret = STMF_STATUS_SUCCESS;
3221 ret = STMF_ERROR_EXISTS;
3224 ret = STMF_ERROR_BUSY;
3227 ret = STMF_ERROR_SERVICE_NOT_FOUND;
3230 ret = STMF_ERROR_SERVICE_DATA_VERSION;
3235 ":error(%d)", ret);
3236 ret = STMF_STATUS_ERROR;
3242 return (ret);
3255 int ret;
3268 ret = initializeConfig();
3269 if (ret != STMF_STATUS_SUCCESS) {
3270 return (ret);
3276 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
3277 return (ret);
3282 if ((ret = groupIoctl(fd, STMF_IOCTL_REMOVE_HOST_GROUP,
3295 ret = psDeleteHostGroup((char *)hostGroupName);
3296 switch (ret) {
3298 ret = STMF_STATUS_SUCCESS;
3301 ret = STMF_ERROR_NOT_FOUND;
3304 ret = STMF_ERROR_BUSY;
3307 ret = STMF_ERROR_SERVICE_NOT_FOUND;
3310 ret = STMF_ERROR_SERVICE_DATA_VERSION;
3315 ret);
3316 ret = STMF_STATUS_ERROR;
3322 return (ret);
3335 int ret = STMF_STATUS_SUCCESS;
3348 ret = initializeConfig();
3349 if (ret != STMF_STATUS_SUCCESS) {
3350 return (ret);
3356 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
3357 return (ret);
3362 if ((ret = groupIoctl(fd, STMF_IOCTL_REMOVE_TARGET_GROUP,
3375 ret = psDeleteTargetGroup((char *)targetGroupName);
3376 switch (ret) {
3378 ret = STMF_STATUS_SUCCESS;
3381 ret = STMF_ERROR_NOT_FOUND;
3384 ret = STMF_ERROR_BUSY;
3387 ret = STMF_ERROR_SERVICE_NOT_FOUND;
3390 ret = STMF_ERROR_SERVICE_DATA_VERSION;
3395 ":error(%d)", ret);
3396 ret = STMF_STATUS_ERROR;
3402 return (ret);
3489 int ret;
3512 ret = initializeConfig();
3513 if (ret != STMF_STATUS_SUCCESS) {
3514 return (ret);
3520 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
3521 return (ret);
3530 ret = STMF_ERROR_NOMEM;
3545 ret = STMF_ERROR_BUSY;
3549 ret = STMF_ERROR_PERM;
3555 ret = STMF_STATUS_ERROR;
3568 ret = STMF_ERROR_NOMEM;
3577 ret = STMF_ERROR_BUSY;
3581 ret = STMF_ERROR_PERM;
3587 ret = STMF_STATUS_ERROR;
3598 ret = STMF_ERROR_NOMEM;
3610 return (ret);
3624 int ret;
3648 ret = initializeConfig();
3649 if (ret != STMF_STATUS_SUCCESS) {
3650 return (ret);
3656 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
3657 return (ret);
3672 ret = STMF_ERROR_NOMEM;
3689 ret = STMF_ERROR_BUSY;
3693 ret = STMF_ERROR_PERM;
3699 ret = STMF_STATUS_ERROR;
3712 ret = STMF_ERROR_NOMEM;
3723 ret = STMF_ERROR_BUSY;
3727 ret = STMF_ERROR_PERM;
3733 ret = STMF_STATUS_ERROR;
3745 ret = STMF_ERROR_NOMEM;
3759 return (ret);
3768 int ret;
3775 ret = psGetHostGroupList(groupList);
3777 ret = psGetTargetGroupList(groupList);
3781 switch (ret) {
3783 ret = STMF_STATUS_SUCCESS;
3786 ret = STMF_ERROR_NOT_FOUND;
3789 ret = STMF_ERROR_BUSY;
3792 ret = STMF_ERROR_SERVICE_NOT_FOUND;
3795 ret = STMF_ERROR_SERVICE_DATA_VERSION;
3800 ret);
3801 ret = STMF_STATUS_ERROR;
3805 return (ret);
3819 int ret = STMF_STATUS_ERROR;
3825 ret = groupListIoctl(hostGroupList, HOST_GROUP);
3826 return (ret);
3837 int ret;
3844 ret = psGetHostGroupMemberList((char *)groupName, groupProp);
3846 ret = psGetTargetGroupMemberList((char *)groupName, groupProp);
3850 switch (ret) {
3852 ret = STMF_STATUS_SUCCESS;
3855 ret = STMF_ERROR_NOT_FOUND;
3858 ret = STMF_ERROR_BUSY;
3861 ret = STMF_ERROR_SERVICE_NOT_FOUND;
3864 ret = STMF_ERROR_SERVICE_DATA_VERSION;
3869 "error(%d)", ret);
3870 ret = STMF_STATUS_ERROR;
3874 return (ret);
3890 int ret;
3896 ret = groupMemberListIoctl(groupName, groupProp, HOST_GROUP);
3898 return (ret);
3937 int ret;
3947 ret = initializeConfig();
3948 if (ret != STMF_STATUS_SUCCESS) {
3949 return (ret);
3965 int ret;
3967 ret = psGetProviderDataList(providerList);
3968 switch (ret) {
3970 ret = STMF_STATUS_SUCCESS;
3973 ret = STMF_ERROR_BUSY;
3976 ret = STMF_ERROR_SERVICE_NOT_FOUND;
3979 ret = STMF_ERROR_SERVICE_DATA_VERSION;
3984 ":error(%d)", ret);
3985 ret = STMF_STATUS_ERROR;
3989 return (ret);
4005 int ret = STMF_STATUS_SUCCESS;
4016 ret = STMF_ERROR_INVALID_ARG;
4020 ret = initializeConfig();
4021 if (ret != STMF_STATUS_SUCCESS) {
4022 return (ret);
4028 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
4029 return (ret);
4039 ret = STMF_ERROR_NOMEM;
4060 ret = STMF_ERROR_BUSY;
4064 ret = STMF_ERROR_PERM;
4070 ret = STMF_STATUS_ERROR;
4083 ret = STMF_ERROR_NOMEM;
4093 ret = STMF_ERROR_BUSY;
4097 ret = STMF_ERROR_PERM;
4103 ret = STMF_STATUS_ERROR;
4116 ret = STMF_ERROR_NOMEM;
4142 return (ret);
4156 int ret;
4162 ret = groupListIoctl(targetGroupList, TARGET_GROUP);
4163 return (ret);
4179 int ret;
4185 ret = groupMemberListIoctl(groupName, groupProp, TARGET_GROUP);
4187 return (ret);
4201 int ret;
4215 ret = initializeConfig();
4216 if (ret != STMF_STATUS_SUCCESS) {
4217 return (ret);
4223 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
4224 return (ret);
4233 ret = STMF_ERROR_NOMEM;
4248 ret = STMF_ERROR_BUSY;
4252 ret = STMF_ERROR_PERM;
4257 ret = STMF_STATUS_ERROR;
4271 ret = STMF_ERROR_NOMEM;
4281 ret = STMF_ERROR_BUSY;
4285 ret = STMF_ERROR_PERM;
4291 ret = STMF_STATUS_ERROR;
4302 ret = STMF_ERROR_NOMEM;
4318 return (ret);
4334 int ret = STMF_STATUS_SUCCESS;
4346 ret = initializeConfig();
4347 if (ret != STMF_STATUS_SUCCESS) {
4348 return (ret);
4354 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
4355 return (ret);
4375 ret = STMF_ERROR_BUSY;
4379 ret = STMF_ERROR_PERM;
4382 ret = STMF_ERROR_NOT_FOUND;
4388 ret = STMF_STATUS_ERROR;
4413 return (ret);
4428 int ret;
4443 ret = initializeConfig();
4444 if (ret != STMF_STATUS_SUCCESS) {
4445 return (ret);
4451 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
4452 return (ret);
4461 ret = STMF_ERROR_NOMEM;
4476 ret = STMF_ERROR_BUSY;
4480 ret = STMF_ERROR_PERM;
4486 ret = STMF_STATUS_ERROR;
4500 ret = STMF_ERROR_NOMEM;
4509 ret = STMF_ERROR_BUSY;
4513 ret = STMF_ERROR_PERM;
4519 ret = STMF_STATUS_ERROR;
4526 if (ret != STMF_STATUS_SUCCESS) {
4538 ret = STMF_ERROR_NOMEM;
4562 return (ret);
4577 int ret = STMF_STATUS_SUCCESS;
4593 ret = initializeConfig();
4594 if (ret != STMF_STATUS_SUCCESS) {
4595 return (ret);
4601 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
4602 return (ret);
4617 ret = STMF_ERROR_BUSY;
4621 ret = STMF_ERROR_PERM;
4630 ret = STMF_STATUS_SUCCESS;
4632 ret = STMF_ERROR_NOT_FOUND;
4635 ret = STMF_ERROR_NOT_FOUND;
4643 ret = STMF_STATUS_ERROR;
4663 return (ret);
4677 int ret;
4684 ret = getStmfState(&iState);
4685 if (ret != STMF_STATUS_SUCCESS) {
4686 return (ret);
4742 int ret;
4757 ret = initializeConfig();
4758 if (ret != STMF_STATUS_SUCCESS) {
4759 return (ret);
4765 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
4766 return (ret);
4775 ret = STMF_ERROR_NOMEM;
4792 ret = STMF_ERROR_BUSY;
4796 ret = STMF_ERROR_PERM;
4802 ret = STMF_STATUS_ERROR;
4825 ret = STMF_ERROR_BUSY;
4829 ret = STMF_ERROR_PERM;
4835 ret = STMF_STATUS_ERROR;
4842 if (ret != STMF_STATUS_SUCCESS) {
4854 ret = STMF_ERROR_NOMEM;
4895 return (ret);
4911 int ret = STMF_STATUS_SUCCESS;
4915 if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_HOST_GROUP,
4919 ret = iLoadGroupMembersFromPs(&(groupList->name[i]),
4922 if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_HG_ENTRY,
4933 return (ret);
4948 int ret = STMF_STATUS_SUCCESS;
4952 if ((ret = groupIoctl(fd, STMF_IOCTL_CREATE_TARGET_GROUP,
4956 ret = iLoadGroupMembersFromPs(&(groupList->name[i]),
4959 if ((ret = groupMemberIoctl(fd, STMF_IOCTL_ADD_TG_ENTRY,
4970 return (ret);
4987 int ret;
4999 ret = iLoadGroupFromPs(&groupList, HOST_GROUP);
5000 if (ret != STMF_STATUS_SUCCESS) {
5001 return (ret);
5003 ret = loadHostGroups(fd, groupList);
5004 if (ret != STMF_STATUS_SUCCESS) {
5012 ret = iLoadGroupFromPs(&groupList, TARGET_GROUP);
5013 if (ret != STMF_STATUS_SUCCESS) {
5016 ret = loadTargetGroups(fd, groupList);
5017 if (ret != STMF_STATUS_SUCCESS) {
5025 ret = psGetLogicalUnitList(&guidList);
5026 switch (ret) {
5028 ret = STMF_STATUS_SUCCESS;
5031 ret = STMF_ERROR_NOT_FOUND;
5034 ret = STMF_ERROR_BUSY;
5037 ret = STMF_ERROR_SERVICE_NOT_FOUND;
5040 ret = STMF_ERROR_SERVICE_DATA_VERSION;
5043 ret = STMF_STATUS_ERROR;
5047 if (ret != STMF_STATUS_SUCCESS) {
5056 ret = psGetViewEntryList(&guidList->guid[i], &viewEntryList);
5057 switch (ret) {
5059 ret = STMF_STATUS_SUCCESS;
5062 ret = STMF_ERROR_NOT_FOUND;
5065 ret = STMF_ERROR_BUSY;
5068 ret = STMF_ERROR_SERVICE_NOT_FOUND;
5071 ret = STMF_ERROR_SERVICE_DATA_VERSION;
5074 ret = STMF_STATUS_ERROR;
5077 if (ret != STMF_STATUS_SUCCESS) {
5081 ret = addViewEntryIoctl(fd, &guidList->guid[i],
5083 if (ret != STMF_STATUS_SUCCESS) {
5090 ret = psGetProviderDataList(&providerList);
5091 switch (ret) {
5093 ret = STMF_STATUS_SUCCESS;
5096 ret = STMF_ERROR_NOT_FOUND;
5099 ret = STMF_ERROR_BUSY;
5102 ret = STMF_ERROR_SERVICE_NOT_FOUND;
5105 ret = STMF_ERROR_SERVICE_DATA_VERSION;
5108 ret = STMF_STATUS_ERROR;
5111 if (ret != STMF_STATUS_SUCCESS) {
5117 ret = psGetProviderData(providerList->provider[i].name,
5119 switch (ret) {
5121 ret = STMF_STATUS_SUCCESS;
5124 ret = STMF_ERROR_NOT_FOUND;
5127 ret = STMF_ERROR_BUSY;
5130 ret = STMF_ERROR_SERVICE_NOT_FOUND;
5133 ret = STMF_ERROR_SERVICE_DATA_VERSION;
5136 ret = STMF_STATUS_ERROR;
5139 if (ret != STMF_STATUS_SUCCESS) {
5144 ret = setProviderData(fd, providerList->provider[i].name, nvl,
5146 switch (ret) {
5148 ret = STMF_STATUS_SUCCESS;
5151 ret = STMF_ERROR_NOT_FOUND;
5154 ret = STMF_ERROR_BUSY;
5157 ret = STMF_ERROR_SERVICE_NOT_FOUND;
5160 ret = STMF_ERROR_SERVICE_DATA_VERSION;
5163 ret = STMF_STATUS_ERROR;
5166 if (ret != STMF_STATUS_SUCCESS) {
5186 return (ret);
5198 int ret = STMF_STATUS_SUCCESS;
5211 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
5212 return (ret);
5227 ret = STMF_ERROR_BUSY;
5231 ret = STMF_ERROR_PERM;
5236 ret = STMF_STATUS_ERROR;
5248 return (ret);
5260 int ret = STMF_STATUS_SUCCESS;
5279 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
5280 return (ret);
5295 ret = STMF_ERROR_BUSY;
5299 ret = STMF_ERROR_PERM;
5304 ret = STMF_STATUS_ERROR;
5308 if (!enabled && ret == STMF_STATUS_SUCCESS) {
5312 return (ret);
5364 int ret = STMF_STATUS_SUCCESS;
5372 if ((ret = openStmf(OPEN_EXCL_STMF, &fd))
5374 return (ret);
5389 ret = stmfGetState(&state);
5390 if (ret == STMF_STATUS_SUCCESS) {
5405 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5406 return (ret);
5408 ret = setStmfState(fd, &stmfStateSet, STMF_SERVICE_TYPE);
5409 if (ret != STMF_STATUS_SUCCESS) {
5414 ret = loadStore(fd);
5415 if (ret != 0) {
5423 if (ret == STMF_STATUS_SUCCESS) {
5424 ret = setStmfState(fd, &stmfStateSet, STMF_SERVICE_TYPE);
5427 return (ret);
5440 int ret = STMF_STATUS_SUCCESS;
5448 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
5449 return (ret);
5467 ret = STMF_ERROR_BUSY;
5471 ret = STMF_ERROR_PERM;
5476 ret = STMF_STATUS_ERROR;
5480 return (ret);
5496 int ret = STMF_STATUS_SUCCESS;
5512 ret = STMF_STATUS_ERROR;
5527 ret = STMF_ERROR_BUSY;
5531 ret = STMF_ERROR_PERM;
5534 ret = STMF_ERROR_NOT_FOUND;
5539 ret = STMF_STATUS_ERROR;
5544 return (ret);
5549 int ret = STMF_STATUS_SUCCESS;
5558 ret = psSetStmfProp(propType, propVal);
5559 switch (ret) {
5561 ret = STMF_STATUS_SUCCESS;
5564 ret = STMF_ERROR_BUSY;
5569 ret);
5570 ret = STMF_STATUS_ERROR;
5573 return (ret);
5580 int ret = STMF_STATUS_SUCCESS;
5595 ret = psGetStmfProp(propType, prop);
5601 switch (ret) {
5603 ret = STMF_STATUS_SUCCESS;
5606 ret = STMF_ERROR_BUSY;
5609 ret = STMF_ERROR_NOT_FOUND;
5614 ret);
5615 ret = STMF_STATUS_ERROR;
5618 return (ret);
5625 int ret;
5626 if ((ret = psGetStmfProp(STMF_DEFAULT_LU_STATE, propVal)) ==
5637 "DefaultLuState:psSetStmfProp:error(%d)", ret);
5641 if ((ret = psGetStmfProp(STMF_DEFAULT_TARGET_PORT_STATE, propVal)) ==
5652 "DefaultTargetPortState:psSetStmfProp:error(%d)", ret);
5656 switch (ret) {
5658 ret = STMF_STATUS_SUCCESS;
5661 ret = STMF_ERROR_NOT_FOUND;
5664 ret = STMF_ERROR_BUSY;
5667 ret = STMF_STATUS_ERROR;
5670 return (ret);
5676 int ret = STMF_STATUS_SUCCESS;
5684 ret = STMF_ERROR_NOMEM;
5690 if ((ret = setStmfProp(stmf_set_props)) != STMF_STATUS_SUCCESS)
5704 ret = STMF_ERROR_BUSY;
5708 ret = STMF_ERROR_PERM;
5711 ret = STMF_ERROR_NOT_FOUND;
5717 ret = STMF_STATUS_ERROR;
5725 return (ret);
5731 int ret = STMF_STATUS_SUCCESS;
5734 if ((ret = openStmf(OPEN_EXCL_STMF, &fd))
5738 ret = loadStmfProp(fd);
5742 if (ret != STMF_STATUS_SUCCESS) {
5746 return (ret);
5758 int ret;
5763 ret = stmfGetState(&state);
5764 if (ret == STMF_STATUS_SUCCESS) {
5777 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5778 return (ret);
5779 ret = setStmfState(fd, &iState, STMF_SERVICE_TYPE);
5781 return (ret);
5793 int ret;
5798 ret = stmfGetState(&state);
5799 if (ret == STMF_STATUS_SUCCESS) {
5813 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5814 return (ret);
5815 ret = setStmfState(fd, &iState, STMF_SERVICE_TYPE);
5817 return (ret);
5832 int ret = STMF_STATUS_SUCCESS;
5848 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5849 return (ret);
5850 ret = setStmfState(fd, &targetState, TARGET_TYPE);
5852 return (ret);
5866 int ret = STMF_STATUS_SUCCESS;
5881 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5882 return (ret);
5883 ret = setStmfState(fd, &luState, LOGICAL_UNIT_TYPE);
5885 return (ret);
5899 int ret = STMF_STATUS_SUCCESS;
5915 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5916 return (ret);
5917 ret = setStmfState(fd, &targetState, TARGET_TYPE);
5919 return (ret);
5933 int ret = STMF_STATUS_SUCCESS;
5948 if ((ret = openStmf(OPEN_EXCL_STMF, &fd)) != STMF_STATUS_SUCCESS)
5949 return (ret);
5950 ret = setStmfState(fd, &luState, LOGICAL_UNIT_TYPE);
5952 return (ret);
5966 int ret;
5976 ret = initializeConfig();
5977 if (ret != STMF_STATUS_SUCCESS) {
5978 return (ret);
5984 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
5985 return (ret);
5987 if ((ret = groupMemberIoctl(fd, STMF_IOCTL_REMOVE_HG_ENTRY,
5996 ret = psRemoveHostGroupMember((char *)hostGroupName,
5998 switch (ret) {
6000 ret = STMF_STATUS_SUCCESS;
6003 ret = STMF_ERROR_MEMBER_NOT_FOUND;
6006 ret = STMF_ERROR_GROUP_NOT_FOUND;
6009 ret = STMF_ERROR_BUSY;
6012 ret = STMF_ERROR_SERVICE_NOT_FOUND;
6015 ret = STMF_ERROR_SERVICE_DATA_VERSION;
6020 "psRemoveHostGroupMember:error(%d)", ret);
6021 ret = STMF_STATUS_ERROR;
6027 return (ret);
6041 int ret;
6051 ret = initializeConfig();
6052 if (ret != STMF_STATUS_SUCCESS) {
6053 return (ret);
6059 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
6060 return (ret);
6062 if ((ret = groupMemberIoctl(fd, STMF_IOCTL_REMOVE_TG_ENTRY,
6071 ret = psRemoveTargetGroupMember((char *)targetGroupName,
6073 switch (ret) {
6075 ret = STMF_STATUS_SUCCESS;
6078 ret = STMF_ERROR_MEMBER_NOT_FOUND;
6081 ret = STMF_ERROR_GROUP_NOT_FOUND;
6084 ret = STMF_ERROR_BUSY;
6087 ret = STMF_ERROR_SERVICE_NOT_FOUND;
6090 ret = STMF_ERROR_SERVICE_DATA_VERSION;
6095 "psRemoveTargetGroupMember:error(%d)", ret);
6096 ret = STMF_STATUS_ERROR;
6102 return (ret);
6117 int ret = STMF_STATUS_SUCCESS;
6128 ret = initializeConfig();
6129 if (ret != STMF_STATUS_SUCCESS) {
6130 return (ret);
6136 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
6137 return (ret);
6155 ret = STMF_ERROR_BUSY;
6158 ret = STMF_ERROR_PERM;
6163 ret = STMF_ERROR_CONFIG_NONE;
6166 ret = STMF_ERROR_PERM;
6172 ret = STMF_ERROR_NOT_FOUND;
6178 ret = STMF_STATUS_ERROR;
6188 ret = psRemoveViewEntry(lu, viewEntryIndex);
6189 switch (ret) {
6191 ret = STMF_STATUS_SUCCESS;
6194 ret = STMF_ERROR_NOT_FOUND;
6197 ret = STMF_ERROR_BUSY;
6200 ret = STMF_ERROR_SERVICE_NOT_FOUND;
6203 ret = STMF_ERROR_SERVICE_DATA_VERSION;
6208 ret);
6209 ret = STMF_STATUS_ERROR;
6215 return (ret);
6253 int ret;
6266 ret = initializeConfig();
6267 if (ret != STMF_STATUS_SUCCESS) {
6268 return (ret);
6274 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
6275 return (ret);
6277 ret = setProviderData(fd, providerName, nvl, providerType, setToken);
6281 if (ret != STMF_STATUS_SUCCESS) {
6290 ret = psSetProviderData(providerName, nvl, providerType, NULL);
6291 switch (ret) {
6293 ret = STMF_STATUS_SUCCESS;
6296 ret = STMF_ERROR_EXISTS;
6299 ret = STMF_ERROR_BUSY;
6302 ret = STMF_ERROR_SERVICE_NOT_FOUND;
6305 ret = STMF_ERROR_SERVICE_DATA_VERSION;
6308 ret = STMF_ERROR_PROV_DATA_STALE;
6313 "psSetProviderData:error(%d)", ret);
6314 ret = STMF_STATUS_ERROR;
6319 return (ret);
6336 int ret = STMF_STATUS_SUCCESS;
6353 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
6354 return (ret);
6360 ret = STMF_ERROR_INVALID_ARG;
6371 ret = STMF_ERROR_INVALID_ARG;
6380 ret = STMF_ERROR_NOMEM;
6400 ret = STMF_ERROR_BUSY;
6404 ret = STMF_ERROR_PERM;
6415 ret = STMF_ERROR_BUSY;
6417 ret =
6425 ret = STMF_STATUS_ERROR;
6429 ret = STMF_ERROR_NOT_FOUND;
6435 ret = STMF_STATUS_ERROR;
6438 if (ret != STMF_STATUS_SUCCESS)
6443 if ((ret = nvlist_unpack((char *)ppi_out->ppi_data,
6445 ret = STMF_STATUS_ERROR;
6456 return (ret);
6473 int ret = STMF_STATUS_SUCCESS;
6540 ret = STMF_ERROR_BUSY;
6544 ret = STMF_ERROR_PERM;
6549 ret = STMF_ERROR_PROV_DATA_STALE;
6551 ret = STMF_STATUS_ERROR;
6557 ret = STMF_STATUS_ERROR;
6560 if (ret != STMF_STATUS_SUCCESS)
6570 return (ret);
6579 int ret = STMF_STATUS_SUCCESS;
6594 ret = psSetServicePersist(persistType);
6595 if (ret != STMF_PS_SUCCESS) {
6596 ret = STMF_ERROR_PERSIST_TYPE;
6603 return (ret);
6620 int ret;
6621 ret = psGetServicePersist(&persistType);
6622 if (ret != STMF_PS_SUCCESS) {
6638 int ret = STMF_STATUS_SUCCESS;
6644 ret = psGetServicePersist(persistType);
6645 if (ret != STMF_PS_SUCCESS) {
6646 ret = STMF_ERROR_PERSIST_TYPE;
6658 return (ret);
6672 int ret = STMF_STATUS_SUCCESS;
6691 ret = STMF_ERROR_PERM;
6694 ret = STMF_ERROR_POST_MSG_FAILED;
6699 return (ret);
6713 int ret = STMF_STATUS_SUCCESS;
6725 if ((ret = openPppt(OPEN_PPPT, &fd)) != STMF_STATUS_SUCCESS) {
6726 return (ret);
6739 ret = STMF_ERROR_PERM;
6742 ret = STMF_ERROR_INVALID_ARG;
6745 ret = STMF_ERROR_DOOR_INSTALLED;
6748 ret = STMF_STATUS_ERROR;
6755 return (ret);
6774 int ret = STMF_STATUS_SUCCESS;
6826 ret = STMF_ERROR_BUSY;
6829 ret = STMF_ERROR_PERM;
6834 ret = STMF_ERROR_CONFIG_NONE;
6837 ret = STMF_ERROR_PERM;
6844 ret = STMF_ERROR_LUN_IN_USE;
6847 ret = STMF_ERROR_VE_CONFLICT;
6850 ret = STMF_ERROR_CONFIG_NONE;
6853 ret = STMF_ERROR_INVALID_HG;
6856 ret = STMF_ERROR_INVALID_TG;
6863 ret = STMF_STATUS_ERROR;
6869 return (ret);
6882 int ret;
6925 ret = initializeConfig();
6926 if (ret != STMF_STATUS_SUCCESS) {
6927 return (ret);
6933 if ((ret = openStmf(OPEN_STMF, &fd)) != STMF_STATUS_SUCCESS)
6934 return (ret);
6939 ret = validateLunNumIoctl(fd, &iViewEntry);
6948 return (ret);