Changeset b7fd2a0 in mainline for uspace/lib/nic/src


Ignore:
Timestamp:
2018-01-13T03:10:29Z (8 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a53ed3a
Parents:
36f0738
Message:

Use errno_t in all uspace and kernel code.

Change type of every variable, parameter and return value that holds an
<errno.h> constant to either errno_t (the usual case), or sys_errno_t
(some places in kernel). This is for the purpose of self-documentation,
as well as for type-checking with a bit of type definition hackery.

Although this is a massive commit, it is a simple text replacement, and thus
is very easy to verify. Simply do the following:

`
git checkout <this commit's hash>
git reset HEAD
git add .
tools/srepl '\berrno_t\b' int
git add .
tools/srepl '\bsys_errno_t\b' sysarg_t
git reset
git diff
`

While this doesn't ensure that the replacements are correct, it does ensure
that the commit doesn't do anything except those replacements. Since errno_t
is typedef'd to int in the usual case (and sys_errno_t to sysarg_t), even if
incorrect, this commit cannot change behavior.

Location:
uspace/lib/nic/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/nic/src/nic_addr_db.c

    r36f0738 rb7fd2a0  
    120120 * @return ENOMEM       If there was not enough memory to initialize the storage
    121121 */
    122 int nic_addr_db_init(nic_addr_db_t *db, size_t addr_len)
     122errno_t nic_addr_db_init(nic_addr_db_t *db, size_t addr_len)
    123123{
    124124        assert(db);
    … …  
    168168 * @return EEXIST       If this adress already is in the db
    169169 */
    170 int nic_addr_db_insert(nic_addr_db_t *db, const uint8_t *addr)
     170errno_t nic_addr_db_insert(nic_addr_db_t *db, const uint8_t *addr)
    171171{
    172172        assert(db && addr);
    … …  
    200200 * @return ENOENT       If there is no address
    201201 */
    202 int nic_addr_db_remove(nic_addr_db_t *db, const uint8_t *addr)
     202errno_t nic_addr_db_remove(nic_addr_db_t *db, const uint8_t *addr)
    203203{
    204204        assert(db && addr);

  • uspace/lib/nic/src/nic_driver.c

    r36f0738 rb7fd2a0  
    6161 * @param name  Name of the device/driver (used in logging)
    6262 */
    63 int nic_driver_init(const char *name)
     63errno_t nic_driver_init(const char *name)
    6464{
    6565        list_initialize(&nic_globals.frame_list_cache);
    … …  
    243243 * @return EOK or an error code
    244244 */
    245 int nic_get_resources(nic_t *nic_data, hw_res_list_parsed_t *resources)
     245errno_t nic_get_resources(nic_t *nic_data, hw_res_list_parsed_t *resources)
    246246{
    247247        ddf_dev_t *dev = nic_data->dev;
    … …  
    399399 *  @return EINVAL
    400400 */
    401 int nic_report_poll_mode(nic_t *nic_data, nic_poll_mode_t mode,
     401errno_t nic_report_poll_mode(nic_t *nic_data, nic_poll_mode_t mode,
    402402        struct timeval *period)
    403403{
    404         int rc = EOK;
     404        errno_t rc = EOK;
    405405        fibril_rwlock_write_lock(&nic_data->main_lock);
    406406        nic_data->poll_mode = mode;
    … …  
    423423 *
    424424 */
    425 int nic_report_address(nic_t *nic_data, const nic_address_t *address)
     425errno_t nic_report_address(nic_t *nic_data, const nic_address_t *address)
    426426{
    427427        assert(nic_data);
    … …  
    434434        /* Notify NIL layer (and uppper) if bound - not in add_device */
    435435        if (nic_data->client_session != NULL) {
    436                 int rc = nic_ev_addr_changed(nic_data->client_session,
     436                errno_t rc = nic_ev_addr_changed(nic_data->client_session,
    437437                    address);
    438438
    … …  
    450450         * calls this should not happen.
    451451         */
    452         int rc = nic_rxc_set_addr(&nic_data->rx_control,
     452        errno_t rc = nic_rxc_set_addr(&nic_data->rx_control,
    453453            &nic_data->mac, address);
    454454       
    … …  
    808808 * @return ENOENT
    809809 */
    810 int nic_query_vlan_mask(const nic_t *nic_data, nic_vlan_mask_t *mask)
     810errno_t nic_query_vlan_mask(const nic_t *nic_data, nic_vlan_mask_t *mask)
    811811{
    812812        assert(mask);
    … …  
    10391039 *  @return 0, never reached
    10401040 */
    1041 static int period_fibril_fun(void *data)
     1041static errno_t period_fibril_fun(void *data)
    10421042{
    10431043        nic_t *nic = data;

  • uspace/lib/nic/src/nic_ev.c

    r36f0738 rb7fd2a0  
    4242
    4343/** Device address changed. */
    44 int nic_ev_addr_changed(async_sess_t *sess, const nic_address_t *addr)
     44errno_t nic_ev_addr_changed(async_sess_t *sess, const nic_address_t *addr)
    4545{
    4646        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    4848        ipc_call_t answer;
    4949        aid_t req = async_send_0(exch, NIC_EV_ADDR_CHANGED, &answer);
    50         int retval = async_data_write_start(exch, addr,
     50        errno_t retval = async_data_write_start(exch, addr,
    5151            sizeof(nic_address_t));
    5252
    … …  
    6363
    6464/** Device state changed. */
    65 int nic_ev_device_state(async_sess_t *sess, sysarg_t state)
     65errno_t nic_ev_device_state(async_sess_t *sess, sysarg_t state)
    6666{
    67         int rc;
     67        errno_t rc;
    6868
    6969        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    7575
    7676/** Frame received. */
    77 int nic_ev_received(async_sess_t *sess, void *data, size_t size)
     77errno_t nic_ev_received(async_sess_t *sess, void *data, size_t size)
    7878{
    7979        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    8181        ipc_call_t answer;
    8282        aid_t req = async_send_0(exch, NIC_EV_RECEIVED, &answer);
    83         int retval = async_data_write_start(exch, data, size);
     83        errno_t retval = async_data_write_start(exch, data, size);
    8484
    8585        async_exchange_end(exch);

  • uspace/lib/nic/src/nic_impl.c

    r36f0738 rb7fd2a0  
    5252 * @return EOK always.
    5353 */
    54 int nic_get_state_impl(ddf_fun_t *fun, nic_device_state_t *state)
     54errno_t nic_get_state_impl(ddf_fun_t *fun, nic_device_state_t *state)
    5555{
    5656        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    … …  
    7272 * @return EINVAL       If the state cannot be changed
    7373 */
    74 int nic_set_state_impl(ddf_fun_t *fun, nic_device_state_t state)
     74errno_t nic_set_state_impl(ddf_fun_t *fun, nic_device_state_t state)
    7575{
    7676        if (state >= NIC_STATE_MAX) {
    … …  
    108108        }
    109109        if (event_handler != NULL) {
    110                 int rc = event_handler(nic_data);
     110                errno_t rc = event_handler(nic_data);
    111111                if (rc != EOK) {
    112112                        fibril_rwlock_write_unlock(&nic_data->main_lock);
    … …  
    117117        if (state == NIC_STATE_STOPPED) {
    118118                /* Notify upper layers that we are reseting the MAC */
    119                 int rc = nic_ev_addr_changed(nic_data->client_session,
     119                errno_t rc = nic_ev_addr_changed(nic_data->client_session,
    120120                        &nic_data->default_mac);
    121121                nic_data->poll_mode = nic_data->default_poll_mode;
    … …  
    168168 * @return EBUSY        If the device is not in state when the frame can be sent.
    169169 */
    170 int nic_send_frame_impl(ddf_fun_t *fun, void *data, size_t size)
     170errno_t nic_send_frame_impl(ddf_fun_t *fun, void *data, size_t size)
    171171{
    172172        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    … …  
    191191 * @return EOK          On success, or an error code.
    192192 */
    193 int nic_callback_create_impl(ddf_fun_t *fun)
     193errno_t nic_callback_create_impl(ddf_fun_t *fun)
    194194{
    195195        nic_t *nic = nic_get_from_ddf_fun(fun);
    … …  
    216216 * @return ELIMIT       If the buffer is too short
    217217 */
    218 int nic_get_address_impl(ddf_fun_t *fun, nic_address_t *address)
     218errno_t nic_get_address_impl(ddf_fun_t *fun, nic_address_t *address)
    219219{
    220220        assert(address);
    … …  
    235235 * @return EOK (cannot fail)
    236236 */
    237 int nic_get_stats_impl(ddf_fun_t *fun, nic_device_stats_t *stats)
     237errno_t nic_get_stats_impl(ddf_fun_t *fun, nic_device_stats_t *stats)
    238238{
    239239        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    … …  
    257257 * @return EOK
    258258 */
    259 int nic_unicast_get_mode_impl(ddf_fun_t *fun, nic_unicast_mode_t *mode,
     259errno_t nic_unicast_get_mode_impl(ddf_fun_t *fun, nic_unicast_mode_t *mode,
    260260        size_t max_count, nic_address_t *addr_list, size_t *addr_count)
    261261{
    … …  
    281281 * @return ENOMEM
    282282 */
    283 int nic_unicast_set_mode_impl(ddf_fun_t *fun,
     283errno_t nic_unicast_set_mode_impl(ddf_fun_t *fun,
    284284        nic_unicast_mode_t mode, const nic_address_t *addr_list, size_t addr_count)
    285285{
    … …  
    294294        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    295295        fibril_rwlock_write_lock(&nic_data->rxc_lock);
    296         int rc = ENOTSUP;
     296        errno_t rc = ENOTSUP;
    297297        if (nic_data->on_unicast_mode_change) {
    298298                rc = nic_data->on_unicast_mode_change(nic_data,
    … …  
    324324 * @return EOK
    325325 */
    326 int nic_multicast_get_mode_impl(ddf_fun_t *fun, nic_multicast_mode_t *mode,
     326errno_t nic_multicast_get_mode_impl(ddf_fun_t *fun, nic_multicast_mode_t *mode,
    327327        size_t max_count, nic_address_t *addr_list, size_t *addr_count)
    328328{
    … …  
    348348 * @return ENOMEM
    349349 */
    350 int nic_multicast_set_mode_impl(ddf_fun_t *fun, nic_multicast_mode_t mode,
     350errno_t nic_multicast_set_mode_impl(ddf_fun_t *fun,     nic_multicast_mode_t mode,
    351351        const nic_address_t *addr_list, size_t addr_count)
    352352{
    … …  
    361361        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    362362        fibril_rwlock_write_lock(&nic_data->rxc_lock);
    363         int rc = ENOTSUP;
     363        errno_t rc = ENOTSUP;
    364364        if (nic_data->on_multicast_mode_change) {
    365365                rc = nic_data->on_multicast_mode_change(nic_data, mode, addr_list, addr_count);
    … …  
    381381 * @return EOK
    382382 */
    383 int nic_broadcast_get_mode_impl(ddf_fun_t *fun, nic_broadcast_mode_t *mode)
     383errno_t nic_broadcast_get_mode_impl(ddf_fun_t *fun, nic_broadcast_mode_t *mode)
    384384{
    385385        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    … …  
    401401 * @return ENOMEM
    402402 */
    403 int nic_broadcast_set_mode_impl(ddf_fun_t *fun, nic_broadcast_mode_t mode)
     403errno_t nic_broadcast_set_mode_impl(ddf_fun_t *fun, nic_broadcast_mode_t mode)
    404404{
    405405        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    406406        fibril_rwlock_write_lock(&nic_data->rxc_lock);
    407         int rc = ENOTSUP;
     407        errno_t rc = ENOTSUP;
    408408        if (nic_data->on_broadcast_mode_change) {
    409409                rc = nic_data->on_broadcast_mode_change(nic_data, mode);
    … …  
    427427 * @return EOK
    428428 */
    429 int nic_blocked_sources_get_impl(ddf_fun_t *fun,
     429errno_t nic_blocked_sources_get_impl(ddf_fun_t *fun,
    430430        size_t max_count, nic_address_t *addr_list, size_t *addr_count)
    431431{
    … …  
    450450 * @return ENOMEM
    451451 */
    452 int nic_blocked_sources_set_impl(ddf_fun_t *fun,
     452errno_t nic_blocked_sources_set_impl(ddf_fun_t *fun,
    453453        const nic_address_t *addr_list, size_t addr_count)
    454454{
    … …  
    458458                nic_data->on_blocked_sources_change(nic_data, addr_list, addr_count);
    459459        }
    460         int rc = nic_rxc_blocked_sources_set(&nic_data->rx_control,
     460        errno_t rc = nic_rxc_blocked_sources_set(&nic_data->rx_control,
    461461                addr_list, addr_count);
    462462        fibril_rwlock_write_unlock(&nic_data->rxc_lock);
    … …  
    473473 * @return ENOENT       If the mask is not set
    474474 */
    475 int nic_vlan_get_mask_impl(ddf_fun_t *fun, nic_vlan_mask_t *mask)
     475errno_t nic_vlan_get_mask_impl(ddf_fun_t *fun, nic_vlan_mask_t *mask)
    476476{
    477477        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    478478        fibril_rwlock_read_lock(&nic_data->rxc_lock);
    479         int rc = nic_rxc_vlan_get_mask(&nic_data->rx_control, mask);
     479        errno_t rc = nic_rxc_vlan_get_mask(&nic_data->rx_control, mask);
    480480        fibril_rwlock_read_unlock(&nic_data->rxc_lock);
    481481        return rc;
    … …  
    491491 * @return ENOMEM
    492492 */
    493 int nic_vlan_set_mask_impl(ddf_fun_t *fun, const nic_vlan_mask_t *mask)
     493errno_t nic_vlan_set_mask_impl(ddf_fun_t *fun, const nic_vlan_mask_t *mask)
    494494{
    495495        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    496496        fibril_rwlock_write_lock(&nic_data->rxc_lock);
    497         int rc = nic_rxc_vlan_set_mask(&nic_data->rx_control, mask);
     497        errno_t rc = nic_rxc_vlan_set_mask(&nic_data->rx_control, mask);
    498498        if (rc == EOK && nic_data->on_vlan_mask_change) {
    499499                nic_data->on_vlan_mask_change(nic_data, mask);
    … …  
    518518 * @return ENOMEM       If there was not enough memory to complete the operation
    519519 */
    520 int nic_wol_virtue_add_impl(ddf_fun_t *fun, nic_wv_type_t type,
     520errno_t nic_wol_virtue_add_impl(ddf_fun_t *fun, nic_wv_type_t type,
    521521        const void *data, size_t length, nic_wv_id_t *new_id)
    522522{
    … …  
    560560        }
    561561        /* Call the user-defined add callback */
    562         int rc = nic_data->on_wol_virtue_add(nic_data, virtue);
     562        errno_t rc = nic_data->on_wol_virtue_add(nic_data, virtue);
    563563        if (rc != EOK) {
    564564                free(virtue->data);
    … …  
    593593 * @return ENOENT       If the virtue identifier is not valid.
    594594 */
    595 int nic_wol_virtue_remove_impl(ddf_fun_t *fun, nic_wv_id_t id)
     595errno_t nic_wol_virtue_remove_impl(ddf_fun_t *fun, nic_wv_id_t id)
    596596{
    597597        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    … …  
    629629 * @return ENOMEM       If there was not enough memory to complete the operation
    630630 */
    631 int nic_wol_virtue_probe_impl(ddf_fun_t *fun, nic_wv_id_t id,
     631errno_t nic_wol_virtue_probe_impl(ddf_fun_t *fun, nic_wv_id_t id,
    632632        nic_wv_type_t *type, size_t max_length, void *data, size_t *length)
    633633{
    … …  
    667667 * @return ENOMEM       If there was not enough memory to complete the operation
    668668 */
    669 int nic_wol_virtue_list_impl(ddf_fun_t *fun, nic_wv_type_t type,
     669errno_t nic_wol_virtue_list_impl(ddf_fun_t *fun, nic_wv_type_t type,
    670670        size_t max_count, nic_wv_id_t *id_list, size_t *id_count)
    671671{
    672672        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    673673        fibril_rwlock_read_lock(&nic_data->wv_lock);
    674         int rc = nic_wol_virtues_list(&nic_data->wol_virtues, type,
     674        errno_t rc = nic_wol_virtues_list(&nic_data->wol_virtues, type,
    675675                max_count, id_list, id_count);
    676676        fibril_rwlock_read_unlock(&nic_data->wv_lock);
    … …  
    688688 * @return EOK          If the operation was successfully completed
    689689  */
    690 int nic_wol_virtue_get_caps_impl(ddf_fun_t *fun, nic_wv_type_t type, int *count)
     690errno_t nic_wol_virtue_get_caps_impl(ddf_fun_t *fun, nic_wv_type_t type, int *count)
    691691{
    692692        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    … …  
    710710 * @return EPARTY       Error in communication protocol
    711711 */
    712 int nic_poll_get_mode_impl(ddf_fun_t *fun,
     712errno_t nic_poll_get_mode_impl(ddf_fun_t *fun,
    713713        nic_poll_mode_t *mode, struct timeval *period)
    714714{
    … …  
    733733 * @return EPARTY       Error in communication protocol
    734734 */
    735 int nic_poll_set_mode_impl(ddf_fun_t *fun,
     735errno_t nic_poll_set_mode_impl(ddf_fun_t *fun,
    736736        nic_poll_mode_t mode, const struct timeval *period)
    737737{
    … …  
    754754        }
    755755        fibril_rwlock_write_lock(&nic_data->main_lock);
    756         int rc = nic_data->on_poll_mode_change(nic_data, mode, period);
     756        errno_t rc = nic_data->on_poll_mode_change(nic_data, mode, period);
    757757        assert(rc == EOK || rc == ENOTSUP || rc == EINVAL);
    758758        if (rc == ENOTSUP && (nic_data->on_poll_request != NULL) &&
    … …  
    783783 * @return EINVAL       If the NIC is not in state where it allows on demand polling
    784784 */
    785 int nic_poll_now_impl(ddf_fun_t *fun) {
     785errno_t nic_poll_now_impl(ddf_fun_t *fun) {
    786786        nic_t *nic_data = nic_get_from_ddf_fun(fun);
    787787        fibril_rwlock_read_lock(&nic_data->main_lock);
    … …  
    821821 * @return EOK always.
    822822 */
    823 int nic_open_impl(ddf_fun_t *fun)
     823errno_t nic_open_impl(ddf_fun_t *fun)
    824824{
    825825        return EOK;

  • uspace/lib/nic/src/nic_rx_control.c

    r36f0738 rb7fd2a0  
    5252 * @return EINVAL       Internal error, should not happen
    5353 */
    54 int nic_rxc_init(nic_rxc_t *rxc)
     54errno_t nic_rxc_init(nic_rxc_t *rxc)
    5555{
    5656        memset(rxc, 0, sizeof(nic_rxc_t));
    57         int rc;
     57        errno_t rc;
    5858        rc = nic_addr_db_init(&rxc->blocked_sources, ETH_ADDR);
    5959        if (rc != EOK) {
    … …  
    8484 * @param filters
    8585 */
    86 int nic_rxc_clear(nic_rxc_t *rxc)
     86errno_t nic_rxc_clear(nic_rxc_t *rxc)
    8787{
    8888        nic_addr_db_destroy(&rxc->unicast_addrs);
    … …  
    103103 *
    104104 */
    105 int nic_rxc_set_addr(nic_rxc_t *rxc, const nic_address_t *prev_addr,
     105errno_t nic_rxc_set_addr(nic_rxc_t *rxc, const nic_address_t *prev_addr,
    106106    const nic_address_t *curr_addr)
    107107{
    108108        if (prev_addr != NULL) {
    109                 int rc = nic_addr_db_remove(&rxc->unicast_addrs,
     109                errno_t rc = nic_addr_db_remove(&rxc->unicast_addrs,
    110110                    (const uint8_t *) &prev_addr->address);
    111111                if (rc != EOK)
    … …  
    173173 * @return ENOMEM       If there was not enough memory
    174174 */
    175 int nic_rxc_unicast_set_mode(nic_rxc_t *rxc, nic_unicast_mode_t mode,
     175errno_t nic_rxc_unicast_set_mode(nic_rxc_t *rxc, nic_unicast_mode_t mode,
    176176        const nic_address_t *address_list, size_t address_count)
    177177{
    … …  
    188188        size_t i;
    189189        for (i = 0; i < address_count; ++i) {
    190                 int rc = nic_addr_db_insert(&rxc->unicast_addrs,
     190                errno_t rc = nic_addr_db_insert(&rxc->unicast_addrs,
    191191                        (const uint8_t *) &address_list[i].address);
    192192                if (rc == ENOMEM) {
    … …  
    237237 * @return ENOMEM       If there was not enough memory
    238238 */
    239 int nic_rxc_multicast_set_mode(nic_rxc_t *rxc, nic_multicast_mode_t mode,
     239errno_t nic_rxc_multicast_set_mode(nic_rxc_t *rxc, nic_multicast_mode_t mode,
    240240        const nic_address_t *address_list, size_t address_count)
    241241{
    … …  
    251251        size_t i;
    252252        for (i = 0; i < address_count; ++i) {
    253                 int rc = nic_addr_db_insert(&rxc->multicast_addrs,
     253                errno_t rc = nic_addr_db_insert(&rxc->multicast_addrs,
    254254                        (const uint8_t *)&address_list[i].address);
    255255                if (rc == ENOMEM) {
    … …  
    279279 * @return EOK          On success
    280280 */
    281 int nic_rxc_broadcast_set_mode(nic_rxc_t *rxc, nic_broadcast_mode_t mode)
     281errno_t nic_rxc_broadcast_set_mode(nic_rxc_t *rxc, nic_broadcast_mode_t mode)
    282282{
    283283        rxc->broadcast_mode = mode;
    … …  
    320320 * @return ENOMEM       If there was not enough memory
    321321 */
    322 int nic_rxc_blocked_sources_set(nic_rxc_t *rxc,
     322errno_t nic_rxc_blocked_sources_set(nic_rxc_t *rxc,
    323323        const nic_address_t *address_list, size_t address_count)
    324324{
    … …  
    330330        size_t i;
    331331        for (i = 0; i < address_count; ++i) {
    332                 int rc = nic_addr_db_insert(&rxc->blocked_sources,
     332                errno_t rc = nic_addr_db_insert(&rxc->blocked_sources,
    333333                        (const uint8_t *) &address_list[i].address);
    334334                if (rc == ENOMEM) {
    … …  
    348348 * @return ENOENT
    349349 */
    350 int nic_rxc_vlan_get_mask(const nic_rxc_t *rxc, nic_vlan_mask_t *mask)
     350errno_t nic_rxc_vlan_get_mask(const nic_rxc_t *rxc, nic_vlan_mask_t *mask)
    351351{
    352352        if (rxc->vlan_mask == NULL) {
    … …  
    366366 * @return ENOMEM
    367367 */
    368 int nic_rxc_vlan_set_mask(nic_rxc_t *rxc, const nic_vlan_mask_t *mask)
     368errno_t nic_rxc_vlan_set_mask(nic_rxc_t *rxc, const nic_vlan_mask_t *mask)
    369369{
    370370        if (mask == NULL) {

  • uspace/lib/nic/src/nic_wol_virtues.c

    r36f0738 rb7fd2a0  
    7171 * @return ENOMEM       On not enough memory
    7272 */
    73 int nic_wol_virtues_init(nic_wol_virtues_t *wvs)
     73errno_t nic_wol_virtues_init(nic_wol_virtues_t *wvs)
    7474{
    7575        memset(wvs, 0, sizeof(nic_wol_virtues_t));
    … …  
    124124 * @return ENOTSUP      This type is unknown
    125125 */
    126 int nic_wol_virtues_verify(nic_wv_type_t type, const void *data, size_t length)
     126errno_t nic_wol_virtues_verify(nic_wv_type_t type, const void *data, size_t length)
    127127{
    128128        switch (type) {
    … …  
    160160 * @return ENOMEM       Not enough memory to activate the virtue
    161161 */
    162 int nic_wol_virtues_add(nic_wol_virtues_t *wvs, nic_wol_virtue_t *virtue)
     162errno_t nic_wol_virtues_add(nic_wol_virtues_t *wvs, nic_wol_virtue_t *virtue)
    163163{
    164164        if (!nic_wv_is_multi(virtue->type) &&
    … …  
    247247 * @return EINVAL       If the filter type is invalid
    248248 */
    249 int nic_wol_virtues_list(const nic_wol_virtues_t *wvs, nic_wv_type_t type,
     249errno_t nic_wol_virtues_list(const nic_wol_virtues_t *wvs, nic_wv_type_t type,
    250250        size_t max_count, nic_wv_id_t *id_list, size_t *id_count)
    251251{
Note: See TracChangeset for help on using the changeset viewer.