Changeset ffa2c8ef in mainline for uspace/app


Ignore:
Timestamp:
2011-01-29T11:36:08Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
46b881c
Parents:
64d2b10
Message:

do not intermix low-level IPC methods with async framework methods

Location:
uspace/app
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/init/init.c

    r64d2b10 rffa2c8ef  
    3737#include <stdio.h>
    3838#include <unistd.h>
    39 #include <ipc/ipc.h>
    4039#include <vfs/vfs.h>
    4140#include <bool.h>

  • uspace/app/klog/klog.c

    r64d2b10 rffa2c8ef  
    3636
    3737#include <stdio.h>
    38 #include <ipc/ipc.h>
    3938#include <ipc/ns.h>
    4039#include <async.h>

  • uspace/app/ping/ping.c

    r64d2b10 rffa2c8ef  
    3535 */
    3636
     37#include <async.h>
    3738#include <stdio.h>
    3839#include <str.h>
    3940#include <task.h>
    4041#include <time.h>
    41 #include <ipc/ipc.h>
    4242#include <ipc/services.h>
    4343#include <str_error.h>
    … …  
    355355                            str_error(ret));
    356356                       
    357                         ipc_hangup(icmp_phone);
     357                        async_hangup(icmp_phone);
    358358                        return ret;
    359359                }
    … …  
    370370                            str_error(ret));
    371371                       
    372                         ipc_hangup(icmp_phone);
     372                        async_hangup(icmp_phone);
    373373                        return ret;
    374374                }
    … …  
    390390        }
    391391       
    392         ipc_hangup(icmp_phone);
     392        async_hangup(icmp_phone);
    393393       
    394394        return 0;

  • uspace/app/taskdump/taskdump.c

    r64d2b10 rffa2c8ef  
    3333 */
    3434
     35#include <async.h>
    3536#include <stdio.h>
    3637#include <stdlib.h>
    3738#include <unistd.h>
    38 #include <ipc/ipc.h>
    3939#include <errno.h>
    4040#include <udebug.h>
    … …  
    105105
    106106        udebug_end(phoneid);
    107         ipc_hangup(phoneid);
     107        async_hangup(phoneid);
    108108
    109109        return 0;
    … …  
    114114        int rc;
    115115
    116         rc = ipc_connect_kbox(task_id);
     116        rc = async_connect_kbox(task_id);
    117117
    118118        if (rc == ENOTSUP) {
    … …  
    126126        if (rc < 0) {
    127127                printf("Error connecting\n");
    128                 printf("ipc_connect_task(%" PRIu64 ") -> %d ", task_id, rc);
     128                printf("async_connect_kbox(%" PRIu64 ") -> %d ", task_id, rc);
    129129                return rc;
    130130        }

  • uspace/app/tester/hw/misc/virtchar1.c

    r64d2b10 rffa2c8ef  
    8989        /* Clean-up. */
    9090        TPRINTF(" Closing phones and file descriptors\n");
    91         ipc_hangup(phone);
     91        async_hangup(phone);
    9292        close(fd);
    9393       

  • uspace/app/tester/hw/serial/serial1.c

    r64d2b10 rffa2c8ef  
    3939#include <stdlib.h>
    4040#include <stdio.h>
    41 #include <ipc/ipc.h>
    4241#include <sys/types.h>
    4342#include <async.h>
    … …  
    8887        char *buf = (char *) malloc(cnt + 1);
    8988        if (buf == NULL) {
    90                 ipc_hangup(phone);
     89                async_hangup(phone);
    9190                devman_hangup_phone(DEVMAN_CLIENT);
    9291                return "Failed to allocate input buffer";
    … …  
    9897        sysarg_t old_word_size;
    9998       
    100         res = ipc_call_sync_0_4(phone, SERIAL_GET_COM_PROPS, &old_baud,
     99        res = async_req_0_4(phone, SERIAL_GET_COM_PROPS, &old_baud,
    101100            &old_par, &old_word_size, &old_stop);
    102101        if (res != EOK) {
    103102                free(buf);
    104                 ipc_hangup(phone);
     103                async_hangup(phone);
    105104                devman_hangup_phone(DEVMAN_CLIENT);
    106105                return "Failed to get old serial communication parameters";
    107106        }
    108107       
    109         res = ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, 1200,
     108        res = async_req_4_0(phone, SERIAL_SET_COM_PROPS, 1200,
    110109            SERIAL_NO_PARITY, 8, 1);
    111110        if (EOK != res) {
    112111                free(buf);
    113                 ipc_hangup(phone);
     112                async_hangup(phone);
    114113                devman_hangup_phone(DEVMAN_CLIENT);
    115114                return "Failed to set serial communication parameters";
    … …  
    124123               
    125124                if (read < 0) {
    126                         ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     125                        async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
    127126                            old_par, old_word_size, old_stop);
    128127                        free(buf);
    129                         ipc_hangup(phone);
     128                        async_hangup(phone);
    130129                        devman_hangup_phone(DEVMAN_CLIENT);
    131130                        return "Failed read from serial device";
    … …  
    133132               
    134133                if ((size_t) read > cnt - total) {
    135                         ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     134                        async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
    136135                            old_par, old_word_size, old_stop);
    137136                        free(buf);
    138                         ipc_hangup(phone);
     137                        async_hangup(phone);
    139138                        devman_hangup_phone(DEVMAN_CLIENT);
    140139                        return "Read more data than expected";
    … …  
    155154                       
    156155                        if (written < 0) {
    157                                 ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     156                                async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
    158157                                    old_par, old_word_size, old_stop);
    159158                                free(buf);
    160                                 ipc_hangup(phone);
     159                                async_hangup(phone);
    161160                                devman_hangup_phone(DEVMAN_CLIENT);
    162161                                return "Failed write to serial device";
    … …  
    164163                       
    165164                        if (written != read) {
    166                                 ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     165                                async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
    167166                                    old_par, old_word_size, old_stop);
    168167                                free(buf);
    169                                 ipc_hangup(phone);
     168                                async_hangup(phone);
    170169                                devman_hangup_phone(DEVMAN_CLIENT);
    171170                                return "Written less data than read from serial device";
    … …  
    183182        ssize_t written = char_dev_write(phone, (void *) EOT, eot_size);
    184183       
    185         ipc_call_sync_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
     184        async_req_4_0(phone, SERIAL_SET_COM_PROPS, old_baud,
    186185            old_par, old_word_size, old_stop);
    187186        free(buf);
    188         ipc_hangup(phone);
     187        async_hangup(phone);
    189188        devman_hangup_phone(DEVMAN_CLIENT);
    190189       

  • uspace/app/tester/tester.h

    r64d2b10 rffa2c8ef  
    3838#include <sys/types.h>
    3939#include <bool.h>
    40 #include <ipc/ipc.h>
    4140
    4241#define IPC_TEST_SERVICE  10240

  • uspace/app/tetris/screen.h

    r64d2b10 rffa2c8ef  
    4848
    4949#include <sys/types.h>
    50 #include <ipc/ipc.h>
    5150#include <async.h>
    5251#include <bool.h>

  • uspace/app/top/screen.c

    r64d2b10 rffa2c8ef  
    3737
    3838#include <stdio.h>
    39 #include <ipc/ipc.h>
    4039#include <io/console.h>
    4140#include <io/style.h>

  • uspace/app/trace/ipc_desc.c

    r64d2b10 rffa2c8ef  
    3333 */
    3434
     35#include <ipc/common.h>
    3536#include <stdlib.h>
    36 #include <ipc/ipc.h>
    3737#include "ipc_desc.h"
    3838

  • uspace/app/trace/ipcp.h

    r64d2b10 rffa2c8ef  
    3636#define IPCP_H_
    3737
    38 #include <ipc/ipc.h>
    3938#include "proto.h"
    4039

  • uspace/app/trace/proto.c

    r64d2b10 rffa2c8ef  
    3535#include <stdio.h>
    3636#include <stdlib.h>
    37 #include <ipc/ipc.h>
    3837#include <adt/hash_table.h>
    3938

  • uspace/app/trace/proto.h

    r64d2b10 rffa2c8ef  
    3636#define PROTO_H_
    3737
     38#include <ipc/common.h>
    3839#include <adt/hash_table.h>
    39 #include <ipc/ipc.h>
    4040#include "trace.h"
    4141

  • uspace/app/trace/trace.c

    r64d2b10 rffa2c8ef  
    3636#include <stdlib.h>
    3737#include <unistd.h>
    38 #include <ipc/ipc.h>
    3938#include <fibril.h>
    4039#include <errno.h>
    … …  
    149148        int rc;
    150149
    151         rc = ipc_connect_kbox(task_id);
     150        rc = async_connect_kbox(task_id);
    152151
    153152        if (rc == ENOTSUP) {
    … …  
    745744        abort_trace = true;
    746745        udebug_end(phoneid);
    747         ipc_hangup(phoneid);
     746        async_hangup(phoneid);
    748747
    749748        ipcp_cleanup();
Note: See TracChangeset for help on using the changeset viewer.