Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2677 → Rev 2678

/trunk/uspace/app/tester/devmap/devmap1.c
142,7 → 142,7
req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
 
retval = ipc_data_write_send(phone, (char *)name, strlen(name) + 1);
retval = ipc_data_write_start(phone, (char *)name, strlen(name) + 1);
 
if (retval != EOK) {
async_wait_for(req, NULL);
175,7 → 175,7
req = async_send_2(driver_phone, DEVMAP_DEVICE_GET_HANDLE, 0, 0,
&answer);
 
retval = ipc_data_write_send(driver_phone, name, strlen(name) + 1);
retval = ipc_data_write_start(driver_phone, name, strlen(name) + 1);
 
if (retval != EOK) {
printf("Failed to send device name '%s'.\n", name);
216,7 → 216,7
 
req = async_send_2(driver_phone, DEVMAP_DEVICE_REGISTER, 0, 0, &answer);
 
retval = ipc_data_write_send(driver_phone, (char *)name,
retval = ipc_data_write_start(driver_phone, (char *)name,
strlen(name) + 1);
 
if (retval != EOK) {
/trunk/uspace/app/klog/klog.c
63,7 → 63,7
printf("Kernel console output.\n");
mapping = as_get_mappable_page(PAGE_SIZE);
res = ipc_share_in_send_1_0(PHONE_NS, mapping, PAGE_SIZE,
res = ipc_share_in_start_1_0(PHONE_NS, mapping, PAGE_SIZE,
SERVICE_MEM_KLOG);
if (res) {
printf("Failed to initialize klog memarea\n");
/trunk/uspace/lib/libfs/libfs.c
71,7 → 71,7
/*
* Send our VFS info structure to VFS.
*/
int rc = ipc_data_write_send(vfs_phone, info, sizeof(*info));
int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info));
if (rc != EOK) {
async_wait_for(req, NULL);
return rc;
94,7 → 94,7
/*
* Request sharing the Path Lookup Buffer with VFS.
*/
rc = ipc_share_in_send_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
if (rc) {
async_wait_for(req, NULL);
return rc;
/trunk/uspace/lib/libc/include/ipc/ipc.h
263,30 → 263,30
 
 
/*
* User-friendly wrappers for ipc_share_in_send().
* User-friendly wrappers for ipc_share_in_start().
*/
#define ipc_share_in_send_0_0(phoneid, dst, size) \
ipc_share_in_send((phoneid), (dst), (size), 0, NULL)
#define ipc_share_in_send_0_1(phoneid, dst, size, flags) \
ipc_share_in_send((phoneid), (dst), (size), 0, (flags))
#define ipc_share_in_send_1_0(phoneid, dst, size, arg) \
ipc_share_in_send((phoneid), (dst), (size), (arg), NULL)
#define ipc_share_in_send_1_1(phoneid, dst, size, arg, flags) \
ipc_share_in_send((phoneid), (dst), (size), (arg), (flags))
#define ipc_share_in_start_0_0(phoneid, dst, size) \
ipc_share_in_start((phoneid), (dst), (size), 0, NULL)
#define ipc_share_in_start_0_1(phoneid, dst, size, flags) \
ipc_share_in_start((phoneid), (dst), (size), 0, (flags))
#define ipc_share_in_start_1_0(phoneid, dst, size, arg) \
ipc_share_in_start((phoneid), (dst), (size), (arg), NULL)
#define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
 
extern int ipc_share_in_send(int phoneid, void *dst, size_t size, ipcarg_t arg,
extern int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
int *flags);
extern int ipc_share_in_receive(ipc_callid_t *callid, size_t *size);
extern int ipc_share_in_deliver(ipc_callid_t callid, void *src, int flags);
extern int ipc_share_out_send(int phoneid, void *src, int flags);
extern int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags);
extern int ipc_share_out_start(int phoneid, void *src, int flags);
extern int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags);
extern int ipc_share_out_deliver(ipc_callid_t callid, void *dst);
extern int ipc_data_read_send(int phoneid, void *dst, size_t size);
extern int ipc_share_out_finalize(ipc_callid_t callid, void *dst);
extern int ipc_data_read_start(int phoneid, void *dst, size_t size);
extern int ipc_data_read_receive(ipc_callid_t *callid, size_t *size);
extern int ipc_data_read_deliver(ipc_callid_t callid, void *src, size_t size);
extern int ipc_data_write_send(int phoneid, void *src, size_t size);
extern int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size);
extern int ipc_data_write_start(int phoneid, void *src, size_t size);
extern int ipc_data_write_receive(ipc_callid_t *callid, size_t *size);
extern int ipc_data_write_deliver(ipc_callid_t callid, void *dst, size_t size);
extern int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size);
 
#endif
 
/trunk/uspace/lib/libc/generic/time.c
141,7 → 141,7
if (!ktime) {
mapping = as_get_mappable_page(PAGE_SIZE);
/* Get the mapping of kernel clock */
res = ipc_share_in_send_1_1(PHONE_NS, mapping, PAGE_SIZE,
res = ipc_share_in_start_1_1(PHONE_NS, mapping, PAGE_SIZE,
SERVICE_MEM_REALTIME, &rights);
if (res) {
printf("Failed to initialize timeofday memarea\n");
/trunk/uspace/lib/libc/generic/vfs.c
73,7 → 73,7
}
}
req = async_send_1(vfs_phone, VFS_MOUNT, dev_handle, NULL);
rc = ipc_data_write_send(vfs_phone, (void *)fs_name, strlen(fs_name));
rc = ipc_data_write_start(vfs_phone, (void *)fs_name, strlen(fs_name));
if (rc != EOK) {
async_wait_for(req, NULL);
async_serialize_end();
80,7 → 80,7
futex_up(&vfs_phone_futex);
return (int) rc;
}
rc = ipc_data_write_send(vfs_phone, (void *)mp, strlen(mp));
rc = ipc_data_write_start(vfs_phone, (void *)mp, strlen(mp));
if (rc != EOK) {
async_wait_for(req, NULL);
async_serialize_end();
112,7 → 112,7
}
}
req = async_send_2(vfs_phone, VFS_OPEN, oflag, 0, &answer);
rc = ipc_data_write_send(vfs_phone, name, strlen(name));
rc = ipc_data_write_start(vfs_phone, name, strlen(name));
if (rc != EOK) {
async_wait_for(req, NULL);
async_serialize_end();
143,7 → 143,7
}
}
req = async_send_1(vfs_phone, VFS_READ, fildes, &answer);
if (ipc_data_read_send(vfs_phone, (void *)buf, nbyte) != EOK) {
if (ipc_data_read_start(vfs_phone, (void *)buf, nbyte) != EOK) {
async_wait_for(req, NULL);
async_serialize_end();
futex_up(&vfs_phone_futex);
173,7 → 173,7
}
}
req = async_send_1(vfs_phone, VFS_WRITE, fildes, &answer);
if (ipc_data_write_send(vfs_phone, (void *)buf, nbyte) != EOK) {
if (ipc_data_write_start(vfs_phone, (void *)buf, nbyte) != EOK) {
async_wait_for(req, NULL);
async_serialize_end();
futex_up(&vfs_phone_futex);
/trunk/uspace/lib/libc/generic/ipc.c
677,7 → 677,7
*
* @return Zero on success or a negative error code from errno.h.
*/
int ipc_share_in_send(int phoneid, void *dst, size_t size, ipcarg_t arg,
int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
int *flags)
{
int res;
727,7 → 727,7
*
* @return Zero on success or a value from @ref errno.h on failure.
*/
int ipc_share_in_deliver(ipc_callid_t callid, void *src, int flags)
int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags)
{
return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) flags);
}
740,7 → 740,7
*
* @return Zero on success or a negative error code from errno.h.
*/
int ipc_share_out_send(int phoneid, void *src, int flags)
int ipc_share_out_start(int phoneid, void *src, int flags)
{
return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
(ipcarg_t) flags);
787,7 → 787,7
*
* @return Zero on success or a value from @ref errno.h on failure.
*/
int ipc_share_out_deliver(ipc_callid_t callid, void *dst)
int ipc_share_out_finalize(ipc_callid_t callid, void *dst)
{
return ipc_answer_1(callid, EOK, (ipcarg_t) dst);
}
801,7 → 801,7
*
* @return Zero on success or a negative error code from errno.h.
*/
int ipc_data_read_send(int phoneid, void *dst, size_t size)
int ipc_data_read_start(int phoneid, void *dst, size_t size)
{
return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
(ipcarg_t) size);
847,7 → 847,7
*
* @return Zero on success or a value from @ref errno.h on failure.
*/
int ipc_data_read_deliver(ipc_callid_t callid, void *src, size_t size)
int ipc_data_read_finalize(ipc_callid_t callid, void *src, size_t size)
{
return ipc_answer_2(callid, EOK, (ipcarg_t) src, (ipcarg_t) size);
}
860,7 → 860,7
*
* @return Zero on success or a negative error code from errno.h.
*/
int ipc_data_write_send(int phoneid, void *src, size_t size)
int ipc_data_write_start(int phoneid, void *src, size_t size)
{
return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
(ipcarg_t) size);
905,7 → 905,7
*
* @return Zero on success or a value from @ref errno.h on failure.
*/
int ipc_data_write_deliver(ipc_callid_t callid, void *dst, size_t size)
int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
{
return ipc_answer_2(callid, EOK, (ipcarg_t) dst, (ipcarg_t) size);
}
/trunk/uspace/srv/console/console.c
537,7 → 537,7
sizeof(keyfield_t) * fb_info.cols * fb_info.rows,
PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
if (!interbuffer) {
if (ipc_share_out_send(fb_info.phone, interbuffer,
if (ipc_share_out_start(fb_info.phone, interbuffer,
AS_AREA_READ) != EOK) {
munmap(interbuffer,
sizeof(keyfield_t) * fb_info.cols * fb_info.rows);
/trunk/uspace/srv/console/gcons.c
325,7 → 325,7
rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
if (rc)
goto exit;
rc = ipc_share_out_send(fbphone, shm, PROTO_READ);
rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
if (rc)
goto drop;
/* Draw logo */
386,7 → 386,7
rc = async_req_1_0(fbphone, FB_PREPARE_SHM, (ipcarg_t) shm);
if (rc)
goto exit;
rc = ipc_share_out_send(fbphone, shm, PROTO_READ);
rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
if (rc)
goto drop;
 
/trunk/uspace/srv/rd/rd.c
110,7 → 110,7
* The client sends an as_area that can absorb the whole
* block.
*/
(void) ipc_share_out_deliver(callid, fs_va);
(void) ipc_share_out_finalize(callid, fs_va);
} else {
/*
* The client offered as_area too small.
/trunk/uspace/srv/fs/tmpfs/tmpfs_ops.c
307,7 → 307,7
}
 
size_t bytes = max(0, min(dentry->size - pos, len));
(void) ipc_data_read_deliver(callid, dentry->data + pos, bytes);
(void) ipc_data_read_finalize(callid, dentry->data + pos, bytes);
 
/*
* Answer the VFS_READ call.
349,7 → 349,7
*/
if (pos + len <= dentry->size) {
/* The file size is not changing. */
(void) ipc_data_write_deliver(callid, dentry->data + pos, len);
(void) ipc_data_write_finalize(callid, dentry->data + pos, len);
ipc_answer_1(rid, EOK, len);
return;
}
369,7 → 369,7
}
dentry->size += delta;
dentry->data = newdata;
(void) ipc_data_write_deliver(callid, dentry->data + pos, len);
(void) ipc_data_write_finalize(callid, dentry->data + pos, len);
ipc_answer_1(rid, EOK, len);
}
 
/trunk/uspace/srv/devmap/devmap.c
233,7 → 233,7
/*
* Send confirmation to sender and get data into buffer.
*/
if (EOK != ipc_data_write_deliver(callid, driver->name, name_size)) {
if (EOK != ipc_data_write_finalize(callid, driver->name, name_size)) {
printf("Cannot read driver name.\n");
free(driver->name);
free(driver);
394,7 → 394,7
return;
}
ipc_data_write_deliver(callid, device->name, size);
ipc_data_write_finalize(callid, device->name, size);
device->name[size] = 0;
 
list_initialize(&(device->devices));
513,7 → 513,8
/*
* Send confirmation to sender and get data into buffer.
*/
if (EOK != (retval = ipc_data_write_deliver(callid, name, name_size))) {
if (EOK != (retval = ipc_data_write_finalize(callid, name,
name_size))) {
ipc_answer_0(iid, EREFUSED);
return;
}
/trunk/uspace/srv/vfs/vfs_open.c
82,7 → 82,7
}
 
int rc;
if ((rc = ipc_data_write_deliver(callid, path, size))) {
if ((rc = ipc_data_write_finalize(callid, path, size))) {
ipc_answer_0(rid, rc);
free(path);
return;
/trunk/uspace/srv/vfs/vfs_mount.c
106,7 → 106,7
* Deliver the file system name.
*/
char fs_name[FS_NAME_MAXLEN + 1];
(void) ipc_data_write_deliver(callid, fs_name, size);
(void) ipc_data_write_finalize(callid, fs_name, size);
fs_name[size] = '\0';
/*
150,7 → 150,7
/*
* Deliver the mount point.
*/
(void) ipc_data_write_deliver(callid, buf, size);
(void) ipc_data_write_finalize(callid, buf, size);
 
/*
* Lookup the root node of the filesystem being mounted.
/trunk/uspace/srv/vfs/vfs_register.c
205,7 → 205,7
link_initialize(&fs_info->fs_link);
futex_initialize(&fs_info->phone_futex, 1);
rc = ipc_data_write_deliver(callid, &fs_info->vfs_info, size);
rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
if (rc != EOK) {
dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
rc);
299,7 → 299,7
/*
* Commit to read-only sharing the PLB with the client.
*/
(void) ipc_share_in_deliver(callid, plb,
(void) ipc_share_in_finalize(callid, plb,
AS_AREA_READ | AS_AREA_CACHEABLE);
 
dprintf("Sharing PLB.\n");