예제 #1
0
CSTUB_FN(int, tmerge)(struct usr_inv_cap *uc,
                      spdid_t spdid, td_t td, td_t td_into, char *param, int len)
{
    int ret;
    long fault = 0;
    struct __sg_tmerge_data *d;
    cbuf_t cb;
    int sz = len + sizeof(struct __sg_tmerge_data);

    assert(param && len > 0);
    assert(param[len-1] == '\0');

    d = cbuf_alloc_ext(sz, &cb, CBUF_TMEM);
    if (!d) return -1;

    d->td = td;
    d->td_into = td_into;
    d->len[0] = 0;
    d->len[1] = len;
    memcpy(&d->data[0], param, len);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    cbuf_free(cb);
    return ret;
}
예제 #2
0
CSTUB_FN(int, twmeta)(struct usr_inv_cap *uc,
                      spdid_t spdid, td_t td, const char *key,
                      unsigned int klen, const char *val, unsigned int vlen)
{
    int ret;
    long fault = 0;
    cbuf_t cb;
    int sz = sizeof(struct __sg_twmeta_data) + klen + vlen + 1;
    struct __sg_twmeta_data *d;

    assert(key && val && klen > 0 && vlen > 0);
    assert(key[klen] == '\0' && val[vlen] == '\0' && sz <= PAGE_SIZE);

    d = cbuf_alloc_ext(sz, &cb, CBUF_TMEM);
    if (!d) assert(0); //return -1;

    d->td = td;
    d->klen = klen;
    d->vlen = vlen;
    memcpy(&d->data[0], key, klen + 1);
    memcpy(&d->data[klen + 1], val, vlen + 1);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    cbuf_free(cb);
    return ret;
}
예제 #3
0
CSTUB_FN(int, trmeta)(struct usr_inv_cap *uc,
                      spdid_t spdid, td_t td, const char *key,
                      unsigned int klen, char *retval, unsigned int max_rval_len)
{
    int ret;
    long fault = 0;
    cbuf_t cb;
    int sz = sizeof(struct __sg_trmeta_data) + klen + max_rval_len + 1;
    struct __sg_trmeta_data *d;

    assert(key && retval && klen > 0 && max_rval_len > 0);
    assert(key[klen] == '\0' && sz <= PAGE_SIZE);

    d = cbuf_alloc_ext(sz, &cb, CBUF_TMEM);
    if (!d) return -1;

    d->td = td;
    d->klen = klen;
    d->retval_len = max_rval_len;
    memcpy(&d->data[0], key, klen + 1);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    if (ret >= 0) {
        if ((unsigned int)ret > max_rval_len) { // as ret >= 0, cast it to unsigned int to omit compiler warning
            cbuf_free(cb);
            return -EIO;
        }
        memcpy(retval, &d->data[klen + 1], ret + 1);
    }
    cbuf_free(cb);
    return ret;
}
CSTUB_FN(void, trelease)(struct usr_inv_cap *uc,
                         spdid_t spdid, td_t tid)
{
    int ret;
    long fault = 0;

    printc("<<<rtorrent In: call trelease (thread %d) >>>\n", cos_get_thd_id());
    struct rec_data_tor *rd;

redo:
    /* printc("<<< In: call trelease (thread %d) >>>\n", cos_get_thd_id()); */
    rd = rd_update(tid, STATE_TRELEASE);
    assert(rd);

    CSTUB_INVOKE(ret, fault, uc, 2, spdid, rd->s_tid);

    if (unlikely(fault)) {
        CSTUB_FAULT_UPDATE();
        goto redo;
    }

    map_rd_delete(rd->c_tid);

    return;
}
/* Here we have reset the owner to be 0 on the client side, so we do
 * not goto redo */
CSTUB_FN(int, lock_component_release) (struct usr_inv_cap *uc,
				       spdid_t spdid, unsigned long lock_id)
{
	long fault = 0;
	int ret;

        struct rec_data_lk *rd = NULL;
redo:
        rd = rd_update(lock_id, LOCK_RELEASE);
	assert(rd);
	/* if (!rd) { */
	/* 	printc("try to release a non-tracking lock\n"); */
	/* 	return -1; */
	/* } */

	CSTUB_INVOKE(ret, fault, uc, 2, spdid, rd->s_lkid);

	if (unlikely (fault)){
		/* printc("cli:thd %d see a fault in lock_component_release!\n",  */
		/*        cos_get_thd_id()); */
		CSTUB_FAULT_UPDATE();
		goto redo;
	}

	if (ret == -EINVAL) {
		/* printc("cli:thd %d lock_component_release return EINVAL\n", cos_get_thd_id()); */
		/* rd_recover_state(rd); */
		/* goto redo; */
		ret = 0;
	}
	/* printc("cli:thd %d lock_component_release return %d\n", cos_get_thd_id(), ret);	 */
	return ret;
}
예제 #6
0
CSTUB_FN(vaddr_t, mman_get_page) (struct usr_inv_cap *uc,
				  spdid_t spdid, vaddr_t addr, int flags)
{
	long fault = 0;
	long ret;

        if (first == 0 && cos_spd_id() != 5) {
		cvect_init_static(&rec_mm_vect);
		cvect_init_static(&parent_rec_mm_vect);
		first = 1;
	}

	unsigned long long start, end;
redo:
	if (cos_spd_id() != 5) {
		printc("cli: (spd %ld) call mman_get_page addr %p\n", 
		       cos_spd_id(), addr);
	}
	
	CSTUB_INVOKE(ret, fault, uc, 3,  spdid,addr, flags);
        if (unlikely (fault)){
		printc("found a fault in mman_get_page!!!!!\n");
		CSTUB_FAULT_UPDATE();
		goto redo;
	}
	
	if (cos_spd_id() != 5) {
		printc("cli: (in spd %ld) mman_get_page return ret %p\n",
		       cos_spd_id(), ret);
	}
	return ret;
}
예제 #7
0
CSTUB_FN(td_t, tsplit)(struct usr_inv_cap *uc,
                       spdid_t spdid, td_t tid, char * param,
                       int len, tor_flags_t tflags, long evtid)
{
    long fault = 0;
    td_t ret;
    struct __sg_tsplit_data *d;
    cbuf_t cb;
    int sz = len + sizeof(struct __sg_tsplit_data);

    assert(param && len >= 0);
    assert(param[len] == '\0');

    d = cbuf_alloc_ext(sz, &cb, CBUF_TMEM);
    if (!d) return -6;

    d->tid    = tid;
    d->tflags = tflags;
    d->evtid  = evtid;
    d->len[0] = 0;
    d->len[1] = len;
    memcpy(&d->data[0], param, len + 1);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    cbuf_free(cb);
    return ret;
}
예제 #8
0
CSTUB_FN(int, twrite)(struct usr_inv_cap *uc,
                      spdid_t spdid, td_t td, int cbid, int sz)
{
    int ret;
    long fault = 0;
    CSTUB_INVOKE(ret, fault, uc, 4, spdid, td, cbid, sz);
    return ret;
}
CSTUB_FN(unsigned long, lock_component_alloc) (struct usr_inv_cap *uc,
					       spdid_t spdid)
{
	long fault;
	unsigned long ret;

        struct rec_data_lk *rd = NULL;
	unsigned long ser_lkid, cli_lkid;

        if (first == 0) {
		cos_map_init_static(&uniq_lkids);
		first = 1;
	}

#ifdef BENCHMARK_MEAS_CREATION_TIME
	rdtscll(meas_start);
#endif

redo:

#ifdef BENCHMARK_MEAS_ALLOC
	rdtscll(meas_end);
	if (test_flag) {
		test_flag = 0;
		printc("recovery a lock cost: %llu\n", meas_end - meas_start);
	}
#endif		

	CSTUB_INVOKE(ret, fault, uc, 1, spdid);
	
	if (unlikely (fault)){

#ifdef BENCHMARK_MEAS_ALLOC
		test_flag = 1;
		rdtscll(meas_start);
#endif		
		CSTUB_FAULT_UPDATE();
		goto redo;
	}
	
	assert(ret > 0);

	cli_lkid = rdlk_alloc();
	assert(cli_lkid >= 1);
	rd = rdlk_lookup(cli_lkid);
        assert(rd);
	
	rd_cons(rd, cos_spd_id(), cli_lkid, ret, LOCK_ALLOC);
	ret = cli_lkid;

#ifdef BENCHMARK_MEAS_CREATION_TIME
	rdtscll(meas_end);
	printc("creating a lock costs %llu\n", meas_end - meas_start);
#endif

	return ret;
}
transition|terminal
// block_cli_if_invoke pred 6 end
// block_cli_if_invoke 6 start
static inline int block_cli_if_invoke_IDL_fname(IDL_parsdecl, int ret, long *fault, struct usr_inv_cap *uc) {
	long __fault = 0;
	CSTUB_INVOKE(ret, __fault, uc, IDL_pars_len, IDL_params);
	*fault = __fault;
	return ret;
}
예제 #11
0
파일: c_stub.c 프로젝트: gparmer/Composite
__attribute__((regparm(1))) int
SS_ipc_client_marshal_args(struct usr_inv_cap *uc, long p0, long p1, long p2, long p3)
{
	int ret, done;
	do {
		CSTUB_INVOKE(ret, done, uc, 4, p0, p1, p2, p3);
	} while (unlikely(done != 1));
	return ret;
}
예제 #12
0
CSTUB_FN(int, lock_component_take) (struct usr_inv_cap *uc,
				    spdid_t spdid, 
				    unsigned long lock_id, unsigned short int thd)
{
	long fault = 0;
	int ret;

	struct rec_data_lk *rd = NULL;

redo:
	rd = rd_update(lock_id, LOCK_TAKE);
	assert(rd);
	
#ifdef BENCHMARK_MEAS_TAKE
	rdtscll(meas_end);
	/* printc("now take again(thd %d, end %llu)!!!!\n", cos_get_thd_id(), meas_end); */
	if (test_flag) {
		test_flag = 0;
		printc("recovery a lock cost: %llu\n", meas_end - meas_start);
	}
#endif		

	CSTUB_INVOKE(ret, fault, uc, 3, spdid, rd->s_lkid, thd);
	
	if (unlikely (fault)){
		/* printc("cli:thd %d see a fault in lock_component_take!\n", cos_get_thd_id()); */
		lock_component_take_ubenchmark_flag = 1;
		rdtscll(ubenchmark_start);

#ifdef BENCHMARK_MEAS_TAKE
		test_flag = 1;
		rdtscll(meas_start);
		/* printc("a fault(thd %d start %llu)!!!!\n", cos_get_thd_id(), meas_start); */
#endif		
		CSTUB_FAULT_UPDATE();
		goto redo;
		/* rd = rd_update(lock_id, LOCK_TAKE); */
		/* ret = 0;  */
		/* rdtscll(ubenchmark_end); */
		/* if (lock_component_take_ubenchmark_flag) { */
		/* 	lock_component_take_ubenchmark_flag = 0; */
		/* 	printc */
		/* 		("lock_component_take(C3):recover per object end-end cost: %llu\n", */
		/* 		 ubenchmark_end - ubenchmark_start); */
		/* } */
		
	}
	if (ret == -EINVAL) {
		/* printc("cli:thd %d lock_component_take return EINVAL\n", cos_get_thd_id()); */
		rd_recover_state(rd);
		goto redo;
	}

	/* printc("cli:thd %d lock_component_take return %d\n", cos_get_thd_id(), ret); */
	return ret;
}
static inline int block_cli_if_invoke_sched_wakeup(spdid_t spdid, u16_t thdid,
						   int ret, long *fault,
						   struct usr_inv_cap *uc)
{
	long __fault = 0;

	CSTUB_INVOKE(ret, __fault, uc, 2, spdid, thdid);
	*fault = __fault;
	return ret;
}
// block_cli_if_invoke pred 3 start
desc_dep_create_none
creation
// block_cli_if_invoke pred 3 end
// block_cli_if_invoke 3 start
static inline int block_cli_if_invoke_IDL_fname(IDL_parsdecl, int ret, long *fault, struct usr_inv_cap *uc) {
	long __fault = 0;
	CSTUB_INVOKE(ret, __fault, uc, IDL_pars_len, IDL_params);
	*fault = __fault;
	return ret;
}
static inline int block_cli_if_invoke_sched_timeout(spdid_t spdid, ul_t amnt,
						    int ret, long *fault,
						    struct usr_inv_cap *uc)
{
	long __fault = 0;

	CSTUB_INVOKE(ret, __fault, uc, 2, spdid, amnt);
	*fault = __fault;
	return ret;
}
예제 #16
0
파일: c_stub.c 프로젝트: georgit/Composite
CSTUB_FN(int, twritep)(struct usr_inv_cap *uc,
		       spdid_t spdid, td_t td, int cbuf_id, int start, int sz)
{
	int ret;
	long fault = 0;

	int temp = (td << 16) | (cbuf_id & 0xFFFF);

	CSTUB_INVOKE(ret, fault, uc, 4, spdid, temp, start, sz);
	return ret;
}
transition|terminal
// block_cli_if_invoke pred 5 end
// block_cli_if_invoke 5 start
static inline int block_cli_if_invoke_IDL_fname(IDL_parsdecl, int ret, long *fault, struct usr_inv_cap *uc) {
	struct desc_track *desc = call_desc_lookup(IDL_id);
	long __fault = 0;
	if (desc) {  // might be created in the same component
		CSTUB_INVOKE(ret, __fault, uc, IDL_pars_len, IDL_server_id_params);
	} else {    // might be created in different component
		CSTUB_INVOKE(ret, __fault, uc, IDL_pars_len, IDL_params);
		if (ret == -1) {   // desc not exist  TODO: change to error code
			block_cli_if_recover(IDL_id);// need upcall
			assert((desc = call_desc_lookup(IDL_id)));
			CSTUB_INVOKE(ret, __fault, uc, IDL_pars_len, IDL_params);
		}
	}
	*fault = __fault;

	return ret;
}
static inline int block_cli_if_invoke_sched_block(spdid_t spdid,
						  u16_t dependency_thd, int ret,
						  long *fault,
						  struct usr_inv_cap *uc)
{
	long __fault = 0;

	CSTUB_INVOKE(ret, __fault, uc, 2, spdid, dependency_thd);
	*fault = __fault;
	return ret;
}
static inline int block_cli_if_invoke_sched_component_take(spdid_t spdid,
							   int ret, long *fault,
							   struct usr_inv_cap
							   *uc)
{
	long __fault = 0;

	CSTUB_INVOKE(ret, __fault, uc, 1, spdid);
	*fault = __fault;
	return ret;
}
static inline int block_cli_if_invoke_sched_create_thd(spdid_t spdid,
						       u32_t sched_param0,
						       u32_t sched_param1,
						       u32_t sched_param2,
						       int ret, long *fault,
						       struct usr_inv_cap *uc)
{
	long __fault = 0;
	CSTUB_INVOKE(ret, __fault, uc, 4, spdid, sched_param0, sched_param1,
		     sched_param2);
	*fault = __fault;
	return ret;
}
static inline int block_cli_if_invoke_evt_trigger(spdid_t spdid, long evtid,
						  int ret, long *fault,
						  struct usr_inv_cap *uc)
{
	long __fault = 0;
	struct desc_track *desc = call_desc_lookup(evtid);

	//if (desc) {  // might be created in the same component
	//      CSTUB_INVOKE(ret, __fault, uc, 2, spdid, evtid);
	//} else {    // might be created in different component

	CSTUB_INVOKE(ret, __fault, uc, 2, spdid, evtid);
	if (ret == -1) {	// desc not exist  TODO: change to error code
		block_cli_if_recover(evtid);	// need upcall
		assert((desc = call_desc_lookup(evtid)));
		CSTUB_INVOKE(ret, __fault, uc, 2, spdid, evtid);
	}

	*fault = __fault;

	return ret;
}
예제 #22
0
CSTUB_FN(vaddr_t, mman_revoke_page) (struct usr_inv_cap *uc,
				     spdid_t spdid, vaddr_t addr, int flags)
{
	long fault = 0;
	long ret;
	
	struct rec_data_mm *rd = NULL;

        if (first == 0 && cos_spd_id() != 5) {
		cvect_init_static(&rec_mm_vect);
		cvect_init_static(&parent_rec_mm_vect);
		first = 1;
	}

	if (cos_spd_id() == 5) goto con;
	
redo:

	rd_update(addr, PAGE_STATE_REVOKE);
	
	printc("cli: mman_revoke_page 1\n");
con:
	CSTUB_INVOKE(ret, fault, uc, 3,  spdid, addr, flags);
        if (unlikely (fault)){
		printc("found a fault in mman_revoke_page!!!!\n");
		CSTUB_FAULT_UPDATE();
		goto redo;
	}

	if (cos_spd_id() == 5) goto done;

	if (ret == -EINVAL) {
		rd_update_subtree(addr, PAGE_STATE_REVOKE);
		goto redo;
	}


	/* here is one issue: if we always remove all tracking
	 * descriptors here, a page that was aliased (and tracked) in
	 * another component might not be removed explicitly through
	 * the revoke functoin. So we do non remove the descriptors*/
	
	/* rd_remove(addr);*/

	/* revoke does not reomve itself, only subtree. So the created
	 * rd is not reomved here. release_page does.*/
	/* rdmm_dealloc(rd); */
done:
	printc("cli: mman_revoke_page return %d\n", ret);
	return ret;
}
static inline int block_cli_if_invoke_evt_split(spdid_t spdid,
						long parent_evtid, int grp,
						int ret, long *fault,
						struct usr_inv_cap *uc)
{
	struct desc_track *parent_desc = NULL;
	if ((parent_evtid > 1)
	    && (parent_desc = call_desc_lookup(parent_evtid))) {
		parent_evtid = parent_desc->evtid;
	}

	long __fault = 0;
	CSTUB_INVOKE(ret, __fault, uc, 3, spdid, parent_evtid, grp);
	*fault = __fault;

	return ret;
}
예제 #24
0
CSTUB_FN(int, tmerge)(struct usr_inv_cap *uc, spdid_t spdid, td_t td,
                      td_t td_into, char * param, int len)
{
    long fault = 0;
    td_t ret;

    struct __sg_tmerge_data *d;
    struct rec_data_tor *rd;
    cbuf_t cb;
    int sz = len + sizeof(struct __sg_tmerge_data);

    /* printc("<<< rtorrent In: call tmerge (thread %d) >>>\n", cos_get_thd_id()); */

    assert(param && len > 0);
    assert(param[len] == '\0');

redo:
    /* printc("<<< In: call tmerge (thread %d) >>>\n", cos_get_thd_id()); */
    rd = rd_update(td, STATE_TMERGE);
    assert(rd);

    d = cbuf_alloc(sz, &cb);
    if (!d) return -1;

    /* printc("c: tmerge td %d (server td %d) len %d param %s\n", td, rd->s_tid, len, param);	 */
    d->td = rd->s_tid;   	/* actual server side torrent id */
    d->td_into = td_into;
    d->len[0] = 0;
    d->len[1] = len;
    memcpy(&d->data[0], param, len);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    if (unlikely(fault)) {
        CSTUB_FAULT_UPDATE();
        cbuf_free(cb);
        goto redo;
    }

    cbuf_free(cb);

    if (!ret) map_rd_delete(rd->c_tid);

    return ret;
}
// block_cli_if_invoke pred 2 start
desc_dep_create_diff
creation
// block_cli_if_invoke pred 2 end
// block_cli_if_invoke 2 start
static inline int block_cli_if_invoke_IDL_fname(IDL_parsdecl, int ret, long *fault, struct usr_inv_cap *uc) {
	struct desc_track *parent_desc = NULL;
	if ((IDL_parent_id > 1) && (parent_desc = call_desc_lookup(IDL_parent_id))) {
		IDL_parent_id = parent_desc->IDL_server_id;
	} /* else {  	// td_root, or in a different component */
	/* 	IDL_parent_id = IDL_parent_id; */
	/* } */

	long __fault = 0;
	CSTUB_INVOKE(ret, __fault, uc, IDL_pars_len, IDL_params);
	*fault = __fault;

	return ret;
}
예제 #26
0
CSTUB_FN(int, trmeta)(struct usr_inv_cap *uc,
                      spdid_t spdid, td_t td, const char *key,
                      unsigned int klen, char *retval, unsigned int max_rval_len)
{
    int ret;
    long fault = 0;
    cbuf_t cb;
    int sz = sizeof(struct __sg_trmeta_data) + klen + max_rval_len + 1;
    struct __sg_trmeta_data *d;
    struct rec_data_tor *rd;

    assert(key && retval && klen > 0 && max_rval_len > 0);
    assert(key[klen] == '\0' && sz <= PAGE_SIZE);

redo:
    printc("<<< In: call trmeta (thread %d) >>>\n", cos_get_thd_id());
    rd = rd_update(td, STATE_TRMETA);
    assert(rd);

    d = cbuf_alloc(sz, &cb);
    if (!d) return -1;

    d->td = rd->s_tid;
    d->klen = klen;
    d->retval_len = max_rval_len;
    memcpy(&d->data[0], key, klen + 1);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);
    if (unlikely(fault)) {
        CSTUB_FAULT_UPDATE();
        goto redo;
    }


    if (ret >= 0) {
        if ((unsigned int)ret > max_rval_len) { // as ret >= 0, cast it to unsigned int to omit compiler warning
            cbuf_free(cb);
            return -EIO;
        }
        memcpy(retval, &d->data[klen + 1], ret + 1);
    }
    cbuf_free(cb);
    return ret;
}
예제 #27
0
CSTUB_FN(int, lock_component_pretake) (struct usr_inv_cap *uc,
				       spdid_t spdid, unsigned long lock_id, 
				       unsigned short int thd)
{
	long fault = 0;
	int ret;
	
        struct rec_data_lk *rd = NULL;
redo:
        rd = rd_update(lock_id, LOCK_PRETAKE);
	assert(rd);

#ifdef BENCHMARK_MEAS_PRETAKE
	rdtscll(meas_end);
	if (test_flag) {
		test_flag = 0;
		printc("recovery a lock cost: %llu\n", meas_end - meas_start);
	}
#endif		
	
	CSTUB_INVOKE(ret, fault, uc, 3, spdid, rd->s_lkid, thd);
	
	if (unlikely(fault)){
		printc("cli:thd %d see a fault in lock_component_pretake!\n", 
		       cos_get_thd_id());
#ifdef BENCHMARK_MEAS_PRETAKE
		test_flag = 1;
		rdtscll(meas_start);
#endif		
		CSTUB_FAULT_UPDATE();		
		goto redo;  // update the generation number
	}

	if (ret == -EINVAL) {
		/* printc("cli:thd %d lock_component_pretake return EINVAL\n", cos_get_thd_id()); */
		rd_recover_state(rd);
		goto redo;
	}

	/* printc("cli:thd %d lock_component_pretake return %d\n", cos_get_thd_id(), ret); */
	
	return ret;
}
예제 #28
0
CSTUB_FN(int, twmeta)(struct usr_inv_cap *uc,
                      spdid_t spdid, td_t td, const char *key,
                      unsigned int klen, const char *val, unsigned int vlen)
{
    int ret;
    long fault = 0;
    cbuf_t cb;
    int sz = sizeof(struct __sg_twmeta_data) + klen + vlen + 1;
    struct __sg_twmeta_data *d;
    struct rec_data_tor *rd;

    assert(key && val && klen > 0 && vlen > 0);
    assert(key[klen] == '\0' && val[vlen] == '\0' && sz <= PAGE_SIZE);

redo:
    printc("<<< In: call twmeta (thread %d) >>>\n", cos_get_thd_id());
    rd = rd_update(td, STATE_TWMETA);
    assert(rd);

    d = cbuf_alloc(sz, &cb);
    if (!d) assert(0); //return -1;

    d->td   = td;   // do not pass rd->s_tid since this is only for recovery
    d->klen = klen;
    d->vlen = vlen;
    memcpy(&d->data[0], key, klen + 1);
    memcpy(&d->data[klen + 1], val, vlen + 1);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    if (unlikely(fault)) {
        CSTUB_FAULT_UPDATE();
        goto redo;
    }

    cbuf_free(cb);
    return ret;
}
예제 #29
0
CSTUB_FN(int, twritep)(struct usr_inv_cap *uc,
                       spdid_t spdid, td_t td, int cb, int sz)
{
    long fault = 0;
    td_t ret;

    struct rec_data_tor *rd;
redo:
    /* printc("<<< In: call twrite  (thread %d) >>>\n", cos_get_thd_id()); */
    rd = rd_update(td, STATE_TWRITE);
    assert(rd);

    CSTUB_INVOKE(ret, fault, uc, 4, spdid, rd->s_tid, cb, sz);

    if (unlikely(fault)) {
        CSTUB_FAULT_UPDATE();
        goto redo;
    }

    /* we can not save the infor here since we need track the offset and
     * uniq file id any way */
    return ret;
}
예제 #30
0
CSTUB_FN(td_t, tsplit)(struct usr_inv_cap *uc,
                       spdid_t spdid, td_t parent_tid, char * param,
                       int len, tor_flags_t tflags, long evtid)
{
    long fault = 0;
    td_t ret;

    struct __sg_tsplit_data *d = NULL;
    cbuf_t cb = 0;

    struct rec_data_tor *rd = NULL;
    int sz  = len + sizeof(struct __sg_tsplit_data);
    td_t		curr_ptid  = 0;
    td_t		cli_tid	   = 0;
    td_t		ser_tid	   = 0;

    /* printc("cli: tsplit passed in param %s\n", param); */
    assert(parent_tid >= 1);
    assert(param && len >= 0);
    assert(param[len] == '\0');

    if (first == 0) {
        cos_map_init_static(&uniq_tids);
        first = 1;
    }

redo:
    /* printc("<<< cli rtorrent: call tsplit  (thread %d, spd %ld and parent tid %d) >>>\n", */
    /*        cos_get_thd_id(), cos_spd_id(), parent_tid); */

    rd = rd_update(parent_tid, STATE_TSPLIT_PARENT);
    if (rd) {
        curr_ptid  = rd->s_tid;
    } else {
        curr_ptid  = parent_tid;
    }
    /* printc("<<< In: call tsplit (thread %d, , spd %ld and curr_parent tid %d) >>>\n",  */
    /*        cos_get_thd_id(), cos_spd_id(), curr_ptid); */

    d = cbuf_alloc(sz, &cb);
    assert(d);
    if (!d) return -1;
    d->parent_tid  = curr_ptid;
    d->tflags      = tflags;
    d->evtid       = evtid;
    d->len[0]      = 0;
    d->len[1]      = len;
    memcpy(&d->data[0], param, len + 1);

    CSTUB_INVOKE(ret, fault, uc, 3, spdid, cb, sz);

    if (unlikely(fault)) {
        CSTUB_FAULT_UPDATE();
        memset(&d->data[0], 0, len);
        cbuf_free(cb);
        printc("tsplit found a fault and ready to go to redo\n");
        goto redo;
    }
    cbuf_free(cb);

    ser_tid = ret;
    /* printc("passed in param %s (ser_tid %d)\n", param, ser_tid); */
    assert(ser_tid >= 1);

    char *l_param = "";
    if (len > 0) {
        l_param = param_save(param, len);
        assert(l_param);
    }

    cli_tid = map_rd_create();
    assert(cli_tid >= 2);

    rd = map_rd_lookup(cli_tid);
    assert(rd);

    rd_cons(rd, curr_ptid, cli_tid, ser_tid, l_param, len, tflags, evtid);

    /* printc("tsplit done!!! return new client tid %d\n\n", cli_tid); */
    return cli_tid;
}