Navigation

← Previous Changeset
Next Changeset →

Changeset 4667

Timestamp:

08/13/07 22:16:42 (1 year ago)

Author:

khali

Message:

Pass the structures by reference inside libsensors. Again a small
performance gain, and this makes the internal code consistent with the
public functions.

Files:

lm-sensors/branches/lm-sensors-3.0.0/lib/access.c (modified) (18 diffs)
lm-sensors/branches/lm-sensors-3.0.0/lib/init.c (modified) (7 diffs)
lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.c (modified) (6 diffs)
lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

lm-sensors/branches/lm-sensors-3.0.0/lib/access.c

r4666	r4667
28	28	#include "general.h"
29	29
30		static int sensors_eval_expr(~~sensors_chip_name chipname,~~
	30	static int sensors_eval_expr(const sensors_chip_name *name,
31	31	const sensors_expr *expr,
32	32	double val, double *result);
…	…
75	75	you want the match that was latest in the config file. */
76	76	static sensors_chip *
77		sensors_for_all_config_chips(~~sensors_chip_name chip_~~name,
	77	sensors_for_all_config_chips(const sensors_chip_name *name,
78	78	const sensors_chip *last)
79	79	{
…	…
86	86	chips = sensors_config_chips[nr].chips;
87	87	for (i = 0; i < chips.fits_count; i++) {
88		if (sensors_match_chip(&chips.fits[i], ~~&chip_~~name))
	88	if (sensors_match_chip(&chips.fits[i], name))
89	89	return sensors_config_chips + nr;
90	90	}
…	…
134	134	one chip, or whether it has wildcards. Returns 0 if it is absolute, 1
135	135	if there are wildcards. */
136		static int sensors_chip_name_has_wildcards(~~sensors_chip_name~~ chip)
137		{
138		if ((chip.prefix == SENSORS_CHIP_NAME_PREFIX_ANY) \|\|
139		(chip.bus == SENSORS_CHIP_NAME_BUS_ANY) \|\|
140		(chip.bus == SENSORS_CHIP_NAME_BUS_ANY_I2C) \|\|
141		(chip.addr == SENSORS_CHIP_NAME_ADDR_ANY))
	136	static int sensors_chip_name_has_wildcards(const sensors_chip_name *chip)
	137	{
	138	if ((chip->prefix == SENSORS_CHIP_NAME_PREFIX_ANY) \|\|
	139	(chip->bus == SENSORS_CHIP_NAME_BUS_ANY) \|\|
	140	(chip->bus == SENSORS_CHIP_NAME_BUS_ANY_I2C) \|\|
	141	(chip->addr == SENSORS_CHIP_NAME_ADDR_ANY))
142	142	return 1;
143	143	else
…	…
158	158
159	159	*result = NULL;
160		if (sensors_chip_name_has_wildcards(*name))
	160	if (sensors_chip_name_has_wildcards(name))
161	161	return -SENSORS_ERR_WILDCARDS;
162	162	if (!(featureptr = sensors_lookup_feature_nr(name, feature)))
163	163	return -SENSORS_ERR_NO_ENTRY;
164	164
165		for (chip = NULL; (chip = sensors_for_all_config_chips(*name, chip));)
	165	for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));)
166	166	for (i = 0; i < chip->labels_count; i++)
167	167	if (!strcasecmp(featureptr->data.name,chip->labels[i].name)){
…	…
211	211	feature->data.mapping)->data.name;
212	212
213		for (chip = NULL; (chip = sensors_for_all_config_chips(*name, chip));)
	213	for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));)
214	214	for (i = 0; i < chip->ignores_count; i++)
215	215	if (!strcasecmp(feature->data.name, chip->ignores[i].name) \|\|
…	…
234	234	int final_expr = 0;
235	235
236		if (sensors_chip_name_has_wildcards(*name))
	236	if (sensors_chip_name_has_wildcards(name))
237	237	return -SENSORS_ERR_WILDCARDS;
238	238	if (!(main_feature = sensors_lookup_feature_nr(name, feature)))
…	…
246	246	return -SENSORS_ERR_ACCESS_R;
247	247	for (chip = NULL;
248		!expr && (chip = sensors_for_all_config_chips(*name, chip));)
	248	!expr && (chip = sensors_for_all_config_chips(name, chip));)
249	249	for (i = 0; !final_expr && (i < chip->computes_count); i++) {
250	250	if (!strcasecmp(main_feature->data.name, chip->computes[i].name)) {
…	…
256	256	}
257	257	}
258		if (sensors_read_sysfs_attr(*name, feature, &val))
	258	if (sensors_read_sysfs_attr(name, feature, &val))
259	259	return -SENSORS_ERR_PROC;
260	260	if (!expr)
261	261	*result = val;
262		else if ((res = sensors_eval_expr(*name, expr, val, result)))
	262	else if ((res = sensors_eval_expr(name, expr, val, result)))
263	263	return res;
264	264	return 0;
…	…
279	279	double to_write;
280	280
281		if (sensors_chip_name_has_wildcards(*name))
	281	if (sensors_chip_name_has_wildcards(name))
282	282	return -SENSORS_ERR_WILDCARDS;
283	283	if (!(main_feature = sensors_lookup_feature_nr(name, feature)))
…	…
291	291	return -SENSORS_ERR_ACCESS_W;
292	292	for (chip = NULL;
293		!expr && (chip = sensors_for_all_config_chips(*name, chip));)
	293	!expr && (chip = sensors_for_all_config_chips(name, chip));)
294	294	for (i = 0; !final_expr && (i < chip->computes_count); i++)
295	295	if (!strcasecmp(main_feature->data.name, chip->computes[i].name)) {
…	…
303	303	to_write = value;
304	304	if (expr)
305		if ((res = sensors_eval_expr(*name, expr, value, &to_write)))
	305	if ((res = sensors_eval_expr(name, expr, value, &to_write)))
306	306	return res;
307		if (sensors_write_sysfs_attr(*name, feature, to_write))
	307	if (sensors_write_sysfs_attr(name, feature, to_write))
308	308	return -SENSORS_ERR_PROC;
309	309	return 0;
…	…
356	356
357	357	/* Evaluate an expression */
358		int sensors_eval_expr(sensors_chip_name chipname, const sensors_expr * expr,
	358	int sensors_eval_expr(const sensors_chip_name *name,
	359	const sensors_expr *expr,
359	360	double val, double *result)
360	361	{
…	…
372	373	}
373	374	if (expr->kind == sensors_kind_var) {
374		if (!(feature = sensors_lookup_feature_name(~~&chip~~name,
	375	if (!(feature = sensors_lookup_feature_name(name,
375	376	expr->data.var)))
376	377	return SENSORS_ERR_NO_ENTRY;
377		if (!(res = sensors_get_feature(~~&chip~~name, feature->data.number, result)))
	378	if (!(res = sensors_get_feature(name, feature->data.number, result)))
378	379	return res;
379	380	return 0;
380	381	}
381		if ((res = sensors_eval_expr(~~chip~~name, expr->data.subexpr.sub1, val, &res1)))
	382	if ((res = sensors_eval_expr(name, expr->data.subexpr.sub1, val, &res1)))
382	383	return res;
383	384	if (expr->data.subexpr.sub2 &&
384		(res = sensors_eval_expr(~~chip~~name, expr->data.subexpr.sub2, val, &res2)))
	385	(res = sensors_eval_expr(name, expr->data.subexpr.sub2, val, &res2)))
385	386	return res;
386	387	switch (expr->data.subexpr.op) {
…	…
417	418	contain wildcards! This function will return 0 on success, and <0 on
418	419	failure. */
419		static int sensors_do_this_chip_sets(~~sensors_chip_name~~ name)
	420	static int sensors_do_this_chip_sets(const sensors_chip_name *name)
420	421	{
421	422	sensors_chip *chip;
…	…
431	432	for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));)
432	433	for (i = 0; i < chip->sets_count; i++) {
433		feature = sensors_lookup_feature_name(&name,
	434	feature = sensors_lookup_feature_name(name,
434	435	chip->sets[i].name);
435	436	if (!feature) {
…	…
459	460	continue;
460	461	}
461		if ((res = sensors_set_feature(&name, feature_nr, value))) {
	462	if ((res = sensors_set_feature(name, feature_nr, value))) {
462	463	sensors_parse_error("Failed to set feature",
463	464	chip->sets[i].lineno);
…	…
480	481	for (nr = 0; (found_name = sensors_get_detected_chips(&nr));)
481	482	if (sensors_match_chip(name, found_name)) {
482		this_res = sensors_do_this_chip_sets(*found_name);
	483	this_res = sensors_do_this_chip_sets(found_name);
483	484	if (!res)
484	485	res = this_res;

lm-sensors/branches/lm-sensors-3.0.0/lib/init.c

r4545	r4667
28	28	#include "scanner.h"
29	29
30		static void free_chip_name(sensors_chip_name name);
	30	static void free_chip_name(sensors_chip_name *name);
31	31	static void free_chip_features(sensors_chip_feature *features);
32		static void free_bus(sensors_bus bus);
33		static void free_chip(sensors_chip chip);
34		static void free_label(sensors_label label);
35		static void free_set(sensors_set set);
36		static void free_compute(sensors_compute compute);
37		static void free_ignore(sensors_ignore ignore);
	32	static void free_bus(sensors_bus *bus);
	33	static void free_chip(sensors_chip *chip);
	34	static void free_label(sensors_label *label);
	35	static void free_set(sensors_set *set);
	36	static void free_compute(sensors_compute *compute);
	37	static void free_ignore(sensors_ignore *ignore);
38	38	static void free_expr(sensors_expr *expr);
39	39
…	…
62	62
63	63	for (i = 0; i < sensors_proc_chips_count; i++) {
64		free_chip_name(sensors_proc_chips[i].chip);
	64	free_chip_name(&sensors_proc_chips[i].chip);
65	65	free_chip_features(sensors_proc_chips[i].feature);
66	66	}
…	…
70	70
71	71	for (i = 0; i < sensors_config_busses_count; i++)
72		free_bus(sensors_config_busses[i]);
	72	free_bus(&sensors_config_busses[i]);
73	73	free(sensors_config_busses);
74	74	sensors_config_busses = NULL;
…	…
76	76
77	77	for (i = 0; i < sensors_config_chips_count; i++)
78		free_chip(sensors_config_chips[i]);
	78	free_chip(&sensors_config_chips[i]);
79	79	free(sensors_config_chips);
80	80	sensors_config_chips = NULL;
…	…
82	82
83	83	for (i = 0; i < sensors_proc_bus_count; i++)
84		free_bus(sensors_proc_bus[i]);
	84	free_bus(&sensors_proc_bus[i]);
85	85	free(sensors_proc_bus);
86	86	sensors_proc_bus = NULL;
…	…
88	88	}
89	89
90		void free_chip_name(sensors_chip_name name)
	90	void free_chip_name(sensors_chip_name *name)
91	91	{
92		free(name.prefix);
93		free(name.busname);
	92	free(name->prefix);
	93	free(name->busname);
94	94	}
95	95
…	…
103	103	}
104	104
105		void free_bus(sensors_bus bus)
	105	void free_bus(sensors_bus *bus)
106	106	{
107		free(bus.adapter);
	107	free(bus->adapter);
108	108	}
109	109
110		void free_chip(sensors_chip chip)
	110	void free_chip(sensors_chip *chip)
111	111	{
112	112	int i;
113	113
114		for (i = 0; i < chip.chips.fits_count; i++)
115		free_chip_name(~~chip.~~chips.fits[i]);
116		free(chip.chips.fits);
117		chip~~.chips.fits_count = chip.~~chips.fits_max = 0;
	114	for (i = 0; i < chip->chips.fits_count; i++)
	115	free_chip_name(&chip->chips.fits[i]);
	116	free(chip->chips.fits);
	117	chip->chips.fits_count = chip->chips.fits_max = 0;
118	118
119		for (i = 0; i < chip.labels_count; i++)
120		free_label(~~chip.~~labels[i]);
121		free(chip.labels);
122		chip~~.labels_count = chip.~~labels_max = 0;
	119	for (i = 0; i < chip->labels_count; i++)
	120	free_label(&chip->labels[i]);
	121	free(chip->labels);
	122	chip->labels_count = chip->labels_max = 0;
123	123
124		for (i = 0; i < chip.sets_count; i++)
125		free_set(~~chip.~~sets[i]);
126		free(chip.sets);
127		chip~~.sets_count = chip.~~sets_max = 0;
	124	for (i = 0; i < chip->sets_count; i++)
	125	free_set(&chip->sets[i]);
	126	free(chip->sets);
	127	chip->sets_count = chip->sets_max = 0;
128	128
129		for (i = 0; i < chip.computes_count; i++)
130		free_compute(~~chip.~~computes[i]);
131		free(chip.computes);
132		chip~~.computes_count = chip.~~computes_max = 0;
	129	for (i = 0; i < chip->computes_count; i++)
	130	free_compute(&chip->computes[i]);
	131	free(chip->computes);
	132	chip->computes_count = chip->computes_max = 0;
133	133
134		for (i = 0; i < chip.ignores_count; i++)
135		free_ignore(~~chip.~~ignores[i]);
136		free(chip.ignores);
137		chip~~.ignores_count = chip.~~ignores_max = 0;
	134	for (i = 0; i < chip->ignores_count; i++)
	135	free_ignore(&chip->ignores[i]);
	136	free(chip->ignores);
	137	chip->ignores_count = chip->ignores_max = 0;
138	138	}
139	139
140		void free_label(sensors_label label)
	140	void free_label(sensors_label *label)
141	141	{
142		free(label.name);
143		free(label.value);
	142	free(label->name);
	143	free(label->value);
144	144	}
145	145
146		void free_set(sensors_set set)
	146	void free_set(sensors_set *set)
147	147	{
148		free(set.name);
149		free_expr(set.value);
	148	free(set->name);
	149	free_expr(set->value);
150	150	}
151	151
152		void free_compute(sensors_compute compute)
	152	void free_compute(sensors_compute *compute)
153	153	{
154		free(compute.name);
155		free_expr(compute.from_proc);
156		free_expr(compute.to_proc);
	154	free(compute->name);
	155	free_expr(compute->from_proc);
	156	free_expr(compute->to_proc);
157	157	}
158	158
159		void free_ignore(sensors_ignore ignore)
	159	void free_ignore(sensors_ignore *ignore)
160	160	{
161		free(ignore.name);
	161	free(ignore->name);
162	162	}
163	163

lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.c

r4638	r4667
397	397	}
398	398
399		int sensors_read_sysfs_attr(sensors_chip_name name, int feature, double *value)
	399	int sensors_read_sysfs_attr(const sensors_chip_name *name, int feature,
	400	double *value)
400	401	{
401	402	const sensors_chip_feature *the_feature;
…	…
407	408	const char *suffix = "";
408	409
409		if (!(the_feature = sensors_lookup_feature_nr(&name, feature)))
	410	if (!(the_feature = sensors_lookup_feature_nr(name, feature)))
410	411	return -SENSORS_ERR_NO_ENTRY;
411	412
…	…
416	417	suffix = "_input";
417	418
418		snprintf(n, NAME_MAX, "%s/%s%s", name.busname, the_feature->data.name,
	419	snprintf(n, NAME_MAX, "%s/%s%s", name->busname, the_feature->data.name,
419	420	suffix);
420	421	if ((f = fopen(n, "r"))) {
…	…
431	432	}
432	433
433		int sensors_write_sysfs_attr(sensors_chip_name name, int feature, double value)
	434	int sensors_write_sysfs_attr(const sensors_chip_name *name, int feature,
	435	double value)
434	436	{
435	437	const sensors_chip_feature *the_feature;
…	…
441	443	const char *suffix = "";
442	444
443		if (!(the_feature = sensors_lookup_feature_nr(&name, feature)))
	445	if (!(the_feature = sensors_lookup_feature_nr(name, feature)))
444	446	return -SENSORS_ERR_NO_ENTRY;
445	447
…	…
450	452	suffix = "_input";
451	453
452		snprintf(n, NAME_MAX, "%s/%s%s", name.busname, the_feature->data.name,
	454	snprintf(n, NAME_MAX, "%s/%s%s", name->busname, the_feature->data.name,
453	455	suffix);
454	456	if ((f = fopen(n, "w"))) {

lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.h

r4553	r4667
30	30
31	31	/* Read a value out of a sysfs attribute file */
32		int sensors_read_sysfs_attr(sensors_chip_name name, int feature, double *value);
	32	int sensors_read_sysfs_attr(const sensors_chip_name *name, int feature,
	33	double *value);
33	34
34	35	/* Write a value to a sysfs attribute file */
35		int sensors_write_sysfs_attr(sensors_chip_name name, int feature, double value);
	36	int sensors_write_sysfs_attr(const sensors_chip_name *name, int feature,
	37	double value);
36	38
37	39	#endif /* !SENSORS_LIB_SYSFS_H */

Download in other formats: