Changeset 0da4e41 in mainline for uspace/lib/libc/generic


Ignore:
Timestamp:
2009-10-11T16:11:22Z (16 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ba8f8cb
Parents:
bbb01b98
Message:

ipc_data_*() and ipc_share_*(), respectively, should be renamed to
async_data_*() and async_share_*(), respectively, because these functions are
using the async framework.

Location:
uspace/lib/libc/generic
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/libc/generic/async.c

    rbbb01b98 r0da4e41  
    10871087}
    10881088
     1089/** Wrapper for making IPC_M_SHARE_IN calls using the async framework.
     1090 *
     1091 * @param phoneid       Phone that will be used to contact the receiving side.
     1092 * @param dst           Destination address space area base.
     1093 * @param size          Size of the destination address space area.
     1094 * @param arg           User defined argument.
     1095 * @param flags         Storage where the received flags will be stored. Can be
     1096 *                      NULL.
     1097 *
     1098 * @return              Zero on success or a negative error code from errno.h.
     1099 */
     1100int async_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
     1101    int *flags)
     1102{
     1103        int res;
     1104        sysarg_t tmp_flags;
     1105        res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
     1106            (ipcarg_t) size, arg, NULL, &tmp_flags);
     1107        if (flags)
     1108                *flags = tmp_flags;
     1109        return res;
     1110}
     1111
     1112/** Wrapper for receiving the IPC_M_SHARE_IN calls using the async framework.
     1113 *
     1114 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls
     1115 * so that the user doesn't have to remember the meaning of each IPC argument.
     1116 *
     1117 * So far, this wrapper is to be used from within a connection fibril.
     1118 *
     1119 * @param callid        Storage where the hash of the IPC_M_SHARE_IN call will
     1120 *                      be stored.
     1121 * @param size          Destination address space area size.   
     1122 *
     1123 * @return              Non-zero on success, zero on failure.
     1124 */
     1125int async_share_in_receive(ipc_callid_t *callid, size_t *size)
     1126{
     1127        ipc_call_t data;
     1128       
     1129        assert(callid);
     1130        assert(size);
     1131
     1132        *callid = async_get_call(&data);
     1133        if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN)
     1134                return 0;
     1135        *size = (size_t) IPC_GET_ARG2(data);
     1136        return 1;
     1137}
     1138
     1139/** Wrapper for answering the IPC_M_SHARE_IN calls using the async framework.
     1140 *
     1141 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
     1142 * so that the user doesn't have to remember the meaning of each IPC argument.
     1143 *
     1144 * @param callid        Hash of the IPC_M_DATA_READ call to answer.
     1145 * @param src           Source address space base.
     1146 * @param flags         Flags to be used for sharing. Bits can be only cleared.
     1147 *
     1148 * @return              Zero on success or a value from @ref errno.h on failure.
     1149 */
     1150int async_share_in_finalize(ipc_callid_t callid, void *src, int flags)
     1151{
     1152        return ipc_share_in_finalize(callid, src, flags);
     1153}
     1154
     1155/** Wrapper for making IPC_M_SHARE_OUT calls using the async framework.
     1156 *
     1157 * @param phoneid       Phone that will be used to contact the receiving side.
     1158 * @param src           Source address space area base address.
     1159 * @param flags         Flags to be used for sharing. Bits can be only cleared.
     1160 *
     1161 * @return              Zero on success or a negative error code from errno.h.
     1162 */
     1163int async_share_out_start(int phoneid, void *src, int flags)
     1164{
     1165        return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
     1166            (ipcarg_t) flags);
     1167}
     1168
     1169/** Wrapper for receiving the IPC_M_SHARE_OUT calls using the async framework.
     1170 *
     1171 * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls
     1172 * so that the user doesn't have to remember the meaning of each IPC argument.
     1173 *
     1174 * So far, this wrapper is to be used from within a connection fibril.
     1175 *
     1176 * @param callid        Storage where the hash of the IPC_M_SHARE_OUT call will
     1177 *                      be stored.
     1178 * @param size          Storage where the source address space area size will be
     1179 *                      stored.
     1180 * @param flags         Storage where the sharing flags will be stored.
     1181 *
     1182 * @return              Non-zero on success, zero on failure.
     1183 */
     1184int async_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags)
     1185{
     1186        ipc_call_t data;
     1187       
     1188        assert(callid);
     1189        assert(size);
     1190        assert(flags);
     1191
     1192        *callid = async_get_call(&data);
     1193        if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
     1194                return 0;
     1195        *size = (size_t) IPC_GET_ARG2(data);
     1196        *flags = (int) IPC_GET_ARG3(data);
     1197        return 1;
     1198}
     1199
     1200/** Wrapper for answering the IPC_M_SHARE_OUT calls using the async framework.
     1201 *
     1202 * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls
     1203 * so that the user doesn't have to remember the meaning of each IPC argument.
     1204 *
     1205 * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
     1206 * @param dst           Destination address space area base address.   
     1207 *
     1208 * @return              Zero on success or a value from @ref errno.h on failure.
     1209 */
     1210int async_share_out_finalize(ipc_callid_t callid, void *dst)
     1211{
     1212        return ipc_share_out_finalize(callid, dst);
     1213}
     1214
     1215
     1216/** Wrapper for making IPC_M_DATA_READ calls using the async framework.
     1217 *
     1218 * @param phoneid       Phone that will be used to contact the receiving side.
     1219 * @param dst           Address of the beginning of the destination buffer.
     1220 * @param size          Size of the destination buffer.
     1221 *
     1222 * @return              Zero on success or a negative error code from errno.h.
     1223 */
     1224int async_data_read_start(int phoneid, void *dst, size_t size)
     1225{
     1226        return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
     1227            (ipcarg_t) size);
     1228}
     1229
     1230/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
     1231 *
     1232 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls
     1233 * so that the user doesn't have to remember the meaning of each IPC argument.
     1234 *
     1235 * So far, this wrapper is to be used from within a connection fibril.
     1236 *
     1237 * @param callid        Storage where the hash of the IPC_M_DATA_READ call will
     1238 *                      be stored.
     1239 * @param size          Storage where the maximum size will be stored. Can be
     1240 *                      NULL.
     1241 *
     1242 * @return              Non-zero on success, zero on failure.
     1243 */
     1244int async_data_read_receive(ipc_callid_t *callid, size_t *size)
     1245{
     1246        ipc_call_t data;
     1247       
     1248        assert(callid);
     1249
     1250        *callid = async_get_call(&data);
     1251        if (IPC_GET_METHOD(data) != IPC_M_DATA_READ)
     1252                return 0;
     1253        if (size)
     1254                *size = (size_t) IPC_GET_ARG2(data);
     1255        return 1;
     1256}
     1257
     1258/** Wrapper for answering the IPC_M_DATA_READ calls using the async framework.
     1259 *
     1260 * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
     1261 * so that the user doesn't have to remember the meaning of each IPC argument.
     1262 *
     1263 * @param callid        Hash of the IPC_M_DATA_READ call to answer.
     1264 * @param src           Source address for the IPC_M_DATA_READ call.
     1265 * @param size          Size for the IPC_M_DATA_READ call. Can be smaller than
     1266 *                      the maximum size announced by the sender.
     1267 *
     1268 * @return              Zero on success or a value from @ref errno.h on failure.
     1269 */
     1270int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
     1271{
     1272        return ipc_data_read_finalize(callid, src, size);
     1273}
     1274
     1275/** Wrapper for making IPC_M_DATA_WRITE calls using the async framework.
     1276 *
     1277 * @param phoneid       Phone that will be used to contact the receiving side.
     1278 * @param src           Address of the beginning of the source buffer.
     1279 * @param size          Size of the source buffer.
     1280 *
     1281 * @return              Zero on success or a negative error code from errno.h.
     1282 */
     1283int async_data_write_start(int phoneid, const void *src, size_t size)
     1284{
     1285        return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
     1286            (ipcarg_t) size);
     1287}
     1288
     1289/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
     1290 *
     1291 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls
     1292 * so that the user doesn't have to remember the meaning of each IPC argument.
     1293 *
     1294 * So far, this wrapper is to be used from within a connection fibril.
     1295 *
     1296 * @param callid        Storage where the hash of the IPC_M_DATA_WRITE call will
     1297 *                      be stored.
     1298 * @param size          Storage where the suggested size will be stored. May be
     1299 *                      NULL
     1300 *
     1301 * @return              Non-zero on success, zero on failure.
     1302 */
     1303int async_data_write_receive(ipc_callid_t *callid, size_t *size)
     1304{
     1305        ipc_call_t data;
     1306       
     1307        assert(callid);
     1308
     1309        *callid = async_get_call(&data);
     1310        if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
     1311                return 0;
     1312        if (size)
     1313                *size = (size_t) IPC_GET_ARG2(data);
     1314        return 1;
     1315}
     1316
     1317/** Wrapper for answering the IPC_M_DATA_WRITE calls using the async framework.
     1318 *
     1319 * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls
     1320 * so that the user doesn't have to remember the meaning of each IPC argument.
     1321 *
     1322 * @param callid        Hash of the IPC_M_DATA_WRITE call to answer.
     1323 * @param dst           Final destination address for the IPC_M_DATA_WRITE call.
     1324 * @param size          Final size for the IPC_M_DATA_WRITE call.
     1325 *
     1326 * @return              Zero on success or a value from @ref errno.h on failure.
     1327 */
     1328int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
     1329{
     1330        return ipc_data_write_finalize(callid, dst, size);
     1331}
     1332
    10891333/** @}
    10901334 */

  • uspace/lib/libc/generic/devmap.c

    rbbb01b98 r0da4e41  
    105105        aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
    106106       
    107         ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
     107        ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
    108108       
    109109        if (retval != EOK) {
    … …  
    143143            &answer);
    144144       
    145         ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
     145        ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
    146146       
    147147        if (retval != EOK) {
    … …  
    180180            &answer);
    181181       
    182         ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
     182        ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
    183183       
    184184        if (retval != EOK) {
    … …  
    271271        aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer);
    272272       
    273         ipcarg_t retval = ipc_data_read_start(phone, data, count * sizeof(dev_desc_t));
     273        ipcarg_t retval = async_data_read_start(phone, data, count * sizeof(dev_desc_t));
    274274       
    275275        if (retval != EOK) {

  • uspace/lib/libc/generic/loader.c

    rbbb01b98 r0da4e41  
    9090        ipc_call_t answer;
    9191        aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
    92         int rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
     92        int rc = async_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
    9393        if (rc != EOK) {
    9494                async_wait_for(req, NULL);
    … …  
    123123        ipc_call_t answer;
    124124        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
    125         int rc = ipc_data_write_start(ldr->phone_id, (void *) pa, pa_len);
     125        int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len);
    126126        if (rc != EOK) {
    127127                async_wait_for(req, NULL);
    … …  
    178178        ipc_call_t answer;
    179179        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
    180         ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
     180        ipcarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
    181181        if (rc != EOK) {
    182182                async_wait_for(req, NULL);
    … …  
    232232        ipc_call_t answer;
    233233        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer);
    234         ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) files_buf,
     234        ipcarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf,
    235235            count * sizeof(fdi_node_t));
    236236        if (rc != EOK) {

  • uspace/lib/libc/generic/vfs/vfs.c

    rbbb01b98 r0da4e41  
    140140       
    141141        req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
    142         rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
     142        rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
    143143        if (rc != EOK) {
    144144                async_wait_for(req, &rc_orig);
    … …  
    152152        }
    153153       
    154         rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
     154        rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
    155155        if (rc != EOK) {
    156156                async_wait_for(req, &rc_orig);
    … …  
    164164        }
    165165
    166         rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
     166        rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
    167167        if (rc != EOK) {
    168168                async_wait_for(req, &rc_orig);
    … …  
    213213       
    214214        req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
    215         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
     215        rc = async_data_write_start(vfs_phone, pa, pa_size);
    216216        if (rc != EOK) {
    217217                ipcarg_t rc_orig;
    … …  
    290290       
    291291        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    292         rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
     292        rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
    293293        if (rc != EOK) {
    294294                ipcarg_t rc_orig;
    … …  
    322322       
    323323        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    324         rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
     324        rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
    325325        if (rc != EOK) {
    326326                ipcarg_t rc_orig;
    … …  
    402402       
    403403        req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
    404         rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
     404        rc = async_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
    405405        if (rc != EOK) {
    406406                ipcarg_t rc_orig;
    … …  
    437437       
    438438        req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
    439         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
     439        rc = async_data_write_start(vfs_phone, pa, pa_size);
    440440        if (rc != EOK) {
    441441                async_wait_for(req, &rc_orig);
    … …  
    448448                        return (int) rc_orig;
    449449        }
    450         rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
     450        rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
    451451        if (rc != EOK) {
    452452                async_wait_for(req, &rc_orig);
    … …  
    514514       
    515515        req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
    516         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
     516        rc = async_data_write_start(vfs_phone, pa, pa_size);
    517517        if (rc != EOK) {
    518518                ipcarg_t rc_orig;
    … …  
    549549       
    550550        req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
    551         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
     551        rc = async_data_write_start(vfs_phone, pa, pa_size);
    552552        if (rc != EOK) {
    553553                ipcarg_t rc_orig;
    … …  
    602602       
    603603        req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
    604         rc = ipc_data_write_start(vfs_phone, olda, olda_size);
     604        rc = async_data_write_start(vfs_phone, olda, olda_size);
    605605        if (rc != EOK) {
    606606                async_wait_for(req, &rc_orig);
    … …  
    614614                        return (int) rc_orig;
    615615        }
    616         rc = ipc_data_write_start(vfs_phone, newa, newa_size);
     616        rc = async_data_write_start(vfs_phone, newa, newa_size);
    617617        if (rc != EOK) {
    618618                async_wait_for(req, &rc_orig);
Note: See TracChangeset for help on using the changeset viewer.