varun-r-mallya/sysprof
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/sysprof.git synced 2026-02-12 16:10:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

libsysprof-capture: Use assert() instead of g_assert()

Browse Source 
Also use it instead of `g_return_if_fail()`.

Signed-off-by: Philip Withnall <withnall@endlessm.com>

Helps: #40
This commit is contained in:
Philip Withnall
2020-07-01 16:26:15 +01:00
parent 5636bbf4f0
commit 8e28ac6e81
12 changed files with 349 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
src/libsysprof-capture/mapped-ring-buffer.c
View File

@ -22,6 +22,7 @@
#include "config.h" #include "config.h"
#include <assert.h>
#include <stdint.h> #include <stdint.h>
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/types.h> #include <sys/types.h>
@ -54,7 +55,7 @@ typedef struct _MappedRingHeader
uint32_t size; uint32_t size;
} MappedRingHeader; } MappedRingHeader;
G_STATIC_ASSERT (sizeof (MappedRingHeader) == 16); static_assert (sizeof (MappedRingHeader) == 16, "MappedRingHeader changed size");
/* /*
* MappedRingBuffer is used to wrap both the reader and writer * MappedRingBuffer is used to wrap both the reader and writer
@ -80,7 +81,7 @@ static inline void *
get_body_at_pos (MappedRingBuffer *self, get_body_at_pos (MappedRingBuffer *self,
size_t pos) size_t pos)
{ {
g_assert (pos < (self->body_size + self->body_size)); assert (pos < (self->body_size + self->body_size));
return (uint8_t *)self->map + self->page_size + pos; return (uint8_t *)self->map + self->page_size + pos;
} }
@ -132,7 +133,7 @@ map_head_and_body_twice (int fd,
return NULL; return NULL;
} }
g_assert (second == (void *)((uint8_t *)map + head_size + body_size)); assert (second == (void *)((uint8_t *)map + head_size + body_size));
return map; return map;
} }
@ -166,8 +167,8 @@ mapped_ring_buffer_new_reader (size_t buffer_size)
void *map; void *map;
int fd; int fd;
g_return_val_if_fail ((buffer_size % _sysprof_getpagesize ()) == 0, NULL); assert ((buffer_size % _sysprof_getpagesize ()) == 0);
g_return_val_if_fail (buffer_size < BUFFER_MAX_SIZE, NULL); assert (buffer_size < BUFFER_MAX_SIZE);
page_size = _sysprof_getpagesize (); page_size = _sysprof_getpagesize ();
@ -243,7 +244,7 @@ mapped_ring_buffer_new_writer (int fd)
size_t page_size; size_t page_size;
void *map; void *map;
g_return_val_if_fail (fd > -1, NULL); assert (fd > -1);
page_size = _sysprof_getpagesize (); page_size = _sysprof_getpagesize ();
@ -329,8 +330,8 @@ mapped_ring_buffer_finalize (MappedRingBuffer *self)
void void
mapped_ring_buffer_unref (MappedRingBuffer *self) mapped_ring_buffer_unref (MappedRingBuffer *self)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (self->ref_count > 0); assert (self->ref_count > 0);
if (g_atomic_int_dec_and_test (&self->ref_count)) if (g_atomic_int_dec_and_test (&self->ref_count))
mapped_ring_buffer_finalize (self); mapped_ring_buffer_finalize (self);
@ -339,8 +340,8 @@ mapped_ring_buffer_unref (MappedRingBuffer *self)
MappedRingBuffer * MappedRingBuffer *
mapped_ring_buffer_ref (MappedRingBuffer *self) mapped_ring_buffer_ref (MappedRingBuffer *self)
{ {
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
g_return_val_if_fail (self->ref_count > 0, NULL); assert (self->ref_count > 0);
g_atomic_int_inc (&self->ref_count); g_atomic_int_inc (&self->ref_count);
@ -350,7 +351,7 @@ mapped_ring_buffer_ref (MappedRingBuffer *self)
int int
mapped_ring_buffer_get_fd (MappedRingBuffer *self) mapped_ring_buffer_get_fd (MappedRingBuffer *self)
{ {
g_return_val_if_fail (self != NULL, -1); assert (self != NULL);
return self->fd; return self->fd;
} }
@ -386,11 +387,11 @@ mapped_ring_buffer_allocate (MappedRingBuffer *self,
uint32_t headpos; uint32_t headpos;
uint32_t tailpos; uint32_t tailpos;
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
g_return_val_if_fail (self->mode & MODE_WRITER, NULL); assert (self->mode & MODE_WRITER);
g_return_val_if_fail (length > 0, NULL); assert (length > 0);
g_return_val_if_fail (length < self->body_size, NULL); assert (length < self->body_size);
g_return_val_if_fail ((length & 0x7) == 0, NULL); assert ((length & 0x7) == 0);
header = get_header (self); header = get_header (self);
headpos = g_atomic_int_get (&header->head); headpos = g_atomic_int_get (&header->head);
@ -442,11 +443,11 @@ mapped_ring_buffer_advance (MappedRingBuffer *self,
MappedRingHeader *header; MappedRingHeader *header;
uint32_t tail; uint32_t tail;
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (self->mode & MODE_WRITER); assert (self->mode & MODE_WRITER);
g_return_if_fail (length > 0); assert (length > 0);
g_return_if_fail (length < self->body_size); assert (length < self->body_size);
g_return_if_fail ((length & 0x7) == 0); assert ((length & 0x7) == 0);
header = get_header (self); header = get_header (self);
tail = header->tail; tail = header->tail;
@ -487,16 +488,16 @@ mapped_ring_buffer_drain (MappedRingBuffer *self,
uint32_t headpos; uint32_t headpos;
uint32_t tailpos; uint32_t tailpos;
g_return_val_if_fail (self != NULL, FALSE); assert (self != NULL);
g_return_val_if_fail (self->mode & MODE_READER, FALSE); assert (self->mode & MODE_READER);
g_return_val_if_fail (callback != NULL, FALSE); assert (callback != NULL);
header = get_header (self); header = get_header (self);
headpos = g_atomic_int_get (&header->head); headpos = g_atomic_int_get (&header->head);
tailpos = g_atomic_int_get (&header->tail); tailpos = g_atomic_int_get (&header->tail);
g_assert (headpos < self->body_size); assert (headpos < self->body_size);
g_assert (tailpos < self->body_size); assert (tailpos < self->body_size);
if (headpos == tailpos) if (headpos == tailpos)
return true; return true;
@ -507,7 +508,7 @@ mapped_ring_buffer_drain (MappedRingBuffer *self,
if (tailpos < headpos) if (tailpos < headpos)
tailpos += self->body_size; tailpos += self->body_size;
g_assert (headpos < tailpos); assert (headpos < tailpos);
while (headpos < tailpos) while (headpos < tailpos)
{ {
@ -571,7 +572,7 @@ mapped_ring_buffer_clear (MappedRingBuffer *self)
{ {
MappedRingHeader *header; MappedRingHeader *header;
g_return_if_fail (self != NULL); assert (self != NULL);
header = get_header (self); header = get_header (self);
header->head = 0; header->head = 0;

4
src/libsysprof-capture/sysprof-address.h
View File

@ -56,6 +56,7 @@
#pragma once #pragma once
#include <assert.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
@ -65,7 +66,8 @@ G_BEGIN_DECLS
typedef uint64_t SysprofAddress; typedef uint64_t SysprofAddress;
G_STATIC_ASSERT (sizeof (SysprofAddress) >= sizeof (void *)); static_assert (sizeof (SysprofAddress) >= sizeof (void *),
"Address space is too big");
typedef enum typedef enum
{ {

36
src/libsysprof-capture/sysprof-capture-condition.c
View File

@ -58,10 +58,12 @@
#include "config.h" #include "config.h"
#include <assert.h>
#include <stdbool.h> #include <stdbool.h>
#include <string.h> #include <string.h>
#include "sysprof-capture-condition.h" #include "sysprof-capture-condition.h"
#include "sysprof-macros-internal.h"
/** /**
* SECTION:sysprof-capture-condition * SECTION:sysprof-capture-condition
@ -109,8 +111,8 @@ bool
sysprof_capture_condition_match (const SysprofCaptureCondition *self, sysprof_capture_condition_match (const SysprofCaptureCondition *self,
const SysprofCaptureFrame *frame) const SysprofCaptureFrame *frame)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (frame != NULL); assert (frame != NULL);
switch (self->type) switch (self->type)
{ {
@ -192,7 +194,7 @@ sysprof_capture_condition_match (const SysprofCaptureCondition *self,
break; break;
} }
g_assert_not_reached (); sysprof_assert_not_reached ();
return false; return false;
} }
@ -250,7 +252,7 @@ sysprof_capture_condition_copy (const SysprofCaptureCondition *self)
break; break;
} }
g_return_val_if_reached (NULL); sysprof_assert_not_reached ();
} }
static void static void
@ -288,7 +290,7 @@ sysprof_capture_condition_finalize (SysprofCaptureCondition *self)
break; break;
default: default:
g_assert_not_reached (); sysprof_assert_not_reached ();
break; break;
} }
@ -298,8 +300,8 @@ sysprof_capture_condition_finalize (SysprofCaptureCondition *self)
SysprofCaptureCondition * SysprofCaptureCondition *
sysprof_capture_condition_ref (SysprofCaptureCondition *self) sysprof_capture_condition_ref (SysprofCaptureCondition *self)
{ {
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
g_return_val_if_fail (self->ref_count > 0, NULL); assert (self->ref_count > 0);
g_atomic_int_inc (&self->ref_count); g_atomic_int_inc (&self->ref_count);
return self; return self;
@ -308,8 +310,8 @@ sysprof_capture_condition_ref (SysprofCaptureCondition *self)
void void
sysprof_capture_condition_unref (SysprofCaptureCondition *self) sysprof_capture_condition_unref (SysprofCaptureCondition *self)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (self->ref_count > 0); assert (self->ref_count > 0);
if (g_atomic_int_dec_and_test (&self->ref_count)) if (g_atomic_int_dec_and_test (&self->ref_count))
sysprof_capture_condition_finalize (self); sysprof_capture_condition_finalize (self);
@ -321,7 +323,7 @@ sysprof_capture_condition_new_where_type_in (unsigned int n_ty
{ {
SysprofCaptureCondition *self; SysprofCaptureCondition *self;
g_return_val_if_fail (types != NULL, NULL); assert (types != NULL);
self = sysprof_capture_condition_init (); self = sysprof_capture_condition_init ();
self->type = SYSPROF_CAPTURE_CONDITION_WHERE_TYPE_IN; self->type = SYSPROF_CAPTURE_CONDITION_WHERE_TYPE_IN;
@ -359,7 +361,7 @@ sysprof_capture_condition_new_where_pid_in (unsigned int n_pids,
{ {
SysprofCaptureCondition *self; SysprofCaptureCondition *self;
g_return_val_if_fail (pids != NULL, NULL); assert (pids != NULL);
self = sysprof_capture_condition_init (); self = sysprof_capture_condition_init ();
self->type = SYSPROF_CAPTURE_CONDITION_WHERE_PID_IN; self->type = SYSPROF_CAPTURE_CONDITION_WHERE_PID_IN;
@ -376,7 +378,7 @@ sysprof_capture_condition_new_where_counter_in (unsigned int n_counters,
{ {
SysprofCaptureCondition *self; SysprofCaptureCondition *self;
g_return_val_if_fail (counters != NULL || n_counters == 0, NULL); assert (counters != NULL || n_counters == 0);
self = sysprof_capture_condition_init (); self = sysprof_capture_condition_init ();
self->type = SYSPROF_CAPTURE_CONDITION_WHERE_COUNTER_IN; self->type = SYSPROF_CAPTURE_CONDITION_WHERE_COUNTER_IN;
@ -407,8 +409,8 @@ sysprof_capture_condition_new_and (SysprofCaptureCondition *left,
{ {
SysprofCaptureCondition *self; SysprofCaptureCondition *self;
g_return_val_if_fail (left != NULL, NULL); assert (left != NULL);
g_return_val_if_fail (right != NULL, NULL); assert (right != NULL);
self = sysprof_capture_condition_init (); self = sysprof_capture_condition_init ();
self->type = SYSPROF_CAPTURE_CONDITION_AND; self->type = SYSPROF_CAPTURE_CONDITION_AND;
@ -434,8 +436,8 @@ sysprof_capture_condition_new_or (SysprofCaptureCondition *left,
{ {
SysprofCaptureCondition *self; SysprofCaptureCondition *self;
g_return_val_if_fail (left != NULL, NULL); assert (left != NULL);
g_return_val_if_fail (right != NULL, NULL); assert (right != NULL);
self = sysprof_capture_condition_init (); self = sysprof_capture_condition_init ();
self->type = SYSPROF_CAPTURE_CONDITION_OR; self->type = SYSPROF_CAPTURE_CONDITION_OR;
@ -459,7 +461,7 @@ sysprof_capture_condition_new_where_file (const char *path)
{ {
SysprofCaptureCondition *self; SysprofCaptureCondition *self;
g_return_val_if_fail (path != NULL, NULL); assert (path != NULL);
self = sysprof_capture_condition_init (); self = sysprof_capture_condition_init ();
self->type = SYSPROF_CAPTURE_CONDITION_WHERE_FILE; self->type = SYSPROF_CAPTURE_CONDITION_WHERE_FILE;

30
src/libsysprof-capture/sysprof-capture-cursor.c
View File

@ -58,6 +58,8 @@
#include "config.h" #include "config.h"
#include <assert.h>
#include "sysprof-capture-condition.h" #include "sysprof-capture-condition.h"
#include "sysprof-capture-cursor.h" #include "sysprof-capture-cursor.h"
#include "sysprof-capture-reader.h" #include "sysprof-capture-reader.h"
@ -105,8 +107,8 @@ sysprof_capture_cursor_init (void)
SysprofCaptureCursor * SysprofCaptureCursor *
sysprof_capture_cursor_ref (SysprofCaptureCursor *self) sysprof_capture_cursor_ref (SysprofCaptureCursor *self)
{ {
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
g_return_val_if_fail (self->ref_count > 0, NULL); assert (self->ref_count > 0);
g_atomic_int_inc (&self->ref_count); g_atomic_int_inc (&self->ref_count);
return self; return self;
@ -121,8 +123,8 @@ sysprof_capture_cursor_ref (SysprofCaptureCursor *self)
void void
sysprof_capture_cursor_unref (SysprofCaptureCursor *self) sysprof_capture_cursor_unref (SysprofCaptureCursor *self)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (self->ref_count > 0); assert (self->ref_count > 0);
if (g_atomic_int_dec_and_test (&self->ref_count)) if (g_atomic_int_dec_and_test (&self->ref_count))
sysprof_capture_cursor_finalize (self); sysprof_capture_cursor_finalize (self);
@ -140,9 +142,9 @@ sysprof_capture_cursor_foreach (SysprofCaptureCursor *self,
SysprofCaptureCursorCallback callback, SysprofCaptureCursorCallback callback,
void *user_data) void *user_data)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (self->reader != NULL); assert (self->reader != NULL);
g_return_if_fail (callback != NULL); assert (callback != NULL);
for (;;) for (;;)
{ {
@ -249,8 +251,8 @@ sysprof_capture_cursor_foreach (SysprofCaptureCursor *self,
void void
sysprof_capture_cursor_reset (SysprofCaptureCursor *self) sysprof_capture_cursor_reset (SysprofCaptureCursor *self)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (self->reader != NULL); assert (self->reader != NULL);
sysprof_capture_reader_reset (self->reader); sysprof_capture_reader_reset (self->reader);
} }
@ -258,7 +260,7 @@ sysprof_capture_cursor_reset (SysprofCaptureCursor *self)
void void
sysprof_capture_cursor_reverse (SysprofCaptureCursor *self) sysprof_capture_cursor_reverse (SysprofCaptureCursor *self)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
self->reversed = !self->reversed; self->reversed = !self->reversed;
} }
@ -275,8 +277,8 @@ void
sysprof_capture_cursor_add_condition (SysprofCaptureCursor *self, sysprof_capture_cursor_add_condition (SysprofCaptureCursor *self,
SysprofCaptureCondition *condition) SysprofCaptureCondition *condition)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (condition != NULL); assert (condition != NULL);
g_ptr_array_add (self->conditions, condition); g_ptr_array_add (self->conditions, condition);
} }
@ -292,7 +294,7 @@ sysprof_capture_cursor_new (SysprofCaptureReader *reader)
{ {
SysprofCaptureCursor *self; SysprofCaptureCursor *self;
g_return_val_if_fail (reader != NULL, NULL); assert (reader != NULL);
self = sysprof_capture_cursor_init (); self = sysprof_capture_cursor_init ();
self->reader = sysprof_capture_reader_copy (reader); self->reader = sysprof_capture_reader_copy (reader);
@ -311,7 +313,7 @@ sysprof_capture_cursor_new (SysprofCaptureReader *reader)
SysprofCaptureReader * SysprofCaptureReader *
sysprof_capture_cursor_get_reader (SysprofCaptureCursor *self) sysprof_capture_cursor_get_reader (SysprofCaptureCursor *self)
{ {
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
return self->reader; return self->reader;
} }

192
src/libsysprof-capture/sysprof-capture-reader.c
View File

@ -58,6 +58,7 @@
#include "config.h" #include "config.h"
#include <assert.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <limits.h> #include <limits.h>
@ -69,6 +70,7 @@
#include "sysprof-capture-reader.h" #include "sysprof-capture-reader.h"
#include "sysprof-capture-util-private.h" #include "sysprof-capture-util-private.h"
#include "sysprof-capture-writer.h" #include "sysprof-capture-writer.h"
#include "sysprof-macros-internal.h"
struct _SysprofCaptureReader struct _SysprofCaptureReader
{ {
@ -92,8 +94,8 @@ sysprof_capture_reader_read_file_header (SysprofCaptureReader *self,
SysprofCaptureFileHeader *header, SysprofCaptureFileHeader *header,
GError **error) GError **error)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (header != NULL); assert (header != NULL);
if (sizeof *header != _sysprof_pread (self->fd, header, sizeof *header, 0L)) if (sizeof *header != _sysprof_pread (self->fd, header, sizeof *header, 0L))
{ {
@ -133,7 +135,7 @@ sysprof_capture_reader_finalize (SysprofCaptureReader *self)
const char * const char *
sysprof_capture_reader_get_time (SysprofCaptureReader *self) sysprof_capture_reader_get_time (SysprofCaptureReader *self)
{ {
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
return self->header.capture_time; return self->header.capture_time;
} }
@ -141,7 +143,7 @@ sysprof_capture_reader_get_time (SysprofCaptureReader *self)
const char * const char *
sysprof_capture_reader_get_filename (SysprofCaptureReader *self) sysprof_capture_reader_get_filename (SysprofCaptureReader *self)
{ {
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
return self->filename; return self->filename;
} }
@ -151,7 +153,7 @@ sysprof_capture_reader_discover_end_time (SysprofCaptureReader *self)
{ {
SysprofCaptureFrame frame; SysprofCaptureFrame frame;
g_assert (self != NULL); assert (self != NULL);
while (sysprof_capture_reader_peek_frame (self, &frame)) while (sysprof_capture_reader_peek_frame (self, &frame))
{ {
@ -212,7 +214,7 @@ sysprof_capture_reader_new_from_fd (int fd,
{ {
SysprofCaptureReader *self; SysprofCaptureReader *self;
g_assert (fd > -1); assert (fd > -1);
self = g_new0 (SysprofCaptureReader, 1); self = g_new0 (SysprofCaptureReader, 1);
self->ref_count = 1; self->ref_count = 1;
@ -251,7 +253,7 @@ sysprof_capture_reader_new (const char *filename,
SysprofCaptureReader *self; SysprofCaptureReader *self;
int fd; int fd;
g_assert (filename != NULL); assert (filename != NULL);
if (-1 == (fd = open (filename, O_RDONLY, 0))) if (-1 == (fd = open (filename, O_RDONLY, 0)))
{ {
@ -277,8 +279,8 @@ static inline void
sysprof_capture_reader_bswap_frame (SysprofCaptureReader *self, sysprof_capture_reader_bswap_frame (SysprofCaptureReader *self,
SysprofCaptureFrame *frame) SysprofCaptureFrame *frame)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (frame!= NULL); assert (frame!= NULL);
if (G_UNLIKELY (self->endian != G_BYTE_ORDER)) if (G_UNLIKELY (self->endian != G_BYTE_ORDER))
{ {
@ -293,8 +295,8 @@ static inline void
sysprof_capture_reader_bswap_file_chunk (SysprofCaptureReader *self, sysprof_capture_reader_bswap_file_chunk (SysprofCaptureReader *self,
SysprofCaptureFileChunk *file_chunk) SysprofCaptureFileChunk *file_chunk)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (file_chunk != NULL); assert (file_chunk != NULL);
if (G_UNLIKELY (self->endian != G_BYTE_ORDER)) if (G_UNLIKELY (self->endian != G_BYTE_ORDER))
file_chunk->len = GUINT16_SWAP_LE_BE (file_chunk->len); file_chunk->len = GUINT16_SWAP_LE_BE (file_chunk->len);
@ -304,8 +306,8 @@ static inline void
sysprof_capture_reader_bswap_log (SysprofCaptureReader *self, sysprof_capture_reader_bswap_log (SysprofCaptureReader *self,
SysprofCaptureLog *log) SysprofCaptureLog *log)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (log != NULL); assert (log != NULL);
if (G_UNLIKELY (self->endian != G_BYTE_ORDER)) if (G_UNLIKELY (self->endian != G_BYTE_ORDER))
log->severity = GUINT16_SWAP_LE_BE (log->severity); log->severity = GUINT16_SWAP_LE_BE (log->severity);
@ -315,8 +317,8 @@ static inline void
sysprof_capture_reader_bswap_map (SysprofCaptureReader *self, sysprof_capture_reader_bswap_map (SysprofCaptureReader *self,
SysprofCaptureMap *map) SysprofCaptureMap *map)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (map != NULL); assert (map != NULL);
if (G_UNLIKELY (self->endian != G_BYTE_ORDER)) if (G_UNLIKELY (self->endian != G_BYTE_ORDER))
{ {
@ -331,8 +333,8 @@ static inline void
sysprof_capture_reader_bswap_mark (SysprofCaptureReader *self, sysprof_capture_reader_bswap_mark (SysprofCaptureReader *self,
SysprofCaptureMark *mark) SysprofCaptureMark *mark)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (mark != NULL); assert (mark != NULL);
if (G_UNLIKELY (self->endian != G_BYTE_ORDER)) if (G_UNLIKELY (self->endian != G_BYTE_ORDER))
mark->duration = GUINT64_SWAP_LE_BE (mark->duration); mark->duration = GUINT64_SWAP_LE_BE (mark->duration);
@ -342,8 +344,8 @@ static inline void
sysprof_capture_reader_bswap_jitmap (SysprofCaptureReader *self, sysprof_capture_reader_bswap_jitmap (SysprofCaptureReader *self,
SysprofCaptureJitmap *jitmap) SysprofCaptureJitmap *jitmap)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (jitmap != NULL); assert (jitmap != NULL);
if (G_UNLIKELY (self->endian != G_BYTE_ORDER)) if (G_UNLIKELY (self->endian != G_BYTE_ORDER))
jitmap->n_jitmaps = GUINT64_SWAP_LE_BE (jitmap->n_jitmaps); jitmap->n_jitmaps = GUINT64_SWAP_LE_BE (jitmap->n_jitmaps);
@ -353,9 +355,9 @@ static bool
sysprof_capture_reader_ensure_space_for (SysprofCaptureReader *self, sysprof_capture_reader_ensure_space_for (SysprofCaptureReader *self,
size_t len) size_t len)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (self->pos <= self->len); assert (self->pos <= self->len);
g_assert (len > 0); assert (len > 0);
/* Ensure alignment of length to read */ /* Ensure alignment of length to read */
len = (len + SYSPROF_CAPTURE_ALIGN - 1) & ~(SYSPROF_CAPTURE_ALIGN - 1); len = (len + SYSPROF_CAPTURE_ALIGN - 1) & ~(SYSPROF_CAPTURE_ALIGN - 1);
@ -371,8 +373,8 @@ sysprof_capture_reader_ensure_space_for (SysprofCaptureReader *self,
while (self->len < len) while (self->len < len)
{ {
g_assert ((self->pos + self->len) < self->bufsz); assert ((self->pos + self->len) < self->bufsz);
g_assert (self->len < self->bufsz); assert (self->len < self->bufsz);
/* Read into our buffer after our current read position */ /* Read into our buffer after our current read position */
r = _sysprof_pread (self->fd, r = _sysprof_pread (self->fd,
@ -396,8 +398,8 @@ sysprof_capture_reader_skip (SysprofCaptureReader *self)
{ {
SysprofCaptureFrame *frame; SysprofCaptureFrame *frame;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof (SysprofCaptureFrame))) if (!sysprof_capture_reader_ensure_space_for (self, sizeof (SysprofCaptureFrame)))
return false; return false;
@ -427,15 +429,15 @@ sysprof_capture_reader_peek_frame (SysprofCaptureReader *self,
{ {
SysprofCaptureFrame *real_frame; SysprofCaptureFrame *real_frame;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->len); assert (self->pos <= self->len);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *real_frame)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *real_frame))
return false; return false;
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
real_frame = (SysprofCaptureFrame *)(void *)&self->buf[self->pos]; real_frame = (SysprofCaptureFrame *)(void *)&self->buf[self->pos];
@ -459,8 +461,8 @@ sysprof_capture_reader_peek_type (SysprofCaptureReader *self,
{ {
SysprofCaptureFrame frame; SysprofCaptureFrame frame;
g_assert (self != NULL); assert (self != NULL);
g_assert (type != NULL); assert (type != NULL);
if (!sysprof_capture_reader_peek_frame (self, &frame)) if (!sysprof_capture_reader_peek_frame (self, &frame))
return false; return false;
@ -478,9 +480,9 @@ sysprof_capture_reader_read_basic (SysprofCaptureReader *self,
SysprofCaptureFrame *frame; SysprofCaptureFrame *frame;
size_t len = sizeof *frame + extra; size_t len = sizeof *frame + extra;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, len)) if (!sysprof_capture_reader_ensure_space_for (self, len))
return NULL; return NULL;
@ -522,7 +524,7 @@ sysprof_capture_reader_read_fork (SysprofCaptureReader *self)
{ {
SysprofCaptureFork *fk; SysprofCaptureFork *fk;
g_assert (self != NULL); assert (self != NULL);
fk = (SysprofCaptureFork *) fk = (SysprofCaptureFork *)
sysprof_capture_reader_read_basic (self, SYSPROF_CAPTURE_FRAME_FORK, sizeof (uint32_t)); sysprof_capture_reader_read_basic (self, SYSPROF_CAPTURE_FRAME_FORK, sizeof (uint32_t));
@ -541,9 +543,9 @@ sysprof_capture_reader_read_map (SysprofCaptureReader *self)
{ {
SysprofCaptureMap *map; SysprofCaptureMap *map;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *map)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *map))
return NULL; return NULL;
@ -581,9 +583,9 @@ sysprof_capture_reader_read_log (SysprofCaptureReader *self)
{ {
SysprofCaptureLog *log; SysprofCaptureLog *log;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *log)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *log))
return NULL; return NULL;
@ -623,9 +625,9 @@ sysprof_capture_reader_read_mark (SysprofCaptureReader *self)
{ {
SysprofCaptureMark *mark; SysprofCaptureMark *mark;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *mark)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *mark))
return NULL; return NULL;
@ -669,9 +671,9 @@ sysprof_capture_reader_read_metadata (SysprofCaptureReader *self)
{ {
SysprofCaptureMetadata *metadata; SysprofCaptureMetadata *metadata;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *metadata)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *metadata))
return NULL; return NULL;
@ -709,9 +711,9 @@ sysprof_capture_reader_read_process (SysprofCaptureReader *self)
{ {
SysprofCaptureProcess *process; SysprofCaptureProcess *process;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *process)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *process))
return NULL; return NULL;
@ -751,9 +753,9 @@ sysprof_capture_reader_read_jitmap (SysprofCaptureReader *self)
uint8_t *endptr; uint8_t *endptr;
unsigned int i; unsigned int i;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *jitmap)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *jitmap))
return NULL; return NULL;
@ -813,9 +815,9 @@ sysprof_capture_reader_read_sample (SysprofCaptureReader *self)
{ {
SysprofCaptureSample *sample; SysprofCaptureSample *sample;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *sample)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *sample))
return NULL; return NULL;
@ -859,9 +861,9 @@ sysprof_capture_reader_read_counter_define (SysprofCaptureReader *self)
{ {
SysprofCaptureCounterDefine *def; SysprofCaptureCounterDefine *def;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *def)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *def))
return NULL; return NULL;
@ -906,9 +908,9 @@ sysprof_capture_reader_read_counter_set (SysprofCaptureReader *self)
{ {
SysprofCaptureCounterSet *set; SysprofCaptureCounterSet *set;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *set)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *set))
return NULL; return NULL;
@ -956,7 +958,7 @@ sysprof_capture_reader_read_counter_set (SysprofCaptureReader *self)
bool bool
sysprof_capture_reader_reset (SysprofCaptureReader *self) sysprof_capture_reader_reset (SysprofCaptureReader *self)
{ {
g_assert (self != NULL); assert (self != NULL);
self->fd_off = sizeof (SysprofCaptureFileHeader); self->fd_off = sizeof (SysprofCaptureFileHeader);
self->pos = 0; self->pos = 0;
@ -968,8 +970,8 @@ sysprof_capture_reader_reset (SysprofCaptureReader *self)
SysprofCaptureReader * SysprofCaptureReader *
sysprof_capture_reader_ref (SysprofCaptureReader *self) sysprof_capture_reader_ref (SysprofCaptureReader *self)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (self->ref_count > 0); assert (self->ref_count > 0);
g_atomic_int_inc (&self->ref_count); g_atomic_int_inc (&self->ref_count);
@ -979,8 +981,8 @@ sysprof_capture_reader_ref (SysprofCaptureReader *self)
void void
sysprof_capture_reader_unref (SysprofCaptureReader *self) sysprof_capture_reader_unref (SysprofCaptureReader *self)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (self->ref_count > 0); assert (self->ref_count > 0);
if (g_atomic_int_dec_and_test (&self->ref_count)) if (g_atomic_int_dec_and_test (&self->ref_count))
sysprof_capture_reader_finalize (self); sysprof_capture_reader_finalize (self);
@ -991,9 +993,9 @@ sysprof_capture_reader_splice (SysprofCaptureReader *self,
SysprofCaptureWriter *dest, SysprofCaptureWriter *dest,
GError **error) GError **error)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (self->fd != -1); assert (self->fd != -1);
g_assert (dest != NULL); assert (dest != NULL);
/* Flush before writing anything to ensure consistency */ /* Flush before writing anything to ensure consistency */
if (!sysprof_capture_writer_flush (dest)) if (!sysprof_capture_writer_flush (dest))
@ -1035,8 +1037,8 @@ sysprof_capture_reader_save_as (SysprofCaptureReader *self,
size_t to_write; size_t to_write;
int fd = -1; int fd = -1;
g_assert (self != NULL); assert (self != NULL);
g_assert (filename != NULL); assert (filename != NULL);
if (-1 == (fd = open (filename, O_CREAT | O_WRONLY, 0640))) if (-1 == (fd = open (filename, O_CREAT | O_WRONLY, 0640)))
goto handle_errno; goto handle_errno;
@ -1065,7 +1067,7 @@ sysprof_capture_reader_save_as (SysprofCaptureReader *self,
if (written == 0 && errno != EAGAIN) if (written == 0 && errno != EAGAIN)
goto handle_errno; goto handle_errno;
g_assert (written <= (ssize_t)to_write); assert (written <= (ssize_t)to_write);
to_write -= written; to_write -= written;
} }
@ -1092,7 +1094,7 @@ handle_errno:
int64_t int64_t
sysprof_capture_reader_get_start_time (SysprofCaptureReader *self) sysprof_capture_reader_get_start_time (SysprofCaptureReader *self)
{ {
g_return_val_if_fail (self != NULL, 0); assert (self != NULL);
if (self->endian != G_BYTE_ORDER) if (self->endian != G_BYTE_ORDER)
return GUINT64_SWAP_LE_BE (self->header.time); return GUINT64_SWAP_LE_BE (self->header.time);
@ -1120,7 +1122,7 @@ sysprof_capture_reader_get_end_time (SysprofCaptureReader *self)
{ {
int64_t end_time = 0; int64_t end_time = 0;
g_return_val_if_fail (self != NULL, 0); assert (self != NULL);
if (self->header.end_time != 0) if (self->header.end_time != 0)
{ {
@ -1149,7 +1151,7 @@ sysprof_capture_reader_copy (SysprofCaptureReader *self)
SysprofCaptureReader *copy; SysprofCaptureReader *copy;
int fd; int fd;
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
if (-1 == (fd = dup (self->fd))) if (-1 == (fd = dup (self->fd)))
return NULL; return NULL;
@ -1175,7 +1177,7 @@ void
sysprof_capture_reader_set_stat (SysprofCaptureReader *self, sysprof_capture_reader_set_stat (SysprofCaptureReader *self,
const SysprofCaptureStat *st_buf) const SysprofCaptureStat *st_buf)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
if (st_buf != NULL) if (st_buf != NULL)
{ {
@ -1193,7 +1195,7 @@ bool
sysprof_capture_reader_get_stat (SysprofCaptureReader *self, sysprof_capture_reader_get_stat (SysprofCaptureReader *self,
SysprofCaptureStat *st_buf) SysprofCaptureStat *st_buf)
{ {
g_return_val_if_fail (self != NULL, FALSE); assert (self != NULL);
if (st_buf != NULL) if (st_buf != NULL)
*st_buf = self->st_buf; *st_buf = self->st_buf;
@ -1206,9 +1208,9 @@ sysprof_capture_reader_read_file (SysprofCaptureReader *self)
{ {
SysprofCaptureFileChunk *file_chunk; SysprofCaptureFileChunk *file_chunk;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *file_chunk)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *file_chunk))
return NULL; return NULL;
@ -1254,7 +1256,7 @@ sysprof_capture_reader_list_files (SysprofCaptureReader *self)
GHashTableIter iter; GHashTableIter iter;
const gchar *key; const gchar *key;
g_assert (self != NULL); assert (self != NULL);
ar = g_ptr_array_new_with_free_func (g_free); ar = g_ptr_array_new_with_free_func (g_free);
files = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); files = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
@ -1289,9 +1291,9 @@ sysprof_capture_reader_read_file_fd (SysprofCaptureReader *self,
const char *path, const char *path,
int fd) int fd)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (path != NULL); assert (path != NULL);
g_assert (fd > -1); assert (fd > -1);
for (;;) for (;;)
{ {
@ -1326,7 +1328,7 @@ sysprof_capture_reader_read_file_fd (SysprofCaptureReader *self,
if (written == 0 && errno != EAGAIN) if (written == 0 && errno != EAGAIN)
return false; return false;
g_assert (written <= (ssize_t)to_write); assert (written <= (ssize_t)to_write);
buf += written; buf += written;
to_write -= written; to_write -= written;
@ -1342,13 +1344,13 @@ sysprof_capture_reader_read_file_fd (SysprofCaptureReader *self,
return false; return false;
} }
g_return_val_if_reached (FALSE); sysprof_assert_not_reached ();
} }
int int
sysprof_capture_reader_get_byte_order (SysprofCaptureReader *self) sysprof_capture_reader_get_byte_order (SysprofCaptureReader *self)
{ {
g_return_val_if_fail (self != NULL, 0); assert (self != NULL);
return self->endian; return self->endian;
} }
@ -1359,8 +1361,8 @@ sysprof_capture_reader_find_file (SysprofCaptureReader *self,
{ {
SysprofCaptureFrameType type; SysprofCaptureFrameType type;
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
g_return_val_if_fail (path != NULL, NULL); assert (path != NULL);
while (sysprof_capture_reader_peek_type (self, &type)) while (sysprof_capture_reader_peek_type (self, &type))
{ {
@ -1389,9 +1391,9 @@ sysprof_capture_reader_read_allocation (SysprofCaptureReader *self)
{ {
SysprofCaptureAllocation *ma; SysprofCaptureAllocation *ma;
g_assert (self != NULL); assert (self != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
g_assert (self->pos <= self->bufsz); assert (self->pos <= self->bufsz);
if (!sysprof_capture_reader_ensure_space_for (self, sizeof *ma)) if (!sysprof_capture_reader_ensure_space_for (self, sizeof *ma))
return NULL; return NULL;

41
src/libsysprof-capture/sysprof-capture-types.h
View File

@ -56,6 +56,7 @@
#pragma once #pragma once
#include <assert.h>
#include <glib.h> #include <glib.h>
#include <inttypes.h> #include <inttypes.h>
#include <stddef.h> #include <stddef.h>
@ -331,27 +332,27 @@ typedef struct
} SysprofCaptureAllocation } SysprofCaptureAllocation
SYSPROF_ALIGNED_END(1); SYSPROF_ALIGNED_END(1);
G_STATIC_ASSERT (sizeof (SysprofCaptureFileHeader) == 256); static_assert (sizeof (SysprofCaptureFileHeader) == 256, "SysprofCaptureFileHeader changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureFrame) == 24); static_assert (sizeof (SysprofCaptureFrame) == 24, "SysprofCaptureFrame changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureMap) == 56); static_assert (sizeof (SysprofCaptureMap) == 56, "SysprofCaptureMap changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureJitmap) == 28); static_assert (sizeof (SysprofCaptureJitmap) == 28, "SysprofCaptureJitmap changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureProcess) == 24); static_assert (sizeof (SysprofCaptureProcess) == 24, "SysprofCaptureProcess changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureSample) == 32); static_assert (sizeof (SysprofCaptureSample) == 32, "SysprofCaptureSample changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureFork) == 28); static_assert (sizeof (SysprofCaptureFork) == 28, "SysprofCaptureFork changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureExit) == 24); static_assert (sizeof (SysprofCaptureExit) == 24, "SysprofCaptureExit changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureTimestamp) == 24); static_assert (sizeof (SysprofCaptureTimestamp) == 24, "SysprofCaptureTimestamp changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureCounter) == 128); static_assert (sizeof (SysprofCaptureCounter) == 128, "SysprofCaptureCounter changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureCounterValues) == 96); static_assert (sizeof (SysprofCaptureCounterValues) == 96, "SysprofCaptureCounterValues changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureCounterDefine) == 32); static_assert (sizeof (SysprofCaptureCounterDefine) == 32, "SysprofCaptureCounterDefine changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureCounterSet) == 32); static_assert (sizeof (SysprofCaptureCounterSet) == 32, "SysprofCaptureCounterSet changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureMark) == 96); static_assert (sizeof (SysprofCaptureMark) == 96, "SysprofCaptureMark changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureMetadata) == 64); static_assert (sizeof (SysprofCaptureMetadata) == 64, "SysprofCaptureMetadata changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureLog) == 64); static_assert (sizeof (SysprofCaptureLog) == 64, "SysprofCaptureLog changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureFileChunk) == 284); static_assert (sizeof (SysprofCaptureFileChunk) == 284, "SysprofCaptureFileChunk changed size");
G_STATIC_ASSERT (sizeof (SysprofCaptureAllocation) == 48); static_assert (sizeof (SysprofCaptureAllocation) == 48, "SysprofCaptureAllocation changed size");
G_STATIC_ASSERT ((G_STRUCT_OFFSET (SysprofCaptureAllocation, addrs) % SYSPROF_CAPTURE_ALIGN) == 0); static_assert ((offsetof (SysprofCaptureAllocation, addrs) % SYSPROF_CAPTURE_ALIGN) == 0, "SysprofCaptureAllocation.addrs is not aligned");
G_STATIC_ASSERT ((G_STRUCT_OFFSET (SysprofCaptureSample, addrs) % SYSPROF_CAPTURE_ALIGN) == 0); static_assert ((offsetof (SysprofCaptureSample, addrs) % SYSPROF_CAPTURE_ALIGN) == 0, "SysprofCaptureSample.addrs is not aligned");
static inline int static inline int
sysprof_capture_address_compare (SysprofCaptureAddress a, sysprof_capture_address_compare (SysprofCaptureAddress a,

7
src/libsysprof-capture/sysprof-capture-util.c
View File

@ -58,6 +58,7 @@
#include "config.h" #include "config.h"
#include <assert.h>
#include <errno.h> #include <errno.h>
#include <glib.h> #include <glib.h>
#include <unistd.h> #include <unistd.h>
@ -205,14 +206,14 @@ ssize_t
if (n_read <= 0) if (n_read <= 0)
return -1; return -1;
g_assert (count >= n_read); assert (count >= n_read);
count -= n_read; count -= n_read;
rpos += n_read; rpos += n_read;
while (wpos < rpos) while (wpos < rpos)
{ {
g_assert (off < sizeof buf); assert (off < sizeof buf);
errno = 0; errno = 0;
n_written = write (out_fd, &buf[off], rpos - wpos); n_written = write (out_fd, &buf[off], rpos - wpos);
@ -226,7 +227,7 @@ ssize_t
} }
} }
g_assert (count == 0); assert (count == 0);
if (offset != NULL) if (offset != NULL)
*offset = rpos; *offset = rpos;

6
src/libsysprof-capture/sysprof-capture-writer-cat.c
View File

@ -158,8 +158,8 @@ sysprof_capture_writer_cat (SysprofCaptureWriter *self,
int64_t first_start_time = INT64_MAX; int64_t first_start_time = INT64_MAX;
int64_t end_time = -1; int64_t end_time = -1;
g_return_val_if_fail (self != NULL, FALSE); assert (self != NULL);
g_return_val_if_fail (reader != NULL, FALSE); assert (reader != NULL);
sysprof_capture_reader_reset (reader); sysprof_capture_reader_reset (reader);
@ -459,7 +459,7 @@ sysprof_capture_writer_cat (SysprofCaptureWriter *self,
} }
} }
g_assert (ids->len == values->len); assert (ids->len == values->len);
sysprof_capture_writer_set_counters (self, sysprof_capture_writer_set_counters (self,
frame->frame.time, frame->frame.time,

178
src/libsysprof-capture/sysprof-capture-writer.c
View File

@ -62,6 +62,7 @@
# define _GNU_SOURCE # define _GNU_SOURCE
#endif #endif
#include <assert.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <glib/gstdio.h> #include <glib/gstdio.h>
@ -75,6 +76,7 @@
#include "sysprof-capture-reader.h" #include "sysprof-capture-reader.h"
#include "sysprof-capture-util-private.h" #include "sysprof-capture-util-private.h"
#include "sysprof-capture-writer.h" #include "sysprof-capture-writer.h"
#include "sysprof-macros-internal.h"
#define DEFAULT_BUFFER_SIZE (_sysprof_getpagesize() * 64L) #define DEFAULT_BUFFER_SIZE (_sysprof_getpagesize() * 64L)
#define INVALID_ADDRESS (G_GUINT64_CONSTANT(0)) #define INVALID_ADDRESS (G_GUINT64_CONSTANT(0))
@ -153,7 +155,7 @@ sysprof_capture_writer_frame_init (SysprofCaptureFrame *frame_,
int64_t time_, int64_t time_,
SysprofCaptureFrameType type) SysprofCaptureFrameType type)
{ {
g_assert (frame_ != NULL); assert (frame_ != NULL);
frame_->len = len; frame_->len = len;
frame_->cpu = cpu; frame_->cpu = cpu;
@ -187,8 +189,8 @@ sysprof_capture_writer_finalize (SysprofCaptureWriter *self)
SysprofCaptureWriter * SysprofCaptureWriter *
sysprof_capture_writer_ref (SysprofCaptureWriter *self) sysprof_capture_writer_ref (SysprofCaptureWriter *self)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (self->ref_count > 0); assert (self->ref_count > 0);
g_atomic_int_inc (&self->ref_count); g_atomic_int_inc (&self->ref_count);
@ -198,8 +200,8 @@ sysprof_capture_writer_ref (SysprofCaptureWriter *self)
void void
sysprof_capture_writer_unref (SysprofCaptureWriter *self) sysprof_capture_writer_unref (SysprofCaptureWriter *self)
{ {
g_assert (self != NULL); assert (self != NULL);
g_assert (self->ref_count > 0); assert (self->ref_count > 0);
if (g_atomic_int_dec_and_test (&self->ref_count)) if (g_atomic_int_dec_and_test (&self->ref_count))
sysprof_capture_writer_finalize (self); sysprof_capture_writer_finalize (self);
@ -212,9 +214,9 @@ sysprof_capture_writer_flush_data (SysprofCaptureWriter *self)
ssize_t written; ssize_t written;
size_t to_write; size_t to_write;
g_assert (self != NULL); assert (self != NULL);
g_assert (self->pos <= self->len); assert (self->pos <= self->len);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
if (self->pos == 0) if (self->pos == 0)
return true; return true;
@ -231,7 +233,7 @@ sysprof_capture_writer_flush_data (SysprofCaptureWriter *self)
if (written == 0 && errno != EAGAIN) if (written == 0 && errno != EAGAIN)
return false; return false;
g_assert (written <= (ssize_t)to_write); assert (written <= (ssize_t)to_write);
buf += written; buf += written;
to_write -= written; to_write -= written;
@ -271,9 +273,9 @@ sysprof_capture_writer_allocate (SysprofCaptureWriter *self,
{ {
void *p; void *p;
g_assert (self != NULL); assert (self != NULL);
g_assert (len != NULL); assert (len != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
sysprof_capture_writer_realign (len); sysprof_capture_writer_realign (len);
@ -284,7 +286,7 @@ sysprof_capture_writer_allocate (SysprofCaptureWriter *self,
self->pos += *len; self->pos += *len;
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
return p; return p;
} }
@ -296,12 +298,12 @@ sysprof_capture_writer_flush_jitmap (SysprofCaptureWriter *self)
ssize_t r; ssize_t r;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
if (self->addr_hash_size == 0) if (self->addr_hash_size == 0)
return true; return true;
g_assert (self->addr_buf_pos > 0); assert (self->addr_buf_pos > 0);
len = sizeof jitmap + self->addr_buf_pos; len = sizeof jitmap + self->addr_buf_pos;
@ -339,9 +341,9 @@ sysprof_capture_writer_lookup_jitmap (SysprofCaptureWriter *self,
unsigned int hash; unsigned int hash;
unsigned int i; unsigned int i;
g_assert (self != NULL); assert (self != NULL);
g_assert (name != NULL); assert (name != NULL);
g_assert (addr != NULL); assert (addr != NULL);
hash = g_str_hash (name) % G_N_ELEMENTS (self->addr_hash); hash = g_str_hash (name) % G_N_ELEMENTS (self->addr_hash);
@ -386,9 +388,9 @@ sysprof_capture_writer_insert_jitmap (SysprofCaptureWriter *self,
unsigned int hash; unsigned int hash;
unsigned int i; unsigned int i;
g_assert (self != NULL); assert (self != NULL);
g_assert (str != NULL); assert (str != NULL);
g_assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0); assert ((self->pos % SYSPROF_CAPTURE_ALIGN) == 0);
len = sizeof addr + strlen (str) + 1; len = sizeof addr + strlen (str) + 1;
@ -398,12 +400,12 @@ sysprof_capture_writer_insert_jitmap (SysprofCaptureWriter *self,
if (!sysprof_capture_writer_flush_jitmap (self)) if (!sysprof_capture_writer_flush_jitmap (self))
return INVALID_ADDRESS; return INVALID_ADDRESS;
g_assert (self->addr_hash_size == 0); assert (self->addr_hash_size == 0);
g_assert (self->addr_buf_pos == 0); assert (self->addr_buf_pos == 0);
} }
g_assert (self->addr_hash_size < G_N_ELEMENTS (self->addr_hash)); assert (self->addr_hash_size < G_N_ELEMENTS (self->addr_hash));
g_assert (len > sizeof addr); assert (len > sizeof addr);
/* Allocate the next unique address */ /* Allocate the next unique address */
addr = SYSPROF_CAPTURE_JITMAP_MARK | ++self->addr_seq; addr = SYSPROF_CAPTURE_JITMAP_MARK | ++self->addr_seq;
@ -421,7 +423,7 @@ sysprof_capture_writer_insert_jitmap (SysprofCaptureWriter *self,
/* Advance our string cache position */ /* Advance our string cache position */
self->addr_buf_pos += len; self->addr_buf_pos += len;
g_assert (self->addr_buf_pos <= sizeof self->addr_buf); assert (self->addr_buf_pos <= sizeof self->addr_buf);
/* Now place the address into the hashtable */ /* Now place the address into the hashtable */
hash = g_str_hash (str) % G_N_ELEMENTS (self->addr_hash); hash = g_str_hash (str) % G_N_ELEMENTS (self->addr_hash);
@ -454,7 +456,7 @@ sysprof_capture_writer_insert_jitmap (SysprofCaptureWriter *self,
} }
} }
g_assert_not_reached (); sysprof_assert_not_reached ();
return INVALID_ADDRESS; return INVALID_ADDRESS;
} }
@ -475,8 +477,8 @@ sysprof_capture_writer_new_from_fd (int fd,
if (buffer_size == 0) if (buffer_size == 0)
buffer_size = DEFAULT_BUFFER_SIZE; buffer_size = DEFAULT_BUFFER_SIZE;
g_assert (fd != -1); assert (fd != -1);
g_assert (buffer_size % _sysprof_getpagesize() == 0); assert (buffer_size % _sysprof_getpagesize() == 0);
/* This is only useful on files, memfd, etc */ /* This is only useful on files, memfd, etc */
if (ftruncate (fd, 0) != 0) { /* Do Nothing */ } if (ftruncate (fd, 0) != 0) { /* Do Nothing */ }
@ -528,12 +530,12 @@ sysprof_capture_writer_new_from_fd (int fd,
return NULL; return NULL;
} }
g_assert (self->pos == 0); assert (self->pos == 0);
g_assert (self->len > 0); assert (self->len > 0);
g_assert (self->len % _sysprof_getpagesize() == 0); assert (self->len % _sysprof_getpagesize() == 0);
g_assert (self->buf != NULL); assert (self->buf != NULL);
g_assert (self->addr_hash_size == 0); assert (self->addr_hash_size == 0);
g_assert (self->fd != -1); assert (self->fd != -1);
return self; return self;
} }
@ -545,8 +547,8 @@ sysprof_capture_writer_new (const char *filename,
SysprofCaptureWriter *self; SysprofCaptureWriter *self;
int fd; int fd;
g_assert (filename != NULL); assert (filename != NULL);
g_assert (buffer_size % _sysprof_getpagesize() == 0); assert (buffer_size % _sysprof_getpagesize() == 0);
if ((-1 == (fd = open (filename, O_CREAT | O_RDWR, 0640))) || if ((-1 == (fd = open (filename, O_CREAT | O_RDWR, 0640))) ||
(-1 == ftruncate (fd, 0L))) (-1 == ftruncate (fd, 0L)))
@ -577,8 +579,8 @@ sysprof_capture_writer_add_map (SysprofCaptureWriter *self,
if (filename == NULL) if (filename == NULL)
filename = ""; filename = "";
g_assert (self != NULL); assert (self != NULL);
g_assert (filename != NULL); assert (filename != NULL);
len = sizeof *ev + strlen (filename) + 1; len = sizeof *ev + strlen (filename) + 1;
@ -619,9 +621,9 @@ sysprof_capture_writer_add_mark (SysprofCaptureWriter *self,
size_t message_len; size_t message_len;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
g_assert (name != NULL); assert (name != NULL);
g_assert (group != NULL); assert (group != NULL);
if (message == NULL) if (message == NULL)
message = ""; message = "";
@ -661,8 +663,8 @@ sysprof_capture_writer_add_metadata (SysprofCaptureWriter *self,
SysprofCaptureMetadata *ev; SysprofCaptureMetadata *ev;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
g_assert (id != NULL); assert (id != NULL);
if (metadata == NULL) if (metadata == NULL)
{ {
@ -703,8 +705,8 @@ sysprof_capture_writer_add_jitmap (SysprofCaptureWriter *self,
if (name == NULL) if (name == NULL)
name = ""; name = "";
g_assert (self != NULL); assert (self != NULL);
g_assert (name != NULL); assert (name != NULL);
if (!sysprof_capture_writer_lookup_jitmap (self, name, &addr)) if (!sysprof_capture_writer_lookup_jitmap (self, name, &addr))
addr = sysprof_capture_writer_insert_jitmap (self, name); addr = sysprof_capture_writer_insert_jitmap (self, name);
@ -725,8 +727,8 @@ sysprof_capture_writer_add_process (SysprofCaptureWriter *self,
if (cmdline == NULL) if (cmdline == NULL)
cmdline = ""; cmdline = "";
g_assert (self != NULL); assert (self != NULL);
g_assert (cmdline != NULL); assert (cmdline != NULL);
len = sizeof *ev + strlen (cmdline) + 1; len = sizeof *ev + strlen (cmdline) + 1;
@ -761,7 +763,7 @@ sysprof_capture_writer_add_sample (SysprofCaptureWriter *self,
SysprofCaptureSample *ev; SysprofCaptureSample *ev;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
len = sizeof *ev + (n_addrs * sizeof (SysprofCaptureAddress)); len = sizeof *ev + (n_addrs * sizeof (SysprofCaptureAddress));
@ -795,7 +797,7 @@ sysprof_capture_writer_add_fork (SysprofCaptureWriter *self,
SysprofCaptureFork *ev; SysprofCaptureFork *ev;
size_t len = sizeof *ev; size_t len = sizeof *ev;
g_assert (self != NULL); assert (self != NULL);
ev = (SysprofCaptureFork *)sysprof_capture_writer_allocate (self, &len); ev = (SysprofCaptureFork *)sysprof_capture_writer_allocate (self, &len);
if (!ev) if (!ev)
@ -823,7 +825,7 @@ sysprof_capture_writer_add_exit (SysprofCaptureWriter *self,
SysprofCaptureExit *ev; SysprofCaptureExit *ev;
size_t len = sizeof *ev; size_t len = sizeof *ev;
g_assert (self != NULL); assert (self != NULL);
ev = (SysprofCaptureExit *)sysprof_capture_writer_allocate (self, &len); ev = (SysprofCaptureExit *)sysprof_capture_writer_allocate (self, &len);
if (!ev) if (!ev)
@ -850,7 +852,7 @@ sysprof_capture_writer_add_timestamp (SysprofCaptureWriter *self,
SysprofCaptureTimestamp *ev; SysprofCaptureTimestamp *ev;
size_t len = sizeof *ev; size_t len = sizeof *ev;
g_assert (self != NULL); assert (self != NULL);
ev = (SysprofCaptureTimestamp *)sysprof_capture_writer_allocate (self, &len); ev = (SysprofCaptureTimestamp *)sysprof_capture_writer_allocate (self, &len);
if (!ev) if (!ev)
@ -874,7 +876,7 @@ sysprof_capture_writer_flush_end_time (SysprofCaptureWriter *self)
int64_t end_time = SYSPROF_CAPTURE_CURRENT_TIME; int64_t end_time = SYSPROF_CAPTURE_CURRENT_TIME;
ssize_t ret; ssize_t ret;
g_assert (self != NULL); assert (self != NULL);
/* This field is opportunistic, so a failure is okay. */ /* This field is opportunistic, so a failure is okay. */
@ -893,7 +895,7 @@ again:
bool bool
sysprof_capture_writer_flush (SysprofCaptureWriter *self) sysprof_capture_writer_flush (SysprofCaptureWriter *self)
{ {
g_assert (self != NULL); assert (self != NULL);
return sysprof_capture_writer_flush_jitmap (self) && return sysprof_capture_writer_flush_jitmap (self) &&
sysprof_capture_writer_flush_data (self) && sysprof_capture_writer_flush_data (self) &&
@ -923,9 +925,9 @@ sysprof_capture_writer_save_as (SysprofCaptureWriter *self,
off_t pos; off_t pos;
int fd = -1; int fd = -1;
g_assert (self != NULL); assert (self != NULL);
g_assert (self->fd != -1); assert (self->fd != -1);
g_assert (filename != NULL); assert (filename != NULL);
if (-1 == (fd = open (filename, O_CREAT | O_RDWR, 0640))) if (-1 == (fd = open (filename, O_CREAT | O_RDWR, 0640)))
goto handle_errno; goto handle_errno;
@ -951,7 +953,7 @@ sysprof_capture_writer_save_as (SysprofCaptureWriter *self,
if (written == 0 && errno != EAGAIN) if (written == 0 && errno != EAGAIN)
goto handle_errno; goto handle_errno;
g_assert (written <= (ssize_t)to_write); assert (written <= (ssize_t)to_write);
to_write -= written; to_write -= written;
} }
@ -1000,8 +1002,8 @@ _sysprof_capture_writer_splice_from_fd (SysprofCaptureWriter *self,
off_t in_off; off_t in_off;
size_t to_write; size_t to_write;
g_assert (self != NULL); assert (self != NULL);
g_assert (self->fd != -1); assert (self->fd != -1);
if (-1 == fstat (fd, &stbuf)) if (-1 == fstat (fd, &stbuf))
goto handle_errno; goto handle_errno;
@ -1030,7 +1032,7 @@ _sysprof_capture_writer_splice_from_fd (SysprofCaptureWriter *self,
if (written == 0 && errno != EAGAIN) if (written == 0 && errno != EAGAIN)
goto handle_errno; goto handle_errno;
g_assert (written <= (ssize_t)to_write); assert (written <= (ssize_t)to_write);
to_write -= written; to_write -= written;
} }
@ -1067,10 +1069,10 @@ sysprof_capture_writer_splice (SysprofCaptureWriter *self,
bool ret; bool ret;
off_t pos; off_t pos;
g_assert (self != NULL); assert (self != NULL);
g_assert (self->fd != -1); assert (self->fd != -1);
g_assert (dest != NULL); assert (dest != NULL);
g_assert (dest->fd != -1); assert (dest->fd != -1);
/* Flush before writing anything to ensure consistency */ /* Flush before writing anything to ensure consistency */
if (!sysprof_capture_writer_flush (self) || !sysprof_capture_writer_flush (dest)) if (!sysprof_capture_writer_flush (self) || !sysprof_capture_writer_flush (dest))
@ -1122,8 +1124,8 @@ sysprof_capture_writer_create_reader (SysprofCaptureWriter *self,
SysprofCaptureReader *ret; SysprofCaptureReader *ret;
int copy; int copy;
g_return_val_if_fail (self != NULL, NULL); assert (self != NULL);
g_return_val_if_fail (self->fd != -1, NULL); assert (self->fd != -1);
if (!sysprof_capture_writer_flush (self)) if (!sysprof_capture_writer_flush (self))
{ {
@ -1159,8 +1161,8 @@ void
sysprof_capture_writer_stat (SysprofCaptureWriter *self, sysprof_capture_writer_stat (SysprofCaptureWriter *self,
SysprofCaptureStat *stat) SysprofCaptureStat *stat)
{ {
g_return_if_fail (self != NULL); assert (self != NULL);
g_return_if_fail (stat != NULL); assert (stat != NULL);
*stat = self->stat; *stat = self->stat;
} }
@ -1177,8 +1179,8 @@ sysprof_capture_writer_define_counters (SysprofCaptureWriter *self,
size_t len; size_t len;
unsigned int i; unsigned int i;
g_assert (self != NULL); assert (self != NULL);
g_assert (counters != NULL); assert (counters != NULL);
if (n_counters == 0) if (n_counters == 0)
return true; return true;
@ -1231,9 +1233,9 @@ sysprof_capture_writer_set_counters (SysprofCaptureWriter *self,
unsigned int field; unsigned int field;
unsigned int i; unsigned int i;
g_assert (self != NULL); assert (self != NULL);
g_assert (counters_ids != NULL || n_counters == 0); assert (counters_ids != NULL || n_counters == 0);
g_assert (values != NULL || !n_counters); assert (values != NULL || !n_counters);
if (n_counters == 0) if (n_counters == 0)
return true; return true;
@ -1299,7 +1301,7 @@ sysprof_capture_writer_request_counter (SysprofCaptureWriter *self,
{ {
int ret; int ret;
g_assert (self != NULL); assert (self != NULL);
if (MAX_COUNTERS - n_counters < self->next_counter_id) if (MAX_COUNTERS - n_counters < self->next_counter_id)
return 0; return 0;
@ -1317,7 +1319,7 @@ _sysprof_capture_writer_set_time_range (SysprofCaptureWriter *self,
{ {
ssize_t ret; ssize_t ret;
g_assert (self != NULL); assert (self != NULL);
do_start: do_start:
ret = _sysprof_pwrite (self->fd, ret = _sysprof_pwrite (self->fd,
@ -1365,7 +1367,7 @@ sysprof_capture_writer_new_from_env (size_t buffer_size)
size_t size_t
sysprof_capture_writer_get_buffer_size (SysprofCaptureWriter *self) sysprof_capture_writer_get_buffer_size (SysprofCaptureWriter *self)
{ {
g_return_val_if_fail (self != NULL, 0); assert (self != NULL);
return self->len; return self->len;
} }
@ -1383,7 +1385,7 @@ sysprof_capture_writer_add_log (SysprofCaptureWriter *self,
size_t message_len; size_t message_len;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
if (domain == NULL) if (domain == NULL)
domain = ""; domain = "";
@ -1428,7 +1430,7 @@ sysprof_capture_writer_add_file (SysprofCaptureWriter *self,
SysprofCaptureFileChunk *ev; SysprofCaptureFileChunk *ev;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
len = sizeof *ev + data_len; len = sizeof *ev + data_len;
ev = (SysprofCaptureFileChunk *)sysprof_capture_writer_allocate (self, &len); ev = (SysprofCaptureFileChunk *)sysprof_capture_writer_allocate (self, &len);
@ -1463,7 +1465,7 @@ sysprof_capture_writer_add_file_fd (SysprofCaptureWriter *self,
{ {
uint8_t data[(4096*4L) - sizeof(SysprofCaptureFileChunk)]; uint8_t data[(4096*4L) - sizeof(SysprofCaptureFileChunk)];
g_assert (self != NULL); assert (self != NULL);
for (;;) for (;;)
{ {
@ -1538,8 +1540,8 @@ sysprof_capture_writer_add_allocation (SysprofCaptureWriter *self,
size_t len; size_t len;
unsigned int n_addrs; unsigned int n_addrs;
g_assert (self != NULL); assert (self != NULL);
g_assert (backtrace_func != NULL); assert (backtrace_func != NULL);
len = sizeof *ev + (MAX_UNWIND_DEPTH * sizeof (SysprofCaptureAddress)); len = sizeof *ev + (MAX_UNWIND_DEPTH * sizeof (SysprofCaptureAddress));
ev = (SysprofCaptureAllocation *)sysprof_capture_writer_allocate (self, &len); ev = (SysprofCaptureAllocation *)sysprof_capture_writer_allocate (self, &len);
@ -1591,7 +1593,7 @@ sysprof_capture_writer_add_allocation_copy (SysprofCaptureWriter *self,
SysprofCaptureAllocation *ev; SysprofCaptureAllocation *ev;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
if (n_addrs > 0xFFF) if (n_addrs > 0xFFF)
n_addrs = 0xFFF; n_addrs = 0xFFF;
@ -1628,17 +1630,17 @@ _sysprof_capture_writer_add_raw (SysprofCaptureWriter *self,
void *begin; void *begin;
size_t len; size_t len;
g_assert (self != NULL); assert (self != NULL);
g_assert ((fr->len & 0x7) == 0); assert ((fr->len & 0x7) == 0);
g_assert (fr->type < SYSPROF_CAPTURE_FRAME_LAST); assert (fr->type < SYSPROF_CAPTURE_FRAME_LAST);
len = fr->len; len = fr->len;
if (!(begin = sysprof_capture_writer_allocate (self, &len))) if (!(begin = sysprof_capture_writer_allocate (self, &len)))
return false; return false;
g_assert (fr->len == len); assert (fr->len == len);
g_assert (fr->type < 16); assert (fr->type < 16);
memcpy (begin, fr, fr->len); memcpy (begin, fr, fr->len);

4
src/libsysprof-capture/sysprof-clock.c
View File

@ -58,9 +58,11 @@
#include "config.h" #include "config.h"
#include <assert.h>
#include <stdbool.h> #include <stdbool.h>
#include "sysprof-clock.h" #include "sysprof-clock.h"
#include "sysprof-macros-internal.h"
int sysprof_clock = -1; int sysprof_clock = -1;
@ -92,5 +94,5 @@ sysprof_clock_init (void)
} }
} }
g_assert_not_reached (); sysprof_assert_not_reached ();
} }

3
src/libsysprof-capture/sysprof-collector.c
View File

@ -60,6 +60,7 @@
# define _GNU_SOURCE # define _GNU_SOURCE
#endif #endif
#include <assert.h>
#include <glib-unix.h> #include <glib-unix.h>
#include <gio/gio.h> #include <gio/gio.h>
#include <gio/gunixconnection.h> #include <gio/gunixconnection.h>
@ -185,7 +186,7 @@ write_final_frame (MappedRingBuffer *ring)
{ {
SysprofCaptureFrame *fr; SysprofCaptureFrame *fr;
g_assert (ring != NULL); assert (ring != NULL);
if ((fr = mapped_ring_buffer_allocate (ring, sizeof *fr))) if ((fr = mapped_ring_buffer_allocate (ring, sizeof *fr)))
{ {

62
src/libsysprof-capture/sysprof-macros-internal.h Normal file
View File

@ -0,0 +1,62 @@
/* sysprof-macros.h
*
* Copyright 2020 Endless OS Foundation
*
* Author:
* - Philip Withnall <withnall@endlessm.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Subject to the terms and conditions of this license, each copyright holder
* and contributor hereby grants to those receiving rights under this license
* a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
* irrevocable (except for failure to satisfy the conditions of this license)
* patent license to make, have made, use, offer to sell, sell, import, and
* otherwise transfer this software, where such license applies only to those
* patent claims, already acquired or hereafter acquired, licensable by such
* copyright holder or contributor that are necessarily infringed by:
*
* (a) their Contribution(s) (the licensed copyrights of copyright holders
* and non-copyrightable additions of contributors, in source or binary
* form) alone; or
*
* (b) combination of their Contribution(s) with the work of authorship to
* which such Contribution(s) was added by such copyright holder or
* contributor, if, at the time the Contribution is added, such addition
* causes such combination to be necessarily infringed. The patent license
* shall not apply to any other combinations which include the
* Contribution.
*
* Except as expressly stated above, no rights or licenses from any copyright
* holder or contributor is granted under this license, whether expressly, by
* implication, estoppel or otherwise.
*
* DISCLAIMER
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* SPDX-License-Identifier: BSD-2-Clause-Patent
*/
#pragma once
#define sysprof_assert_not_reached() assert (false)