Please PVS

- [V522] Don't use malloc() but only xbt_malloc()
  this deals "gracefully" with error conditions
- [V507] Don't leak references to local arrays to outer scope

diff --git a/examples/c/app-chainsend/broadcaster.c b/examples/c/app-chainsend/broadcaster.c
index ad60acd..9444caa 100644 (file)
--- a/examples/c/app-chainsend/broadcaster.c
+++ b/examples/c/app-chainsend/broadcaster.c
@@ -9,7 +9,7 @@ XBT_LOG_NEW_DEFAULT_CATEGORY(broadcaster, "Messages specific for the broadcaster
 
 static chain_message_t chain_message_new(sg_mailbox_t prev, sg_mailbox_t next, const unsigned int num_pieces)
 {
-  chain_message_t msg = (chain_message_t)malloc(sizeof(s_chain_message_t));
+  chain_message_t msg = xbt_malloc(sizeof(s_chain_message_t));
   msg->prev_          = prev;
   msg->next_          = next;
   msg->num_pieces     = num_pieces;
@@ -50,13 +50,13 @@ static void broadcaster_send_file(const_broadcaster_t bc)
 
 static broadcaster_t broadcaster_init(sg_mailbox_t* mailboxes, unsigned int host_count, unsigned int piece_count)
 {
-  broadcaster_t bc = (broadcaster_t)malloc(sizeof(s_broadcaster_t));
+  broadcaster_t bc = xbt_malloc(sizeof(s_broadcaster_t));
 
   bc->first         = NULL;
   bc->host_count    = host_count;
   bc->piece_count   = piece_count;
   bc->mailboxes     = mailboxes;
-  bc->pending_sends = (sg_comm_t*)malloc(sizeof(sg_comm_t) * MAX_PENDING_COMMS);
+  bc->pending_sends = xbt_malloc(sizeof(sg_comm_t) * MAX_PENDING_COMMS);
 
   broadcaster_build_chain(bc);
 
@@ -77,7 +77,7 @@ void broadcaster(int argc, char* argv[])
   xbt_assert(argc > 2);
   unsigned int host_count = xbt_str_parse_int(argv[1], "Invalid number of peers: %s");
 
-  sg_mailbox_t* mailboxes = (sg_mailbox_t*)malloc(sizeof(sg_mailbox_t) * host_count);
+  sg_mailbox_t* mailboxes = xbt_malloc(sizeof(sg_mailbox_t) * host_count);
 
   for (unsigned int i = 1; i <= host_count; i++) {
     char* name = bprintf("node-%u.simgrid.org", i);

diff --git a/examples/c/app-chainsend/chainsend.h b/examples/c/app-chainsend/chainsend.h
index 84caabb..48de28e 100644 (file)
--- a/examples/c/app-chainsend/chainsend.h
+++ b/examples/c/app-chainsend/chainsend.h
@@ -28,7 +28,7 @@
 /* Broadcaster struct */
 typedef struct s_broadcaster {
   unsigned int host_count;
-  int piece_count;
+  unsigned int piece_count;
   sg_mailbox_t first;
   sg_mailbox_t* mailboxes;
   sg_comm_t* pending_sends;

diff --git a/examples/c/app-chainsend/peer.c b/examples/c/app-chainsend/peer.c
index d49e9f7..8245908 100644 (file)
--- a/examples/c/app-chainsend/peer.c
+++ b/examples/c/app-chainsend/peer.c
@@ -58,13 +58,13 @@ static void peer_forward_file(peer_t p)
 
 static peer_t peer_init(XBT_ATTRIB_UNUSED int argc, XBT_ATTRIB_UNUSED char* argv[])
 {
-  peer_t p           = (peer_t)malloc(sizeof(s_peer_t));
+  peer_t p           = xbt_malloc(sizeof(s_peer_t));
   p->prev            = NULL;
   p->next            = NULL;
   p->received_pieces = 0;
   p->received_bytes  = 0;
-  p->pending_recvs   = (sg_comm_t*)malloc(sizeof(sg_comm_t) * MAX_PENDING_COMMS);
-  p->pending_sends   = (sg_comm_t*)malloc(sizeof(sg_comm_t) * MAX_PENDING_COMMS);
+  p->pending_recvs   = xbt_malloc(sizeof(sg_comm_t) * MAX_PENDING_COMMS);
+  p->pending_sends   = xbt_malloc(sizeof(sg_comm_t) * MAX_PENDING_COMMS);
 
   p->me = sg_mailbox_by_name(sg_host_self_get_name());
 

diff --git a/examples/c/app-masterworker/app-masterworker.c b/examples/c/app-masterworker/app-masterworker.c
index 35b2c75..1db37f7 100644 (file)
--- a/examples/c/app-masterworker/app-masterworker.c
+++ b/examples/c/app-masterworker/app-masterworker.c
@@ -31,7 +31,7 @@ static void master(int argc, char* argv[])
   for (int i = 0; i < number_of_tasks; i++) { /* For each task to be executed: */
     char mailbox_name[80];
     char task_name[80];
-    double* payload = (double*)malloc(sizeof(double));
+    double* payload = xbt_malloc(sizeof(double));
     snprintf(mailbox_name, 79, "worker-%ld", i % workers_count); /* - Select a @ref worker in a round-robin way */
     snprintf(task_name, 79, "Task_%d", i);
 
@@ -48,7 +48,7 @@ static void master(int argc, char* argv[])
   for (int i = 0; i < workers_count; i++) { /* - Eventually tell all the workers to stop by sending a "finalize" task */
     char mailbox_name[80];
     snprintf(mailbox_name, 79, "worker-%ld", i % workers_count);
-    double* payload      = (double*)malloc(sizeof(double));
+    double* payload      = xbt_malloc(sizeof(double));
     sg_mailbox_t mailbox = sg_mailbox_by_name(mailbox_name);
     *payload             = FINALIZE;
     sg_mailbox_put(mailbox, payload, 0);

diff --git a/examples/c/async-waitall/async-waitall.c b/examples/c/async-waitall/async-waitall.c
index bd58ed3..f0755cf 100644 (file)
--- a/examples/c/async-waitall/async-waitall.c
+++ b/examples/c/async-waitall/async-waitall.c
@@ -25,11 +25,11 @@ static void sender(int argc, char* argv[])
   long receivers_count = xbt_str_parse_int(argv[3], "Invalid amount of receivers: %s");
 
   /* Array in which we store all ongoing communications */
-  sg_comm_t* pending_comms = malloc(sizeof(sg_comm_t) * (messages_count + receivers_count));
+  sg_comm_t* pending_comms = xbt_malloc(sizeof(sg_comm_t) * (messages_count + receivers_count));
   int pending_comms_count  = 0;
 
   /* Make an array of the mailboxes to use */
-  sg_mailbox_t* mboxes = malloc(sizeof(sg_mailbox_t) * receivers_count);
+  sg_mailbox_t* mboxes = xbt_malloc(sizeof(sg_mailbox_t) * receivers_count);
   for (long i = 0; i < receivers_count; i++) {
     char mailbox_name[80];
     snprintf(mailbox_name, 79, "receiver-%ld", i);

diff --git a/examples/c/cloud-masterworker/cloud-masterworker.c b/examples/c/cloud-masterworker/cloud-masterworker.c
index 911fe8b..1f1c583 100644 (file)
--- a/examples/c/cloud-masterworker/cloud-masterworker.c
+++ b/examples/c/cloud-masterworker/cloud-masterworker.c
@@ -28,7 +28,7 @@ static void send_tasks(int nb_workers)
   for (int i = 0; i < nb_workers; i++) {
     char mbox_name[MAXMBOXLEN];
     snprintf(mbox_name, MAXMBOXLEN, "MBOX:WRK%02d", i);
-    double* payload   = (double*)malloc(sizeof(double));
+    double* payload   = xbt_malloc(sizeof(double));
     *payload          = comp_size;
     sg_mailbox_t mbox = sg_mailbox_by_name(mbox_name);
 
@@ -67,7 +67,7 @@ static void master_fun(XBT_ATTRIB_UNUSED int argc, XBT_ATTRIB_UNUSED char* argv[
 {
   sg_host_t* worker_pms = sg_actor_self_data();
 
-  sg_vm_t* vms = (sg_vm_t*)malloc(2 * sizeof(sg_vm_t));
+  sg_vm_t* vms = xbt_malloc(2 * sizeof(sg_vm_t));
 
   /* Launch VMs and worker actors. One VM per PM, and one worker actor per VM. */
   XBT_INFO("# Launch 2 VMs");
@@ -146,7 +146,7 @@ static void master_fun(XBT_ATTRIB_UNUSED int argc, XBT_ATTRIB_UNUSED char* argv[
     char mbox_name[MAXMBOXLEN];
     snprintf(mbox_name, MAXMBOXLEN, "MBOX:WRK%02d", i);
     sg_mailbox_t mbox = sg_mailbox_by_name(mbox_name);
-    double* payload   = (double*)malloc(sizeof(double));
+    double* payload   = xbt_malloc(sizeof(double));
     *payload          = FINALIZE;
     sg_mailbox_put(mbox, payload, 0);
   }
@@ -185,7 +185,7 @@ int main(int argc, char* argv[])
   /* the first pm is the master, the others are workers */
   sg_host_t master_pm = pms[0];
 
-  sg_host_t* worker_pms = (sg_host_t*)malloc(2 * sizeof(sg_host_t));
+  sg_host_t* worker_pms = xbt_malloc(2 * sizeof(sg_host_t));
   for (int i = 0; i < 2; i++)
     worker_pms[i] = pms[i + 1];
 

diff --git a/examples/c/exec-waitany/exec-waitany.c b/examples/c/exec-waitany/exec-waitany.c
index 7f65a20..dc3f0ad 100644 (file)
--- a/examples/c/exec-waitany/exec-waitany.c
+++ b/examples/c/exec-waitany/exec-waitany.c
@@ -19,7 +19,7 @@ static void worker(int argc, char* argv[])
   int with_timeout = !strcmp(argv[1], "true");
 
   /* Vector in which we store all pending executions*/
-  sg_exec_t* pending_execs = malloc(sizeof(sg_exec_t) * 3);
+  sg_exec_t* pending_execs = xbt_malloc(sizeof(sg_exec_t) * 3);
   int pending_execs_count  = 0;
 
   for (int i = 0; i < 3; i++) {

diff --git a/src/xbt/log.cpp b/src/xbt/log.cpp
index 0f28f5d..ef3fd94 100644 (file)
--- a/src/xbt/log.cpp
+++ b/src/xbt/log.cpp
@@ -175,6 +175,7 @@ void _xbt_log_event_log(xbt_log_event_t ev, const char *fmt, ...)
       va_start(ev->ap, fmt);
       done = cat->layout->do_layout(cat->layout, ev, fmt);
       va_end(ev->ap);
+      ev->buffer = nullptr; // Calm down, static analyzers, this pointer to local array wont leak out of the scope.
       if (done) {
         appender->do_append(appender, buff);
       } else {