自学教程：C++ uuid_copy函数代码示例

/** * Command to register a real device in a group. * It must be called after group_begin() and before * group_create() or group_start(). * * @param[in] params The parsed command array * * The real parameters passed in the array are: *  - UUID of the group in which the real device has to be added *  - UUID of the real device in the VRT *  - UUID of the real device in the NBD *  - Whether the disk is local or not *  - Whether the disk is UP or not *  - Whether the device properties must be loaded from disk * * @return EXA_SUCCESS on success, negative error code on failure. */static intvrt_cmd_group_add_rdev(const struct VrtGroupAddRdev *cmd){    vrt_rdev_info_t *rdev_info;    os_thread_mutex_lock(&pending_group_lock);    if (!pending_group)    {	os_thread_mutex_unlock(&pending_group_lock);	return -EPERM;    }    if (!uuid_is_equal(&cmd->group_uuid, &pending_group->uuid))    {	exalog_error("Failed to edit group " UUID_FMT                     ", group " UUID_FMT " is already being edited.",                     UUID_VAL(&cmd->group_uuid), UUID_VAL(&pending_group->uuid));	os_thread_mutex_unlock(&pending_group_lock);	return -EAGAIN;    }    if (pending_group->nb_rdevs == NBMAX_DISKS_PER_GROUP)    {	os_thread_mutex_unlock(&pending_group_lock);	return -EAGAIN;    }    rdev_info = &pending_group->rdevs[pending_group->nb_rdevs];    uuid_copy(&rdev_info->uuid,     &cmd->uuid);    uuid_copy(&rdev_info->nbd_uuid, &cmd->nbd_uuid);    rdev_info->node_id = cmd->node_id;    rdev_info->spof_id = cmd->spof_id;    rdev_info->local   = cmd->local;    rdev_info->up      = cmd->up;    pending_group->nb_rdevs++;    os_thread_mutex_unlock(&pending_group_lock);    return EXA_SUCCESS;}

int32_t ida_fd_to_loc(ida_local_t * local, loc_t * loc, fd_t * fd){    int32_t error;    error = inode_path(fd->inode, NULL, (char **)&loc->path);    if (unlikely(error < 0))    {        return -error;    }    loc->name = strrchr(loc->path, '/');    if (loc->name != NULL)    {        loc->name++;    }    error = ida_inode_assign(local, &loc->inode, fd->inode);    if (unlikely(error != 0))    {        goto failed;    }    if (!uuid_is_null(loc->inode->gfid))    {        uuid_copy(loc->gfid, loc->inode->gfid);    }    loc->parent = inode_parent(loc->inode, 0, NULL);    if (loc->parent != NULL)    {        if (!uuid_is_null(loc->parent->gfid))        {            uuid_copy(loc->pargfid, loc->parent->gfid);        }    }    return 0;failed:    GF_FREE((char *)loc->path);    return ENOMEM;}

static int newfs_create(const char *path, mode_t mode, struct fuse_file_info *fi){    char message[1024];    sprintf(message, "newfs_create: path = %s/n", path);    write_log_fuse(message);    /* split the path up into its parts */    char tokens[1024][NAME_MAX]; int count;     tokenize_path(tokens, path, &count);    /* traverse the file system looking for the directory above our target file */    fcb parent; uuid_t parent_key;    int rec = get_fcb_from_tokens(&parent, &parent_key, tokens, count - 1);    if(rec != 0){        if(rec == -ENOENT)            write_log_fuse("newfs_create: failure ENOENT/n");        if(rec == -ENOTDIR)            write_log_fuse("newfs_create: failure ENOTDIR/n");        return rec;    }    if(!parent.dir){        write_log_fuse("newfs_create: failure ENOTDIR/n");        return -ENOTDIR;    }    /* get the directory data and look for the target */    dir_entry *dirs = malloc(sizeof(dir_entry) * parent.num_files);    fetch_dirdata(dirs, parent.datakey, parent.num_files);    int found=0, i=0;    for(i = 0; i != parent.num_files; i++){        if(strcmp(dirs[i].name, tokens[count-1]) == 0){            found++;        }    }    if(found){        write_log_fuse("newfs_create: failure EEXIST/n");        return -EEXIST;    }    /* if all is well, create a new file and store the updated fcb */    uuid_t child_key;    uuid_generate(child_key);    init_file_fcb(child_key);    parent.num_files++;    dirs = realloc(dirs, sizeof(dir_entry) * parent.num_files);    strcpy(dirs[parent.num_files-1].name, tokens[count-1]);    uuid_copy(dirs[parent.num_files-1].key, child_key);    store_dirdata(dirs, parent.datakey, parent.num_files);    parent.size = sizeof(dir_entry) * parent.num_files;    store_fcb(parent, parent_key);    write_log_fuse("newfs_create: success/n");     return 0;}

static void bearerbox_to_sql(void *arg){    Boxc *conn = (Boxc *)arg;    Msg *msg, *mack;    while (sqlbox_status == SQL_RUNNING && conn->alive) {        msg = read_from_box(conn->bearerbox_connection, conn);        if (msg == NULL) {    /* garbage/connection lost */                    /* tell sqlbox to die */            conn->alive = 0;            sqlbox_status = SQL_SHUTDOWN;            debug("sqlbox", 0, "bearerbox_to_sql: connection to bearerbox died.");            break;        }            if (msg_type(msg) == heartbeat) {                // todo                    debug("sqlbox", 0, "bearerbox_to_sql: catch an heartbeat - we are alive");                    msg_destroy(msg);                    continue;            }        /* if this is an identification message from an smsbox instance */        if (msg_type(msg) == admin && msg->admin.command == cmd_shutdown) {                    /* tell sqlbox to die */            conn->alive = 0;            sqlbox_status = SQL_SHUTDOWN;            debug("sqlbox", 0, "bearerbox_to_sql: Bearerbox told us to shutdown.");            break;        }        if (msg_type(msg) == sms) {            if (msg->sms.sms_type != report_mo) {                if (save_mo) {                    gw_sql_save_msg(msg, octstr_imm("MO"));                }            }            else {                if (save_dlr) {                    gw_sql_save_msg(msg, octstr_imm("DLR"));                }            }	    /* create ack message */	    mack = msg_create(ack);	    mack->ack.nack = ack_success;	    mack->ack.time = msg->sms.time;	    uuid_copy(mack->ack.id, msg->sms.id);	    send_msg(conn->bearerbox_connection, conn, mack);	    msg_destroy(mack);        }        msg_destroy(msg);    }}

static intcont_query_bcast(crt_context_t ctx, struct cont *cont, const uuid_t pool_hdl,		 const uuid_t cont_hdl, struct cont_query_out *query_out){	struct	cont_tgt_query_in	*in;	struct  cont_tgt_query_out	*out;	crt_rpc_t			*rpc;	int				 rc;	D_DEBUG(DF_DSMS,		DF_CONT"bcasting pool_hld="DF_UUID" cont_hdl ="DF_UUID"/n",		DP_CONT(cont->c_svc->cs_pool_uuid, cont->c_uuid),		DP_UUID(pool_hdl), DP_UUID(cont_hdl));	rc = ds_cont_bcast_create(ctx, cont->c_svc, CONT_TGT_QUERY, &rpc);	if (rc != 0)		D_GOTO(out, rc);	in = crt_req_get(rpc);	uuid_copy(in->tqi_pool_uuid, pool_hdl);	uuid_copy(in->tqi_cont_uuid, cont->c_uuid);	out = crt_reply_get(rpc);	out->tqo_min_purged_epoch = DAOS_EPOCH_MAX;	rc = dss_rpc_send(rpc);	if (rc != 0)		D_GOTO(out_rpc, rc);	out = crt_reply_get(rpc);	rc  = out->tqo_rc;	if (rc != 0) {		D_DEBUG(DF_DSMS, DF_CONT": failed to query %d targets/n",			DP_CONT(cont->c_svc->cs_pool_uuid, cont->c_uuid), rc);		D_GOTO(out_rpc, rc = -DER_IO);	}out_rpc:	crt_req_decref(rpc);out:	return rc;}

static intcont_svc_init(struct cont_svc *svc, const uuid_t pool_uuid, uint64_t id,	      struct ds_rsvc *rsvc){	int rc;	uuid_copy(svc->cs_pool_uuid, pool_uuid);	svc->cs_id = id;	svc->cs_rsvc = rsvc;	rc = ABT_rwlock_create(&svc->cs_lock);	if (rc != ABT_SUCCESS) {		D_ERROR("failed to create cs_lock: %d/n", rc);		D_GOTO(err, rc = dss_abterr2der(rc));	}	/* cs_root */	rc = rdb_path_init(&svc->cs_root);	if (rc != 0)		D_GOTO(err_lock, rc);	rc = rdb_path_push(&svc->cs_root, &rdb_path_root_key);	if (rc != 0)		D_GOTO(err_root, rc);	/* cs_conts */	rc = rdb_path_clone(&svc->cs_root, &svc->cs_conts);	if (rc != 0)		D_GOTO(err_root, rc);	rc = rdb_path_push(&svc->cs_conts, &ds_cont_prop_conts);	if (rc != 0)		D_GOTO(err_conts, rc);	/* cs_hdls */	rc = rdb_path_clone(&svc->cs_root, &svc->cs_hdls);	if (rc != 0)		D_GOTO(err_conts, rc);	rc = rdb_path_push(&svc->cs_hdls, &ds_cont_prop_cont_handles);	if (rc != 0)		D_GOTO(err_hdls, rc);	return 0;err_hdls:	rdb_path_fini(&svc->cs_hdls);err_conts:	rdb_path_fini(&svc->cs_conts);err_root:	rdb_path_fini(&svc->cs_root);err_lock:	ABT_rwlock_free(&svc->cs_lock);err:	return rc;}

voidcl_uuid_copy(cl_uuid_t* dst, cl_uuid_t* src){    if (dst == NULL || src == NULL) {        cl_log(LOG_ERR, "cl_uuid_copy: "               "wrong argument %s is NULL",               dst == NULL?"dst":"src");        assert(0);    }    uuid_copy(dst->uuid, src->uuid);}

static void fill_inv_item_from_opensim(inventory_item *citem,				       os_inv_item &item) {    uuid_copy(citem->item_id, item.item_id);    uuid_copy(citem->owner_id, item.owner_id);    citem->inv_type = item.inv_type;    uuid_copy(citem->folder_id, item.folder_id);    uuid_copy(citem->creator_as_uuid, item.creator_as_uuid);    citem->perms.next = item.next_perms;    citem->perms.current = item.current_perms;    citem->perms.base = item.base_perms;    citem->perms.everyone = item.everyone_perms;    citem->perms.group = item.group_perms;    citem->asset_type = item.asset_type;    uuid_copy(citem->asset_id, item.asset_id);    uuid_copy(citem->group_id, item.group_id);    citem->group_owned = item.group_owned;    citem->sale_price = item.sale_price;    citem->sale_type = item.sale_type;    citem->flags = item.flags;    citem->creation_date = item.creation_date;        xmlFree(item.name); xmlFree(item.description);    xmlFree(item.creator_id);}

struct block *new_leaf(struct mtree *mt){	struct block *b = zero_blk(mt->dev, mt->next_block++);	struct leaf *leaf = b->buf;	uuid_copy(leaf->uuid, mt->uuid);	leaf->blknum = b->blknum;	leaf->seqnum = mt->seqnum++;	leaf->isLeaf = true;	leaf->num_recs = 0;	leaf->end = BLOCK_SIZE - sizeof(*leaf);	return b;}

static int store_spool_save_ack(Msg *msg, ack_status_t status){    int ret;    Msg *nack = msg_create(ack);    nack->ack.nack = status;    uuid_copy(nack->ack.id, msg->sms.id);    nack->ack.time = msg->sms.time;    ret = store_spool_save(nack);    msg_destroy(nack);    return ret;}

struct pg_cache_page_index *create_page_index(uuid_t *id){    struct pg_cache_page_index *page_index;    page_index = mallocz(sizeof(*page_index));    page_index->JudyL_array = (Pvoid_t) NULL;    uuid_copy(page_index->id, *id);    assert(0 == uv_rwlock_init(&page_index->lock));    page_index->oldest_time = INVALID_TIME;    page_index->latest_time = INVALID_TIME;    return page_index;}

static intcont_destroy_bcast(crt_context_t ctx, struct cont_svc *svc,		   const uuid_t cont_uuid){	struct cont_tgt_destroy_in     *in;	struct cont_tgt_destroy_out    *out;	crt_rpc_t		       *rpc;	int				rc;	D_DEBUG(DF_DSMS, DF_CONT": bcasting/n",		DP_CONT(svc->cs_pool_uuid, cont_uuid));	rc = ds_cont_bcast_create(ctx, svc, CONT_TGT_DESTROY, &rpc);	if (rc != 0)		D_GOTO(out, rc);	in = crt_req_get(rpc);	uuid_copy(in->tdi_pool_uuid, svc->cs_pool_uuid);	uuid_copy(in->tdi_uuid, cont_uuid);	rc = dss_rpc_send(rpc);	if (rc != 0)		D_GOTO(out_rpc, rc);	out = crt_reply_get(rpc);	rc = out->tdo_rc;	if (rc != 0) {		D_ERROR(DF_CONT": failed to destroy %d targets/n",			DP_CONT(svc->cs_pool_uuid, cont_uuid), rc);		rc = -DER_IO;	}out_rpc:	crt_req_decref(rpc);out:	D_DEBUG(DF_DSMS, DF_CONT": bcasted: %d/n",		DP_CONT(svc->cs_pool_uuid, cont_uuid), rc);	return rc;}

voidxfs_log_dinode_to_disk(	struct xfs_log_dinode	*from,	struct xfs_dinode	*to){	to->di_magic = cpu_to_be16(from->di_magic);	to->di_mode = cpu_to_be16(from->di_mode);	to->di_version = from->di_version;	to->di_format = from->di_format;	to->di_onlink = 0;	to->di_uid = cpu_to_be32(from->di_uid);	to->di_gid = cpu_to_be32(from->di_gid);	to->di_nlink = cpu_to_be32(from->di_nlink);	to->di_projid_lo = cpu_to_be16(from->di_projid_lo);	to->di_projid_hi = cpu_to_be16(from->di_projid_hi);	memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));	to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);	to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);	to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);	to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);	to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);	to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);	to->di_size = cpu_to_be64(from->di_size);	to->di_nblocks = cpu_to_be64(from->di_nblocks);	to->di_extsize = cpu_to_be32(from->di_extsize);	to->di_nextents = cpu_to_be32(from->di_nextents);	to->di_anextents = cpu_to_be16(from->di_anextents);	to->di_forkoff = from->di_forkoff;	to->di_aformat = from->di_aformat;	to->di_dmevmask = cpu_to_be32(from->di_dmevmask);	to->di_dmstate = cpu_to_be16(from->di_dmstate);	to->di_flags = cpu_to_be16(from->di_flags);	to->di_gen = cpu_to_be32(from->di_gen);	if (from->di_version == 3) {		to->di_changecount = cpu_to_be64(from->di_changecount);		to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec);		to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec);		to->di_flags2 = cpu_to_be64(from->di_flags2);		to->di_cowextsize = cpu_to_be32(from->di_cowextsize);		to->di_ino = cpu_to_be64(from->di_ino);		to->di_lsn = cpu_to_be64(from->di_lsn);		memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));		uuid_copy(&to->di_uuid, &from->di_uuid);		to->di_flushiter = 0;	} else {		to->di_flushiter = cpu_to_be16(from->di_flushiter);	}}

int main(){    uuid_t id,id2;    char out[36];    uuid_unparse(id,out);    debug(DEBUG_TEST,"The object id is:%s",out);    uuid_copy(id2,id);    char out2[36];    uuid_unparse(id,out2);    debug(DEBUG_TEST,"The object id is:%s",out2);    print(id);    return 0;}

void sendMessage(uuid_t to_node, struct Message message){	struct element *e = malloc(sizeof(struct element));	e->next = NULL;	uuid_copy(e->nodeID, to_node);	e->message = message;	if( root == NULL ) {		last = root = e;	} else {		last->next = e;		last = e;	}}

static intcont_close(struct rdb_tx *tx, struct ds_pool_hdl *pool_hdl, struct cont *cont,	   crt_rpc_t *rpc){	struct cont_close_in	       *in = crt_req_get(rpc);	daos_iov_t			key;	daos_iov_t			value;	struct container_hdl		chdl;	struct cont_tgt_close_rec	rec;	int				rc;	D_DEBUG(DF_DSMS, DF_CONT": processing rpc %p: hdl="DF_UUID"/n",		DP_CONT(pool_hdl->sph_pool->sp_uuid, in->cci_op.ci_uuid), rpc,		DP_UUID(in->cci_op.ci_hdl));	/* See if this container handle is already closed. */	daos_iov_set(&key, in->cci_op.ci_hdl, sizeof(uuid_t));	daos_iov_set(&value, &chdl, sizeof(chdl));	rc = rdb_tx_lookup(tx, &cont->c_svc->cs_hdls, &key, &value);	if (rc != 0) {		if (rc == -DER_NONEXIST) {			D_DEBUG(DF_DSMS, DF_CONT": already closed: "DF_UUID"/n",				DP_CONT(cont->c_svc->cs_pool->sp_uuid,					cont->c_uuid),				DP_UUID(in->cci_op.ci_hdl));			rc = 0;		}		D_GOTO(out, rc);	}	uuid_copy(rec.tcr_hdl, in->cci_op.ci_hdl);	rec.tcr_hce = chdl.ch_hce;	D_DEBUG(DF_DSMS, DF_CONT": closing: hdl="DF_UUID" hce="DF_U64"/n",		DP_CONT(cont->c_svc->cs_pool_uuid, in->cci_op.ci_uuid),		DP_UUID(rec.tcr_hdl), rec.tcr_hce);	rc = cont_close_bcast(rpc->cr_ctx, cont->c_svc, &rec, 1 /* nrecs */);	if (rc != 0)		D_GOTO(out, rc);	rc = cont_close_one_hdl(tx, cont->c_svc, rpc->cr_ctx, rec.tcr_hdl);out:	D_DEBUG(DF_DSMS, DF_CONT": replying rpc %p: %d/n",		DP_CONT(pool_hdl->sph_pool->sp_uuid, in->cci_op.ci_uuid), rpc,		rc);	return rc;}

void smtpdumper_calldetection(void *dataptr) {   BLOCK_META_DATA *mdata = NULL;   smtpcapture *smtpcapturedata = (smtpcapture*)dataptr;   //printf("SMTPDUMP smtpdumper_calldetection enter/n");   if(!dataptr) {      //printf("SMTPDUMP dataptr is NULL!/n");      return;   }   if(smtpcapturedata->clientdata) {//      printf("SMTPDUMP Calling sendData() with the following data (%d bytes):/n/n", ((smtpcapture*)(dataptr))->storedsize);#ifdef DISPLAY_DEMO_OUTPUT      prettyprint(smtpcapturedata->clientdata, smtpcapturedata->storedsize);      printf("/n/n");#endif      mdata = calloc(1, sizeof(*mdata));      if(mdata == NULL) return;      // Fill in the required fields      mdata->timestamp = (unsigned int)time(NULL);      mdata->data = smtpcapturedata->clientdata;      mdata->size = smtpcapturedata->storedsize;//      mdata->src_ip = 0x01010101;//      mdata->dst_ip = 0x02020202;      mdata->ip_proto = 6;      mdata->src_port = 25;      mdata->dst_port = 8000;      uuid_copy(mdata->datatype, MAIL_CAPTURE);      rzb_collection.sendData(mdata);   } else {      //printf("SMTPDUMP dataptr->clientdata is NULL!/n");   }   //printf("SMTPDUMP Freeing session data/n");   // Data is freed by sendData; we just need to clear out the rest of the structure.   // We can accomplish this by setting clientdata to NULL so we don't do the doublefree   smtpcapturedata->clientdata = NULL;   smtpdumper_freedata(smtpcapturedata);}

/* Lock and read metadata at specified position */int vmfs_metadata_lock(vmfs_fs_t *fs,off_t pos,u_char *buf,size_t buf_len,                       vmfs_metadata_hdr_t *mdh){   /* Acquire heartbeat */   if (vmfs_heartbeat_acquire(fs) == -1)      return(-1);   /* Reserve volume */   if (vmfs_device_reserve(fs->dev,pos) == -1) {      fprintf(stderr,"VMFS: unable to reserve volume./n");      goto err_reserve;   }   /* Read the complete metadata for the caller */   if (vmfs_device_read(fs->dev,pos,buf,buf_len) != buf_len) {      fprintf(stderr,"VMFS: unable to read metadata./n");      goto err_io;   }   vmfs_metadata_hdr_read(mdh,buf);      if (mdh->hb_lock != 0)      goto err_io;   /* Update metadata information */   mdh->obj_seq++;   mdh->hb_lock = 1;   mdh->hb_pos  = fs->hb.pos;   mdh->hb_seq  = fs->hb_seq;   uuid_copy(mdh->hb_uuid,fs->hb.uuid);   vmfs_metadata_hdr_write(mdh,buf);   /* Rewrite the metadata header only */   if (vmfs_device_write(fs->dev,pos,buf,VMFS_METADATA_HDR_SIZE)       != VMFS_METADATA_HDR_SIZE)   {      fprintf(stderr,"VMFS: unable to write metadata header./n");      goto err_io;   }   vmfs_device_release(fs->dev,pos);   return(0); err_io:   vmfs_device_release(fs->dev,pos); err_reserve:   vmfs_heartbeat_release(fs);   return(-1);}

static void who_am_i (kbicho_s *b){	bicho_msg_s	m;	int		rc;	m.m_method = BICHO_WHO_AM_I;	rc = call_tau(b->kb_key, &m);	if (rc) {		weprintf("who_am_i failed %d", rc);		return;	}	strlcpy(b->kb_name, m.bi_name, TAU_NAME);	uuid_copy(b->kb_id, m.bi_id);	PRs(b->kb_name);}

static int repep_add (struct epbase *ep, struct tgtd *tg, char *ubuf){	struct rtentry *rt = rt_cur (ubuf);	if (uuid_compare (rt->uuid, get_rep_tgtd (tg)->uuid) )		uuid_copy (get_rep_tgtd (tg)->uuid, rt->uuid);	DEBUG_OFF ("ep %d recv req %10.10s from socket %d", ep->eid, ubuf, tg->fd);	mutex_lock (&ep->lock);	skbuf_head_in (&ep->rcv, ubuf);	BUG_ON (ep->rcv.waiters < 0);	if (ep->rcv.waiters)		condition_broadcast (&ep->cond);	mutex_unlock (&ep->lock);	return 0;}

static UUIDJobNode *AllocateUUIDJobNode (uuid_t id, ServiceJob *job_p){	UUIDJobNode *node_p = (UUIDJobNode *) AllocMemory (sizeof (UUIDJobNode));	if (node_p)		{			node_p -> ujn_node.ln_prev_p = NULL;			node_p -> ujn_node.ln_next_p = NULL;			uuid_copy (node_p -> ujn_id, id);			node_p -> ujn_job_p = job_p;		}	return node_p;}

int dump_bptree_sequential(bptree_session *bps, uuid_t failed_node){	int ksize, vsize, rv;	unsigned char k[BPTREE_MAX_VALUE_SIZE], v[BPTREE_MAX_VALUE_SIZE];	char uuid_out[40];	char s1[512];	char path[128];    sprintf(path, "/tmp/%d.out", bps->bpt_id);    FILE *fp = fopen(path,"w");	//printf("Dumping bpt_id %d:/n",bps->bpt_id);	//fflush(stdout);	if (!uuid_is_null(failed_node))	{		bps->cursor_node = read_node(bps, failed_node, &rv);		if(rv == BPTREE_OP_TAPIOCA_NOT_READY) return rv;		bps->cursor_pos = 0;		rv = bptree_index_next(bps, k, &ksize, v, &vsize);		if (rv != BPTREE_OP_KEY_FOUND) return rv;	}	else	{		bptree_index_first(bps, k, &ksize, v, &vsize);	}	for(rv = 0;;)	{		bptree_key_value_to_string(bps, k,v,ksize,vsize,s1);		uuid_unparse(bpnode_get_id(bps->cursor_node), uuid_out);		fprintf(fp, "Node->Cell %s -> %d /t Key: %s /n",				uuid_out, bps->cursor_pos, s1);		rv = bptree_index_next(bps, k, &ksize, v, &vsize);		if (rv != BPTREE_OP_KEY_FOUND) break;	}	if (rv == BPTREE_OP_EOF)	{		fprintf(fp, "/n/n");		fflush(stdout);		rv = BPTREE_OP_SUCCESS;	}	else if (rv == BPTREE_OP_TAPIOCA_NOT_READY)	{		uuid_copy(failed_node, bpnode_get_id(bps->cursor_node));		//uuid_copy(failed_node, bps->cursor_node->self_key);	}	return rv;	fflush(fp);	fclose(fp);}

void inspectFile (char * fileName, uuid_t uuid) {	void * threadData = NULL;	if (threadInit != NULL) {		if (!threadInit(&threadData)) {			rzb_log(LOG_ERR, "Couldn't run nugget inspection threadInit.");			exit(-1);		} else {			rzb_log(LOG_DEBUG, "Thread init for nugget complete.");		}	}	sleep(sleepTime);	struct EventId * eventId;	eventId = calloc(1,sizeof(struct EventId));	struct Block * block = Block_Create ();	struct List * list	= NTLVList_Create();	struct stat st;	stat(fileName, &st);	//BlockPool_Init();	block->pId->iLength = st.st_size;	if (!Transfer_Prepare_File(block, fileName, false)) {		rzb_log(LOG_ERR, "Trouble preparing file transfer - '%s'", fileName);		Block_Destroy(block);		free(eventId);		List_Destroy(list);		return;	}	Hash_Update(block->pId->pHash, block->data.pointer, block->pId->iLength);	Hash_Finalize(block->pId->pHash);	uuid_copy(block->pId->uuidDataType,uuid);	struct ContextList * current = NULL;	while (contextList != NULL) {		current = contextList;		uint8_t ret = function (block, eventId, list, threadData);		if ( ret >= 0 ) {			rzb_log(LOG_NOTICE, "Returned with: %u", ret);		}		if (current == contextList)			break;	}	List_Destroy(list);	/*Don't need to free/destroy as it's done with the judgment.	 * Was needed previously because of cloning - cloning removed*/	//Block_Destroy(block);	//free(eventId);	if (threadCleanup != NULL) {		threadCleanup(threadData);	}}

void initGPTHeader(gpt_header_t *gpt, uint64_t diskSize, gpt_partition_t *partitions){    // https://en.wikipedia.org/wiki/GUID_Partition_Table    // little endian format    // GPT Signature    gpt->signature         = 0x5452415020494645;    // 1.0 version    gpt->revision          = 0x00010000;    // 512 bytes header size    gpt->header_size       = UINT32_C(512);    // 0'ed revered field    gpt->reserved          = UINT32_C(0);    // primary header lba    gpt->current_lba       = UINT64_C(1);    // backup header lba    gpt->backup_lba        = UINT64_C(diskSize - 1);    // number of partitions    gpt->number_partitions = UINT32_C(2);    // first/last usable lba's    gpt->first_usable_lba = partitions[0].first_lba;    gpt->last_usable_lba  = partitions[1].last_lba;    // first partition entry address    gpt->starting_lba     = UINT64_C(2);    // init CRC to 0    gpt->crc_header       = UINT32_C(0);    gpt->crc_partition    = UINT32_C(0);    // create unique id for the disk    uuid_t uuid;    uuid_generate(uuid);    uuid_copy(gpt->disk_guid, uuid);    // today' size of each partition entry    gpt->size_partition_entries = UINT32_C(128);    // 0'ed last bytes...    memset(gpt->reserved2, '/0', 420);    // calculate the CRC32 of partitions entries    gpt->crc_partition = crc32(0, (unsigned char*)partitions, gpt->number_partitions * gpt->size_partition_entries);    // calculate the CRC32 of this header    gpt->header_size = sizeof(*gpt);    gpt->crc_header = crc32(0, (unsigned char*)gpt, gpt->header_size);}

int nilfs_cleaner_reload(struct nilfs_cleaner *cleaner, const char *conffile){	struct nilfs_cleaner_request_with_path req;	struct nilfs_cleaner_response res;	size_t pathlen, reqsz;	int bytes, ret = -1;	if (cleaner->sendq < 0 || cleaner->recvq < 0) {		errno = EBADF;		goto out;	}	if (nilfs_cleaner_clear_queueu(cleaner) < 0)		goto out;	if (conffile) {		if (myrealpath(conffile, req.pathname,			       NILFS_CLEANER_MSG_MAX_PATH) == NULL)			goto out;		pathlen = strlen(req.pathname);		req.hdr.argsize = pathlen + 1;		reqsz = sizeof(req.hdr) + pathlen + 1;	} else {		req.hdr.argsize = 0;		reqsz = sizeof(req.hdr);	}	req.hdr.cmd = NILFS_CLEANER_CMD_RELOAD;	uuid_copy(req.hdr.client_uuid, cleaner->client_uuid);	ret = mq_send(cleaner->sendq, (char *)&req, reqsz,		      NILFS_CLEANER_PRIO_NORMAL);	if (ret < 0)		goto out;	bytes = mq_receive(cleaner->recvq, (char *)&res, sizeof(res), NULL);	if (bytes < sizeof(res)) {		if (bytes >= 0)			errno = EIO;		ret = -1;		goto out;	}	if (res.result == NILFS_CLEANER_RSP_NACK) {		ret = -1;		errno = res.err;	}out:	return ret;}

static void read_uuid(BANG_peer *self,uuid_t uuid) {    uuid_t *uuid_ptr = (uuid_t*) read_message(self,sizeof(uuid_t));    if (uuid_ptr) {        uuid_copy(uuid,*uuid_ptr);#ifdef BDEBUG_1        char unparsed[37];        uuid_unparse(uuid,unparsed);        fprintf(stderr,"READ-THREAD:/tRead uuid %s./n",unparsed);#endif        free(uuid_ptr);    } else {        uuid_clear(uuid);    }}

assembly_volume_t *assembly_volume_alloc(const exa_uuid_t *uuid){    assembly_volume_t *av;    av = os_malloc(sizeof(assembly_volume_t));    if (av == NULL)        return NULL;    uuid_copy(&av->uuid, uuid);    av->slots = NULL;    av->total_slots_count = 0;    av->next = NULL;    return av;}

voidxfs_dinode_from_disk(	xfs_icdinode_t		*to,	xfs_dinode_t		*from){	to->di_magic = be16_to_cpu(from->di_magic);	to->di_mode = be16_to_cpu(from->di_mode);	to->di_version = from ->di_version;	to->di_format = from->di_format;	to->di_onlink = be16_to_cpu(from->di_onlink);	to->di_uid = be32_to_cpu(from->di_uid);	to->di_gid = be32_to_cpu(from->di_gid);	to->di_nlink = be32_to_cpu(from->di_nlink);	to->di_projid_lo = be16_to_cpu(from->di_projid_lo);	to->di_projid_hi = be16_to_cpu(from->di_projid_hi);	memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));	to->di_flushiter = be16_to_cpu(from->di_flushiter);	to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);	to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);	to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);	to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);	to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);	to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);	to->di_size = be64_to_cpu(from->di_size);	to->di_nblocks = be64_to_cpu(from->di_nblocks);	to->di_extsize = be32_to_cpu(from->di_extsize);	to->di_nextents = be32_to_cpu(from->di_nextents);	to->di_anextents = be16_to_cpu(from->di_anextents);	to->di_forkoff = from->di_forkoff;	to->di_aformat	= from->di_aformat;	to->di_dmevmask	= be32_to_cpu(from->di_dmevmask);	to->di_dmstate	= be16_to_cpu(from->di_dmstate);	to->di_flags	= be16_to_cpu(from->di_flags);	to->di_gen	= be32_to_cpu(from->di_gen);	if (to->di_version == 3) {		to->di_changecount = be64_to_cpu(from->di_changecount);		to->di_crtime.t_sec = be32_to_cpu(from->di_crtime.t_sec);		to->di_crtime.t_nsec = be32_to_cpu(from->di_crtime.t_nsec);		to->di_flags2 = be64_to_cpu(from->di_flags2);		to->di_ino = be64_to_cpu(from->di_ino);		to->di_lsn = be64_to_cpu(from->di_lsn);		memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));		uuid_copy(&to->di_uuid, &from->di_uuid);	}}

intclientd_stat_get(ExamsgHandle h, const struct nbd_stats_request *request,		 struct nbd_stats_reply *reply){  nbd_request_t req;  req.event = NBDCMD_STATS;  /* FIXME the only field usefull seems to be reset... */  req.stats_reset = request->reset;  strlcpy(req.node_name, request->node_name, sizeof(req.node_name));  strlcpy(req.device_path, request->disk_path, sizeof(req.device_path));  uuid_copy(&req.device_uuid, &request->device_uuid);  return admwrk_daemon_query_nointr(h, EXAMSG_NBD_CLIENT_ID, EXAMSG_DAEMON_RQST,				    &req, sizeof(req),				    reply, sizeof(*reply));}