Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset eaa0c3f in mainline


Ignore:
Timestamp:
2012-01-21T23:55:03Z (8 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
master
Children:
c38e417
Parents:
86c71de (diff), e98fe28c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge with mainline

Location:
uspace
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/trace/trace.c

    r86c71de reaa0c3f  
    623623error:
    624624        loader_abort(ldr);
    625         free(ldr);
    626625        return NULL;
    627626}
  • uspace/drv/char/ps2mouse/ps2mouse.c

    r86c71de reaa0c3f  
    116116        assert(mouse);
    117117        assert(dev);
    118         mouse->input_sess = NULL;
     118        mouse->client_sess = NULL;
    119119        mouse->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
    120120            dev->handle, IPC_FLAG_BLOCKING);
     
    218218
    219219                async_exch_t *exch =
    220                     async_exchange_begin(mouse->input_sess);
     220                    async_exchange_begin(mouse->client_sess);
    221221                if (!exch) {
    222222                        ddf_msg(LVL_ERROR,
    223                             "Failed to create input exchange.");
     223                            "Failed creating exchange.");
    224224                        continue;
    225225                }
     
    277277
    278278                async_exch_t *exch =
    279                     async_exchange_begin(mouse->input_sess);
     279                    async_exchange_begin(mouse->client_sess);
    280280                if (!exch) {
    281281                        ddf_msg(LVL_ERROR,
    282                             "Failed to create input exchange.");
     282                            "Failed creating exchange.");
    283283                        continue;
    284284                }
     
    386386                if (sess == NULL) {
    387387                        ddf_msg(LVL_WARN,
    388                             "Failed to create start input session");
     388                            "Failed creating client callback session");
    389389                        async_answer_0(icallid, EAGAIN);
    390390                        break;
    391391                }
    392                 if (mouse->input_sess == NULL) {
    393                         mouse->input_sess = sess;
    394                         ddf_msg(LVL_DEBUG, "Set input session");
     392                if (mouse->client_sess == NULL) {
     393                        mouse->client_sess = sess;
     394                        ddf_msg(LVL_DEBUG, "Set client session");
    395395                        async_answer_0(icallid, EOK);
    396396                } else {
    397                         ddf_msg(LVL_ERROR, "Input session already set");
     397                        ddf_msg(LVL_ERROR, "Client session already set");
    398398                        async_answer_0(icallid, ELIMIT);
    399399                }
  • uspace/drv/char/ps2mouse/ps2mouse.h

    r86c71de reaa0c3f  
    4343        ddf_fun_t *mouse_fun;      /**< Mouse function. */
    4444        async_sess_t *parent_sess; /**< Connection to device providing data. */
    45         async_sess_t *input_sess;  /**< Callback connection to consumer. */
     45        async_sess_t *client_sess;  /**< Callback connection to client. */
    4646        fid_t polling_fibril;      /**< Fibril retrieving an parsing data. */
    4747} ps2_mouse_t;
  • uspace/drv/char/xtkbd/xtkbd.c

    r86c71de reaa0c3f  
    206206        assert(kbd);
    207207        assert(dev);
    208         kbd->input_sess = NULL;
     208        kbd->client_sess = NULL;
    209209        kbd->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
    210210            dev->handle, IPC_FLAG_BLOCKING);
     
    296296                if (key != 0) {
    297297                        async_exch_t *exch =
    298                             async_exchange_begin(kbd->input_sess);
     298                            async_exchange_begin(kbd->client_sess);
    299299                        if (!exch) {
    300300                                ddf_msg(LVL_ERROR,
    301                                     "Failed to create input exchange.");
     301                                    "Failed creating exchange.");
    302302                                continue;
    303303                        }
     
    352352                if (sess == NULL) {
    353353                        ddf_msg(LVL_WARN,
    354                             "Failed to create start input session");
     354                            "Failed creating callback session");
    355355                        async_answer_0(icallid, EAGAIN);
    356356                        break;
    357357                }
    358                 if (kbd->input_sess == NULL) {
    359                         kbd->input_sess = sess;
    360                         ddf_msg(LVL_DEBUG, "Set input session");
     358                if (kbd->client_sess == NULL) {
     359                        kbd->client_sess = sess;
     360                        ddf_msg(LVL_DEBUG, "Set client session");
    361361                        async_answer_0(icallid, EOK);
    362362                } else {
    363                         ddf_msg(LVL_ERROR, "Input session already set");
     363                        ddf_msg(LVL_ERROR, "Client session already set");
    364364                        async_answer_0(icallid, ELIMIT);
    365365                }
  • uspace/drv/char/xtkbd/xtkbd.h

    r86c71de reaa0c3f  
    4343        ddf_fun_t *kbd_fun;        /**< Keyboard function. */
    4444        async_sess_t *parent_sess; /**< Connection to device providing data. */
    45         async_sess_t *input_sess;  /**< Callback connection to consumer. */
     45        async_sess_t *client_sess; /**< Callback connection to client. */
    4646        fid_t polling_fibril;      /**< Fibril retrieving an parsing data. */
    4747} xt_kbd_t;
  • uspace/lib/c/include/ipc/devman.h

    r86c71de reaa0c3f  
    146146typedef enum {
    147147        DRIVER_DEV_ADD = IPC_FIRST_USER_METHOD,
    148         DRIVER_DEV_ADDED,
    149148        DRIVER_DEV_REMOVE,
    150149        DRIVER_DEV_GONE,
  • uspace/lib/c/include/ipc/net.h

    r86c71de reaa0c3f  
    305305 *
    306306 */
    307 #define IPC_GET_DEVICE_HANDLE(call)  ((devman_handle_t) IPC_GET_ARG2(call))
     307#define IPC_GET_DEVICE_HANDLE(call)  ((service_id_t) IPC_GET_ARG2(call))
    308308
    309309/** Return the device driver service message argument.
  • uspace/lib/c/include/ipc/net_net.h

    r86c71de reaa0c3f  
    5454        NET_NET_GET_DEVICES_COUNT,
    5555        /** Return names and device IDs of all devices */
    56         NET_NET_GET_DEVICES,
    57         /** Notify the networking service about a ready device */
    58         NET_NET_DRIVER_READY
     56        NET_NET_GET_DEVICES
    5957} net_messages;
    6058
  • uspace/lib/drv/generic/driver.c

    r86c71de reaa0c3f  
    303303}
    304304
    305 static void driver_dev_added(ipc_callid_t iid, ipc_call_t *icall)
    306 {
    307         fibril_mutex_lock(&devices_mutex);
    308         ddf_dev_t *dev = driver_get_device(IPC_GET_ARG1(*icall));
    309         fibril_mutex_unlock(&devices_mutex);
    310        
    311         if (dev != NULL && driver->driver_ops->device_added != NULL)
    312                 driver->driver_ops->device_added(dev);
    313 }
    314 
    315305static void driver_dev_remove(ipc_callid_t iid, ipc_call_t *icall)
    316306{
     
    460450                case DRIVER_DEV_ADD:
    461451                        driver_dev_add(callid, &call);
    462                         break;
    463                 case DRIVER_DEV_ADDED:
    464                         async_answer_0(callid, EOK);
    465                         driver_dev_added(callid, &call);
    466452                        break;
    467453                case DRIVER_DEV_REMOVE:
  • uspace/lib/drv/include/ddf/driver.h

    r86c71de reaa0c3f  
    145145        /** Ask driver to offline a specific function */
    146146        int (*fun_offline)(ddf_fun_t *);
    147 
    148         /**
    149          * Notification that the device was succesfully added.
    150          * The driver can do any blocking operation without
    151          * blocking the device manager.
    152          *
    153          * XXX REMOVE THIS
    154          */
    155         void (*device_added)(ddf_dev_t *dev);
    156147} driver_ops_t;
    157148
  • uspace/lib/net/generic/net_remote.c

    r86c71de reaa0c3f  
    167167}
    168168
    169 int net_driver_ready(async_sess_t *sess, devman_handle_t handle)
    170 {
    171         async_exch_t *exch = async_exchange_begin(sess);
    172         int rc = async_req_1_0(exch, NET_NET_DRIVER_READY, handle);
    173         async_exchange_end(exch);
    174        
    175         return rc;
    176 }
    177 
    178169/** @}
    179170 */
  • uspace/lib/net/include/net_interface.h

    r86c71de reaa0c3f  
    5252extern int net_get_devices_req(async_sess_t *, measured_string_t **, size_t *,
    5353    uint8_t **);
    54 extern int net_driver_ready(async_sess_t *, devman_handle_t);
    5554extern async_sess_t *net_connect_module(void);
    5655
  • uspace/lib/net/include/nil_remote.h

    r86c71de reaa0c3f  
    3434#define __NET_NIL_REMOTE_H__
    3535
     36#include <ipc/loc.h>
    3637#include <net/device.h>
    3738#include <net/packet.h>
  • uspace/lib/net/nil/nil_remote.c

    r86c71de reaa0c3f  
    3636 */
    3737
     38#include <ipc/loc.h>
    3839#include <nil_remote.h>
    3940#include <generic.h>
     
    123124
    124125int nil_device_req(async_sess_t *sess, nic_device_id_t device_id,
    125     devman_handle_t handle, size_t mtu)
     126    service_id_t sid, size_t mtu)
    126127{
    127128        async_exch_t *exch = async_exchange_begin(sess);
    128129        int rc = async_req_3_0(exch, NET_NIL_DEVICE, (sysarg_t) device_id,
    129             (sysarg_t) handle, (sysarg_t) mtu);
     130            (sysarg_t) sid, (sysarg_t) mtu);
    130131        async_exchange_end(exch);
    131132        return rc;
  • uspace/lib/nic/include/nic.h

    r86c71de reaa0c3f  
    219219extern void nic_set_poll_handlers(nic_t *,
    220220        poll_mode_change_handler, poll_request_handler);
    221 
    222 /* Functions called in device_added */
    223 extern int nic_ready(nic_t *);
    224221
    225222/* General driver functions */
  • uspace/lib/nic/include/nic_driver.h

    r86c71de reaa0c3f  
    8080        /** Device's default MAC address (assigned the first time, used in STOP) */
    8181        nic_address_t default_mac;
    82         /** Session to SERVICE_NETWORKING */
    83         async_sess_t *net_session;
    8482        /** Session to SERVICE_ETHERNET or SERVICE_NILDUMMY */
    8583        async_sess_t *nil_session;
  • uspace/lib/nic/src/nic_driver.c

    r86c71de reaa0c3f  
    4949#include <devman.h>
    5050#include <ddf/interrupt.h>
    51 #include <net_interface.h>
    5251#include <ops/nic.h>
    5352#include <errno.h>
     
    8988    nic_iface_t *iface)
    9089{
    91         if (driver_ops) {
    92                 if (!driver_ops->device_added)
    93                         driver_ops->device_added = nic_device_added_impl;
    94         }
    95 
    9690        if (dev_ops) {
    9791                if (!dev_ops->open)
     
    429423
    430424/**
    431  * Connect to the NET and IRQ services. This function should be called only from
     425 * Connect to IRC service. This function should be called only from
    432426 * the add_device handler, thus no locking is required.
    433427 *
     
    436430 * @return EOK          If connection was successful.
    437431 * @return EINVAL       If the IRC service cannot be determined.
    438  * @return EREFUSED     If NET or IRC service cannot be connected.
     432 * @return EREFUSED     If IRC service cannot be connected.
    439433 */
    440434int nic_connect_to_services(nic_t *nic_data)
    441435{
    442         /* NET service */
    443         nic_data->net_session = service_connect_blocking(EXCHANGE_SERIALIZE,
    444                 SERVICE_NETWORKING, 0, 0);
    445         if (nic_data->net_session == NULL)
    446                 return errno;
    447        
    448436        /* IRC service */
    449437        sysarg_t apic;
     
    462450       
    463451        return EOK;
    464 }
    465 
    466 /** Notify the NET service that the device is ready
    467  *
    468  * @param nic NICF structure
    469  *
    470  * @return EOK on success
    471  *
    472  */
    473 int nic_ready(nic_t *nic)
    474 {
    475         fibril_rwlock_read_lock(&nic->main_lock);
    476        
    477         async_sess_t *session = nic->net_session;
    478         devman_handle_t handle = nic->dev->handle;
    479        
    480         fibril_rwlock_read_unlock(&nic->main_lock);
    481        
    482         if (session == NULL)
    483                 return EINVAL;
    484        
    485         return net_driver_ready(session, handle);
    486452}
    487453
     
    726692        nic_data->device_id = NIC_DEVICE_INVALID_ID;
    727693        nic_data->state = NIC_STATE_STOPPED;
    728         nic_data->net_session = NULL;
    729694        nic_data->nil_session = NULL;
    730695        nic_data->irc_session = NULL;
     
    781746 */
    782747static void nic_destroy(nic_t *nic_data) {
    783         if (nic_data->net_session != NULL) {
    784                 async_hangup(nic_data->net_session);
    785         }
    786 
    787748        if (nic_data->nil_session != NULL) {
    788749                async_hangup(nic_data->nil_session);
  • uspace/lib/nic/src/nic_impl.c

    r86c71de reaa0c3f  
    8585        }
    8686        if (state == NIC_STATE_ACTIVE) {
    87                 if (nic_data->nil_session == NULL || nic_data->net_session == NULL
    88                     || nic_data->device_id < 0) {
     87                if (nic_data->nil_session == NULL || nic_data->device_id < 0) {
    8988                        fibril_rwlock_write_unlock(&nic_data->main_lock);
    9089                        return EINVAL;
     
    805804}
    806805
    807 /** Default implementation of the device_added method
    808  *
    809  * Just calls nic_ready.
    810  *
    811  * @param dev
    812  *
    813  */
    814 void nic_device_added_impl(ddf_dev_t *dev)
    815 {
    816         nic_ready((nic_t *) dev->driver_data);
    817 }
    818 
    819806/**
    820807 * Default handler for unknown methods (outside of the NIC interface).
  • uspace/srv/devman/devman.c

    r86c71de reaa0c3f  
    794794        case EOK:
    795795                dev->state = DEVICE_USABLE;
    796                 exch = async_exchange_begin(drv->sess);
    797                 async_msg_1(exch, DRIVER_DEV_ADDED, dev->handle);
    798                 async_exchange_end(exch);
    799796                break;
    800797        case ENOENT:
     
    803800        default:
    804801                dev->state = DEVICE_INVALID;
     802                break;
    805803        }
    806804       
  • uspace/srv/loc/loc.c

    r86c71de reaa0c3f  
    5656#define NULL_SERVICES  256
    5757
     58/** Callback session */
     59typedef struct {
     60        link_t cb_sess_list;
     61        async_sess_t *sess;
     62} cb_sess_t;
     63
    5864LIST_INITIALIZE(services_list);
    5965LIST_INITIALIZE(namespaces_list);
     
    8692
    8793static FIBRIL_MUTEX_INITIALIZE(callback_sess_mutex);
    88 static async_sess_t *callback_sess = NULL;
     94static LIST_INITIALIZE(callback_sess_list);
    8995
    9096service_id_t loc_create_id(void)
     
    608614        size_t act_size;
    609615        loc_service_t *svc;
     616        char *fqn;
    610617       
    611618        if (!async_data_read_receive(&callid, &size)) {
     
    625632        }
    626633       
    627         act_size = str_size(svc->name);
     634        if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
     635                fibril_mutex_unlock(&services_list_mutex);
     636                async_answer_0(callid, ENOMEM);
     637                async_answer_0(iid, ENOMEM);
     638                return;
     639        }
     640       
     641        act_size = str_size(fqn);
    628642        if (act_size > size) {
     643                free(fqn);
    629644                fibril_mutex_unlock(&services_list_mutex);
    630645                async_answer_0(callid, EOVERFLOW);
     
    633648        }
    634649       
    635         sysarg_t retval = async_data_read_finalize(callid, svc->name,
     650        sysarg_t retval = async_data_read_finalize(callid, fqn,
    636651            min(size, act_size));
     652        free(fqn);
    637653       
    638654        fibril_mutex_unlock(&services_list_mutex);
     
    790806}
    791807
    792 /** Find ID for category specified by name.
    793  *
    794  * On success, answer will contain EOK int retval and service ID in arg1.
     808/** Create callback connection.
     809 *
     810 * Create callback connection which will be used to send category change
     811 * events.
     812 *
     813 * On success, answer will contain EOK int retval.
    795814 * On failure, error code will be sent in retval.
    796  *
    797815 */
    798816static void loc_callback_create(ipc_callid_t iid, ipc_call_t *icall)
    799817{
    800         async_sess_t *cb_sess = async_callback_receive(EXCHANGE_SERIALIZE);
     818        cb_sess_t *cb_sess;
     819       
     820        cb_sess = calloc(1, sizeof(cb_sess_t));
    801821        if (cb_sess == NULL) {
    802822                async_answer_0(iid, ENOMEM);
     
    804824        }
    805825       
     826        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
     827        if (sess == NULL) {
     828                free(cb_sess);
     829                async_answer_0(iid, ENOMEM);
     830                return;
     831        }
     832       
     833        cb_sess->sess = sess;
     834        link_initialize(&cb_sess->cb_sess_list);
     835       
    806836        fibril_mutex_lock(&callback_sess_mutex);
    807         if (callback_sess != NULL) {
    808                 fibril_mutex_unlock(&callback_sess_mutex);
    809                 async_answer_0(iid, EEXIST);
    810                 return;
    811         }
    812        
    813         callback_sess = cb_sess;
     837        list_append(&cb_sess->cb_sess_list, &callback_sess_list);
    814838        fibril_mutex_unlock(&callback_sess_mutex);
    815839       
     
    820844{
    821845        fibril_mutex_lock(&callback_sess_mutex);
    822 
    823         if (callback_sess != NULL) {
    824                 async_exch_t *exch = async_exchange_begin(callback_sess);
     846       
     847        list_foreach(callback_sess_list, link) {
     848                cb_sess_t *cb_sess;
     849               
     850                cb_sess = list_get_instance(link, cb_sess_t, cb_sess_list);
     851               
     852                async_exch_t *exch = async_exchange_begin(cb_sess->sess);
    825853                async_msg_0(exch, LOC_EVENT_CAT_CHANGE);
    826854                async_exchange_end(exch);
    827855        }
    828 
     856       
    829857        fibril_mutex_unlock(&callback_sess_mutex);
    830858}
  • uspace/srv/net/cfg/e1k.nic

    r86c71de reaa0c3f  
    33NAME=e1k
    44
    5 HWPATH=/hw/pci0/00:03.0/port0
     5HWPATH=devices/\hw\pci0\00:03.0\port0
    66NIL=eth
    77IL=ip
  • uspace/srv/net/cfg/lo.nic

    r86c71de reaa0c3f  
    33NAME=lo
    44
    5 HWPATH=/virt/lo/port0
     5HWPATH=devices/\virt\lo\port0
    66NIL=nildummy
    77IL=ip
  • uspace/srv/net/cfg/ne2k.nic

    r86c71de reaa0c3f  
    33NAME=ne2k
    44
    5 HWPATH=/hw/pci0/00:01.0/ne2k/port0
     5HWPATH=devices/\hw\pci0\00:01.0\ne2k\port0
    66NIL=eth
    77IL=ip
  • uspace/srv/net/net/Makefile

    r86c71de reaa0c3f  
    3131ROOT_PATH = $(USPACE_PREFIX)/..
    3232LIBS = $(LIBNET_PREFIX)/libnet.a
    33 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
     33EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include \
     34    -I$(LIBDRV_PREFIX)/include
    3435
    3536COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
  • uspace/srv/net/net/net.c

    r86c71de reaa0c3f  
    4141#include <stdio.h>
    4242#include <str.h>
    43 #include <devman.h>
    4443#include <str_error.h>
    4544#include <ns.h>
     
    5655#include <adt/measured_strings.h>
    5756#include <adt/module_map.h>
     57#include <loc.h>
     58#include <nic.h>
    5859#include <nil_remote.h>
    5960#include <net_interface.h>
     
    7374GENERIC_CHAR_MAP_IMPLEMENT(measured_strings, measured_string_t);
    7475DEVICE_MAP_IMPLEMENT(netifs, netif_t);
     76LIST_INITIALIZE(netif_list);
    7577
    7678/** Add the configured setting to the configuration map.
     
    287289 *
    288290 */
    289 static int init_device(netif_t *netif, devman_handle_t handle)
     291static int init_device(netif_t *netif, service_id_t sid)
    290292{
    291293        printf("%s: Initializing device '%s'\n", NAME, netif->name);
    292294       
    293         netif->handle = handle;
    294         netif->sess = devman_device_connect(EXCHANGE_SERIALIZE, netif->handle,
     295        link_initialize(&netif->netif_list);
     296       
     297        netif->sid = sid;
     298        netif->sess = loc_service_connect(EXCHANGE_SERIALIZE, netif->sid,
    295299            IPC_FLAG_BLOCKING);
    296300        if (netif->sess == NULL) {
     
    337341                    strtol((const char *) setting->value, NULL, 10) : 0;
    338342                rc = nil_device_req(netif->nil->sess, netif->id,
    339                     netif->handle, mtu);
     343                    netif->sid, mtu);
    340344                if (rc != EOK) {
    341345                        printf("%s: Unable to start network interface layer\n",
     
    363367       
    364368        printf("%s: Activating device '%s'\n", NAME, netif->name);
     369        list_append(&netif->netif_list, &netif_list);
    365370        return nic_set_state(netif->sess, NIC_STATE_ACTIVE);
    366371}
    367372
    368 static int net_port_ready(devman_handle_t handle)
    369 {
    370         char hwpath[MAX_PATH_LENGTH];
    371         int rc = devman_fun_get_path(handle, hwpath, MAX_PATH_LENGTH);
    372         if (rc != EOK)
     373static int net_nic_ready(service_id_t sid)
     374{
     375        int rc;
     376        char *hwpath;
     377       
     378        rc = loc_service_get_name(sid, &hwpath);
     379        if (rc != EOK) {
     380                printf("%s: Failed getting name of service '%u'\n",
     381                    NAME, (unsigned) sid);
    373382                return EINVAL;
     383        }
    374384       
    375385        int index = char_map_find(&net_globals.netif_hwpaths,
    376386            (uint8_t *) hwpath, 0);
    377         if (index == CHAR_MAP_NULL)
     387       
     388        if (index == CHAR_MAP_NULL) {
     389                printf("%s: Service '%s' not found in map.\n", NAME, hwpath);
     390                free(hwpath);
    378391                return ENOENT;
     392        }
     393       
     394        free(hwpath);
    379395       
    380396        netif_t *netif = netifs_get_index(&net_globals.netifs, index);
     
    382398                return ENOENT;
    383399       
    384         rc = init_device(netif, handle);
     400        rc = init_device(netif, sid);
    385401        if (rc != EOK)
    386402                return rc;
     
    391407       
    392408        netif->il->usage++;
    393        
    394         return EOK;
    395 }
    396 
    397 static int net_driver_ready_local(devman_handle_t handle)
    398 {
    399         devman_handle_t *funs;
    400         size_t count;
    401         int rc = devman_dev_get_functions(handle, &funs, &count);
    402         if (rc != EOK)
    403                 return rc;
    404        
    405         for (size_t i = 0; i < count; i++) {
    406                 rc = net_port_ready(funs[i]);
    407                 if (rc != EOK)
    408                         return rc;
    409         }
    410409       
    411410        return EOK;
     
    479478                net_free_devices(strings, count);
    480479                return rc;
    481         case NET_NET_DRIVER_READY:
    482                 rc = net_driver_ready_local(IPC_GET_ARG1(*call));
    483                 *answer_count = 0;
    484                 return rc;
    485480        default:
    486481                return ENOTSUP;
     
    528523                answer_call(callid, res, &answer, count);
    529524        }
     525}
     526
     527static int nic_check_new(void)
     528{
     529        category_id_t nic_cat;
     530        service_id_t *svcs;
     531        size_t count, i;
     532        bool already_known;
     533        int rc;
     534
     535        rc = loc_category_get_id(DEVICE_CATEGORY_NIC, &nic_cat, IPC_FLAG_BLOCKING);
     536        if (rc != EOK) {
     537                printf("%s: Failed resolving category '%s'.\n", NAME,
     538                    DEVICE_CATEGORY_NIC);
     539                return ENOENT;
     540        }
     541
     542        rc = loc_category_get_svcs(nic_cat, &svcs, &count);
     543        if (rc != EOK) {
     544                printf("%s: Failed getting list of NIC devices.\n", NAME);
     545                return EIO;
     546        }
     547
     548        for (i = 0; i < count; i++) {
     549                already_known = false;
     550
     551                list_foreach(netif_list, link) {
     552                        netif_t *netif = list_get_instance(link, netif_t, netif_list);
     553                        if (netif->sid == svcs[i]) {
     554                                already_known = true;
     555                                break;
     556                        }
     557                }
     558
     559                if (!already_known) {
     560                        rc = net_nic_ready(svcs[i]);
     561                        if (rc != EOK) {
     562                                printf("%s: Failed adding NIC device #%u.\n",
     563                                    NAME, (unsigned) svcs[i]);
     564                        }
     565                }
     566        }
     567
     568        free(svcs);
     569        return EOK;
     570}
     571
     572static void cat_change_cb(void)
     573{
     574        (void) nic_check_new();
     575}
     576
     577static int net_start_nic_discovery(void)
     578{
     579        int rc;
     580
     581        rc = loc_register_cat_change_cb(cat_change_cb);
     582        if (rc != EOK) {
     583                printf("%s: Failed registering callback for device discovery (%d).\n",
     584                    NAME, rc);
     585                return rc;
     586        }
     587
     588        return nic_check_new();
    530589}
    531590
     
    573632                                continue;
    574633                       
    575                         netif->handle = -1;
     634                        netif->sid = -1;
    576635                        netif->sess = NULL;
    577636                       
     
    697756        }
    698757       
     758        rc = net_start_nic_discovery();
     759        if (rc != EOK) {
     760                printf("%s: Error starting NIC discovery\n", NAME);
     761                pm_destroy();
     762                return rc;
     763        }
     764       
    699765        task_retval(0);
    700766        async_manager();
  • uspace/srv/net/net/net.h

    r86c71de reaa0c3f  
    3535#define NET_NET_H_
    3636
     37#include <ipc/loc.h>
    3738#include <net/device.h>
    3839#include <adt/char_map.h>
     
    4142#include <adt/module_map.h>
    4243#include <net/packet.h>
    43 #include <devman.h>
    4444
    4545#define NAME  "net"
     
    9696       
    9797        /** Serving network interface driver module index. */
    98         devman_handle_t handle;  /**< Handle for devman */
     98        service_id_t sid;  /**< Service ID */
    9999        async_sess_t *sess;      /**< Driver session. */
    100100       
    101101        module_t *nil;  /**< Serving link layer module index. */
    102102        module_t *il;   /**< Serving internet layer module index. */
     103       
     104        link_t netif_list;
    103105} netif_t;
    104106
  • uspace/srv/net/nil/eth/eth.c

    r86c71de reaa0c3f  
    4848#include <ipc/net.h>
    4949#include <ipc/services.h>
     50#include <loc.h>
    5051#include <net/modules.h>
    5152#include <net_checksum.h>
     
    226227 *
    227228 * @param[in] device_id New device identifier.
    228  * @param[in] handle    Device driver handle.
     229 * @param[in] sid       NIC service ID.
    229230 * @param[in] mtu       Device maximum transmission unit.
    230231 *
     
    234235 *
    235236 */
    236 static int eth_device_message(nic_device_id_t device_id, devman_handle_t handle,
     237static int eth_device_message(nic_device_id_t device_id, service_id_t sid,
    237238    size_t mtu)
    238239{
     
    259260        device = eth_devices_find(&eth_globals.devices, device_id);
    260261        if (device) {
    261                 if (device->handle != handle) {
     262                if (device->sid != sid) {
    262263                        printf("Device %d already exists\n", device->device_id);
    263264                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     
    298299
    299300        device->device_id = device_id;
    300         device->handle = handle;
     301        device->sid = sid;
    301302        device->flags = 0;
    302303        if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
     
    335336       
    336337        /* Bind the device driver */
    337         device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     338        device->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid,
    338339            IPC_FLAG_BLOCKING);
    339340        if (device->sess == NULL) {
     
    362363        }
    363364       
    364         printf("%s: Device registered (id: %d, handle: %zu: mtu: %zu, "
     365        printf("%s: Device registered (id: %d, sid: %zu: mtu: %zu, "
    365366            "mac: " PRIMAC ", flags: 0x%x)\n", NAME,
    366             device->device_id, device->handle, device->mtu,
     367            device->device_id, device->sid, device->mtu,
    367368            ARGSMAC(device->addr.address), device->flags);
    368369
  • uspace/srv/net/nil/eth/eth.h

    r86c71de reaa0c3f  
    4141#include <async.h>
    4242#include <fibril_synch.h>
     43#include <ipc/loc.h>
    4344#include <ipc/services.h>
    4445#include <net/device.h>
    4546#include <adt/measured_strings.h>
    46 #include <devman.h>
    4747
    4848/** Ethernet address length. */
     
    224224        nic_device_id_t device_id;
    225225        /** Device handle */
    226         devman_handle_t handle;
     226        service_id_t sid;
    227227        /** Driver session. */
    228228        async_sess_t *sess;
  • uspace/srv/net/nil/nildummy/nildummy.c

    r86c71de reaa0c3f  
    5353#include <packet_remote.h>
    5454#include <packet_client.h>
    55 #include <devman.h>
    5655#include <device/nic.h>
     56#include <loc.h>
    5757#include <nil_skel.h>
    5858#include "nildummy.h"
     
    115115 */
    116116static int nildummy_device_message(nic_device_id_t device_id,
    117     devman_handle_t handle, size_t mtu)
     117    service_id_t sid, size_t mtu)
    118118{
    119119        fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
     
    123123            nildummy_devices_find(&nildummy_globals.devices, device_id);
    124124        if (device) {
    125                 if (device->handle != handle) {
     125                if (device->sid != sid) {
    126126                        printf("Device %d exists, handles do not match\n",
    127127                            device->device_id);
     
    158158       
    159159        device->device_id = device_id;
    160         device->handle = handle;
     160        device->sid = sid;
    161161        if (mtu > 0)
    162162                device->mtu = mtu;
     
    165165       
    166166        /* Bind the device driver */
    167         device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     167        device->sess = loc_service_connect(EXCHANGE_SERIALIZE, sid,
    168168            IPC_FLAG_BLOCKING);
    169169        if (device->sess == NULL) {
  • uspace/srv/net/nil/nildummy/nildummy.h

    r86c71de reaa0c3f  
    4141#include <async.h>
    4242#include <fibril_synch.h>
     43#include <ipc/loc.h>
    4344#include <ipc/services.h>
    44 #include <ipc/devman.h>
    4545#include <net/device.h>
    4646
     
    7878        /** Device identifier. */
    7979        nic_device_id_t device_id;
    80         /** Device driver handle. */
    81         devman_handle_t handle;
     80        /** Device service ID. */
     81        service_id_t sid;
    8282        /** Driver session. */
    8383        async_sess_t *sess;
Note: See TracChangeset for help on using the changeset viewer.