size_t
del_entry_fn(void *data, char *buffer, gf_boolean_t encode)
{
char *tmpbuf = NULL;
size_t bufsz = 0;
struct changelog_entry_fields *ce = NULL;
ce = (struct changelog_entry_fields *)data;
if (encode) {
tmpbuf = uuid_utoa(ce->cef_uuid);
CHANGELOG_FILL_BUFFER(buffer, bufsz, tmpbuf, strlen(tmpbuf));
} else {
CHANGELOG_FILL_BUFFER(buffer, bufsz, ce->cef_uuid, sizeof(uuid_t));
}
CHANGELOG_FILL_BUFFER(buffer, bufsz, "/", 1);
CHANGELOG_FILL_BUFFER(buffer, bufsz, ce->cef_bname, strlen(ce->cef_bname));
CHANGELOG_FILL_BUFFER(buffer, bufsz, "\0", 1);
if (ce->cef_path[0] == '\0') {
CHANGELOG_FILL_BUFFER(buffer, bufsz, "\0", 1);
} else {
CHANGELOG_FILL_BUFFER(buffer, bufsz, ce->cef_path,
strlen(ce->cef_path));
}
return bufsz;
}
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
quota_conf_write_gfid (int fd, void *buf, char type)
{
int ret = 0;
ret = gf_nwrite (fd, buf, 16);
if (ret != 16) {
ret = -1;
goto out;
}
ret = gf_nwrite (fd, &type, 1);
if (ret != 1) {
ret = -1;
goto out;
}
ret = 0;
out:
if (ret < 0)
gf_log_callingfn ("quota", GF_LOG_ERROR, "failed to write "
"gfid %s to a quota conf", uuid_utoa (buf));
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;
}
int
gf_sql_update_delete_wind (gf_sql_connection_t *sql_conn,
gfdb_db_record_t *gfdb_db_record)
{
int ret = -1;
char *gfid_str = NULL;
char *pargfid_str = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
if (!gfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating gfid string failed.");
goto out;
}
pargfid_str = gf_strdup (uuid_utoa(gfdb_db_record->pargfid));
if (!pargfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating pargfid_str "
"string failed.");
goto out;
}
if (gfdb_db_record->link_consistency) {
ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str,
gfdb_db_record->file_name, 1,
_gf_false);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_UPDATE_FAILED,
"Failed updating link flags in wind");
goto out;
}
}
ret = 0;
out:
GF_FREE (gfid_str);
GF_FREE (pargfid_str);
return ret;
}
int32_t
glusterd_conn_build_socket_filepath (char *rundir, uuid_t uuid,
char *socketpath, int len)
{
char sockfilepath[PATH_MAX] = {0,};
snprintf (sockfilepath, sizeof (sockfilepath), "%s/run-%s",
rundir, uuid_utoa (uuid));
glusterd_set_socket_filepath (sockfilepath, socketpath, len);
return 0;
}
int
nfs_inode_loc_fill (inode_t *inode, loc_t *loc, int how)
{
char *resolvedpath = NULL;
inode_t *parent = NULL;
int ret = -EFAULT;
if ((!inode) || (!loc))
return ret;
/* If gfid is not null, then the inode is already linked to
* the inode table, and not a newly created one. For newly
* created inode, inode_path returns null gfid as the path.
*/
if (!gf_uuid_is_null (inode->gfid)) {
ret = inode_path (inode, NULL, &resolvedpath);
if (ret < 0) {
gf_msg (GF_NFS, GF_LOG_ERROR, 0,
NFS_MSG_PATH_RESOLVE_FAIL, "path resolution "
"failed %s", resolvedpath);
goto err;
}
}
if (resolvedpath == NULL) {
char tmp_path[GFID_STR_PFX_LEN + 1] = {0,};
snprintf (tmp_path, sizeof (tmp_path), "<gfid:%s>",
uuid_utoa (loc->gfid));
resolvedpath = gf_strdup (tmp_path);
} else {
parent = inode_parent (inode, loc->pargfid, NULL);
}
ret = nfs_loc_fill (loc, inode, parent, resolvedpath);
if (ret < 0) {
gf_msg (GF_NFS, GF_LOG_ERROR, -ret,
NFS_MSG_LOC_FILL_RESOLVE_FAIL,
"loc fill resolution failed %s", resolvedpath);
goto err;
}
ret = 0;
err:
if (parent)
inode_unref (parent);
GF_FREE (resolvedpath);
return ret;
}
int
glfs_graph_setup (struct glfs *fs, glusterfs_graph_t *graph)
{
if (fs->active_subvol == graph->top)
return 0;
pthread_mutex_lock (&fs->mutex);
{
fs->active_subvol = graph->top;
pthread_cond_broadcast (&fs->cond);
}
pthread_mutex_unlock (&fs->mutex);
gf_log ("glfs-master", GF_LOG_INFO, "switched to graph %s (%d)",
uuid_utoa ((unsigned char *)graph->graph_uuid), graph->id);
return 0;
}
{
int ret = -1;
loc_t loc = {0,};
dict_t *xattr = NULL;
dict_t *old_xattr = NULL;
afr_private_t *priv = NULL;
int i = 0;
priv = this->private;
loc.inode = inode_ref (inode);
gf_uuid_copy (loc.gfid, inode->gfid);
gf_msg (this->name, GF_LOG_INFO, 0,
AFR_MSG_SELF_HEAL_INFO, "performing metadata selfheal on %s",
uuid_utoa (inode->gfid));
ret = syncop_getxattr (priv->children[source], &loc, &xattr, NULL,
NULL, NULL);
if (ret < 0) {
ret = -EIO;
goto out;
}
afr_delete_ignorable_xattrs (xattr);
for (i = 0; i < priv->child_count; i++) {
if (old_xattr) {
dict_unref (old_xattr);
old_xattr = NULL;
}
static int
glusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req)
{
gd1_mgmt_v3_unlock_req lock_req = {{0},};
int32_t ret = -1;
glusterd_op_lock_ctx_t *ctx = NULL;
glusterd_peerinfo_t *peerinfo = NULL;
xlator_t *this = NULL;
gf_boolean_t is_synctasked = _gf_false;
gf_boolean_t free_ctx = _gf_false;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &lock_req,
(xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);
if (ret < 0) {
gf_log (this->name, GF_LOG_ERROR, "Failed to decode unlock "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
gf_log (this->name, GF_LOG_DEBUG, "Received volume unlock req "
"from uuid: %s", uuid_utoa (lock_req.uuid));
if (glusterd_friend_find_by_uuid (lock_req.uuid, &peerinfo)) {
gf_log (this->name, GF_LOG_WARNING, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (lock_req.uuid));
ret = -1;
goto out;
}
ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);
if (!ctx) {
ret = -1;
goto out;
}
uuid_copy (ctx->uuid, lock_req.uuid);
ctx->req = req;
ctx->dict = dict_new ();
if (!ctx->dict) {
ret = -1;
goto out;
}
ret = dict_unserialize (lock_req.dict.dict_val,
lock_req.dict.dict_len, &ctx->dict);
if (ret) {
gf_log (this->name, GF_LOG_WARNING,
"failed to unserialize the dictionary");
goto out;
}
is_synctasked = dict_get_str_boolean (ctx->dict,
"is_synctasked", _gf_false);
if (is_synctasked) {
ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);
/* The above function does not take ownership of ctx.
* Therefore we need to free the ctx explicitly. */
free_ctx = _gf_true;
}
else {
ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,
ctx);
}
out:
if (ret || free_ctx) {
if (ctx->dict)
dict_unref (ctx->dict);
if (ctx)
GF_FREE (ctx);
}
free (lock_req.dict.dict_val);
gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);
return ret;
}
static int
glusterd_handle_post_validate_fn (rpcsvc_request_t *req)
{
int32_t ret = -1;
gd1_mgmt_v3_post_val_req op_req = {{0},};
glusterd_peerinfo_t *peerinfo = NULL;
xlator_t *this = NULL;
char *op_errstr = NULL;
dict_t *dict = NULL;
dict_t *rsp_dict = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &op_req,
(xdrproc_t)xdr_gd1_mgmt_v3_post_val_req);
if (ret < 0) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to decode post validation "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
if (glusterd_friend_find_by_uuid (op_req.uuid, &peerinfo)) {
gf_log (this->name, GF_LOG_WARNING, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (op_req.uuid));
ret = -1;
goto out;
}
dict = dict_new ();
if (!dict)
goto out;
ret = dict_unserialize (op_req.dict.dict_val,
op_req.dict.dict_len, &dict);
if (ret) {
gf_log (this->name, GF_LOG_WARNING,
"failed to unserialize the dictionary");
goto out;
}
rsp_dict = dict_new ();
if (!rsp_dict) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to get new dictionary");
return -1;
}
ret = gd_mgmt_v3_post_validate_fn (op_req.op, op_req.op_ret, dict,
&op_errstr, rsp_dict);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Post Validation failed on operation %s",
gd_op_list[op_req.op]);
}
ret = glusterd_mgmt_v3_post_validate_send_resp (req, op_req.op,
ret, op_errstr,
rsp_dict);
if (ret) {
gf_log (this->name, GF_LOG_ERROR,
"Failed to send Post Validation "
"response for operation %s",
gd_op_list[op_req.op]);
goto out;
}
out:
if (op_errstr && (strcmp (op_errstr, "")))
GF_FREE (op_errstr);
free (op_req.dict.dict_val);
if (dict)
dict_unref (dict);
if (rsp_dict)
dict_unref (rsp_dict);
gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret);
return ret;
}
int
gf_sql_insert_unwind (gf_sql_connection_t *sql_conn,
gfdb_db_record_t *gfdb_db_record)
{
int ret = -1;
gfdb_time_t *modtime = NULL;
gf_boolean_t its_wind = _gf_true;/*remains true for this function*/
char *gfid_str = NULL;
char *pargfid_str = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
if (!gfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating gfid string failed.");
goto out;
}
/*Only update if recording unwind is set*/
if (gfdb_db_record->do_record_times &&
gfdb_db_record->do_record_uwind_time) {
modtime = &gfdb_db_record->gfdb_unwind_change_time;
ret = gf_update_time (sql_conn, gfid_str, modtime,
gfdb_db_record->do_record_counters,
(!its_wind),
isreadfop (gfdb_db_record->gfdb_fop_type));
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_UPDATE_FAILED, "Failed update unwind "
"time in DB");
goto out;
}
}
/*For link creation and changes we use link updated*/
if (gfdb_db_record->islinkupdate &&
isdentryfop(gfdb_db_record->gfdb_fop_type)) {
pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
if (!pargfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED,
"Creating pargfid_str string failed.");
goto out;
}
ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str,
gfdb_db_record->file_name, 0, _gf_true);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_UPDATE_FAILED, "Failed updating link "
"flags in unwind");
goto out;
}
}
ret = 0;
out:
GF_FREE (gfid_str);
GF_FREE (pargfid_str);
return ret;
}
static int
glusterd_handle_mgmt_v3_unlock_fn (rpcsvc_request_t *req)
{
gd1_mgmt_v3_unlock_req lock_req = {{0},};
int32_t ret = -1;
glusterd_op_lock_ctx_t *ctx = NULL;
xlator_t *this = NULL;
gf_boolean_t is_synctasked = _gf_false;
gf_boolean_t free_ctx = _gf_false;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &lock_req,
(xdrproc_t)xdr_gd1_mgmt_v3_unlock_req);
if (ret < 0) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_REQ_DECODE_FAIL, "Failed to decode unlock "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
gf_msg_debug (this->name, 0, "Received volume unlock req "
"from uuid: %s", uuid_utoa (lock_req.uuid));
if (glusterd_peerinfo_find_by_uuid (lock_req.uuid) == NULL) {
gf_msg (this->name, GF_LOG_WARNING, 0,
GD_MSG_PEER_NOT_FOUND, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (lock_req.uuid));
ret = -1;
goto out;
}
ctx = GF_CALLOC (1, sizeof (*ctx), gf_gld_mt_op_lock_ctx_t);
if (!ctx) {
ret = -1;
goto out;
}
gf_uuid_copy (ctx->uuid, lock_req.uuid);
ctx->req = req;
ctx->dict = dict_new ();
if (!ctx->dict) {
ret = -1;
goto out;
}
ret = dict_unserialize (lock_req.dict.dict_val,
lock_req.dict.dict_len, &ctx->dict);
if (ret) {
gf_msg (this->name, GF_LOG_WARNING, 0,
GD_MSG_DICT_UNSERIALIZE_FAIL,
"failed to unserialize the dictionary");
goto out;
}
is_synctasked = dict_get_str_boolean (ctx->dict,
"is_synctasked", _gf_false);
if (is_synctasked) {
ret = glusterd_syctasked_mgmt_v3_unlock (req, &lock_req, ctx);
if (ret) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_MGMTV3_UNLOCK_FAIL,
"Failed to release mgmt_v3_locks");
/* Ignore the return code, as it shouldn't be propagated
* from the handler function so as to avoid double
* deletion of the req
*/
ret = 0;
}
/* The above function does not take ownership of ctx.
* Therefore we need to free the ctx explicitly. */
free_ctx = _gf_true;
}
else {
/* Shouldn't ignore the return code here, and it should
* be propagated from the handler function as in failure
* case it doesn't delete the req object
*/
ret = glusterd_op_state_machine_mgmt_v3_unlock (req, &lock_req,
ctx);
if (ret)
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_MGMTV3_UNLOCK_FAIL,
"Failed to release mgmt_v3_locks");
}
out:
if (ctx && (ret || free_ctx)) {
if (ctx->dict)
dict_unref (ctx->dict);
GF_FREE (ctx);
}
free (lock_req.dict.dict_val);
gf_msg_trace (this->name, 0, "Returning %d", ret);
return ret;
}
static int
glusterd_handle_post_validate_fn (rpcsvc_request_t *req)
{
int32_t ret = -1;
gd1_mgmt_v3_post_val_req op_req = {{0},};
xlator_t *this = NULL;
char *op_errstr = NULL;
dict_t *dict = NULL;
dict_t *rsp_dict = NULL;
this = THIS;
GF_ASSERT (this);
GF_ASSERT (req);
ret = xdr_to_generic (req->msg[0], &op_req,
(xdrproc_t)xdr_gd1_mgmt_v3_post_val_req);
if (ret < 0) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_REQ_DECODE_FAIL,
"Failed to decode post validation "
"request received from peer");
req->rpc_err = GARBAGE_ARGS;
goto out;
}
if (glusterd_peerinfo_find_by_uuid (op_req.uuid) == NULL) {
gf_msg (this->name, GF_LOG_WARNING, 0,
GD_MSG_PEER_NOT_FOUND, "%s doesn't "
"belong to the cluster. Ignoring request.",
uuid_utoa (op_req.uuid));
ret = -1;
goto out;
}
dict = dict_new ();
if (!dict)
goto out;
ret = dict_unserialize (op_req.dict.dict_val,
op_req.dict.dict_len, &dict);
if (ret) {
gf_msg (this->name, GF_LOG_WARNING, 0,
GD_MSG_DICT_UNSERIALIZE_FAIL,
"failed to unserialize the dictionary");
goto out;
}
rsp_dict = dict_new ();
if (!rsp_dict) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_DICT_CREATE_FAIL,
"Failed to get new dictionary");
return -1;
}
ret = gd_mgmt_v3_post_validate_fn (op_req.op, op_req.op_ret, dict,
&op_errstr, rsp_dict);
if (ret) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_POST_VALIDATION_FAIL,
"Post Validation failed on operation %s",
gd_op_list[op_req.op]);
}
ret = glusterd_mgmt_v3_post_validate_send_resp (req, op_req.op,
ret, op_errstr,
rsp_dict);
if (ret) {
gf_msg (this->name, GF_LOG_ERROR, 0,
GD_MSG_MGMTV3_OP_RESP_FAIL,
"Failed to send Post Validation "
"response for operation %s",
gd_op_list[op_req.op]);
goto out;
}
out:
if (op_errstr && (strcmp (op_errstr, "")))
GF_FREE (op_errstr);
free (op_req.dict.dict_val);
if (dict)
dict_unref (dict);
if (rsp_dict)
dict_unref (rsp_dict);
/* Return 0 from handler to avoid double deletion of req obj */
return 0;
}
int
gf_sql_delete_unwind (gf_sql_connection_t *sql_conn,
gfdb_db_record_t *gfdb_db_record)
{
int ret = -1;
char *gfid_str = NULL;
char *pargfid_str = NULL;
gfdb_time_t *modtime = NULL;
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid));
if (!gfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating gfid string failed.");
goto out;
}
/*Nuke all the entries for this GFID from DB*/
if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL_ALL) {
gf_sql_delete_all(sql_conn, gfid_str);
}
/*Remove link entries only*/
else if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL) {
pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid));
if (!pargfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating pargfid_str "
"string failed.");
goto out;
}
/* Special performance case:
* Updating wind time in unwind for delete. This is done here
* as in the wind path we will not know whether its the last
* link or not. For a last link there is not use to update any
* wind or unwind time!*/
if (gfdb_db_record->do_record_times) {
/*Update the wind write times*/
modtime = &gfdb_db_record->gfdb_wind_change_time;
ret = gf_update_time (sql_conn, gfid_str, modtime,
gfdb_db_record->do_record_counters,
_gf_true,
isreadfop (gfdb_db_record->gfdb_fop_type));
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_UPDATE_FAILED,
"Failed update wind time in DB");
goto out;
}
}
modtime = &gfdb_db_record->gfdb_unwind_change_time;
ret = gf_sql_delete_link(sql_conn, gfid_str, pargfid_str,
gfdb_db_record->file_name);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_DELETE_FAILED, "Failed deleting link");
goto out;
}
if (gfdb_db_record->do_record_times &&
gfdb_db_record->do_record_uwind_time) {
ret = gf_update_time (sql_conn, gfid_str, modtime,
gfdb_db_record->do_record_counters,
_gf_false,
isreadfop(gfdb_db_record->gfdb_fop_type));
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_UPDATE_FAILED, "Failed update "
"unwind time in DB");
goto out;
}
}
} else {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_INVALID_UPLINK, "Invalid unlink option");
goto out;
}
ret = 0;
out:
GF_FREE (gfid_str);
GF_FREE (pargfid_str);
return ret;
}
int
gf_sql_insert_wind (gf_sql_connection_t *sql_conn,
gfdb_db_record_t *gfdb_db_record)
{
int ret = -1;
gfdb_time_t *modtime = NULL;
char *pargfid_str = NULL;
char *gfid_str = NULL;
char *old_pargfid_str = NULL;
gf_boolean_t its_wind = _gf_true;/*remains true for this function*/
CHECK_SQL_CONN (sql_conn, out);
GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out);
gfid_str = gf_strdup (uuid_utoa (gfdb_db_record->gfid));
if (!gfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating gfid string failed.");
goto out;
}
modtime = &gfdb_db_record->gfdb_wind_change_time;
/* handle all dentry based operations */
if (isdentryfop (gfdb_db_record->gfdb_fop_type)) {
/*Parent GFID is always set*/
pargfid_str = gf_strdup (uuid_utoa (gfdb_db_record->pargfid));
if (!pargfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_CREATE_FAILED, "Creating gfid string "
"failed.");
goto out;
}
/* handle create, mknod */
if (isdentrycreatefop (gfdb_db_record->gfdb_fop_type)) {
/*insert link*/
ret = gf_sql_insert_link(sql_conn,
gfid_str, pargfid_str,
gfdb_db_record->file_name,
gfdb_db_record->file_path,
gfdb_db_record->link_consistency,
gfdb_db_record->ignore_errors);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_INSERT_FAILED, "Failed "
"inserting link in DB");
goto out;
}
gfdb_db_record->islinkupdate = gfdb_db_record->
link_consistency;
/*
* Only for create/mknod insert wind time
* for the first time
* */
ret = gf_sql_insert_write_wind_time (sql_conn, gfid_str,
modtime);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_INSERT_FAILED, "Failed "
"inserting wind time in DB");
goto out;
}
goto out;
}
/*handle rename, link */
else {
/*rename*/
if (strlen (gfdb_db_record->old_file_name) != 0) {
old_pargfid_str = gf_strdup (uuid_utoa (
gfdb_db_record->old_pargfid));
if (!old_pargfid_str) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
0, LG_MSG_CREATE_FAILED,
"Creating gfid string failed.");
goto out;
}
gf_sql_update_link (sql_conn, gfid_str,
pargfid_str,
gfdb_db_record->file_name,
gfdb_db_record->file_path,
old_pargfid_str,
gfdb_db_record->old_file_name,
gfdb_db_record->
link_consistency);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
0, LG_MSG_UPDATE_FAILED,
"Failed updating link");
goto out;
}
gfdb_db_record->islinkupdate = gfdb_db_record->
link_consistency;
}
/*link*/
else {
ret = gf_sql_insert_link (sql_conn,
gfid_str, pargfid_str,
gfdb_db_record->file_name,
gfdb_db_record->file_path,
gfdb_db_record->link_consistency,
gfdb_db_record->ignore_errors);
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR,
0, LG_MSG_INSERT_FAILED,
"Failed inserting link in DB");
goto out;
}
gfdb_db_record->islinkupdate = gfdb_db_record->
link_consistency;
}
}
}
/* update times only when said!*/
if (gfdb_db_record->do_record_times) {
/*All fops update times read or write*/
ret = gf_update_time (sql_conn, gfid_str, modtime,
gfdb_db_record->do_record_counters,
its_wind,
isreadfop (gfdb_db_record->gfdb_fop_type));
if (ret) {
gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,
LG_MSG_UPDATE_FAILED, "Failed update wind time"
" in DB");
goto out;
}
}
ret = 0;
out:
GF_FREE (gfid_str);
GF_FREE (pargfid_str);
GF_FREE (old_pargfid_str);
return ret;
}
struct glfs_object *
glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len,
struct stat *stat)
{
loc_t loc = {0, };
int ret = -1;
struct iatt iatt = {0, };
inode_t *newinode = NULL;
xlator_t *subvol = NULL;
struct glfs_object *object = NULL;
/* validate in args */
if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
errno = EINVAL;
return NULL;
}
__glfs_entry_fs (fs);
/* get the active volume */
subvol = glfs_active_subvol (fs);
if (!subvol) {
errno = EIO;
goto out;
}
memcpy (loc.gfid, handle, GFAPI_HANDLE_LENGTH);
newinode = inode_find (subvol->itable, loc.gfid);
if (newinode)
loc.inode = newinode;
else {
loc.inode = inode_new (subvol->itable);
if (!loc.inode) {
errno = ENOMEM;
goto out;
}
}
ret = syncop_lookup (subvol, &loc, 0, &iatt, 0, 0);
DECODE_SYNCOP_ERR (ret);
if (ret) {
gf_log (subvol->name, GF_LOG_WARNING,
"inode refresh of %s failed: %s",
uuid_utoa (loc.gfid), strerror (errno));
goto out;
}
newinode = inode_link (loc.inode, 0, 0, &iatt);
if (newinode)
inode_lookup (newinode);
else {
gf_log (subvol->name, GF_LOG_WARNING,
"inode linking of %s failed: %s",
uuid_utoa (loc.gfid), strerror (errno));
errno = EINVAL;
goto out;
}
/* populate stat */
if (stat)
glfs_iatt_to_stat (fs, &iatt, stat);
object = GF_CALLOC (1, sizeof(struct glfs_object),
glfs_mt_glfs_object_t);
if (object == NULL) {
errno = ENOMEM;
ret = -1;
goto out;
}
/* populate the return object */
object->inode = newinode;
uuid_copy (object->gfid, object->inode->gfid);
out:
/* TODO: Check where the inode ref is being held? */
loc_wipe (&loc);
glfs_subvol_done (fs, subvol);
return object;
}
static char *
binary_to_ascii (uuid_t uuid)
{
return uuid_utoa (uuid);
}
*off = offset;
}
int
changelog_encode_ascii(xlator_t *this, changelog_log_data_t *cld)
{
size_t off = 0;
size_t gfid_len = 0;
char *gfid_str = NULL;
char *buffer = NULL;
changelog_priv_t *priv = NULL;
priv = this->private;
gfid_str = uuid_utoa(cld->cld_gfid);
gfid_len = strlen(gfid_str);
/* extra bytes for decorations */
buffer = alloca(gfid_len + cld->cld_ptr_len + 10);
CHANGELOG_STORE_ASCII(priv, buffer, off, gfid_str, gfid_len, cld);
if (cld->cld_xtra_records)
changelog_encode_write_xtra(cld, buffer, &off, _gf_true);
CHANGELOG_FILL_BUFFER(buffer, off, "\0", 1);
return changelog_write_change(priv, buffer, off);
}
int