diff options
Diffstat (limited to 'base')
| -rw-r--r-- | base/bitfield.hh | 8 | ||||
| -rw-r--r-- | base/callback.hh | 13 | ||||
| -rw-r--r-- | base/compression/null_compression.hh | 8 | ||||
| -rw-r--r-- | base/inet.cc | 170 | ||||
| -rw-r--r-- | base/inet.hh | 311 | ||||
| -rw-r--r-- | base/intmath.hh | 2 | ||||
| -rw-r--r-- | base/range.cc | 18 | ||||
| -rw-r--r-- | base/range.hh | 119 | ||||
| -rw-r--r-- | base/refcnt.hh | 33 | ||||
| -rw-r--r-- | base/remote_gdb.cc | 15 | ||||
| -rw-r--r-- | base/stats/types.hh | 2 |
11 files changed, 533 insertions, 166 deletions
diff --git a/base/bitfield.hh b/base/bitfield.hh index ee5ea72cf..bdc3fb13e 100644 --- a/base/bitfield.hh +++ b/base/bitfield.hh @@ -26,10 +26,10 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef __BITFIELD_HH -#define __BITFIELD_HH +#ifndef __BASE_BITFIELD_HH__ +#define __BASE_BITFIELD_HH__ -#include <inttypes.h> +#include "sim/host.hh" /** * Generate a 64-bit mask of 'nbits' 1s, right justified. @@ -66,4 +66,4 @@ sext(uint64_t val) return sign_bit ? (val | ~mask(N)) : val; } -#endif +#endif // __BASE_BITFIELD_HH__ diff --git a/base/callback.hh b/base/callback.hh index eee629cf5..342ab7e0f 100644 --- a/base/callback.hh +++ b/base/callback.hh @@ -103,4 +103,17 @@ class CallbackQueue } }; +template <class T, void (T::* F)()> +class MakeCallback : public Callback +{ + private: + T *object; + + public: + MakeCallback(T *o) + : object(o) + { } + void process() { (object->*F)(); } +}; + #endif // __CALLBACK_HH__ diff --git a/base/compression/null_compression.hh b/base/compression/null_compression.hh index 195498f1b..63364a955 100644 --- a/base/compression/null_compression.hh +++ b/base/compression/null_compression.hh @@ -26,16 +26,16 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef __NULL_COMPRESSION_HH__ -#define __NULL_COMPRESSION_HH__ +#ifndef __BASE_COMPRESSION_NULL_COMPRESSION_HH__ +#define __BASE_COMPRESSION_NULL_COMPRESSION_HH__ /** * @file * This file defines a doNothing compression algorithm. */ -#include <inttypes.h> // for uint8_t #include "base/misc.hh" // for fatal() +#include "sim/host.hh" /** @@ -73,4 +73,4 @@ class NullCompression } }; -#endif //__NULL_COMPRESSION_HH__ +#endif //__BASE_COMPRESSION_NULL_COMPRESSION_HH__ diff --git a/base/inet.cc b/base/inet.cc index 0b9e32854..eca7238ff 100644 --- a/base/inet.cc +++ b/base/inet.cc @@ -26,6 +26,7 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include <cstdio> #include <sstream> #include <string> @@ -34,29 +35,174 @@ #include "base/inet.hh" using namespace std; +namespace Net { + +EthAddr::EthAddr() +{ + memset(data, 0, ETH_ADDR_LEN); +} + +EthAddr::EthAddr(const uint8_t ea[ETH_ADDR_LEN]) +{ + *data = *ea; +} + +EthAddr::EthAddr(const eth_addr &ea) +{ + *data = *ea.data; +} + +EthAddr::EthAddr(const std::string &addr) +{ + parse(addr); +} + +const EthAddr & +EthAddr::operator=(const eth_addr &ea) +{ + *data = *ea.data; + return *this; +} + +const EthAddr & +EthAddr::operator=(const std::string &addr) +{ + parse(addr); + return *this; +} + +void +EthAddr::parse(const std::string &addr) +{ + // the hack below is to make sure that ETH_ADDR_LEN is 6 otherwise + // the sscanf function won't work. + int bytes[ETH_ADDR_LEN == 6 ? ETH_ADDR_LEN : -1]; + if (sscanf(addr.c_str(), "%x:%x:%x:%x:%x:%x", &bytes[0], &bytes[1], + &bytes[2], &bytes[3], &bytes[4], &bytes[5]) != ETH_ADDR_LEN) { + memset(data, 0xff, ETH_ADDR_LEN); + return; + } + + for (int i = 0; i < ETH_ADDR_LEN; ++i) { + if (bytes[i] & ~0xff) { + memset(data, 0xff, ETH_ADDR_LEN); + return; + } + + data[i] = bytes[i]; + } +} + string -eaddr_string(const uint8_t a[6]) +EthAddr::string() const { stringstream stream; + stream << *this; + return stream.str(); +} + +bool +operator==(const EthAddr &left, const EthAddr &right) +{ + return memcmp(left.bytes(), right.bytes(), ETH_ADDR_LEN); +} + +ostream & +operator<<(ostream &stream, const EthAddr &ea) +{ + const uint8_t *a = ea.addr(); ccprintf(stream, "%x:%x:%x:%x:%x:%x", a[0], a[1], a[2], a[3], a[4], a[5]); + return stream; +} - return stream.str(); +uint16_t +cksum(const IpPtr &ptr) +{ + int sum = ip_cksum_add(ptr->bytes(), ptr->hlen(), 0); + return ip_cksum_carry(sum); } uint16_t -IpHdr::ip_cksum() const +__tu_cksum(const IpPtr &ip) { - int sum = ip_cksum_add(this, hlen(), 0); - sum = ip_cksum_carry(sum); - return sum; + int tcplen = ip->len() - ip->hlen(); + int sum = ip_cksum_add(ip->payload(), tcplen, 0); + sum = ip_cksum_add(&ip->ip_src, 8, sum); // source and destination + sum += htons(ip->ip_p + tcplen); + return ip_cksum_carry(sum); } uint16_t -IpHdr::tu_cksum() const +cksum(const TcpPtr &tcp) +{ return __tu_cksum(IpPtr(tcp.packet())); } + +uint16_t +cksum(const UdpPtr &udp) +{ return __tu_cksum(IpPtr(udp.packet())); } + +bool +IpHdr::options(vector<const IpOpt *> &vec) const { - int sum = ip_cksum_add(payload(), len() - hlen(), 0); - sum = ip_cksum_add(&ip_src, 8, sum); // source and destination - sum += htons(ip_p + len() - hlen()); - sum = ip_cksum_carry(sum); - return sum; + vec.clear(); + + const uint8_t *data = bytes() + sizeof(struct ip_hdr); + int all = hlen() - sizeof(struct ip_hdr); + while (all > 0) { + const IpOpt *opt = (const IpOpt *)data; + int len = opt->len(); + if (all < len) + return false; + + vec.push_back(opt); + all -= len; + data += len; + } + + return true; } + +bool +TcpHdr::options(vector<const TcpOpt *> &vec) const +{ + vec.clear(); + + const uint8_t *data = bytes() + sizeof(struct tcp_hdr); + int all = off() - sizeof(struct tcp_hdr); + while (all > 0) { + const TcpOpt *opt = (const TcpOpt *)data; + int len = opt->len(); + if (all < len) + return false; + + vec.push_back(opt); + all -= len; + data += len; + } + + return true; +} + +bool +TcpOpt::sack(vector<SackRange> &vec) const +{ + vec.clear(); + + const uint8_t *data = bytes() + sizeof(struct tcp_hdr); + int all = len() - offsetof(tcp_opt, opt_data.sack); + while (all > 0) { + const uint16_t *sack = (const uint16_t *)data; + int len = sizeof(uint16_t) * 2; + if (all < len) { + vec.clear(); + return false; + } + + vec.push_back(RangeIn(ntohs(sack[0]), ntohs(sack[1]))); + all -= len; + data += len; + } + + return false; +} + +/* namespace Net */ } diff --git a/base/inet.hh b/base/inet.hh index 8a49790a7..7ea4de6bb 100644 --- a/base/inet.hh +++ b/base/inet.hh @@ -29,10 +29,16 @@ #ifndef __BASE_INET_HH__ #define __BASE_INET_HH__ +#include <iosfwd> #include <string> +#include <utility> +#include <vector> -#include "dnet/os.h" +#include "base/range.hh" +#include "dev/etherpkt.hh" +#include "sim/host.hh" +#include "dnet/os.h" #include "dnet/eth.h" #include "dnet/ip.h" #include "dnet/ip6.h" @@ -41,45 +47,90 @@ #include "dnet/icmp.h" #include "dnet/tcp.h" #include "dnet/udp.h" - #include "dnet/intf.h" #include "dnet/route.h" #include "dnet/fw.h" - #include "dnet/blob.h" #include "dnet/rand.h" -#include "sim/host.hh" +namespace Net { -std::string eaddr_string(const uint8_t a[6]); +/* + * Ethernet Stuff + */ +struct EthAddr : protected eth_addr +{ + protected: + void parse(const std::string &addr); -struct EthHdr; -struct IpHdr; -struct TcpHdr; -struct UdpHdr; + public: + EthAddr(); + EthAddr(const uint8_t ea[ETH_ADDR_LEN]); + EthAddr(const eth_addr &ea); + EthAddr(const std::string &addr); + const EthAddr &operator=(const eth_addr &ea); + const EthAddr &operator=(const std::string &addr); -struct EthHdr : protected eth_hdr -{ - uint16_t type() const { return ntohs(eth_type); } + int size() const { return sizeof(eth_addr); } - const IpHdr *ip() const - { return type() == ETH_TYPE_IP ? (const IpHdr *)payload() : 0; } + const uint8_t *bytes() const { return &data[0]; } + uint8_t *bytes() { return &data[0]; } - IpHdr *ip() - { return type() == ETH_TYPE_IP ? (IpHdr *)payload() : 0; } + const uint8_t *addr() const { return &data[0]; } + bool unicast() const { return data[0] == 0x00; } + bool multicast() const { return data[0] == 0x01; } + bool broadcast() const { return data[0] == 0xff; } + std::string string() const; +}; + +std::ostream &operator<<(std::ostream &stream, const EthAddr &ea); +bool operator==(const EthAddr &left, const EthAddr &right); + +struct EthHdr : public eth_hdr +{ + uint16_t type() const { return ntohs(eth_type); } + const EthAddr &src() const { return *(EthAddr *)ð_src; } + const EthAddr &dst() const { return *(EthAddr *)ð_dst; } - bool unicast() { return eth_dst.data[0] == 0x00; } - bool multicast() { return eth_dst.data[0] == 0x01; } - bool broadcast() { return eth_dst.data[0] == 0xff; } + int size() const { return sizeof(eth_hdr); } - int size() const { return sizeof(EthHdr); } const uint8_t *bytes() const { return (const uint8_t *)this; } const uint8_t *payload() const { return bytes() + size(); } uint8_t *bytes() { return (uint8_t *)this; } uint8_t *payload() { return bytes() + size(); } }; -struct IpHdr : protected ip_hdr +class EthPtr +{ + protected: + friend class IpPtr; + PacketPtr p; + + public: + EthPtr() {} + EthPtr(const PacketPtr &ptr) : p(ptr) { } + + EthHdr *operator->() { return (EthHdr *)p->data; } + EthHdr &operator*() { return *(EthHdr *)p->data; } + operator EthHdr *() { return (EthHdr *)p->data; } + + const EthHdr *operator->() const { return (const EthHdr *)p->data; } + const EthHdr &operator*() const { return *(const EthHdr *)p->data; } + operator const EthHdr *() const { return (const EthHdr *)p->data; } + + const EthPtr &operator=(const PacketPtr &ptr) { p = ptr; return *this; } + + const PacketPtr packet() const { return p; } + PacketPtr packet() { return p; } + bool operator!() const { return !p; } + operator bool() const { return p; } +}; + +/* + * IP Stuff + */ +struct IpOpt; +struct IpHdr : public ip_hdr { uint8_t version() const { return ip_v; } uint8_t hlen() const { return ip_hl * 4; } @@ -96,19 +147,7 @@ struct IpHdr : protected ip_hdr void sum(uint16_t sum) { ip_sum = sum; } - uint16_t ip_cksum() const; - uint16_t tu_cksum() const; - - const TcpHdr *tcp() const - { return proto() == IP_PROTO_TCP ? (const TcpHdr *)payload() : 0; } - const UdpHdr *udp() const - { return proto() == IP_PROTO_UDP ? (const UdpHdr *)payload() : 0; } - - TcpHdr *tcp() - { return proto() == IP_PROTO_TCP ? (TcpHdr *)payload() : 0; } - UdpHdr *udp() - { return proto() == IP_PROTO_UDP ? (UdpHdr *)payload() : 0; } - + bool options(std::vector<const IpOpt *> &vec) const; int size() const { return hlen(); } const uint8_t *bytes() const { return (const uint8_t *)this; } @@ -117,7 +156,84 @@ struct IpHdr : protected ip_hdr uint8_t *payload() { return bytes() + size(); } }; -struct TcpHdr : protected tcp_hdr +class IpPtr +{ + protected: + friend class TcpPtr; + friend class UdpPtr; + PacketPtr p; + + const IpHdr *h() const + { return (const IpHdr *)(p->data + sizeof(eth_hdr)); } + IpHdr *h() { return (IpHdr *)(p->data + sizeof(eth_hdr)); } + + void set(const PacketPtr &ptr) + { + EthHdr *eth = (EthHdr *)ptr->data; + if (eth->type() == ETH_TYPE_IP) + p = ptr; + else + p = 0; + } + + public: + IpPtr() {} + IpPtr(const PacketPtr &ptr) { set(ptr); } + IpPtr(const EthPtr &ptr) { set(ptr.p); } + IpPtr(const IpPtr &ptr) : p(ptr.p) { } + + IpHdr *operator->() { return h(); } + IpHdr &operator*() { return *h(); } + operator IpHdr *() { return h(); } + + const IpHdr *operator->() const { return h(); } + const IpHdr &operator*() const { return *h(); } + operator const IpHdr *() const { return h(); } + + const IpPtr &operator=(const PacketPtr &ptr) { set(ptr); return *this; } + const IpPtr &operator=(const EthPtr &ptr) { set(ptr.p); return *this; } + const IpPtr &operator=(const IpPtr &ptr) { p = ptr.p; return *this; } + + const PacketPtr packet() const { return p; } + PacketPtr packet() { return p; } + bool operator!() const { return !p; } + operator bool() const { return p; } + operator bool() { return p; } +}; + +uint16_t cksum(const IpPtr &ptr); + +struct IpOpt : public ip_opt +{ + uint8_t type() const { return opt_type; } + uint8_t typeNumber() const { return IP_OPT_NUMBER(opt_type); } + uint8_t typeClass() const { return IP_OPT_CLASS(opt_type); } + uint8_t typeCopied() const { return IP_OPT_COPIED(opt_type); } + uint8_t len() const { return IP_OPT_TYPEONLY(type()) ? 1 : opt_len; } + + bool isNumber(int num) const { return typeNumber() == IP_OPT_NUMBER(num); } + bool isClass(int cls) const { return typeClass() == IP_OPT_CLASS(cls); } + bool isCopied(int cpy) const { return typeCopied() == IP_OPT_COPIED(cpy); } + + const uint8_t *data() const { return opt_data.data8; } + void sec(ip_opt_data_sec &sec) const; + void lsrr(ip_opt_data_rr &rr) const; + void ssrr(ip_opt_data_rr &rr) const; + void ts(ip_opt_data_ts &ts) const; + uint16_t satid() const { return ntohs(opt_data.satid); } + uint16_t mtup() const { return ntohs(opt_data.mtu); } + uint16_t mtur() const { return ntohs(opt_data.mtu); } + void tr(ip_opt_data_tr &tr) const; + const uint32_t *addext() const { return &opt_data.addext[0]; } + uint16_t rtralt() const { return ntohs(opt_data.rtralt); } + void sdb(std::vector<uint32_t> &vec) const; +}; + +/* + * TCP Stuff + */ +struct TcpOpt; +struct TcpHdr : public tcp_hdr { uint16_t sport() const { return ntohs(th_sport); } uint16_t dport() const { return ntohs(th_dport); } @@ -131,6 +247,8 @@ struct TcpHdr : protected tcp_hdr void sum(uint16_t sum) { th_sum = sum; } + bool options(std::vector<const TcpOpt *> &vec) const; + int size() const { return off(); } const uint8_t *bytes() const { return (const uint8_t *)this; } const uint8_t *payload() const { return bytes() + size(); } @@ -138,7 +256,81 @@ struct TcpHdr : protected tcp_hdr uint8_t *payload() { return bytes() + size(); } }; -struct UdpHdr : protected udp_hdr +class TcpPtr +{ + protected: + PacketPtr p; + int off; + + const TcpHdr *h() const { return (const TcpHdr *)(p->data + off); } + TcpHdr *h() { return (TcpHdr *)(p->data + off); } + + void set(const PacketPtr &ptr, int offset) { p = ptr; off = offset; } + void set(const IpPtr &ptr) + { + if (ptr->proto() == IP_PROTO_TCP) + set(ptr.p, sizeof(eth_hdr) + ptr->hlen()); + else + set(0, 0); + } + + public: + TcpPtr() {} + TcpPtr(const IpPtr &ptr) { set(ptr); } + TcpPtr(const TcpPtr &ptr) : p(ptr.p), off(ptr.off) {} + + TcpHdr *operator->() { return h(); } + TcpHdr &operator*() { return *h(); } + operator TcpHdr *() { return h(); } + + const TcpHdr *operator->() const { return h(); } + const TcpHdr &operator*() const { return *h(); } + operator const TcpHdr *() const { return h(); } + + const TcpPtr &operator=(const IpPtr &i) { set(i); return *this; } + const TcpPtr &operator=(const TcpPtr &t) { set(t.p, t.off); return *this; } + + const PacketPtr packet() const { return p; } + PacketPtr packet() { return p; } + bool operator!() const { return !p; } + operator bool() const { return p; } + operator bool() { return p; } +}; + +uint16_t cksum(const TcpPtr &ptr); + +typedef Range<uint16_t> SackRange; + +struct TcpOpt : public tcp_opt +{ + uint8_t type() const { return opt_type; } + uint8_t len() const { return TCP_OPT_TYPEONLY(type()) ? 1 : opt_len; } + + bool isopt(int opt) const { return type() == opt; } + + const uint8_t *data() const { return opt_data.data8; } + + uint16_t mss() const { return ntohs(opt_data.mss); } + uint8_t wscale() const { return opt_data.wscale; } + bool sack(std::vector<SackRange> &vec) const; + uint32_t echo() const { return ntohl(opt_data.echo); } + uint32_t tsval() const { return ntohl(opt_data.timestamp[0]); } + uint32_t tsecr() const { return ntohl(opt_data.timestamp[1]); } + uint32_t cc() const { return ntohl(opt_data.cc); } + uint8_t cksum() const{ return opt_data.cksum; } + const uint8_t *md5() const { return opt_data.md5; } + + int size() const { return len(); } + const uint8_t *bytes() const { return (const uint8_t *)this; } + const uint8_t *payload() const { return bytes() + size(); } + uint8_t *bytes() { return (uint8_t *)this; } + uint8_t *payload() { return bytes() + size(); } +}; + +/* + * UDP Stuff + */ +struct UdpHdr : public udp_hdr { uint16_t sport() const { return ntohs(uh_sport); } uint16_t dport() const { return ntohs(uh_dport); } @@ -147,11 +339,56 @@ struct UdpHdr : protected udp_hdr void sum(uint16_t sum) { uh_sum = htons(sum); } - int size() const { return sizeof(UdpHdr); } + int size() const { return sizeof(udp_hdr); } const uint8_t *bytes() const { return (const uint8_t *)this; } const uint8_t *payload() const { return bytes() + size(); } uint8_t *bytes() { return (uint8_t *)this; } uint8_t *payload() { return bytes() + size(); } }; +class UdpPtr +{ + protected: + PacketPtr p; + int off; + + const UdpHdr *h() const { return (const UdpHdr *)(p->data + off); } + UdpHdr *h() { return (UdpHdr *)(p->data + off); } + + void set(const PacketPtr &ptr, int offset) { p = ptr; off = offset; } + void set(const IpPtr &ptr) + { + if (ptr->proto() == IP_PROTO_UDP) + set(ptr.p, sizeof(eth_hdr) + ptr->hlen()); + else + set(0, 0); + } + + public: + UdpPtr() {} + UdpPtr(const IpPtr &ptr) { set(ptr); } + UdpPtr(const UdpPtr &ptr) : p(ptr.p), off(ptr.off) {} + + UdpHdr *operator->() { return h(); } + UdpHdr &operator*() { return *h(); } + operator UdpHdr *() { return h(); } + + const UdpHdr *operator->() const { return h(); } + const UdpHdr &operator*() const { return *h(); } + operator const UdpHdr *() const { return h(); } + + const UdpPtr &operator=(const IpPtr &i) { set(i); return *this; } + const UdpPtr &operator=(const UdpPtr &t) { set(t.p, t.off); return *this; } + + const PacketPtr packet() const { return p; } + PacketPtr packet() { return p; } + bool operator!() const { return !p; } + operator bool() const { return p; } + operator bool() { return p; } +}; + +uint16_t cksum(const UdpPtr &ptr); + +/* namespace Net */ } + #endif // __BASE_INET_HH__ diff --git a/base/intmath.hh b/base/intmath.hh index 821514668..5ffe27103 100644 --- a/base/intmath.hh +++ b/base/intmath.hh @@ -120,7 +120,7 @@ FloorLog2(int64_t x) } #if defined(__APPLE__) -int +inline int FloorLog2(size_t x) { assert(x > 0); diff --git a/base/range.cc b/base/range.cc index 4453ecc9f..1087c02c8 100644 --- a/base/range.cc +++ b/base/range.cc @@ -34,12 +34,12 @@ using namespace std; template <class T> bool -__x_parse_range(const std::string &str, T &start, T &end) +__x_parse_range(const std::string &str, T &first, T &last) { std::vector<std::string> values; tokenize(values, str, ':'); - T thestart, theend; + T thefirst, thelast; if (values.size() != 2) return false; @@ -47,29 +47,29 @@ __x_parse_range(const std::string &str, T &start, T &end) std::string s = values[0]; std::string e = values[1]; - if (!to_number(s, thestart)) + if (!to_number(s, thefirst)) return false; bool increment = (e[0] == '+'); if (increment) e = e.substr(1); - if (!to_number(e, theend)) + if (!to_number(e, thelast)) return false; if (increment) - theend += thestart; + thelast += thefirst - 1; - start = thestart; - end = theend; + first = thefirst; + last = thelast; return true; } #define RANGE_PARSE(type) \ template<> bool \ -__parse_range(const std::string &s, type &start, type &end) \ -{ return __x_parse_range(s, start, end); } +__parse_range(const std::string &s, type &first, type &last) \ +{ return __x_parse_range(s, first, last); } RANGE_PARSE(unsigned long long); RANGE_PARSE(signed long long); diff --git a/base/range.hh b/base/range.hh index 2197e2f86..9289792ea 100644 --- a/base/range.hh +++ b/base/range.hh @@ -26,44 +26,32 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef __RANGE_HH__ -#define __RANGE_HH__ +#ifndef __BASE_RANGE_HH__ +#define __BASE_RANGE_HH__ #include <cassert> #include <string> +/** + * @param s range string + * EndExclusive Ranges are in the following format: + * <range> := {<start_val>}:{<end>} + * <start> := <end_val> | +<delta> + */ template <class T> bool __parse_range(const std::string &s, T &start, T &end); template <class T> struct Range { - private: - /** - * @param s range string - * Ranges are in the following format: - * <range> := {<start_val>}:{<end>} - * <end> := <end_val> | +<delta> - */ - void - parse(const std::string &s) - { - if (!__parse_range(s, start, end)) - invalidate(); - } - - public: T start; T end; - public: - Range() - { - invalidate(); - } + Range() { invalidate(); } - Range(T first, T second) - : start(first), end(second) + template <class U> + Range(const std::pair<U, U> &r) + : start(r.first), end(r.second) {} template <class U> @@ -71,14 +59,10 @@ struct Range : start(r.start), end(r.end) {} - template <class U> - Range(const std::pair<U, U> &r) - : start(r.first), end(r.second) - {} - Range(const std::string &s) { - parse(s); + if (!__parse_range(s, start, end)) + invalidate(); } template <class U> @@ -99,32 +83,39 @@ struct Range const Range &operator=(const std::string &s) { - parse(s); + if (!__parse_range(s, start, end)) + invalidate(); return *this; } - void invalidate() { start = 0; end = 0; } - T size() const { return end - start; } + void invalidate() { start = 1; end = 0; } + T size() const { return end - start + 1; } bool valid() const { return start < end; } }; template <class T> -inline Range<T> -make_range(T start, T end) -{ - return Range<T>(start, end); -} - -template <class T> inline std::ostream & operator<<(std::ostream &o, const Range<T> &r) { - // don't currently support output of invalid ranges - assert(r.valid()); - o << r.start << ":" << r.end; + o << '[' << r.start << "," << r.end << ']'; return o; } +template <class T> +inline Range<T> +RangeEx(T start, T end) +{ return std::make_pair(start, end - 1); } + +template <class T> +inline Range<T> +RangeIn(T start, T end) +{ return std::make_pair(start, end); } + +template <class T, class U> +inline Range<T> +RangeSize(T start, U size) +{ return std::make_pair(start, start + size - 1); } + //////////////////////////////////////////////////////////////////////// // // Range to Range Comparisons @@ -139,7 +130,6 @@ template <class T, class U> inline bool operator==(const Range<T> &range1, const Range<U> &range2) { - assert(range1.valid() && range2.valid()); return range1.start == range2.start && range1.end == range2.end; } @@ -152,7 +142,6 @@ template <class T, class U> inline bool operator!=(const Range<T> &range1, const Range<U> &range2) { - assert(range1.valid() && range2.valid()); return range1.start != range2.start || range1.end != range2.end; } @@ -165,8 +154,7 @@ template <class T, class U> inline bool operator<(const Range<T> &range1, const Range<U> &range2) { - assert(range1.valid() && range2.valid()); - return range1.end <= range2.start; + return range1.start < range2.start; } /** @@ -179,8 +167,7 @@ template <class T, class U> inline bool operator<=(const Range<T> &range1, const Range<U> &range2) { - assert(range1.valid() && range2.valid()); - return range1.start <= range2.start && range1.end <= range2.end; + return range1.start <= range2.start; } /** @@ -192,8 +179,7 @@ template <class T, class U> inline bool operator>(const Range<T> &range1, const Range<U> &range2) { - assert(range1.valid() && range2.valid()); - return range1.start >= range2.end; + return range1.start > range2.start; } /** @@ -206,8 +192,7 @@ template <class T, class U> inline bool operator>=(const Range<T> &range1, const Range<U> &range2) { - assert(range1.valid() && range2.valid()); - return range1.start >= range2.start && range1.end >= range2.end; + return range1.start >= range2.start; } //////////////////////////////////////////////////////////////////////// @@ -224,7 +209,6 @@ template <class T, class U> inline bool operator==(const T &pos, const Range<U> &range) { - assert(range.valid()); return pos >= range.start && pos <= range.end; } @@ -237,8 +221,7 @@ template <class T, class U> inline bool operator!=(const T &pos, const Range<U> &range) { - assert(range.valid()); - return pos < range.start || pos >= range.end; + return pos < range.start || pos > range.end; } /** @@ -250,7 +233,6 @@ template <class T, class U> inline bool operator<(const T &pos, const Range<U> &range) { - assert(range.valid()); return pos < range.start; } @@ -263,8 +245,7 @@ template <class T, class U> inline bool operator<=(const T &pos, const Range<U> &range) { - assert(range.valid()); - return pos < range.end; + return pos <= range.end; } /** @@ -276,8 +257,7 @@ template <class T, class U> inline bool operator>(const T &pos, const Range<U> &range) { - assert(range.valid()); - return pos >= range.end; + return pos > range.end; } /** @@ -289,7 +269,6 @@ template <class T, class U> inline bool operator>=(const T &pos, const Range<U> &range) { - assert(range.valid()); return pos >= range.start; } @@ -307,8 +286,7 @@ template <class T, class U> inline bool operator==(const Range<T> &range, const U &pos) { - assert(range.valid()); - return pos >= range.start && pos < range.end; + return pos >= range.start && pos <= range.end; } /** @@ -320,8 +298,7 @@ template <class T, class U> inline bool operator!=(const Range<T> &range, const U &pos) { - assert(range.valid()); - return pos < range.start || pos >= range.end; + return pos < range.start || pos > range.end; } /** @@ -333,8 +310,7 @@ template <class T, class U> inline bool operator<(const Range<T> &range, const U &pos) { - assert(range.valid()); - return range.end <= pos; + return range.end < pos; } /** @@ -346,7 +322,6 @@ template <class T, class U> inline bool operator<=(const Range<T> &range, const U &pos) { - assert(range.valid()); return range.start <= pos; } @@ -359,7 +334,6 @@ template <class T, class U> inline bool operator>(const Range<T> &range, const U &pos) { - assert(range.valid()); return range.start > pos; } @@ -372,8 +346,7 @@ template <class T, class U> inline bool operator>=(const Range<T> &range, const U &pos) { - assert(range.valid()); - return range.end > pos; + return range.end >= pos; } -#endif // __RANGE_HH__ +#endif // __BASE_RANGE_HH__ diff --git a/base/refcnt.hh b/base/refcnt.hh index 251dc905b..00ba8fa4a 100644 --- a/base/refcnt.hh +++ b/base/refcnt.hh @@ -51,15 +51,26 @@ class RefCountingPtr protected: T *data; - void copy(T *d) { + void copy(T *d) + { data = d; if (data) data->incref(); } - void del() { + void del() + { if (data) data->decref(); } + void set(T *d) + { + if (data == d) + return; + + del(); + copy(d); + } + public: RefCountingPtr() : data(NULL) {} @@ -75,21 +86,9 @@ class RefCountingPtr const T &operator*() const { return *data; } const T *get() const { return data; } - RefCountingPtr &operator=(T *p) { - if (data != p) { - del(); - copy(p); - } - return *this; - } - - RefCountingPtr &operator=(const RefCountingPtr &r) { - if (data != r.data) { - del(); - copy(r.data); - } - return *this; - } + RefCountingPtr &operator=(T *p) { set(p); return *this; } + RefCountingPtr &operator=(const RefCountingPtr &r) + { return operator=(r.data); } bool operator!() const { return data == 0; } operator bool() const { return data != 0; } diff --git a/base/remote_gdb.cc b/base/remote_gdb.cc index 41f11005d..598f03c35 100644 --- a/base/remote_gdb.cc +++ b/base/remote_gdb.cc @@ -326,14 +326,13 @@ bool RemoteGDB::acc(Addr va, size_t len) { Addr last_va; - Addr pte; - va = alpha_trunc_page(va); - last_va = alpha_round_page(va + len); + va = TheISA::TruncPage(va); + last_va = TheISA::RoundPage(va + len); do { - if (va >= ALPHA_K0SEG_BASE && va < ALPHA_K1SEG_BASE) { - if (va < (ALPHA_K0SEG_BASE + pmem->size())) { + if (TheISA::IsK0Seg(va)) { + if (va < (TheISA::K0SegBase + pmem->size())) { DPRINTF(GDBAcc, "acc: Mapping is valid K0SEG <= " "%#x < K0SEG + size\n", va); return true; @@ -355,12 +354,12 @@ RemoteGDB::acc(Addr va, size_t len) return true; Addr ptbr = context->regs.ipr[AlphaISA::IPR_PALtemp20]; - pte = kernel_pte_lookup(pmem, ptbr, va); - if (!pte || !entry_valid(pmem->phys_read_qword(pte))) { + TheISA::PageTableEntry pte = kernel_pte_lookup(pmem, ptbr, va); + if (!pte.valid()) { DPRINTF(GDBAcc, "acc: %#x pte is invalid\n", va); return false; } - va += ALPHA_PGBYTES; + va += TheISA::PageBytes; } while (va < last_va); DPRINTF(GDBAcc, "acc: %#x mapping is valid\n", va); diff --git a/base/stats/types.hh b/base/stats/types.hh index fbabfb118..8e45531fb 100644 --- a/base/stats/types.hh +++ b/base/stats/types.hh @@ -30,7 +30,7 @@ #define __BASE_STATS_TYPES_HH__ #include <vector> -#include <inttypes.h> +#include "sim/host.hh" namespace Stats { |