diff options
Diffstat (limited to 'sysfsutils/test/test_module.c')
| -rw-r--r-- | sysfsutils/test/test_module.c | 711 |
1 files changed, 711 insertions, 0 deletions
diff --git a/sysfsutils/test/test_module.c b/sysfsutils/test/test_module.c new file mode 100644 index 0000000..b4e6523 --- /dev/null +++ b/sysfsutils/test/test_module.c @@ -0,0 +1,711 @@ +/* + * sysfs_module.c + * + * Generic module utility functions for libsysfs + * + * Copyright (C) IBM Corp. 2003-2005 + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/** + *************************************************************************** + * this will test the module related functions provided by libsysfs. + * + * extern void sysfs_close_module(struct sysfs_module *module); + * extern struct sysfs_module *sysfs_open_module_path(const char *path); + * extern struct sysfs_module *sysfs_open_module(const char *name); + * extern struct dlist *sysfs_get_module_attributes + * (struct sysfs_module *module); + * extern struct sysfs_attribute *sysfs_get_module_attr + * (struct sysfs_module *module, const char *name); + * extern struct dlist *sysfs_get_module_parms(struct sysfs_module *module); + * extern struct dlist *sysfs_get_module_sections(struct sysfs_module *module); + * extern struct sysfs_attribute *sysfs_get_module_parm + * (struct sysfs_module *module, const char *parm); + * extern struct sysfs_attribute *sysfs_get_module_section + * (struct sysfs_module *module, const char *section); + */ + +#include "test-defs.h" +#include <errno.h> + +/** + * sysfs_close_module: closes a module. + * @module: sysfs_module device to close. + * flag: + * 0: path -> valid + * 1: path -> NULL + */ +int test_sysfs_close_module(int flag) +{ + struct sysfs_module *module; + + switch (flag) { + case 0: + module = sysfs_open_module_path(val_mod_path); + if (module == NULL) + return 0; + break; + case 1: + module = NULL; + break; + default: + return -1; + } + sysfs_close_module(module); + + dbg_print("%s: returns void\n",__FUNCTION__); + return 0; +} + +/** + * sysfs_open_module_path: Opens and populates the module struct + * @path: path to module. + * returns struct sysfs_module with success and NULL with error. + * + * flag: + * 0: path -> valid + * 1: path -> invalid + * 2: path -> NULL + */ +int test_sysfs_open_module_path(int flag) +{ + struct sysfs_module *module = NULL; + char *path = NULL; + + switch (flag) { + case 0: + path = val_mod_path; + break; + case 1: + path = inval_path; + break; + case 2: + path = NULL; + break; + default: + return -1; + } + + module = sysfs_open_module_path(path); + + switch (flag) { + case 0: + if (module == NULL) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_module(module); + dbg_print("\n"); + } + break; + case 1: + case 2: + if (module != NULL) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + default: + break; + } + + if (module!= NULL) + sysfs_close_module(module); + + return 0; +} + +/** + * sysfs_open_module: opens specific module on a system + * returns sysfs_module structure with success or NULL with error. + * flag: + * 0: name -> valid + * 1: name -> invalid + * 2: name -> NULL + */ +int test_sysfs_open_module(int flag) +{ + struct sysfs_module *module = NULL; + char *modname = NULL; + + switch (flag) { + case 0: + modname = val_mod_name; + break; + case 1: + modname = inval_name; + break; + case 2: + modname = NULL; + break; + default: + return -1; + } + + module = sysfs_open_module(modname); + + switch (flag) { + case 0: + if (module == NULL) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_module(module); + dbg_print("\n"); + } + break; + case 1: + case 2: + if (module) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + break; + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} + +/** + * sysfs_get_module_attr: searches module's attributes by name + * @module: module to look through + * @name: attribute name to get + * returns sysfs_attribute reference with success or NULL with error + * flag: + * 0: name -> valid, attrname -> valid + * 1: name -> valid, attrname -> invalid + * 2: name -> valid, attrname -> NULL + */ +int test_sysfs_get_module_attr(int flag) +{ + char *name, *attrname; + struct sysfs_attribute *attr; + struct sysfs_module *module; + + switch (flag) { + case 0: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + attrname = val_mod_attr_name; + break; + case 1: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + attrname = inval_name; + break; + case 2: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + attrname = NULL; + break; + default: + return -1; + } + + attr = sysfs_get_module_attr(module,attrname); + + switch (flag) { + case 0: + if(!attr) { + if (errno == EACCES) + dbg_print("%s: attribute %s does not support " + "READ\n", __FUNCTION__, attrname); + else if (errno == ENOENT) + dbg_print("%s: attribute %s not defined for " + "module at %s\n", __FUNCTION__, + attrname, name); + else if (errno == 0) + dbg_print("%s: module at %s does not export " + "attributes\n", __FUNCTION__, val_drv_path); + else + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + } else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_attribute(attr); + dbg_print("\n"); + } + break; + + case 1: + case 2: + if (attr) + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + dbg_print("******************\n"); + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} + +/** + * sysfs_get_module_attributes: returns a dlist of attributes for + * the requested sysfs_module + * @cdev: sysfs_module for which attributes are needed + * returns a dlist of attributes if exists, NULL otherwise + * flag: + * 0: name -> valid + * 1: name -> invalid + * 2: name -> NULL + */ +int test_sysfs_get_module_attributes(int flag) +{ + struct dlist *list; + struct sysfs_module *module; + char *name; + + switch (flag) { + case 0: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + break; + case 1: + name = inval_name; + module = sysfs_open_module_path(name); + if (!module) { + return 0; + } + break; + case 2: + name = NULL; + module = sysfs_open_module_path(name); + if (!module) { + return 0; + } + default: + return -1; + } + + list = sysfs_get_module_attributes(module); + + switch (flag) { + case 0: + if (!list) { + if (errno == 0) + dbg_print("%s: No attributes are defined for " + "the module at %s\n", __FUNCTION__, name); + else + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + } else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_attribute_list(list); + dbg_print("\n"); + } + break; + case 1: + case 2: + if (list != NULL) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + break; + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} + +/** + * sysfs_get_module_parms: Get modules list of parameters + * @module: sysfs_module whose parmameter list is required + * Returns dlist of parameters on SUCCESS and NULL on error + * flag: + * 0: name -> valid + * 1: name -> invalid + * 2: name -> NULL + */ +int test_sysfs_get_module_parms(int flag) +{ + struct dlist *params; + char *name; + struct sysfs_module *module; + switch (flag) { + case 0: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + break; + case 1: + name = inval_name; + module = sysfs_open_module_path(name); + if (!module) { + return 0; + } + break; + case 2: + name = NULL; + module = sysfs_open_module_path(name); + if (!module) { + return 0; + } + break; + default: + return -1; + } + + params = sysfs_get_module_parms(module); + + switch (flag) { + case 0: + if (!params) { + if (errno == 0) + dbg_print("%s: No parameters are passed for " + "the module at %s\n", __FUNCTION__, name); + else + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + } else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_parm_list(params); + dbg_print("\n"); + } + break; + case 1: + case 2: + if (params) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + break; + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} + +/** + * sysfs_get_module_sections: Get the set of sections for this module + * @module: sysfs_module whose list of sections is required + * Returns dlist of sections on SUCCESS and NULL on error + * 0: name -> valid + * 1: name -> invalid + * 2: name -> NULL + */ +int test_sysfs_get_module_sections(int flag) +{ + struct dlist *sections; + char *name; + struct sysfs_module *module; + + switch (flag) { + case 0: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + break; + case 1: + name = inval_name; + module = sysfs_open_module_path(name); + if (!module) { + return 0; + } + break; + case 2: + name = NULL; + module = sysfs_open_module_path(name); + if (!module) { + return 0; + } + break; + default: + return -1; + } + + sections = sysfs_get_module_sections(module); + + switch (flag) { + case 0: + if (!sections) { + if (errno == 0) + dbg_print("%s: No sections for the module at " + "%s\n", __FUNCTION__, name); + else + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + } else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_section_list(sections); + dbg_print("\n"); + } + break; + case 1: + case 2: + if (sections) + dbg_print("%s: FAILED with flag = %d errno = %d\n", + __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + break; + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} + +/** + * sysfs_get_module_parm: + * @module: sysfs_module to look through + * @parm: name of the parameter to look for + * Returns sysfs_attribute * on SUCCESS and NULL on error + * flag: + * 0: name -> valid, paramname -> valid + * 1: name -> valid, paramname -> invalid + * 2: name -> valid, paramname -> NULL + */ +int test_sysfs_get_module_parm(int flag) +{ + char *name, *paramname; + struct sysfs_attribute *attr; + struct sysfs_module *module; + + switch (flag) { + case 0: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + paramname = val_mod_param; + break; + case 1: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + paramname = inval_name; + break; + case 2: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + paramname = NULL; + break; + default: + return -1; + } + + attr = sysfs_get_module_parm(module,paramname); + + switch (flag) { + case 0: + if(!attr) { + if (errno == EACCES) + dbg_print("%s: parameter %s not used by module" + , __FUNCTION__, paramname); + else if (errno == ENOENT) + dbg_print("%s: attribute %s not defined for " + "module at %s\n", __FUNCTION__, + paramname, name); + else if (errno == 0) + dbg_print("%s: module at %s does not use " + "parameter\n", __FUNCTION__, val_mod_path); + else + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + } else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_attribute(attr); + dbg_print("\n"); + } + break; + + case 1: + case 2: + if (attr) + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} + +/** + * sysfs_get_module_section + * @module: sysfs_module to look through + * @section: name of the section to look for + * Returns sysfs_attribute * on SUCCESS and NULL on error + * flag: + * 0: name -> valid, sectname -> valid + * 1: name -> valid, sectname -> invalid + * 2: name -> valid, sectname -> NULL + */ +int test_sysfs_get_module_section(int flag) +{ + char *name, *sectname; + struct sysfs_attribute *attr; + struct sysfs_module *module; + + switch (flag) { + case 0: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + sectname = val_mod_section; + break; + case 1: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + sectname = inval_name; + break; + case 2: + name = val_mod_path; + module = sysfs_open_module_path(name); + if (!module) { + dbg_print("%s: failed opening module at %s\n", + __FUNCTION__, name); + return 0; + } + sectname = NULL; + break; + default: + return -1; + } + + attr = sysfs_get_module_section(module,sectname); + + switch (flag) { + case 0: + if(!attr) { + if (errno == EACCES) + dbg_print("%s: section %s not used by module" + , __FUNCTION__, sectname); + else if (errno == ENOENT) + dbg_print("%s: section %s not defined for " + "module at %s\n", __FUNCTION__, + sectname, name); + else if (errno == 0) + dbg_print("%s: module at %s does not use " + "section\n", __FUNCTION__, val_mod_path); + else + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + } else { + dbg_print("%s: SUCCEEDED with flag = %d\n\n", + __FUNCTION__, flag); + show_attribute(attr); + dbg_print("\n"); + } + break; + + case 1: + case 2: + if (attr) + dbg_print("%s: FAILED with flag = %d errno = " + "%d\n", __FUNCTION__, flag, errno); + else + dbg_print("%s: SUCCEEDED with flag = %d\n", + __FUNCTION__, flag); + default: + break; + } + + if (module) + sysfs_close_module(module); + return 0; +} |