From patchwork Wed Mar 26 11:45:49 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paolo Bonzini X-Patchwork-Id: 333828 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 53828140179 for ; Wed, 26 Mar 2014 22:48:12 +1100 (EST) Received: from localhost ([::1]:47154 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1WSmJV-0001L3-M2 for incoming@patchwork.ozlabs.org; Wed, 26 Mar 2014 07:48:09 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:45594) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1WSmIx-0001Dl-8e for qemu-devel@nongnu.org; Wed, 26 Mar 2014 07:47:40 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1WSmIr-0005g1-Le for qemu-devel@nongnu.org; Wed, 26 Mar 2014 07:47:35 -0400 Received: from mail-qc0-x22d.google.com ([2607:f8b0:400d:c01::22d]:56960) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1WSmIr-0005fu-H2; Wed, 26 Mar 2014 07:47:29 -0400 Received: by mail-qc0-f173.google.com with SMTP id r5so2369548qcx.32 for ; Wed, 26 Mar 2014 04:47:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=sender:from:to:cc:subject:date:message-id; bh=j5Jg708fSSXa62FmOJPlvGM8xP/jmfuxr3cFY2e87Rc=; b=Gj6XbOutFS/MeLLyLOdo42U9RkbLD573upmkRK80Q6oozU7TjyWSOe4u08LeXHZNlr 2T/22ftjNnBmtPx3Nae0MMALOTyWJwy0El1WXVg9mzp0VQPDvXIxRjXxfm1+heUzmMS0 Gd4hWvYI9lrYhk//1UlpL8sVvVF+nhC+eW+GCQv7kgy9tLqfQIEGOtz3rzf80aM3gS+t MfsSJ22Xhkcs6rZYyaf4mGtz6H/6d5N2Aac/xDPuhROVDJHrOBeErYBZHpLSSLr1fvFG I23hYxz0/qxM8yZRbG1kzcIzsotscJlgWBATsb9FqC3PymSAME9YKuNLRE8ZMR17W6wF ljSA== X-Received: by 10.224.75.5 with SMTP id w5mr28826765qaj.52.1395834449068; Wed, 26 Mar 2014 04:47:29 -0700 (PDT) Received: from yakj.usersys.redhat.com (net-37-117-156-129.cust.vodafonedsl.it. [37.117.156.129]) by mx.google.com with ESMTPSA id x5sm38167783qaj.9.2014.03.26.04.47.03 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 26 Mar 2014 04:47:27 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Date: Wed, 26 Mar 2014 12:45:49 +0100 Message-Id: <1395834349-19001-1-git-send-email-pbonzini@redhat.com> X-Mailer: git-send-email 1.8.5.3 X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2607:f8b0:400d:c01::22d Cc: qemu-trivial@nongnu.org, armbru@redhat.com Subject: [Qemu-devel] [PATCH v4] scripts: add sample model file for Coverity Scan X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org This is the model file that is being used for the QEMU project's scans on scan.coverity.com. It fixed about 30 false positives (10% of the total) and exposed about 60 new memory leaks. The file is not automatically used; changes to it must be propagated to the website manually by an admin (right now Markus, Peter and me are admins). Signed-off-by: Paolo Bonzini Signed-off-by: Markus Armbruster --- scripts/coverity-model.c | 183 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 scripts/coverity-model.c diff --git a/scripts/coverity-model.c b/scripts/coverity-model.c new file mode 100644 index 0000000..4c99a85 --- /dev/null +++ b/scripts/coverity-model.c @@ -0,0 +1,183 @@ +/* Coverity Scan model + * + * Copyright (C) 2014 Red Hat, Inc. + * + * Authors: + * Markus Armbruster + * Paolo Bonzini + * + * This work is licensed under the terms of the GNU GPL, version 2 or, at your + * option, any later version. See the COPYING file in the top-level directory. + */ + + +/* + * This is the source code for our Coverity user model file. The + * purpose of user models is to increase scanning accuracy by explaining + * code Coverity can't see (out of tree libraries) or doesn't + * sufficiently understand. Better accuracy means both fewer false + * positives and more true defects. Memory leaks in particular. + * + * - A model file can't import any header files. Some built-in primitives are + * available but not wchar_t, NULL etc. + * - Modeling doesn't need full structs and typedefs. Rudimentary structs + * and similar types are sufficient. + * - An uninitialized local variable signifies that the variable could be + * any value. + * + * The model file must be uploaded by an admin in the analysis settings of + * http://scan.coverity.com/projects/378 + */ + +#define NULL ((void *)0) + +typedef unsigned char uint8_t; +typedef char int8_t; +typedef unsigned int uint32_t; +typedef int int32_t; +typedef long ssize_t; +typedef unsigned long long uint64_t; +typedef long long int64_t; +typedef _Bool bool; + +/* exec.c */ + +typedef struct AddressSpace AddressSpace; +typedef uint64_t hwaddr; + +static void __write(uint8_t *buf, ssize_t len) +{ + int first, last; + __coverity_negative_sink__(len); + if (len == 0) return; + buf[0] = first; + buf[len-1] = last; + __coverity_writeall__(buf); +} + +static void __read(uint8_t *buf, ssize_t len) +{ + __coverity_negative_sink__(len); + if (len == 0) return; + int first = buf[0]; + int last = buf[len-1]; +} + +bool address_space_rw(AddressSpace *as, hwaddr addr, uint8_t *buf, + int len, bool is_write) +{ + bool result; + + // TODO: investigate impact of treating reads as producing + // tainted data, with __coverity_tainted_data_argument__(buf). + if (is_write) __write(buf, len); else __read(buf, len); + + return result; +} + +/* Tainting */ + +typedef struct {} name2keysym_t; +static int get_keysym(const name2keysym_t *table, + const char *name) +{ + int result; + if (result > 0) { + __coverity_tainted_string_sanitize_content__(name); + return result; + } else { + return 0; + } +} + +/* 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. + * + * Modeling this would result in Coverity flagging a lot of memory + * allocations as potentially returning NULL, and asking us to check + * whether the result of the allocation is NULL or not. However, the + * resulting pointer should never be dereferenced anyway, and in fact + * it is not in the vast majority of cases. + * + * If a dereference did happen, this would suppress a defect report + * for an actual null pointer dereference. But it's too unlikely to + * be worth wading through the false positives, and with some luck + * 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 *); + +void * +g_malloc(size_t n_bytes) +{ + void *mem; + __coverity_negative_sink__(n_bytes); + mem = malloc(n_bytes == 0 ? 1 : n_bytes); + if (!mem) __coverity_panic__(); + return mem; +} + +void * +g_malloc0(size_t n_bytes) +{ + void *mem; + __coverity_negative_sink__(n_bytes); + mem = calloc(1, n_bytes == 0 ? 1 : n_bytes); + if (!mem) __coverity_panic__(); + return mem; +} + +void g_free(void *mem) +{ + free(mem); +} + +void *g_realloc(void * mem, size_t n_bytes) +{ + __coverity_negative_sink__(n_bytes); + mem = realloc(mem, n_bytes == 0 ? 1 : n_bytes); + if (!mem) __coverity_panic__(); + return mem; +} + +void *g_try_malloc(size_t n_bytes) +{ + __coverity_negative_sink__(n_bytes); + return malloc(n_bytes == 0 ? 1 : n_bytes); +} + +void *g_try_malloc0(size_t n_bytes) +{ + __coverity_negative_sink__(n_bytes); + return calloc(1, n_bytes == 0 ? 1 : n_bytes); +} + +void *g_try_realloc(void *mem, size_t n_bytes) +{ + __coverity_negative_sink__(n_bytes); + return realloc(mem, n_bytes == 0 ? 1 : n_bytes); +} + +/* Other glib functions */ + +typedef struct _GIOChannel GIOChannel; +GIOChannel *g_io_channel_unix_new(int fd) +{ + GIOChannel *c = g_malloc0(sizeof(GIOChannel)); + __coverity_escape__(fd); + return c; +} + +void g_assertion_message_expr(const char *domain, + const char *file, + int line, + const char *func, + const char *expr) +{ + __coverity_panic__(); +}