Return to dev.c CVS log

Up to [Early Linux] / linux / net / tcp

Annotation of linux/net/tcp/dev.c, revision 1.1

1.1     ! root        1: /* dev.c */
        !             2: /*
        !             3:     Copyright (C) 1992  Ross Biro
        !             4: 
        !             5:     This program is free software; you can redistribute it and/or modify
        !             6:     it under the terms of the GNU General Public License as published by
        !             7:     the Free Software Foundation; either version 2, or (at your option)
        !             8:     any later version.
        !             9: 
        !            10:     This program is distributed in the hope that it will be useful,
        !            11:     but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13:     GNU General Public License for more details.
        !            14: 
        !            15:     You should have received a copy of the GNU General Public License
        !            16:     along with this program; if not, write to the Free Software
        !            17:     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
        !            18: 
        !            19:     The Author may be reached as [email protected] or
        !            20:     C/O Department of Mathematics; Stanford University; Stanford, CA 94305
        !            21: */
        !            22: 
        !            23: #include <asm/segment.h>
        !            24: #include <asm/system.h>
        !            25: #include <linux/types.h>
        !            26: #include <linux/kernel.h>
        !            27: #include <linux/sched.h>
        !            28: #include <linux/string.h>
        !            29: #include <linux/mm.h>
        !            30: #include <linux/socket.h>
        !            31: #include <netinet/in.h>
        !            32: #include <asm/memory.h>
        !            33: #include "dev.h"
        !            34: #include "eth.h"
        !            35: #include "timer.h"
        !            36: #include "ip.h"
        !            37: #include "tcp.h"
        !            38: #include "sock.h"
        !            39: #include <linux/errno.h>
        !            40: #include "arp.h"
        !            41: 
        !            42: #undef DEV_DEBUG
        !            43: #ifdef DEV_DEBUG
        !            44: #define PRINTK printk
        !            45: #else
        !            46: #define PRINTK dummy_routine
        !            47: #endif
        !            48: 
        !            49: 
        !            50: static  unsigned long
        !            51: min(unsigned long a, unsigned long b)
        !            52: {
        !            53:    if (a < b) return (a);
        !            54:    return (b);
        !            55: }
        !            56: 
        !            57: void
        !            58: dev_add_pack (struct packet_type *pt)
        !            59: {
        !            60:    struct packet_type *p1;
        !            61:    pt->next = ptype_base;
        !            62: 
        !            63:    /* see if we need to copy it. */
        !            64:    for (p1 = ptype_base; p1 != NULL; p1 = p1->next)
        !            65:      {
        !            66:        if (p1->type == pt->type)
        !            67:          {
        !            68:             pt->copy = 1;
        !            69:             break;
        !            70:          }
        !            71:      }
        !            72: 
        !            73:    ptype_base = pt;
        !            74:    
        !            75: }
        !            76: 
        !            77: void
        !            78: dev_remove_pack (struct packet_type *pt)
        !            79: {
        !            80:    struct packet_type *lpt, *pt1;
        !            81:    if (pt == ptype_base)
        !            82:      {
        !            83:        ptype_base = pt->next;
        !            84:        return;
        !            85:      }
        !            86: 
        !            87:    lpt = NULL;
        !            88: 
        !            89:    for (pt1 = ptype_base; pt1->next != NULL; pt1=pt1->next)
        !            90:      {
        !            91:        if (pt1->next == pt )
        !            92:          {
        !            93:             cli();
        !            94:             if (!pt->copy && lpt) 
        !            95:               lpt->copy = 0;
        !            96:             pt1->next = pt->next;
        !            97:             sti();
        !            98:             return;
        !            99:          }
        !           100: 
        !           101:        if (pt1->next -> type == pt ->type)
        !           102:          {
        !           103:             lpt = pt1->next;
        !           104:          }
        !           105:      }
        !           106: }
        !           107: 
        !           108: struct device *
        !           109: get_dev (char *name)
        !           110: {
        !           111:    struct device *dev;
        !           112:    for (dev = dev_base; dev != NULL; dev=dev->next)
        !           113:      {
        !           114:        if (strcmp (dev->name, name) == 0) return (dev);
        !           115:      }
        !           116:    return (NULL);
        !           117: }
        !           118: 
        !           119: void
        !           120: dev_queue_xmit (struct sk_buff *skb, struct device *dev, int pri)
        !           121: {
        !           122:   struct sk_buff *skb2;
        !           123:   PRINTK ("eth_queue_xmit (skb=%X, dev=%X, pri = %d)\n", skb, dev, pri);
        !           124:   skb->dev = dev;
        !           125:   if (pri < 0 || pri >= DEV_NUMBUFFS)
        !           126:     {
        !           127:        printk ("bad priority in dev_queue_xmit.\n");
        !           128:        pri = 1;
        !           129:     }
        !           130: 
        !           131:   if (dev->hard_start_xmit(skb, dev) == 0)
        !           132:     {
        !           133:        return;
        !           134:     }
        !           135: 
        !           136:   if (skb->next != NULL)
        !           137:     {
        !           138:        printk ("retransmitted packet still on queue. \n");
        !           139:        return;
        !           140:     }
        !           141: 
        !           142:   /* used to say it is not currently on a send list. */
        !           143:   skb->next = NULL;
        !           144: 
        !           145: 
        !           146:   /* put skb into a bidirectional circular linked list. */
        !           147:   PRINTK ("eth_queue dev->buffs[%d]=%X\n",pri, dev->buffs[pri]);
        !           148:   /* interrupts should already be cleared by hard_start_xmit. */
        !           149:   cli();
        !           150:   if (dev->buffs[pri] == NULL)
        !           151:     {
        !           152:       dev->buffs[pri]=skb;
        !           153:       skb->next = skb;
        !           154:       skb->prev = skb;
        !           155:     }
        !           156:   else
        !           157:     {
        !           158:       skb2=dev->buffs[pri];
        !           159:       skb->next = skb2;
        !           160:       skb->prev = skb2->prev;
        !           161:       skb->next->prev = skb;
        !           162:       skb->prev->next = skb;
        !           163:     }
        !           164:   sti();
        !           165: 
        !           166: }
        !           167: 
        !           168: 
        !           169: /* this routine now just gets the data out of the card and returns.
        !           170:    it's return values now mean.
        !           171: 
        !           172:    1 <- exit even if you have more packets.
        !           173:    0 <- call me again no matter what.
        !           174:   -1 <- last packet not processed, try again. */
        !           175: 
        !           176: int
        !           177: dev_rint(unsigned char *buff, unsigned long len, int flags,
        !           178:         struct device * dev)
        !           179: {
        !           180:    struct sk_buff *skb=NULL;
        !           181:    struct packet_type *ptype;
        !           182:    unsigned short type;
        !           183:    unsigned char flag =0;
        !           184:    unsigned char *to;
        !           185:    int amount;
        !           186: 
        !           187:    /* try to grab some memory. */
        !           188:    if (len > 0 && buff != NULL)
        !           189:      {
        !           190:        skb = malloc (sizeof (*skb) + len);
        !           191:        skb->mem_len = sizeof (*skb) + len;
        !           192:        skb->mem_addr = skb;
        !           193:      }
        !           194: 
        !           195:    /* firs we copy the packet into a buffer, and save it for later. */
        !           196:    if (buff != NULL && skb != NULL)
        !           197:      {
        !           198:        if ( !(flags & IN_SKBUFF))
        !           199:          {
        !           200:             to = (unsigned char *)(skb+1);
        !           201:             while (len > 0)
        !           202:               {
        !           203:                  amount = min (len, (unsigned long) dev->rmem_end -
        !           204:                                (unsigned long) buff);
        !           205:                  memcpy (to, buff, amount);
        !           206:                  len -= amount;
        !           207:                  buff += amount;
        !           208:                  to += amount;
        !           209:                  if ((unsigned long)buff == dev->rmem_end)
        !           210:                    buff = (unsigned char *)dev->rmem_start;
        !           211:               }
        !           212:          }
        !           213:        else
        !           214:          {
        !           215:             free_s (skb->mem_addr, skb->mem_len);
        !           216:             skb = (struct sk_buff *)buff;
        !           217:          }
        !           218: 
        !           219:        skb->len = len;
        !           220:        skb->dev = dev;
        !           221:        skb->sk = NULL;
        !           222: 
        !           223:        /* now add it to the dev backlog. */
        !           224:        cli();
        !           225:        if (dev-> backlog == NULL)
        !           226:          {
        !           227:             skb->prev = skb;
        !           228:             skb->next = skb;
        !           229:             dev->backlog = skb;
        !           230:          }
        !           231:        else
        !           232:          {
        !           233:             skb ->prev = dev->backlog->prev;
        !           234:             skb->next = dev->backlog;
        !           235:             skb->next->prev = skb;
        !           236:             skb->prev->next = skb;
        !           237:          }
        !           238:        sti();
        !           239:        return (0);
        !           240:      }
        !           241: 
        !           242:    if (skb != NULL) 
        !           243:      free_s (skb->mem_addr, skb->mem_len);
        !           244: 
        !           245:    /* anything left to process? */
        !           246: 
        !           247:    if (dev->backlog == NULL)
        !           248:      {
        !           249:        if (buff == NULL)
        !           250:          {
        !           251:             sti();
        !           252:             return (1);
        !           253:          }
        !           254: 
        !           255:        if (skb != NULL)
        !           256:          {
        !           257:             sti();
        !           258:             return (-1);
        !           259:          }
        !           260: 
        !           261:        sti();
        !           262:        printk ("dev_rint:Dropping packets due to lack of memory\n");
        !           263:        return (1);
        !           264:      }
        !           265: 
        !           266:    skb= dev->backlog;
        !           267:    if (skb->next == skb)
        !           268:      {
        !           269:        dev->backlog = NULL;
        !           270:      }
        !           271:    else
        !           272:      {
        !           273:        dev->backlog = skb->next;
        !           274:        skb->next->prev = skb->prev;
        !           275:        skb->prev->next = skb->next;
        !           276:      }
        !           277:    sti();
        !           278: 
        !           279:    /* bump the pointer to the next structure. */
        !           280:    skb->h.raw = (unsigned char *)(skb+1) + dev->hard_header_len;
        !           281:    skb->len -= dev->hard_header_len;
        !           282: 
        !           283:    /* convert the type to an ethernet type. */
        !           284:    type = dev->type_trans (skb, dev);
        !           285: 
        !           286:    /* if there get to be a lot of types we should changes this to
        !           287:       a bunch of linked lists like we do for ip protocols. */
        !           288:    for (ptype = ptype_base; ptype != NULL; ptype=ptype->next)
        !           289:      {
        !           290:        if (ptype->type == type)
        !           291:          {
        !           292:             struct sk_buff *skb2;
        !           293:             /* copy the packet if we need to. */
        !           294:             if (ptype->copy)
        !           295:               {
        !           296:                  skb2 = malloc (skb->mem_len);
        !           297:                  if (skb2 == NULL) continue;
        !           298:                  memcpy (skb2, skb, skb->mem_len);
        !           299:                  skb2->mem_addr = skb2;
        !           300:               }
        !           301:             else
        !           302:               {
        !           303:                  skb2 = skb;
        !           304:                  flag = 1;
        !           305:               }
        !           306:               
        !           307:             ptype->func (skb2, dev, ptype);
        !           308:          }
        !           309:      }
        !           310: 
        !           311:    if (!flag)
        !           312:      {
        !           313:        PRINTK ("discarding packet type = %X\n", type);
        !           314:        free_skb (skb, FREE_READ);
        !           315:      }
        !           316: 
        !           317:      if (buff == NULL)
        !           318:        return (0);
        !           319:      else
        !           320:        return (-1);
        !           321: }
        !           322: 
        !           323: /* This routine is called when an device interface is ready to
        !           324:    transmit a packet.  Buffer points to where the packet should
        !           325:    be put, and the routine returns the length of the packet.  A
        !           326:    length of zero is interrpreted to mean the transmit buffers
        !           327:    are empty, and the transmitter should be shut down. */
        !           328: 
        !           329: unsigned long
        !           330: dev_tint(unsigned char *buff,  struct device *dev)
        !           331: {
        !           332:   int i;
        !           333:   int tmp;
        !           334:   struct sk_buff *skb;
        !           335:   for (i=0; i < DEV_NUMBUFFS; i++)
        !           336:     {
        !           337:       while (dev->buffs[i]!=NULL)
        !           338:        {
        !           339:          cli();
        !           340:          skb=dev->buffs[i];
        !           341:          if (skb->next == skb)
        !           342:            {
        !           343:              dev->buffs[i] = NULL;
        !           344:            }
        !           345:          else
        !           346:            {
        !           347:              dev->buffs[i]=skb->next;
        !           348:              skb->prev->next = skb->next;
        !           349:              skb->next->prev = skb->prev;
        !           350:            }
        !           351:          skb->next = NULL;
        !           352:          skb->prev = NULL;
        !           353:          sti();
        !           354:          tmp = skb->len;
        !           355:          if (!skb->arp)
        !           356:            {
        !           357:               if (dev->rebuild_header (skb+1, dev))
        !           358:                 {
        !           359:                    skb->dev = dev;
        !           360:                    arp_queue (skb);
        !           361:                    continue;
        !           362:                 }
        !           363:            }
        !           364:             
        !           365:          if (tmp <= dev->mtu)
        !           366:            {
        !           367:               if (dev->send_packet != NULL)
        !           368:                 {
        !           369:                    dev->send_packet(skb, dev);
        !           370:                 }
        !           371:               if (buff != NULL)
        !           372:                 memcpy (buff, skb + 1, tmp);
        !           373: 
        !           374:               PRINTK (">>\n");
        !           375:               print_eth ((struct enet_header *)(skb+1));
        !           376:            }
        !           377:          else
        !           378:            {
        !           379:               printk ("**** bug len bigger than mtu. \n");
        !           380:            }
        !           381: 
        !           382:          if (skb->free)
        !           383:            {
        !           384:                  free_skb(skb, FREE_WRITE);
        !           385:            }
        !           386: 
        !           387:          if (tmp != 0)
        !           388:            return (tmp);
        !           389:        }
        !           390:     }
        !           391:   PRINTK ("dev_tint returning 0 \n");
        !           392:   return (0);
        !           393: }
        !           394: 

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