Main Page | Class List | Directories | File List | Class Members | File Members
cmdlang

cmd_pef.c File Reference

#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <OpenIPMI/ipmiif.h>
#include <OpenIPMI/ipmi_pef.h>
#include <OpenIPMI/ipmi_cmdlang.h>
#include <OpenIPMI/ipmi_mc.h>
#include <OpenIPMI/internal/ipmi_malloc.h>
#include <OpenIPMI/internal/locked_list.h>

Go to the source code of this file.

Classes

struct  pef_config_info_s
struct  find_config_s
struct  lp_item_s
struct  lps_s
struct  ulp_item_s
struct  ulps_s
struct  pef_config_op_s
struct  pet_mc_unlock_s

Defines

#define PEF_CONFIG_NAME_LEN   80
#define FR(name, type)
#define F(name, type)
#define CMDS_PEF_LEN   (sizeof(cmds_pef)/sizeof(ipmi_cmdlang_init_t))

Typedefs

typedef pef_config_info_s pef_config_info_t
typedef find_config_s find_config_t
typedef void(* lp_set )(ipmi_cmd_info_t *cmd_info, char *val, ipmi_pef_config_t *lanc, void *func)
typedef void(* lp_out )(ipmi_cmd_info_t *cmd_info, char *name, ipmi_pef_config_t *lanc, void *func)
typedef lp_item_s lp_item_t
typedef void(* ulp_set )(ipmi_cmd_info_t *cmd_info, int sel, char *val, ipmi_pef_config_t *lanc, void *func)
typedef void(* ulp_out )(ipmi_cmd_info_t *cmd_info, int sel, char *name, ipmi_pef_config_t *lanc, void *func)
typedef ulp_item_s ulp_item_t
typedef pef_config_op_s pef_config_op_t
typedef pet_mc_unlock_s pef_mc_unlock_t

Functions

static void pef_list_handler (ipmi_pef_t *pef, void *cb_data)
static void pef_list (ipmi_domain_t *domain, void *cb_data)
static void get_mc_name (ipmi_mc_t *mc, void *cb_data)
static void pef_info (ipmi_pef_t *pef, void *cb_data)
static void pef_new_done (ipmi_pef_t *pef, int err, void *cb_data)
static void pef_new (ipmi_mc_t *mc, void *cb_data)
static void pef_close_done (ipmi_pef_t *pef, int err, void *cb_data)
static void pef_close (ipmi_pef_t *pef, void *cb_data)
static int find_config_handler (void *cb_data, void *item1, void *item2)
static ipmi_pef_config_t * find_config (char *name, int delete)
static void set_retint (ipmi_cmd_info_t *cmd_info, char *val, ipmi_pef_config_t *lanc, void *func)
static void out_retint (ipmi_cmd_info_t *cmd_info, char *name, ipmi_pef_config_t *lanc, void *func)
static void set_retbool (ipmi_cmd_info_t *cmd_info, char *val, ipmi_pef_config_t *lanc, void *func)
static void out_retbool (ipmi_cmd_info_t *cmd_info, char *name, ipmi_pef_config_t *lanc, void *func)
static void set_int (ipmi_cmd_info_t *cmd_info, char *val, ipmi_pef_config_t *lanc, void *func)
static void out_int (ipmi_cmd_info_t *cmd_info, char *name, ipmi_pef_config_t *lanc, void *func)
static void set_guid (ipmi_cmd_info_t *cmd_info, char *val, ipmi_pef_config_t *lanc, void *func)
static void out_guid (ipmi_cmd_info_t *cmd_info, char *name, ipmi_pef_config_t *lanc, void *func)
static void uset_bool (ipmi_cmd_info_t *cmd_info, int sel, char *val, ipmi_pef_config_t *lanc, void *func)
static void uout_bool (ipmi_cmd_info_t *cmd_info, int sel, char *name, ipmi_pef_config_t *lanc, void *func)
static void uset_int (ipmi_cmd_info_t *cmd_info, int sel, char *val, ipmi_pef_config_t *lanc, void *func)
static void uout_int (ipmi_cmd_info_t *cmd_info, int sel, char *name, ipmi_pef_config_t *lanc, void *func)
static void uset_str (ipmi_cmd_info_t *cmd_info, int sel, char *val, ipmi_pef_config_t *lanc, void *func)
static void uout_str (ipmi_cmd_info_t *cmd_info, int sel, char *name, ipmi_pef_config_t *lanc, void *func)
static void config_info (ipmi_cmd_info_t *cmd_info, ipmi_pef_config_t *config)
static void pef_config_get_done (ipmi_pef_t *pef, int err, ipmi_pef_config_t *config, void *cb_data)
static void pef_config_get (ipmi_pef_t *pef, void *cb_data)
static void pef_config_set_done (ipmi_pef_t *pef, int err, void *cb_data)
static void pef_config_set (ipmi_pef_t *pef, void *cb_data)
static void pef_config_unlock_done (ipmi_pef_t *pef, int err, void *cb_data)
static void pef_config_unlock (ipmi_pef_t *pef, void *cb_data)
static void pef_config_close (ipmi_cmd_info_t *cmd_info)
static int pef_config_list_handler (void *cb_data, void *item1, void *item2)
static void pef_config_list (ipmi_cmd_info_t *cmd_info)
static int pef_config_info_handler (void *cb_data, void *item1, void *item2)
static void pef_config_info (ipmi_cmd_info_t *cmd_info)
static void pef_config_update (ipmi_cmd_info_t *cmd_info)
static void pef_unlock_mc_done2 (ipmi_pef_t *pef, int err, void *cb_data)
static void pef_unlock_mc_done1 (ipmi_pef_t *pef, int err, void *cb_data)
static void pef_unlock_mc (ipmi_mc_t *mc, void *cb_data)
int ipmi_cmdlang_pef_init (os_handler_t *os_hnd)
static int config_destroy_handler (void *cb_data, void *item1, void *item2)
void ipmi_cmdlang_pef_shutdown (void)

Variables

static locked_list_t * pefs
static unsigned int unique_num = 0
static lp_item_t lp_retint = {set_retint, out_retint}
static lp_item_t lp_retbool = {set_retbool, out_retbool}
static lp_item_t lp_int = {set_int, out_int}
static lp_item_t lp_guid = {set_guid, out_guid}
static struct lps_s lps []
static ulp_item_t lp_ubool = {uset_bool, uout_bool}
static ulp_item_t lp_uint = {uset_int, uout_int}
static ulp_item_t lp_ustr = {uset_str, uout_str}
static struct ulps_s elps []
static struct ulps_s plps []
static struct ulps_s slps []
static ipmi_cmdlang_cmd_t * pef_cmds
static ipmi_cmdlang_cmd_t * config_cmds
static ipmi_cmdlang_init_t cmds_pef []

Define Documentation

#define CMDS_PEF_LEN   (sizeof(cmds_pef)/sizeof(ipmi_cmdlang_init_t))
 

Definition at line 1299 of file cmd_pef.c.

Referenced by ipmi_cmdlang_pef_init().

#define F (  name,
type   ) 
 

Value:

{ #name, &lp_ ## type, ipmi_pefconfig_get_ ## name, \
                        ipmi_pefconfig_set_ ## name }

#define FR (  name,
type   ) 
 

Value:

{ #name, &lp_ ## type, ipmi_pefconfig_get_ ## name, \
                         NULL }

#define PEF_CONFIG_NAME_LEN   80
 

Definition at line 197 of file cmd_pef.c.

Typedef Documentation

typedef struct find_config_s find_config_t
 

typedef struct lp_item_s lp_item_t
 

typedef void(* lp_out)(ipmi_cmd_info_t *cmd_info, char *name, ipmi_pef_config_t *lanc, void *func)
 

Definition at line 245 of file cmd_pef.c.

typedef void(* lp_set)(ipmi_cmd_info_t *cmd_info, char *val, ipmi_pef_config_t *lanc, void *func)
 

Definition at line 243 of file cmd_pef.c.

typedef struct pef_config_info_s pef_config_info_t
 

typedef struct pef_config_op_s pef_config_op_t
 

typedef struct pet_mc_unlock_s pef_mc_unlock_t
 

typedef struct ulp_item_s ulp_item_t
 

typedef void(* ulp_out)(ipmi_cmd_info_t *cmd_info, int sel, char *name, ipmi_pef_config_t *lanc, void *func)
 

Definition at line 430 of file cmd_pef.c.

typedef void(* ulp_set)(ipmi_cmd_info_t *cmd_info, int sel, char *val, ipmi_pef_config_t *lanc, void *func)
 

Definition at line 428 of file cmd_pef.c.

Function Documentation

static int config_destroy_handler (  void *  cb_data,
void *  item1,
void *  item2
)  [static]
 

Definition at line 1320 of file cmd_pef.c.

References pef_config_info_s::config, ipmi_mem_free(), ipmi_pef_free_config(), and LOCKED_LIST_ITER_CONTINUE.

01321 {
01322     pef_config_info_t *info = item1;
01323 
01324     ipmi_pef_free_config(info->config);
01325     ipmi_mem_free(info);
01326     return LOCKED_LIST_ITER_CONTINUE;
01327 }

static void config_info (  ipmi_cmd_info_t *  cmd_info,
ipmi_pef_config_t *  config
)  [static]
 

Definition at line 599 of file cmd_pef.c.

References elps, ulps_s::get_func, i, ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_out_int(), ipmi_cmdlang_up(), ipmi_pefconfig_get_num_alert_policies(), ipmi_pefconfig_get_num_alert_strings(), ipmi_pefconfig_get_num_event_filters(), ulps_s::lpi, lps_s::lpi, lps, name, ulp_item_s::out, and lp_item_s::out.

00600 {
00601     int i;
00602     int j;
00603     int num;
00604 
00605     /* Basic items */
00606     for (i=0; lps[i].name; i++) {
00607         lp_item_t *lp = lps[i].lpi;
00608         lp->out(cmd_info, lps[i].name, config, lps[i].get_func);
00609     }
00610 
00611     /* per-event-filter table items */
00612     num = ipmi_pefconfig_get_num_event_filters(config);
00613     for (j=0; j<num; j++) {
00614         struct ulps_s *lps = elps;
00615         ipmi_cmdlang_out(cmd_info, "Event Filter", NULL);
00616         ipmi_cmdlang_down(cmd_info);
00617         ipmi_cmdlang_out_int(cmd_info, "Number", j);
00618         for (i=0; lps[i].name; i++) {
00619             ulp_item_t *lp = lps[i].lpi;
00620             lp->out(cmd_info, j, lps[i].name, config, lps[i].get_func);
00621         }
00622         ipmi_cmdlang_up(cmd_info);
00623     }
00624 
00625     /* per-alert policy table items */
00626     num = ipmi_pefconfig_get_num_alert_policies(config);
00627     for (j=0; j<num; j++) {
00628         struct ulps_s *lps = plps;
00629         ipmi_cmdlang_out(cmd_info, "Alert Policy", NULL);
00630         ipmi_cmdlang_down(cmd_info);
00631         ipmi_cmdlang_out_int(cmd_info, "Number", j);
00632         for (i=0; lps[i].name; i++) {
00633             ulp_item_t *lp = lps[i].lpi;
00634             lp->out(cmd_info, j, lps[i].name, config, lps[i].get_func);
00635         }
00636         ipmi_cmdlang_up(cmd_info);
00637     }
00638 
00639     /* per-alert string items */
00640     num = ipmi_pefconfig_get_num_alert_strings(config);
00641     for (j=0; j<num; j++) {
00642         struct ulps_s *lps = slps;
00643         ipmi_cmdlang_out(cmd_info, "Alert String", NULL);
00644         ipmi_cmdlang_down(cmd_info);
00645         ipmi_cmdlang_out_int(cmd_info, "Number", j);
00646         for (i=0; lps[i].name; i++) {
00647             ulp_item_t *lp = lps[i].lpi;
00648             lp->out(cmd_info, j, lps[i].name, config, lps[i].get_func);
00649         }
00650         ipmi_cmdlang_up(cmd_info);
00651     }
00652 }

static ipmi_pef_config_t* find_config (  char *  name,
int  delete
)  [static]
 

Definition at line 232 of file cmd_pef.c.

References find_config_s::config, find_config_s::delete, find_config_handler(), locked_list_iterate(), and find_config_s::name.

00233 {
00234     find_config_t find;
00235 
00236     find.name = name;
00237     find.config = NULL;
00238     find.delete = delete;
00239     locked_list_iterate(pefs, find_config_handler, &find);
00240     return find.config;
00241 }

static int find_config_handler (  void *  cb_data,
void *  item1,
void *  item2
)  [static]
 

Definition at line 214 of file cmd_pef.c.

References pef_config_info_s::config, find_config_s::config, find_config_s::delete, ipmi_mem_free(), LOCKED_LIST_ITER_CONTINUE, LOCKED_LIST_ITER_STOP, locked_list_remove(), pef_config_info_s::name, and find_config_s::name.

00215 {
00216     pef_config_info_t *info = item1;
00217     find_config_t     *find = cb_data;
00218 
00219     if (strcmp(find->name, info->name) == 0) {
00220         find->config = info->config;
00221         if (find->delete) {
00222             locked_list_remove(pefs, item1, item2);
00223             ipmi_mem_free(info);
00224         }
00225         return LOCKED_LIST_ITER_STOP;
00226     }
00227 
00228     return LOCKED_LIST_ITER_CONTINUE;
00229 }

static void get_mc_name (  ipmi_mc_t *  mc,
void *  cb_data
)  [static]
 

Definition at line 83 of file cmd_pef.c.

References ipmi_cmdlang_out(), ipmi_mc_get_name(), and IPMI_MC_NAME_LEN.

00084 {
00085     ipmi_cmd_info_t *cmd_info = cb_data;
00086     char            mc_name[IPMI_MC_NAME_LEN];
00087 
00088     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
00089     ipmi_cmdlang_out(cmd_info, "MC", mc_name);
00090 }

int ipmi_cmdlang_pef_init (  os_handler_t *  os_hnd  ) 
 

Definition at line 1302 of file cmd_pef.c.

References CMDS_PEF_LEN, ipmi_cmdlang_reg_table(), locked_list_alloc(), and locked_list_destroy().

Referenced by ipmi_cmdlang_init().

01303 {
01304     int rv;
01305 
01306     pefs = locked_list_alloc(os_hnd);
01307     if (!pefs)
01308         return ENOMEM;
01309 
01310     rv = ipmi_cmdlang_reg_table(cmds_pef, CMDS_PEF_LEN);
01311     if (rv) {
01312         locked_list_destroy(pefs);
01313         pefs = NULL;
01314     }
01315 
01316     return rv;
01317 }

void ipmi_cmdlang_pef_shutdown (  void   ) 
 

Definition at line 1330 of file cmd_pef.c.

References config_destroy_handler(), locked_list_destroy(), and locked_list_iterate().

Referenced by ipmi_cmdlang_cleanup().

01331 {
01332     locked_list_iterate(pefs, config_destroy_handler, NULL);
01333     locked_list_destroy(pefs);
01334     pefs = NULL;
01335 }

static void out_guid (  ipmi_cmd_info_t *  cmd_info,
char *  name,
ipmi_pef_config_t *  lanc,
void *  func
)  [static]
 

Definition at line 369 of file cmd_pef.c.

References i, ipmi_cmdlang_out(), and s.

00371 {
00372     int            rv;
00373     int            (*f)(ipmi_pef_config_t *l, unsigned char *v,
00374                         unsigned int *dl) = func;
00375     unsigned char  v[16];
00376     unsigned int   len = sizeof(v);
00377     char           str[33];
00378     char           *s;
00379     int            i;
00380     
00381     rv = f(lanc, (unsigned char *) &v, &len);
00382     if (!rv) {
00383         s = str;
00384         for (i=0; i<16; i++)
00385             s += sprintf(s, "%2.2x", v[i]);
00386         ipmi_cmdlang_out(cmd_info, name, str);
00387     }
00388 }

static void out_int (  ipmi_cmd_info_t *  cmd_info,
char *  name,
ipmi_pef_config_t *  lanc,
void *  func
)  [static]
 

Definition at line 320 of file cmd_pef.c.

References ipmi_cmdlang_out_int().

00322 {
00323     unsigned int   v;
00324     int            rv;
00325     int            (*f)(ipmi_pef_config_t *l, unsigned int *v) = func;
00326     
00327     rv = f(lanc, &v);
00328     if (!rv)
00329         ipmi_cmdlang_out_int(cmd_info, name, v);
00330 }

static void out_retbool (  ipmi_cmd_info_t *  cmd_info,
char *  name,
ipmi_pef_config_t *  lanc,
void *  func
)  [static]
 

Definition at line 295 of file cmd_pef.c.

References ipmi_cmdlang_out_bool().

00297 {
00298     unsigned int   (*f)(ipmi_pef_config_t *l) = func;
00299     ipmi_cmdlang_out_bool(cmd_info, name, f(lanc));
00300 }

static void out_retint (  ipmi_cmd_info_t *  cmd_info,
char *  name,
ipmi_pef_config_t *  lanc,
void *  func
)  [static]
 

Definition at line 270 of file cmd_pef.c.

References ipmi_cmdlang_out_int().

00272 {
00273     unsigned int   (*f)(ipmi_pef_config_t *l) = func;
00274     ipmi_cmdlang_out_int(cmd_info, name, f(lanc));
00275 }

static void pef_close (  ipmi_pef_t *  pef,
void *  cb_data
)  [static]
 

Definition at line 179 of file cmd_pef.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_pef_destroy(), ipmi_pef_get_name(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and pef_close_done().

00180 {
00181     ipmi_cmd_info_t *cmd_info = cb_data;
00182     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00183     int             rv;
00184 
00185     ipmi_cmdlang_cmd_info_get(cmd_info);
00186     rv = ipmi_pef_destroy(pef, pef_close_done, cmd_info);
00187     if (rv) {
00188         ipmi_cmdlang_cmd_info_put(cmd_info);
00189         ipmi_pef_get_name(pef, cmdlang->objstr,
00190                               cmdlang->objstr_len);
00191         cmdlang->errstr = "Error closing PEF";
00192         cmdlang->err = rv;
00193         cmdlang->location = "cmd_pef.c(pef_close)";
00194     }
00195 }

static void pef_close_done (  ipmi_pef_t *  pef,
int  err,
void *  cb_data
)  [static]
 

Definition at line 154 of file cmd_pef.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_unlock(), ipmi_pef_get_name(), IPMI_PEF_NAME_LEN, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by pef_close().

00155 {
00156     ipmi_cmd_info_t *cmd_info = cb_data;
00157     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00158     char            pef_name[IPMI_PEF_NAME_LEN];
00159 
00160     ipmi_cmdlang_lock(cmd_info);
00161     if (err) {
00162         ipmi_pef_get_name(pef, cmdlang->objstr,
00163                           cmdlang->objstr_len);
00164         cmdlang->errstr = "Error closing PEF";
00165         cmdlang->err = err;
00166         cmdlang->location = "cmd_pef.c(pef_close_done)";
00167         goto out;
00168     }
00169 
00170     ipmi_pef_get_name(pef, pef_name, sizeof(pef_name));
00171     ipmi_cmdlang_out(cmd_info, "PEF destroyed", pef_name);
00172 
00173  out:
00174     ipmi_cmdlang_unlock(cmd_info);
00175     ipmi_cmdlang_cmd_info_put(cmd_info);
00176 }

static void pef_config_close (  ipmi_cmd_info_t *  cmd_info  )  [static]
 

Definition at line 901 of file cmd_pef.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, find_config(), ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_out(), ipmi_pef_free_config(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

00902 {
00903     ipmi_cmdlang_t    *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00904     int               curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
00905     int               argc = ipmi_cmdlang_get_argc(cmd_info);
00906     char              **argv = ipmi_cmdlang_get_argv(cmd_info);
00907     ipmi_pef_config_t *lanc;
00908     char              *lanc_name;
00909 
00910     if ((argc - curr_arg) < 1) {
00911         /* Not enough parameters */
00912         cmdlang->errstr = "Not enough parameters";
00913         cmdlang->err = EINVAL;
00914         lanc_name = "";
00915         goto out_err;
00916     }
00917     lanc_name = argv[curr_arg];
00918 
00919     lanc = find_config(lanc_name, 1);
00920     if (!lanc) {
00921         cmdlang->errstr = "Invalid PEF config";
00922         cmdlang->err = EINVAL;
00923         goto out_err;
00924     }
00925 
00926     ipmi_pef_free_config(lanc);
00927     ipmi_cmdlang_out(cmd_info, "PEF config destroyed", lanc_name);
00928     return;
00929 
00930  out_err:
00931     strncpy(cmdlang->objstr, lanc_name, cmdlang->objstr_len);
00932     cmdlang->location = "cmd_pef.c(pef_config_close)";
00933 }

static void pef_config_get (  ipmi_pef_t *  pef,
void *  cb_data
)  [static]
 

Definition at line 710 of file cmd_pef.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_pef_get_config(), ipmi_pef_get_name(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and pef_config_get_done().

00711 {
00712     ipmi_cmd_info_t *cmd_info = cb_data;
00713     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00714     int             rv;
00715 
00716     ipmi_cmdlang_cmd_info_get(cmd_info);
00717     rv = ipmi_pef_get_config(pef, pef_config_get_done, cmd_info);
00718     if (rv) {
00719         ipmi_pef_get_name(pef, cmdlang->objstr,
00720                               cmdlang->objstr_len);
00721         ipmi_cmdlang_cmd_info_put(cmd_info);
00722         cmdlang->errstr = "Error getting PEF";
00723         cmdlang->err = rv;
00724         cmdlang->location = "cmd_pef.c(pef_config_get)";
00725     }
00726 }

static void pef_config_get_done (  ipmi_pef_t *  pef,
int  err,
ipmi_pef_config_t *  config,
void *  cb_data
)  [static]
 

Definition at line 655 of file cmd_pef.c.

References cmdlang, config_info(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_mem_alloc(), ipmi_mem_free(), ipmi_pef_free_config(), ipmi_pef_get_name(), IPMI_PEF_NAME_LEN, ipmi_cmdlang_s::location, locked_list_add(), ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and unique_num.

Referenced by pef_config_get().

00659 {
00660     ipmi_cmd_info_t   *cmd_info = cb_data;
00661     ipmi_cmdlang_t    *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00662     char              pef_name[IPMI_PEF_NAME_LEN];
00663     pef_config_info_t *info;
00664 
00665     ipmi_cmdlang_lock(cmd_info);
00666     if (err) {
00667         cmdlang->errstr = "Error getting PEF";
00668         cmdlang->err = err;
00669         goto out;
00670     }
00671 
00672     ipmi_pef_get_name(pef, pef_name, sizeof(pef_name));
00673 
00674     info = ipmi_mem_alloc(sizeof(*info));
00675     if (!info) {
00676         cmdlang->errstr = "Out of memory";
00677         cmdlang->err = ENOMEM;
00678         ipmi_pef_free_config(config);
00679         goto out;
00680     }
00681     snprintf(info->name, sizeof(info->name), "%s.%u",
00682              pef_name, unique_num);
00683     info->config = config;
00684     if (!locked_list_add(pefs, info, NULL)) {
00685         cmdlang->errstr = "Out of memory";
00686         cmdlang->err = ENOMEM;
00687         ipmi_pef_free_config(config);
00688         ipmi_mem_free(info);
00689         goto out;
00690     }
00691     unique_num++;
00692 
00693     ipmi_cmdlang_out(cmd_info, "PEF Config", NULL);
00694     ipmi_cmdlang_down(cmd_info);
00695     ipmi_cmdlang_out(cmd_info, "Name", info->name);
00696     config_info(cmd_info, config);
00697     ipmi_cmdlang_up(cmd_info);
00698 
00699  out:
00700     if (cmdlang->err) {
00701         ipmi_pef_get_name(pef, cmdlang->objstr,
00702                               cmdlang->objstr_len);
00703         cmdlang->location = "cmd_pef.c(pef_config_get_done)";
00704     }
00705     ipmi_cmdlang_unlock(cmd_info);
00706     ipmi_cmdlang_cmd_info_put(cmd_info);
00707 }

static void pef_config_info (  ipmi_cmd_info_t *  cmd_info  )  [static]
 

Definition at line 969 of file cmd_pef.c.

References cmdlang, config_info(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, find_config(), ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_down(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), ipmi_cmdlang_s::location, locked_list_iterate(), ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and pef_config_info_handler().

00970 {
00971     ipmi_cmdlang_t    *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00972     int               curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
00973     int               argc = ipmi_cmdlang_get_argc(cmd_info);
00974     char              **argv = ipmi_cmdlang_get_argv(cmd_info);
00975     ipmi_pef_config_t *lanc;
00976 
00977     if ((argc - curr_arg) < 1) {
00978         locked_list_iterate(pefs, pef_config_info_handler, cmd_info);
00979     } else {
00980         lanc = find_config(argv[curr_arg], 0);
00981         if (!lanc) {
00982             cmdlang->errstr = "Invalid PEF config";
00983             cmdlang->err = EINVAL;
00984             goto out_err;
00985         }
00986         ipmi_cmdlang_out(cmd_info, "PEF Config", NULL);
00987         ipmi_cmdlang_down(cmd_info);
00988         ipmi_cmdlang_out(cmd_info, "Name", argv[curr_arg]);
00989         config_info(cmd_info, lanc);
00990         ipmi_cmdlang_up(cmd_info);
00991     }
00992     return;
00993 
00994  out_err:
00995     strncpy(cmdlang->objstr, argv[curr_arg], cmdlang->objstr_len);
00996     cmdlang->location = "cmd_pef.c(pef_config_info)";
00997 }

static int pef_config_info_handler (  void *  cb_data,
void *  item1,
void *  item2
)  [static]
 

Definition at line 955 of file cmd_pef.c.

References pef_config_info_s::config, config_info(), ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), LOCKED_LIST_ITER_CONTINUE, and pef_config_info_s::name.

Referenced by pef_config_info().

00956 {
00957     ipmi_cmd_info_t   *cmd_info = cb_data;
00958     pef_config_info_t *info = item1;
00959 
00960     ipmi_cmdlang_out(cmd_info, "PEF Config", NULL);
00961     ipmi_cmdlang_down(cmd_info);
00962     ipmi_cmdlang_out(cmd_info, "Name", info->name);
00963     config_info(cmd_info, info->config);
00964     ipmi_cmdlang_up(cmd_info);
00965     return LOCKED_LIST_ITER_CONTINUE;
00966 }

static void pef_config_list (  ipmi_cmd_info_t *  cmd_info  )  [static]
 

Definition at line 946 of file cmd_pef.c.

References ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), locked_list_iterate(), and pef_config_list_handler().

00947 {
00948     ipmi_cmdlang_out(cmd_info, "PEF Configs", NULL);
00949     ipmi_cmdlang_down(cmd_info);
00950     locked_list_iterate(pefs, pef_config_list_handler, cmd_info);
00951     ipmi_cmdlang_up(cmd_info);
00952 }

static int pef_config_list_handler (  void *  cb_data,
void *  item1,
void *  item2
)  [static]
 

Definition at line 936 of file cmd_pef.c.

References ipmi_cmdlang_out(), LOCKED_LIST_ITER_CONTINUE, and pef_config_info_s::name.

Referenced by pef_config_list().

00937 {
00938     ipmi_cmd_info_t   *cmd_info = cb_data;
00939     pef_config_info_t *info = item1;
00940 
00941     ipmi_cmdlang_out(cmd_info, "Name", info->name);
00942     return LOCKED_LIST_ITER_CONTINUE;
00943 }

static void pef_config_set (  ipmi_pef_t *  pef,
void *  cb_data
)  [static]
 

Definition at line 762 of file cmd_pef.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, find_config(), ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_mem_alloc(), ipmi_mem_free(), ipmi_pef_get_name(), ipmi_pef_set_config(), ipmi_cmdlang_s::location, name, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and pef_config_set_done().

Referenced by start_config_set_cb().

00763 {
00764     ipmi_cmd_info_t   *cmd_info = cb_data;
00765     ipmi_cmdlang_t    *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00766     int               rv;
00767     int               curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
00768     int               argc = ipmi_cmdlang_get_argc(cmd_info);
00769     char              **argv = ipmi_cmdlang_get_argv(cmd_info);
00770     ipmi_pef_config_t *lanc;
00771     pef_config_op_t   *info;
00772     char              *name;
00773 
00774     if ((argc - curr_arg) < 1) {
00775         /* Not enough parameters */
00776         cmdlang->errstr = "Not enough parameters";
00777         cmdlang->err = EINVAL;
00778         goto out_err;
00779     }
00780 
00781     name = argv[curr_arg];
00782     curr_arg++;
00783     lanc = find_config(name, 0);
00784     if (!lanc) {
00785         cmdlang->errstr = "Invalid PEF config";
00786         cmdlang->err = EINVAL;
00787         goto out_err;
00788     }
00789 
00790     info = ipmi_mem_alloc(sizeof(*info));
00791     if (!info) {
00792         cmdlang->errstr = "Out of memory";
00793         cmdlang->err = ENOMEM;
00794         goto out_err;
00795     }
00796     info->cmd_info = cmd_info;
00797     strncpy(info->name, name, sizeof(info->name));
00798 
00799     ipmi_cmdlang_cmd_info_get(cmd_info);
00800     rv = ipmi_pef_set_config(pef, lanc, pef_config_set_done, info);
00801     if (rv) {
00802         ipmi_cmdlang_cmd_info_put(cmd_info);
00803         cmdlang->errstr = "Error setting PEF";
00804         cmdlang->err = rv;
00805         ipmi_mem_free(info);
00806         goto out_err;
00807     }
00808 
00809     return;
00810 
00811  out_err:
00812     ipmi_pef_get_name(pef, cmdlang->objstr,
00813                           cmdlang->objstr_len);
00814     cmdlang->location = "cmd_pef.c(pef_config_set)";
00815 }

static void pef_config_set_done (  ipmi_pef_t *  pef,
int  err,
void *  cb_data</