*
* Copyright(c) 2016 Intel Corporation. All rights reserved.
*
- * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ *of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is furnished to do
+ * of the Software, and to permit persons to whom the Software is furnished to
+ *do
* so, subject to the following conditions:
*
- * The above copyright notice and this permission notice shall be included in all
+ * The above copyright notice and this permission notice shall be included in
+ *all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
pthread_mutex_lock(&pdb->poll_thread.mutex);
state = pdb->poll_thread.state;
pthread_mutex_unlock(&pdb->poll_thread.mutex);
- return (state == OVS_DB_POLL_STATE_RUNNING);
+ return state == OVS_DB_POLL_STATE_RUNNING;
}
/* Generate unique identifier (UID). It is used by OVS DB API
while (rem > 0) {
if ((nbytes = send(pdb->sock, data + off, rem, 0)) <= 0)
- return (-1);
+ return -1;
rem -= (size_t)nbytes;
off += (size_t)nbytes;
}
- return (0);
+ return 0;
}
/*
yajl_gen_status yajl_gen_ret;
if ((jgen = yajl_gen_alloc(NULL)) == NULL)
- return (-1);
+ return -1;
/* check & get request attributes */
if ((jparams = yajl_tree_get(jnode, params_path, yajl_t_array)) == NULL ||
}
/* clean up and return success */
yajl_gen_clear(jgen);
- return (0);
+ return 0;
yajl_gen_failure:
/* release memory */
yajl_gen_clear(jgen);
- return (-1);
+ return -1;
}
/* Get OVS DB registered callback by YAJL val. The YAJL
if ((jparams = yajl_tree_get(jnode, params_path, yajl_t_array)) == NULL ||
(yajl_tree_get(jnode, id_path, yajl_t_null) == NULL)) {
OVS_ERROR("invalid OVS DB request received");
- return (-1);
+ return -1;
}
/* check array length: [<json-value>, <table-updates>] */
if ((YAJL_GET_ARRAY(jparams) == NULL) ||
(YAJL_GET_ARRAY(jparams)->len != 2)) {
OVS_ERROR("invalid OVS DB request received");
- return (-1);
+ return -1;
}
jvalue = YAJL_GET_ARRAY(jparams)->values[0];
jtable_updates = YAJL_GET_ARRAY(jparams)->values[1];
if ((!YAJL_IS_OBJECT(jtable_updates)) || (!YAJL_IS_STRING(jvalue))) {
OVS_ERROR("invalid OVS DB request id or table update received");
- return (-1);
+ return -1;
}
/* find registered callback based on <json-value> */
if (cb == NULL || cb->table.call == NULL) {
OVS_ERROR("No OVS DB table update callback found");
pthread_mutex_unlock(&pdb->mutex);
- return (-1);
+ return -1;
}
/* call registered callback */
/* check & get result attributes */
if (!jresult || !jerror || !jid)
- return (-1);
+ return -1;
/* try to find registered callback */
pthread_mutex_lock(&pdb->mutex);
}
pthread_mutex_unlock(&pdb->mutex);
- return (0);
+ return 0;
}
/* Handle JSON data (one request) and call
/* duplicate the data to make null-terminated string
* required for yajl_tree_parse() */
if ((sjson = calloc(1, len + 1)) == NULL)
- return (-1);
+ return -1;
sstrncpy(sjson, data, len + 1);
OVS_DEBUG("[len=%zu] %s", len, sjson);
if (jnode == NULL) {
OVS_ERROR("yajl_tree_parse() %s", yajl_errbuf);
sfree(sjson);
- return (-1);
+ return -1;
}
/* get method name */
if ((method = YAJL_GET_STRING(jval)) == NULL) {
yajl_tree_free(jnode);
sfree(sjson);
- return (-1);
+ return -1;
}
if (strcmp("echo", method) == 0) {
/* echo request from the server */
/* release memory */
yajl_tree_free(jnode);
sfree(sjson);
- return (0);
+ return 0;
}
/*
/* allocate new chunk of memory */
new_buff = realloc(jreader->buff_ptr, (jreader->buff_size + data_len));
if (new_buff == NULL)
- return (-1);
+ return -1;
/* point to new allocated memory */
jreader->buff_ptr = new_buff;
/* store input data */
memcpy(jreader->buff_ptr + jreader->buff_offset, data, data_len);
jreader->buff_offset += data_len;
- return (0);
+ return 0;
}
/* Pop one fully-fledged JSON if already exists. Returns 0 if
*json_ptr = jreader->buff_ptr + jreader->json_offset;
*json_len_ptr = json_len + 1;
jreader->json_offset = i + 1;
- return (0);
+ return 0;
}
/* increase JSON data length */
jreader->json_offset = 0;
}
- return (-1);
+ return -1;
}
/* Reset JSON reader. It is useful when start processing
/* create JSON reader instance */
if ((jreader = ovs_json_reader_alloc()) == NULL) {
OVS_ERROR("initialize json reader failed");
- return (NULL);
+ return NULL;
}
/* poll data */
OVS_DEBUG("poll thread has been completed");
ovs_json_reader_free(jreader);
- return (NULL);
+ return NULL;
}
/* EVENT worker thread.
}
OVS_DEBUG("event thread has been completed");
- return (NULL);
+ return NULL;
}
/* Initialize EVENT thread */
pdb->event_thread.tid = (pthread_t)-1;
/* init event thread condition variable */
if (pthread_cond_init(&pdb->event_thread.cond, NULL)) {
- return (-1);
+ return -1;
}
/* init event thread mutex */
if (pthread_mutex_init(&pdb->event_thread.mutex, NULL)) {
pthread_cond_destroy(&pdb->event_thread.cond);
- return (-1);
+ return -1;
}
/* Hold the event thread mutex. It ensures that no events
* will be lost while thread is still starting. Once event
if (pthread_mutex_lock(&pdb->event_thread.mutex)) {
pthread_mutex_destroy(&pdb->event_thread.mutex);
pthread_cond_destroy(&pdb->event_thread.cond);
- return (-1);
+ return -1;
}
/* start event thread */
pthread_t tid;
pthread_mutex_unlock(&pdb->event_thread.mutex);
pthread_mutex_destroy(&pdb->event_thread.mutex);
pthread_cond_destroy(&pdb->event_thread.cond);
- return (-1);
+ return -1;
}
pdb->event_thread.tid = tid;
- return (0);
+ return 0;
}
/* Destroy EVENT thread */
static int ovs_db_event_thread_destroy(ovs_db_t *pdb) {
if (pdb->event_thread.tid == (pthread_t)-1)
/* already destroyed */
- return (0);
+ return 0;
ovs_db_event_post(pdb, OVS_DB_EVENT_TERMINATE);
if (pthread_join(pdb->event_thread.tid, NULL) != 0)
- return (-1);
+ return -1;
/* Event thread always holds the thread mutex when
* performs some task (handles event) and releases it when
* while sleeping. Thus, if event thread exits, the mutex
pthread_mutex_destroy(&pdb->event_thread.mutex);
pthread_cond_destroy(&pdb->event_thread.cond);
pdb->event_thread.tid = (pthread_t)-1;
- return (0);
+ return 0;
}
/* Initialize POLL thread */
pdb->poll_thread.tid = (pthread_t)-1;
/* init event thread mutex */
if (pthread_mutex_init(&pdb->poll_thread.mutex, NULL)) {
- return (-1);
+ return -1;
}
/* start poll thread */
pthread_t tid;
if (plugin_thread_create(&tid, NULL, ovs_poll_worker, pdb,
"utils_ovs:poll") != 0) {
pthread_mutex_destroy(&pdb->poll_thread.mutex);
- return (-1);
+ return -1;
}
pdb->poll_thread.tid = tid;
- return (0);
+ return 0;
}
/* Destroy POLL thread */
static int ovs_db_poll_thread_destroy(ovs_db_t *pdb) {
if (pdb->poll_thread.tid == (pthread_t)-1)
/* already destroyed */
- return (0);
+ return 0;
/* change thread state */
pthread_mutex_lock(&pdb->poll_thread.mutex);
pdb->poll_thread.state = OVS_DB_POLL_STATE_EXITING;
pthread_mutex_unlock(&pdb->poll_thread.mutex);
/* join the thread */
if (pthread_join(pdb->poll_thread.tid, NULL) != 0)
- return (-1);
+ return -1;
pthread_mutex_destroy(&pdb->poll_thread.mutex);
pdb->poll_thread.tid = (pthread_t)-1;
- return (0);
+ return 0;
}
/*
const char *unix_path, ovs_db_callback_t *cb) {
/* sanity check */
if (node == NULL || service == NULL || unix_path == NULL)
- return (NULL);
+ return NULL;
/* allocate db data & fill it */
ovs_db_t *pdb = pdb = calloc(1, sizeof(*pdb));
if (pdb == NULL)
- return (NULL);
+ return NULL;
/* store the OVS DB address */
sstrncpy(pdb->node, node, sizeof(pdb->node));
if (pthread_mutexattr_init(&mutex_attr)) {
OVS_ERROR("OVS DB mutex attribute init failed");
sfree(pdb);
- return (NULL);
+ return NULL;
}
/* set OVS DB mutex as recursive */
if (pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE)) {
OVS_ERROR("Failed to set OVS DB mutex as recursive");
pthread_mutexattr_destroy(&mutex_attr);
sfree(pdb);
- return (NULL);
+ return NULL;
}
/* init OVS DB mutex */
if (pthread_mutex_init(&pdb->mutex, &mutex_attr)) {
OVS_ERROR("OVS DB mutex init failed");
pthread_mutexattr_destroy(&mutex_attr);
sfree(pdb);
- return (NULL);
+ return NULL;
}
/* destroy mutex attributes */
pthread_mutexattr_destroy(&mutex_attr);
/* init event thread */
if (ovs_db_event_thread_init(pdb) < 0) {
ovs_db_destroy(pdb);
- return (NULL);
+ return NULL;
}
/* init polling thread */
pdb->sock = -1;
if (ovs_db_poll_thread_init(pdb) < 0) {
ovs_db_destroy(pdb);
- return (NULL);
+ return NULL;
}
return pdb;
}
/* sanity check */
if (!pdb || !method || !params)
- return (-1);
+ return -1;
if ((jgen = yajl_gen_alloc(NULL)) == NULL)
- return (-1);
+ return -1;
/* try to parse params */
if ((jparams = yajl_tree_parse(params, NULL, 0)) == NULL) {
OVS_ERROR("params is not a JSON string");
yajl_gen_clear(jgen);
- return (-1);
+ return -1;
}
/* generate method field */
/* generate id field */
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "id");
uid = ovs_uid_generate();
- ssnprintf(uid_buff, sizeof(uid_buff), "%" PRIX64, uid);
+ snprintf(uid_buff, sizeof(uid_buff), "%" PRIX64, uid);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, uid_buff);
OVS_YAJL_CALL(yajl_gen_map_close, jgen);
/* sanity check */
if (pdb == NULL || tb_name == NULL || update_cb == NULL)
- return (-1);
+ return -1;
/* allocate new update callback */
if ((new_cb = calloc(1, sizeof(ovs_callback_t))) == NULL)
- return (-1);
+ return -1;
/* init YAJL generator */
if ((jgen = yajl_gen_alloc(NULL)) == NULL) {
sfree(new_cb);
- return (-1);
+ return -1;
}
/* add new callback to front */
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, OVS_DB_DEFAULT_DB_NAME);
/* uid string <json-value> */
- ssnprintf(uid_str, sizeof(uid_str), "%" PRIX64, new_cb->uid);
+ snprintf(uid_str, sizeof(uid_str), "%" PRIX64, new_cb->uid);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, uid_str);
/* <monitor-requests> */
/* sanity check */
if (pdb == NULL)
- return (-1);
+ return -1;
/* try to lock the structure before releasing */
if ((ret = pthread_mutex_lock(&pdb->mutex))) {
OVS_ERROR("pthread_mutex_lock() DB mutex lock failed (%d)", ret);
- return (-1);
+ return -1;
}
/* stop poll thread */