Changeset 79ae36dd in mainline for uspace/lib/net


Ignore:
Timestamp:
2011-06-08T19:01:55Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0eff68e
Parents:
764d71e
Message:

new async framework with integrated exchange tracking

  • strict isolation between low-level IPC and high-level async framework with integrated exchange tracking
    • each IPC connection is represented by an async_sess_t structure
    • each IPC exchange is represented by an async_exch_t structure
    • exchange management is either based on atomic messages (EXCHANGE_ATOMIC), locking (EXCHANGE_SERIALIZE) or connection cloning (EXCHANGE_CLONE)
  • async_obsolete: temporary compatibility layer to keep old async clients working (several pieces of code are currently broken, but only non-essential functionality)
  • IPC_M_PHONE_HANGUP is now method no. 0 (for elegant boolean evaluation)
  • IPC_M_DEBUG_ALL has been renamed to IPC_M_DEBUG
  • IPC_M_PING has been removed (VFS protocol now has VFS_IN_PING)
  • console routines in libc have been rewritten for better abstraction
  • additional use for libc-private header files (FILE structure opaque to the client)
  • various cstyle changes (typos, indentation, missing externs in header files, improved comments, etc.)
Location:
uspace/lib/net
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/net/generic/generic.c

    r764d71e r79ae36dd  
    3737#include <generic.h>
    3838#include <async.h>
     39#include <async_obsolete.h>
    3940#include <ipc/services.h>
    4041#include <net/device.h>
    … …  
    5657    int state, services_t target)
    5758{
    58         async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     59        async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    5960            (sysarg_t) state, target);
    6061       
    … …  
    7879    int arg2, services_t service)
    7980{
    80         return (int) async_req_3_0(phone, (sysarg_t) message,
     81        return (int) async_obsolete_req_3_0(phone, (sysarg_t) message,
    8182            (sysarg_t) device_id, (sysarg_t) arg2, (sysarg_t) service);
    8283}
    … …  
    107108
    108109        /* Request the address */
    109         message_id = async_send_1(phone, (sysarg_t) message,
     110        message_id = async_obsolete_send_1(phone, (sysarg_t) message,
    110111            (sysarg_t) device_id, NULL);
    111112        string = measured_strings_return(phone, address, data, 1);
    … …  
    145146        sysarg_t suffix;
    146147       
    147         sysarg_t result = async_req_1_4(phone, (sysarg_t) message,
     148        sysarg_t result = async_obsolete_req_1_4(phone, (sysarg_t) message,
    148149            (sysarg_t) device_id, &addr_len, &prefix, &content, &suffix);
    149150       
    … …  
    172173{
    173174        if (error) {
    174                 async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     175                async_obsolete_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
    175176                    (sysarg_t) packet_id, (sysarg_t) target, (sysarg_t) error);
    176177        } else {
    177                 async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     178                async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    178179                    (sysarg_t) packet_id, (sysarg_t) target);
    179180        }
    … …  
    198199{
    199200        if (error) {
    200                 async_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
     201                async_obsolete_msg_4(phone, (sysarg_t) message, (sysarg_t) device_id,
    201202                    (sysarg_t) packet_id, (sysarg_t) sender, (sysarg_t) error);
    202203        } else {
    203                 async_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
     204                async_obsolete_msg_3(phone, (sysarg_t) message, (sysarg_t) device_id,
    204205                    (sysarg_t) packet_id, (sysarg_t) sender);
    205206        }
    … …  
    243244
    244245        /* Request the translation */
    245         message_id = async_send_3(phone, (sysarg_t) message,
     246        message_id = async_obsolete_send_3(phone, (sysarg_t) message,
    246247            (sysarg_t) device_id, (sysarg_t) count, (sysarg_t) service, NULL);
    247248        measured_strings_send(phone, configuration, count);

  • uspace/lib/net/generic/packet_remote.c

    r764d71e r79ae36dd  
    3737
    3838#include <async.h>
     39#include <async_obsolete.h>
    3940#include <errno.h>
    4041#include <ipc/packet.h>
    … …  
    5960 * @return EOK on success.
    6061 * @return Other error codes as defined for the pm_add() function.
    61  * @return Other error codes as defined for the async_share_in_start() function.
     62 * @return Other error codes as defined for the async_obsolete_share_in_start() function.
    6263 *
    6364 */
    … …  
    6970        int rc;
    7071       
    71         message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
     72        message = async_obsolete_send_1(phone, NET_PACKET_GET, packet_id, &answer);
    7273
    7374        *packet = (packet_t *) as_get_mappable_page(size);
    74         rc = async_share_in_start_0_0(phone, *packet, size);
     75        rc = async_obsolete_share_in_start_0_0(phone, *packet, size);
    7576        if (rc != EOK) {
    7677                munmap(*packet, size);
    … …  
    117118                sysarg_t size;
    118119               
    119                 rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
     120                rc = async_obsolete_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
    120121                    &size);
    121122                if (rc != EOK)
    … …  
    154155        int rc;
    155156       
    156         rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
     157        rc = async_obsolete_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
    157158            max_prefix, max_suffix, &packet_id, &size);
    158159        if (rc != EOK)
    … …  
    185186        int rc;
    186187       
    187         rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
     188        rc = async_obsolete_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
    188189            &size);
    189190        if (rc != EOK)
    … …  
    212213void pq_release_remote(int phone, packet_id_t packet_id)
    213214{
    214         async_msg_1(phone, NET_PACKET_RELEASE, packet_id);
     215        async_obsolete_msg_1(phone, NET_PACKET_RELEASE, packet_id);
    215216}
    216217

  • uspace/lib/net/il/arp_remote.c

    r764d71e r79ae36dd  
    4040
    4141#include <async.h>
     42#include <async_obsolete.h>
    4243#include <errno.h>
    4344#include <ipc/services.h>
    … …  
    6869int arp_clean_cache_req(int arp_phone)
    6970{
    70         return (int) async_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
     71        return (int) async_obsolete_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
    7172}
    7273
    … …  
    8788        sysarg_t result;
    8889
    89         message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
     90        message_id = async_obsolete_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
    9091            (sysarg_t) device_id, protocol, NULL);
    9192        measured_strings_send(arp_phone, address, 1);
    … …  
    104105int arp_clear_device_req(int arp_phone, device_id_t device_id)
    105106{
    106         return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
     107        return (int) async_obsolete_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
    107108            (sysarg_t) device_id);
    108109}
    … …  
    137138        sysarg_t result;
    138139
    139         message_id = async_send_3(arp_phone, NET_ARP_DEVICE,
     140        message_id = async_obsolete_send_3(arp_phone, NET_ARP_DEVICE,
    140141            (sysarg_t) device_id, protocol, netif, NULL);
    141142        measured_strings_send(arp_phone, address, 1);

  • uspace/lib/net/il/il_skel.c

    r764d71e r79ae36dd  
    4242#include <net/modules.h>
    4343
     44// FIXME: remove this header
     45#include <kernel/ipc/ipc_methods.h>
     46
    4447/** Default thread for new connections.
    4548 *
    … …  
    7578                 * result.
    7679                 */
    77                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    78                     (res == EHANGUP))
     80                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    7981                        return;
    8082               

  • uspace/lib/net/il/ip_remote.c

    r764d71e r79ae36dd  
    4444#include <packet_client.h>
    4545#include <generic.h>
    46 
     46#include <async_obsolete.h>
    4747#include <ipc/services.h>
    4848#include <ipc/il.h>
    … …  
    6666    in_addr_t address, in_addr_t netmask, in_addr_t gateway)
    6767{
    68         return (int) async_req_4_0(ip_phone, NET_IP_ADD_ROUTE,
     68        return (int) async_obsolete_req_4_0(ip_phone, NET_IP_ADD_ROUTE,
    6969            (sysarg_t) device_id, (sysarg_t) gateway.s_addr,
    7070            (sysarg_t) address.s_addr, (sysarg_t) netmask.s_addr);
    … …  
    150150       
    151151        ipc_call_t answer;
    152         aid_t message_id = async_send_1(ip_phone, NET_IP_GET_ROUTE,
     152        aid_t message_id = async_obsolete_send_1(ip_phone, NET_IP_GET_ROUTE,
    153153            (sysarg_t) protocol, &answer);
    154154       
    155         if ((async_data_write_start(ip_phone, destination, addrlen) == EOK) &&
    156             (async_data_read_start(ip_phone, headerlen,
     155        if ((async_obsolete_data_write_start(ip_phone, destination, addrlen) == EOK) &&
     156            (async_obsolete_data_read_start(ip_phone, headerlen,
    157157            sizeof(*headerlen)) == EOK) && (*headerlen > 0)) {
    158158                *header = malloc(*headerlen);
    159159                if (*header) {
    160                         if (async_data_read_start(ip_phone, *header,
     160                        if (async_obsolete_data_read_start(ip_phone, *header,
    161161                            *headerlen) != EOK)
    162162                                free(*header);
    … …  
    243243    in_addr_t gateway)
    244244{
    245         return (int) async_req_2_0(ip_phone, NET_IP_SET_GATEWAY,
     245        return (int) async_obsolete_req_2_0(ip_phone, NET_IP_SET_GATEWAY,
    246246            (sysarg_t) device_id, (sysarg_t) gateway.s_addr);
    247247}

  • uspace/lib/net/netif/netif_remote.c

    r764d71e r79ae36dd  
    3838#include <packet_client.h>
    3939#include <generic.h>
    40 
     40#include <async_obsolete.h>
    4141#include <ipc/services.h>
    4242#include <ipc/netif.h>
    … …  
    8282int netif_probe_req(int netif_phone, device_id_t device_id, int irq, void *io)
    8383{
    84         return async_req_3_0(netif_phone, NET_NETIF_PROBE, device_id, irq,
     84        return async_obsolete_req_3_0(netif_phone, NET_NETIF_PROBE, device_id, irq,
    8585            (sysarg_t) io);
    8686}
    … …  
    119119int netif_start_req(int netif_phone, device_id_t device_id)
    120120{
    121         return async_req_1_0(netif_phone, NET_NETIF_START, device_id);
     121        return async_obsolete_req_1_0(netif_phone, NET_NETIF_START, device_id);
    122122}
    123123
    … …  
    136136int netif_stop_req(int netif_phone, device_id_t device_id)
    137137{
    138         return async_req_1_0(netif_phone, NET_NETIF_STOP, device_id);
     138        return async_obsolete_req_1_0(netif_phone, NET_NETIF_STOP, device_id);
    139139}
    140140
    … …  
    154154                return EBADMEM;
    155155       
    156         aid_t message_id = async_send_1(netif_phone, NET_NETIF_STATS,
     156        aid_t message_id = async_obsolete_send_1(netif_phone, NET_NETIF_STATS,
    157157            (sysarg_t) device_id, NULL);
    158         async_data_read_start(netif_phone, stats, sizeof(*stats));
     158        async_obsolete_data_read_start(netif_phone, stats, sizeof(*stats));
    159159       
    160160        sysarg_t result;

  • uspace/lib/net/netif/netif_skel.c

    r764d71e r79ae36dd  
    5454#include <nil_remote.h>
    5555
     56// FIXME: remove this header
     57#include <kernel/ipc/ipc_methods.h>
     58
    5659DEVICE_MAP_IMPLEMENT(netif_device_map, netif_device_t);
    5760
    … …  
    288291        *count = 0;
    289292       
     293        if (!IPC_GET_IMETHOD(*call))
     294                return EOK;
     295       
    290296        switch (IPC_GET_IMETHOD(*call)) {
    291         case IPC_M_PHONE_HUNGUP:
    292                 return EOK;
    293        
    294297        case NET_NETIF_PROBE:
    295298                return netif_probe_req_local(0, IPC_GET_DEVICE(*call),
    … …  
    385388               
    386389                /* End if said to either by the message or the processing result */
    387                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    388                     (res == EHANGUP))
     390                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    389391                        return;
    390392               

  • uspace/lib/net/nil/nil_skel.c

    r764d71e r79ae36dd  
    4242#include <net/modules.h>
    4343
     44// FIXME: remove this header
     45#include <kernel/ipc/ipc_methods.h>
     46
    4447/** Default thread for new connections.
    4548 *
    … …  
    7578                 * result.
    7679                 */
    77                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    78                     (res == EHANGUP))
     80                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    7981                        return;
    8082               

  • uspace/lib/net/tl/icmp_remote.c

    r764d71e r79ae36dd  
    4141
    4242#include <async.h>
     43#include <async_obsolete.h>
    4344#include <errno.h>
    4445#include <ipc/services.h>
    … …  
    6465    icmp_param_t mtu, packet_t *packet)
    6566{
    66         async_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code,
     67        async_obsolete_msg_3(icmp_phone, NET_ICMP_DEST_UNREACH, (sysarg_t) code,
    6768            (sysarg_t) packet_get_id(packet), (sysarg_t) mtu);
    6869        return EOK;
    … …  
    8384int icmp_source_quench_msg(int icmp_phone, packet_t *packet)
    8485{
    85         async_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0,
     86        async_obsolete_msg_2(icmp_phone, NET_ICMP_SOURCE_QUENCH, 0,
    8687            (sysarg_t) packet_get_id(packet));
    8788        return EOK;
    … …  
    103104int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t *packet)
    104105{
    105         async_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code,
     106        async_obsolete_msg_2(icmp_phone, NET_ICMP_TIME_EXCEEDED, (sysarg_t) code,
    106107            (sysarg_t) packet_get_id(packet));
    107108        return EOK;
    … …  
    125126    icmp_param_t pointer, packet_t *packet)
    126127{
    127         async_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code,
     128        async_obsolete_msg_3(icmp_phone, NET_ICMP_PARAMETERPROB, (sysarg_t) code,
    128129            (sysarg_t) packet_get_id(packet), (sysarg_t) pointer);
    129130        return EOK;

  • uspace/lib/net/tl/tl_skel.c

    r764d71e r79ae36dd  
    4242#include <net/modules.h>
    4343
     44// FIXME: remove this header
     45#include <kernel/ipc/ipc_methods.h>
     46
    4447/** Default thread for new connections.
    4548 *
    … …  
    7780                 * result.
    7881                 */
    79                 if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    80                     (res == EHANGUP))
     82                if ((!IPC_GET_IMETHOD(call)) || (res == EHANGUP))
    8183                        return;
    8284               
Note: See TracChangeset for help on using the changeset viewer.