Changeset b7fd2a0 in mainline for uspace/lib/usbvirt/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/usbvirt/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbvirt/src/ctrltransfer.c

    r36f0738 rb7fd2a0  
    4949 * @retval EFORWARD No suitable handler found.
    5050 */
    51 int process_control_transfer(usbvirt_device_t *dev,
     51errno_t process_control_transfer(usbvirt_device_t *dev,
    5252    const usbvirt_control_request_handler_t *control_handlers,
    5353    const usb_device_request_setup_packet_t *setup,
    … …  
    7070                usb_log_debug("Control transfer: %s(%s)\n", handler->name,
    7171                    usb_debug_str_buffer((uint8_t*) setup, sizeof(*setup), 0));
    72                 int rc = handler->callback(dev, setup, data, data_sent_size);
     72                errno_t rc = handler->callback(dev, setup, data, data_sent_size);
    7373                if (rc != EFORWARD) {
    7474                        return rc;

  • uspace/lib/usbvirt/src/device.c

    r36f0738 rb7fd2a0  
    8282 * @return Error code.
    8383 */
    84 int usbvirt_device_plug(usbvirt_device_t *dev, const char *vhc_path)
     84errno_t usbvirt_device_plug(usbvirt_device_t *dev, const char *vhc_path)
    8585{
    8686        if (DEV != NULL)
    … …  
    8888       
    8989        devman_handle_t handle;
    90         int rc = devman_fun_get_handle(vhc_path, &handle, 0);
     90        errno_t rc = devman_fun_get_handle(vhc_path, &handle, 0);
    9191        if (rc != EOK)
    9292                return rc;

  • uspace/lib/usbvirt/src/ipc_dev.c

    r36f0738 rb7fd2a0  
    8181    ipc_callid_t iid, ipc_call_t *icall)
    8282{
    83         int rc;
     83        errno_t rc;
    8484
    8585        void *setup_packet = NULL;
    … …  
    137137{
    138138        size_t data_buffer_len = IPC_GET_ARG1(*icall);
    139         int rc;
     139        errno_t rc;
    140140
    141141        void *setup_packet = NULL;
    … …  
    183183        usb_endpoint_t endpoint = IPC_GET_ARG1(*icall);
    184184
    185         int rc;
     185        errno_t rc;
    186186
    187187        size_t data_len = 0;
    … …  
    230230        size_t data_buffer_size = 0;
    231231
    232         int rc = async_data_write_accept(&data_buffer, false,
     232        errno_t rc = async_data_write_accept(&data_buffer, false,
    233233            1, 0, 0, &data_buffer_size);
    234234        if (rc != EOK) {

  • uspace/lib/usbvirt/src/ipc_hc.c

    r36f0738 rb7fd2a0  
    5555 *
    5656 */
    57 int usbvirt_ipc_send_control_read(async_sess_t *sess, void *setup_buffer,
     57errno_t usbvirt_ipc_send_control_read(async_sess_t *sess, void *setup_buffer,
    5858    size_t setup_buffer_size, void *data_buffer, size_t data_buffer_size,
    5959    size_t *data_transfered_size)
    … …  
    7777        }
    7878       
    79         int rc = async_data_write_start(exch, setup_buffer, setup_buffer_size);
     79        errno_t rc = async_data_write_start(exch, setup_buffer, setup_buffer_size);
    8080        if (rc != EOK) {
    8181                async_exchange_end(exch);
    … …  
    9595        }
    9696       
    97         int data_request_rc;
    98         int opening_request_rc;
     97        errno_t data_request_rc;
     98        errno_t opening_request_rc;
    9999        async_wait_for(data_request, &data_request_rc);
    100100        async_wait_for(opening_request, &opening_request_rc);
    … …  
    103103                /* Prefer the return code of the opening request. */
    104104                if (opening_request_rc != EOK)
    105                         return (int) opening_request_rc;
     105                        return (errno_t) opening_request_rc;
    106106                else
    107                         return (int) data_request_rc;
     107                        return (errno_t) data_request_rc;
    108108        }
    109109       
    110110        if (opening_request_rc != EOK)
    111                 return (int) opening_request_rc;
     111                return (errno_t) opening_request_rc;
    112112       
    113113        if (data_transfered_size != NULL)
    … …  
    129129 *
    130130 */
    131 int usbvirt_ipc_send_control_write(async_sess_t *sess, void *setup_buffer,
     131errno_t usbvirt_ipc_send_control_write(async_sess_t *sess, void *setup_buffer,
    132132    size_t setup_buffer_size, void *data_buffer, size_t data_buffer_size)
    133133{
    … …  
    150150        }
    151151       
    152         int rc = async_data_write_start(exch, setup_buffer, setup_buffer_size);
     152        errno_t rc = async_data_write_start(exch, setup_buffer, setup_buffer_size);
    153153        if (rc != EOK) {
    154154                async_exchange_end(exch);
    … …  
    168168        async_exchange_end(exch);
    169169       
    170         int opening_request_rc;
     170        errno_t opening_request_rc;
    171171        async_wait_for(opening_request, &opening_request_rc);
    172172       
    173         return (int) opening_request_rc;
     173        return (errno_t) opening_request_rc;
    174174}
    175175
    … …  
    186186 *
    187187 */
    188 int usbvirt_ipc_send_data_in(async_sess_t *sess, usb_endpoint_t ep,
     188errno_t usbvirt_ipc_send_data_in(async_sess_t *sess, usb_endpoint_t ep,
    189189    usb_transfer_type_t tr_type, void *data, size_t data_size, size_t *act_size)
    190190{
    … …  
    230230        }
    231231       
    232         int data_request_rc;
    233         int opening_request_rc;
     232        errno_t data_request_rc;
     233        errno_t opening_request_rc;
    234234        async_wait_for(data_request, &data_request_rc);
    235235        async_wait_for(opening_request, &opening_request_rc);
    … …  
    238238                /* Prefer the return code of the opening request. */
    239239                if (opening_request_rc != EOK)
    240                         return (int) opening_request_rc;
     240                        return (errno_t) opening_request_rc;
    241241                else
    242                         return (int) data_request_rc;
     242                        return (errno_t) data_request_rc;
    243243        }
    244244       
    245245        if (opening_request_rc != EOK)
    246                 return (int) opening_request_rc;
     246                return (errno_t) opening_request_rc;
    247247       
    248248        if (act_size != NULL)
    … …  
    263263 *
    264264 */
    265 int usbvirt_ipc_send_data_out(async_sess_t *sess, usb_endpoint_t ep,
     265errno_t usbvirt_ipc_send_data_out(async_sess_t *sess, usb_endpoint_t ep,
    266266    usb_transfer_type_t tr_type, void *data, size_t data_size)
    267267{
    … …  
    296296        }
    297297       
    298         int rc = async_data_write_start(exch, data, data_size);
     298        errno_t rc = async_data_write_start(exch, data, data_size);
    299299       
    300300        async_exchange_end(exch);
    … …  
    305305        }
    306306       
    307         int opening_request_rc;
     307        errno_t opening_request_rc;
    308308        async_wait_for(opening_request, &opening_request_rc);
    309309       
    310         return (int) opening_request_rc;
     310        return (errno_t) opening_request_rc;
    311311}
    312312

  • uspace/lib/usbvirt/src/private.h

    r36f0738 rb7fd2a0  
    3838#include <usbvirt/device.h>
    3939
    40 int process_control_transfer(usbvirt_device_t *,
     40errno_t process_control_transfer(usbvirt_device_t *,
    4141    const usbvirt_control_request_handler_t *,
    4242    const usb_device_request_setup_packet_t *,

  • uspace/lib/usbvirt/src/stdreq.c

    r36f0738 rb7fd2a0  
    6666
    6767/** NOP handler */
    68 int req_nop(usbvirt_device_t *device,
     68errno_t req_nop(usbvirt_device_t *device,
    6969    const usb_device_request_setup_packet_t *setup_packet,
    7070    uint8_t *data, size_t *act_size)
    … …  
    7474
    7575/** GET_DESCRIPTOR handler. */
    76 static int req_get_descriptor(usbvirt_device_t *device,
     76static errno_t req_get_descriptor(usbvirt_device_t *device,
    7777    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
    7878{
    … …  
    135135}
    136136
    137 static int req_set_address(usbvirt_device_t *device,
     137static errno_t req_set_address(usbvirt_device_t *device,
    138138    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
    139139{
    … …  
    155155}
    156156
    157 static int req_set_configuration(usbvirt_device_t *device,
     157static errno_t req_set_configuration(usbvirt_device_t *device,
    158158    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
    159159{
    … …  
    197197}
    198198
    199 static int req_get_dev_status(usbvirt_device_t *device,
     199static errno_t req_get_dev_status(usbvirt_device_t *device,
    200200    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
    201201{
    … …  
    207207        return EOK;
    208208}
    209 static int req_get_iface_ep_status(usbvirt_device_t *device,
     209static errno_t req_get_iface_ep_status(usbvirt_device_t *device,
    210210    const usb_device_request_setup_packet_t *setup_packet, uint8_t *data, size_t *act_size)
    211211{

  • uspace/lib/usbvirt/src/transfer.c

    r36f0738 rb7fd2a0  
    5050 * @return Error code.
    5151 */
    52 static int usbvirt_control_transfer(usbvirt_device_t *dev,
     52static errno_t usbvirt_control_transfer(usbvirt_device_t *dev,
    5353    const void *setup, size_t setup_size,
    5454    void *data, size_t data_size, size_t *data_size_sent)
    … …  
    6565        }
    6666
    67         int rc;
     67        errno_t rc;
    6868
    6969        /* Run user handler first. */
    … …  
    100100 * @return Error code.
    101101 */
    102 int usbvirt_control_write(usbvirt_device_t *dev, const void *setup,
     102errno_t usbvirt_control_write(usbvirt_device_t *dev, const void *setup,
    103103    size_t setup_size, void *data, size_t data_size)
    104104{
    … …  
    119119 * @return Error code.
    120120 */
    121 int usbvirt_control_read(usbvirt_device_t *dev, const void *setup, size_t setup_size,
     121errno_t usbvirt_control_read(usbvirt_device_t *dev, const void *setup, size_t setup_size,
    122122    void *data, size_t data_size, size_t *data_size_sent)
    123123{
    … …  
    135135 * @return Error code.
    136136 */
    137 int usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
     137errno_t usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
    138138    usb_endpoint_t endpoint, const void *data, size_t data_size)
    139139{
    … …  
    145145        }
    146146
    147         int rc = dev->ops->data_out[endpoint](dev, endpoint, transf_type,
     147        errno_t rc = dev->ops->data_out[endpoint](dev, endpoint, transf_type,
    148148            data, data_size);
    149149
    … …  
    161161 * @return Error code.
    162162 */
    163 int usbvirt_data_in(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
     163errno_t usbvirt_data_in(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
    164164    usb_endpoint_t endpoint, void *data, size_t data_size, size_t *data_size_sent)
    165165{
    … …  
    172172
    173173        size_t data_size_sent_tmp;
    174         int rc = dev->ops->data_in[endpoint](dev, endpoint, transf_type,
     174        errno_t rc = dev->ops->data_in[endpoint](dev, endpoint, transf_type,
    175175            data, data_size, &data_size_sent_tmp);
    176176

  • uspace/lib/usbvirt/src/virthub_base.c

    r36f0738 rb7fd2a0  
    5454}
    5555
    56 int virthub_base_init(virthub_base_t *instance, const char *name,
     56errno_t virthub_base_init(virthub_base_t *instance, const char *name,
    5757    usbvirt_device_ops_t *ops, void *data,
    5858    const usb_standard_device_descriptor_t *device_desc,
    … …  
    109109}
    110110
    111 int virthub_base_request(virthub_base_t *instance, usb_target_t target,
     111errno_t virthub_base_request(virthub_base_t *instance, usb_target_t target,
    112112    usb_direction_t dir, const usb_device_request_setup_packet_t *setup,
    113113    void *buffer, size_t buffer_size, size_t *real_size)
    … …  
    143143}
    144144
    145 int virthub_base_get_hub_descriptor(usbvirt_device_t *dev,
     145errno_t virthub_base_get_hub_descriptor(usbvirt_device_t *dev,
    146146    const usb_device_request_setup_packet_t *request, uint8_t *data,
    147147    size_t *act_size)
    … …  
    159159}
    160160
    161 int virthub_base_get_null_status(usbvirt_device_t *dev,
     161errno_t virthub_base_get_null_status(usbvirt_device_t *dev,
    162162    const usb_device_request_setup_packet_t *request, uint8_t *data,
    163163    size_t *act_size)
Note: See TracChangeset for help on using the changeset viewer.