* David Goulet ([email protected]) wrote:
> Signed-off-by: David Goulet <[email protected]>
> ---
>  libust/buffers.c    |    4 ++--
>  libust/marker.c     |    6 +++---
>  libust/tracectl.c   |    4 ++--
>  libust/tracepoint.c |    8 ++++----
>  4 files changed, 11 insertions(+), 11 deletions(-)
> 
> diff --git a/libust/buffers.c b/libust/buffers.c
> index 5d9bb8e..374ec61 100644
> --- a/libust/buffers.c
> +++ b/libust/buffers.c
> @@ -777,11 +777,11 @@ static int ust_buffers_create_channel(const char 
> *trace_name, struct ust_trace *
>       ltt_chan->commit_count_mask = (~0UL >> ltt_chan->n_subbufs_order);
>       ltt_chan->n_cpus = get_n_cpus();
>  //ust//      ltt_chan->buf = percpu_alloc_mask(sizeof(struct 
> ltt_channel_buf_struct), GFP_KERNEL, cpu_possible_map);
> -     ltt_chan->buf = (void *) malloc(ltt_chan->n_cpus * sizeof(void *));
> +     ltt_chan->buf = (void *) zmalloc(ltt_chan->n_cpus * sizeof(void *));

Yes, a lot of algos in LTTng assume we use zalloc from the kernel, which
sets memory to 0. We should merge this.

So for this patch:

Signed-off-by: Mathieu Desnoyers <[email protected]>

Please also grep around in the rest of UST for this. e.g.

ustd:

               tmp = malloc(pad_size);
               memset(tmp, 0, pad_size);

should clearly use zmalloc.

Thanks,

Mathieu

>       if(ltt_chan->buf == NULL) {
>               goto error;
>       }
> -     ltt_chan->buf_struct_shmids = (int *) malloc(ltt_chan->n_cpus * 
> sizeof(int));
> +     ltt_chan->buf_struct_shmids = (int *) zmalloc(ltt_chan->n_cpus * 
> sizeof(int));
>       if(ltt_chan->buf_struct_shmids == NULL)
>               goto free_buf;
>  
> diff --git a/libust/marker.c b/libust/marker.c
> index 19467d1..3351726 100644
> --- a/libust/marker.c
> +++ b/libust/marker.c
> @@ -428,10 +428,10 @@ static struct marker_entry *add_marker(const char 
> *channel, const char *name,
>               }
>       }
>       /*
> -      * Using malloc here to allocate a variable length element. Could
> +      * Using zmalloc here to allocate a variable length element. Could
>        * cause some memory fragmentation if overused.
>        */
> -     e = malloc(sizeof(struct marker_entry)
> +     e = zmalloc(sizeof(struct marker_entry)
>                   + channel_len + name_len + format_len);
>       if (!e)
>               return ERR_PTR(-ENOMEM);
> @@ -1363,7 +1363,7 @@ int marker_register_lib(struct marker *markers_start, 
> int markers_count)
>  {
>       struct lib *pl;
>  
> -     pl = (struct lib *) malloc(sizeof(struct lib));
> +     pl = (struct lib *) zmalloc(sizeof(struct lib));
>  
>       pl->markers_start = markers_start;
>       pl->markers_count = markers_count;
> diff --git a/libust/tracectl.c b/libust/tracectl.c
> index a82c107..b556c91 100644
> --- a/libust/tracectl.c
> +++ b/libust/tracectl.c
> @@ -638,9 +638,9 @@ static int do_cmd_get_subbuffer(const char *recvbuf, 
> struct ustcomm_source *src)
>  
>                       found = 1;
>  
> -                     bc = (struct blocked_consumer *) malloc(sizeof(struct 
> blocked_consumer));
> +                     bc = (struct blocked_consumer *) zmalloc(sizeof(struct 
> blocked_consumer));
>                       if(bc == NULL) {
> -                             ERR("malloc returned NULL");
> +                             ERR("zmalloc returned NULL");
>                               goto unlock_traces;
>                       }
>                       bc->fd_consumer = src->fd;
> diff --git a/libust/tracepoint.c b/libust/tracepoint.c
> index 6155e29..ee7259c 100644
> --- a/libust/tracepoint.c
> +++ b/libust/tracepoint.c
> @@ -74,7 +74,7 @@ struct tp_probes {
>  
>  static inline void *allocate_probes(int count)
>  {
> -     struct tp_probes *p  = malloc(count * sizeof(void *)
> +     struct tp_probes *p  = zmalloc(count * sizeof(void *)
>                       + sizeof(struct tp_probes));
>       return p == NULL ? NULL : p->probes;
>  }
> @@ -218,10 +218,10 @@ static struct tracepoint_entry *add_tracepoint(const 
> char *name)
>               }
>       }
>       /*
> -      * Using kmalloc here to allocate a variable length element. Could
> +      * Using zmalloc here to allocate a variable length element. Could
>        * cause some memory fragmentation if overused.
>        */
> -     e = malloc(sizeof(struct tracepoint_entry) + name_len);
> +     e = zmalloc(sizeof(struct tracepoint_entry) + name_len);
>       if (!e)
>               return ERR_PTR(-ENOMEM);
>       memcpy(&e->name[0], name, name_len);
> @@ -646,7 +646,7 @@ int tracepoint_register_lib(struct tracepoint 
> *tracepoints_start, int tracepoint
>  {
>       struct tracepoint_lib *pl;
>  
> -     pl = (struct tracepoint_lib *) malloc(sizeof(struct tracepoint_lib));
> +     pl = (struct tracepoint_lib *) zmalloc(sizeof(struct tracepoint_lib));
>  
>       pl->tracepoints_start = tracepoints_start;
>       pl->tracepoints_count = tracepoints_count;
> -- 
> 1.7.0.4
> 
> 
> _______________________________________________
> ltt-dev mailing list
> [email protected]
> http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev
> 

-- 
Mathieu Desnoyers
Operating System Efficiency R&D Consultant
EfficiOS Inc.
http://www.efficios.com

_______________________________________________
ltt-dev mailing list
[email protected]
http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev

Reply via email to