Skip to content

Commit ff82f03

Browse files
jtguggedaljtguggedal
committed
modules: Add return value checks
Check all non-void functions' return values, or explicitly void where error handling is not relevant. Signed-off-by: Jan Tore Guggedal <jantore.guggedal@nordicsemi.no>
1 parent 6e41a4a commit ff82f03

File tree

7 files changed

+166
-103
lines changed

7 files changed

+166
-103
lines changed

‎app/src/main.c

+39-19
Original file line numberDiff line numberDiff line change
@@ -310,9 +310,10 @@ static void sensor_and_poll_triggers_send(void)
310310
/* Delayable work used to send messages on the TIMER_CHAN */
311311
static void timer_work_fn(struct k_work *work)
312312
{
313-
ARG_UNUSED(work);
313+
int err;
314+
int dummy = 0;
314315

315-
int err, dummy = 0;
316+
ARG_UNUSED(work);
316317

317318
err = zbus_chan_pub(&TIMER_CHAN, &dummy, K_SECONDS(1));
318319
if (err) {
@@ -363,6 +364,7 @@ static void idle_entry(void *o)
363364
LOG_DBG("%s", __func__);
364365

365366
#if defined(CONFIG_APP_LED)
367+
int err;
366368
/* Blink Yellow */
367369
struct led_msg led_msg = {
368370
.type = LED_RGB_SET,
@@ -374,16 +376,15 @@ static void idle_entry(void *o)
374376
.repetitions = 10,
375377
};
376378

377-
int err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
378-
379+
err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
379380
if (err) {
380381
LOG_ERR("zbus_chan_pub, error: %d", err);
381382
SEND_FATAL_ERROR();
382383
return;
383384
}
384385
#endif /* CONFIG_APP_LED */
385386

386-
k_work_cancel_delayable(&trigger_work);
387+
(void)k_work_cancel_delayable(&trigger_work);
387388
}
388389

389390
static void idle_run(void *o)
@@ -405,6 +406,8 @@ static void idle_run(void *o)
405406

406407
static void triggering_entry(void *o)
407408
{
409+
int err;
410+
408411
ARG_UNUSED(o);
409412

410413
LOG_DBG("%s", __func__);
@@ -421,16 +424,20 @@ static void triggering_entry(void *o)
421424
.repetitions = 10,
422425
};
423426

424-
int err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
425-
427+
err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
426428
if (err) {
427429
LOG_ERR("zbus_chan_pub, error: %d", err);
428430
SEND_FATAL_ERROR();
429431
return;
430432
}
431433
#endif /* CONFIG_APP_LED */
432434

433-
k_work_reschedule(&trigger_work, K_NO_WAIT);
435+
err = k_work_reschedule(&trigger_work, K_NO_WAIT);
436+
if (err < 0) {
437+
LOG_ERR("k_work_reschedule, error: %d", err);
438+
SEND_FATAL_ERROR();
439+
return;
440+
}
434441
}
435442

436443
static void triggering_run(void *o)
@@ -452,11 +459,19 @@ static void triggering_run(void *o)
452459
struct configuration config = MSG_TO_CONFIGURATION(state_object->msg_buf);
453460

454461
if (config.config_present) {
462+
int err;
463+
455464
LOG_DBG("Configuration update, new interval: %lld", config.update_interval);
456465

457466
state_object->interval_sec = config.update_interval;
458467

459-
k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
468+
err = k_work_reschedule(&trigger_work,
469+
K_SECONDS(state_object->interval_sec));
470+
if (err < 0) {
471+
LOG_ERR("k_work_reschedule, error: %d", err);
472+
SEND_FATAL_ERROR();
473+
}
474+
460475
return;
461476
}
462477
}
@@ -466,13 +481,13 @@ static void triggering_run(void *o)
466481

467482
static void requesting_location_entry(void *o)
468483
{
484+
int err;
485+
enum location_msg_type location_msg = LOCATION_SEARCH_TRIGGER;
486+
469487
ARG_UNUSED(o);
470488

471489
LOG_DBG("%s", __func__);
472490

473-
int err;
474-
enum location_msg_type location_msg = LOCATION_SEARCH_TRIGGER;
475-
476491
err = zbus_chan_pub(&LOCATION_CHAN, &location_msg, K_SECONDS(1));
477492
if (err) {
478493
LOG_ERR("zbus_chan_pub data sample trigger, error: %d", err);
@@ -505,6 +520,7 @@ static void requesting_location_run(void *o)
505520

506521
static void requesting_sensors_and_polling_entry(void *o)
507522
{
523+
int err;
508524
const struct main_state *state_object = (const struct main_state *)o;
509525

510526
LOG_DBG("%s", __func__);
@@ -513,7 +529,11 @@ static void requesting_sensors_and_polling_entry(void *o)
513529

514530
LOG_DBG("Next trigger in %lld seconds", state_object->interval_sec);
515531

516-
k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
532+
err = k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
533+
if (err < 0) {
534+
LOG_ERR("k_work_reschedule, error: %d", err);
535+
SEND_FATAL_ERROR();
536+
}
517537
}
518538

519539
static void requesting_sensors_and_polling_run(void *o)
@@ -537,7 +557,7 @@ static void requesting_sensors_and_polling_exit(void *o)
537557

538558
LOG_DBG("%s", __func__);
539559

540-
k_work_cancel_delayable(&trigger_work);
560+
(void)k_work_cancel_delayable(&trigger_work);
541561
}
542562

543563
/* STATE_FOTA */
@@ -548,7 +568,7 @@ static void fota_entry(void *o)
548568

549569
LOG_DBG("%s", __func__);
550570

551-
k_work_cancel_delayable(&trigger_work);
571+
(void)k_work_cancel_delayable(&trigger_work);
552572
}
553573

554574
static void fota_run(void *o)
@@ -602,15 +622,15 @@ static void fota_downloading_run(void *o)
602622

603623
static void fota_waiting_for_network_disconnect_entry(void *o)
604624
{
605-
ARG_UNUSED(o);
606-
607-
LOG_DBG("%s", __func__);
608-
609625
int err;
610626
struct network_msg msg = {
611627
.type = NETWORK_DISCONNECT
612628
};
613629

630+
ARG_UNUSED(o);
631+
632+
LOG_DBG("%s", __func__);
633+
614634
err = zbus_chan_pub(&NETWORK_CHAN, &msg, K_SECONDS(1));
615635
if (err) {
616636
LOG_ERR("zbus_chan_pub, error: %d", err);

‎app/src/modules/cloud/cloud_module.c

+7-2
Original file line numberDiff line numberDiff line change
@@ -400,13 +400,18 @@ static void state_connecting_attempt_entry(void *o)
400400

401401
static void state_connecting_backoff_entry(void *o)
402402
{
403+
int err;
403404
struct cloud_state *state_object = o;
404405

405406
LOG_DBG("%s", __func__);
406407

407408
state_object->backoff_time = calculate_backoff_time(state_object->connection_attempts);
408409

409-
k_work_schedule(&backoff_timer_work, K_SECONDS(state_object->backoff_time));
410+
err = k_work_schedule(&backoff_timer_work, K_SECONDS(state_object->backoff_time));
411+
if (err < 0) {
412+
LOG_ERR("k_work_schedule, error: %d", err);
413+
SEND_FATAL_ERROR();
414+
}
410415
}
411416

412417
static void state_connecting_backoff_run(void *o)
@@ -430,7 +435,7 @@ static void state_connecting_backoff_exit(void *o)
430435

431436
LOG_DBG("%s", __func__);
432437

433-
k_work_cancel_delayable(&backoff_timer_work);
438+
(void)k_work_cancel_delayable(&backoff_timer_work);
434439
}
435440

436441
/* Handler for STATE_CLOUD_CONNECTED. */

‎app/src/modules/fota/fota.c

+3-2
Original file line numberDiff line numberDiff line change
@@ -459,13 +459,14 @@ static void state_reboot_pending_entry(void *o)
459459

460460
static void state_canceling_entry(void *o)
461461
{
462+
int err;
463+
462464
ARG_UNUSED(o);
463465

464466
LOG_DBG("%s", __func__);
465467
LOG_DBG("Canceling download");
466468

467-
int err = fota_download_cancel();
468-
469+
err = fota_download_cancel();
469470
if (err) {
470471
LOG_ERR("fota_download_cancel, error: %d", err);
471472
SEND_FATAL_ERROR();

‎app/src/modules/led/led.c

+26-5
Original file line numberDiff line numberDiff line change
@@ -106,12 +106,18 @@ static int pwm_out(const struct led_msg *led_msg, bool force_off)
106106
/* Timer work handler for LED blinking */
107107
static void blink_timer_handler(struct k_work *work)
108108
{
109+
int err;
110+
109111
ARG_UNUSED(work);
110112

111113
led_is_on = !led_is_on;
112114

113115
/* Update LED state */
114-
pwm_out(&current_led_state, !led_is_on);
116+
err = pwm_out(&current_led_state, !led_is_on);
117+
if (err) {
118+
LOG_ERR("pwm_out, error: %d", err);
119+
SEND_FATAL_ERROR();
120+
}
115121

116122
/* If LED just turned off, we completed one cycle */
117123
if (!led_is_on && remaining_cycles > 0) {
@@ -127,17 +133,22 @@ static void blink_timer_handler(struct k_work *work)
127133
current_led_state.duration_on_msec :
128134
current_led_state.duration_off_msec;
129135

130-
k_work_schedule(&blink_work, K_MSEC(next_delay));
136+
err = k_work_schedule(&blink_work, K_MSEC(next_delay));
137+
if (err < 0) {
138+
LOG_ERR("k_work_schedule, error: %d", err);
139+
SEND_FATAL_ERROR();
140+
}
131141
}
132142

133143
/* Function called when there is a message received on a channel that the module listens to */
134144
static void led_callback(const struct zbus_channel *chan)
135145
{
136146
if (&LED_CHAN == chan) {
147+
int err;
137148
const struct led_msg *led_msg = zbus_chan_const_msg(chan);
138149

139150
/* Cancel any existing blink timer */
140-
k_work_cancel_delayable(&blink_work);
151+
(void)k_work_cancel_delayable(&blink_work);
141152

142153
/* Store the new LED state */
143154
memcpy(&current_led_state, led_msg, sizeof(struct led_msg));
@@ -147,18 +158,28 @@ static void led_callback(const struct zbus_channel *chan)
147158

148159
/* Start with LED on */
149160
led_is_on = true;
150-
pwm_out(led_msg, false);
161+
162+
err = pwm_out(led_msg, false);
163+
if (err) {
164+
LOG_ERR("pwm_out, error: %d", err);
165+
SEND_FATAL_ERROR();
166+
}
151167

152168
/* Schedule first toggle if we have cycles to do */
153169
if (remaining_cycles != 0 || led_msg->repetitions == -1) {
154-
k_work_schedule(&blink_work, K_MSEC(led_msg->duration_on_msec));
170+
err = k_work_schedule(&blink_work, K_MSEC(led_msg->duration_on_msec));
171+
if (err < 0) {
172+
LOG_ERR("k_work_schedule, error: %d", err);
173+
SEND_FATAL_ERROR();
174+
}
155175
}
156176
}
157177
}
158178

159179
static int led_init(void)
160180
{
161181
k_work_init_delayable(&blink_work, blink_timer_handler);
182+
162183
return 0;
163184
}
164185

0 commit comments

Comments
 (0)