C++ (Cpp) rpc_release示例

示例#1

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_ping() {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_ping", RPC_PROC_PING);
    rpc_set_dest(REFOS_PROCSERV_EP);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#2

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_window_unmap() {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_window_unmap", RPC_PROC_WINDOW_UNMAP);
    rpc_set_dest(REFOS_PROCSERV_EP);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#3

文件： nfsiod.c 项目： liexusong/linux2.0-comment

void
nfsiod_release(struct nfsiod_req *req)
{
	dprintk("BIO: nfsiod_release called\n");
	rpc_release(req->rq_server->rsock, &req->rq_rpcreq);
	memset(&req->rq_rpcreq, 0, sizeof(struct rpc_ioreq));
	req->rq_next = free_list;
	free_list = req;
}

示例#4

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_unwatch_client(seL4_CPtr liveness) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_unwatch_client", RPC_PROC_UNWATCH_CLIENT);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(liveness);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#5

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_delete_mem_window(seL4_CPtr window) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_delete_mem_window", RPC_PROC_DELETE_MEM_WINDOW);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(window);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#6

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_notification_buffer(seL4_CPtr dataspace) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_notification_buffer", RPC_PROC_NOTIFICATION_BUFFER);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(dataspace);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#7

文件： proc_client.c 项目： gapry/refos

int proc_window_getID(seL4_CPtr window) {
    int rpc__error_;
    int __ret__;
    memset(&__ret__, 0, sizeof(int));

    rpc_init("proc_window_getID", RPC_PROC_WINDOW_GETID);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(window);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    __ret__ = (int) rpc_pop_uint();
    rpc_release();
    return __ret__;
}

示例#8

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_exit(int32_t status) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_exit", RPC_PROC_EXIT);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_uint(status);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#9

文件： name_client.c 项目： gapry/refos

refos_err_t nsv_unregister(seL4_CPtr nameserv, char* name) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("nsv_unregister", RPC_NSV_UNREGISTER);
    rpc_set_dest(nameserv);
    rpc_push_str(name);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#10

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_unregister_as_pager(seL4_CPtr window) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_unregister_as_pager", RPC_PROC_UNREGISTER_AS_PAGER);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(window);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#11

文件： proc_client.c 项目： gapry/refos

seL4_CPtr proc_new_async_endpoint_internal(refos_err_t* errno) {
    int rpc__error_;
    seL4_CPtr __ret__;
    memset(&__ret__, 0, sizeof(seL4_CPtr));

    rpc_init("proc_new_async_endpoint_internal", RPC_PROC_NEW_ASYNC_ENDPOINT_INTERNAL);
    rpc_set_dest(REFOS_PROCSERV_EP);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(errno, sizeof(refos_err_t));
    __ret__ = (seL4_CPtr) rpc_pop_cptr();
    __ret__ = rpc_copyout_cptr(__ret__);
    rpc_release();
    return __ret__;
}

示例#12

文件： proc_client.c 项目： gapry/refos

seL4_CPtr proc_get_irq_handler(int irq) {
    int rpc__error_;
    seL4_CPtr __ret__;
    memset(&__ret__, 0, sizeof(seL4_CPtr));

    rpc_init("proc_get_irq_handler", RPC_PROC_GET_IRQ_HANDLER);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_uint(irq);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    __ret__ = (seL4_CPtr) rpc_pop_cptr();
    __ret__ = rpc_copyout_cptr(__ret__);
    rpc_release();
    return __ret__;
}

示例#13

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_nice(int threadID, int priority) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_nice", RPC_PROC_NICE);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_uint(threadID);
    rpc_push_uint(priority);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#14

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_set_parambuffer(seL4_CPtr dataspace, uint32_t size) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_set_parambuffer", RPC_PROC_SET_PARAMBUFFER);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(dataspace);
    rpc_push_uint(size);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#15

文件： proc_client.c 项目： gapry/refos

seL4_CPtr proc_get_mem_window(uint32_t vaddr) {
    int rpc__error_;
    seL4_CPtr __ret__;
    memset(&__ret__, 0, sizeof(seL4_CPtr));

    rpc_init("proc_get_mem_window", RPC_PROC_GET_MEM_WINDOW);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_uint(vaddr);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    __ret__ = (seL4_CPtr) rpc_pop_cptr();
    __ret__ = rpc_copyout_cptr(__ret__);
    rpc_release();
    return __ret__;
}

示例#16

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_window_map(seL4_CPtr window, uint32_t windowOffset, uint32_t srcAddr) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_window_map", RPC_PROC_WINDOW_MAP);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(window);
    rpc_push_uint(windowOffset);
    rpc_push_uint(srcAddr);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#17

文件： proc_client.c 项目： gapry/refos

seL4_CPtr proc_get_mem_window_dspace(seL4_CPtr window, refos_err_t* errno) {
    int rpc__error_;
    seL4_CPtr __ret__;
    memset(&__ret__, 0, sizeof(seL4_CPtr));

    rpc_init("proc_get_mem_window_dspace", RPC_PROC_GET_MEM_WINDOW_DSPACE);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_cptr(window);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(errno, sizeof(refos_err_t));
    __ret__ = (seL4_CPtr) rpc_pop_cptr();
    __ret__ = rpc_copyout_cptr(__ret__);
    rpc_release();
    return __ret__;
}

示例#18

文件： name_client.c 项目： gapry/refos

seL4_CPtr nsv_resolve_segment_internal(seL4_CPtr nameserv, char* path, int* resolvedBytes, refos_err_t* errno) {
    int rpc__error_;
    seL4_CPtr __ret__;
    memset(&__ret__, 0, sizeof(seL4_CPtr));

    rpc_init("nsv_resolve_segment_internal", RPC_NSV_RESOLVE_SEGMENT_INTERNAL);
    rpc_set_dest(nameserv);
    rpc_push_str(path);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(resolvedBytes, sizeof(int));
    rpc_pop_buf(errno, sizeof(refos_err_t));
    __ret__ = (seL4_CPtr) rpc_pop_cptr();
    __ret__ = rpc_copyout_cptr(__ret__);
    rpc_release();
    return __ret__;
}

示例#19

文件： proc_client.c 项目： gapry/refos

int proc_clone_internal(seL4_Word entryPoint, seL4_Word childStack, int flags, seL4_Word arg, refos_err_t* errno) {
    int rpc__error_;
    int __ret__;
    memset(&__ret__, 0, sizeof(int));

    rpc_init("proc_clone_internal", RPC_PROC_CLONE_INTERNAL);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_buf(&entryPoint, sizeof(seL4_Word));
    rpc_push_buf(&childStack, sizeof(seL4_Word));
    rpc_push_uint(flags);
    rpc_push_buf(&arg, sizeof(seL4_Word));

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(errno, sizeof(refos_err_t));
    __ret__ = (int) rpc_pop_uint();
    rpc_release();
    return __ret__;
}

示例#20

文件： proc_client.c 项目： gapry/refos

refos_err_t proc_new_proc(char* name, char* params, bool block, int32_t priority, int32_t* status) {
    int rpc__error_;
    refos_err_t __ret__;
    memset(&__ret__, 0, sizeof(refos_err_t));

    rpc_init("proc_new_proc", RPC_PROC_NEW_PROC);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_str(name);
    rpc_push_str(params);
    rpc_push_buf(&block, sizeof(bool));
    rpc_push_uint(priority);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(status, sizeof(int32_t));
    rpc_pop_buf(&__ret__, sizeof(refos_err_t));
    rpc_release();
    return __ret__;
}

示例#21

文件： proc_client.c 项目： gapry/refos

seL4_CPtr proc_create_mem_window_internal(uint32_t vaddr, uint32_t size, uint32_t permissions, uint32_t flags, refos_err_t* errno) {
    int rpc__error_;
    seL4_CPtr __ret__;
    memset(&__ret__, 0, sizeof(seL4_CPtr));

    rpc_init("proc_create_mem_window_internal", RPC_PROC_CREATE_MEM_WINDOW_INTERNAL);
    rpc_set_dest(REFOS_PROCSERV_EP);
    rpc_push_uint(vaddr);
    rpc_push_uint(size);
    rpc_push_uint(permissions);
    rpc_push_uint(flags);

    rpc__error_ = rpc_call_server();
    if (rpc__error_) {
        rpc_release();
        return __ret__;
    }

    rpc_pop_buf(errno, sizeof(refos_err_t));
    __ret__ = (seL4_CPtr) rpc_pop_cptr();
    __ret__ = rpc_copyout_cptr(__ret__);
    rpc_release();
    return __ret__;
}