static gboolean
_write_log_stamp(SerializeArchive *sa, const UnixTime *stamp)
{
return serialize_write_uint64(sa, stamp->ut_sec) &&
serialize_write_uint32(sa, stamp->ut_usec) &&
serialize_write_uint32(sa, stamp->ut_gmtoff);
}
static gboolean
_write_log_stamp(SerializeArchive *sa, LogStamp *stamp)
{
return serialize_write_uint64(sa, stamp->tv_sec) &&
serialize_write_uint32(sa, stamp->tv_usec) &&
serialize_write_uint32(sa, stamp->zone_offset);
}
static void
_write_struct(SerializeArchive *sa, NVTable *self)
{
serialize_write_uint32(sa, self->size);
serialize_write_uint32(sa, self->used);
serialize_write_uint16(sa, self->index_size);
serialize_write_uint8(sa, self->num_static_entries);
serialize_write_uint32_array(sa, self->static_entries, self->num_static_entries);
serialize_write_uint32_array(sa, (guint32 *) nv_table_get_index(self), self->index_size * 2);
}
static void
_write_struct(SerializeArchive *sa, NVTable *self)
{
guint16 i;
NVDynValue *dyn_entries;
serialize_write_uint32(sa, self->size);
serialize_write_uint32(sa, self->used);
serialize_write_uint16(sa, self->num_dyn_entries);
serialize_write_uint8(sa, self->num_static_entries);
for (i = 0; i < self->num_static_entries; i++)
{
serialize_write_uint32(sa, self->static_entries[i]);
}
dyn_entries = nv_table_get_dyn_entries(self);
for (i = 0; i < self->num_dyn_entries; i++)
{
_serialize_nv_dyn_value(sa, &dyn_entries[i]);
}
}
static void
_write_meta_data(SerializeArchive *sa, NVTableMetaData *meta_data)
{
serialize_write_uint32(sa, meta_data->magic);
serialize_write_uint8(sa, meta_data->flags);
}
static void
_serialize_nv_dyn_value(SerializeArchive *sa, NVDynValue *dyn_value)
{
serialize_write_nvhandle(sa, dyn_value->handle);
serialize_write_uint32(sa, dyn_value->ofs);
};
/*
* NOTE: can only be called from the main thread (e.g. log_pipe_init/deinit).
*/
static gboolean
_add_key(PersistState *self, const gchar *key, PersistEntryHandle handle)
{
PersistEntry *entry;
gpointer key_area;
gboolean new_block_created = FALSE;
SerializeArchive *sa;
g_assert(key[0] != 0);
entry = g_new(PersistEntry, 1);
entry->ofs = handle;
g_hash_table_insert(self->keys, g_strdup(key), entry);
/* we try to insert the key into the current block first, then if it
doesn't fit, we create a new block */
while (1)
{
/* the size of the key block chain part, 4 byte for the empty string length, guint32 for the link to the next block */
guint32 chain_size = sizeof(guint32) + sizeof(guint32);
gboolean success;
key_area = persist_state_map_entry(self, self->current_key_block);
/* we reserve space for the next area pointer */
sa = serialize_buffer_archive_new(key_area + self->current_key_ofs, self->current_key_size - self->current_key_ofs - chain_size);
sa->silent = TRUE;
success =
serialize_write_cstring(sa, key, -1) &&
serialize_write_uint32(sa, handle);
if (!success)
{
serialize_archive_free(sa);
if (!new_block_created)
{
PersistEntryHandle new_block;
/* we unmap the key_area as otherwise we can't grow because of the pending maps */
persist_state_unmap_entry(self, self->current_key_block);
/* ah, we couldn't fit into the current block, create a new one and link it off the old one */
new_block = _alloc_value(self, PERSIST_STATE_KEY_BLOCK_SIZE, TRUE, 0);
if (!new_block)
{
msg_error("Unable to allocate space in the persistent file for key store",
NULL);
return FALSE;
}
key_area = persist_state_map_entry(self, self->current_key_block);
sa = serialize_buffer_archive_new(key_area + self->current_key_ofs, self->current_key_size - self->current_key_ofs);
if (!serialize_write_cstring(sa, "", 0) ||
!serialize_write_uint32(sa, new_block))
{
/* hmmm. now this is bad, we couldn't write the tail of the
block even though we always reserved space for it, this
is a programming error somewhere in this function. */
g_assert_not_reached();
}
serialize_archive_free(sa);
persist_state_unmap_entry(self, self->current_key_block);
self->current_key_block = new_block;
self->current_key_size = PERSIST_STATE_KEY_BLOCK_SIZE;
self->current_key_ofs = 0;
new_block_created = TRUE;
}
else
{
/* if this happens, that means that the current key
* entry won't fit even into a freshly initialized key
* block, this means that the key is too large. */
msg_error("Persistent key too large, it cannot be larger than somewhat less than 4k",
evt_tag_str("key", key),
NULL);
persist_state_unmap_entry(self, self->current_key_block);
return FALSE;
}
}
else
{
self->header->key_count = GUINT32_TO_BE(GUINT32_FROM_BE(self->header->key_count) + 1);
self->current_key_ofs += serialize_buffer_archive_get_pos(sa);
serialize_archive_free(sa);
persist_state_unmap_entry(self, self->current_key_block);
return TRUE;
}
}
g_assert_not_reached();
}
