wimax: no need to check return value of debugfs_create functions

When calling debugfs functions, there is no need to ever check the return value. The function can work or not, but the code logic should never do something different based on this. This cleans up a lot of unneeded code and logic around the debugfs wimax files, making all of this much simpler and easier to understand.

Greg Kroah-Hartman committed 7 years ago

Commit a62052b1 parent 38b9e0f8 files · +51 −257Browse files

Unified · Split

8 files

drivers/net/wimax/i2400m/debugfs.c +23 −127
drivers/net/wimax/i2400m/driver.c +1 −6
drivers/net/wimax/i2400m/i2400m.h +2 −5
drivers/net/wimax/i2400m/usb.c +11 −53
include/linux/wimax/debug.h +3 −17
net/wimax/debugfs.c +8 −34
net/wimax/stack.c +1 −10
net/wimax/wimax-internal.h +2 −5

drivers/net/wimax/i2400m/debugfs.c+23−127

@@ -30,15 +30,6 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_netdev_queue_stopped, · 29 unmodified lines
30	30	debugfs_netdev_queue_stopped_get,
31	31	NULL, "%llu\n");
32	32
33		−
34		−static
35		−struct dentry *debugfs_create_netdev_queue_stopped(
36		− const char name, struct dentry parent, struct i2400m *i2400m)
37		−{
38		− return debugfs_create_file(name, 0400, parent, i2400m,
39		− &fops_netdev_queue_stopped);
40		−}
41		−
42	33	/*
43	34	* We don't allow partial reads of this file, as then the reader would
44	35	* get weirdly confused data as it is updated.
@@ -167,15 +158,6 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_suspend, · 122 unmodified lines
167	158	NULL, debugfs_i2400m_suspend_set,
168	159	"%llu\n");
169	160
170		−static
171		−struct dentry *debugfs_create_i2400m_suspend(
172		− const char name, struct dentry parent, struct i2400m *i2400m)
173		−{
174		− return debugfs_create_file(name, 0200, parent, i2400m,
175		− &fops_i2400m_suspend);
176		−}
177		−
178		−
179	161	/*
180	162	* Reset the device
181	163	*
@@ -205,73 +187,25 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_i2400m_reset, · 23 unmodified lines
205	187	NULL, debugfs_i2400m_reset_set,
206	188	"%llu\n");
207	189
208		−static
209		−struct dentry *debugfs_create_i2400m_reset(
210		− const char name, struct dentry parent, struct i2400m *i2400m)
	190	+void i2400m_debugfs_add(struct i2400m *i2400m)
211	191	{
212		− return debugfs_create_file(name, 0200, parent, i2400m,
213		− &fops_i2400m_reset);
214		−}
215		−
216		−
217		−#define __debugfs_register(prefix, name, parent) \
218		−do { \
219		− result = d_level_register_debugfs(prefix, name, parent); \
220		− if (result < 0) \
221		− goto error; \
222		−} while (0)
223		−
224		−
225		−int i2400m_debugfs_add(struct i2400m *i2400m)
226		−{
227		− int result;
228		− struct device *dev = i2400m_dev(i2400m);
229	192	struct dentry *dentry = i2400m->wimax_dev.debugfs_dentry;
230		− struct dentry *fd;
231	193
232	194	dentry = debugfs_create_dir("i2400m", dentry);
233		− result = PTR_ERR(dentry);
234		− if (IS_ERR(dentry)) {
235		− if (result == -ENODEV)
236		− result = 0; /* No debugfs support */
237		− goto error;
238		− }
239	195	i2400m->debugfs_dentry = dentry;
240		− __debugfs_register("dl_", control, dentry);
241		− __debugfs_register("dl_", driver, dentry);
242		− __debugfs_register("dl_", debugfs, dentry);
243		− __debugfs_register("dl_", fw, dentry);
244		− __debugfs_register("dl_", netdev, dentry);
245		− __debugfs_register("dl_", rfkill, dentry);
246		− __debugfs_register("dl_", rx, dentry);
247		− __debugfs_register("dl_", tx, dentry);
248		−
249		− fd = debugfs_create_size_t("tx_in", 0400, dentry,
250		− &i2400m->tx_in);
251		− result = PTR_ERR(fd);
252		− if (IS_ERR(fd) && result != -ENODEV) {
253		− dev_err(dev, "Can't create debugfs entry "
254		− "tx_in: %d\n", result);
255		− goto error;
256		− }
257	196
258		− fd = debugfs_create_size_t("tx_out", 0400, dentry,
259		− &i2400m->tx_out);
260		− result = PTR_ERR(fd);
261		− if (IS_ERR(fd) && result != -ENODEV) {
262		− dev_err(dev, "Can't create debugfs entry "
263		− "tx_out: %d\n", result);
264		− goto error;
265		− }
	197	+ d_level_register_debugfs("dl_", control, dentry);
	198	+ d_level_register_debugfs("dl_", driver, dentry);
	199	+ d_level_register_debugfs("dl_", debugfs, dentry);
	200	+ d_level_register_debugfs("dl_", fw, dentry);
	201	+ d_level_register_debugfs("dl_", netdev, dentry);
	202	+ d_level_register_debugfs("dl_", rfkill, dentry);
	203	+ d_level_register_debugfs("dl_", rx, dentry);
	204	+ d_level_register_debugfs("dl_", tx, dentry);
266	205
267		− fd = debugfs_create_u32("state", 0600, dentry,
268		− &i2400m->state);
269		− result = PTR_ERR(fd);
270		− if (IS_ERR(fd) && result != -ENODEV) {
271		− dev_err(dev, "Can't create debugfs entry "
272		− "state: %d\n", result);
273		− goto error;
274		− }
	206	+ debugfs_create_size_t("tx_in", 0400, dentry, &i2400m->tx_in);
	207	+ debugfs_create_size_t("tx_out", 0400, dentry, &i2400m->tx_out);
	208	+ debugfs_create_u32("state", 0600, dentry, &i2400m->state);
275	209
276	210	/*
277	211	* Trace received messages from user space
@@ -295,60 +229,22 @@ int i2400m_debugfs_add(struct i2400m *i2400m) · 17 unmodified lines
295	229	* It is not really very atomic, but it is also not too
296	230	* critical.
297	231	*/
298		− fd = debugfs_create_u8("trace_msg_from_user", 0600, dentry,
299		− &i2400m->trace_msg_from_user);
300		− result = PTR_ERR(fd);
301		− if (IS_ERR(fd) && result != -ENODEV) {
302		− dev_err(dev, "Can't create debugfs entry "
303		− "trace_msg_from_user: %d\n", result);
304		− goto error;
305		− }
	232	+ debugfs_create_u8("trace_msg_from_user", 0600, dentry,
	233	+ &i2400m->trace_msg_from_user);
306	234
307		− fd = debugfs_create_netdev_queue_stopped("netdev_queue_stopped",
308		− dentry, i2400m);
309		− result = PTR_ERR(fd);
310		− if (IS_ERR(fd) && result != -ENODEV) {
311		− dev_err(dev, "Can't create debugfs entry "
312		− "netdev_queue_stopped: %d\n", result);
313		− goto error;
314		− }
	235	+ debugfs_create_file("netdev_queue_stopped", 0400, dentry, i2400m,
	236	+ &fops_netdev_queue_stopped);
315	237
316		− fd = debugfs_create_file("rx_stats", 0600, dentry, i2400m,
317		− &i2400m_rx_stats_fops);
318		− result = PTR_ERR(fd);
319		− if (IS_ERR(fd) && result != -ENODEV) {
320		− dev_err(dev, "Can't create debugfs entry "
321		− "rx_stats: %d\n", result);
322		− goto error;
323		− }
	238	+ debugfs_create_file("rx_stats", 0600, dentry, i2400m,
	239	+ &i2400m_rx_stats_fops);
324	240
325		− fd = debugfs_create_file("tx_stats", 0600, dentry, i2400m,
326		− &i2400m_tx_stats_fops);
327		− result = PTR_ERR(fd);
328		− if (IS_ERR(fd) && result != -ENODEV) {
329		− dev_err(dev, "Can't create debugfs entry "
330		− "tx_stats: %d\n", result);
331		− goto error;
332		− }
	241	+ debugfs_create_file("tx_stats", 0600, dentry, i2400m,
	242	+ &i2400m_tx_stats_fops);
333	243
334		− fd = debugfs_create_i2400m_suspend("suspend", dentry, i2400m);
335		− result = PTR_ERR(fd);
336		− if (IS_ERR(fd) && result != -ENODEV) {
337		− dev_err(dev, "Can't create debugfs entry suspend: %d\n",
338		− result);
339		− goto error;
340		− }
	244	+ debugfs_create_file("suspend", 0200, dentry, i2400m,
	245	+ &fops_i2400m_suspend);
341	246
342		− fd = debugfs_create_i2400m_reset("reset", dentry, i2400m);
343		− result = PTR_ERR(fd);
344		− if (IS_ERR(fd) && result != -ENODEV) {
345		− dev_err(dev, "Can't create debugfs entry reset: %d\n", result);
346		− goto error;
347		− }
348		−
349		− result = 0;
350		−error:
351		− return result;
	247	+ debugfs_create_file("reset", 0200, dentry, i2400m, &fops_i2400m_reset);
352	248	}
353	249
354	250	void i2400m_debugfs_rm(struct i2400m *i2400m)

drivers/net/wimax/i2400m/driver.c+1−6

@@ -905,11 +905,7 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags) · 904 unmodified lines
905	905	goto error_sysfs_setup;
906	906	}
907	907
908		− result = i2400m_debugfs_add(i2400m);
909		− if (result < 0) {
910		− dev_err(dev, "cannot setup i2400m's debugfs: %d\n", result);
911		− goto error_debugfs_setup;
912		− }
	908	+ i2400m_debugfs_add(i2400m);
913	909
914	910	result = i2400m_dev_start(i2400m, bm_flags);
915	911	if (result < 0)
@@ -919,7 +915,6 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags) · 3 unmodified lines
919	915
920	916	error_dev_start:
921	917	i2400m_debugfs_rm(i2400m);
922		−error_debugfs_setup:
923	918	sysfs_remove_group(&i2400m->wimax_dev.net_dev->dev.kobj,
924	919	&i2400m_dev_attr_group);
925	920	error_sysfs_setup:

drivers/net/wimax/i2400m/i2400m.h+2−5

@@ -812,13 +812,10 @@ enum i2400m_pt; · 811 unmodified lines
812	812	int i2400m_tx(struct i2400m , const void , size_t, enum i2400m_pt);
813	813
814	814	#ifdef CONFIG_DEBUG_FS
815		−int i2400m_debugfs_add(struct i2400m *);
	815	+void i2400m_debugfs_add(struct i2400m *);
816	816	void i2400m_debugfs_rm(struct i2400m *);
817	817	#else
818		−static inline int i2400m_debugfs_add(struct i2400m *i2400m)
819		−{
820		− return 0;
821		−}
	818	+static inline void i2400m_debugfs_add(struct i2400m *i2400m) {}
822	819	static inline void i2400m_debugfs_rm(struct i2400m *i2400m) {}
823	820	#endif
824	821

drivers/net/wimax/i2400m/usb.c+11−53

@@ -366,61 +366,25 @@ struct d_level D_LEVEL[] = { · 365 unmodified lines
366	366	};
367	367	size_t D_LEVEL_SIZE = ARRAY_SIZE(D_LEVEL);
368	368
369		−
370		−#define __debugfs_register(prefix, name, parent) \
371		−do { \
372		− result = d_level_register_debugfs(prefix, name, parent); \
373		− if (result < 0) \
374		− goto error; \
375		−} while (0)
376		−
377		−
378	369	static
379		−int i2400mu_debugfs_add(struct i2400mu *i2400mu)
	370	+void i2400mu_debugfs_add(struct i2400mu *i2400mu)
380	371	{
381		− int result;
382		− struct device *dev = &i2400mu->usb_iface->dev;
383	372	struct dentry *dentry = i2400mu->i2400m.wimax_dev.debugfs_dentry;
384		− struct dentry *fd;
385	373
386	374	dentry = debugfs_create_dir("i2400m-usb", dentry);
387		− result = PTR_ERR(dentry);
388		− if (IS_ERR(dentry)) {
389		− if (result == -ENODEV)
390		− result = 0; /* No debugfs support */
391		− goto error;
392		− }
393	375	i2400mu->debugfs_dentry = dentry;
394		− __debugfs_register("dl_", usb, dentry);
395		− __debugfs_register("dl_", fw, dentry);
396		− __debugfs_register("dl_", notif, dentry);
397		− __debugfs_register("dl_", rx, dentry);
398		− __debugfs_register("dl_", tx, dentry);
399	376
400		− /* Don't touch these if you don't know what you are doing */
401		− fd = debugfs_create_u8("rx_size_auto_shrink", 0600, dentry,
402		− &i2400mu->rx_size_auto_shrink);
403		− result = PTR_ERR(fd);
404		− if (IS_ERR(fd) && result != -ENODEV) {
405		− dev_err(dev, "Can't create debugfs entry "
406		− "rx_size_auto_shrink: %d\n", result);
407		− goto error;
408		− }
	377	+ d_level_register_debugfs("dl_", usb, dentry);
	378	+ d_level_register_debugfs("dl_", fw, dentry);
	379	+ d_level_register_debugfs("dl_", notif, dentry);
	380	+ d_level_register_debugfs("dl_", rx, dentry);
	381	+ d_level_register_debugfs("dl_", tx, dentry);
409	382
410		− fd = debugfs_create_size_t("rx_size", 0600, dentry,
411		− &i2400mu->rx_size);
412		− result = PTR_ERR(fd);
413		− if (IS_ERR(fd) && result != -ENODEV) {
414		− dev_err(dev, "Can't create debugfs entry "
415		− "rx_size: %d\n", result);
416		− goto error;
417		− }
418		−
419		− return 0;
	383	+ /* Don't touch these if you don't know what you are doing */
	384	+ debugfs_create_u8("rx_size_auto_shrink", 0600, dentry,
	385	+ &i2400mu->rx_size_auto_shrink);
420	386
421		−error:
422		− debugfs_remove_recursive(i2400mu->debugfs_dentry);
423		− return result;
	387	+ debugfs_create_size_t("rx_size", 0600, dentry, &i2400mu->rx_size);
424	388	}
425	389
426	390
@@ -534,15 +498,9 @@ int i2400mu_probe(struct usb_interface *iface, · 107 unmodified lines
534	498	dev_err(dev, "cannot setup device: %d\n", result);
535	499	goto error_setup;
536	500	}
537		− result = i2400mu_debugfs_add(i2400mu);
538		− if (result < 0) {
539		− dev_err(dev, "Can't register i2400mu's debugfs: %d\n", result);
540		− goto error_debugfs_add;
541		− }
	501	+ i2400mu_debugfs_add(i2400mu);
542	502	return 0;
543	503
544		−error_debugfs_add:
545		− i2400m_release(i2400m);
546	504	error_setup:
547	505	usb_set_intfdata(iface, NULL);
548	506	usb_put_dev(i2400mu->usb_dev);

include/linux/wimax/debug.h+3−17

@@ -98,9 +98,7 @@ · 97 unmodified lines
98	98	* To manipulate from user space the levels, create a debugfs dentry
99	99	* and then register each submodule with:
100	100	*
101		− * result = d_level_register_debugfs("PREFIX_", submodule_X, parent);
102		− * if (result < 0)
103		− * goto error;
	101	+ * d_level_register_debugfs("PREFIX_", submodule_X, parent);
104	102	*
105	103	* Where PREFIX_ is a name of your chosing. This will create debugfs
106	104	* file with a single numeric value that can be use to tweak it. To
@@ -408,25 +406,13 @@ do { \ · 301 unmodified lines
408	406	* @submodule: name of submodule (not a string, just the name)
409	407	* @dentry: debugfs parent dentry
410	408	*
411		− * Returns: 0 if ok, < 0 errno on error.
412		− *
413	409	* For removing, just use debugfs_remove_recursive() on the parent.
414	410	*/
415	411	#define d_level_register_debugfs(prefix, name, parent) \
416	412	({ \
417		− int rc; \
418		− struct dentry *fd; \
419		− struct dentry *verify_parent_type = parent; \
420		− fd = debugfs_create_u8( \
421		− prefix #name, 0600, verify_parent_type, \
	413	+ debugfs_create_u8( \
	414	+ prefix #name, 0600, parent, \
422	415	&(D_LEVEL[__D_SUBMODULE_ ## name].level)); \
423		− rc = PTR_ERR(fd); \
424		− if (IS_ERR(fd) && rc != -ENODEV) \
425		− printk(KERN_ERR "%s: Can't create debugfs entry %s: " \
426		− "%d\n", __func__, prefix #name, rc); \
427		− else \
428		− rc = 0; \
429		− rc; \
430	416	})
431	417
432	418

net/wimax/debugfs.c+8−34

@@ -13,49 +13,23 @@ · 12 unmodified lines
13	13	#define D_SUBMODULE debugfs
14	14	#include "debug-levels.h"
15	15
16		−
17		−#define __debugfs_register(prefix, name, parent) \
18		−do { \
19		− result = d_level_register_debugfs(prefix, name, parent); \
20		− if (result < 0) \
21		− goto error; \
22		−} while (0)
23		−
24		−
25		−int wimax_debugfs_add(struct wimax_dev *wimax_dev)
	16	+void wimax_debugfs_add(struct wimax_dev *wimax_dev)
26	17	{
27		− int result;
28	18	struct net_device *net_dev = wimax_dev->net_dev;
29		− struct device *dev = net_dev->dev.parent;
30	19	struct dentry *dentry;
31	20	char buf[128];
32	21
33	22	snprintf(buf, sizeof(buf), "wimax:%s", net_dev->name);
34	23	dentry = debugfs_create_dir(buf, NULL);
35		− result = PTR_ERR(dentry);
36		− if (IS_ERR(dentry)) {
37		− if (result == -ENODEV)
38		− result = 0; /* No debugfs support */
39		− else
40		− dev_err(dev, "Can't create debugfs dentry: %d\n",
41		− result);
42		− goto out;
43		− }
44	24	wimax_dev->debugfs_dentry = dentry;
45		− __debugfs_register("wimax_dl_", debugfs, dentry);
46		− __debugfs_register("wimax_dl_", id_table, dentry);
47		− __debugfs_register("wimax_dl_", op_msg, dentry);
48		− __debugfs_register("wimax_dl_", op_reset, dentry);
49		− __debugfs_register("wimax_dl_", op_rfkill, dentry);
50		− __debugfs_register("wimax_dl_", op_state_get, dentry);
51		− __debugfs_register("wimax_dl_", stack, dentry);
52		− result = 0;
53		−out:
54		− return result;
55	25
56		−error:
57		− debugfs_remove_recursive(wimax_dev->debugfs_dentry);
58		− return result;
	26	+ d_level_register_debugfs("wimax_dl_", debugfs, dentry);
	27	+ d_level_register_debugfs("wimax_dl_", id_table, dentry);
	28	+ d_level_register_debugfs("wimax_dl_", op_msg, dentry);
	29	+ d_level_register_debugfs("wimax_dl_", op_reset, dentry);
	30	+ d_level_register_debugfs("wimax_dl_", op_rfkill, dentry);
	31	+ d_level_register_debugfs("wimax_dl_", op_state_get, dentry);
	32	+ d_level_register_debugfs("wimax_dl_", stack, dentry);
59	33	}
60	34
61	35	void wimax_debugfs_rm(struct wimax_dev *wimax_dev)

net/wimax/stack.c+1−10

@@ -481,12 +481,7 @@ int wimax_dev_add(struct wimax_dev wimax_dev, struct net_device net_dev) · 480 unmodified lines
481	481	/* Set up user-space interaction */
482	482	mutex_lock(&wimax_dev->mutex);
483	483	wimax_id_table_add(wimax_dev);
484		− result = wimax_debugfs_add(wimax_dev);
485		− if (result < 0) {
486		− dev_err(dev, "cannot initialize debugfs: %d\n",
487		− result);
488		− goto error_debugfs_add;
489		− }
	484	+ wimax_debugfs_add(wimax_dev);
490	485
491	486	__wimax_state_set(wimax_dev, WIMAX_ST_DOWN);
492	487	mutex_unlock(&wimax_dev->mutex);
@@ -498,10 +493,6 @@ int wimax_dev_add(struct wimax_dev wimax_dev, struct net_device net_dev) · 5 unmodified lines
498	493	d_fnend(3, dev, "(wimax_dev %p net_dev %p) = 0\n", wimax_dev, net_dev);
499	494	return 0;
500	495
501		−error_debugfs_add:
502		− wimax_id_table_rm(wimax_dev);
503		− mutex_unlock(&wimax_dev->mutex);
504		− wimax_rfkill_rm(wimax_dev);
505	496	error_rfkill_add:
506	497	d_fnend(3, dev, "(wimax_dev %p net_dev %p) = %d\n",
507	498	wimax_dev, net_dev, result);

net/wimax/wimax-internal.h+2−5

@@ -57,13 +57,10 @@ void __wimax_state_set(struct wimax_dev *wimax_dev, enum wimax_st state) · 56 unmodified lines
57	57	void __wimax_state_change(struct wimax_dev *, enum wimax_st);
58	58
59	59	#ifdef CONFIG_DEBUG_FS
60		−int wimax_debugfs_add(struct wimax_dev *);
	60	+void wimax_debugfs_add(struct wimax_dev *);
61	61	void wimax_debugfs_rm(struct wimax_dev *);
62	62	#else
63		−static inline int wimax_debugfs_add(struct wimax_dev *wimax_dev)
64		−{
65		− return 0;
66		−}
	63	+static inline void wimax_debugfs_add(struct wimax_dev *wimax_dev) {}
67	64	static inline void wimax_debugfs_rm(struct wimax_dev *wimax_dev) {}
68	65	#endif
69	66

wimax: no need to check return value of debugfs_create functions

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code