Commit 16a3df40 authored by Zhang Chen's avatar Zhang Chen Committed by Jason Wang
Browse files

net/net: Add SocketReadState for reuse codes 



This function is from net/socket.c, move it to net.c and net.h.
Add SocketReadState to make others reuse net_fill_rstate().
suggestion from jason.

v4:
 - move 'rs->finalize = finalize' to rs_init()

v3:
 - remove SocketReadState init callback
 - put finalize callback to net_fill_rstate()

v2:
 - rename ReadState to SocketReadState
 - add SocketReadState init and finalize callback

v1:
 - init patch

Signed-off-by: default avatarZhang Chen <zhangchen.fnst@cn.fujitsu.com>
Signed-off-by: default avatarLi Zhijian <lizhijian@cn.fujitsu.com>
Signed-off-by: default avatarWen Congyang <wency@cn.fujitsu.com>
Signed-off-by: default avatarJason Wang <jasowang@redhat.com>
parent d30300f7

include/net/net.h

+13 −0
Original line number Diff line number Diff line
@@ -57,6 +57,8 @@ typedef void (SetOffload)(NetClientState *, int, int, int, int, int); 
typedef void (SetVnetHdrLen)(NetClientState *, int);

typedef int (SetVnetLE)(NetClientState *, bool);

typedef int (SetVnetBE)(NetClientState *, bool);

typedef struct SocketReadState SocketReadState;

typedef void (SocketReadStateFinalize)(SocketReadState *rs);



typedef struct NetClientInfo {

    NetClientOptionsKind type;
@@ -102,6 +104,15 @@ typedef struct NICState { 
    bool peer_deleted;

} NICState;



struct SocketReadState {

    int state; /* 0 = getting length, 1 = getting data */

    uint32_t index;

    uint32_t packet_len;

    uint8_t buf[NET_BUFSIZE];

    SocketReadStateFinalize *finalize;

};



int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size);

char *qemu_mac_strdup_printf(const uint8_t *macaddr);

NetClientState *qemu_find_netdev(const char *id);

int qemu_find_net_clients_except(const char *id, NetClientState **ncs,
@@ -160,6 +171,8 @@ ssize_t qemu_deliver_packet_iov(NetClientState *sender, 


void print_net_client(Monitor *mon, NetClientState *nc);

void hmp_info_network(Monitor *mon, const QDict *qdict);

void net_socket_rs_init(SocketReadState *rs,

                        SocketReadStateFinalize *finalize);



/* NIC info */

net/filter-mirror.c

+16 −50
Original line number Diff line number Diff line
@@ -40,10 +40,7 @@ typedef struct MirrorState { 
    char *outdev;

    CharDriverState *chr_in;

    CharDriverState *chr_out;

    int state; /* 0 = getting length, 1 = getting data */

    unsigned int index;

    unsigned int packet_len;

    uint8_t buf[REDIRECTOR_MAX_LEN];

    SocketReadState rs;

} MirrorState;



static int filter_mirror_send(CharDriverState *chr_out,
@@ -108,51 +105,12 @@ static void redirector_chr_read(void *opaque, const uint8_t *buf, int size) 
{

    NetFilterState *nf = opaque;

    MirrorState *s = FILTER_REDIRECTOR(nf);

    unsigned int l;



    while (size > 0) {

        /* reassemble a packet from the network */

        switch (s->state) { /* 0 = getting length, 1 = getting data */

        case 0:

            l = 4 - s->index;

            if (l > size) {

                l = size;

            }

            memcpy(s->buf + s->index, buf, l);

            buf += l;

            size -= l;

            s->index += l;

            if (s->index == 4) {

                /* got length */

                s->packet_len = ntohl(*(uint32_t *)s->buf);

                s->index = 0;

                s->state = 1;

            }

            break;

        case 1:

            l = s->packet_len - s->index;

            if (l > size) {

                l = size;

            }

            if (s->index + l <= sizeof(s->buf)) {

                memcpy(s->buf + s->index, buf, l);

            } else {

                error_report("serious error: oversized packet received.");

                s->index = s->state = 0;

                qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);

                return;

            }

    int ret;



            s->index += l;

            buf += l;

            size -= l;

            if (s->index >= s->packet_len) {

                s->index = 0;

                s->state = 0;

                redirector_to_filter(nf, s->buf, s->packet_len);

            }

            break;

        }

    ret = net_fill_rstate(&s->rs, buf, size);



    if (ret == -1) {

        qemu_chr_add_handlers(s->chr_in, NULL, NULL, NULL, NULL);

    }

}
@@ -258,6 +216,14 @@ static void filter_mirror_setup(NetFilterState *nf, Error **errp) 
    }

}



static void redirector_rs_finalize(SocketReadState *rs)

{

    MirrorState *s = container_of(rs, MirrorState, rs);

    NetFilterState *nf = NETFILTER(s);



    redirector_to_filter(nf, rs->buf, rs->packet_len);

}



static void filter_redirector_setup(NetFilterState *nf, Error **errp)

{

    MirrorState *s = FILTER_REDIRECTOR(nf);
@@ -274,7 +240,7 @@ static void filter_redirector_setup(NetFilterState *nf, Error **errp) 
        }

    }



    s->state = s->index = 0;

    net_socket_rs_init(&s->rs, redirector_rs_finalize);



    if (s->indev) {

        s->chr_in = qemu_chr_find(s->indev);

net/net.c

+70 −0
Original line number Diff line number Diff line
@@ -1550,3 +1550,73 @@ QemuOptsList qemu_net_opts = { 
        { /* end of list */ }

    },

};



void net_socket_rs_init(SocketReadState *rs,

                        SocketReadStateFinalize *finalize)

{

    rs->state = 0;

    rs->index = 0;

    rs->packet_len = 0;

    memset(rs->buf, 0, sizeof(rs->buf));

    rs->finalize = finalize;

}



/*

 * Returns

 * 0: SocketReadState is not ready

 * 1: SocketReadState is ready

 * otherwise error occurs

 */

int net_fill_rstate(SocketReadState *rs, const uint8_t *buf, int size)

{

    unsigned int l;



    while (size > 0) {

        /* reassemble a packet from the network */

        switch (rs->state) { /* 0 = getting length, 1 = getting data */

        case 0:

            l = 4 - rs->index;

            if (l > size) {

                l = size;

            }

            memcpy(rs->buf + rs->index, buf, l);

            buf += l;

            size -= l;

            rs->index += l;

            if (rs->index == 4) {

                /* got length */

                rs->packet_len = ntohl(*(uint32_t *)rs->buf);

                rs->index = 0;

                rs->state = 1;

            }

            break;

        case 1:

            l = rs->packet_len - rs->index;

            if (l > size) {

                l = size;

            }

            if (rs->index + l <= sizeof(rs->buf)) {

                memcpy(rs->buf + rs->index, buf, l);

            } else {

                fprintf(stderr, "serious error: oversized packet received,"

                    "connection terminated.\n");

                rs->index = rs->state = 0;

                return -1;

            }



            rs->index += l;

            buf += l;

            size -= l;

            if (rs->index >= rs->packet_len) {

                rs->index = 0;

                rs->state = 0;

                if (rs->finalize) {

                    rs->finalize(rs);

                }

                return 1;

            }

            break;

        }

    }

    return 0;

}

net/socket.c

+22 −55
Original line number Diff line number Diff line
@@ -38,11 +38,8 @@ typedef struct NetSocketState { 
    NetClientState nc;

    int listen_fd;

    int fd;

    int state; /* 0 = getting length, 1 = getting data */

    unsigned int index;

    unsigned int packet_len;

    SocketReadState rs;

    unsigned int send_index;      /* number of bytes sent (only SOCK_STREAM) */

    uint8_t buf[NET_BUFSIZE];

    struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */

    IOHandler *send_fn;           /* differs between SOCK_STREAM/SOCK_DGRAM */

    bool read_poll;               /* waiting to receive data? */
@@ -143,11 +140,22 @@ static void net_socket_send_completed(NetClientState *nc, ssize_t len) 
    }

}



static void net_socket_rs_finalize(SocketReadState *rs)

{

    NetSocketState *s = container_of(rs, NetSocketState, rs);



    if (qemu_send_packet_async(&s->nc, rs->buf,

                               rs->packet_len,

                               net_socket_send_completed) == 0) {

        net_socket_read_poll(s, false);

    }

}



static void net_socket_send(void *opaque)

{

    NetSocketState *s = opaque;

    int size;

    unsigned l;

    int ret;

    uint8_t buf1[NET_BUFSIZE];

    const uint8_t *buf;
@@ -166,61 +174,18 @@ static void net_socket_send(void *opaque) 
        closesocket(s->fd);



        s->fd = -1;

        s->state = 0;

        s->index = 0;

        s->packet_len = 0;

        net_socket_rs_init(&s->rs, net_socket_rs_finalize);

        s->nc.link_down = true;

        memset(s->buf, 0, sizeof(s->buf));

        memset(s->nc.info_str, 0, sizeof(s->nc.info_str));



        return;

    }

    buf = buf1;

    while (size > 0) {

        /* reassemble a packet from the network */

        switch(s->state) {

        case 0:

            l = 4 - s->index;

            if (l > size)

                l = size;

            memcpy(s->buf + s->index, buf, l);

            buf += l;

            size -= l;

            s->index += l;

            if (s->index == 4) {

                /* got length */

                s->packet_len = ntohl(*(uint32_t *)s->buf);

                s->index = 0;

                s->state = 1;

            }

            break;

        case 1:

            l = s->packet_len - s->index;

            if (l > size)

                l = size;

            if (s->index + l <= sizeof(s->buf)) {

                memcpy(s->buf + s->index, buf, l);

            } else {

                fprintf(stderr, "serious error: oversized packet received,"

                    "connection terminated.\n");

                s->state = 0;

                goto eoc;

            }



            s->index += l;

            buf += l;

            size -= l;

            if (s->index >= s->packet_len) {

                s->index = 0;

                s->state = 0;

                if (qemu_send_packet_async(&s->nc, s->buf, s->packet_len,

                                           net_socket_send_completed) == 0) {

                    net_socket_read_poll(s, false);

                    break;

                }

            }

            break;

        }

    ret = net_fill_rstate(&s->rs, buf, size);



    if (ret == -1) {

        goto eoc;

    }

}
@@ -229,7 +194,7 @@ static void net_socket_send_dgram(void *opaque) 
    NetSocketState *s = opaque;

    int size;



    size = qemu_recv(s->fd, s->buf, sizeof(s->buf), 0);

    size = qemu_recv(s->fd, s->rs.buf, sizeof(s->rs.buf), 0);

    if (size < 0)

        return;

    if (size == 0) {
@@ -238,7 +203,7 @@ static void net_socket_send_dgram(void *opaque) 
        net_socket_write_poll(s, false);

        return;

    }

    if (qemu_send_packet_async(&s->nc, s->buf, size,

    if (qemu_send_packet_async(&s->nc, s->rs.buf, size,

                               net_socket_send_completed) == 0) {

        net_socket_read_poll(s, false);

    }
@@ -401,6 +366,7 @@ static NetSocketState *net_socket_fd_init_dgram(NetClientState *peer, 
    s->fd = fd;

    s->listen_fd = -1;

    s->send_fn = net_socket_send_dgram;

    net_socket_rs_init(&s->rs, net_socket_rs_finalize);

    net_socket_read_poll(s, true);



    /* mcast: save bound address as dst */
@@ -451,6 +417,7 @@ static NetSocketState *net_socket_fd_init_stream(NetClientState *peer, 


    s->fd = fd;

    s->listen_fd = -1;

    net_socket_rs_init(&s->rs, net_socket_rs_finalize);



    /* Disable Nagle algorithm on TCP sockets to reduce latency */

    socket_set_nodelay(fd);