Explorando la calidad del código del sistema operativo Zephyr

PlatformIO

PVS-Studio

• Ventanas Visual Studio 2010-2019 C, C ++, C ++ / CLI, C ++ / CX (WinRT)
• Ventanas IAR Embedded Workbench, compilador C / C ++ para ARM C, C ++
• Ventanas QNX Momentics, QCC C, C ++
• Windows / Linux Keil µVision, DS-MDK, compilador ARM 5/6 C, C ++
• Windows / Linux Texas Instruments Code Composer Studio, Herramientas de generación de código ARM C, C ++
• Windows/Linux/macOS. GNU Arm Embedded Toolchain, Arm Embedded GCC compiler, C, C++
• Windows/Linux/macOS. Clang C, C++
• Linux/macOS. GCC C, C++
• Windows. MinGW C, C++

Céfiro

• Espacio de direcciones unificadas. El código de aplicación específico en combinación con el núcleo personalizado crea una imagen monolítica que se ejecuta en el dispositivo.
• . , .
• . .
• . . .
• : , , , , .

Calidad del código Zephyr

• PVS-Studio 122 High 367 Medium. , , 560 C/C++ . . 7810 C/C++ 10075 . , . , , .
• . «» , .
• La utilidad SourceMonitor , después de analizar el código fuente, dio estadísticas de que el 48% del código son comentarios. Esto es mucho y en mi experiencia indica una gran preocupación por la calidad del código, su comprensión para otros desarrolladores.
• Al desarrollar un proyecto, se utiliza un analizador de código estático Coverity. Probablemente, debido a este hecho, el analizador PVS-Studio, aunque encontró errores en el proyecto, no pudo mostrarse vívidamente, como a veces sucede al analizar otros proyectos.

Advertencias semifalsas

static struct char_framebuffer char_fb;

int cfb_framebuffer_invert(struct device *dev)
{
  struct char_framebuffer *fb = &char_fb;

  if (!fb || !fb->buf) {
    return -1;
  }

  fb->inverted = !fb->inverted;

  return 0;
}

int hex2char(u8_t x, char *c)
{
  if (x <= 9) {
    *c = x + '0';
  } else if (x >= 10 && x <= 15) {
    *c = x - 10 + 'a';
  } else {
    return -EINVAL;
  }
  return 0;
}

} else if (x <= 15) {

#if defined(CONFIG_ASSERT_ON_ERRORS)
#define CHECKIF(expr) \
  __ASSERT_NO_MSG(!(expr));   \
  if (0)
#elif defined(CONFIG_NO_RUNTIME_CHECKS)
#define CHECKIF(...) \
  if (0)
#else
#define CHECKIF(expr) \
  if (expr)
#endif

#define CHECKIF(expr) \
  if (expr)

int k_queue_append_list(struct k_queue *queue, void *head, void *tail)
{
  CHECKIF(head == NULL || tail == NULL) {
    return -EINVAL;
  }

  k_spinlock_key_t key = k_spin_lock(&queue->lock);
  struct k_thread *thread = NULL;
  if (head != NULL) {
    thread = z_unpend_first_thread(&queue->wait_q);
  }
  ....
}

CHECKIF(head == NULL || tail == NULL) {
  return -EINVAL;
}

if (head == NULL || tail == NULL) {
  return -EINVAL;
}

if (0) {
  return -EINVAL;
}

Advertencias de caso

1. . : , , , Coverity. , PVS-Studio - , .
2. . , «» . , . GitHub, PVS-Studio.

static void gen_prov_ack(struct prov_rx *rx, struct net_buf_simple *buf)
{
  ....
  if (link.tx.cb && link.tx.cb) {
    link.tx.cb(0, link.tx.cb_data);
  }
  ....
}

#if defined(CONFIG_NET_HOSTNAME_ENABLE)
const char *net_hostname_get(void);
#else
static inline const char *net_hostname_get(void)
{
  return "zephyr";
}
#endif

static inline const char *net_hostname_get(void)
{
  return "zephyr";
}

static int do_net_init(void)
{
  ....
  (void)memcpy(hostname, net_hostname_get(), MAX_HOSTNAME_LEN);
  ....
}

(void)memcpy(hostname, net_hostname_get(),
    sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx"));

int do_write_op_json(struct lwm2m_message *msg)
{
  u8_t value[TOKEN_BUF_LEN];
  u8_t base_name[MAX_RESOURCE_LEN];
  u8_t full_name[MAX_RESOURCE_LEN];
  ....
  /* combine base_name + name */
  snprintf(full_name, TOKEN_BUF_LEN, "%s%s", base_name, value);
  ....
}

u8_t value[64];
u8_t base_name[20];
u8_t full_name[20];
....
snprintf(full_name, 64, "%s%s", base_name, value);

static int keys_set(const char *name, size_t len_rd, settings_read_cb read_cb,
                    void *cb_arg)
{
  ....
  size_t len;
  ....
  len = read_cb(cb_arg, val, sizeof(val));
  if (len < 0) {
    BT_ERR("Failed to read value (err %zu)", len);
    return -EINVAL;
  }
  ....
}

static inline int mesh_x_set(....)
{
 ssize_t len;
 len = read_cb(cb_arg, out, read_len);
 if (len < 0) {
 ....
}

static u8_t read_cb(const struct bt_gatt_attr *attr, void *user_data)

static char *mntpt_prepare(char *mntpt)
{
  char *cpy_mntpt;

  cpy_mntpt = k_malloc(strlen(mntpt) + 1);
  if (cpy_mntpt) {
    ((u8_t *)mntpt)[strlen(mntpt)] = '\0';
    memcpy(cpy_mntpt, mntpt, strlen(mntpt));
  }
  return cpy_mntpt;
}

((u8_t *)mntpt)[strlen(mntpt)] = '\0';

((u8_t *)cpy_mntpt)[strlen(mntpt)] = '\0';

static char *mntpt_prepare(char *mntpt)
{
  char *cpy_mntpt;

  cpy_mntpt = k_malloc(strlen(mntpt) + 1);
  if (cpy_mntpt) {
    strcpy(cpy_mntpt, mntpt);
  }
  return cpy_mntpt;
}

int bt_mesh_model_publish(struct bt_mesh_model *model)
{
  ....
  struct bt_mesh_model_pub *pub = model->pub;
  ....
  struct bt_mesh_msg_ctx ctx = {
    .send_rel = pub->send_rel,
  };
  ....
  if (!pub) {
    return -ENOTSUP;
  }
  ....
}

.send_rel = pub->send_rel,

int net_tcp_accept(struct net_context *context, net_tcp_accept_cb_t cb,
                   void *user_data)
{
  ....
  struct tcp *conn = context->tcp;
  ....
  conn->accept_cb = cb;

  if (!conn || conn->state != TCP_LISTEN) {
    return -EINVAL;
  }
  ....
}

• V595 [CWE-476] El puntero 'context-> tcp' se utilizó antes de que se verificara contra nullptr. Líneas de verificación: 1512, 1518. tcp.c 1512
• V595 [CWE-476] El puntero 'fsm' se utilizó antes de que se verificara contra nullptr. Líneas de verificación: 365, 382. fsm.c 365

static int x509_get_subject_alt_name( unsigned char **p,
                                      const unsigned char *end,
                                      mbedtls_x509_sequence *subject_alt_name)
{
  ....
    while( *p < end )
    {
        if( ( end - *p ) < 1 )
            return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
                    MBEDTLS_ERR_ASN1_OUT_OF_DATA );
    ....
  }
  ....
}

• * p <fin
• (final - * p) <1

uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp)
{
    if(!disp) disp = lv_disp_get_default();
    if(!disp) {
        LV_LOG_WARN("lv_disp_get_inactive_time: no display registered");
        return 0;
    }

    if(disp) return lv_tick_elaps(disp->last_activity_time);

    lv_disp_t * d;
    uint32_t t = UINT32_MAX;
    d          = lv_disp_get_next(NULL);
    while(d) {
        t = LV_MATH_MIN(t, lv_tick_elaps(d->last_activity_time));
        d = lv_disp_get_next(d);
    }

    return t;
}

static size_t put_end_tlv(struct lwm2m_output_context *out, u16_t mark_pos,
        u8_t *writer_flags, u8_t writer_flag,
        int tlv_type, int tlv_id)
{
  struct tlv_out_formatter_data *fd;
  struct oma_tlv tlv;
  u32_t len = 0U;

  fd = engine_get_out_user_data(out);
  if (!fd) {
    return 0;
  }

  *writer_flags &= ~writer_flag;

  len = out->out_cpkt->offset - mark_pos;

  /* use stored location */
  fd->mark_pos = mark_pos;

  /* set instance length */
  tlv_setup(&tlv, tlv_type, tlv_id, len);
  len = oma_tlv_put(&tlv, out, NULL, true) - tlv.length;
  return 0;
}

  len = oma_tlv_put(&tlv, out, NULL, true) - tlv.length;
  return len;
}

static int nvs_startup(struct nvs_fs *fs)
{
  ....
  k_mutex_lock(&fs->nvs_lock, K_FOREVER);
  ....
  if (fs->ate_wra == fs->data_wra && last_ate.len) {
    return -ESPIPE;
  }
  ....
end:
  k_mutex_unlock(&fs->nvs_lock);
  return rc;
}

static int nvs_startup(struct nvs_fs *fs)
{
  ....
  k_mutex_lock(&fs->nvs_lock, K_FOREVER);
  ....
  if (fs->ate_wra == fs->data_wra && last_ate.len) {
    rc = -ESPIPE;
    goto end;
  }
  ....
end:
  k_mutex_unlock(&fs->nvs_lock);
  return rc;
}

• V1020 La función salió sin llamar a la función 'k_mutex_unlock'. Líneas de verificación: 574, 549. nvs.c 574
• V1020 La función salió sin llamar a la función 'k_mutex_unlock'. Líneas de verificación: 908, 890. net_context.c 908
• V1020 La función salió sin llamar a la función 'k_mutex_unlock'. Líneas de verificación: 1194, 1189. shell.c 1194

Conclusión