C++ (Cpp) ipmi_thresholds_size Examples

Example #1

File: sample3.c Project: sharkconi/openipmi

static sdata_t *
alloc_sdata(ipmi_sensor_t *sensor)
{
    sdata_t *sdata;

    sdata = malloc(sizeof(*sdata));
    if (!sdata)
	return NULL;

    sdata->es = malloc(ipmi_event_state_size());
    if (!sdata->es) {
	free(sdata);
	return NULL;
    }
    ipmi_event_state_init(sdata->es);

    sdata->th = malloc(ipmi_thresholds_size());
    if (!sdata->th) {
	free(sdata->es);
	free(sdata);
	return NULL;
    }
    ipmi_thresholds_init(sdata->th);

    sdata->refcount = 1;

    sdata->sensor_id = ipmi_sensor_convert_to_id(sensor);
    ipmi_sensor_get_name(sensor, sdata->name, sizeof(sdata->name));

    sdata->next = sdata_list;
    sdata->prev = NULL;
    sdata_list = sdata;

    return sdata;
}

Example #2

File: ipmi_sensor.c Project: openhpi1/testrepo

SaErrorT orig_set_sensor_thresholds(struct oh_handler_state *handler,
				    struct ohoi_sensor_info *sensor_info,
				    const SaHpiSensorThresholdsT *thres)
{
	struct ohoi_handler	*ipmi_handler =
					(struct ohoi_handler *)(handler->data);
        struct ohoi_sensor_thresholds	thres_data;
        int				rv;
		ipmi_sensor_id_t		sensor_id;

	sensor_id = sensor_info->info.orig_sensor_info.sensor_id;

	memset(&thres_data, 0, sizeof(thres_data));
	thres_data.thrhlds = malloc(ipmi_thresholds_size()); 
	if (thres_data.thrhlds == NULL) {
		dbg("could not alloc memory");
		return SA_ERR_HPI_OUT_OF_MEMORY;
	}
       
	thres_data.sensor_thres = *thres;
        
        rv = ipmi_sensor_pointer_cb(sensor_id,
				    set_sensor_thresholds,
				    &thres_data);
		
        if (rv) {
		dbg("Unable to convert sensor_id to pointer");
		free(thres_data.thrhlds);
                return SA_ERR_HPI_INVALID_CMD;
	}

	rv = ohoi_loop_until(is_get_sensor_thresholds_done, 
                               &thres_data, OHOI_TIMEOUT, ipmi_handler);
	free(thres_data.thrhlds);
	if (rv != SA_OK) {
		return rv;
	}
	if (thres_data.rvalue) {
		return thres_data.rvalue;
	}
	return SA_OK;
}

Example #3

File: cmd_sensor.c Project: ystk/debian-openipmi

static void
sensor_set_thresholds(ipmi_sensor_t *sensor, void *cb_data)
{
    ipmi_cmd_info_t    *cmd_info = cb_data;
    ipmi_cmdlang_t     *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
    int                rv;
    int                curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
    int                argc = ipmi_cmdlang_get_argc(cmd_info);
    char               **argv = ipmi_cmdlang_get_argv(cmd_info);
    ipmi_thresholds_t  *th = NULL;
    enum ipmi_thresh_e thresh;
    double             val;

    if ((argc - curr_arg) < 1) {
	/* Not enough parameters */
	cmdlang->errstr = "Not enough parameters";
	cmdlang->err = EINVAL;
	goto out_err;
    }

    th = ipmi_mem_alloc(ipmi_thresholds_size());
    if (!th) {
	cmdlang->errstr = "Out of memory";
	cmdlang->err = ENOMEM;
	goto out_err;
    }
    ipmi_thresholds_init(th);
    while (curr_arg < argc) {
	ipmi_cmdlang_get_threshold(argv[curr_arg], &thresh, cmd_info);
	if (cmdlang->err) {
	    cmdlang->errstr = "Invalid threshold";
	    goto out_err;
	}
	curr_arg++;

	ipmi_cmdlang_get_double(argv[curr_arg], &val, cmd_info);
	if (cmdlang->err) {
	    cmdlang->errstr = "Invalid threshold value";
	    goto out_err;
	}
	curr_arg++;

	rv = ipmi_threshold_set(th, sensor, thresh, val);
	if (rv) {
	    cmdlang->errstr = "Error setting value";
	    cmdlang->err = rv;
	    goto out_err;
	}
    }

    ipmi_cmdlang_cmd_info_get(cmd_info);
    rv = ipmi_sensor_set_thresholds(sensor, th, sensor_set_thresholds_done,
				    cmd_info);
    if (rv) {
	ipmi_cmdlang_cmd_info_put(cmd_info);
	cmdlang->err = rv;
	cmdlang->errstr = "Error setting thresholds";
	goto out_err;
    }
    ipmi_mem_free(th);
    return;

 out_err:
    ipmi_sensor_get_name(sensor, cmdlang->objstr,
			 cmdlang->objstr_len);
    cmdlang->location = "cmd_sensor.c(sensor_set_thresholds)";
    if (th)
	ipmi_mem_free(th);
}