Annotation of qemu/slirp/if.c, revision 1.1.1.3

1.1       root        1: /*
                      2:  * Copyright (c) 1995 Danny Gasparovski.
                      3:  *
                      4:  * Please read the file COPYRIGHT for the
                      5:  * terms and conditions of the copyright.
                      6:  */
                      7: 
                      8: #include <slirp.h>
                      9: 
                     10: int     if_queued = 0;                  /* Number of packets queued so far */
                     11: 
                     12: struct  mbuf if_fastq;                  /* fast queue (for interactive data) */
                     13: struct  mbuf if_batchq;                 /* queue for non-interactive data */
                     14: struct mbuf *next_m;                   /* Pointer to next mbuf to output */
                     15: 
                     16: #define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
                     17: 
                     18: void
                     19: ifs_insque(ifm, ifmhead)
                     20:        struct mbuf *ifm, *ifmhead;
                     21: {
                     22:        ifm->ifs_next = ifmhead->ifs_next;
                     23:        ifmhead->ifs_next = ifm;
                     24:        ifm->ifs_prev = ifmhead;
                     25:        ifm->ifs_next->ifs_prev = ifm;
                     26: }
                     27: 
                     28: void
                     29: ifs_remque(ifm)
                     30:        struct mbuf *ifm;
                     31: {
                     32:        ifm->ifs_prev->ifs_next = ifm->ifs_next;
                     33:        ifm->ifs_next->ifs_prev = ifm->ifs_prev;
                     34: }
                     35: 
                     36: void
                     37: if_init()
                     38: {
                     39:        if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq;
                     40:        if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;
                     41:         //     sl_compress_init(&comp_s);
                     42:        next_m = &if_batchq;
                     43: }
                     44: 
                     45: #if 0
                     46: /*
                     47:  * This shouldn't be needed since the modem is blocking and
                     48:  * we don't expect any signals, but what the hell..
                     49:  */
                     50: inline int
                     51: writen(fd, bptr, n)
                     52:        int fd;
                     53:        char *bptr;
                     54:        int n;
                     55: {
                     56:        int ret;
                     57:        int total;
1.1.1.3 ! root       58: 
1.1       root       59:        /* This should succeed most of the time */
                     60:        ret = send(fd, bptr, n,0);
                     61:        if (ret == n || ret <= 0)
                     62:           return ret;
1.1.1.3 ! root       63: 
1.1       root       64:        /* Didn't write everything, go into the loop */
                     65:        total = ret;
                     66:        while (n > total) {
                     67:                ret = send(fd, bptr+total, n-total,0);
                     68:                if (ret <= 0)
                     69:                   return ret;
                     70:                total += ret;
                     71:        }
                     72:        return total;
                     73: }
                     74: 
                     75: /*
                     76:  * if_input - read() the tty, do "top level" processing (ie: check for any escapes),
                     77:  * and pass onto (*ttyp->if_input)
1.1.1.3 ! root       78:  *
1.1       root       79:  * XXXXX Any zeros arriving by themselves are NOT placed into the arriving packet.
                     80:  */
                     81: #define INBUFF_SIZE 2048 /* XXX */
                     82: void
                     83: if_input(ttyp)
                     84:        struct ttys *ttyp;
                     85: {
                     86:        u_char if_inbuff[INBUFF_SIZE];
                     87:        int if_n;
1.1.1.3 ! root       88: 
1.1       root       89:        DEBUG_CALL("if_input");
                     90:        DEBUG_ARG("ttyp = %lx", (long)ttyp);
1.1.1.3 ! root       91: 
1.1       root       92:        if_n = recv(ttyp->fd, (char *)if_inbuff, INBUFF_SIZE,0);
1.1.1.3 ! root       93: 
1.1       root       94:        DEBUG_MISC((dfd, " read %d bytes\n", if_n));
1.1.1.3 ! root       95: 
1.1       root       96:        if (if_n <= 0) {
                     97:                if (if_n == 0 || (errno != EINTR && errno != EAGAIN)) {
                     98:                        if (ttyp->up)
                     99:                           link_up--;
                    100:                        tty_detached(ttyp, 0);
                    101:                }
                    102:                return;
                    103:        }
                    104:        if (if_n == 1) {
                    105:                if (*if_inbuff == '0') {
                    106:                        ttyp->ones = 0;
                    107:                        if (++ttyp->zeros >= 5)
                    108:                           slirp_exit(0);
                    109:                        return;
                    110:                }
                    111:                if (*if_inbuff == '1') {
                    112:                        ttyp->zeros = 0;
                    113:                        if (++ttyp->ones >= 5)
                    114:                           tty_detached(ttyp, 0);
                    115:                        return;
                    116:                }
                    117:        }
                    118:        ttyp->ones = ttyp->zeros = 0;
1.1.1.3 ! root      119: 
1.1       root      120:        (*ttyp->if_input)(ttyp, if_inbuff, if_n);
                    121: }
1.1.1.3 ! root      122: #endif
        !           123: 
1.1       root      124: /*
                    125:  * if_output: Queue packet into an output queue.
1.1.1.3 ! root      126:  * There are 2 output queue's, if_fastq and if_batchq.
1.1       root      127:  * Each output queue is a doubly linked list of double linked lists
                    128:  * of mbufs, each list belonging to one "session" (socket).  This
                    129:  * way, we can output packets fairly by sending one packet from each
                    130:  * session, instead of all the packets from one session, then all packets
1.1.1.3 ! root      131:  * from the next session, etc.  Packets on the if_fastq get absolute
1.1       root      132:  * priority, but if one session hogs the link, it gets "downgraded"
                    133:  * to the batchq until it runs out of packets, then it'll return
                    134:  * to the fastq (eg. if the user does an ls -alR in a telnet session,
                    135:  * it'll temporarily get downgraded to the batchq)
                    136:  */
                    137: void
                    138: if_output(so, ifm)
                    139:        struct socket *so;
                    140:        struct mbuf *ifm;
                    141: {
                    142:        struct mbuf *ifq;
                    143:        int on_fastq = 1;
1.1.1.3 ! root      144: 
1.1       root      145:        DEBUG_CALL("if_output");
                    146:        DEBUG_ARG("so = %lx", (long)so);
                    147:        DEBUG_ARG("ifm = %lx", (long)ifm);
1.1.1.3 ! root      148: 
1.1       root      149:        /*
                    150:         * First remove the mbuf from m_usedlist,
                    151:         * since we're gonna use m_next and m_prev ourselves
                    152:         * XXX Shouldn't need this, gotta change dtom() etc.
                    153:         */
                    154:        if (ifm->m_flags & M_USEDLIST) {
                    155:                remque(ifm);
                    156:                ifm->m_flags &= ~M_USEDLIST;
                    157:        }
1.1.1.3 ! root      158: 
1.1       root      159:        /*
1.1.1.3 ! root      160:         * See if there's already a batchq list for this session.
1.1       root      161:         * This can include an interactive session, which should go on fastq,
                    162:         * but gets too greedy... hence it'll be downgraded from fastq to batchq.
                    163:         * We mustn't put this packet back on the fastq (or we'll send it out of order)
                    164:         * XXX add cache here?
                    165:         */
                    166:        for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev) {
                    167:                if (so == ifq->ifq_so) {
                    168:                        /* A match! */
                    169:                        ifm->ifq_so = so;
                    170:                        ifs_insque(ifm, ifq->ifs_prev);
                    171:                        goto diddit;
                    172:                }
                    173:        }
1.1.1.3 ! root      174: 
1.1       root      175:        /* No match, check which queue to put it on */
                    176:        if (so && (so->so_iptos & IPTOS_LOWDELAY)) {
                    177:                ifq = if_fastq.ifq_prev;
                    178:                on_fastq = 1;
                    179:                /*
                    180:                 * Check if this packet is a part of the last
                    181:                 * packet's session
                    182:                 */
                    183:                if (ifq->ifq_so == so) {
                    184:                        ifm->ifq_so = so;
                    185:                        ifs_insque(ifm, ifq->ifs_prev);
                    186:                        goto diddit;
                    187:                }
                    188:        } else
                    189:                ifq = if_batchq.ifq_prev;
1.1.1.3 ! root      190: 
1.1       root      191:        /* Create a new doubly linked list for this session */
                    192:        ifm->ifq_so = so;
                    193:        ifs_init(ifm);
                    194:        insque(ifm, ifq);
1.1.1.3 ! root      195: 
1.1       root      196: diddit:
                    197:        ++if_queued;
1.1.1.3 ! root      198: 
1.1       root      199:        if (so) {
                    200:                /* Update *_queued */
                    201:                so->so_queued++;
                    202:                so->so_nqueued++;
                    203:                /*
                    204:                 * Check if the interactive session should be downgraded to
                    205:                 * the batchq.  A session is downgraded if it has queued 6
                    206:                 * packets without pausing, and at least 3 of those packets
                    207:                 * have been sent over the link
                    208:                 * (XXX These are arbitrary numbers, probably not optimal..)
                    209:                 */
1.1.1.3 ! root      210:                if (on_fastq && ((so->so_nqueued >= 6) &&
1.1       root      211:                                 (so->so_nqueued - so->so_queued) >= 3)) {
1.1.1.3 ! root      212: 
1.1       root      213:                        /* Remove from current queue... */
                    214:                        remque(ifm->ifs_next);
1.1.1.3 ! root      215: 
1.1       root      216:                        /* ...And insert in the new.  That'll teach ya! */
                    217:                        insque(ifm->ifs_next, &if_batchq);
                    218:                }
                    219:        }
                    220: 
                    221: #ifndef FULL_BOLT
                    222:        /*
                    223:         * This prevents us from malloc()ing too many mbufs
                    224:         */
                    225:        if (link_up) {
                    226:                /* if_start will check towrite */
                    227:                if_start();
                    228:        }
                    229: #endif
                    230: }
                    231: 
                    232: /*
                    233:  * Send a packet
                    234:  * We choose a packet based on it's position in the output queues;
                    235:  * If there are packets on the fastq, they are sent FIFO, before
                    236:  * everything else.  Otherwise we choose the first packet from the
                    237:  * batchq and send it.  the next packet chosen will be from the session
                    238:  * after this one, then the session after that one, and so on..  So,
                    239:  * for example, if there are 3 ftp session's fighting for bandwidth,
                    240:  * one packet will be sent from the first session, then one packet
                    241:  * from the second session, then one packet from the third, then back
                    242:  * to the first, etc. etc.
                    243:  */
                    244: void
                    245: if_start(void)
                    246: {
                    247:        struct mbuf *ifm, *ifqt;
1.1.1.3 ! root      248: 
1.1       root      249:        DEBUG_CALL("if_start");
1.1.1.3 ! root      250: 
1.1       root      251:        if (if_queued == 0)
                    252:           return; /* Nothing to do */
1.1.1.3 ! root      253: 
1.1       root      254:  again:
                    255:         /* check if we can really output */
                    256:         if (!slirp_can_output())
                    257:             return;
                    258: 
                    259:        /*
                    260:         * See which queue to get next packet from
                    261:         * If there's something in the fastq, select it immediately
                    262:         */
                    263:        if (if_fastq.ifq_next != &if_fastq) {
                    264:                ifm = if_fastq.ifq_next;
                    265:        } else {
                    266:                /* Nothing on fastq, see if next_m is valid */
                    267:                if (next_m != &if_batchq)
                    268:                   ifm = next_m;
                    269:                else
                    270:                   ifm = if_batchq.ifq_next;
1.1.1.3 ! root      271: 
1.1       root      272:                /* Set which packet to send on next iteration */
                    273:                next_m = ifm->ifq_next;
                    274:        }
                    275:        /* Remove it from the queue */
                    276:        ifqt = ifm->ifq_prev;
                    277:        remque(ifm);
                    278:        --if_queued;
1.1.1.3 ! root      279: 
1.1       root      280:        /* If there are more packets for this session, re-queue them */
                    281:        if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm) {
                    282:                insque(ifm->ifs_next, ifqt);
                    283:                ifs_remque(ifm);
                    284:        }
1.1.1.3 ! root      285: 
1.1       root      286:        /* Update so_queued */
                    287:        if (ifm->ifq_so) {
                    288:                if (--ifm->ifq_so->so_queued == 0)
                    289:                   /* If there's no more queued, reset nqueued */
                    290:                   ifm->ifq_so->so_nqueued = 0;
                    291:        }
1.1.1.3 ! root      292: 
1.1       root      293:        /* Encapsulate the packet for sending */
                    294:         if_encap(ifm->m_data, ifm->m_len);
                    295: 
                    296:         m_free(ifm);
                    297: 
                    298:        if (if_queued)
                    299:           goto again;
                    300: }

unix.superglobalmegacorp.com