Changes in / [1a9174e:d3b2ffa] in mainline


Ignore:
Files:
1 added
23 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r1a9174e rd3b2ffa  
    494494
    495495% Support for NS16550 controller (kernel console)
    496 ! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=serial|CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&(PLATFORM=ia32|PLATFORM=amd64)] CONFIG_NS16550_KCON (n/y)
     496! [(CONFIG_HID_IN=generic|CONFIG_HID_IN=serial|CONFIG_HID_OUT=generic|CONFIG_HID_OUT=serial)&(PLATFORM=ia32|PLATFORM=amd64)] CONFIG_NS16550_KCON (y/n)
    497497
    498498% Use NS16550 controller as serial input (kernel console)

  • kernel/generic/include/synch/waitq.h

    r1a9174e rd3b2ffa  
    8282extern void _waitq_wakeup_unsafe(waitq_t *, wakeup_mode_t);
    8383extern void waitq_interrupt_sleep(struct thread *);
    84 extern void waitq_unsleep(waitq_t *);
    8584extern int waitq_count_get(waitq_t *);
    8685extern void waitq_count_set(waitq_t *, int val);

  • kernel/generic/src/ipc/ipc.c

    r1a9174e rd3b2ffa  
    550550        errno_t rc;
    551551
    552 restart:
    553552        rc = waitq_sleep_timeout(&box->wq, usec, flags, NULL);
    554553        if (rc != EOK)
    … …  
    590589                list_append(&request->ab_link, &box->dispatched_calls);
    591590        } else {
    592                 /* This can happen regularly after ipc_cleanup */
     591                /*
     592                 * This can happen regularly after ipc_cleanup, or in
     593                 * response to ipc_poke(). Let the caller sort out the wakeup.
     594                 */
    593595                irq_spinlock_unlock(&box->lock, true);
    594                 goto restart;
     596                return NULL;
    595597        }
    596598

  • kernel/generic/src/ipc/sysipc.c

    r1a9174e rd3b2ffa  
    856856sys_errno_t sys_ipc_poke(void)
    857857{
    858         waitq_unsleep(&TASK->answerbox.wq);
     858        waitq_wakeup(&TASK->answerbox.wq, WAKEUP_FIRST);
    859859        return EOK;
    860860}

  • kernel/generic/src/synch/waitq.c

    r1a9174e rd3b2ffa  
    190190        if (do_wakeup)
    191191                thread_ready(thread);
    192 }
    193 
    194 /** Interrupt the first thread sleeping in the wait queue.
    195  *
    196  * Note that the caller somehow needs to know that the thread to be interrupted
    197  * is sleeping interruptibly.
    198  *
    199  * @param wq Pointer to wait queue.
    200  *
    201  */
    202 void waitq_unsleep(waitq_t *wq)
    203 {
    204         irq_spinlock_lock(&wq->lock, true);
    205 
    206         if (!list_empty(&wq->sleepers)) {
    207                 thread_t *thread = list_get_instance(list_first(&wq->sleepers),
    208                     thread_t, wq_link);
    209 
    210                 irq_spinlock_lock(&thread->lock, false);
    211 
    212                 assert(thread->sleep_interruptible);
    213 
    214                 if ((thread->timeout_pending) &&
    215                     (timeout_unregister(&thread->sleep_timeout)))
    216                         thread->timeout_pending = false;
    217 
    218                 list_remove(&thread->wq_link);
    219                 thread->saved_context = thread->sleep_interruption_context;
    220                 thread->sleep_queue = NULL;
    221 
    222                 irq_spinlock_unlock(&thread->lock, false);
    223                 thread_ready(thread);
    224         }
    225 
    226         irq_spinlock_unlock(&wq->lock, true);
    227192}
    228193

  • tools/ew.py

    r1a9174e rd3b2ffa  
    217217                cmdline += ' -nographic'
    218218
     219        if ((not is_override('nographic')) and not is_override('noserial')):
     220                cmdline += ' -serial stdio'
     221
    219222        if (is_override('bigmem')):
    220223                cmdline += ' -m 4G'
    … …  
    343346        print("-notablet\tDisable USB tablet (use only relative-position PS/2 mouse instead), if applicable.")
    344347        print("-nographic\tDisable graphical output. Serial port output must be enabled for this to be useful.")
     348        print("-noserial\tDisable serial port output in the terminal.")
    345349        print("-bigmem\tSets maximum RAM size to 4GB.")
    346350
    … …  
    401405                elif sys.argv[i] == '-bigmem':
    402406                        overrides['bigmem'] = True
     407                elif sys.argv[i] == '-noserial':
     408                        overrides['noserial'] = True
    403409                elif sys.argv[i] == '-qemu_path' and i < len(sys.argv) - 1:
    404410                        expect_qemu = True

  • uspace/app/stats/stats.c

    r1a9174e rd3b2ffa  
    3838#include <stdio.h>
    3939#include <task.h>
    40 #include <thread.h>
    4140#include <stats.h>
    4241#include <errno.h>

  • uspace/app/top/top.c

    r1a9174e rd3b2ffa  
    3939#include <stdlib.h>
    4040#include <task.h>
    41 #include <thread.h>
    4241#include <sys/time.h>
    4342#include <errno.h>

  • uspace/drv/bus/usb/xhci/endpoint.c

    r1a9174e rd3b2ffa  
    102102        if (dev->speed >= USB_SPEED_HIGH ||
    103103            ep->transfer_type != USB_TRANSFER_INTERRUPT) {
     104
     105                // XXX: According to the spec, the interval should be
     106                //      from [1, 16]. However, in QEMU, we get 0 here
     107                //      (a QEMU bug?).
     108                if (xhci_ep->interval == 0)
     109                        xhci_ep->interval = 8;
     110
    104111                xhci_ep->interval = 1 << (xhci_ep->interval - 1);
    105112        }

  • uspace/drv/nic/virtio-net/virtio-net.c

    r1a9174e rd3b2ffa  
    7070};
    7171
    72 /** Allocate DMA buffers
    73  *
    74  * @param buffers[in]  Number of buffers to allocate.
    75  * @param size[in]     Size of each buffer.
    76  * @param write[in]    True if the buffers are writable by the driver, false
    77  *                     otherwise.
    78  * @param buf[out]     Output array holding virtual addresses of the allocated
    79  *                     buffers.
    80  * @param buf_p[out]   Output array holding physical addresses of the allocated
    81  *                     buffers.
    82  *
    83  * The buffers can be deallocated by virtio_net_teardown_bufs().
    84  *
    85  * @return  EOK on success or error code.
    86  */
    87 static errno_t virtio_net_setup_bufs(unsigned int buffers, size_t size,
    88     bool write, void *buf[], uintptr_t buf_p[])
    89 {
    90         /*
    91          * Allocate all buffers at once in one large chunk.
    92          */
    93         void *virt = AS_AREA_ANY;
    94         uintptr_t phys;
    95         errno_t rc = dmamem_map_anonymous(buffers * size, 0,
    96             write ? AS_AREA_WRITE : AS_AREA_READ, 0, &phys, &virt);
    97         if (rc != EOK)
    98                 return rc;
    99 
    100         ddf_msg(LVL_NOTE, "DMA buffers: %p-%p", virt, virt + buffers * size);
    101 
    102         /*
    103          * Calculate addresses of the individual buffers for easy access.
    104          */
    105         for (unsigned i = 0; i < buffers; i++) {
    106                 buf[i] = virt + i * size;
    107                 buf_p[i] = phys + i * size;
    108         }
    109 
    110         return EOK;
    111 }
    112 
    113 /** Deallocate DMA buffers
    114  *
    115  * @param buf[in]  Array holding the virtual addresses of the DMA buffers
    116  *                 previously allocated by virtio_net_setup_bufs().
    117  */
    118 static void virtio_net_teardown_bufs(void *buf[])
    119 {
    120         if (buf[0]) {
    121                 dmamem_unmap_anonymous(buf[0]);
    122                 buf[0] = NULL;
    123         }
    124 }
    125 
    126 /** Create free descriptor list from the unused VIRTIO descriptors
    127  *
    128  * @param vdev[in]   VIRTIO device for which the free list will be created.
    129  * @param num[in]    Index of the virtqueue for which the free list will be
    130  *                   created.
    131  * @param size[in]   Number of descriptors on the free list. The free list will
    132  *                   contain descriptors starting from 0 to \a size - 1.
    133  * @param head[out]  Variable that will hold the VIRTIO descriptor at the head
    134  *                   of the free list.
    135  */
    136 static void virtio_net_create_desc_free_list(virtio_dev_t *vdev, uint16_t num,
    137     uint16_t size, uint16_t *head)
    138 {
    139         for (unsigned i = 0; i < size; i++) {
    140                 virtio_virtq_desc_set(vdev, num, i, 0, 0,
    141                     VIRTQ_DESC_F_NEXT, (i + 1 == size) ? -1U : i + 1);
    142         }
    143         *head = 0;
    144 }
    145 
    146 /** Allocate a descriptor from the free list
    147  *
    148  * @param vdev[in]      VIRTIO device with the free list.
    149  * @param num[in]       Index of the virtqueue with free list.
    150  * @param head[in,out]  Head of the free list.
    151  *
    152  * @return  Allocated descriptor or 0xFFFF if the list is empty.
    153  */
    154 static uint16_t virtio_net_alloc_desc(virtio_dev_t *vdev, uint16_t num,
    155     uint16_t *head)
    156 {
    157         virtq_t *q = &vdev->queues[num];
    158         fibril_mutex_lock(&q->lock);
    159         uint16_t descno = *head;
    160         if (descno != (uint16_t) -1U)
    161                 *head = virtio_virtq_desc_get_next(vdev, num, descno);
    162         fibril_mutex_unlock(&q->lock);
    163         return descno;
    164 }
    165 
    166 /** Free a descriptor into the free list
    167  *
    168  * @param vdev[in]      VIRTIO device with the free list.
    169  * @param num[in]       Index of the virtqueue with free list.
    170  * @param head[in,out]  Head of the free list.
    171  * @param descno[in]    The freed descriptor.
    172  */
    173 static void virtio_net_free_desc(virtio_dev_t *vdev, uint16_t num,
    174     uint16_t *head, uint16_t descno)
    175 {
    176         virtq_t *q = &vdev->queues[num];
    177         fibril_mutex_lock(&q->lock);
    178         virtio_virtq_desc_set(vdev, num, descno, 0, 0, VIRTQ_DESC_F_NEXT,
    179             *head);
    180         *head = descno;
    181         fibril_mutex_unlock(&q->lock);
    182 }
    183 
    18472static void virtio_net_irq_handler(ipc_call_t *icall, ddf_dev_t *dev)
    18573{
    … …  
    214102
    215103        while (virtio_virtq_consume_used(vdev, TX_QUEUE_1, &descno, &len)) {
    216                 virtio_net_free_desc(vdev, TX_QUEUE_1,
    217                     &virtio_net->tx_free_head, descno);
     104                virtio_free_desc(vdev, TX_QUEUE_1, &virtio_net->tx_free_head,
     105                    descno);
    218106        }
    219107        while (virtio_virtq_consume_used(vdev, CT_QUEUE_1, &descno, &len)) {
    220                 virtio_net_free_desc(vdev, CT_QUEUE_1,
    221                     &virtio_net->ct_free_head, descno);
     108                virtio_free_desc(vdev, CT_QUEUE_1, &virtio_net->ct_free_head,
     109                    descno);
    222110        }
    223111}
    … …  
    345233         * Setup DMA buffers
    346234         */
    347         rc = virtio_net_setup_bufs(RX_BUFFERS, RX_BUF_SIZE, false,
     235        rc = virtio_setup_dma_bufs(RX_BUFFERS, RX_BUF_SIZE, false,
    348236            virtio_net->rx_buf, virtio_net->rx_buf_p);
    349237        if (rc != EOK)
    350238                goto fail;
    351         rc = virtio_net_setup_bufs(TX_BUFFERS, TX_BUF_SIZE, true,
     239        rc = virtio_setup_dma_bufs(TX_BUFFERS, TX_BUF_SIZE, true,
    352240            virtio_net->tx_buf, virtio_net->tx_buf_p);
    353241        if (rc != EOK)
    354242                goto fail;
    355         rc = virtio_net_setup_bufs(CT_BUFFERS, CT_BUF_SIZE, true,
     243        rc = virtio_setup_dma_bufs(CT_BUFFERS, CT_BUF_SIZE, true,
    356244            virtio_net->ct_buf, virtio_net->ct_buf_p);
    357245        if (rc != EOK)
    … …  
    379267         * Put all TX and CT buffers on a free list
    380268         */
    381         virtio_net_create_desc_free_list(vdev, TX_QUEUE_1, TX_BUFFERS,
     269        virtio_create_desc_free_list(vdev, TX_QUEUE_1, TX_BUFFERS,
    382270            &virtio_net->tx_free_head);
    383         virtio_net_create_desc_free_list(vdev, CT_QUEUE_1, CT_BUFFERS,
     271        virtio_create_desc_free_list(vdev, CT_QUEUE_1, CT_BUFFERS,
    384272            &virtio_net->ct_free_head);
    385273
    … …  
    414302
    415303fail:
    416         virtio_net_teardown_bufs(virtio_net->rx_buf);
    417         virtio_net_teardown_bufs(virtio_net->tx_buf);
    418         virtio_net_teardown_bufs(virtio_net->ct_buf);
     304        virtio_teardown_dma_bufs(virtio_net->rx_buf);
     305        virtio_teardown_dma_bufs(virtio_net->tx_buf);
     306        virtio_teardown_dma_bufs(virtio_net->ct_buf);
    419307
    420308        virtio_device_setup_fail(vdev);
    … …  
    428316        virtio_net_t *virtio_net = (virtio_net_t *) nic_get_specific(nic);
    429317
    430         virtio_net_teardown_bufs(virtio_net->rx_buf);
    431         virtio_net_teardown_bufs(virtio_net->tx_buf);
    432         virtio_net_teardown_bufs(virtio_net->ct_buf);
     318        virtio_teardown_dma_bufs(virtio_net->rx_buf);
     319        virtio_teardown_dma_bufs(virtio_net->tx_buf);
     320        virtio_teardown_dma_bufs(virtio_net->ct_buf);
    433321
    434322        virtio_device_setup_fail(&virtio_net->virtio_dev);
    … …  
    446334        }
    447335
    448         uint16_t descno = virtio_net_alloc_desc(vdev, TX_QUEUE_1,
     336        uint16_t descno = virtio_alloc_desc(vdev, TX_QUEUE_1,
    449337            &virtio_net->tx_free_head);
    450338        if (descno == (uint16_t) -1U) {

  • uspace/lib/c/generic/async/ports.c

    r1a9174e rd3b2ffa  
    3535#include <ipc/irq.h>
    3636#include <ipc/event.h>
    37 #include <futex.h>
    3837#include <fibril.h>
    3938#include <adt/hash_table.h>

  • uspace/lib/c/generic/async/server.c

    r1a9174e rd3b2ffa  
    122122#include "../private/fibril.h"
    123123
     124#define DPRINTF(...)  ((void) 0)
     125
    124126/** Async framework global futex */
    125127futex_t async_futex = FUTEX_INITIALIZER;
    … …  
    132134        link_t link;
    133135
    134         cap_call_handle_t chandle;
    135136        ipc_call_t call;
    136137} msg_t;
    … …  
    164165        list_t msg_queue;
    165166
    166         /** Identification of the opening call. */
    167         cap_call_handle_t chandle;
    168 
    169167        /** Call data of the opening call. */
    170168        ipc_call_t call;
    … …  
    179177        void *data;
    180178} connection_t;
     179
     180/* Member of notification_t::msg_list. */
     181typedef struct {
     182        link_t link;
     183        ipc_call_t calldata;
     184} notification_msg_t;
    181185
    182186/* Notification data */
    … …  
    197201        void *arg;
    198202
    199         /** Data of the most recent notification. */
    200         ipc_call_t calldata;
    201 
    202         /**
    203          * How many notifications with this `imethod` arrived since it was last
    204          * handled. If `count` > 1, `calldata` only holds the data for the most
    205          * recent such notification, all the older data being lost.
    206          *
    207          * `async_spawn_notification_handler()` can be used to increase the
    208          * number of notifications that can be processed simultaneously,
    209          * reducing the likelihood of losing them when the handler blocks.
    210          */
    211         long count;
     203        /** List of arrived notifications. */
     204        list_t msg_list;
    212205} notification_t;
    213206
    … …  
    249242static LIST_INITIALIZE(notification_queue);
    250243static FIBRIL_SEMAPHORE_INITIALIZE(notification_semaphore, 0);
     244
     245static LIST_INITIALIZE(notification_freelist);
     246static long notification_freelist_total = 0;
     247static long notification_freelist_used = 0;
    251248
    252249static sysarg_t notification_avail = 0;
    … …  
    412409        client_t *client = async_client_get(fibril_connection->in_task_id, true);
    413410        if (!client) {
    414                 ipc_answer_0(fibril_connection->chandle, ENOMEM);
     411                ipc_answer_0(fibril_connection->call.cap_handle, ENOMEM);
    415412                return 0;
    416413        }
    … …  
    421418         * Call the connection handler function.
    422419         */
    423         fibril_connection->handler(fibril_connection->chandle,
     420        fibril_connection->handler(fibril_connection->call.cap_handle,
    424421            &fibril_connection->call, fibril_connection->data);
    425422
    … …  
    448445
    449446                list_remove(&msg->link);
    450                 ipc_answer_0(msg->chandle, EHANGUP);
     447                ipc_answer_0(msg->call.cap_handle, EHANGUP);
    451448                free(msg);
    452449        }
    … …  
    471468 * @param in_task_id     Identification of the incoming connection.
    472469 * @param in_phone_hash  Identification of the incoming connection.
    473  * @param chandle        Handle of the opening IPC_M_CONNECT_ME_TO call.
    474  *                       If chandle is CAP_NIL, the connection was opened by
    475  *                       accepting the IPC_M_CONNECT_TO_ME call and this
    476  *                       function is called directly by the server.
    477  * @param call           Call data of the opening call.
     470 * @param call           Call data of the opening call. If call is NULL,
     471 *                       the connection was opened by accepting the
     472 *                       IPC_M_CONNECT_TO_ME call and this function is
     473 *                       called directly by the server.
    478474 * @param handler        Connection handler.
    479475 * @param data           Client argument to pass to the connection handler.
    … …  
    483479 */
    484480static fid_t async_new_connection(task_id_t in_task_id, sysarg_t in_phone_hash,
    485     cap_call_handle_t chandle, ipc_call_t *call, async_port_handler_t handler,
    486     void *data)
     481    ipc_call_t *call, async_port_handler_t handler, void *data)
    487482{
    488483        connection_t *conn = malloc(sizeof(*conn));
    489484        if (!conn) {
    490                 if (chandle != CAP_NIL)
    491                         ipc_answer_0(chandle, ENOMEM);
     485                if (call)
     486                        ipc_answer_0(call->cap_handle, ENOMEM);
    492487
    493488                return (uintptr_t) NULL;
    … …  
    497492        conn->in_phone_hash = in_phone_hash;
    498493        list_initialize(&conn->msg_queue);
    499         conn->chandle = chandle;
    500494        conn->close_chandle = CAP_NIL;
    501495        conn->handler = handler;
    … …  
    504498        if (call)
    505499                conn->call = *call;
     500        else
     501                conn->call.cap_handle = CAP_NIL;
    506502
    507503        /* We will activate the fibril ASAP */
    … …  
    512508                free(conn);
    513509
    514                 if (chandle != CAP_NIL)
    515                         ipc_answer_0(chandle, ENOMEM);
     510                if (call)
     511                        ipc_answer_0(call->cap_handle, ENOMEM);
    516512
    517513                return (uintptr_t) NULL;
    … …  
    568564        sysarg_t phone_hash = IPC_GET_ARG5(answer);
    569565        fid_t fid = async_new_connection(answer.in_task_id, phone_hash,
    570             CAP_NIL, NULL, handler, data);
     566            NULL, handler, data);
    571567        if (fid == (uintptr_t) NULL)
    572568                return ENOMEM;
    … …  
    637633 * timeouts are unregistered.
    638634 *
    639  * @param chandle  Handle of the incoming call.
    640  * @param call     Data of the incoming call.
     635 * @param call Data of the incoming call.
    641636 *
    642637 * @return False if the call doesn't match any connection.
    … …  
    644639 *
    645640 */
    646 static bool route_call(cap_call_handle_t chandle, ipc_call_t *call)
     641static bool route_call(ipc_call_t *call)
    647642{
    648643        assert(call);
    … …  
    667662        }
    668663
    669         msg->chandle = chandle;
    670664        msg->call = *call;
    671665        list_append(&msg->link, &conn->msg_queue);
    672666
    673667        if (IPC_GET_IMETHOD(*call) == IPC_M_PHONE_HUNGUP)
    674                 conn->close_chandle = chandle;
     668                conn->close_chandle = call->cap_handle;
    675669
    676670        /* If the connection fibril is waiting for an event, activate it */
    … …  
    709703                notification_t *notification = list_get_instance(
    710704                    list_first(&notification_queue), notification_t, qlink);
    711                 list_remove(&notification->qlink);
    712705
    713706                async_notification_handler_t handler = notification->handler;
    714707                void *arg = notification->arg;
    715                 ipc_call_t calldata = notification->calldata;
    716                 long count = notification->count;
    717 
    718                 notification->count = 0;
     708
     709                notification_msg_t *m = list_pop(&notification->msg_list,
     710                    notification_msg_t, link);
     711                assert(m);
     712                ipc_call_t calldata = m->calldata;
     713
     714                notification_freelist_used--;
     715
     716                if (notification_freelist_total > 64 &&
     717                    notification_freelist_total > 2 * notification_freelist_used) {
     718                        /* Going to free the structure if we have too much. */
     719                        notification_freelist_total--;
     720                } else {
     721                        /* Otherwise add to freelist. */
     722                        list_append(&m->link, &notification_freelist);
     723                        m = NULL;
     724                }
     725
     726                if (list_empty(&notification->msg_list))
     727                        list_remove(&notification->qlink);
    719728
    720729                futex_unlock(&notification_futex);
    721 
    722                 // FIXME: Pass count to the handler. It might be important.
    723                 (void) count;
    724730
    725731                if (handler)
    726732                        handler(&calldata, arg);
     733
     734                free(m);
    727735        }
    728736
    … …  
    760768        futex_lock(&notification_futex);
    761769
     770        notification_msg_t *m = list_pop(&notification_freelist,
     771            notification_msg_t, link);
     772
     773        if (!m) {
     774                futex_unlock(&notification_futex);
     775                m = malloc(sizeof(notification_msg_t));
     776                if (!m) {
     777                        DPRINTF("Out of memory.\n");
     778                        abort();
     779                }
     780
     781                futex_lock(&notification_futex);
     782                notification_freelist_total++;
     783        }
     784
    762785        ht_link_t *link = hash_table_find(&notification_hash_table,
    763786            &IPC_GET_IMETHOD(*call));
    … …  
    765788                /* Invalid notification. */
    766789                // TODO: Make sure this can't happen and turn it into assert.
     790                notification_freelist_total--;
    767791                futex_unlock(&notification_futex);
     792                free(m);
    768793                return;
    769794        }
    … …  
    772797            hash_table_get_inst(link, notification_t, htlink);
    773798
    774         notification->count++;
    775         notification->calldata = *call;
    776 
    777         if (link_in_use(&notification->qlink)) {
    778                 /* Notification already queued. */
    779                 futex_unlock(&notification_futex);
    780                 return;
    781         }
    782 
    783         list_append(&notification->qlink, &notification_queue);
     799        notification_freelist_used++;
     800        m->calldata = *call;
     801        list_append(&m->link, &notification->msg_list);
     802
     803        if (!link_in_use(&notification->qlink))
     804                list_append(&notification->qlink, &notification_queue);
     805
    784806        futex_unlock(&notification_futex);
    785807
    … …  
    802824        notification->handler = handler;
    803825        notification->arg = arg;
     826
     827        list_initialize(&notification->msg_list);
    804828
    805829        fid_t fib = 0;
    … …  
    10111035        list_remove(&msg->link);
    10121036
    1013         cap_call_handle_t chandle = msg->chandle;
     1037        cap_call_handle_t chandle = msg->call.cap_handle;
    10141038        *call = msg->call;
    10151039        free(msg);
    … …  
    10581082 * Otherwise the call is routed to its connection fibril.
    10591083 *
    1060  * @param chandle  Handle of the incoming call.
    1061  * @param call     Data of the incoming call.
    1062  *
    1063  */
    1064 static void handle_call(cap_call_handle_t chandle, ipc_call_t *call)
     1084 * @param call Data of the incoming call.
     1085 *
     1086 */
     1087static void handle_call(ipc_call_t *call)
    10651088{
    10661089        assert(call);
    … …  
    10691092                return;
    10701093
    1071         if (chandle == CAP_NIL) {
     1094        if (call->cap_handle == CAP_NIL) {
    10721095                if (call->flags & IPC_CALL_NOTIF) {
    10731096                        /* Kernel notification */
    … …  
    10871110                    async_get_port_handler(iface, 0, &data);
    10881111
    1089                 async_new_connection(call->in_task_id, in_phone_hash, chandle,
    1090                     call, handler, data);
     1112                async_new_connection(call->in_task_id, in_phone_hash, call,
     1113                    handler, data);
    10911114                return;
    10921115        }
    10931116
    10941117        /* Try to route the call through the connection hash table */
    1095         if (route_call(chandle, call))
     1118        if (route_call(call))
    10961119                return;
    10971120
    10981121        /* Unknown call from unknown phone - hang it up */
    1099         ipc_answer_0(chandle, EHANGUP);
     1122        ipc_answer_0(call->cap_handle, EHANGUP);
    11001123}
    11011124
    … …  
    11781201
    11791202                assert(rc == EOK);
    1180                 handle_call(call.cap_handle, &call);
     1203                handle_call(&call);
    11811204        }
    11821205
    … …  
    18471870}
    18481871
    1849 _Noreturn void async_manager(void)
     1872__noreturn void async_manager(void)
    18501873{
    18511874        futex_lock(&async_futex);

  • uspace/lib/c/generic/fibril_synch.c

    r1a9174e rd3b2ffa  
    4444#include <stdlib.h>
    4545#include <stdio.h>
     46#include <io/kio.h>
     47
    4648#include "private/async.h"
    4749#include "private/fibril.h"
     50
     51static fibril_local bool deadlocked = false;
    4852
    4953static void optimize_execution_power(void)
    … …  
    6266{
    6367        fibril_t *f = (fibril_t *) fibril_get_id();
     68
     69        if (deadlocked) {
     70                kio_printf("Deadlock detected while printing deadlock. Aborting.\n");
     71                abort();
     72        }
     73        deadlocked = true;
    6474
    6575        printf("Deadlock detected.\n");

  • uspace/lib/c/generic/ubsan.c

    r1a9174e rd3b2ffa  
    9898#endif
    9999void __ubsan_handle_nonnull_return(struct nonnull_return_data *data);
     100void __ubsan_handle_builtin_unreachable(struct unreachable_data *data);
    100101
    101102static void print_loc(const char *func, struct source_location *loc)
    … …  
    107108                f += sizeof(func_prefix);
    108109
    109         PRINTF("Undefined behavior %s at %s:%" PRIu32 " col %" PRIu32 "\n",
     110        PRINTF("####### Undefined behavior %s at %s:%" PRIu32 " col %" PRIu32 "\n",
    110111            f, loc->file_name, loc->line, loc->column);
    111112}
    … …  
    115116{
    116117        print_loc(__func__, &data->loc);
     118        PRINTF("Type: %s, alignment: %lu, type_check_kind: %hhu\n",
     119            data->type->type_name, data->alignment, data->type_check_kind);
    117120        ubsan_panic();
    118121}
    … …  
    219222        ubsan_panic();
    220223}
     224
     225void __ubsan_handle_builtin_unreachable(struct unreachable_data *data)
     226{
     227        print_loc(__func__, &data->loc);
     228        ubsan_panic();
     229}
     230

  • uspace/lib/c/include/async.h

    r1a9174e rd3b2ffa  
    5151#include <abi/cap.h>
    5252
     53#include <_bits/__noreturn.h>
     54
    5355typedef sysarg_t aid_t;
    5456typedef sysarg_t port_id_t;
    … …  
    108110typedef struct async_exch async_exch_t;
    109111
    110 extern _Noreturn void async_manager(void);
     112extern __noreturn void async_manager(void);
    111113
    112114#define async_get_call(data) \

  • uspace/lib/c/include/futex.h

    r1a9174e rd3b2ffa  
    4545        atomic_t val;
    4646#ifdef CONFIG_DEBUG_FUTEX
    47         _Atomic void *owner;
     47        void *owner;
    4848#endif
    4949} futex_t;

  • uspace/lib/c/include/setjmp.h

    r1a9174e rd3b2ffa  
    3535
    3636#include <libarch/fibril_context.h>
     37#include <_bits/__noreturn.h>
    3738
    3839typedef context_t jmp_buf[1];
    3940
    4041extern int __setjmp(jmp_buf) __attribute__((returns_twice));
    41 extern _Noreturn void __longjmp(jmp_buf, int);
     42extern __noreturn void __longjmp(jmp_buf, int);
    4243
    4344#define setjmp __setjmp
    44 extern _Noreturn void longjmp(jmp_buf, int);
     45extern __noreturn void longjmp(jmp_buf, int);
    4546
    4647#endif

  • uspace/lib/drv/generic/remote_usb.c

    r1a9174e rd3b2ffa  
    7777                return EBADMEM;
    7878
    79         usb_device_desc_t tmp_desc;
     79        sysarg_t address, depth, speed, handle, iface;
    8080
    8181        const errno_t ret = async_req_1_5(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    82             IPC_M_USB_GET_MY_DESCRIPTION,
    83             (sysarg_t *) &tmp_desc.address,
    84             (sysarg_t *) &tmp_desc.depth,
    85             (sysarg_t *) &tmp_desc.speed,
    86             &tmp_desc.handle,
    87             (sysarg_t *) &tmp_desc.iface);
    88         if (ret == EOK && desc)
    89                 *desc = tmp_desc;
     82            IPC_M_USB_GET_MY_DESCRIPTION, &address, &depth, &speed, &handle,
     83            &iface);
     84        if (ret == EOK && desc) {
     85                *desc = (usb_device_desc_t) {
     86                        .address = address,
     87                        .depth = depth,
     88                        .speed = speed,
     89                        .handle = handle,
     90                        .iface = iface,
     91                };
     92        }
     93
    9094        return ret;
    9195}

  • uspace/lib/softfloat/common.c

    r1a9174e rd3b2ffa  
    252252        int j;
    253253        for (j = 0; j < 32; j += 8) {
    254                 if (i & (0xFF << (24 - j))) {
     254                if (i & (0xFFu << (24 - j))) {
    255255                        return (j + count_zeroes8(i >> (24 - j)));
    256256                }

  • uspace/lib/usb/include/usb/request.h

    r1a9174e rd3b2ffa  
    7575#define USB_SETUP_PACKET_SIZE 8
    7676
    77 /** Device request setup packet.
    78  * The setup packet describes the request.
    79  */
    80 typedef struct {
    81         /** Request type.
    82          * The type combines transfer direction, request type and
    83          * intended recipient.
    84          */
    85         uint8_t request_type;
    8677#define SETUP_REQUEST_TYPE_DEVICE_TO_HOST (1 << 7)
    8778#define SETUP_REQUEST_TYPE_HOST_TO_DEVICE (0 << 7)
    … …  
    9485    (uint8_t)(((type & 0x3) << 5) | (recipient & 0x1f))
    9586
    96         /** Request identification. */
    97         uint8_t request;
    98         /** Main parameter to the request. */
    99         union __attribute__((packed)) {
    100                 uint16_t value;
    101                 /* FIXME: add #ifdefs according to host endianness */
    102                 struct __attribute__((packed)) {
    103                         uint8_t value_low;
    104                         uint8_t value_high;
     87/** Device request setup packet.
     88 * The setup packet describes the request.
     89 */
     90typedef union {
     91        struct __attribute__((packed)) {
     92                /** Request type.
     93                 * The type combines transfer direction, request type and
     94                 * intended recipient.
     95                 */
     96                uint8_t request_type;
     97
     98                /** Request identification. */
     99                uint8_t request;
     100                /** Main parameter to the request. */
     101                union __attribute__((packed)) {
     102                        uint16_t value;
     103                        /* FIXME: add #ifdefs according to host endianness */
     104                        struct __attribute__((packed)) {
     105                                uint8_t value_low;
     106                                uint8_t value_high;
     107                        };
    105108                };
     109                /** Auxiliary parameter to the request.
     110                 * Typically, it is offset to something.
     111                 */
     112                uint16_t index;
     113                /** Length of extra data. */
     114                uint16_t length;
    106115        };
    107         /** Auxiliary parameter to the request.
    108          * Typically, it is offset to something.
    109          */
    110         uint16_t index;
    111         /** Length of extra data. */
    112         uint16_t length;
     116        uint64_t raw;
    113117} __attribute__((packed)) usb_device_request_setup_packet_t;
    114118

  • uspace/lib/usbhost/src/usb2_bus.c

    r1a9174e rd3b2ffa  
    142142        usb_log_debug("Device(%d): Setting USB address.", address);
    143143        err = bus_device_send_batch_sync(dev, usb2_default_target, USB_DIRECTION_OUT,
    144             NULL, 0, *(uint64_t *)&set_address, "set address", NULL);
     144            NULL, 0, set_address.raw, "set address", NULL);
    145145        if (err) {
    146146                usb_log_error("Device(%d): Failed to set new address: %s.",

  • uspace/lib/virtio/virtio-pci.h

    r1a9174e rd3b2ffa  
    181181} virtio_dev_t;
    182182
     183extern errno_t virtio_setup_dma_bufs(unsigned int, size_t, bool, void *[],
     184    uintptr_t []);
     185extern void virtio_teardown_dma_bufs(void *[]);
     186
    183187extern void virtio_virtq_desc_set(virtio_dev_t *vdev, uint16_t, uint16_t,
    184188    uint64_t, uint32_t, uint16_t, uint16_t);
    … …  
    186190    uint16_t);
    187191
     192extern void virtio_create_desc_free_list(virtio_dev_t *, uint16_t, uint16_t,
     193    uint16_t *);
     194extern uint16_t virtio_alloc_desc(virtio_dev_t *, uint16_t, uint16_t *);
     195extern void virtio_free_desc(virtio_dev_t *, uint16_t, uint16_t *, uint16_t);
     196
    188197extern void virtio_virtq_produce_available(virtio_dev_t *, uint16_t, uint16_t);
    189198extern bool virtio_virtq_consume_used(virtio_dev_t *, uint16_t, uint16_t *,

  • uspace/lib/virtio/virtio.c

    r1a9174e rd3b2ffa  
    3939#include <libarch/barrier.h>
    4040
     41/** Allocate DMA buffers
     42 *
     43 * @param buffers[in]  Number of buffers to allocate.
     44 * @param size[in]     Size of each buffer.
     45 * @param write[in]    True if the buffers are writable by the driver, false
     46 *                     otherwise.
     47 * @param buf[out]     Output array holding virtual addresses of the allocated
     48 *                     buffers.
     49 * @param buf_p[out]   Output array holding physical addresses of the allocated
     50 *                     buffers.
     51 *
     52 * The buffers can be deallocated by virtio_net_teardown_bufs().
     53 *
     54 * @return  EOK on success or error code.
     55 */
     56errno_t virtio_setup_dma_bufs(unsigned int buffers, size_t size,
     57    bool write, void *buf[], uintptr_t buf_p[])
     58{
     59        /*
     60         * Allocate all buffers at once in one large chunk.
     61         */
     62        void *virt = AS_AREA_ANY;
     63        uintptr_t phys;
     64        errno_t rc = dmamem_map_anonymous(buffers * size, 0,
     65            write ? AS_AREA_WRITE : AS_AREA_READ, 0, &phys, &virt);
     66        if (rc != EOK)
     67                return rc;
     68
     69        ddf_msg(LVL_NOTE, "DMA buffers: %p-%p", virt, virt + buffers * size);
     70
     71        /*
     72         * Calculate addresses of the individual buffers for easy access.
     73         */
     74        for (unsigned i = 0; i < buffers; i++) {
     75                buf[i] = virt + i * size;
     76                buf_p[i] = phys + i * size;
     77        }
     78
     79        return EOK;
     80}
     81
     82/** Deallocate DMA buffers
     83 *
     84 * @param buf[in]  Array holding the virtual addresses of the DMA buffers
     85 *                 previously allocated by virtio_net_setup_bufs().
     86 */
     87extern void virtio_teardown_dma_bufs(void *buf[])
     88{
     89        if (buf[0]) {
     90                dmamem_unmap_anonymous(buf[0]);
     91                buf[0] = NULL;
     92        }
     93}
     94
    4195void virtio_virtq_desc_set(virtio_dev_t *vdev, uint16_t num, uint16_t descno,
    4296    uint64_t addr, uint32_t len, uint16_t flags, uint16_t next)
    … …  
    57111        return pio_read_le16(&d->next);
    58112}
     113
     114/** Create free descriptor list from the unused VIRTIO descriptors
     115 *
     116 * @param vdev[in]   VIRTIO device for which the free list will be created.
     117 * @param num[in]    Index of the virtqueue for which the free list will be
     118 *                   created.
     119 * @param size[in]   Number of descriptors on the free list. The free list will
     120 *                   contain descriptors starting from 0 to \a size - 1.
     121 * @param head[out]  Variable that will hold the VIRTIO descriptor at the head
     122 *                   of the free list.
     123 */
     124void virtio_create_desc_free_list(virtio_dev_t *vdev, uint16_t num,
     125    uint16_t size, uint16_t *head)
     126{
     127        for (unsigned i = 0; i < size; i++) {
     128                virtio_virtq_desc_set(vdev, num, i, 0, 0,
     129                    VIRTQ_DESC_F_NEXT, (i + 1 == size) ? -1U : i + 1);
     130        }
     131        *head = 0;
     132}
     133
     134/** Allocate a descriptor from the free list
     135 *
     136 * @param vdev[in]      VIRTIO device with the free list.
     137 * @param num[in]       Index of the virtqueue with free list.
     138 * @param head[in,out]  Head of the free list.
     139 *
     140 * @return  Allocated descriptor or 0xFFFF if the list is empty.
     141 */
     142uint16_t virtio_alloc_desc(virtio_dev_t *vdev, uint16_t num, uint16_t *head)
     143{
     144        virtq_t *q = &vdev->queues[num];
     145        fibril_mutex_lock(&q->lock);
     146        uint16_t descno = *head;
     147        if (descno != (uint16_t) -1U)
     148                *head = virtio_virtq_desc_get_next(vdev, num, descno);
     149        fibril_mutex_unlock(&q->lock);
     150        return descno;
     151}
     152
     153/** Free a descriptor into the free list
     154 *
     155 * @param vdev[in]      VIRTIO device with the free list.
     156 * @param num[in]       Index of the virtqueue with free list.
     157 * @param head[in,out]  Head of the free list.
     158 * @param descno[in]    The freed descriptor.
     159 */
     160void virtio_free_desc(virtio_dev_t *vdev, uint16_t num, uint16_t *head,
     161    uint16_t descno)
     162{
     163        virtq_t *q = &vdev->queues[num];
     164        fibril_mutex_lock(&q->lock);
     165        virtio_virtq_desc_set(vdev, num, descno, 0, 0, VIRTQ_DESC_F_NEXT,
     166            *head);
     167        *head = descno;
     168        fibril_mutex_unlock(&q->lock);
     169}
     170
    59171
    60172void virtio_virtq_produce_available(virtio_dev_t *vdev, uint16_t num,
Note: See TracChangeset for help on using the changeset viewer.