mac-802_3.cc

Go to the documentation of this file.

/* -*-  Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
/*
 * mac-802_3.cc
 * $Id: mac-802_3.cc,v 1.16 2002/06/14 23:15:03 yuri Exp $
 */
#include <packet.h>
#include <random.h>
#include <arp.h>
#include <ll.h> 
#include <mac-802_3.h>

//#define MAC_DEBUG

#ifndef MAC_DEBUG
#define FPRINTF(s, f, t, index, func) do {} while (0)
#else
   static double xtime= 0.0;
#  define FPRINTF(s, f, t, index, func) \
         do { fprintf(s, f, t, index, func); xtime= t; } while (0)
#endif //MAC_DEBUG

#define PRNT_MAC_FUNCS(mac) \
        FPRINTF(stderr, "%.15f : %d : %s\n", \
                Scheduler::instance().clock(), (mac)->index_, __PRETTY_FUNCTION__)

inline void MacHandler::cancel() {
        PRNT_MAC_FUNCS(mac);
        Scheduler& s = Scheduler::instance();
        assert(busy_);
        s.cancel(&intr);
        // No need to free the event intr since it's statically allocated.
        busy_ = 0;
}

inline void Mac8023HandlerSend::cancel() {
        PRNT_MAC_FUNCS(mac);
        assert(busy_);
        Scheduler &s= Scheduler::instance();
        s.cancel(&intr);
        busy_= 0;
        p_= 0;
}

inline void MacHandlerRecv::cancel() {
        PRNT_MAC_FUNCS(mac);
        Scheduler& s = Scheduler::instance();
        assert(busy_ && p_);
        s.cancel(&intr);
        busy_ = 0;
        Packet::free(p_);
        p_= 0;
}

inline void MacHandlerRetx::cancel() {
        PRNT_MAC_FUNCS(mac);
        Scheduler& s = Scheduler::instance();
        assert(busy_ && p_);
        s.cancel(&intr);
}

inline void MacHandlerIFS::cancel() {
        PRNT_MAC_FUNCS(mac);
        //fprintf (stderr, "cancelled dtime= %.15f\n", intr.time_- Scheduler::instance().clock());
        MacHandler::cancel();
}
static class Mac802_3Class : public TclClass {
public:
        Mac802_3Class() : TclClass("Mac/802_3") {}
        TclObject* create(int, const char*const*) {
                return (new Mac802_3);
        }
} class_mac802_3;

void Mac8023HandlerSend::handle(Event*) {
        PRNT_MAC_FUNCS(mac);
        assert(p_);
        /* Transmission completed successfully */
        busy_ = 0;
        p_= 0;
        mac->mhRetx_.free();
        mac->mhRetx_.reset();
        mac->mhIFS_.schedule(mac->netif_->txtime(int(IEEE_8023_IFS_BITS/8.0)));
}

void Mac8023HandlerSend::schedule(const Packet *p, double t) {
        PRNT_MAC_FUNCS(mac);
        Scheduler& s = Scheduler::instance();
        assert(!busy_);
        s.schedule(this, &intr, t);
        busy_ = 1;
        p_= p;
}

void MacHandlerRecv::handle(Event* ) {
        /* Reception Successful */
        PRNT_MAC_FUNCS(mac);
        busy_ = 0;
        mac->recv_complete(p_);
        p_= 0;
}

void MacHandlerRecv::schedule(Packet *p, double t) {
        PRNT_MAC_FUNCS(mac);
        Scheduler& s = Scheduler::instance();
        assert(p && !busy_);
        s.schedule(this, &intr, t);
        busy_ = 1;
        p_ = p;
}

bool MacHandlerRetx::schedule(double delta) {
        PRNT_MAC_FUNCS(mac);
        Scheduler& s = Scheduler::instance();
        assert(p_ && !busy_);
        int k, r;
        if(try_ < IEEE_8023_ALIMIT) {
                k = min(try_, IEEE_8023_BLIMIT);
                r = Random::integer(1 << k);
                s.schedule(this, &intr, r * mac->netif_->txtime((int)(IEEE_8023_SLOT_BITS/8.0)) + delta);
                busy_ = 1;
                return true;
        }
        return false;
}

void MacHandlerRetx::handle(Event *) {
        PRNT_MAC_FUNCS(mac);
        assert(p_);
        busy_= 0;
        ++try_;
        mac->transmit(p_);
}

inline void MacHandlerIFS::schedule(double t) {
        PRNT_MAC_FUNCS(mac);
        assert(!busy_);
        Scheduler &s= Scheduler::instance();
        s.schedule(this, &intr, t);
        busy_= 1;
}
inline void MacHandlerIFS::handle(Event*) { 
        PRNT_MAC_FUNCS(mac);
        busy_= 0; 
        mac->resume(); 
}


Mac802_3::Mac802_3() : trace_(0), 
        mhRecv_(this), mhRetx_(this), mhIFS_(this), mhSend_(this) {
        // Bind mac trace variable 
        bind_bool("trace_",&trace_);
}

void Mac802_3::sendUp(Packet *p, Handler *) {
        PRNT_MAC_FUNCS(this);
        /* just received the 1st bit of a packet */
        if (state_ != MAC_IDLE && mhIFS_.busy()) {
#define EPS 1.0e-15 /* can be considered controller clock resolution */
                if (mhIFS_.expire() - Scheduler::instance().clock() > EPS) {
                        // This can happen when 3 nodes TX:
                        // 1 was TX, then IFS, then TX again;
                        // 2,3 were in RX (from 1), then IFS, then TX, then collision with 1 and IFS
                        // while 3 in IFS it RX from 2 and vice versa.
                        // We ignore it and let the ifs timer take care of things.
                        Packet::free(p);
                        return;
                } else {
                        // This means that mhIFS_ is about to expire now. We assume that IFS is over 
                        // and resume, because we want to give this guy a chance - otherwise the guy 
                        // who TX before will TX again (fairness); if we have anything to
                        // TX, this forces a collision.
                        mhIFS_.cancel();
                        resume();
                }
#undef EPS
        } 
        if(state_ == MAC_IDLE) {
                state_ = MAC_RECV;
                assert(!mhRecv_.busy());
                /* the last bit will arrive in txtime seconds */
                mhRecv_.schedule(p, netif_->txtime(p));
        } else {
                collision(p); //received packet while sending or receiving
        }
}

void Mac802_3::sendDown(Packet *p, Handler *h) {
        PRNT_MAC_FUNCS(this);
        assert(initialized());
        assert(h);
        assert(netif_->txtime(IEEE_8023_MINFRAME) > 
               2*netif_->channel()->maxdelay()); /* max prop. delay is limited by specs: 
                                                    about 25us for 10Mbps
                                                    and   2.5us for 100Mbps
                                                 */

        int size= (HDR_CMN(p)->size() += ETHER_HDR_LEN); //XXX also preamble?
        hdr_mac *mh= HDR_MAC(p);
        mh->padding_= 0;
        if (size > IEEE_8023_MAXFRAME) {
                static bool warnedMAX= false;
                if (!warnedMAX) {
                        fprintf(stderr, "Mac802_3: frame is too big: %d\n", size);
                        warnedMAX= true;
                }
        } else if (size < IEEE_8023_MINFRAME) {
                // pad it to fit MINFRAME
                mh->padding_= IEEE_8023_MINFRAME - size;
                HDR_CMN(p)->size() += mh->padding_;
        }
        callback_ = h;
        mhRetx_.packet(p); //packet's buffered by mhRetx in case of retransmissions

        transmit(p);
}


void Mac802_3::transmit(Packet *p) {
        PRNT_MAC_FUNCS(this);
        assert(callback_);
        if(mhSend_.packet()) {
                fprintf(stderr, "index: %d\n", index_);
                fprintf(stderr, "Retx Timer: %d\n", mhRetx_.busy());
                fprintf(stderr, "IFS  Timer: %d\n", mhIFS_.busy());
                fprintf(stderr, "Recv Timer: %d\n", mhRecv_.busy());
                fprintf(stderr, "Send Timer: %d\n", mhSend_.busy());
                exit(1);
        }

        /* Perform carrier sense  - if we were sending before, never mind state_ */
        if (mhIFS_.busy() || (state_ != MAC_IDLE)) {
                /* we'll try again when IDLE. It'll happen either when
                   reception completes, or if collision.  Either way,
                   we call resume() */
                return;
        }

        double txtime = netif_->txtime(p);
        /* Schedule transmission of the packet's last bit */
        mhSend_.schedule(p, txtime);

        // pass the packet to the PHY: need to send a copy, 
        // because there may be collision and it may be freed
        Packet *newp = p->copy();
        HDR_CMN(newp)->direction()= hdr_cmn::DOWN; //down
        
        downtarget_->recv(newp);

        state_= MAC_SEND;
}

void Mac802_3::collision(Packet *p) {

        PRNT_MAC_FUNCS(this);

        if (mhIFS_.busy()) mhIFS_.cancel();

        double ifstime= netif_->txtime(int((IEEE_8023_JAMSIZE+IEEE_8023_IFS_BITS)/8.0)); //jam time + ifs
        mhIFS_.schedule(ifstime);

        switch(state_) {
        case MAC_SEND:
          // If mac trace feature is on generate a collision trace for this packet. 
                if (trace_)
                   drop(p);
                else
                   Packet::free(p);
                if (mhSend_.busy()) mhSend_.cancel();
                if (!mhRetx_.busy()) {
                        /* schedule retransmissions */
                        if (!mhRetx_.schedule(ifstime)) {
                                p= mhRetx_.packet();
                                hdr_cmn *th = hdr_cmn::access(p);
                                HDR_CMN(p)->size() -= (ETHER_HDR_LEN + HDR_MAC(p)->padding_);
                                fprintf(stderr,"BEB limit exceeded:Dropping packet %d\n",th->uid());
                                fflush(stderr);
                                drop(p); // drop if backed off far enough
                                mhRetx_.reset();
                        }
                }
                break;
        case MAC_RECV:
                Packet::free(p);
                // more than 2 packets collisions possible
                if (mhRecv_.busy()) mhRecv_.cancel();
                break;
        default:
                assert("SHOULD NEVER HAPPEN" == 0);
        }
}

void Mac802_3::recv_complete(Packet *p) {
        PRNT_MAC_FUNCS(this);
        assert(!mhRecv_.busy());
        assert(!mhSend_.busy());
        hdr_cmn *ch= HDR_CMN(p);
        /* Address Filtering */
        hdr_mac *mh= HDR_MAC(p);
        int dst= mh->macDA();

        if ((dst != BCAST_ADDR) && (dst != index_)) {
                Packet::free(p);
                goto done;
        }
        /* Strip off the mac header and padding if any */
        ch->size() -= (ETHER_HDR_LEN + mh->padding_);

        /* xxx FEC here */
        if( ch->error() ) {
                fprintf(stderr,"\nChecksum error\nDropping packet");
                fflush(stderr);
                // drop(p);
                Packet::free(p);
                goto done;
        }


        /* we could schedule an event to account for mac-delay */
        
        if ((p->ref_count() > 0) /* so the channel is using ref-copying */
            && (dst == BCAST_ADDR)) {
                /* make a real copy only if broadcasting, otherwise
                 * all nodes except the receiver are going to free
                 * this packet 
                 */
                uptarget_->recv(p->copy(), (Handler*) 0);
                Packet::free(p); // this will decrement ref counter
        } else {
                uptarget_->recv(p, (Handler*) 0);
        }

 done:
        mhIFS_.schedule(netif_->txtime(int(IEEE_8023_IFS_BITS/8.0)));// wait for one IFS, then resume
}

/* we call resume() in these cases:
   - successful transmission
   - whole packet's received
   - collision and backoffLimit's exceeded
   - collision while receiving */
void Mac802_3::resume() {
        PRNT_MAC_FUNCS(this);
        assert(!mhRecv_.busy());
        assert(!mhSend_.busy());
        assert(!mhIFS_.busy());

        state_= MAC_IDLE;

        if (mhRetx_.packet()) {
                if (!mhRetx_.busy()) {
                        // we're not backing off and not sensing carrier right now: send
                        transmit(mhRetx_.packet());
                }
        } else {
                if (callback_ && !mhRetx_.busy()) {
                        //WARNING: calling callback_->handle may change the value of callback_
                        Handler* h= callback_; 
                        callback_= 0;
                        h->handle(0);
                }
        }
}

---