/*
* Private functions
*/
static void cam_configure_dmac(p_camera_context_t camera_context)
{
unsigned int des_physical;
camera_frame_buffer_queue_t *queue;
queue = (camera_context->capture_mode == CAMERA_MODE_VIDEO)?
&(camera_context->video_capture_buffer_queue):
&(camera_context->still_capture_buffer_queue);
if (queue->head == NULL)
return;
des_physical = DESCR(queue->head, 0, phy, FIRST, REAL);
ci_dma_load_descriptor(des_physical, CI_DMA_CHANNEL_0);
if (camera_context->fifo1_transfer_size) {
des_physical = DESCR(queue->head, 1, phy, FIRST, REAL);
ci_dma_load_descriptor(des_physical, CI_DMA_CHANNEL_1);
}
if (camera_context->fifo2_transfer_size) {
des_physical = DESCR(queue->head, 2, phy, FIRST, REAL);
ci_dma_load_descriptor(des_physical, CI_DMA_CHANNEL_2);
}
camera_context->dma_running = 1;
}
static void
test_content_dedup(gconstpointer test_data)
{
guint num_duplicates = *(guint*)test_data;
void change_chunk_hash(GSList *beans, guint start) {
guint8 counter = start;
for (GSList *cursor = beans;
cursor;
cursor = cursor->next) {
if (DESCR(cursor->data) == &descr_struct_CHUNKS) {
GByteArray *hash = CHUNKS_get_hash(cursor->data);
hash->data[0] = counter;
CHUNKS_set_hash(cursor->data, hash); // no-op because same pointer
counter++;
} else if (DESCR(cursor->data) == &descr_struct_CONTENTS_HEADERS) {
GByteArray *hash = g_byte_array_sized_new(16);
GRID_INFO("---- forging content hash ----");
for (guint8 i = 0; i < 16; i++) {
hash->data[i] = i + 1;
}
CONTENTS_HEADERS_set_hash(cursor->data, hash);
}
}
}
static void
encode_bean (GString *g, gpointer bean)
{
if (DESCR(bean) == &descr_struct_CHUNKS)
return encode_chunk (g, bean);
if (DESCR(bean) == &descr_struct_CONTENTS)
return encode_content (g, bean);
if (DESCR(bean) == &descr_struct_CONTENTS_HEADERS)
return encode_header (g, bean);
if (DESCR(bean) == &descr_struct_ALIASES)
return encode_alias (g, bean);
if (DESCR(bean) == &descr_struct_PROPERTIES)
return encode_property (g, bean);
g_assert_not_reached ();
}
static gchar *
_bean_query_DELETE(gpointer bean)
{
GString *gstr = g_string_new("");
g_string_printf(gstr, "DELETE FROM %s WHERE ", DESCR(bean)->sql_name);
return g_string_free(_bean_clause(bean, gstr, TRUE), FALSE);
}
/**
* Extract host, port and chunk hexadecimal id from a bean.
*
* @param bean A pointer to a bean_CHUNKS_s or bean_CONTENTS_s
* @param[out] host
* @param[out] port
* @param[out] chunk_hexid The chunk hexadecimal id (with leading '/')
* @param[out] err
*/
static void extract_chunk_url(gpointer bean,
gchar **host, gint *port, gchar **chunk_hexid, GError **err)
{
gchar *cid_url = NULL;
if (DESCR(bean) == &descr_struct_CHUNKS) {
cid_url = CHUNKS_get_id((struct bean_CHUNKS_s*)bean)->str;
} else if (DESCR(bean) == &descr_struct_CONTENTS) {
cid_url = CONTENTS_get_chunk_id((struct bean_CONTENTS_s*)bean)->str;
} else {
if (err)
*err = NEWERROR(0, "Invalid 'bean' argument, must be "
"(struct bean_CHUNKS_s*) or (struct bean_CONTENTS_s*)");
else
return;
}
return split_chunk_url(cid_url, host, port, chunk_hexid, err);
}
static int
_update_content_storage_policy(struct gridd_filter_ctx_s *ctx, struct meta2_backend_s *m2b,
struct oio_url_s *url, const char *stgpol)
{
GError *e = NULL;
GSList *beans = NULL;
gpointer alias = NULL;
gpointer header = NULL;
void _get_alias_header_cb(gpointer udata, gpointer bean) {
(void) udata;
if(DESCR(bean) == &descr_struct_ALIASES)
alias = bean;
else if (DESCR(bean) == &descr_struct_CONTENTS_HEADERS)
header = bean;
else
_bean_clean(bean);
}
/**
* Inserts a bean (chunk or contents_headers) in a hashtable,
* the key being the hash of the bean
*/
static void _add_to_hashtable_cb(gpointer hashtable, gpointer bean)
{
GHashTable *_chunks_by_hash = (GHashTable *)hashtable;
GByteArray *hash = NULL;
if (DESCR(bean) == &descr_struct_CHUNKS) {
hash = CHUNKS_get_hash(bean);
} else if (DESCR(bean) == &descr_struct_CONTENTS_HEADERS) {
hash = CONTENTS_HEADERS_get_hash(bean);
} else {
g_assert_not_reached();
}
GSList *chunk_list = g_hash_table_lookup(_chunks_by_hash, hash);
if (chunk_list != NULL) {
/* Remove it without freeing it */
g_hash_table_steal(_chunks_by_hash, hash);
}
/* No problem if the key was not found: NULL is a valid GSList* */
g_hash_table_insert(_chunks_by_hash, hash, g_slist_prepend(chunk_list, bean));
}
void s3_list_cb(gpointer ignored, gpointer bean)
{
(void) ignored;
if(max > 0) {
if(DESCR(bean) == &descr_struct_ALIASES) {
check_alias(bean);
max--;
if(0 == max)
next_marker = g_strdup(ALIASES_get_alias(bean)->str);
} else {
_get_cb(obc, bean);
}
return;
}
if(DESCR(bean) == &descr_struct_ALIASES) {
truncated = TRUE;
}
_bean_clean(bean);
}
GByteArray*
m2v2_remote_pack_SPARE(GByteArray *sid, struct hc_url_s *url,
const gchar *pol, GSList *notin_list, GSList *broken_list)
{
struct message_s *msg;
gchar *spare_type = M2V2_SPARE_BY_STGPOL;
GByteArray *body = NULL;
GSList *beans = NULL;
if (notin_list != NULL) {
spare_type = M2V2_SPARE_BY_BLACKLIST;
for (GSList *l = notin_list; l != NULL; l = l->next) {
if (DESCR(l->data) != &descr_struct_CHUNKS)
continue;
beans = g_slist_prepend(beans, _bean_dup(l->data));
}
}
for (GSList *l = broken_list; l != NULL; l = l->next) {
if (DESCR(l->data) != &descr_struct_CHUNKS)
continue;
struct bean_CHUNKS_s *chunk = _bean_dup(l->data);
// This makes difference between valid and broken chunks
CHUNKS_set_size(chunk, -1);
beans = g_slist_prepend(beans, chunk);
}
/* body is only mandatory for M2V2_SPARE_BY_BLACKLIST so when
* notin_list != NULL. If not_in_list != NULL, beans is always
* != NULL so body is sent.
*/
if (beans != NULL)
body = bean_sequence_marshall(beans);
msg = _m2v2_build_request("M2V2_BEANS", sid, url, body);
message_add_fields_str(msg,
M2_KEY_STORAGE_POLICY, pol,
M2_KEY_SPARE, spare_type,
NULL);
_bean_cleanl2(beans);
return message_marshall_gba_and_clean(msg);
}
static void
_json_BEAN_only(GString *gstr, GSList *l, gconstpointer selector,
gboolean extend, void (*encoder)(GString*,gpointer))
{
gboolean first = TRUE;
for (; l ;l=l->next) {
if (selector && DESCR(l->data) != selector)
continue;
if (!first)
g_string_append_c(gstr, ',');
first = FALSE;
g_string_append_c (gstr, '{');
if (extend)
g_string_append_printf (gstr, "\"type\":\"%s\",",
DESCR(l->data)->name);
encoder(gstr, l->data);
g_string_append_c (gstr, '}');
}
}
static GString*
_bean_clause(gpointer bean, GString *gstr, gboolean pk_only)
{
guint count;
const struct field_descriptor_s *fd;
if (!gstr)
gstr = g_string_sized_new(3 * DESCR(bean)->count_fields);
for (count=0,fd=DESCR(bean)->fields; fd->name ;fd++) {
if (pk_only && !fd->pk)
continue;
if (count)
g_string_append(gstr, " AND ");
g_string_append(gstr, fd->name);
g_string_append_c(gstr, '=');
g_string_append_c(gstr, '?');
count ++;
}
return gstr;
}
static struct beans_content_s *
_beans_to_content(const GSList *beans)
{
struct beans_content_s *c = g_malloc0(sizeof(struct beans_content_s));
GPtrArray *contents, *chunks;
chunk_pair_t pair;
contents = g_ptr_array_new();
chunks = g_ptr_array_new();
/*dispatch */
for(; beans; beans = beans->next) {
if (DESCR(beans->data) == &descr_struct_CHUNKS)
g_ptr_array_add(chunks, _bean_dup(beans->data));
else if (DESCR(beans->data) == &descr_struct_CONTENTS)
g_ptr_array_add(contents, _bean_dup(beans->data));
else if (DESCR(beans->data) == &descr_struct_CONTENTS_HEADERS)
c->header = _bean_dup(beans->data);
else if (DESCR(beans->data) == &descr_struct_ALIASES)
c->alias = _bean_dup(beans->data);
else if (DESCR(beans->data) == &descr_struct_PROPERTIES)
c->properties = g_slist_append(c->properties, _bean_dup(beans->data));
}
/* build pairs */
c->pairs = g_array_new(FALSE, FALSE, sizeof(chunk_pair_t));
for(guint i=0; i < contents->len ; i++) {
init_chunk_pair(chunks, &pair, g_ptr_array_index(contents, i));
if(pair.chunk != NULL)
g_array_append_vals(c->pairs, &pair, 1);
}
g_array_sort(c->pairs, (GCompareFunc) compare_pairs_positions);
// what we want to preserve are the pointers to beans created by
// _bean_dup, not the GPtrArray -> we can safely free the arrays.
g_ptr_array_unref(contents);
g_ptr_array_unref(chunks);
return c;
}
static int
_list_S3(struct gridd_filter_ctx_s *ctx, struct gridd_reply_ctx_s *reply,
struct list_params_s *lp, GSList *headers)
{
GError *e = NULL;
struct meta2_backend_s *m2b = meta2_filter_ctx_get_backend(ctx);
struct hc_url_s *url = meta2_filter_ctx_get_url(ctx);
struct on_bean_ctx_s *obc = _on_bean_ctx_init(ctx, reply);
gboolean truncated = FALSE;
char *next_marker = NULL;
gchar **properties = NULL;
if (lp->maxkeys <= 0)
lp->maxkeys = OIO_M2V2_LISTRESULT_BATCH;
GRID_DEBUG("LP H:%d A:%d D:%d prefix:%s marker:%s end:%s max:%"G_GINT64_FORMAT,
lp->flag_headers, lp->flag_allversion, lp->flag_nodeleted,
lp->prefix, lp->marker_start, lp->marker_end, lp->maxkeys);
// XXX the underlying meta2_backend_list_aliases() function MUST
// return headers before the associated alias.
gint64 max = lp->maxkeys;
void s3_list_cb(gpointer ignored, gpointer bean) {
(void) ignored;
if (max > 0) {
if (DESCR(bean) == &descr_struct_ALIASES) {
_bean_list_cb(&obc->l, bean);
if (0 == --max)
next_marker = g_strdup(ALIASES_get_alias(bean)->str);
} else {
_bean_list_cb(&obc->l, bean);
}
} else {
if (DESCR(bean) == &descr_struct_ALIASES)
truncated = TRUE;
_bean_clean(bean);
}
}
static void
_json_BEAN_only(GString *gstr, GSList *l, gconstpointer selector,
void (*code)(GString*,gpointer))
{
gboolean first = TRUE;
for (; l ;l=l->next) {
if (DESCR(l->data) != selector)
continue;
if (!first)
g_string_append_c(gstr, ',');
first = FALSE;
code(gstr, l->data);
}
}
static GSList *
convert_chunks_to_srvinfo(struct grid_lbpool_s *lbp, GSList *src)
{
GSList *result = NULL;
for (GSList *l=src; l ;l=l->next) {
if (!l->data || DESCR(l->data) != &descr_struct_CHUNKS)
continue;
struct service_info_s *si = NULL;
GError *e = service_info_from_chunk_id(lbp, CHUNKS_get_id(l->data)->str, &si);
if (NULL != e) {
GRID_WARN("CHUNK -> ServiceInfo conversion error : (%d) %s",
e->code, e->message);
g_clear_error(&e);
continue;
}
result = g_slist_prepend(result, si);
}
return result;
}
