Discussion:
[Libstoragemgmt-devel] [PATCH] C & PY API: Clean-up error number constants
Tony Asleson
2014-08-06 00:01:14 UTC
Permalink
See email from Gris subject: "Error number review"

Signed-off-by: Tony Asleson <***@redhat.com>
---
.../include/libstoragemgmt/libstoragemgmt_error.h | 62 ++----
c_binding/lsm_datatypes.cpp | 101 +++++-----
c_binding/lsm_mgmt.cpp | 209 ++++++---------------
c_binding/lsm_plugin_ipc.cpp | 18 +-
plugin/nstor/nstor.py | 8 +-
plugin/ontap/na.py | 4 +-
plugin/ontap/ontap.py | 30 +--
plugin/sim/simarray.py | 76 ++++----
plugin/simc/simc_lsmplugin.c | 26 +--
plugin/smispy/smis.py | 56 +++---
plugin/targetd/targetd.py | 10 +-
python_binding/lsm/_common.py | 66 ++-----
python_binding/lsm/_data.py | 6 +-
python_binding/lsm/_pluginrunner.py | 2 +-
python_binding/lsm/_transport.py | 2 +-
test/tester.c | 100 +++++-----
16 files changed, 308 insertions(+), 468 deletions(-)

diff --git a/c_binding/include/libstoragemgmt/libstoragemgmt_error.h b/c_binding/include/libstoragemgmt/libstoragemgmt_error.h
index 60f2362..5ce1d2c 100644
--- a/c_binding/include/libstoragemgmt/libstoragemgmt_error.h
+++ b/c_binding/include/libstoragemgmt/libstoragemgmt_error.h
@@ -48,7 +48,6 @@ typedef enum {
LSM_ERR_PLUGIN_BUG = 2, /**< Plugin BUG */
LSM_ERR_STORAGE_SDK_BUG = 3, /**< Storage SDK BUG */
LSM_ERR_JOB_STARTED = 7, /**< Operation has started */
- LSM_ERR_INDEX_BOUNDS = 10, /**< Out of bounds on string index */
LSM_ERR_TIMEOUT = 11, /**< Plug-in is un-responsive */
LSM_ERR_DAEMON_NOT_RUNNING = 12, /**< Daemon is not running */

@@ -57,35 +56,17 @@ typedef enum {
LSM_ERR_EXISTS_INITIATOR = 52, /**< Initiator exists */
LSM_ERR_EXISTS_NAME = 53, /**< Named item already exists */
LSM_ERR_FS_NOT_EXPORTED = 54, /**< FS not nfs exported */
- LSM_ERR_INITIATOR_NOT_IN_ACCESS_GROUP = 55, /**< Initiator not in access group */
LSM_ERR_EXISTS_POOL = 56, /**< Pool exists */
LSM_ERR_EXISTS_VOLUME = 57, /**< Volume exists */

- LSM_ERR_INVALID_ACCESS_GROUP = 100, /**< Invalid access group */
LSM_ERR_INVALID_ARGUMENT = 101, /**< Precondition checks failed */
- LSM_ERR_INVALID_CONN = 102, /**< Connection structure is invalid */
- LSM_ERR_INVALID_ERR = 103, /**< Invalid error structure */
- LSM_ERR_INVALID_FS = 104, /**< invalid fs */
- LSM_ERR_INVALID_JOB = 106, /**< Invalid job number */
- LSM_ERR_INVALID_NAME = 107, /**< Name specified is invalid */
- LSM_ERR_INVALID_NFS = 108, /**< invalid nfs export record */
- LSM_ERR_INVALID_PLUGIN = 109, /**< Invalid plugin structure */
- LSM_ERR_INVALID_POOL = 110, /**< Invalid pool pointer */
- LSM_ERR_INVALID_SL = 111, /**< Invalid string list */
- LSM_ERR_INVALID_SS = 112, /**< Invalid snapshot */
- LSM_ERR_INVALID_URI = 113, /**< Invalid uri */
- LSM_ERR_INVALID_VAL = 114, /**< Invalid value */
- LSM_ERR_INVALID_VOL = 115, /**< Invalid volume pointer */
- LSM_ERR_INVALID_CAPABILITY = 116, /**< Invalid capability pointer */
- LSM_ERR_INVALID_SYSTEM = 117, /**< Invalid system pointer */
- LSM_ERR_INVALID_INIT = 118, /**< Invalid Initiator ID */
- LSM_ERR_INVALID_DISK = 119, /**< Invalid disk */
- LSM_ERR_INVALID_HASH = 120, /**< Invalid optional data */
- LSM_ERR_INVALID_BLOCK_RANGE = 121, /**< Invalud block range */

LSM_ERR_IS_MAPPED = 125, /**< Mapping already exists */

- LSM_ERR_NO_CONNECT = 150, /**< Unable to connect to host */
+ LSM_ERR_CONNREFUSED = 140, /**< Host on network, but not allowing connection */
+ LSM_ERR_HOSTDOWN = 141, /**< Host unreachable on network */
+ LSM_ERR_NETWORK_ERROR = 142, /**< Generic network error */
+
LSM_ERR_NO_MAPPING = 151, /**< There is no access for initiator and volume */
LSM_ERR_NO_MEMORY = 152, /**< Memory allocation failure */
LSM_ERR_NO_SUPPORT = 153, /**< Feature not supported */
@@ -94,51 +75,42 @@ typedef enum {
LSM_ERR_NOT_FOUND_FS = 201, /**< Specified FS not found */
LSM_ERR_NOT_FOUND_JOB = 202, /**< Specified JOB not found */
LSM_ERR_NOT_FOUND_POOL = 203, /**< Specified POOL not found */
- LSM_ERR_NOT_FOUND_SS = 204, /**< Specified snap shot not found */
+ LSM_ERR_NOT_FOUND_FS_SS = 204, /**< Specified snap shot not found */
LSM_ERR_NOT_FOUND_VOLUME = 205, /**< Specified volume not found */
LSM_ERR_NOT_FOUND_NFS_EXPORT = 206, /**< NFS export not found */
LSM_ERR_NOT_FOUND_INITIATOR = 207, /**< Initiator not found */
LSM_ERR_NOT_FOUND_SYSTEM = 208, /**< System not found */
LSM_ERR_NOT_FOUND_DISK = 209, /**< Disk not found */

- LSM_ERR_NOT_IMPLEMENTED = 225, /**< Feature not implemented */
LSM_ERR_NOT_LICENSED = 226, /**< Need license for feature */

- LSM_ERR_OFF_LINE = 250, /**< Specified element is off line */
- LSM_ERR_ON_LINE = 251, /**< Specified element is on line */
+ LSM_ERR_NO_SUPPORT_ONLINE_CHANGE = 250, /**< Take offline before performing operation */
+ LSM_ERR_NO_SUPPORT_OFFLINE_CHANGE = 251, /**< Needs to be online to perform operation */

LSM_ERR_PLUGIN_AUTH_FAILED = 300, /**< Authorization failed */
- LSM_ERR_PLUGIN_DLOPEN = 301, /**< dlopen on plugin failed */
- LSM_ERR_PLUGIN_DLSYM = 302, /**< Required symbols in plugin missing */
- LSM_ERR_PLUGIN_ERROR = 303, /**< Non-descript plugin error */
- LSM_ERR_PLUGIN_MISSING_HOST = 304, /**< Missing or invalid hostname */
- LSM_ERR_PLUGIN_MISSING_NS = 305, /**< Missing namespace */
- LSM_ERR_PLUGIN_MISSING_PORT = 306, /**< Missing port */
- LSM_ERR_PLUGIN_PERMISSIONS = 307, /**< Unable to access plugin */
+ LSM_ERR_PLUGIN_IPC_FAIL = 301, /**< dlopen on plugin failed */
+
+ LSM_ERR_PLUGIN_SOCKET_PERMISSION = 307, /**< Unable to access plugin */
LSM_ERR_PLUGIN_REGISTRATION = 308, /**< Error during plug-in registration */
- LSM_ERR_PLUGIN_UNKNOWN_HOST = 309, /**< Name resolution failed */
- LSM_ERR_PLUGIN_TIMEOUT = 310, /**< Plug-in timed out talking to array */
LSM_ERR_PLUGIN_NOT_EXIST = 311, /**< Plug-in does not appear to exist */

- LSM_ERR_SIZE_INSUFFICIENT_SPACE = 350, /**< Insufficient space */
+ LSM_ERR_NOT_ENOUGH_SPACE = 350, /**< Insufficient space */
LSM_ERR_VOLUME_SAME_SIZE = 351, /**< Trying to resize to same size */
- LSM_ERR_SIZE_TOO_LARGE = 352, /**< Size specified is too large */
LSM_ERR_SIZE_TOO_SMALL = 353, /**< Size specified is too small */
LSM_ERR_SIZE_LIMIT_REACHED = 354, /**< Limit has been reached */

- LSM_ERR_TRANSPORT_COMMUNICATION = 400, /**< Error comunicating with plug-in */
- LSM_ERR_TRANSPORT_SERIALIZATION = 401, /**< Transport serialization error */
+ LSM_ERR_TRANSPORT_COMMUNICATION = 400, /**< Error comunicating with plug-in */
+ LSM_ERR_TRANSPORT_SERIALIZATION = 401, /**< Transport serialization error */
LSM_ERR_TRANSPORT_INVALID_ARG = 402, /**< Parameter transported over IPC is invalid */

- LSM_ERR_UNSUPPORTED_INITIATOR_TYPE = 450, /**< Unsupported initiator type */
- LSM_ERR_UNSUPPORTED_PROVISIONING = 451, /**< Unsupported provisioning */
- LSM_ERR_UNSUPPORTED_REPLICATION_TYPE = 452, /**< Unsupported replication type */
-
LSM_ERR_DISK_BUSY = 500, /* Disk already in use */
LSM_ERR_VOLUME_BUSY = 501, /* Volume already in use */
+ ACCESS_GROUP_MASKED = 502,
+

+ LSM_ERR_UNSUPPORTED_SEARCH_KEY = 510, /**< Unsupport search key */

- LSM_ERR_UNSUPPORTED_SEARCH_KEY = 510 /**< Unsupport search key */
+ EMPTY_ACCESS_GROUP = 511

} lsm_error_number;

diff --git a/c_binding/lsm_datatypes.cpp b/c_binding/lsm_datatypes.cpp
index fa2adab..8e53158 100644
--- a/c_binding/lsm_datatypes.cpp
+++ b/c_binding/lsm_datatypes.cpp
@@ -61,7 +61,7 @@ extern "C" {

int lsm_string_list_append(lsm_string_list *sl, const char *value)
{
- int rc = LSM_ERR_INVALID_SL;
+ int rc = LSM_ERR_INVALID_ARGUMENT;

if( LSM_IS_STRING_LIST(sl) ) {
char *d = strdup(value);
@@ -77,14 +77,12 @@ int lsm_string_list_append(lsm_string_list *sl, const char *value)

int lsm_string_list_delete(lsm_string_list *sl, uint32_t index)
{
- int rc = LSM_ERR_INVALID_SL;
+ int rc = LSM_ERR_INVALID_ARGUMENT;

if( LSM_IS_STRING_LIST(sl) ) {
if( index < sl->values->len ) {
g_ptr_array_remove_index(sl->values, index);
rc = LSM_ERR_OK;
- } else {
- rc = LSM_ERR_INDEX_BOUNDS;
}
}
return rc;
@@ -118,7 +116,7 @@ int lsm_string_list_elem_set(lsm_string_list *sl, uint32_t index,
}
}
} else {
- rc = LSM_ERR_INVALID_SL;
+ rc = LSM_ERR_INVALID_ARGUMENT;
}
return rc;
}
@@ -163,7 +161,7 @@ int lsm_string_list_free(lsm_string_list *sl)
free(sl);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

uint32_t lsm_string_list_size(lsm_string_list *sl)
@@ -311,24 +309,24 @@ int driver_load(lsm_connect *c, const char *plugin_name, const char *password,
c->tp = new Ipc(sd);
if( startup ) {
if( connection_establish(c, password, timeout, e, flags)) {
- rc = LSM_ERR_PLUGIN_DLOPEN;
+ rc = LSM_ERR_PLUGIN_IPC_FAIL;
}
}
} else {
- *e = lsm_error_create(LSM_ERR_PLUGIN_DLOPEN,
+ *e = lsm_error_create(LSM_ERR_PLUGIN_IPC_FAIL,
LSM_ERR_DOMAIN_FRAME_WORK,
LSM_ERR_LEVEL_ERROR, "Unable to connect to plugin",
NULL, dlerror(), NULL, 0 );

- rc = LSM_ERR_PLUGIN_DLOPEN;
+ rc = LSM_ERR_PLUGIN_IPC_FAIL;
}
} else {
- *e = lsm_error_create(LSM_ERR_PLUGIN_PERMISSIONS,
+ *e = lsm_error_create(LSM_ERR_PLUGIN_SOCKET_PERMISSION,
LSM_ERR_DOMAIN_FRAME_WORK,
LSM_ERR_LEVEL_ERROR, "Unable to access plugin",
NULL, NULL, NULL, 0 );

- rc = LSM_ERR_PLUGIN_PERMISSIONS;
+ rc = LSM_ERR_PLUGIN_SOCKET_PERMISSION;
}

free(plugin_file);
@@ -379,7 +377,7 @@ lsm_error_ptr lsm_error_create(lsm_error_number code, lsm_error_domain domain,
int lsm_error_free(lsm_error_ptr e)
{
if (!LSM_IS_ERROR(e)) {
- return LSM_ERR_INVALID_ERR;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if (e->debug_data) {
@@ -585,11 +583,11 @@ int lsm_pool_record_free(lsm_pool *p)
free(p);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_POOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

CREATE_FREE_ARRAY_FUNC(lsm_pool_record_array_free, lsm_pool_record_free, lsm_pool *,
- LSM_ERR_INVALID_POOL)
+ LSM_ERR_INVALID_ARGUMENT)

char *lsm_pool_name_get(lsm_pool *p)
{
@@ -763,11 +761,11 @@ int lsm_system_record_free(lsm_system *s)
free(s);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_SYSTEM;
+ return LSM_ERR_INVALID_ARGUMENT;
}

CREATE_FREE_ARRAY_FUNC(lsm_system_record_array_free, lsm_system_record_free,
- lsm_system *, LSM_ERR_INVALID_SYSTEM)
+ lsm_system *, LSM_ERR_INVALID_ARGUMENT)

lsm_system *lsm_system_record_copy(lsm_system *s)
{
@@ -852,11 +850,11 @@ int lsm_volume_record_free(lsm_volume *v)
free(v);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_VOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

CREATE_FREE_ARRAY_FUNC( lsm_volume_record_array_free, lsm_volume_record_free,
- lsm_volume *, LSM_ERR_INVALID_VOL)
+ lsm_volume *, LSM_ERR_INVALID_ARGUMENT)

lsm_disk *lsm_disk_record_copy(lsm_disk *disk)
{
@@ -884,11 +882,11 @@ int lsm_disk_record_free(lsm_disk *d)
free(d);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_DISK;
+ return LSM_ERR_INVALID_ARGUMENT;
}

CREATE_FREE_ARRAY_FUNC( lsm_disk_record_array_free, lsm_disk_record_free,
- lsm_disk *, LSM_ERR_INVALID_DISK)
+ lsm_disk *, LSM_ERR_INVALID_ARGUMENT)

/* We would certainly expand this to encompass the entire function */
#define MEMBER_SET_REF(x, validation, member, value, alloc_func, free_func, error) \
@@ -1053,11 +1051,11 @@ int lsm_access_group_record_free(lsm_access_group *ag)
free(ag);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_ACCESS_GROUP;
+ return LSM_ERR_INVALID_ARGUMENT;
}

CREATE_FREE_ARRAY_FUNC(lsm_access_group_record_array_free, lsm_access_group_record_free,
- lsm_access_group *, LSM_ERR_INVALID_ACCESS_GROUP)
+ lsm_access_group *, LSM_ERR_INVALID_ARGUMENT)

const char *lsm_access_group_id_get( lsm_access_group *group )
{
@@ -1133,7 +1131,7 @@ int lsm_block_range_record_free( lsm_block_range *br )
free(br);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_BLOCK_RANGE;
+ return LSM_ERR_INVALID_ARGUMENT;
}

lsm_block_range *lsm_block_range_record_copy( lsm_block_range *source )
@@ -1150,7 +1148,7 @@ lsm_block_range *lsm_block_range_record_copy( lsm_block_range *source )

CREATE_ALLOC_ARRAY_FUNC(lsm_block_range_record_array_alloc, lsm_block_range *)
CREATE_FREE_ARRAY_FUNC(lsm_block_range_record_array_free, lsm_block_range_record_free,
- lsm_block_range *, LSM_ERR_INVALID_BLOCK_RANGE)
+ lsm_block_range *, LSM_ERR_INVALID_ARGUMENT)


uint64_t lsm_block_range_source_start_get(lsm_block_range *br)
@@ -1211,7 +1209,7 @@ int lsm_fs_record_free( lsm_fs *fs)
free(fs);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

lsm_fs *lsm_fs_record_copy(lsm_fs *source)
@@ -1230,7 +1228,7 @@ lsm_fs *lsm_fs_record_copy(lsm_fs *source)

CREATE_ALLOC_ARRAY_FUNC(lsm_fs_record_array_alloc, lsm_fs *)
CREATE_FREE_ARRAY_FUNC(lsm_fs_record_array_free, lsm_fs_record_free, lsm_fs *,
- LSM_ERR_INVALID_FS)
+ LSM_ERR_INVALID_ARGUMENT)

const char *lsm_fs_id_get(lsm_fs *fs)
{
@@ -1309,12 +1307,12 @@ int lsm_fs_ss_record_free( lsm_fs_ss *ss)
free(ss);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_SS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

CREATE_ALLOC_ARRAY_FUNC(lsm_fs_ss_record_array_alloc, lsm_fs_ss *)
CREATE_FREE_ARRAY_FUNC(lsm_fs_ss_record_array_free, lsm_fs_ss_record_free, lsm_fs_ss *,
- LSM_ERR_INVALID_SS)
+ LSM_ERR_INVALID_ARGUMENT)

const char *lsm_fs_ss_id_get(lsm_fs_ss *ss)
{
@@ -1403,7 +1401,7 @@ int lsm_nfs_export_record_free( lsm_nfs_export *exp )
free(exp);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_NFS;
+ return LSM_ERR_INVALID_ARGUMENT;
}


@@ -1419,7 +1417,7 @@ lsm_nfs_export *lsm_nfs_export_record_copy( lsm_nfs_export *s )

CREATE_ALLOC_ARRAY_FUNC(lsm_nfs_export_record_array_alloc, lsm_nfs_export *)
CREATE_FREE_ARRAY_FUNC(lsm_nfs_export_record_array_free, lsm_nfs_export_record_free,
- lsm_nfs_export *, LSM_ERR_INVALID_NFS)
+ lsm_nfs_export *, LSM_ERR_INVALID_ARGUMENT)

const char *lsm_nfs_export_id_get( lsm_nfs_export *exp )
{
@@ -1429,7 +1427,7 @@ const char *lsm_nfs_export_id_get( lsm_nfs_export *exp )
int lsm_nfs_export_id_set(lsm_nfs_export *exp, const char *ep )
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, id, ep, strdup, free,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

const char *lsm_nfs_export_fs_id_get( lsm_nfs_export *exp )
@@ -1440,7 +1438,7 @@ const char *lsm_nfs_export_fs_id_get( lsm_nfs_export *exp )
int lsm_nfs_export_fs_id_set( lsm_nfs_export *exp, const char *fs_id)
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, fs_id, fs_id, strdup, free,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

const char *lsm_nfs_export_export_path_get( lsm_nfs_export *exp )
@@ -1451,7 +1449,7 @@ const char *lsm_nfs_export_export_path_get( lsm_nfs_export *exp )
int lsm_nfs_export_export_path_set( lsm_nfs_export *exp, const char *ep )
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, export_path, ep, strdup, free,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

const char *lsm_nfs_export_auth_type_get( lsm_nfs_export *exp )
@@ -1462,7 +1460,7 @@ const char *lsm_nfs_export_auth_type_get( lsm_nfs_export *exp )
int lsm_nfs_export_auth_type_set( lsm_nfs_export *exp, const char *auth )
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, auth_type, auth, strdup, free,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

lsm_string_list * lsm_nfs_export_root_get( lsm_nfs_export *exp)
@@ -1473,7 +1471,7 @@ lsm_string_list * lsm_nfs_export_root_get( lsm_nfs_export *exp)
int lsm_nfs_export_root_set( lsm_nfs_export *exp, lsm_string_list *root)
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, root, root, lsm_string_list_copy,
- lsm_string_list_free, LSM_ERR_INVALID_NFS);
+ lsm_string_list_free, LSM_ERR_INVALID_ARGUMENT);
}

lsm_string_list * lsm_nfs_export_read_write_get( lsm_nfs_export *exp)
@@ -1484,7 +1482,7 @@ lsm_string_list * lsm_nfs_export_read_write_get( lsm_nfs_export *exp)
int lsm_nfs_export_read_write_set( lsm_nfs_export *exp, lsm_string_list *rw)
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, rw, rw, lsm_string_list_copy,
- lsm_string_list_free, LSM_ERR_INVALID_NFS);
+ lsm_string_list_free, LSM_ERR_INVALID_ARGUMENT);
}

lsm_string_list * lsm_nfs_export_read_only_get( lsm_nfs_export *exp)
@@ -1495,7 +1493,7 @@ lsm_string_list * lsm_nfs_export_read_only_get( lsm_nfs_export *exp)
int lsm_nfs_export_read_only_set(lsm_nfs_export *exp, lsm_string_list *ro)
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, ro, ro, lsm_string_list_copy,
- lsm_string_list_free, LSM_ERR_INVALID_NFS);
+ lsm_string_list_free, LSM_ERR_INVALID_ARGUMENT);
}

uint64_t lsm_nfs_export_anon_uid_get( lsm_nfs_export *exp )
@@ -1506,7 +1504,7 @@ uint64_t lsm_nfs_export_anon_uid_get( lsm_nfs_export *exp )
int lsm_nfs_export_anon_uid_set( lsm_nfs_export *exp, uint64_t value)
{
MEMBER_SET_VAL(exp, LSM_IS_NFS_EXPORT, anonuid, value,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

uint64_t lsm_nfs_export_anon_gid_get( lsm_nfs_export *exp )
@@ -1517,7 +1515,7 @@ uint64_t lsm_nfs_export_anon_gid_get( lsm_nfs_export *exp )
int lsm_nfs_export_anon_gid_set( lsm_nfs_export *exp, uint64_t value )
{
MEMBER_SET_VAL(exp, LSM_IS_NFS_EXPORT, anongid, value,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

const char *lsm_nfs_export_options_get( lsm_nfs_export *exp)
@@ -1528,7 +1526,7 @@ const char *lsm_nfs_export_options_get( lsm_nfs_export *exp)
int lsm_nfs_export_options_set( lsm_nfs_export *exp, const char *value )
{
MEMBER_SET_REF(exp, LSM_IS_NFS_EXPORT, options, value, strdup, free,
- LSM_ERR_INVALID_NFS);
+ LSM_ERR_INVALID_ARGUMENT);
}

MEMBER_FUNC_GET(const char *, lsm_nfs_export_plugin_data_get,
@@ -1559,14 +1557,13 @@ int lsm_capability_set(lsm_storage_capabilities *cap, lsm_capability_type t,
{
int rc = LSM_ERR_INVALID_ARGUMENT;

- if( !LSM_IS_CAPABILITIY(cap) ) {
- return LSM_ERR_INVALID_CAPABILITY;
+ if( LSM_IS_CAPABILITIY(cap) ) {
+ if( (uint32_t)t < cap->len) {
+ cap->cap[t] = v;
+ rc = LSM_ERR_OK;
+ }
}

- if( (uint32_t)t < cap->len) {
- cap->cap[t] = v;
- rc = LSM_ERR_OK;
- }
return rc;
}

@@ -1578,7 +1575,7 @@ int lsm_capability_set_n( lsm_storage_capabilities *cap,
int index = 0;

if( !LSM_IS_CAPABILITIY(cap) ) {
- return LSM_ERR_INVALID_CAPABILITY;
+ return LSM_ERR_INVALID_ARGUMENT;
}

va_list var_arg;
@@ -1680,7 +1677,7 @@ int lsm_capability_record_free(lsm_storage_capabilities *cap)
free(cap);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_CAPABILITY;
+ return LSM_ERR_INVALID_ARGUMENT;
}

char* capability_string(lsm_storage_capabilities *c)
@@ -1745,7 +1742,7 @@ int lsm_hash_free(lsm_hash *op)
free(op);
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_HASH;
+ return LSM_ERR_INVALID_ARGUMENT;
}

int lsm_hash_keys(lsm_hash *op, lsm_string_list **l)
@@ -1771,7 +1768,7 @@ int lsm_hash_keys(lsm_hash *op, lsm_string_list **l)
}
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_HASH;
+ return LSM_ERR_INVALID_ARGUMENT;
}

const char *lsm_hash_string_get(lsm_hash *op,
@@ -1801,7 +1798,7 @@ int lsm_hash_string_set(lsm_hash *op,
return LSM_ERR_NO_MEMORY;
}
}
- return LSM_ERR_INVALID_HASH;
+ return LSM_ERR_INVALID_ARGUMENT;
}

lsm_target_port *lsm_target_port_record_alloc( const char *id,
@@ -1886,7 +1883,7 @@ MEMBER_FUNC_GET(const char *, lsm_target_port_system_id_get, lsm_target_port *tp
CREATE_ALLOC_ARRAY_FUNC(lsm_target_port_record_array_alloc, lsm_target_port *)
CREATE_FREE_ARRAY_FUNC(lsm_target_port_record_array_free,
lsm_target_port_record_free, lsm_target_port *,
- LSM_ERR_INVALID_SS)
+ LSM_ERR_INVALID_ARGUMENT)



diff --git a/c_binding/lsm_mgmt.cpp b/c_binding/lsm_mgmt.cpp
index 7ca71c0..5805cf9 100644
--- a/c_binding/lsm_mgmt.cpp
+++ b/c_binding/lsm_mgmt.cpp
@@ -57,9 +57,9 @@ static const char * const TARGET_PORT_SEARCH_KEYS[] = {"id", "system_id"};
*/
#define CONN_SETUP(c) do { \
if(!LSM_IS_CONNECT(c)) { \
- return LSM_ERR_INVALID_CONN; \
+ return LSM_ERR_INVALID_ARGUMENT;\
} \
- lsm_error_free(c->error); \
+ lsm_error_free(c->error); \
c->error = NULL; \
} while (0)

@@ -116,7 +116,7 @@ int lsm_connect_password(const char *uri, const char *password,
rc = LSM_ERR_NO_MEMORY;
}
} else {
- rc = LSM_ERR_INVALID_URI;
+ rc = LSM_ERR_INVALID_ARGUMENT;
}

/*If we fail for any reason free resources associated with connection*/
@@ -131,12 +131,8 @@ int lsm_connect_password(const char *uri, const char *password,

static int lsmErrorLog(lsm_connect *c, lsm_error_ptr error)
{
- if (!LSM_IS_CONNECT(c)) {
- return LSM_ERR_INVALID_CONN;
- }
-
- if (!LSM_IS_ERROR(error)) {
- return LSM_ERR_INVALID_ERR;
+ if ( !LSM_IS_CONNECT(c) || !LSM_IS_ERROR(error) ) {
+ return LSM_ERR_INVALID_ARGUMENT;
}

if (c->error) {
@@ -649,11 +645,8 @@ int lsm_capabilities(lsm_connect *c, lsm_system *system,
int rc = LSM_ERR_OK;
CONN_SETUP(c);

- if( !LSM_IS_SYSTEM(system) ) {
- return LSM_ERR_INVALID_SYSTEM;
- }
-
- if( CHECK_RP(cap) || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_SYSTEM(system) || CHECK_RP(cap) ||
+ LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -954,11 +947,7 @@ int lsm_pool_create(lsm_connect *c, lsm_system *system,
{
CONN_SETUP(c);

- if( !LSM_IS_SYSTEM(system) ) {
- return LSM_ERR_INVALID_SYSTEM;
- }
-
- if( CHECK_STR(pool_name) || !size_bytes ||
+ if( !LSM_IS_SYSTEM(system) || CHECK_STR(pool_name) || !size_bytes ||
CHECK_RP(pool)|| CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ||
!valid_pool_raid_type(raid_type) ||
!valid_pool_member_type(member_type)) {
@@ -993,17 +982,12 @@ static int lsm_pool_create_from(lsm_connect *c,
{
CONN_SETUP(c);

- if( !LSM_IS_SYSTEM(system) ) {
- return LSM_ERR_INVALID_SYSTEM;
- }
-
- if( CHECK_STR(pool_name) ||
+ if( !LSM_IS_SYSTEM(system) || CHECK_STR(pool_name) ||
CHECK_RP(pool)|| CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ||
!valid_pool_raid_type(raid_type) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

-
std::map<std::string, Value> p;
p["system"] = system_to_value(system);
p["pool_name"] = Value(pool_name);
@@ -1055,15 +1039,7 @@ int LSM_DLL_EXPORT lsm_pool_create_from_disks(lsm_connect *c,
{
CONN_SETUP(c);

- if( !LSM_IS_SYSTEM(system) ) {
- return LSM_ERR_INVALID_SYSTEM;
- }
-
- if( !LSM_IS_POOL(pool) ) {
- return LSM_ERR_INVALID_POOL;
- }
-
- if( CHECK_STR(pool_name) ||
+ if( !LSM_IS_SYSTEM(system) || !LSM_IS_POOL(pool) || CHECK_STR(pool_name) ||
!size_bytes || CHECK_RP(created_pool)|| CHECK_RP(job) ||
LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
@@ -1093,7 +1069,7 @@ int lsm_pool_delete(lsm_connect *c, lsm_pool *pool, char **job, lsm_flag flags)
CONN_SETUP(c);

if( !LSM_IS_POOL(pool) ) {
- return LSM_ERR_INVALID_POOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if (CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -1136,7 +1112,7 @@ int lsm_volume_create(lsm_connect *c, lsm_pool *pool, const char *volumeName,
CONN_SETUP(c);

if( !LSM_IS_POOL(pool)) {
- return LSM_ERR_INVALID_POOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( CHECK_STR(volumeName) || !size || CHECK_RP(newVolume) ||
@@ -1168,12 +1144,8 @@ int lsm_volume_resize(lsm_connect *c, lsm_volume *volume,
{
CONN_SETUP(c);

- if( !LSM_IS_VOL(volume)) {
- return LSM_ERR_INVALID_VOL;
- }
-
- if( !newSize || CHECK_RP(resizedVolume) || CHECK_RP(job)
- || newSize == 0 || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_VOL(volume) || !newSize || CHECK_RP(resizedVolume) ||
+ CHECK_RP(job) || newSize == 0 || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1205,12 +1177,8 @@ int lsm_volume_replicate(lsm_connect *c, lsm_pool *pool,
{
CONN_SETUP(c);

- if( pool && !LSM_IS_POOL(pool) ) {
- return LSM_ERR_INVALID_POOL;
- }
-
- if( !LSM_IS_VOL(volumeSrc) ) {
- return LSM_ERR_INVALID_VOL;
+ if( pool && !LSM_IS_POOL(pool) || !LSM_IS_VOL(volumeSrc) ) {
+ return LSM_ERR_INVALID_ARGUMENT;
}

if(CHECK_STR(name) || CHECK_RP(newReplicant) || CHECK_RP(job) ||
@@ -1243,14 +1211,10 @@ int lsm_volume_replicate_range_block_size(lsm_connect *c, lsm_system *system,
int rc = LSM_ERR_OK;
CONN_SETUP(c);

- if( !bs || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !bs || LSM_FLAG_UNUSED_CHECK(flags) || !LSM_IS_SYSTEM(system) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

- if( !LSM_IS_SYSTEM(system) ) {
- return LSM_ERR_INVALID_SYSTEM;
- }
-
try {
std::map<std::string, Value> p;
p["system"] = system_to_value(system);
@@ -1283,7 +1247,7 @@ int lsm_volume_replicate_range(lsm_connect *c,
CONN_SETUP(c);

if( !LSM_IS_VOL(source) || !LSM_IS_VOL(dest) ) {
- return LSM_ERR_INVALID_VOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( !ranges || !num_ranges || CHECK_RP(job) ||
@@ -1312,7 +1276,7 @@ int lsm_volume_delete(lsm_connect *c, lsm_volume *volume, char **job,
CONN_SETUP(c);

if( !LSM_IS_VOL(volume) ) {
- return LSM_ERR_INVALID_VOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -1381,7 +1345,7 @@ static int online_offline(lsm_connect *c, lsm_volume *v,
CONN_SETUP(c);

if( !LSM_IS_VOL(v)) {
- return LSM_ERR_INVALID_VOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if ( LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -1442,12 +1406,8 @@ int lsm_access_group_create(lsm_connect *c, const char *name,
{
CONN_SETUP(c);

- if( !LSM_IS_SYSTEM(system) ) {
- return LSM_ERR_INVALID_SYSTEM;
- }
-
- if( CHECK_STR(name) || CHECK_STR(init_id) || CHECK_RP(access_group) ||
- LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_SYSTEM(system) || CHECK_STR(name) || CHECK_STR(init_id) ||
+ CHECK_RP(access_group) || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1478,11 +1438,7 @@ int lsm_access_group_delete(lsm_connect *c, lsm_access_group *access_group,
{
CONN_SETUP(c);

- if( !LSM_IS_ACCESS_GROUP(access_group) ){
- return LSM_ERR_INVALID_ACCESS_GROUP;
- }
-
- if( LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_ACCESS_GROUP(access_group) || LSM_FLAG_UNUSED_CHECK(flags) ){
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1505,12 +1461,8 @@ int lsm_access_group_initiator_add(lsm_connect *c,
{
CONN_SETUP(c);

- if( !LSM_IS_ACCESS_GROUP(access_group) ) {
- return LSM_ERR_INVALID_ACCESS_GROUP;
- }
-
- if( CHECK_STR(init_id) || LSM_FLAG_UNUSED_CHECK(flags) ||
- CHECK_RP(updated_access_group)) {
+ if( !LSM_IS_ACCESS_GROUP(access_group) || CHECK_STR(init_id) ||
+ LSM_FLAG_UNUSED_CHECK(flags) || CHECK_RP(updated_access_group)) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1542,12 +1494,8 @@ int lsm_access_group_initiator_delete(lsm_connect *c,
{
CONN_SETUP(c);

- if( !LSM_IS_ACCESS_GROUP(access_group)) {
- return LSM_ERR_INVALID_ACCESS_GROUP;
- }
-
- if( CHECK_STR(initiator_id) || LSM_FLAG_UNUSED_CHECK(flags) ||
- CHECK_RP(updated_access_group)) {
+ if( !LSM_IS_ACCESS_GROUP(access_group) || CHECK_STR(initiator_id) ||
+ LSM_FLAG_UNUSED_CHECK(flags) || CHECK_RP(updated_access_group)) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1576,15 +1524,8 @@ int lsm_volume_mask(lsm_connect *c, lsm_access_group *access_group,
{
CONN_SETUP(c);

- if( !LSM_IS_ACCESS_GROUP(access_group)) {
- return LSM_ERR_INVALID_ACCESS_GROUP;
- }
-
- if( !LSM_IS_VOL(volume) ) {
- return LSM_ERR_INVALID_VOL;
- }
-
- if( LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_ACCESS_GROUP(access_group) || !LSM_IS_VOL(volume) ||
+ LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1606,15 +1547,8 @@ int lsm_volume_unmask(lsm_connect *c, lsm_access_group *group,
{
CONN_SETUP(c);

- if( !LSM_IS_ACCESS_GROUP(group)) {
- return LSM_ERR_INVALID_ACCESS_GROUP;
- }
-
- if( !LSM_IS_VOL(volume)) {
- return LSM_ERR_INVALID_VOL;
- }
-
- if( LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_ACCESS_GROUP(group) || !LSM_IS_VOL(volume) ||
+ LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1637,11 +1571,8 @@ int lsm_volumes_accessible_by_access_group(lsm_connect *c,
int rc = LSM_ERR_OK;
CONN_SETUP(c);

- if( !LSM_IS_ACCESS_GROUP(group)) {
- return LSM_ERR_INVALID_ACCESS_GROUP;
- }
-
- if( !volumes || !count || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_ACCESS_GROUP(group) ||
+ !volumes || !count || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1687,7 +1618,7 @@ int lsm_access_groups_granted_to_volume(lsm_connect *c,
CONN_SETUP(c);

if( !LSM_IS_VOL(volume)) {
- return LSM_ERR_INVALID_VOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( !groups || !groupCount || LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -1712,7 +1643,7 @@ int lsm_volume_child_dependency(lsm_connect *c, lsm_volume *volume,
CONN_SETUP(c);

if( !LSM_IS_VOL(volume)) {
- return LSM_ERR_INVALID_VOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( !yes || LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -1752,11 +1683,7 @@ int lsm_volume_child_dependency_delete(lsm_connect *c, lsm_volume *volume,
{
CONN_SETUP(c);

- if( !LSM_IS_VOL(volume)) {
- return LSM_ERR_INVALID_VOL;
- }
-
- if( CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_VOL(volume) || CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1884,7 +1811,7 @@ int lsm_fs_create(lsm_connect *c, lsm_pool *pool, const char *name,
CONN_SETUP(c);

if( !LSM_IS_POOL(pool)) {
- return LSM_ERR_INVALID_POOL;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( CHECK_STR(name) || !size_bytes || CHECK_RP(fs) || CHECK_RP(job)
@@ -1913,11 +1840,7 @@ int lsm_fs_delete(lsm_connect *c, lsm_fs *fs, char **job, lsm_flag flags)
{
CONN_SETUP(c);

- if( !LSM_IS_FS(fs) ) {
- return LSM_ERR_INVALID_FS;
- }
-
- if( CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_FS(fs) || CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1939,11 +1862,8 @@ int lsm_fs_resize(lsm_connect *c, lsm_fs *fs,
{
CONN_SETUP(c);

- if( !LSM_IS_FS(fs)) {
- return LSM_ERR_INVALID_FS;
- }
-
- if( !new_size_bytes || CHECK_RP(rfs) || CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_FS(fs) || !new_size_bytes || CHECK_RP(rfs) || CHECK_RP(job) ||
+ LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -1970,11 +1890,8 @@ int lsm_fs_clone(lsm_connect *c, lsm_fs *src_fs,
{
CONN_SETUP(c);

- if( !LSM_IS_FS(src_fs)) {
- return LSM_ERR_INVALID_FS;
- }
-
- if( CHECK_STR(name) || CHECK_RP(cloned_fs) || CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_FS(src_fs) || CHECK_STR(name) || CHECK_RP(cloned_fs) ||
+ CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

@@ -2001,11 +1918,7 @@ int lsm_fs_file_clone(lsm_connect *c, lsm_fs *fs, const char *src_file_name,
{
CONN_SETUP(c);

- if( !LSM_IS_FS(fs)) {
- return LSM_ERR_INVALID_FS;
- }
-
- if( CHECK_STR(src_file_name) || CHECK_STR(dest_file_name)
+ if( !LSM_IS_FS(fs) || CHECK_STR(src_file_name) || CHECK_STR(dest_file_name)
|| CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}
@@ -2031,12 +1944,12 @@ int lsm_fs_child_dependency( lsm_connect *c, lsm_fs *fs, lsm_string_list *files,
CONN_SETUP(c);

if( !LSM_IS_FS(fs) ) {
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( files ) {
if( !LSM_IS_STRING_LIST(files) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

@@ -2079,12 +1992,12 @@ int lsm_fs_child_dependency_delete( lsm_connect *c, lsm_fs *fs, lsm_string_list
CONN_SETUP(c);

if( !LSM_IS_FS(fs)) {
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( files ) {
if( !LSM_IS_STRING_LIST(files) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

@@ -2111,7 +2024,7 @@ int lsm_fs_ss_list(lsm_connect *c, lsm_fs *fs, lsm_fs_ss **ss[],
CONN_SETUP(c);

if( !LSM_IS_FS(fs) ) {
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( CHECK_RP(ss) || !ssCount ) {
@@ -2163,7 +2076,7 @@ int lsm_fs_ss_create(lsm_connect *c, lsm_fs *fs, const char *name, lsm_fs_ss **s
CONN_SETUP(c);

if( !LSM_IS_FS(fs)) {
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( CHECK_STR(name) || CHECK_RP(snapshot) || CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -2192,11 +2105,11 @@ int lsm_fs_ss_delete(lsm_connect *c, lsm_fs *fs, lsm_fs_ss *ss, char **job,
CONN_SETUP(c);

if( !LSM_IS_FS(fs) ) {
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( !LSM_IS_SS(ss) ) {
- return LSM_ERR_INVALID_SS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( CHECK_RP(job) || LSM_FLAG_UNUSED_CHECK(flags) ) {
@@ -2223,22 +2136,22 @@ int lsm_fs_ss_restore(lsm_connect *c, lsm_fs *fs, lsm_fs_ss *ss,
CONN_SETUP(c);

if( !LSM_IS_FS(fs) ) {
- return LSM_ERR_INVALID_FS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( !LSM_IS_SS(ss) ) {
- return LSM_ERR_INVALID_SS;
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( files ) {
if( !LSM_IS_STRING_LIST(files) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

if( restore_files ) {
if( !LSM_IS_STRING_LIST(restore_files) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

@@ -2335,19 +2248,19 @@ int lsm_nfs_export_fs( lsm_connect *c,

if( root_list ) {
if( !LSM_IS_STRING_LIST(root_list) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

if( rw_list ) {
if( !LSM_IS_STRING_LIST(rw_list) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

if( ro_list ) {
if( !LSM_IS_STRING_LIST(ro_list) ) {
- return LSM_ERR_INVALID_SL;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

@@ -2383,11 +2296,7 @@ int lsm_nfs_export_delete( lsm_connect *c, lsm_nfs_export *e, lsm_flag flags)
{
CONN_SETUP(c);

- if( !LSM_IS_NFS_EXPORT(e) ) {
- return LSM_ERR_INVALID_NFS;
- }
-
- if( LSM_FLAG_UNUSED_CHECK(flags) ) {
+ if( !LSM_IS_NFS_EXPORT(e) || LSM_FLAG_UNUSED_CHECK(flags) ) {
return LSM_ERR_INVALID_ARGUMENT;
}

diff --git a/c_binding/lsm_plugin_ipc.cpp b/c_binding/lsm_plugin_ipc.cpp
index 68cbf44..b174d09 100644
--- a/c_binding/lsm_plugin_ipc.cpp
+++ b/c_binding/lsm_plugin_ipc.cpp
@@ -110,7 +110,7 @@ int lsm_register_plugin_v1(lsm_plugin_ptr plug,
struct lsm_san_ops_v1 *san_op, struct lsm_fs_ops_v1 *fs_op,
struct lsm_nas_ops_v1 *nas_op)
{
- int rc = LSM_ERR_INVALID_PLUGIN;
+ int rc = LSM_ERR_INVALID_ARGUMENT;

if(LSM_IS_PLUGIN(plug)) {
plug->private_data = private_data;
@@ -402,7 +402,7 @@ static int handle_job_status( lsm_plugin_ptr p, Value &params, Value &response)
result.push_back(pool_to_value((lsm_pool *)value));
lsm_pool_record_free((lsm_pool *)value);
} else {
- rc = LSM_ERR_PLUGIN_ERROR;
+ rc = LSM_ERR_PLUGIN_BUG;
}
}
response = Value(result);
@@ -2382,7 +2382,7 @@ static int lsm_plugin_run(lsm_plugin_ptr p)
lsm_plugin_free(p, flags);
p = NULL;
} else {
- rc = LSM_ERR_INVALID_PLUGIN;
+ rc = LSM_ERR_INVALID_ARGUMENT;
}

return rc;
@@ -2391,7 +2391,7 @@ static int lsm_plugin_run(lsm_plugin_ptr p)
int lsm_log_error_basic( lsm_plugin_ptr plug, lsm_error_number code, const char* msg )
{
if( !LSM_IS_PLUGIN(plug) ) {
- return LSM_ERR_INVALID_PLUGIN;
+ return LSM_ERR_INVALID_ARGUMENT;
}

lsm_error_ptr e = LSM_ERROR_CREATE_PLUGIN_MSG(code, msg);
@@ -2409,12 +2409,8 @@ int lsm_log_error_basic( lsm_plugin_ptr plug, lsm_error_number code, const char*

int lsm_plugin_error_log( lsm_plugin_ptr plug, lsm_error_ptr error)
{
- if( !LSM_IS_PLUGIN(plug) ) {
- return LSM_ERR_INVALID_PLUGIN;
- }
-
- if(!LSM_IS_ERROR(error) ) {
- return LSM_ERR_INVALID_ERR;
+ if( !LSM_IS_PLUGIN(plug) || !LSM_IS_ERROR(error) ) {
+ return LSM_ERR_INVALID_ARGUMENT;
}

if( plug->error ) {
@@ -2442,7 +2438,7 @@ int LSM_DLL_EXPORT lsm_uri_parse(const char *uri, char **scheme, char **user,
char **server, int *port, char **path,
lsm_hash **query_params)
{
- int rc = LSM_ERR_INVALID_URI;
+ int rc = LSM_ERR_INVALID_ARGUMENT;
xmlURIPtr u = NULL;

if( uri && strlen(uri) > 0 ) {
diff --git a/plugin/nstor/nstor.py b/plugin/nstor/nstor.py
index c29c712..b47b8b6 100644
--- a/plugin/nstor/nstor.py
+++ b/plugin/nstor/nstor.py
@@ -44,7 +44,7 @@ def handle_nstor_errors(method):
raise
except Exception as e:
error("Unexpected exception:\n" + traceback.format_exc())
- raise LsmError(ErrorNumber.PLUGIN_ERROR, str(e),
+ raise LsmError(ErrorNumber.PLUGIN_BUG, str(e),
traceback.format_exc())
return nstor_wrapper

@@ -83,7 +83,7 @@ class NexentaStor(INfs, IStorageAreaNetwork):
resp_json = response.read()
resp = json.loads(resp_json)
if resp['error']:
- raise LsmError(ErrorNumber.PLUGIN_ERROR, resp['error'])
+ raise LsmError(ErrorNumber.PLUGIN_BUG, resp['error'])
return resp['result']

def _request(self, method, obj, params):
@@ -297,7 +297,7 @@ class NexentaStor(INfs, IStorageAreaNetwork):

@handle_nstor_errors
def fs_resize(self, fs, new_size_bytes, flags=0):
- raise LsmError(ErrorNumber.NOT_IMPLEMENTED, "Not implemented")
+ raise LsmError(ErrorNumber.NO_SUPPORT, "Not implemented")

@staticmethod
def _get_pool_id(fs_name):
@@ -563,7 +563,7 @@ class NexentaStor(INfs, IStorageAreaNetwork):
Note: Tuple return values are mutually exclusive, when one
is None the other must be valid.
"""
- raise LsmError(ErrorNumber.NOT_IMPLEMENTED,
+ raise LsmError(ErrorNumber.NO_SUPPORT,
"volume_replicate not implemented")

# if rep_type == Volume.REPLICATE_SNAPSHOT:
diff --git a/plugin/ontap/na.py b/plugin/ontap/na.py
index cd015a5..3890361 100644
--- a/plugin/ontap/na.py
+++ b/plugin/ontap/na.py
@@ -420,7 +420,7 @@ class Filer(object):
params['destination-path'] = dest_path

if backing_snapshot:
- raise FilerError(ErrorNumber.NOT_IMPLEMENTED,
+ raise FilerError(ErrorNumber.NO_SUPPORT,
"Support for backing luns not implemented "
"for this API version")
#params['snapshot-name']= backing_snapshot
@@ -460,7 +460,7 @@ class Filer(object):
elif progress['clone-state'] == 'completed':
return
else:
- raise FilerError(ErrorNumber.NOT_IMPLEMENTED,
+ raise FilerError(ErrorNumber.NO_SUPPORT,
'Unexpected state=' +
progress['clone-state'])
else:
diff --git a/plugin/ontap/ontap.py b/plugin/ontap/ontap.py
index 6cf7ec0..067fc3f 100644
--- a/plugin/ontap/ontap.py
+++ b/plugin/ontap/ontap.py
@@ -32,21 +32,21 @@ from lsm import (Volume, FileSystem, FsSnapshot, NfsExport,

#Maps na to lsm, this is expected to expand over time.
e_map = {
- na.Filer.ENOSPC: ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ na.Filer.ENOSPC: ErrorNumber.NOT_ENOUGH_SPACE,
na.Filer.ENO_SUCH_VOLUME: ErrorNumber.NOT_FOUND_VOLUME,
- na.Filer.ESIZE_TOO_LARGE: ErrorNumber.SIZE_TOO_LARGE,
+ na.Filer.ESIZE_TOO_LARGE: ErrorNumber.NOT_ENOUGH_SPACE,
na.Filer.ENO_SUCH_FS: ErrorNumber.NOT_FOUND_FS,
na.Filer.EVOLUME_TOO_SMALL: ErrorNumber.SIZE_TOO_SMALL,
na.Filer.EAPILICENSE: ErrorNumber.NOT_LICENSED,
na.Filer.EFSDOESNOTEXIST: ErrorNumber.NOT_FOUND_FS,
- na.Filer.EFSOFFLINE: ErrorNumber.OFF_LINE,
- na.Filer.EFSNAMEINVALID: ErrorNumber.INVALID_NAME,
+ na.Filer.EFSOFFLINE: ErrorNumber.NO_SUPPORT_ONLINE_CHANGE,
+ na.Filer.EFSNAMEINVALID: ErrorNumber.INVALID_ARGUMENT,
na.Filer.ESERVICENOTLICENSED: ErrorNumber.NOT_LICENSED,
na.Filer.ECLONE_LICENSE_EXPIRED: ErrorNumber.NOT_LICENSED,
na.Filer.ECLONE_NOT_LICENSED: ErrorNumber.NOT_LICENSED,
- na.Filer.EINVALID_ISCSI_NAME: ErrorNumber.INVALID_INIT,
- na.Filer.ETIMEOUT: ErrorNumber.PLUGIN_TIMEOUT,
- na.Filer.EUNKNOWN: ErrorNumber.PLUGIN_ERROR
+ na.Filer.EINVALID_ISCSI_NAME: ErrorNumber.INVALID_ARGUMENT,
+ na.Filer.ETIMEOUT: ErrorNumber.TIMEOUT,
+ na.Filer.EUNKNOWN: ErrorNumber.PLUGIN_BUG
}


@@ -58,7 +58,7 @@ def error_map(oe):
if oe.errno in e_map:
return e_map[oe.errno], oe.reason
else:
- return ErrorNumber.PLUGIN_ERROR, \
+ return ErrorNumber.PLUGIN_BUG, \
oe.reason + " (vendor error code= " + str(oe.errno) + ")"


@@ -519,7 +519,7 @@ class Ontap(IStorageAreaNetwork, INfs):
def volume_create(self, pool, volume_name, size_bytes, provisioning,
flags=0):
if provisioning != Volume.PROVISION_DEFAULT:
- raise LsmError(ErrorNumber.UNSUPPORTED_PROVISIONING,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"Unsupported provisioning")
na_aggrs = self.f.aggregates()
na_aggr_names = [x['name'] for x in na_aggrs]
@@ -732,7 +732,7 @@ class Ontap(IStorageAreaNetwork, INfs):
if g.name == name:
return g

- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.NOT_FOUND_ACCESS_GROUP,
"access_group_create(): Unable to find access group "
"%s just created!" % name)

@@ -756,7 +756,7 @@ class Ontap(IStorageAreaNetwork, INfs):
raise
na_ags = self.f.igroups(access_group.name)
if len(na_ags) != 1:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"access_group_initiator_add(): Got unexpected"
"(not 1) count of na_ag: %s" % na_ags)

@@ -778,7 +778,7 @@ class Ontap(IStorageAreaNetwork, INfs):
raise
na_ags = self.f.igroups(access_group.name)
if len(na_ags) != 1:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"access_group_initiator_add(): Got unexpected"
"(not 1) count of na_ag: %s" % na_ags)

@@ -848,7 +848,7 @@ class Ontap(IStorageAreaNetwork, INfs):
@handle_ontap_errors
def job_status(self, job_id, flags=0):
if job_id is None and '@' not in job_id:
- raise LsmError(ErrorNumber.INVALID_JOB, "Invalid job, missing @")
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT, "Invalid job, missing @")

job = job_id.split('@', 2)

@@ -857,7 +857,7 @@ class Ontap(IStorageAreaNetwork, INfs):
elif job[0] == Ontap.SPLIT_JOB:
return self._clone_split_status(job[1])

- raise LsmError(ErrorNumber.INVALID_JOB, "Invalid job")
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT, "Invalid job")

@handle_ontap_errors
def job_free(self, job_id, flags=0):
@@ -1073,7 +1073,7 @@ class Ontap(IStorageAreaNetwork, INfs):
if e.fs_id == fs_id and e.export_path == export_path:
return e

- raise LsmError(ErrorNumber.PLUGIN_ERROR,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"export not created successfully!")

@handle_ontap_errors
diff --git a/plugin/sim/simarray.py b/plugin/sim/simarray.py
index d59a1b1..c81c851 100644
--- a/plugin/sim/simarray.py
+++ b/plugin/sim/simarray.py
@@ -759,7 +759,7 @@ class SimData(object):
member_sizes.extend([pool_each_size])

else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Got unsupported member_type in _size_of_raid()" +
": %d" % member_type)
all_size = 0
@@ -805,7 +805,7 @@ class SimData(object):
print "%s" % size_bytes_2_size_human(all_size)
print "%s" % size_bytes_2_size_human(member_size)
return int(all_size / 2 - member_size * 2)
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_size_of_raid() got invalid raid type: " +
"%s(%d)" % (Pool.raid_type_to_str(raid_type),
raid_type))
@@ -881,7 +881,7 @@ class SimData(object):
# check free size
free_space = self.pool_free_space(pool_id)
if (free_space < size_bytes):
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Insufficient space in pool")
sim_vol = dict()
sim_vol['vol_id'] = self._next_vol_id()
@@ -899,7 +899,7 @@ class SimData(object):
if vol_id in self.vol_dict.keys():
del(self.vol_dict[vol_id])
return
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such volume: %s" % vol_id)

def volume_resize(self, vol_id, new_size_bytes, flags=0):
@@ -908,26 +908,26 @@ class SimData(object):
pool_id = self.vol_dict[vol_id]['pool_id']
free_space = self.pool_free_space(pool_id)
if (free_space < new_size_bytes):
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Insufficient space in pool")

self.vol_dict[vol_id]['total_space'] = new_size_bytes
self.vol_dict[vol_id]['consume_size'] = new_size_bytes
return self.vol_dict[vol_id]
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"No such volume: %s" % vol_id)

def volume_replicate(self, dst_pool_id, rep_type, src_vol_id, new_vol_name,
flags=0):
if src_vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such volume: %s" % src_vol_id)
size_bytes = self.vol_dict[src_vol_id]['total_space']
size_bytes = SimData._block_rounding(size_bytes)
# check free size
free_space = self.pool_free_space(dst_pool_id)
if (free_space < size_bytes):
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Insufficient space in pool")
sim_vol = dict()
sim_vol['vol_id'] = self._next_vol_id()
@@ -963,11 +963,11 @@ class SimData(object):
def volume_replicate_range(self, rep_type, src_vol_id, dst_vol_id, ranges,
flags=0):
if src_vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % src_vol_id)

if dst_vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % dst_vol_id)

sim_reps = []
@@ -992,7 +992,7 @@ class SimData(object):

def volume_online(self, vol_id, flags=0):
if vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % vol_id)
# TODO: Volume.STATUS_XXX does have indication about volume offline
# or online, meanwhile, cmdline does not support volume_online()
@@ -1001,7 +1001,7 @@ class SimData(object):

def volume_offline(self, vol_id, flags=0):
if vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % vol_id)
# TODO: Volume.STATUS_XXX does have indication about volume offline
# or online, meanwhile, cmdline does not support volume_online()
@@ -1013,7 +1013,7 @@ class SimData(object):
If volume is a src or dst of a replication, we return True.
"""
if vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % vol_id)
if 'replicate' in self.vol_dict[vol_id].keys() and \
self.vol_dict[vol_id]['replicate']:
@@ -1026,7 +1026,7 @@ class SimData(object):

def volume_child_dependency_rm(self, vol_id, flags=0):
if vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % vol_id)
if 'replicate' in self.vol_dict[vol_id].keys() and \
self.vol_dict[vol_id]['replicate']:
@@ -1131,7 +1131,7 @@ class SimData(object):
raise LsmError(ErrorNumber.NOT_FOUND_ACCESS_GROUP,
"Access group not found: %s" % ag_id)
if vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % vol_id)
if 'mask' not in self.vol_dict[vol_id].keys():
self.vol_dict[vol_id]['mask'] = dict()
@@ -1144,7 +1144,7 @@ class SimData(object):
raise LsmError(ErrorNumber.NOT_FOUND_ACCESS_GROUP,
"Access group not found: %s" % ag_id)
if vol_id not in self.vol_dict.keys():
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_VOLUME,
"No such Volume: %s" % vol_id)
if 'mask' not in self.vol_dict[vol_id].keys():
return None
@@ -1198,7 +1198,7 @@ class SimData(object):
# check free size
free_space = self.pool_free_space(pool_id)
if (free_space < size_bytes):
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Insufficient space in pool")
sim_fs = dict()
fs_id = self._next_fs_id()
@@ -1216,7 +1216,7 @@ class SimData(object):
if fs_id in self.fs_dict.keys():
del(self.fs_dict[fs_id])
return
- raise LsmError(ErrorNumber.INVALID_FS,
+ raise LsmError(ErrorNumber.NOT_FOUND_FS,
"No such File System: %s" % fs_id)

def fs_resize(self, fs_id, new_size_bytes, flags=0):
@@ -1225,14 +1225,14 @@ class SimData(object):
pool_id = self.fs_dict[fs_id]['pool_id']
free_space = self.pool_free_space(pool_id)
if (free_space < new_size_bytes):
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Insufficient space in pool")

self.fs_dict[fs_id]['total_space'] = new_size_bytes
self.fs_dict[fs_id]['free_space'] = new_size_bytes
self.fs_dict[fs_id]['consume_size'] = new_size_bytes
return self.fs_dict[fs_id]
- raise LsmError(ErrorNumber.INVALID_VOLUME,
+ raise LsmError(ErrorNumber.NOT_FOUND_FS,
"No such File System: %s" % fs_id)

def fs_clone(self, src_fs_id, dst_fs_name, snap_id, flags=0):
@@ -1240,7 +1240,7 @@ class SimData(object):
raise LsmError(ErrorNumber.NOT_FOUND_FS,
"File System: %s not found" % src_fs_id)
if snap_id and snap_id not in self.snap_dict.keys():
- raise LsmError(ErrorNumber.INVALID_SS,
+ raise LsmError(ErrorNumber.NOT_FOUND_FS_SS,
"No such Snapshot: %s" % snap_id)
src_sim_fs = self.fs_dict[src_fs_id]
dst_sim_fs = self.fs_create(
@@ -1257,7 +1257,7 @@ class SimData(object):
raise LsmError(ErrorNumber.NOT_FOUND_FS,
"File System: %s not found" % fs_id)
if snap_id and snap_id not in self.snap_dict.keys():
- raise LsmError(ErrorNumber.INVALID_SS,
+ raise LsmError(ErrorNumber.NOT_FOUND_FS_SS,
"No such Snapshot: %s" % snap_id)
# TODO: No file clone query API yet, no need to do anything internally
return None
@@ -1295,7 +1295,7 @@ class SimData(object):
raise LsmError(ErrorNumber.NOT_FOUND_FS,
"File System: %s not found" % fs_id)
if snap_id not in self.snap_dict.keys():
- raise LsmError(ErrorNumber.INVALID_SS,
+ raise LsmError(ErrorNumber.NOT_FOUND_FS_SS,
"No such Snapshot: %s" % snap_id)
del self.snap_dict[snap_id]
new_snap_ids = []
@@ -1311,7 +1311,7 @@ class SimData(object):
raise LsmError(ErrorNumber.NOT_FOUND_FS,
"File System: %s not found" % fs_id)
if snap_id not in self.snap_dict.keys():
- raise LsmError(ErrorNumber.INVALID_SS,
+ raise LsmError(ErrorNumber.NOT_FOUND_FS_SS,
"No such Snapshot: %s" % snap_id)
# Nothing need to done internally for restore.
return None
@@ -1407,7 +1407,7 @@ class SimData(object):

def fs_unexport(self, exp_id, flags=0):
if exp_id not in self.exp_dict.keys():
- raise LsmError(ErrorNumber.INVALID_NFS,
+ raise LsmError(ErrorNumber.NOT_FOUND_NFS_EXPORT,
"No such NFS Export: %s" % exp_id)
del self.exp_dict[exp_id]
return None
@@ -1487,7 +1487,7 @@ class SimData(object):
# 4. All disks' total space is the same.
if len(member_ids) <= 0:
if raise_error:
- raise LsmError(ErrorNumber.INVALID_DISK,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"No disk ID defined")
else:
return None
@@ -1507,7 +1507,7 @@ class SimData(object):
for disk_id in member_ids:
if disk_id not in self.disk_dict.keys():
if raise_error:
- raise LsmError(ErrorNumber.INVALID_DISK,
+ raise LsmError(ErrorNumber.NOT_FOUND_DISK,
"The disk ID %s does not exist" % disk_id)
else:
return None
@@ -1586,7 +1586,7 @@ class SimData(object):
return newly create sim_pool or None.
"""
if sys_id != SimData.SIM_DATA_SYS_ID:
- raise LsmError(ErrorNumber.INVALID_SYSTEM,
+ raise LsmError(ErrorNumber.NOT_FOUND_SYSTEM,
"No such system: %s" % sys_id)

return self._pool_create_from_disks(pool_name, member_ids, raid_type,
@@ -1601,7 +1601,7 @@ class SimData(object):
if len(free_sim_pool_ids) == 0 or \
member_id not in free_sim_pool_ids:
if raise_error:
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Pool %s " % member_id +
"is full, no space to create new pool")
else:
@@ -1609,7 +1609,7 @@ class SimData(object):

free_size = self.pool_free_space(member_id)
if free_size < size_bytes:
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"Pool %s does not have requested free" %
member_id + "to create new pool")

@@ -1633,7 +1633,7 @@ class SimData(object):
def pool_create_from_pool(self, sys_id, pool_name, member_id, size_bytes,
flags=0):
if sys_id != SimData.SIM_DATA_SYS_ID:
- raise LsmError(ErrorNumber.INVALID_SYSTEM,
+ raise LsmError(ErrorNumber.NOT_FOUND_SYSTEM,
"No such system: %s" % sys_id)
return self._pool_create_from_pool(pool_name, member_id, size_bytes,
raise_error=True)
@@ -1664,7 +1664,7 @@ class SimData(object):
if sim_disk['total_space'] >= size_bytes:
return [sim_disk]
if raise_error:
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"No %s is bigger than " % disk_type_str +
"expected size: %s(%d)" %
(size_bytes_2_size_human(size_bytes),
@@ -1690,7 +1690,7 @@ class SimData(object):
if all_free_size >= size_bytes:
return chose_sim_disks
if raise_error:
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"No enough %s to provide size %s(%d)" %
(disk_type_str,
size_bytes_2_size_human(size_bytes),
@@ -1716,7 +1716,7 @@ class SimData(object):
return cur_sim_disks[0:member_count]

if raise_error:
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"No enough %s " % disk_type_str +
"to create %s providing size: %s(%d)" %
(Pool.raid_type_to_str(raid_type),
@@ -1739,7 +1739,7 @@ class SimData(object):
return sim_pool

if raise_error:
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"No pool is bigger than expected size: " +
"%s(%d)" %
(size_bytes_2_size_human(size_bytes),
@@ -1751,7 +1751,7 @@ class SimData(object):
raid_type=Pool.RAID_TYPE_UNKNOWN,
member_type=Pool.MEMBER_TYPE_UNKNOWN, flags=0):
if sys_id != SimData.SIM_DATA_SYS_ID:
- raise LsmError(ErrorNumber.INVALID_SYSTEM,
+ raise LsmError(ErrorNumber.NOT_FOUND_SYSTEM,
"No such system: %s" % sys_id)

size_bytes = SimData._block_rounding(size_bytes)
@@ -1806,12 +1806,12 @@ class SimData(object):
return sim_pool

# only member_type == Pool.MEMBER_TYPE_UNKNOWN can reach here.
- raise LsmError(ErrorNumber.SIZE_INSUFFICIENT_SPACE,
+ raise LsmError(ErrorNumber.NOT_ENOUGH_SPACE,
"No enough free spaces to create new pool")

def pool_delete(self, pool_id, flags=0):
if pool_id not in self.pool_dict.keys():
- raise LsmError(ErrorNumber.INVALID_POOL,
+ raise LsmError(ErrorNumber.NOT_FOUND_POOL,
"Pool not found: %s" % pool_id)

volumes = self.volumes()
diff --git a/plugin/simc/simc_lsmplugin.c b/plugin/simc/simc_lsmplugin.c
index 496b8ed..cb2b7dd 100644
--- a/plugin/simc/simc_lsmplugin.c
+++ b/plugin/simc/simc_lsmplugin.c
@@ -313,7 +313,7 @@ static int tmo_set(lsm_plugin_ptr c, uint32_t timeout, lsm_flag flags )
pd->tmo = timeout;
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_PLUGIN;
+ return LSM_ERR_INVALID_ARGUMENT;
}

static int tmo_get(lsm_plugin_ptr c, uint32_t *timeout, lsm_flag flags)
@@ -324,7 +324,7 @@ static int tmo_get(lsm_plugin_ptr c, uint32_t *timeout, lsm_flag flags)
*timeout = pd->tmo;
return LSM_ERR_OK;
}
- return LSM_ERR_INVALID_PLUGIN;
+ return LSM_ERR_INVALID_ARGUMENT;
}

static int cap(lsm_plugin_ptr c, lsm_system *system,
@@ -419,7 +419,7 @@ static int job_status(lsm_plugin_ptr c, const char *job_id,
rc = LSM_ERR_NOT_FOUND_JOB;
}
} else {
- rc = LSM_ERR_INVALID_PLUGIN;
+ rc = LSM_ERR_INVALID_ARGUMENT;
}

return rc;
@@ -484,7 +484,7 @@ static int list_systems(lsm_plugin_ptr c, lsm_system **systems[],
}
return LSM_ERR_NO_MEMORY;
} else {
- return LSM_ERR_INVALID_PLUGIN;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

@@ -498,7 +498,7 @@ static int job_free(lsm_plugin_ptr c, char *job_id, lsm_flag flags)
rc = LSM_ERR_NOT_FOUND_JOB;
}
} else {
- rc = LSM_ERR_INVALID_PLUGIN;
+ rc = LSM_ERR_INVALID_ARGUMENT;
}

return rc;
@@ -776,7 +776,7 @@ static int volume_create(lsm_plugin_ptr c, lsm_pool *pool,
}

} else {
- rc = lsm_log_error_basic(c, LSM_ERR_SIZE_INSUFFICIENT_SPACE,
+ rc = lsm_log_error_basic(c, LSM_ERR_NOT_ENOUGH_SPACE,
"Insufficient space in pool");
}

@@ -892,7 +892,7 @@ static int volume_resize(lsm_plugin_ptr c, lsm_volume *volume,
} else {
/*Could not accommodate re-sized, go back */
pool_allocate(p, curr_size);
- rc = lsm_log_error_basic(c, LSM_ERR_SIZE_INSUFFICIENT_SPACE,
+ rc = lsm_log_error_basic(c, LSM_ERR_NOT_ENOUGH_SPACE,
"Insufficient space in pool");
}

@@ -1262,7 +1262,7 @@ static int access_group_initiator_delete( lsm_plugin_ptr c,
lsm_access_group **updated_access_group,
lsm_flag flags)
{
- int rc = LSM_ERR_INITIATOR_NOT_IN_ACCESS_GROUP;
+ int rc = LSM_ERR_INVALID_ARGUMENT;
struct plugin_data *pd = (struct plugin_data*)lsm_private_data_get(c);

struct allocated_ag *find = (struct allocated_ag *)
@@ -1681,7 +1681,7 @@ static int fs_create(lsm_plugin_ptr c, lsm_pool *pool, const char *name,
rc = lsm_log_error_basic(c, LSM_ERR_NO_MEMORY, "ENOMEM");
}
} else {
- rc = lsm_log_error_basic(c, LSM_ERR_SIZE_INSUFFICIENT_SPACE,
+ rc = lsm_log_error_basic(c, LSM_ERR_NOT_ENOUGH_SPACE,
"Insufficient space in pool");
}
} else {
@@ -1756,7 +1756,7 @@ static int fs_resize(lsm_plugin_ptr c, lsm_fs *fs,
} else {
/*Could not accommodate re-sized, go back */
pool_allocate(p, lsm_fs_total_space_get(tfs));
- rc = lsm_log_error_basic(c, LSM_ERR_SIZE_INSUFFICIENT_SPACE,
+ rc = lsm_log_error_basic(c, LSM_ERR_NOT_ENOUGH_SPACE,
"Insufficient space in pool");
}

@@ -1931,7 +1931,7 @@ static int ss_delete(lsm_plugin_ptr c, lsm_fs *fs, lsm_fs_ss *ss,

if( find ) {
if( !g_hash_table_remove(find->ss, lsm_fs_ss_id_get(ss)) ) {
- rc = lsm_log_error_basic(c, LSM_ERR_NOT_FOUND_SS,
+ rc = lsm_log_error_basic(c, LSM_ERR_NOT_FOUND_FS_SS,
"snapshot not found");
} else {
rc = create_job(pd, job, LSM_DATA_TYPE_NONE, NULL, NULL);
@@ -1955,7 +1955,7 @@ static int ss_restore(lsm_plugin_ptr c, lsm_fs *fs, lsm_fs_ss *ss,

if( find ) {
if(!g_hash_table_lookup(find->ss, lsm_fs_ss_id_get(ss))) {
- rc = lsm_log_error_basic(c, LSM_ERR_NOT_FOUND_SS,
+ rc = lsm_log_error_basic(c, LSM_ERR_NOT_FOUND_FS_SS,
"snapshot not found");
} else {
rc = create_job(pd, job, LSM_DATA_TYPE_NONE, NULL, NULL);
@@ -2327,7 +2327,7 @@ int unload( lsm_plugin_ptr c, lsm_flag flags)
_unload(pd);
return LSM_ERR_OK;
} else {
- return LSM_ERR_INVALID_PLUGIN;
+ return LSM_ERR_INVALID_ARGUMENT;
}
}

diff --git a/plugin/smispy/smis.py b/plugin/smispy/smis.py
index 024a613..368b606 100644
--- a/plugin/smispy/smis.py
+++ b/plugin/smispy/smis.py
@@ -99,14 +99,14 @@ def handle_cim_errors(method):
elif 'HTTP error' in desc:
raise LsmError(ErrorNumber.TRANSPORT_COMMUNICATION,
desc)
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG, desc)
+ raise LsmError(ErrorNumber.PLUGIN_BUG, desc)
except pywbem.cim_http.AuthError as ae:
raise LsmError(ErrorNumber.PLUGIN_AUTH_FAILED, "Unauthorized user")
except pywbem.cim_http.Error as te:
raise LsmError(ErrorNumber.NETWORK_ERROR, str(te))
except Exception as e:
error("Unexpected exception:\n" + traceback.format_exc())
- raise LsmError(ErrorNumber.PLUGIN_ERROR, str(e),
+ raise LsmError(ErrorNumber.PLUGIN_BUG, str(e),
traceback.format_exc())
return cim_wrapper

@@ -608,7 +608,7 @@ class Smis(IStorageAreaNetwork):
return cim_xxx

if raise_error:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Unable to find class instance %s " % class_name +
"with property %s " % prop_name +
"with value %s" % prop_value)
@@ -655,11 +655,11 @@ class Smis(IStorageAreaNetwork):

except Exception:
tb = traceback.format_exc()
- raise LsmError(ErrorNumber.PLUGIN_ERROR,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
'Error: ' + msg + " rc= " + str(rc) +
' Debug data exception: ' + str(tb))

- raise LsmError(ErrorNumber.PLUGIN_ERROR,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
'Error: ' + msg + " rc= " + str(rc))

@handle_cim_errors
@@ -1185,7 +1185,7 @@ class Smis(IStorageAreaNetwork):
status = JobStatus.ERROR

else:
- raise LsmError(ErrorNumber.PLUGIN_ERROR,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
str(cim_job['ErrorDescription']))

return status, percent_complete, completed_item
@@ -1206,7 +1206,7 @@ class Smis(IStorageAreaNetwork):
return 'CIM_SCSIProtocolController'
if class_type == 'Initiator':
return 'CIM_StorageHardwareID'
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Smis._cim_class_name_of() got unknown " +
"class_type %s" % class_type)

@@ -1226,7 +1226,7 @@ class Smis(IStorageAreaNetwork):
return ErrorNumber.NOT_FOUND_ACCESS_GROUP
if class_type == 'Initiator':
return ErrorNumber.INVALID_ARGUMENT
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Smis._cim_class_name_of() got unknown " +
"class_type %s" % class_type)

@@ -1251,7 +1251,7 @@ class Smis(IStorageAreaNetwork):
elif class_type == 'Initiator':
rc = ['StorageID']
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Smis._property_list_of_id() got unknown " +
"class_type %s" % class_type)

@@ -1571,7 +1571,7 @@ class Smis(IStorageAreaNetwork):
PropertyList=pool_pros, LocalOnly=False)
return self._new_pool(cim_new_pool)
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Got not new Pool from out of InvokeMethod" +
"when CreateOrModifyElementFromStoragePool")

@@ -1773,7 +1773,7 @@ class Smis(IStorageAreaNetwork):
if pool:
rc.extend([pool])
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Failed to retrieve pool information " +
"from CIM_StoragePool: %s" % cim_pool.path)
return search_property(rc, search_key, search_value)
@@ -1873,7 +1873,7 @@ class Smis(IStorageAreaNetwork):
Create a volume.
"""
if provisioning != Volume.PROVISION_DEFAULT:
- raise LsmError(ErrorNumber.UNSUPPORTED_PROVISIONING,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"Unsupported provisioning")

# Get the Configuration service for the system we are interested in.
@@ -1903,7 +1903,7 @@ class Smis(IStorageAreaNetwork):
return i
else:
raise LsmError(
- ErrorNumber.PLUGIN_ERROR,
+ ErrorNumber.PLUGIN_BUG,
msg + ", job error code= " + str(s))

def _detach(self, vol, sync):
@@ -2162,7 +2162,7 @@ class Smis(IStorageAreaNetwork):
elif len(cim_srvs) == 0:
return None
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_get_cim_service_path(): Got unexpected(not 1) "
"count of %s from cim_sys %s: %s" %
(class_name, cim_sys_path, cim_srvs))
@@ -2606,7 +2606,7 @@ class Smis(IStorageAreaNetwork):
raise LsmError(ErrorNumber.NO_SUPPORT,
'AccessGroup is not supported by this array')
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Got %d instance of " % len(cim_ccss_path) +
"ControllerConfigurationService from %s" %
cim_sys_path + " in _cim_spc_of()")
@@ -2885,7 +2885,7 @@ class Smis(IStorageAreaNetwork):
list(self._cim_spc_to_lsm(cim_spc, system_id)
for cim_spc in cim_spcs))
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_get_cim_spc_by_id(): Got invalid mask_type: "
"%s" % mask_type)

@@ -3086,7 +3086,7 @@ class Smis(IStorageAreaNetwork):
cim_spc_path,
AssocClass='CIM_ProtocolControllerForUnit',
ResultClass='CIM_StorageVolume')) >= 1:
- raise LsmError(ErrorNumber.ACCESS_GROUP_BUSY,
+ raise LsmError(ErrorNumber.ACCESS_GROUP_MASKED,
"Refuse to remove last initiator member "
"from access group which have volume "
"masked to")
@@ -3338,7 +3338,7 @@ class Smis(IStorageAreaNetwork):
# each CIM_DiskDrive
return cim_exts[0]
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Failed to find out Primordial " +
"CIM_StorageExtent for CIM_DiskDrive %s " %
cim_disk_path)
@@ -3555,7 +3555,7 @@ class Smis(IStorageAreaNetwork):
elif len(cim_disks) == 2:
return None
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"Found two or more CIM_DiskDrive associated to " +
"requested CIM_StorageExtent %s" %
cim_pri_ext_path)
@@ -4437,12 +4437,12 @@ class Smis(IStorageAreaNetwork):
cim_iscsi_nodes.extend([cim_spc])

if len(cim_iscsi_nodes) == 0:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_iscsi_node_of(): No iSCSI node "
"CIM_SCSIProtocolController associated to %s"
% cim_iscsi_pg_path)
if len(cim_iscsi_nodes) > 1:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_iscsi_node_of(): Got two or more iSCSI node "
"CIM_SCSIProtocolController associated to %s: %s"
% (cim_iscsi_pg_path, cim_iscsi_nodes))
@@ -4507,7 +4507,7 @@ class Smis(IStorageAreaNetwork):
AssocClass='CIM_BindsTo',
PropertyList=['PortNumber'])
if len(cim_tcps) == 0:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_cim_iscsi_pg_to_lsm(): "
"No CIM_TCPProtocolEndpoint associated to %s"
% cim_iscsi_pg.path)
@@ -4728,13 +4728,13 @@ class Smis(IStorageAreaNetwork):
if out_key in out:
if flag_out_array:
if len(out[out_key]) != 1:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_wait_invoke(), %s is not length 1: %s"
% (out_key, out.items()))
return out[out_key][0]
return out[out_key]
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_wait_invoke(), %s not exist in out %s" %
(out_key, out.items()))
elif rc == Smis.INVOKE_ASYNC:
@@ -4761,11 +4761,11 @@ class Smis(IStorageAreaNetwork):
AssocClass='CIM_AffectedJobElement',
ResultClass=expect_class)
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_wait_invoke(): Got unknown job state "
"%d: %s" % (job_state, cim_job.items()))
if len(cim_xxxs_path) != 1:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_wait_invoke(): got unexpect(not 1) "
"return from CIM_AffectedJobElement: "
"%s, out: %s, job: %s" %
@@ -4773,7 +4773,7 @@ class Smis(IStorageAreaNetwork):
cim_job.items()))
return cim_xxxs_path[0]
else:
- raise LsmError(ErrorNumber.LSM_PLUGIN_BUG,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
"_wait_invoke(): Got unexpected rc code "
"%d, out: %s" % (rc, out.items()))

@@ -4988,7 +4988,7 @@ class Smis(IStorageAreaNetwork):
cim_spc_path,
AssocClass='CIM_ProtocolControllerForUnit',
ResultClass='CIM_StorageVolume')) >= 1:
- raise LsmError(ErrorNumber.MASKED_ACCESS_GROUP,
+ raise LsmError(ErrorNumber.ACCESS_GROUP_MASKED,
"Access Group %s has volume masked" %
access_group.id)

diff --git a/plugin/targetd/targetd.py b/plugin/targetd/targetd.py
index 597ee7d..9cf763e 100644
--- a/plugin/targetd/targetd.py
+++ b/plugin/targetd/targetd.py
@@ -290,7 +290,7 @@ class TargetdStorage(IStorageAreaNetwork, INfs):
def volume_create(self, pool, volume_name, size_bytes, provisioning,
flags=0):
if provisioning != Volume.PROVISION_DEFAULT:
- raise LsmError(ErrorNumber.UNSUPPORTED_PROVISIONING,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"Unsupported provisioning")

self._jsonrequest("vol_create", dict(pool=pool.id,
@@ -537,7 +537,7 @@ class TargetdStorage(IStorageAreaNetwork, INfs):

fs_path = self._get_fs_path(fs_id)
if fs_path is None:
- raise LsmError(ErrorNumber.INVALID_FS, "File system not found")
+ raise LsmError(ErrorNumber.NOT_FOUND_FS, "File system not found")

for host in rw_list:
tmp_opts = copy.copy(base_opts)
@@ -578,7 +578,7 @@ class TargetdStorage(IStorageAreaNetwork, INfs):
if host_entry in l:
return host

- raise LsmError(ErrorNumber.PLUGIN_ERROR, "Failed to create export")
+ raise LsmError(ErrorNumber.PLUGIN_BUG, "Failed to create export")

@handle_errors
def export_remove(self, export, flags=0):
@@ -600,7 +600,7 @@ class TargetdStorage(IStorageAreaNetwork, INfs):
request = urllib2.Request(self.url, data, self.headers)
response_obj = urllib2.urlopen(request)
except socket.error:
- raise LsmError(ErrorNumber.NO_CONNECT,
+ raise LsmError(ErrorNumber.NETWORK_ERROR,
"Unable to connect to targetd, uri right?")

response_data = response_obj.read()
@@ -624,5 +624,5 @@ class TargetdStorage(IStorageAreaNetwork, INfs):
if status:
if status[0]:
raise LsmError(
- ErrorNumber.LSM_PLUGIN_BUG,
+ ErrorNumber.PLUGIN_BUG,
"%d has error %d" % (async_code, status[0]))
diff --git a/python_binding/lsm/_common.py b/python_binding/lsm/_common.py
index 386d9a9..d11c170 100644
--- a/python_binding/lsm/_common.py
+++ b/python_binding/lsm/_common.py
@@ -73,7 +73,7 @@ def common_urllib2_error_handler(exp):

stack_trace = traceback.format_exc()
error("Unexpected exception:\n" + stack_trace)
- raise LsmError(ErrorNumber.PLUGIN_ERROR, "Unexpected exception",
+ raise LsmError(ErrorNumber.PLUGIN_BUG, "Unexpected exception",
stack_trace)


@@ -275,13 +275,13 @@ def uri_parse(uri, requires=None, required_params=None):
if requires:
for r in requires:
if r not in rc:
- raise LsmError(ErrorNumber.PLUGIN_ERROR,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
'uri missing \"%s\" or is in invalid form' % r)

if required_params:
for r in required_params:
if r not in rc['parameters']:
- raise LsmError(ErrorNumber.PLUGIN_ERROR,
+ raise LsmError(ErrorNumber.PLUGIN_BUG,
'uri missing query parameter %s' % r)
return rc

@@ -422,11 +422,10 @@ class ErrorLevel(object):
#using them.
class ErrorNumber(object):
OK = 0
- LSM_LIB_BUG = 1
- LSM_PLUGIN_BUG = 2
- LSM_STORAGE_SDK_BUG = 3
+ LIB_BUG = 1
+ PLUGIN_BUG = 2
+ STORAGE_SDK_BUG = 3
JOB_STARTED = 7
- INDEX_BOUNDS = 10
TIMEOUT = 11
DAEMON_NOT_RUNNING = 12

@@ -438,26 +437,7 @@ class ErrorNumber(object):
EXISTS_POOL = 56
EXISTS_VOLUME = 57

- INVALID_ACCESS_GROUP = 100
INVALID_ARGUMENT = 101
- INVALID_CONN = 102
- INVALID_ERR = 103
- INVALID_FS = 104
- INVALID_JOB = 106
- INVALID_NAME = 107
- INVALID_NFS = 108
- INVALID_PLUGIN = 109
- INVALID_POOL = 110
- INVALID_SL = 111
- INVALID_SS = 112
- INVALID_URI = 113
- INVALID_VALUE = 114
- INVALID_VOLUME = 115
- INVALID_CAPABILITY = 116
- INVALID_SYSTEM = 117
- INVALID_INIT = 118
- INVALID_DISK = 119
- INVALID_BLOCK_RANGE = 121

IS_MAPPED = 125

@@ -465,7 +445,6 @@ class ErrorNumber(object):
NETWORK_HOSTDOWN = 141 # Host unreachable on network
NETWORK_ERROR = 142 # Generic network error

- NO_CONNECT = 150
NO_MAPPING = 151
NO_MEMORY = 152
NO_SUPPORT = 153
@@ -474,34 +453,26 @@ class ErrorNumber(object):
NOT_FOUND_FS = 201
NOT_FOUND_JOB = 202
NOT_FOUND_POOL = 203
- NOT_FOUND_SS = 204
+ NOT_FOUND_FS_SS = 204
NOT_FOUND_VOLUME = 205
NOT_FOUND_NFS_EXPORT = 206
NOT_FOUND_SYSTEM = 208
NOT_FOUND_DISK = 209

- NOT_IMPLEMENTED = 225
NOT_LICENSED = 226

- OFF_LINE = 250
- ON_LINE = 251
+ NO_SUPPORT_ONLINE_CHANGE = 250
+ NO_SUPPORT_OFFLINE_CHANGE = 251

PLUGIN_AUTH_FAILED = 300
- PLUGIN_DLOPEN = 301
- PLUGIN_DLSYM = 302
- PLUGIN_ERROR = 303
- PLUGIN_MISSING_HOST = 304
- PLUGIN_MISSING_NS = 305
- PLUGIN_MISSING_PORT = 306
- PLUGIN_PERMISSION = 307
+ PLUGIN_IPC_FAIL = 301
+
+ PLUGIN_SOCKET_PERMISSION = 307
PLUGIN_REGISTRATION = 308
- PLUGIN_UNKNOWN_HOST = 309
- PLUGIN_TIMEOUT = 310
PLUGIN_NOT_EXIST = 311

- SIZE_INSUFFICIENT_SPACE = 350
+ NOT_ENOUGH_SPACE = 350
SIZE_SAME = 351
- SIZE_TOO_LARGE = 352
SIZE_TOO_SMALL = 353
SIZE_LIMIT_REACHED = 354

@@ -509,22 +480,17 @@ class ErrorNumber(object):
TRANSPORT_SERIALIZATION = 401
TRANSPORT_INVALID_ARG = 402

- UNSUPPORTED_PROVISIONING = 451
- UNSUPPORTED_REPLICATION_TYPE = 452
-
DISK_BUSY = 500
VOLUME_BUSY = 501
- ACCESS_GROUP_BUSY = 502 # refuse to remove the last initiator from
- # access group which have volume masked.
+ ACCESS_GROUP_MASKED = 502 # refuse to remove the last initiator from
+ # access group which have volume masked or
+ # allow an access group to be deleted

UNSUPPORTED_SEARCH_KEY = 510

EMPTY_ACCESS_GROUP = 511 # volume_mask() will fail if access group
# has no member/initiator.

- MASKED_ACCESS_GROUP = 512 # access_group_delete() will fail if
- # have volume masked.
-
_LOCALS = locals()

@staticmethod
diff --git a/python_binding/lsm/_data.py b/python_binding/lsm/_data.py
index d6feed8..17df3ec 100644
--- a/python_binding/lsm/_data.py
+++ b/python_binding/lsm/_data.py
@@ -692,14 +692,14 @@ class AccessGroup(IData):
if AccessGroup._regex_iscsi_iqn.match(str(init_id)):
return True
if raise_error:
- raise LsmError(ErrorNumber.INVALID_INIT,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"Invalid iSCSI IQN Initiator: %s" % init_id)
return False
elif init_type == AccessGroup.INIT_TYPE_WWPN:
if AccessGroup._regex_lsm_wwpn.match(str(init_id)):
return True
if raise_error:
- raise LsmError(ErrorNumber.INVALID_INIT,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"Invalid WWPN Initiator: %s" % init_id)
return False
elif raise_error:
@@ -750,7 +750,7 @@ class AccessGroup(IData):
s = ":".join(re.findall(r'..', s))
return s
if raise_error:
- raise LsmError(ErrorNumber.INVALID_INIT,
+ raise LsmError(ErrorNumber.INVALID_ARGUMENT,
"Invalid WWPN Initiator: %s" % wwpn)
return None

diff --git a/python_binding/lsm/_pluginrunner.py b/python_binding/lsm/_pluginrunner.py
index 024fc0d..49f7a96 100644
--- a/python_binding/lsm/_pluginrunner.py
+++ b/python_binding/lsm/_pluginrunner.py
@@ -138,7 +138,7 @@ class PluginRunner(object):
error("Unhandled exception in plug-in!\n" + traceback.format_exc())

try:
- self.tp.send_error(msg_id, ErrorNumber.PLUGIN_ERROR,
+ self.tp.send_error(msg_id, ErrorNumber.PLUGIN_BUG,
"Unhandled exception in plug-in",
str(traceback.format_exc()))
except Exception:
diff --git a/python_binding/lsm/_transport.py b/python_binding/lsm/_transport.py
index 9a4f00e..4498be2 100644
--- a/python_binding/lsm/_transport.py
+++ b/python_binding/lsm/_transport.py
@@ -101,7 +101,7 @@ class TransPort(object):
s.connect(path)
except socket.error:
#self, code, message, data=None, *args, **kwargs
- raise LsmError(ErrorNumber.NO_CONNECT,
+ raise LsmError(ErrorNumber.NETWORK_ERROR,
"Unable to connect to lsmd, daemon started?")
return s

diff --git a/test/tester.c b/test/tester.c
index 535a1a5..5ce641f 100644
--- a/test/tester.c
+++ b/test/tester.c
@@ -1228,14 +1228,14 @@ START_TEST(test_invalid_input)

rc = lsm_connect_password("INVALID_URI:\\yep", NULL, &test_connect, 20000,
&test_error, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_URI, "rc %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc %d", rc);


rc = lsm_connect_close((lsm_connect *)&bad, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_CONN == rc, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);

rc = lsm_connect_close((lsm_connect *)NULL, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_CONN == rc, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);



@@ -1386,11 +1386,11 @@ START_TEST(test_invalid_input)
job = NULL;

rc = lsm_volume_create(c, NULL, NULL, 0, 0, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_POOL == rc, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);

rc = lsm_volume_create(c, (lsm_pool *)&bad, "BAD_POOL", 10000000,
LSM_PROVISION_DEFAULT, &new_vol, &job, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_POOL == rc, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);

rc = lsm_volume_create(c, test_pool, "", 10000000, LSM_PROVISION_DEFAULT,
&new_vol, &job, LSM_FLAG_RSVD);
@@ -1421,7 +1421,7 @@ START_TEST(test_invalid_input)

/* lsmVolumeResize */
rc = lsm_volume_resize(c, NULL, 0, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_VOL == rc, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);


lsm_volume *resized = (lsm_volume *)&bad;
@@ -1447,7 +1447,7 @@ START_TEST(test_invalid_input)

/* lsmVolumeDelete */
rc = lsm_volume_delete(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_VOL == rc, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);

rc = lsm_volume_delete(c, resized, NULL, LSM_FLAG_RSVD);
fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc %d", rc);
@@ -1470,7 +1470,7 @@ START_TEST(test_invalid_input)


rc = lsm_capabilities(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_SYSTEM, "rc %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT, "rc %d", rc);

if( num_systems ) {
rc = lsm_capabilities(c, sys[0], NULL, LSM_FLAG_RSVD);
@@ -1480,11 +1480,11 @@ START_TEST(test_invalid_input)
/* lsmVolumeReplicate */
lsm_volume *cloned = NULL;
rc = lsm_volume_replicate(c, (lsm_pool *)&bad, 0, NULL, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_POOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_replicate(c, test_pool, LSM_VOLUME_REPLICATE_CLONE, NULL,
"cloned", &cloned, &job, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_replicate(c, test_pool, LSM_VOLUME_REPLICATE_CLONE, new_vol,
"", &cloned, &job, LSM_FLAG_RSVD);
@@ -1506,11 +1506,11 @@ START_TEST(test_invalid_input)
/* lsmVolumeReplicateRange */
rc = lsm_volume_replicate_range(c, LSM_VOLUME_REPLICATE_CLONE, NULL, NULL,
NULL, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_replicate_range(c, LSM_VOLUME_REPLICATE_CLONE, new_vol,
NULL, NULL, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_replicate_range(c, LSM_VOLUME_REPLICATE_CLONE, new_vol, new_vol,
NULL, 1, &job, LSM_FLAG_RSVD);
@@ -1518,10 +1518,10 @@ START_TEST(test_invalid_input)


rc = lsm_volume_online(c, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_offline(c, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


/* lsmAccessGroupCreate */
@@ -1534,7 +1534,7 @@ START_TEST(test_invalid_input)

rc = lsm_access_group_create(c, "my_group", ISCSI_HOST[0], LSM_ACCESS_GROUP_INIT_TYPE_OTHER,
NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SYSTEM, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_access_group_create(c, "my_group", ISCSI_HOST[0], LSM_ACCESS_GROUP_INIT_TYPE_OTHER,
@@ -1545,15 +1545,15 @@ START_TEST(test_invalid_input)

/* lsmAccessGroupDel */
rc = lsm_access_group_delete(c, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_ACCESS_GROUP, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

/* lsmAccessGroupInitiatorAdd */
rc = lsm_access_group_initiator_add(c, NULL, NULL, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_ACCESS_GROUP, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_access_group_initiator_delete(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_ACCESS_GROUP, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_access_group_initiator_delete(c, ag, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1561,42 +1561,42 @@ START_TEST(test_invalid_input)


rc = lsm_volume_mask(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_ACCESS_GROUP, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_mask(c, ag, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_unmask(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_ACCESS_GROUP, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_unmask(c, ag, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


/* lsmVolumesAccessibleByAccessGroup */
rc = lsm_volumes_accessible_by_access_group(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_ACCESS_GROUP, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volumes_accessible_by_access_group(c, ag, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

/* lsmAccessGroupsGrantedToVolume */
rc = lsm_access_groups_granted_to_volume(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_access_groups_granted_to_volume(c, new_vol, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

/* lsmVolumeChildDependency */
rc = lsm_volume_child_dependency(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_child_dependency(c, new_vol, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

/*lsmVolumeChildDependencyDelete*/
rc = lsm_volume_child_dependency_delete(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_VOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_volume_child_dependency_delete(c, new_vol, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1623,7 +1623,7 @@ START_TEST(test_invalid_input)

/*lsmFsCreate*/
rc = lsm_fs_create(c, NULL, NULL, 0, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_POOL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_create(c, test_pool, NULL, 0, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1640,21 +1640,21 @@ START_TEST(test_invalid_input)

/* lsmFsDelete */
rc = lsm_fs_delete(c, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_delete(c, arg_fs, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

/* lsmFsResize */
rc = lsm_fs_resize(c, NULL, 0, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_resize(c, arg_fs, 0, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

/* lsmFsClone */
rc = lsm_fs_clone(c, NULL, NULL, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_clone(c, arg_fs, NULL, NULL, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1662,18 +1662,18 @@ START_TEST(test_invalid_input)

/*lsmFsFileClone*/
rc = lsm_fs_file_clone(c, NULL, NULL, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_file_clone(c, arg_fs, NULL, NULL, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_fs_child_dependency(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

lsm_string_list *badf = (lsm_string_list *)&bad;
rc = lsm_fs_child_dependency(c, arg_fs, badf, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

lsm_string_list *f = lsm_string_list_alloc(1);
rc = lsm_fs_child_dependency(c, arg_fs, f, NULL, LSM_FLAG_RSVD);
@@ -1681,10 +1681,10 @@ START_TEST(test_invalid_input)

/*lsmFsChildDependencyDelete*/
rc = lsm_fs_child_dependency_delete(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_child_dependency_delete(c, arg_fs, badf, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_child_dependency_delete(c, arg_fs, f, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1692,7 +1692,7 @@ START_TEST(test_invalid_input)


rc = lsm_fs_ss_list(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_fs_ss_list(c, arg_fs, NULL, NULL, LSM_FLAG_RSVD);
@@ -1700,7 +1700,7 @@ START_TEST(test_invalid_input)


rc = lsm_fs_ss_create(c, NULL, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_create(c, arg_fs, NULL, NULL, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1717,26 +1717,26 @@ START_TEST(test_invalid_input)
}

rc = lsm_fs_ss_delete(c, NULL, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_delete(c, arg_fs, NULL, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_delete(c, arg_fs, arg_ss, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_fs_ss_restore(c, NULL, NULL, NULL, NULL, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_FS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_restore(c, arg_fs, NULL, NULL, NULL, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_restore(c, arg_fs, arg_ss, badf, NULL, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_restore(c, arg_fs, arg_ss, badf, badf, 0, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_fs_ss_restore(c, arg_fs, arg_ss, f, f, 0, NULL, LSM_FLAG_RSVD);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1763,15 +1763,15 @@ START_TEST(test_invalid_input)

rc = lsm_nfs_export_fs(c, NULL, NULL, badf, NULL, NULL, 0,0,NULL, NULL, NULL,
LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_nfs_export_fs(c, NULL, NULL, f, badf, NULL, 0,0,NULL, NULL, NULL,
LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_nfs_export_fs(c, NULL, NULL, f, f, badf, 0,0,NULL, NULL, NULL,
LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_SL, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_nfs_export_fs(c, NULL, NULL, f, f, f, 0,0, NULL, NULL, NULL,
@@ -1779,7 +1779,7 @@ START_TEST(test_invalid_input)
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_nfs_export_delete(c, NULL, LSM_FLAG_RSVD);
- fail_unless(rc == LSM_ERR_INVALID_NFS, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);


rc = lsm_volume_record_free(new_vol);
@@ -1798,10 +1798,10 @@ START_TEST(test_invalid_input)
int flags = 10;

rc = lsm_pool_create(NULL, NULL, NULL, size, raid_type, member_type, NULL, NULL, flags);
- fail_unless(rc == LSM_ERR_INVALID_CONN, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_pool_create(c, NULL, NULL, size, raid_type, member_type, NULL, NULL, flags);
- fail_unless(rc == LSM_ERR_INVALID_SYSTEM, "rc = %d", rc);
+ fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);

rc = lsm_pool_create(c, system, NULL, size, raid_type, member_type, NULL, NULL, flags);
fail_unless(rc == LSM_ERR_INVALID_ARGUMENT, "rc = %d", rc);
@@ -1977,7 +1977,7 @@ START_TEST(test_plugin_info)
}

rc = lsm_plugin_info_get(NULL, &desc, &version, LSM_FLAG_RSVD);
- fail_unless(LSM_ERR_INVALID_CONN == rc, "rc = %d", rc);
+ fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc = %d", rc);

rc = lsm_plugin_info_get(c, NULL, &version, LSM_FLAG_RSVD);
fail_unless(LSM_ERR_INVALID_ARGUMENT == rc, "rc = %d", rc);
--
1.8.2.1
Loading...