static int
glusterd_mgmt_v3_unlock_send_resp (rpcsvc_request_t *req, int32_t status)
{
gd1_mgmt_v3_unlock_rsp rsp = {{0},};
int ret = -1;
xlator_t *this = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
rsp.op_ret = status;
if (rsp.op_ret)
rsp.op_errno = errno;
glusterd_get_uuid (&rsp.uuid);
ret = glusterd_submit_reply (req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gd1_mgmt_v3_unlock_rsp);
gf_log (this->name, GF_LOG_DEBUG,
"Responded to mgmt_v3 unlock, ret: %d", ret);
return ret;
}
int
get_checksum_for_path (char *path, uint32_t *checksum)
{
int ret = -1;
int fd = -1;
GF_ASSERT (path);
GF_ASSERT (checksum);
fd = open (path, O_RDWR);
if (fd == -1) {
gf_log (THIS->name, GF_LOG_ERROR, "Unable to open %s, errno: %d",
path, errno);
goto out;
}
ret = get_checksum_for_file (fd, checksum);
out:
if (fd != -1)
close (fd);
return ret;
}
static int
glusterd_syctasked_mgmt_v3_unlock (rpcsvc_request_t *req,
gd1_mgmt_v3_unlock_req *unlock_req,
glusterd_op_lock_ctx_t *ctx)
{
int32_t ret = -1;
xlator_t *this = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
GF_ASSERT (ctx);
/* Trying to release multiple mgmt_v3 locks */
ret = glusterd_multiple_mgmt_v3_unlock (ctx->dict, ctx->uuid);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to release mgmt_v3 locks for %s",
uuid_utoa(ctx->uuid));
}
ret = glusterd_mgmt_v3_unlock_send_resp (req, ret);
gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);
return ret;
}
int32_t
gf_store_validate_key_value (char *storepath, char *key, char *val,
gf_store_op_errno_t *op_errno)
{
int ret = 0;
GF_ASSERT (op_errno);
GF_ASSERT (storepath);
if ((key == NULL) && (val == NULL)) {
ret = -1;
gf_log ("", GF_LOG_ERROR, "Glusterd store may be corrupted, "
"Invalid key and value (null) in %s", storepath);
*op_errno = GD_STORE_KEY_VALUE_NULL;
} else if (key == NULL) {
ret = -1;
gf_log ("", GF_LOG_ERROR, "Glusterd store may be corrupted, "
"Invalid key (null) in %s", storepath);
*op_errno = GD_STORE_KEY_NULL;
} else if (val == NULL) {
ret = -1;
gf_log ("", GF_LOG_ERROR, "Glusterd store may be corrupted, "
"Invalid value (null) for key %s in %s", key,
storepath);
*op_errno = GD_STORE_VALUE_NULL;
} else {
ret = 0;
*op_errno = GD_STORE_SUCCESS;
}
return ret;
}
static void
runner_insert_arg (runner_t *runner, char *arg)
{
int i = 0;
GF_ASSERT (arg);
if (runner->runerr)
return;
for (i = 0; i < runner->argvlen; i++) {
if (runner->argv[i] == NULL)
break;
}
GF_ASSERT (i < runner->argvlen);
if (i == runner->argvlen - 1) {
runner->argv = GF_REALLOC (runner->argv,
runner->argvlen * 2 * sizeof (*runner->argv));
if (!runner->argv) {
runner->runerr = errno;
return;
}
memset (/* "+" is aware of the type of its left side,
* no need to multiply with type-size */
runner->argv + runner->argvlen,
0, runner->argvlen * sizeof (*runner->argv));
runner->argvlen *= 2;
}
runner->argv[i] = arg;
}
static int
glusterd_op_state_machine_mgmt_v3_unlock (rpcsvc_request_t *req,
gd1_mgmt_v3_unlock_req *lock_req,
glusterd_op_lock_ctx_t *ctx)
{
int32_t ret = -1;
xlator_t *this = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = glusterd_op_sm_inject_event (GD_OP_EVENT_UNLOCK,
&lock_req->txn_id, ctx);
if (ret)
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_OP_EVENT_UNLOCK_FAIL,
"Failed to inject event GD_OP_EVENT_UNLOCK");
glusterd_friend_sm ();
glusterd_op_sm ();
gf_msg_trace (this->name, 0, "Returning %d", ret);
return ret;
}
int
gf_store_lock (gf_store_handle_t *sh)
{
int ret;
GF_ASSERT (sh);
GF_ASSERT (sh->path);
GF_ASSERT (sh->locked == F_ULOCK);
sh->fd = open (sh->path, O_RDWR);
if (sh->fd == -1) {
gf_log ("", GF_LOG_ERROR, "Failed to open '%s': %s", sh->path,
strerror (errno));
return -1;
}
ret = lockf (sh->fd, F_LOCK, 0);
if (ret)
gf_log ("", GF_LOG_ERROR, "Failed to gain lock on '%s': %s",
sh->path, strerror (errno));
else
/* sh->locked is protected by the lockf(sh->fd) above */
sh->locked = F_LOCK;
return ret;
}
static int
glusterd_synctasked_mgmt_v3_lock (rpcsvc_request_t *req,
gd1_mgmt_v3_lock_req *lock_req,
glusterd_op_lock_ctx_t *ctx)
{
int32_t ret = -1;
xlator_t *this = NULL;
uint32_t op_errno = 0;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
GF_ASSERT (ctx);
GF_ASSERT (ctx->dict);
/* Trying to acquire multiple mgmt_v3 locks */
ret = glusterd_multiple_mgmt_v3_lock (ctx->dict, ctx->uuid, &op_errno);
if (ret)
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_MGMTV3_LOCK_GET_FAIL,
"Failed to acquire mgmt_v3 locks for %s",
uuid_utoa (ctx->uuid));
ret = glusterd_mgmt_v3_lock_send_resp (req, ret, op_errno);
gf_msg_trace (this->name, 0, "Returning %d", ret);
return ret;
}
void
__gf_free (void *free_ptr)
{
size_t req_size = 0;
char *ptr = NULL;
uint32_t type = 0;
xlator_t *xl = NULL;
if (!gf_mem_acct_enable) {
FREE (free_ptr);
return;
}
if (!free_ptr)
return;
ptr = (char *)free_ptr - 8 - 4;
if (GF_MEM_HEADER_MAGIC != *(uint32_t *)ptr) {
//Possible corruption, assert here
GF_ASSERT (0);
}
*(uint32_t *)ptr = 0;
ptr = ptr - sizeof(xlator_t *);
memcpy (&xl, ptr, sizeof(xlator_t *));
if (!xl) {
//gf_free expects xl to be available
GF_ASSERT (0);
}
if (!xl->mem_acct.rec) {
ptr = (char *)free_ptr - GF_MEM_HEADER_SIZE;
goto free;
}
ptr = ptr - sizeof(size_t);
memcpy (&req_size, ptr, sizeof (size_t));
ptr = ptr - 4;
type = *(uint32_t *)ptr;
if (GF_MEM_TRAILER_MAGIC != *(uint32_t *)
((char *)free_ptr + req_size)) {
// This points to a memory overrun
GF_ASSERT (0);
}
*(uint32_t *) ((char *)free_ptr + req_size) = 0;
LOCK (&xl->mem_acct.rec[type].lock);
{
xl->mem_acct.rec[type].size -= req_size;
xl->mem_acct.rec[type].num_allocs--;
}
UNLOCK (&xl->mem_acct.rec[type].lock);
free:
FREE (ptr);
}
void
__gf_free (void *free_ptr)
{
size_t req_size = 0;
char *ptr = NULL;
uint32_t type = 0;
xlator_t *xl = NULL;
if (!THIS->ctx->mem_acct_enable) {
FREE (free_ptr);
return;
}
if (!free_ptr)
return;
ptr = (char *)free_ptr - 8 - 4;
//Possible corruption, assert here
GF_ASSERT (GF_MEM_HEADER_MAGIC == *(uint32_t *)ptr);
*(uint32_t *)ptr = 0;
ptr = ptr - sizeof(xlator_t *);
memcpy (&xl, ptr, sizeof(xlator_t *));
//gf_free expects xl to be available
GF_ASSERT (xl != NULL);
if (!xl->mem_acct.rec) {
ptr = (char *)free_ptr - GF_MEM_HEADER_SIZE;
goto free;
}
ptr = ptr - sizeof(size_t);
memcpy (&req_size, ptr, sizeof (size_t));
ptr = ptr - 4;
type = *(uint32_t *)ptr;
// This points to a memory overrun
GF_ASSERT (GF_MEM_TRAILER_MAGIC ==
*(uint32_t *)((char *)free_ptr + req_size));
*(uint32_t *) ((char *)free_ptr + req_size) = 0;
LOCK (&xl->mem_acct.rec[type].lock);
{
xl->mem_acct.rec[type].size -= req_size;
xl->mem_acct.rec[type].num_allocs--;
/* If all the instaces are freed up then ensure typestr is
* set to NULL */
if (!xl->mem_acct.rec[type].num_allocs)
xl->mem_acct.rec[type].typestr = NULL;
}
UNLOCK (&xl->mem_acct.rec[type].lock);
free:
FREE (ptr);
}
void
gf_store_unlock (gf_store_handle_t *sh)
{
GF_ASSERT (sh);
GF_ASSERT (sh->locked == F_LOCK);
sh->locked = F_ULOCK;
lockf (sh->fd, F_ULOCK, 0);
close (sh->fd);
}
void
gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr,
size_t size, uint32_t type)
{
char *ptr = NULL;
if (!alloc_ptr)
return;
ptr = (char *) (*alloc_ptr);
if (!xl) {
GF_ASSERT (0);
}
if (!(xl->mem_acct.rec)) {
GF_ASSERT (0);
}
if (type > xl->mem_acct.num_types) {
GF_ASSERT (0);
}
LOCK(&xl->mem_acct.rec[type].lock);
{
xl->mem_acct.rec[type].size += size;
xl->mem_acct.rec[type].num_allocs++;
xl->mem_acct.rec[type].total_allocs++;
xl->mem_acct.rec[type].max_size =
max (xl->mem_acct.rec[type].max_size,
xl->mem_acct.rec[type].size);
xl->mem_acct.rec[type].max_num_allocs =
max (xl->mem_acct.rec[type].max_num_allocs,
xl->mem_acct.rec[type].num_allocs);
}
UNLOCK(&xl->mem_acct.rec[type].lock);
*(uint32_t *)(ptr) = type;
ptr = ptr + 4;
memcpy (ptr, &size, sizeof(size_t));
ptr += sizeof (size_t);
memcpy (ptr, &xl, sizeof(xlator_t *));
ptr += sizeof (xlator_t *);
*(uint32_t *)(ptr) = GF_MEM_HEADER_MAGIC;
ptr = ptr + 4;
ptr = ptr + 8; //padding
*(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
*alloc_ptr = (void *)ptr;
return;
}
int
gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
uint32_t type, const char *typestr)
{
void *ptr = NULL;
struct mem_header *header = NULL;
if (!alloc_ptr)
return -1;
ptr = *alloc_ptr;
GF_ASSERT (xl != NULL);
GF_ASSERT (xl->mem_acct != NULL);
GF_ASSERT (type <= xl->mem_acct->num_types);
LOCK(&xl->mem_acct->rec[type].lock);
{
if (!xl->mem_acct->rec[type].typestr)
xl->mem_acct->rec[type].typestr = typestr;
xl->mem_acct->rec[type].size += size;
xl->mem_acct->rec[type].num_allocs++;
xl->mem_acct->rec[type].total_allocs++;
xl->mem_acct->rec[type].max_size =
max (xl->mem_acct->rec[type].max_size,
xl->mem_acct->rec[type].size);
xl->mem_acct->rec[type].max_num_allocs =
max (xl->mem_acct->rec[type].max_num_allocs,
xl->mem_acct->rec[type].num_allocs);
}
UNLOCK(&xl->mem_acct->rec[type].lock);
INCREMENT_ATOMIC (xl->mem_acct->lock, xl->mem_acct->refcnt);
header = (struct mem_header *) ptr;
header->type = type;
header->size = size;
header->mem_acct = xl->mem_acct;
header->magic = GF_MEM_HEADER_MAGIC;
ptr += sizeof (struct mem_header);
/* data follows in this gap of 'size' bytes */
*(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
*alloc_ptr = ptr;
return 0;
}
//设置内存统计信息
int
gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
uint32_t type, const char *typestr)
{
char *ptr = NULL;
if (!alloc_ptr)
return -1;
ptr = (char *) (*alloc_ptr);
GF_ASSERT (xl != NULL);
GF_ASSERT (xl->mem_acct.rec != NULL);
GF_ASSERT (type <= xl->mem_acct.num_types);
LOCK(&xl->mem_acct.rec[type].lock);
{
if (!xl->mem_acct.rec[type].typestr)
xl->mem_acct.rec[type].typestr = typestr;
xl->mem_acct.rec[type].size += size;
xl->mem_acct.rec[type].num_allocs++;
xl->mem_acct.rec[type].total_allocs++;
xl->mem_acct.rec[type].max_size =
max (xl->mem_acct.rec[type].max_size,
xl->mem_acct.rec[type].size);
xl->mem_acct.rec[type].max_num_allocs =
max (xl->mem_acct.rec[type].max_num_allocs,
xl->mem_acct.rec[type].num_allocs);
}
UNLOCK(&xl->mem_acct.rec[type].lock);
// http://blog.csdn.net/wangyuling1234567890/article/details/24564891 普通内存分配结构有错误
//头大小: GF_MEM_HEADER_SIZE (4 + sizeof (size_t) + sizeof (xlator_t *) + 4 + 8)
*(uint32_t *)(ptr) = type;
ptr = ptr + 4;
memcpy (ptr, &size, sizeof(size_t));
ptr += sizeof (size_t);
memcpy (ptr, &xl, sizeof(xlator_t *));
ptr += sizeof (xlator_t *);
*(uint32_t *)(ptr) = GF_MEM_HEADER_MAGIC; //魔数
ptr = ptr + 4;
ptr = ptr + 8; //padding 填充
//尾大小: GF_MEM_TRAILER_SIZE 8
*(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC; //魔数
*alloc_ptr = (void *)ptr;
return 0;
}
int
gf_store_read_and_tokenize (FILE *file, char *str, char **iter_key,
char **iter_val, gf_store_op_errno_t *store_errno)
{
int32_t ret = -1;
char *savetok = NULL;
char *key = NULL;
char *value = NULL;
char *temp = NULL;
size_t str_len = 0;
GF_ASSERT (file);
GF_ASSERT (str);
GF_ASSERT (iter_key);
GF_ASSERT (iter_val);
GF_ASSERT (store_errno);
temp = fgets (str, PATH_MAX, file);
if (temp == NULL || feof (file)) {
ret = -1;
*store_errno = GD_STORE_EOF;
goto out;
}
str_len = strlen(str);
str[str_len - 1] = '\0';
/* Truncate the "\n", as fgets stores "\n" in str */
key = strtok_r (str, "=", &savetok);
if (!key) {
ret = -1;
*store_errno = GD_STORE_KEY_NULL;
goto out;
}
value = strtok_r (NULL, "", &savetok);
if (!value) {
ret = -1;
*store_errno = GD_STORE_VALUE_NULL;
goto out;
}
*iter_key = key;
*iter_val = value;
*store_errno = GD_STORE_SUCCESS;
ret = 0;
out:
return ret;
}
int
gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
uint32_t type, const char *typestr)
{
char *ptr = NULL;
if (!alloc_ptr)
return -1;
ptr = (char *) (*alloc_ptr);
GF_ASSERT (xl != NULL);
GF_ASSERT (xl->mem_acct.rec != NULL);
GF_ASSERT (type <= xl->mem_acct.num_types);
LOCK(&xl->mem_acct.rec[type].lock);
{
if (!xl->mem_acct.rec[type].typestr)
xl->mem_acct.rec[type].typestr = typestr;
xl->mem_acct.rec[type].size += size;
xl->mem_acct.rec[type].num_allocs++;
xl->mem_acct.rec[type].total_allocs++;
xl->mem_acct.rec[type].max_size =
max (xl->mem_acct.rec[type].max_size,
xl->mem_acct.rec[type].size);
xl->mem_acct.rec[type].max_num_allocs =
max (xl->mem_acct.rec[type].max_num_allocs,
xl->mem_acct.rec[type].num_allocs);
}
UNLOCK(&xl->mem_acct.rec[type].lock);
*(uint32_t *)(ptr) = type;
ptr = ptr + 4;
memcpy (ptr, &size, sizeof(size_t));
ptr += sizeof (size_t);
memcpy (ptr, &xl, sizeof(xlator_t *));
ptr += sizeof (xlator_t *);
*(uint32_t *)(ptr) = GF_MEM_HEADER_MAGIC;
ptr = ptr + 4;
ptr = ptr + 8; //padding
*(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
*alloc_ptr = (void *)ptr;
return 0;
}
int32_t
gf_store_save_value (int fd, char *key, char *value)
{
int32_t ret = -1;
int dup_fd = -1;
FILE *fp = NULL;
GF_ASSERT (fd > 0);
GF_ASSERT (key);
GF_ASSERT (value);
dup_fd = dup (fd);
if (dup_fd == -1)
goto out;
fp = fdopen (dup_fd, "a+");
if (fp == NULL) {
gf_log ("", GF_LOG_WARNING, "fdopen failed.");
ret = -1;
goto out;
}
ret = fprintf (fp, "%s=%s\n", key, value);
if (ret < 0) {
gf_log ("", GF_LOG_WARNING, "Unable to store key: %s,"
"value: %s, error: %s", key, value,
strerror (errno));
ret = -1;
goto out;
}
ret = fflush (fp);
if (feof (fp)) {
gf_log ("", GF_LOG_WARNING,
"fflush failed, error: %s",
strerror (errno));
ret = -1;
goto out;
}
ret = 0;
out:
if (fp)
fclose (fp);
gf_log ("", GF_LOG_DEBUG, "returning: %d", ret);
return ret;
}
int
xlator_volopt_dynload (char *xlator_type, void **dl_handle,
volume_opt_list_t *opt_list)
{
int ret = -1;
char *name = NULL;
void *handle = NULL;
volume_opt_list_t *vol_opt = NULL;
GF_VALIDATE_OR_GOTO ("xlator", xlator_type, out);
GF_ASSERT (dl_handle);
if (*dl_handle)
if (dlclose (*dl_handle))
gf_log ("xlator", GF_LOG_WARNING, "Unable to close "
"previously opened handle( may be stale)."
"Ignoring the invalid handle");
ret = gf_asprintf (&name, "%s/%s.so", XLATORDIR, xlator_type);
if (-1 == ret) {
gf_log ("xlator", GF_LOG_ERROR, "asprintf failed");
goto out;
}
ret = -1;
gf_log ("xlator", GF_LOG_TRACE, "attempt to load file %s", name);
handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
if (!handle) {
gf_log ("xlator", GF_LOG_WARNING, "%s", dlerror ());
goto out;
}
*dl_handle = handle;
vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
if (!vol_opt) {
goto out;
}
if (!(vol_opt->given_opt = dlsym (handle, "options"))) {
dlerror ();
gf_log ("xlator", GF_LOG_DEBUG,
"Strict option validation not enforced -- neglecting");
}
opt_list->given_opt = vol_opt->given_opt;
INIT_LIST_HEAD (&vol_opt->list);
list_add_tail (&vol_opt->list, &opt_list->list);
ret = 0;
out:
gf_log ("xlator", GF_LOG_DEBUG, "Returning %d", ret);
return ret;
}
/*Libgfdb API Function: Used to terminate/de-initialize db connection
* (Destructor function for db connection object)
* Arguments:
* _conn_node : GFDB Connection node
* Returns : if successful return 0 or
* -ve value in case of failure*/
int
fini_db (gfdb_conn_node_t *_conn_node)
{
int ret = -1;
gfdb_db_operations_t *db_operations_t = NULL;
CHECK_CONN_NODE_GOTO (_conn_node, empty);
db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations;
GF_ASSERT (db_operations_t->fini_db_op);
ret = db_operations_t->fini_db_op(&_conn_node->gfdb_connection.
gf_db_connection);
if (ret) {
gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
LG_MSG_CLOSE_CONNECTION_FAILED, "Failed close the db "
"connection");
goto out;
}
ret = delete_conn_node (_conn_node);
if (ret) {
gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting "
"connection node from list");
}
empty:
ret = 0;
out:
return ret;
}
/*Internal function: Used initialize/map db operation of
* specified type of db plugin*/
static int
init_db_operations (gfdb_db_type_t gfdb_db_type,
gfdb_db_operations_t *gfdb_db_operations)
{
int ret = -1;
GF_ASSERT (gfdb_db_operations);
/*Clear the gfdb_db_operations*/
gfdb_db_operations = memset(gfdb_db_operations, 0,
sizeof(*gfdb_db_operations));
switch (gfdb_db_type) {
case GFDB_SQLITE3:
gf_sqlite3_fill_db_operations (gfdb_db_operations);
ret = 0;
break;
case GFDB_HYPERDEX:
case GFDB_HASH_FILE_STORE:
case GFDB_ROCKS_DB:
gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
LG_MSG_UNSUPPORTED_PLUGIN, "Plugin not supported");
break;
case GFDB_INVALID_DB:
case GFDB_DB_END:
gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0,
LG_MSG_INVALID_DB_TYPE, "Invalid DB Type");
break;
}
return ret;
}
int
gf_store_locked_local (gf_store_handle_t *sh)
{
GF_ASSERT (sh);
return (sh->locked == F_LOCK);
}
void
runner_redir (runner_t *runner, int fd, int tgt_fd)
{
GF_ASSERT (fd > 0 && fd < 3);
runner->chfd[fd] = (tgt_fd >= 0) ? tgt_fd : -2;
}
FILE *
runner_chio (runner_t *runner, int fd)
{
GF_ASSERT (fd > 0 && fd < 3);
return runner->chio[fd];
}
static int
xlator_option_validate_size_list (xlator_t *xl, const char *key,
const char *value, volume_option_t *opt,
char **op_errstr)
{
int ret = 0;
char errstr[1024] = {0, };
GF_ASSERT (value);
ret = gf_validate_size (value, opt);
if (ret)
ret = validate_list_elements (value, opt, NULL, &gf_validate_size);
if (ret) {
snprintf (errstr, 1024,
"option %s %s: '%s' is not a valid "
"size-list", key, value, value);
*op_errstr = gf_strdup (errstr);
}
return ret;
}
void *
mount3udp_thread (void *argv)
{
xlator_t *nfsx = argv;
register SVCXPRT *transp = NULL;
GF_ASSERT (nfsx);
if (glusterfs_this_set(nfsx)) {
gf_log (GF_MNT, GF_LOG_ERROR, "failed to set xlator, "
"nfs.mount-udp will not work");
return NULL;
}
transp = svcudp_create(RPC_ANYSOCK);
if (transp == NULL) {
gf_log (GF_MNT, GF_LOG_ERROR, "svcudp_create error");
return NULL;
}
if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3,
mountudp_program_3, IPPROTO_UDP)) {
gf_log (GF_MNT, GF_LOG_ERROR, "svc_register error");
return NULL;
}
svc_run ();
gf_log (GF_MNT, GF_LOG_ERROR, "svc_run returned");
return NULL;
}
/* Strips all whitespace characters in a string and returns length of new string
* on success
*/
int
gf_strip_whitespace (char *str, int len)
{
int i = 0;
int new_len = 0;
char *new_str = NULL;
GF_ASSERT (str);
new_str = GF_CALLOC (1, len + 1, gf_common_mt_char);
if (new_str == NULL)
return -1;
for (i = 0; i < len; i++) {
if (!isspace (str[i]))
new_str[new_len++] = str[i];
}
new_str[new_len] = '\0';
if (new_len != len) {
memset (str, 0, len);
strncpy (str, new_str, new_len);
}
GF_FREE (new_str);
return new_len;
}
/*Function to fill db operations*/
void
gf_sqlite3_fill_db_operations(gfdb_db_operations_t *gfdb_db_ops)
{
GF_ASSERT (gfdb_db_ops);
gfdb_db_ops->init_db_op = gf_sqlite3_init;
gfdb_db_ops->fini_db_op = gf_sqlite3_fini;
gfdb_db_ops->insert_record_op = gf_sqlite3_insert;
gfdb_db_ops->delete_record_op = gf_sqlite3_delete;
gfdb_db_ops->find_all_op = gf_sqlite3_find_all;
gfdb_db_ops->find_unchanged_for_time_op =
gf_sqlite3_find_unchanged_for_time;
gfdb_db_ops->find_recently_changed_files_op =
gf_sqlite3_find_recently_changed_files;
gfdb_db_ops->find_unchanged_for_time_freq_op =
gf_sqlite3_find_unchanged_for_time_freq;
gfdb_db_ops->find_recently_changed_files_freq_op =
gf_sqlite3_find_recently_changed_files_freq;
gfdb_db_ops->clear_files_heat_op = gf_sqlite3_clear_files_heat;
gfdb_db_ops->get_db_version = gf_sqlite3_version;
gfdb_db_ops->get_db_params = gf_sqlite3_pragma;
gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma;
}
static int
create_filetable (sqlite3 *sqlite3_db_conn)
{
int ret = -1;
char *sql_stmt = NULL;
char *sql_strerror = NULL;
GF_ASSERT(sqlite3_db_conn);
sql_stmt = sql_stmt_init();
if (!sql_stmt) {
ret = ENOMEM;
goto out;
}
GF_CREATE_STMT(sql_stmt);
ret = sqlite3_exec (sqlite3_db_conn, sql_stmt, NULL, NULL,
&sql_strerror);
if (ret != SQLITE_OK) {
gf_log (GFDB_STR_SQLITE3, GF_LOG_ERROR,
"Failed executing: %s : %s",
sql_stmt, sql_strerror);
sqlite3_free (sql_strerror);
ret = -1;
goto out;
}
ret = 0;
out:
sql_stmt_fini (&sql_stmt);
return ret;
}
int
gf_sqlite3_fini (void **db_conn)
{
int ret = -1;
gf_sql_connection_t *sql_conn = NULL;
GF_ASSERT (db_conn);
sql_conn = *db_conn;
if (sql_conn) {
if (sql_conn->sqlite3_db_conn) {
ret = gf_close_sqlite3_conn(sql_conn->sqlite3_db_conn);
if (ret) {
/*Logging of error done in
* gf_close_sqlite3_conn()*/
goto out;
}
sql_conn->sqlite3_db_conn = NULL;
}
gf_sql_connection_fini (&sql_conn);
}
*db_conn = sql_conn;
ret = 0;
out:
return ret;
}
void *
__gf_realloc (void *ptr, size_t size)
{
size_t tot_size = 0;
char *orig_ptr = NULL;
xlator_t *xl = NULL;
uint32_t type = 0;
if (!gf_mem_acct_enable)
return REALLOC (ptr, size);
tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
orig_ptr = (char *)ptr - 8 - 4;
GF_ASSERT (*(uint32_t *)orig_ptr == GF_MEM_HEADER_MAGIC);
orig_ptr = orig_ptr - sizeof(xlator_t *);
xl = *((xlator_t **)orig_ptr);
orig_ptr = (char *)ptr - GF_MEM_HEADER_SIZE;
type = *(uint32_t *)orig_ptr;
ptr = realloc (orig_ptr, tot_size);
if (!ptr) {
gf_log_nomem ("", GF_LOG_ALERT, tot_size);
return NULL;
}
gf_mem_set_acct_info (xl, (char **)&ptr, size, type);
return (void *)ptr;
}
