Skip to content

Commit a7fb94a

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 0db43bc commit a7fb94a

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
@@ -305,9 +305,10 @@ static void sensor_and_poll_triggers_send(void)
305305
/* Delayable work used to send messages on the TIMER_CHAN */
306306
static void timer_work_fn(struct k_work *work)
307307
{
308-
ARG_UNUSED(work);
308+
int err;
309+
int dummy = 0;
309310

310-
int err, dummy = 0;
311+
ARG_UNUSED(work);
311312

312313
err = zbus_chan_pub(&TIMER_CHAN, &dummy, K_SECONDS(1));
313314
if (err) {
@@ -357,6 +358,7 @@ static void idle_entry(void *o)
357358
LOG_DBG("%s", __func__);
358359

359360
#if defined(CONFIG_APP_LED)
361+
int err;
360362
/* Blink Yellow */
361363
struct led_msg led_msg = {
362364
.type = LED_RGB_SET,
@@ -368,16 +370,15 @@ static void idle_entry(void *o)
368370
.repetitions = 10,
369371
};
370372

371-
int err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
372-
373+
err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
373374
if (err) {
374375
LOG_ERR("zbus_chan_pub, error: %d", err);
375376
SEND_FATAL_ERROR();
376377
return;
377378
}
378379
#endif /* CONFIG_APP_LED */
379380

380-
k_work_cancel_delayable(&trigger_work);
381+
(void)k_work_cancel_delayable(&trigger_work);
381382
}
382383

383384
static void idle_run(void *o)
@@ -395,6 +396,8 @@ static void idle_run(void *o)
395396

396397
static void triggering_entry(void *o)
397398
{
399+
int err;
400+
398401
ARG_UNUSED(o);
399402

400403
LOG_DBG("%s", __func__);
@@ -411,16 +414,20 @@ static void triggering_entry(void *o)
411414
.repetitions = 10,
412415
};
413416

414-
int err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
415-
417+
err = zbus_chan_pub(&LED_CHAN, &led_msg, K_SECONDS(1));
416418
if (err) {
417419
LOG_ERR("zbus_chan_pub, error: %d", err);
418420
SEND_FATAL_ERROR();
419421
return;
420422
}
421423
#endif /* CONFIG_APP_LED */
422424

423-
k_work_reschedule(&trigger_work, K_NO_WAIT);
425+
err = k_work_reschedule(&trigger_work, K_NO_WAIT);
426+
if (err) {
427+
LOG_ERR("k_work_reschedule, error: %d", err);
428+
SEND_FATAL_ERROR();
429+
return;
430+
}
424431
}
425432

426433
static void triggering_run(void *o)
@@ -435,8 +442,16 @@ static void triggering_run(void *o)
435442
}
436443

437444
if (state_object->chan == &CONFIG_CHAN) {
445+
int err;
446+
438447
LOG_DBG("Configuration update, new interval: %lld", state_object->interval_sec);
439-
k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
448+
449+
err = k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
450+
if (err) {
451+
LOG_ERR("k_work_reschedule, error: %d", err);
452+
SEND_FATAL_ERROR();
453+
}
454+
440455
return;
441456
}
442457
}
@@ -445,13 +460,13 @@ static void triggering_run(void *o)
445460

446461
static void requesting_location_entry(void *o)
447462
{
463+
int err;
464+
enum location_msg_type location_msg = LOCATION_SEARCH_TRIGGER;
465+
448466
ARG_UNUSED(o);
449467

450468
LOG_DBG("%s", __func__);
451469

452-
int err;
453-
enum location_msg_type location_msg = LOCATION_SEARCH_TRIGGER;
454-
455470
err = zbus_chan_pub(&LOCATION_CHAN, &location_msg, K_SECONDS(1));
456471
if (err) {
457472
LOG_ERR("zbus_chan_pub data sample trigger, error: %d", err);
@@ -480,6 +495,7 @@ static void requesting_location_run(void *o)
480495

481496
static void requesting_sensors_and_polling_entry(void *o)
482497
{
498+
int err;
483499
const struct main_state *state_object = (const struct main_state *)o;
484500

485501
LOG_DBG("%s", __func__);
@@ -488,7 +504,11 @@ static void requesting_sensors_and_polling_entry(void *o)
488504

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

491-
k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
507+
err = k_work_reschedule(&trigger_work, K_SECONDS(state_object->interval_sec));
508+
if (err) {
509+
LOG_ERR("k_work_reschedule, error: %d", err);
510+
SEND_FATAL_ERROR();
511+
}
492512
}
493513

494514
static void requesting_sensors_and_polling_run(void *o)
@@ -512,7 +532,7 @@ static void requesting_sensors_and_polling_exit(void *o)
512532

513533
LOG_DBG("%s", __func__);
514534

515-
k_work_cancel_delayable(&trigger_work);
535+
(void)k_work_cancel_delayable(&trigger_work);
516536
}
517537

518538
/* STATE_FOTA */
@@ -523,7 +543,7 @@ static void fota_entry(void *o)
523543

524544
LOG_DBG("%s", __func__);
525545

526-
k_work_cancel_delayable(&trigger_work);
546+
(void)k_work_cancel_delayable(&trigger_work);
527547
}
528548

529549
static void fota_run(void *o)
@@ -572,15 +592,15 @@ static void fota_downloading_run(void *o)
572592

573593
static void fota_network_disconnect_entry(void *o)
574594
{
575-
ARG_UNUSED(o);
576-
577-
LOG_DBG("%s", __func__);
578-
579595
int err;
580596
struct network_msg msg = {
581597
.type = NETWORK_DISCONNECT
582598
};
583599

600+
ARG_UNUSED(o);
601+
602+
LOG_DBG("%s", __func__);
603+
584604
err = zbus_chan_pub(&NETWORK_CHAN, &msg, K_SECONDS(1));
585605
if (err) {
586606
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
@@ -439,13 +439,14 @@ static void state_reboot_needed_entry(void *o)
439439

440440
static void state_canceling_entry(void *o)
441441
{
442+
int err;
443+
442444
ARG_UNUSED(o);
443445

444446
LOG_DBG("%s", __func__);
445447
LOG_DBG("Canceling download");
446448

447-
int err = fota_download_cancel();
448-
449+
err = fota_download_cancel();
449450
if (err) {
450451
LOG_ERR("fota_download_cancel, error: %d", err);
451452
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)