Commit 651621b7 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/armbru/tags/pull-cov-model-2015-02-05' into staging 



coverity: Improve and extend model

# gpg: Signature made Thu 05 Feb 2015 16:20:49 GMT using RSA key ID EB918653
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>"
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>"

* remotes/armbru/tags/pull-cov-model-2015-02-05:
  MAINTAINERS: Add myself as Coverity model maintainer
  coverity: Model g_free() isn't necessarily free()
  coverity: Model GLib string allocation partially
  coverity: Improve model for GLib memory allocation

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents cd07b193 8c413e79

MAINTAINERS

+5 −0
Original line number Diff line number Diff line
@@ -783,6 +783,11 @@ M: Samuel Thibault <samuel.thibault@ens-lyon.org> 
S: Maintained

F: backends/baum.c



Coverity model

M: Markus Armbruster <armbru@redhat.com>

S: Supported

F: scripts/coverity-model.c



CPU

M: Andreas Färber <afaerber@suse.de>

S: Supported

scripts/coverity-model.c

+193 −35
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ typedef unsigned long long uint64_t; 
typedef long long int64_t;

typedef _Bool bool;



typedef struct va_list_str *va_list;



/* exec.c */



typedef struct AddressSpace AddressSpace;
@@ -90,7 +92,8 @@ static int get_keysym(const name2keysym_t *table, 
    }

}



/* glib memory allocation functions.

/*

 * GLib memory allocation functions.

 *

 * Note that we ignore the fact that g_malloc of 0 bytes returns NULL,

 * and g_realloc of 0 bytes frees the pointer.
@@ -107,60 +110,215 @@ static int get_keysym(const name2keysym_t *table, 
 * we'll get a buffer overflow reported anyway.

 */



void *malloc(size_t);

void *calloc(size_t, size_t);

void *realloc(void *, size_t);

void free(void *);

/*

 * Allocation primitives, cannot return NULL

 * See also Coverity's library/generic/libc/all/all.c

 */



void *g_malloc_n(size_t nmemb, size_t size)

{

    size_t sz;

    void *ptr;



    __coverity_negative_sink__(nmemb);

    __coverity_negative_sink__(size);

    sz = nmemb * size;

    ptr = __coverity_alloc__(size);

    __coverity_mark_as_uninitialized_buffer__(ptr);

    __coverity_mark_as_afm_allocated__(ptr, "g_free");

    return ptr;

}



void *

g_malloc(size_t n_bytes)

void *g_malloc0_n(size_t nmemb, size_t size)

{

    void *mem;

    __coverity_negative_sink__(n_bytes);

    mem = malloc(n_bytes == 0 ? 1 : n_bytes);

    if (!mem) __coverity_panic__();

    return mem;

    size_t sz;

    void *ptr;



    __coverity_negative_sink__(nmemb);

    __coverity_negative_sink__(size);

    sz = nmemb * size;

    ptr = __coverity_alloc__(size);

    __coverity_writeall0__(ptr);

    __coverity_mark_as_afm_allocated__(ptr, "g_free");

    return ptr;

}



void *

g_malloc0(size_t n_bytes)

void *g_realloc_n(void *ptr, size_t nmemb, size_t size)

{

    size_t sz;



    __coverity_negative_sink__(nmemb);

    __coverity_negative_sink__(size);

    sz = nmemb * size;

    __coverity_escape__(ptr);

    ptr = __coverity_alloc__(size);

    /*

     * Memory beyond the old size isn't actually initialized.  Can't

     * model that.  See Coverity's realloc() model

     */

    __coverity_writeall__(ptr);

    __coverity_mark_as_afm_allocated__(ptr, "g_free");

    return ptr;

}



void g_free(void *ptr)

{

    __coverity_free__(ptr);

    __coverity_mark_as_afm_freed__(ptr, "g_free");

}



/*

 * Derive the g_try_FOO_n() from the g_FOO_n() by adding indeterminate

 * out of memory conditions

 */



void *g_try_malloc_n(size_t nmemb, size_t size)

{

    int nomem;



    if (nomem) {

        return NULL;

    }

    return g_malloc_n(nmemb, size);

}



void *g_try_malloc0_n(size_t nmemb, size_t size)

{

    int nomem;



    if (nomem) {

        return NULL;

    }

    return g_malloc0_n(nmemb, size);

}



void *g_try_realloc_n(void *ptr, size_t nmemb, size_t size)

{

    int nomem;



    if (nomem) {

        return NULL;

    }

    return g_realloc_n(ptr, nmemb, size);

}



/* Trivially derive the g_FOO() from the g_FOO_n() */



void *g_malloc(size_t size)

{

    void *mem;

    __coverity_negative_sink__(n_bytes);

    mem = calloc(1, n_bytes == 0 ? 1 : n_bytes);

    if (!mem) __coverity_panic__();

    return mem;

    return g_malloc_n(1, size);

}



void g_free(void *mem)

void *g_malloc0(size_t size)

{

    free(mem);

    return g_malloc0_n(1, size);

}



void *g_realloc(void * mem, size_t n_bytes)

void *g_realloc(void *ptr, size_t size)

{

    __coverity_negative_sink__(n_bytes);

    mem = realloc(mem, n_bytes == 0 ? 1 : n_bytes);

    if (!mem) __coverity_panic__();

    return mem;

    return g_realloc_n(ptr, 1, size);

}



void *g_try_malloc(size_t n_bytes)

void *g_try_malloc(size_t size)

{

    __coverity_negative_sink__(n_bytes);

    return malloc(n_bytes == 0 ? 1 : n_bytes);

    return g_try_malloc_n(1, size);

}



void *g_try_malloc0(size_t n_bytes)

void *g_try_malloc0(size_t size)

{

    __coverity_negative_sink__(n_bytes);

    return calloc(1, n_bytes == 0 ? 1 : n_bytes);

    return g_try_malloc0_n(1, size);

}



void *g_try_realloc(void *mem, size_t n_bytes)

void *g_try_realloc(void *ptr, size_t size)

{

    __coverity_negative_sink__(n_bytes);

    return realloc(mem, n_bytes == 0 ? 1 : n_bytes);

    return g_try_realloc_n(ptr, 1, size);

}



/*

 * GLib string allocation functions

 */



char *g_strdup(const char *s)

{

    char *dup;

    size_t i;



    if (!s) {

        return NULL;

    }



    __coverity_string_null_sink__(s);

    __coverity_string_size_sink__(s);

    dup = __coverity_alloc_nosize__();

    __coverity_mark_as_afm_allocated__(dup, "g_free");

    for (i = 0; (dup[i] = s[i]); i++) ;

    return dup;

}



char *g_strndup(const char *s, size_t n)

{

    char *dup;

    size_t i;



    __coverity_negative_sink__(n);



    if (!s) {

        return NULL;

    }



    dup = g_malloc(n + 1);

    for (i = 0; i < n && (dup[i] = s[i]); i++) ;

    dup[i] = 0;

    return dup;

}



char *g_strdup_printf(const char *format, ...)

{

    char ch, *s;

    size_t len;



    __coverity_string_null_sink__(format);

    __coverity_string_size_sink__(format);



    ch = *format;



    s = __coverity_alloc_nosize__();

    __coverity_writeall__(s);

    __coverity_mark_as_afm_allocated__(s, "g_free");

    return s;

}



char *g_strdup_vprintf(const char *format, va_list ap)

{

    char ch, *s;

    size_t len;



    __coverity_string_null_sink__(format);

    __coverity_string_size_sink__(format);



    ch = *format;

    ch = *(char *)ap;



    s = __coverity_alloc_nosize__();

    __coverity_writeall__(s);

    __coverity_mark_as_afm_allocated__(s, "g_free");



    return len;

}



char *g_strconcat(const char *s, ...)

{

    char *s;



    /*

     * Can't model: last argument must be null, the others

     * null-terminated strings

     */



    s = __coverity_alloc_nosize__();

    __coverity_writeall__(s);

    __coverity_mark_as_afm_allocated__(s, "g_free");

    return s;

}



/* Other glib functions */