Return to virtio-9p-coth.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw / 9pfs

Annotation of qemu/hw/9pfs/virtio-9p-coth.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Virtio 9p backend
        !             3:  *
        !             4:  * Copyright IBM, Corp. 2010
        !             5:  *
        !             6:  * Authors:
        !             7:  *  Harsh Prateek Bora <[email protected]>
        !             8:  *  Venkateswararao Jujjuri(JV) <[email protected]>
        !             9:  *
        !            10:  * This work is licensed under the terms of the GNU GPL, version 2.  See
        !            11:  * the COPYING file in the top-level directory.
        !            12:  *
        !            13:  */
        !            14: 
        !            15: #include "qemu-char.h"
        !            16: #include "fsdev/qemu-fsdev.h"
        !            17: #include "qemu-thread.h"
        !            18: #include "qemu-coroutine.h"
        !            19: #include "virtio-9p-coth.h"
        !            20: 
        !            21: /* v9fs glib thread pool */
        !            22: static V9fsThPool v9fs_pool;
        !            23: 
        !            24: void co_run_in_worker_bh(void *opaque)
        !            25: {
        !            26:     Coroutine *co = opaque;
        !            27:     g_thread_pool_push(v9fs_pool.pool, co, NULL);
        !            28: }
        !            29: 
        !            30: static void v9fs_qemu_process_req_done(void *arg)
        !            31: {
        !            32:     char byte;
        !            33:     ssize_t len;
        !            34:     Coroutine *co;
        !            35: 
        !            36:     do {
        !            37:         len = read(v9fs_pool.rfd, &byte, sizeof(byte));
        !            38:     } while (len == -1 &&  errno == EINTR);
        !            39: 
        !            40:     while ((co = g_async_queue_try_pop(v9fs_pool.completed)) != NULL) {
        !            41:         qemu_coroutine_enter(co, NULL);
        !            42:     }
        !            43: }
        !            44: 
        !            45: static void v9fs_thread_routine(gpointer data, gpointer user_data)
        !            46: {
        !            47:     ssize_t len;
        !            48:     char byte = 0;
        !            49:     Coroutine *co = data;
        !            50: 
        !            51:     qemu_coroutine_enter(co, NULL);
        !            52: 
        !            53:     g_async_queue_push(v9fs_pool.completed, co);
        !            54:     do {
        !            55:         len = write(v9fs_pool.wfd, &byte, sizeof(byte));
        !            56:     } while (len == -1 && errno == EINTR);
        !            57: }
        !            58: 
        !            59: int v9fs_init_worker_threads(void)
        !            60: {
        !            61:     int ret = 0;
        !            62:     int notifier_fds[2];
        !            63:     V9fsThPool *p = &v9fs_pool;
        !            64:     sigset_t set, oldset;
        !            65: 
        !            66:     sigfillset(&set);
        !            67:     /* Leave signal handling to the iothread.  */
        !            68:     pthread_sigmask(SIG_SETMASK, &set, &oldset);
        !            69: 
        !            70:     if (qemu_pipe(notifier_fds) == -1) {
        !            71:         ret = -1;
        !            72:         goto err_out;
        !            73:     }
        !            74:     p->pool = g_thread_pool_new(v9fs_thread_routine, p, -1, FALSE, NULL);
        !            75:     if (!p->pool) {
        !            76:         ret = -1;
        !            77:         goto err_out;
        !            78:     }
        !            79:     p->completed = g_async_queue_new();
        !            80:     if (!p->completed) {
        !            81:         /*
        !            82:          * We are going to terminate.
        !            83:          * So don't worry about cleanup
        !            84:          */
        !            85:         ret = -1;
        !            86:         goto err_out;
        !            87:     }
        !            88:     p->rfd = notifier_fds[0];
        !            89:     p->wfd = notifier_fds[1];
        !            90: 
        !            91:     fcntl(p->rfd, F_SETFL, O_NONBLOCK);
        !            92:     fcntl(p->wfd, F_SETFL, O_NONBLOCK);
        !            93: 
        !            94:     qemu_set_fd_handler(p->rfd, v9fs_qemu_process_req_done, NULL, NULL);
        !            95: err_out:
        !            96:     pthread_sigmask(SIG_SETMASK, &oldset, NULL);
        !            97:     return ret;
        !            98: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.