blob: b4e65232845522667b2c1c58593e60b3ca41f6ed [file] [log] [blame]
/*
* 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;
}