You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by ge...@apache.org on 2010/02/24 19:48:52 UTC

svn commit: r915922 [8/14] - in /incubator/trafficserver/traffic/trunk: ./ install/ iocore/aio/ iocore/block-cache/ iocore/cache/ iocore/cluster/ iocore/dns/ iocore/eventsystem/ iocore/hostdb/ iocore/net/ iocore/utils/ libev/ libev/CVS/ libinktomi++/ l...

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h Wed Feb 24 18:48:42 2010
@@ -33,32 +33,25 @@
 // +1 for each power of 2
 //
 //////////////////////////////////////////////////////////////
-INK_INLINE int
-buffer_size_to_index(unsigned int size, int max = max_iobuffer_size)
+inline ink64
+buffer_size_to_index(ink64 size, ink64 max = max_iobuffer_size)
 {
   int r = max;
-  while (r && ((unsigned int) BUFFER_SIZE_FOR_INDEX(r - 1)) >= size)
+  while (r && BUFFER_SIZE_FOR_INDEX(r - 1) >= size)
     r--;
   return r;
 }
 
-INK_INLINE int
-iobuffer_size_to_index(unsigned int size, int max)
+inline ink64
+iobuffer_size_to_index(ink64 size, ink64 max)
 {
-  if (size > DEFAULT_MAX_BUFFER_SIZE) {
-    ////////////////////////////////////////////////////
-    // BUFFER_SIZE_INDEX_FOR_XMALLOC_SIZE returns the //
-    // negative of its argument. The argument must be //
-    // a signed int, otherwise the returned value is  //
-    // also unsigned.                                 //
-    ////////////////////////////////////////////////////
-    return BUFFER_SIZE_INDEX_FOR_XMALLOC_SIZE((int) size);
-  }
+  if (size > BUFFER_SIZE_FOR_INDEX(max))
+    return BUFFER_SIZE_INDEX_FOR_XMALLOC_SIZE(size);
   return buffer_size_to_index(size, max);
 }
 
-INK_INLINE int
-index_to_buffer_size(int idx)
+inline ink64
+index_to_buffer_size(ink64 idx)
 {
   if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(idx))
     return BUFFER_SIZE_FOR_INDEX(idx);
@@ -71,8 +64,8 @@
   return 0;
 }
 
-INK_INLINE IOBufferBlock *
-iobufferblock_clone(IOBufferBlock * b, int offset, int len)
+inline IOBufferBlock *
+iobufferblock_clone(IOBufferBlock * b, ink64 offset, ink64 len)
 {
 
   IOBufferBlock *start_buf = NULL;
@@ -81,14 +74,14 @@
   while (b && len >= 0) {
     char *start = b->_start;
     char *end = b->_end;
-    int max_bytes = end - start;
+    ink64 max_bytes = end - start;
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
       b = b->next;
       continue;
     }
-    int bytes = len;
+    ink64 bytes = len;
     if (bytes >= max_bytes)
       bytes = max_bytes;
     IOBufferBlock *new_buf = b->clone();
@@ -108,13 +101,13 @@
   return start_buf;
 }
 
-INK_INLINE IOBufferBlock *
-iobufferblock_skip(IOBufferBlock * b, int *poffset, int *plen, int write)
+inline IOBufferBlock *
+iobufferblock_skip(IOBufferBlock * b, ink64 *poffset, ink64 *plen, ink64 write)
 {
-  int offset = *poffset;
-  int len = write;
+  ink64 offset = *poffset;
+  ink64 len = write;
   while (b && len >= 0) {
-    int max_bytes = b->read_avail();
+    ink64 max_bytes = b->read_avail();
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
@@ -139,8 +132,8 @@
 struct Resource;
 extern Resource *res_lookup(const char *path);
 
-INK_INLINE void
-iobuffer_mem_inc(const char *_loc, int _size_index)
+inline void
+iobuffer_mem_inc(const char *_loc, ink64 _size_index)
 {
   if (!res_track_memory)
     return;
@@ -166,8 +159,8 @@
   ink_debug_assert(r >= 0);
 }
 
-INK_INLINE void
-iobuffer_mem_dec(const char *_loc, int _size_index)
+inline void
+iobuffer_mem_dec(const char *_loc, ink64 _size_index)
 {
   if (!res_track_memory)
     return;
@@ -194,27 +187,27 @@
 
 //////////////////////////////////////////////////////////////////
 //
-// INK_INLINE functions definitions
+// inline functions definitions
 //
 //////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////
 //
 //  class IOBufferData --
-//         INK_INLINE functions definitions
+//         inline functions definitions
 //
 //////////////////////////////////////////////////////////////////
-INK_INLINE int
+inline ink64
 IOBufferData::block_size()
 {
   return index_to_buffer_size(_size_index);
 }
 
-INK_INLINE IOBufferData *
+inline IOBufferData *
 new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                            const char *location,
 #endif
-                           void *b, int size, int asize_index)
+                           void *b, ink64 size, ink64 asize_index)
 {
   (void) size;
   IOBufferData *d = ioDataAllocator.alloc();
@@ -228,12 +221,12 @@
   return d;
 }
 
-INK_INLINE IOBufferData *
+inline IOBufferData *
 new_constant_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                                     const char *loc,
 #endif
-                                    void *b, int size)
+                                    void *b, ink64 size)
 {
   return new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
@@ -242,12 +235,12 @@
                                     b, size, BUFFER_SIZE_INDEX_FOR_CONSTANT_SIZE(size));
 }
 
-INK_INLINE IOBufferData *
+inline IOBufferData *
 new_xmalloc_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                                    const char *location,
 #endif
-                                   void *b, int size)
+                                   void *b, ink64 size)
 {
   return new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
@@ -256,12 +249,12 @@
                                     b, size, BUFFER_SIZE_INDEX_FOR_XMALLOC_SIZE(size));
 }
 
-INK_INLINE IOBufferData *
+inline IOBufferData *
 new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                            const char *location,
 #endif
-                           void *b, int size)
+                           void *b, ink64 size)
 {
   return new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
@@ -270,12 +263,12 @@
                                     b, size, iobuffer_size_to_index(size));
 }
 
-INK_INLINE IOBufferData *
+inline IOBufferData *
 new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                            const char *loc,
 #endif
-                           int size_index, AllocType type)
+                           ink64 size_index, AllocType type)
 {
   IOBufferData *d = ioDataAllocator.alloc();
 #ifdef TRACK_BUFFER_USER
@@ -289,8 +282,8 @@
 // from being compiled correctly at -O3
 // so it is DUPLICATED in IOBuffer.cc
 // ****** IF YOU CHANGE THIS FUNCTION change that one as well.
-INK_INLINE void
-IOBufferData::alloc(int size_index, AllocType type)
+inline void
+IOBufferData::alloc(ink64 size_index, AllocType type)
 {
   if (_data)
     dealloc();
@@ -303,7 +296,6 @@
   case MEMALIGNED:
     if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(size_index))
       _data = (char *) ioBufAllocator[size_index].alloc_void();
-    // This really can happen, since the above IF casts to an (unsigned int)
     // coverity[dead_error_condition]
     else if (BUFFER_SIZE_INDEX_IS_XMALLOCED(size_index))
       // coverity[dead_error_line]
@@ -322,7 +314,7 @@
 // ****** IF YOU CHANGE THIS FUNCTION change that one as well.
 
 
-INK_INLINE void
+inline void
 IOBufferData::dealloc()
 {
 #ifdef TRACK_BUFFER_USER
@@ -348,7 +340,7 @@
   _mem_type = NO_ALLOC;
 }
 
-INK_INLINE void
+inline void
 IOBufferData::free()
 {
   dealloc();
@@ -358,10 +350,10 @@
 //////////////////////////////////////////////////////////////////
 //
 //  class IOBufferBlock --
-//         INK_INLINE functions definitions
+//         inline functions definitions
 //
 //////////////////////////////////////////////////////////////////
-INK_INLINE IOBufferBlock *
+inline IOBufferBlock *
 new_IOBufferBlock_internal(
 #ifdef TRACK_BUFFER_USER
                             const char *location
@@ -375,12 +367,12 @@
   return b;
 }
 
-INK_INLINE IOBufferBlock *
+inline IOBufferBlock *
 new_IOBufferBlock_internal(
 #ifdef TRACK_BUFFER_USER
                             const char *location,
 #endif
-                            IOBufferData * d, int len, int offset)
+                            IOBufferData * d, ink64 len, ink64 offset)
 {
   IOBufferBlock *b = ioBlockAllocator.alloc();
 #ifdef TRACK_BUFFER_USER
@@ -390,7 +382,7 @@
   return b;
 }
 
-INK_INLINE
+inline
 IOBufferBlock::IOBufferBlock():
 _start(0),
 _end(0),
@@ -403,29 +395,29 @@
   return;
 }
 
-INK_INLINE void
-IOBufferBlock::consume(int len)
+inline void
+IOBufferBlock::consume(ink64 len)
 {
   _start += len;
   ink_assert(_start <= _end);
 }
 
-INK_INLINE void
-IOBufferBlock::fill(int len)
+inline void
+IOBufferBlock::fill(ink64 len)
 {
   _end += len;
   ink_assert(_end <= _buf_end);
 }
 
-INK_INLINE void
+inline void
 IOBufferBlock::reset()
 {
   _end = _start = buf();
   _buf_end = buf() + data->block_size();
 }
 
-INK_INLINE void
-IOBufferBlock::alloc(int i)
+inline void
+IOBufferBlock::alloc(ink64 i)
 {
   ink_debug_assert(BUFFER_SIZE_ALLOCATED(i));
 #ifdef TRACK_BUFFER_USER
@@ -436,7 +428,7 @@
   reset();
 }
 
-INK_INLINE void
+inline void
 IOBufferBlock::clear()
 {
   data = NULL;
@@ -456,7 +448,7 @@
   _buf_end = _end = _start = NULL;
 }
 
-INK_INLINE IOBufferBlock *
+inline IOBufferBlock *
 IOBufferBlock::clone()
 {
 #ifdef TRACK_BUFFER_USER
@@ -474,21 +466,21 @@
   return b;
 }
 
-INK_INLINE void
+inline void
 IOBufferBlock::dealloc()
 {
   clear();
 }
 
-INK_INLINE void
+inline void
 IOBufferBlock::free()
 {
   dealloc();
   ioBlockAllocator.free(this);
 }
 
-INK_INLINE void
-IOBufferBlock::set_internal(void *b, int len, int asize_index)
+inline void
+IOBufferBlock::set_internal(void *b, ink64 len, ink64 asize_index)
 {
 #ifdef TRACK_BUFFER_USER
   data = new_IOBufferData_internal(_location, BUFFER_SIZE_NOT_ALLOCATED);
@@ -504,8 +496,8 @@
   _end = _start + len;
 }
 
-INK_INLINE void
-IOBufferBlock::set(IOBufferData * d, int len, int offset)
+inline void
+IOBufferBlock::set(IOBufferData * d, ink64 len, ink64 offset)
 {
   data = d;
   _start = buf() + offset;
@@ -513,40 +505,40 @@
   _buf_end = _start + d->block_size();
 }
 
-INK_INLINE void
-IOBufferBlock::realloc_set_internal(void *b, int buf_size, int asize_index)
+inline void
+IOBufferBlock::realloc_set_internal(void *b, ink64 buf_size, ink64 asize_index)
 {
-  int data_size = size();
+  ink64 data_size = size();
   memcpy(b, _start, size());
   dealloc();
   set_internal(b, buf_size, asize_index);
   _end = _start + data_size;
 }
 
-INK_INLINE void
-IOBufferBlock::realloc(void *b, int buf_size)
+inline void
+IOBufferBlock::realloc(void *b, ink64 buf_size)
 {
   realloc_set_internal(b, buf_size, BUFFER_SIZE_NOT_ALLOCATED);
 }
 
-INK_INLINE void
-IOBufferBlock::realloc_xmalloc(void *b, int buf_size)
+inline void
+IOBufferBlock::realloc_xmalloc(void *b, ink64 buf_size)
 {
   realloc_set_internal(b, buf_size, -buf_size);
 }
 
-INK_INLINE void
-IOBufferBlock::realloc_xmalloc(int buf_size)
+inline void
+IOBufferBlock::realloc_xmalloc(ink64 buf_size)
 {
   realloc_set_internal(xmalloc(buf_size), buf_size, -buf_size);
 }
 
-INK_INLINE void
-IOBufferBlock::realloc(int i)
+inline void
+IOBufferBlock::realloc(ink64 i)
 {
   if (i == data->_size_index)
     return;
-  if (i >= (int) sizeof(ioBufAllocator))
+  if (i >= (ink64) sizeof(ioBufAllocator))
     return;
 
   ink_release_assert(i > data->_size_index && i != BUFFER_SIZE_NOT_ALLOCATED);
@@ -557,10 +549,10 @@
 //////////////////////////////////////////////////////////////////
 //
 //  class IOBufferReader --
-//         INK_INLINE functions definitions
+//         inline functions definitions
 //
 //////////////////////////////////////////////////////////////////
-INK_INLINE void
+inline void
 IOBufferReader::skip_empty_blocks()
 {
   while (block->next && block->next->read_avail() && start_offset >= block->size()) {
@@ -569,31 +561,31 @@
   }
 }
 
-INK_INLINE bool
+inline bool
 IOBufferReader::low_water()
 {
   return mbuf->low_water();
 }
 
-INK_INLINE bool
+inline bool
 IOBufferReader::high_water()
 {
   return read_avail() >= mbuf->water_mark;
 }
 
-INK_INLINE bool
+inline bool
 IOBufferReader::current_low_water()
 {
   return mbuf->current_low_water();
 }
 
-INK_INLINE IOBufferBlock *
+inline IOBufferBlock *
 IOBufferReader::get_current_block()
 {
   return (block);
 }
 
-INK_INLINE char *
+inline char *
 IOBufferReader::start()
 {
   if (block == 0)
@@ -602,7 +594,7 @@
   return block->start() + start_offset;
 }
 
-INK_INLINE char *
+inline char *
 IOBufferReader::end()
 {
   if (block == 0)
@@ -611,16 +603,16 @@
   return block->end();
 }
 
-INK_INLINE int
+inline ink64
 IOBufferReader::block_read_avail()
 {
   if (block == 0)
     return (0);
   skip_empty_blocks();
-  return (int) (block->end() - (block->start() + start_offset));
+  return (ink64) (block->end() - (block->start() + start_offset));
 }
 
-INK_INLINE int
+inline int
 IOBufferReader::block_count()
 {
   int count = 0;
@@ -632,32 +624,32 @@
   return count;
 }
 
-INK_INLINE int
+inline ink64
 IOBufferReader::read_avail()
 {
-  int t = 0;
+  ink64 t = 0;
   IOBufferBlock *b = block;
   while (b) {
     t += b->read_avail();
     b = b->next;
   }
   t -= start_offset;
-  if (size_limit != MAXINT && t > size_limit)
+  if (size_limit != INK64_MAX && t > size_limit)
     t = size_limit;
   return t;
 }
 
-INK_INLINE void
-IOBufferReader::consume(int n)
+inline void
+IOBufferReader::consume(ink64 n)
 {
   start_offset += n;
-  if (size_limit != MAXINT)
+  if (size_limit != INK64_MAX)
     size_limit -= n;
   ink_assert(size_limit >= 0);
   if (block == 0)
     return;
-  int r = block->read_avail();
-  int s = start_offset;
+  ink64 r = block->read_avail();
+  ink64 s = start_offset;
   while (r <= s && block->next && block->next->read_avail()) {
     s -= r;
     start_offset = s;
@@ -667,8 +659,8 @@
   ink_debug_assert(read_avail() >= 0);
 }
 
-INK_INLINE char &
-IOBufferReader::operator[] (int i)
+inline char &
+IOBufferReader::operator[] (ink64 i)
 {
   static char
     _error = '\0';
@@ -677,8 +669,7 @@
     b = block;
   i += start_offset;
   while (b) {
-    int
-      bytes = b->read_avail();
+    ink64 bytes = b->read_avail();
     if (bytes > i)
       return b->start()[i];
     i -= bytes;
@@ -692,28 +683,28 @@
   return _error;
 }
 
-INK_INLINE void
+inline void
 IOBufferReader::clear()
 {
   accessor = NULL;
   block = NULL;
   mbuf = NULL;
   start_offset = 0;
-  size_limit = MAXINT;
+  size_limit = INK64_MAX;
 }
 
-INK_INLINE void
+inline void
 IOBufferReader::reset()
 {
   block = mbuf->_writer;
   start_offset = 0;
-  size_limit = MAXINT;
+  size_limit = INK64_MAX;
 }
 
 ////////////////////////////////////////////////////////////////
 //
 //  class MIOBuffer --
-//      INK_INLINE functions definitions
+//      inline functions definitions
 //
 ////////////////////////////////////////////////////////////////
 inkcoreapi extern ClassAllocator<MIOBuffer> ioAllocator;
@@ -730,8 +721,8 @@
 //  MIOBufferData) will be freed by this class.
 //
 ////////////////////////////////////////////////////////////////
-INK_INLINE
-MIOBuffer::MIOBuffer(void *b, int bufsize, int aWater_mark)
+inline
+MIOBuffer::MIOBuffer(void *b, ink64 bufsize, ink64 aWater_mark)
 {
   set(b, bufsize);
   water_mark = aWater_mark;
@@ -742,8 +733,8 @@
   return;
 }
 
-INK_INLINE
-MIOBuffer::MIOBuffer(int default_size_index)
+inline
+MIOBuffer::MIOBuffer(ink64 default_size_index)
 {
   clear();
   size_index = default_size_index;
@@ -753,7 +744,7 @@
   return;
 }
 
-INK_INLINE
+inline
 MIOBuffer::MIOBuffer()
 {
   clear();
@@ -763,7 +754,7 @@
   return;
 }
 
-INK_INLINE
+inline
 MIOBuffer::~
 MIOBuffer()
 {
@@ -771,11 +762,11 @@
   dealloc_all_readers();
 }
 
-INK_INLINE MIOBuffer * new_MIOBuffer_internal(
+inline MIOBuffer * new_MIOBuffer_internal(
 #ifdef TRACK_BUFFER_USER
                                                const char *location,
 #endif
-                                               int size_index)
+                                               ink64 size_index)
 {
   MIOBuffer *b = ioAllocator.alloc();
 #ifdef TRACK_BUFFER_USER
@@ -785,7 +776,7 @@
   return b;
 }
 
-INK_INLINE void
+inline void
 free_MIOBuffer(MIOBuffer * mio)
 {
   mio->_writer = NULL;
@@ -793,11 +784,11 @@
   ioAllocator.free(mio);
 }
 
-INK_INLINE MIOBuffer * new_empty_MIOBuffer_internal(
+inline MIOBuffer * new_empty_MIOBuffer_internal(
 #ifdef TRACK_BUFFER_USER
                                                      const char *location,
 #endif
-                                                     int size_index)
+                                                     ink64 size_index)
 {
   MIOBuffer *b = ioAllocator.alloc();
   b->size_index = size_index;
@@ -807,13 +798,13 @@
   return b;
 }
 
-INK_INLINE void
+inline void
 free_empty_MIOBuffer(MIOBuffer * mio)
 {
   ioAllocator.free(mio);
 }
 
-INK_INLINE IOBufferReader *
+inline IOBufferReader *
 MIOBuffer::alloc_accessor(MIOBufferAccessor * anAccessor)
 {
   int i;
@@ -832,7 +823,7 @@
   return e;
 }
 
-INK_INLINE IOBufferReader *
+inline IOBufferReader *
 MIOBuffer::alloc_reader()
 {
   int i;
@@ -851,12 +842,12 @@
   return e;
 }
 
-INK_INLINE int
+inline ink64
 MIOBuffer::block_size()
 {
   return index_to_buffer_size(size_index);
 }
-INK_INLINE IOBufferReader *
+inline IOBufferReader *
 MIOBuffer::clone_reader(IOBufferReader * r)
 {
   int i;
@@ -878,7 +869,7 @@
   return e;
 }
 
-INK_INLINE int
+inline ink64
 MIOBuffer::block_write_avail()
 {
   IOBufferBlock *b = first_write_block();
@@ -900,7 +891,7 @@
 //  block.
 //
 ////////////////////////////////////////////////////////////////
-INK_INLINE void
+inline void
 MIOBuffer::append_block_internal(IOBufferBlock * b)
 {
   // It would be nice to remove an empty buffer at the beginning,
@@ -923,7 +914,7 @@
     _writer = _writer->next;
 }
 
-INK_INLINE void
+inline void
 MIOBuffer::append_block(IOBufferBlock * b)
 {
   ink_assert(b->read_avail());
@@ -938,8 +929,8 @@
 //  and make the new block the current block (writer).
 //
 ////////////////////////////////////////////////////////////////
-INK_INLINE void
-MIOBuffer::append_block(int asize_index)
+inline void
+MIOBuffer::append_block(ink64 asize_index)
 {
   ink_debug_assert(BUFFER_SIZE_ALLOCATED(asize_index));
 #ifdef TRACK_BUFFER_USER
@@ -952,20 +943,20 @@
   return;
 }
 
-INK_INLINE void
+inline void
 MIOBuffer::add_block()
 {
   append_block(size_index);
 }
 
-INK_INLINE void
+inline void
 MIOBuffer::check_add_block()
 {
   if (!high_water() && current_low_water())
     add_block();
 }
 
-INK_INLINE IOBufferBlock *
+inline IOBufferBlock *
 MIOBuffer::get_current_block()
 {
   return first_write_block();
@@ -981,10 +972,10 @@
 //  or below the watermark space available.
 //
 //////////////////////////////////////////////////////////////////
-INK_INLINE int
+inline ink64
 MIOBuffer::current_write_avail()
 {
-  int t = 0;
+  ink64 t = 0;
   IOBufferBlock *b = _writer;
   while (b) {
     t += b->write_avail();
@@ -1002,17 +993,17 @@
 //  the current block then a new block is appended.
 //
 //////////////////////////////////////////////////////////////////
-INK_INLINE int
+inline ink64
 MIOBuffer::write_avail()
 {
   check_add_block();
   return current_write_avail();
 }
 
-INK_INLINE void
-MIOBuffer::fill(int len)
+inline void
+MIOBuffer::fill(ink64 len)
 {
-  int f = _writer->write_avail();
+  ink64 f = _writer->write_avail();
   while (f < len) {
     _writer->fill(f);
     len -= f;
@@ -1023,7 +1014,7 @@
   _writer->fill(len);
 }
 
-INK_INLINE int
+inline int
 MIOBuffer::max_block_count()
 {
   int maxb = 0;
@@ -1038,14 +1029,14 @@
   return maxb;
 }
 
-INK_INLINE int
+inline ink64
 MIOBuffer::max_read_avail()
 {
-  int s = 0;
+  ink64 s = 0;
   int found = 0;
   for (int i = 0; i < MAX_MIOBUFFER_READERS; i++) {
     if (readers[i].allocated()) {
-      int ss = readers[i].read_avail();
+      ink64 ss = readers[i].read_avail();
       if (ss > s) {
         s = ss;
       }
@@ -1057,8 +1048,8 @@
   return s;
 }
 
-INK_INLINE void
-MIOBuffer::set(void *b, int len)
+inline void
+MIOBuffer::set(void *b, ink64 len)
 {
 #ifdef TRACK_BUFFER_USER
   _writer = new_IOBufferBlock_internal(_location);
@@ -1069,8 +1060,8 @@
   init_readers();
 }
 
-INK_INLINE void
-MIOBuffer::set_xmalloced(void *b, int len)
+inline void
+MIOBuffer::set_xmalloced(void *b, ink64 len)
 {
 #ifdef TRACK_BUFFER_USER
   _writer = new_IOBufferBlock_internal(_location);
@@ -1081,8 +1072,8 @@
   init_readers();
 }
 
-INK_INLINE void
-MIOBuffer::append_xmalloced(void *b, int len)
+inline void
+MIOBuffer::append_xmalloced(void *b, ink64 len)
 {
 #ifdef TRACK_BUFFER_USER
   IOBufferBlock *x = new_IOBufferBlock_internal(_location);
@@ -1093,8 +1084,8 @@
   append_block_internal(x);
 }
 
-INK_INLINE void
-MIOBuffer::append_fast_allocated(void *b, int len, int fast_size_index)
+inline void
+MIOBuffer::append_fast_allocated(void *b, ink64 len, ink64 fast_size_index)
 {
 #ifdef TRACK_BUFFER_USER
   IOBufferBlock *x = new_IOBufferBlock_internal(_location);
@@ -1105,8 +1096,8 @@
   append_block_internal(x);
 }
 
-INK_INLINE void
-MIOBuffer::alloc(int i)
+inline void
+MIOBuffer::alloc(ink64 i)
 {
 #ifdef TRACK_BUFFER_USER
   _writer = new_IOBufferBlock_internal(_location);
@@ -1118,14 +1109,14 @@
   init_readers();
 }
 
-INK_INLINE void
-MIOBuffer::alloc_xmalloc(int buf_size)
+inline void
+MIOBuffer::alloc_xmalloc(ink64 buf_size)
 {
   char *b = (char *) xmalloc(buf_size);
   set_xmalloced(b, buf_size);
 }
 
-INK_INLINE void
+inline void
 MIOBuffer::dealloc_reader(IOBufferReader * e)
 {
   if (e->accessor) {
@@ -1136,19 +1127,19 @@
   e->clear();
 }
 
-INK_INLINE IOBufferReader *
+inline IOBufferReader *
 IOBufferReader::clone()
 {
   return mbuf->clone_reader(this);
 }
 
-INK_INLINE void
+inline void
 IOBufferReader::dealloc()
 {
   mbuf->dealloc_reader(this);
 }
 
-INK_INLINE void
+inline void
 MIOBuffer::dealloc_all_readers()
 {
   for (int i = 0; i < MAX_MIOBUFFER_READERS; i++)
@@ -1156,13 +1147,13 @@
       dealloc_reader(&readers[i]);
 }
 
-INK_INLINE void
-MIOBuffer::set_size_index(int size)
+inline void
+MIOBuffer::set_size_index(ink64 size)
 {
   size_index = iobuffer_size_to_index(size);
 }
 
-INK_INLINE void
+inline void
 MIOBufferAccessor::reader_for(MIOBuffer * abuf)
 {
   mbuf = abuf;
@@ -1172,7 +1163,7 @@
     entry = NULL;
 }
 
-INK_INLINE void
+inline void
 MIOBufferAccessor::reader_for(IOBufferReader * areader)
 {
   if (entry == areader)
@@ -1182,21 +1173,21 @@
   ink_assert(mbuf);
 }
 
-INK_INLINE void
+inline void
 MIOBufferAccessor::writer_for(MIOBuffer * abuf)
 {
   mbuf = abuf;
   entry = NULL;
 }
 
-INK_INLINE void
+inline void
 MIOBufferAccessor::clear()
 {
   entry = NULL;
   mbuf = NULL;
 }
 
-INK_INLINE
+inline
 MIOBufferAccessor::~
 MIOBufferAccessor()
 {

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_ProtectedQueue.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_ProtectedQueue.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_ProtectedQueue.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_ProtectedQueue.h Wed Feb 24 18:48:42 2010
@@ -33,8 +33,11 @@
 #include "I_EventSystem.h"
 
 
-INK_INLINE
+inline
 ProtectedQueue::ProtectedQueue():write_pipe_fd(-1),read_pipe_fd(-1)
+#if defined(USE_OLD_EVENTFD)
+:write_pipe_fd(-1),read_pipe_fd(-1)
+#endif
 {
   Event e;
   ink_mutex_init(&lock, "ProtectedQueue");
@@ -42,10 +45,11 @@
   ink_cond_init(&might_have_data);
 }
 
-INK_INLINE void
+inline void
 ProtectedQueue::signal()
 {
   // Need to get the lock before you can signal the thread
+#if defined(USE_OLD_EVENTFD)
   if(write_pipe_fd!=-1) {
     int retVal = socketManager.write(write_pipe_fd,(void*)"W",1);
     if(retVal <= 0) {
@@ -53,16 +57,20 @@
       socketManager.close(fd);
     }
   } else {
+#endif
     ink_mutex_acquire(&lock);
     ink_cond_signal(&might_have_data);
     ink_mutex_release(&lock);
+#if defined(USE_OLD_EVENTFD)
   }
+#endif
 }
 
-INK_INLINE int
+inline int
 ProtectedQueue::try_signal()
 {
   // Need to get the lock before you can signal the thread
+#if defined(USE_OLD_EVENTFD)
   if(write_pipe_fd!=-1) {
     int retVal = socketManager.write(write_pipe_fd,(void*)"W",1);
     if(retVal <= 0) {
@@ -72,6 +80,7 @@
     }
     return 1;
   } else {
+#endif
     if (ink_mutex_try_acquire(&lock)) {
       ink_cond_signal(&might_have_data);
       ink_mutex_release(&lock);
@@ -79,11 +88,13 @@
     } else {
       return 0;
     }
+#if defined(USE_OLD_EVENTFD)
   }
+#endif
 }
 
 // Called from the same thread (don't need to signal)
-INK_INLINE void
+inline void
 ProtectedQueue::enqueue_local(Event * e)
 {
   ink_assert(!e->in_the_prot_queue && !e->in_the_priority_queue);
@@ -91,7 +102,7 @@
   localQueue.enqueue(e);
 }
 
-INK_INLINE void
+inline void
 ProtectedQueue::remove(Event * e)
 {
   ink_assert(e->in_the_prot_queue);
@@ -100,7 +111,7 @@
   e->in_the_prot_queue = 0;
 }
 
-INK_INLINE Event *
+inline Event *
 ProtectedQueue::dequeue_local()
 {
   Event *e = localQueue.dequeue();
@@ -111,6 +122,7 @@
   return e;
 }
 
+#if defined(USE_OLD_EVENTFD)
 INK_INLINE void 
 ProtectedQueue::setReadFd(int fd)
 {
@@ -132,5 +144,6 @@
   setWriteFd(pfd[1]);
   return pfd[0];
 }
+#endif /* USE_OLD_EVENTFD */
 
 #endif

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_Thread.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_Thread.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_Thread.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_Thread.h Wed Feb 24 18:48:42 2010
@@ -36,31 +36,31 @@
   ///////////////////////////////////////////////
   // Common Interface impl                     //
   ///////////////////////////////////////////////
-INK_INLINE
+inline
 Thread::~
 Thread()
 {
 }
 
-INK_INLINE void
+inline void
 Thread::set_specific()
 {
   ink_thread_setspecific(Thread::thread_data_key, this);
 }
 
-INK_INLINE Thread *
+inline Thread *
 this_thread()
 {
   return (Thread *) ink_thread_getspecific(Thread::thread_data_key);
 }
 
-INK_INLINE ink_hrtime
+inline ink_hrtime
 ink_get_hrtime()
 {
   return Thread::cur_time;
 }
 
-INK_INLINE ink_hrtime
+inline ink_hrtime
 ink_get_based_hrtime()
 {
   return Thread::cur_time;

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEThread.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEThread.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEThread.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEThread.h Wed Feb 24 18:48:42 2010
@@ -37,26 +37,23 @@
 
 const int DELAY_FOR_RETRY = HRTIME_MSECONDS(10);
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_spawn(Continuation * cont)
 {
   Event *e = EVENT_ALLOC(eventAllocator, this);
   return schedule(e->init(cont, 0, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_imm(Continuation * cont, int callback_event, void *cookie)
 {
   Event *e =::eventAllocator.alloc();
   e->callback_event = callback_event;
   e->cookie = cookie;
-#ifdef ENABLE_TIME_TRACE
-  e->start_time = ink_get_hrtime();
-#endif
   return schedule(e->init(cont, 0, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_at(Continuation * cont, ink_hrtime t, int callback_event, void *cookie)
 {
   Event *e =::eventAllocator.alloc();
@@ -65,7 +62,7 @@
   return schedule(e->init(cont, t, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_in(Continuation * cont, ink_hrtime t, int callback_event, void *cookie)
 {
   Event *e =::eventAllocator.alloc();
@@ -74,7 +71,7 @@
   return schedule(e->init(cont, ink_get_based_hrtime() + t, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_every(Continuation * cont, ink_hrtime t, int callback_event, void *cookie)
 {
   Event *e =::eventAllocator.alloc();
@@ -83,7 +80,7 @@
   return schedule(e->init(cont, ink_get_based_hrtime() + t, t));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule(Event * e)
 {
   e->ethread = this;
@@ -97,19 +94,16 @@
   return e;
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_imm_local(Continuation * cont, int callback_event, void *cookie)
 {
   Event *e = EVENT_ALLOC(eventAllocator, this);
   e->callback_event = callback_event;
-#ifdef ENABLE_TIME_TRACE
-  e->start_time = ink_get_hrtime();
-#endif
   e->cookie = cookie;
   return schedule_local(e->init(cont, 0, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_at_local(Continuation * cont, ink_hrtime t, int callback_event, void *cookie)
 {
   Event *e = EVENT_ALLOC(eventAllocator, this);
@@ -118,7 +112,7 @@
   return schedule_local(e->init(cont, t, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_in_local(Continuation * cont, ink_hrtime t, int callback_event, void *cookie)
 {
   Event *e = EVENT_ALLOC(eventAllocator, this);
@@ -127,7 +121,7 @@
   return schedule_local(e->init(cont, ink_get_based_hrtime() + t, 0));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_every_local(Continuation * cont, ink_hrtime t, int callback_event, void *cookie)
 {
   Event *e = EVENT_ALLOC(eventAllocator, this);
@@ -136,7 +130,7 @@
   return schedule_local(e->init(cont, ink_get_based_hrtime() + t, t));
 }
 
-INK_INLINE Event *
+inline Event *
 EThread::schedule_local(Event * e)
 {
   if (tt != REGULAR) {
@@ -154,13 +148,13 @@
   return e;
 }
 
-INK_INLINE EThread *
+inline EThread *
 this_ethread()
 {
   return (EThread *) this_thread();
 }
 
-INK_INLINE void
+inline void
 EThread::free_event(Event * e)
 {
   ink_assert(!e->in_the_priority_queue && !e->in_the_prot_queue);
@@ -168,10 +162,12 @@
   EVENT_FREE(e, eventAllocator, this);
 }
 
+#if defined(USE_OLD_EVENTFD)
 INK_INLINE int 
 EThread::getEventFd()
 {
   return EventQueueExternal.getReadFd();
 }
+#endif
 
 #endif /*_EThread_h_*/

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEvent.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEvent.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEvent.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEvent.h Wed Feb 24 18:48:42 2010
@@ -24,7 +24,7 @@
 #ifndef _P_UnixEvent_h_
 #define _P_UnixEvent_h_
 
-INK_INLINE Event *
+inline Event *
 Event::init(Continuation * c, ink_hrtime atimeout_at, ink_hrtime aperiod)
 {
   continuation = c;
@@ -35,14 +35,14 @@
   return this;
 }
 
-INK_INLINE void
+inline void
 Event::free()
 {
   mutex = NULL;
   eventAllocator.free(this);
 }
 
-INK_INLINE
+inline
 Event::Event():
   ethread(0),
   in_the_prot_queue(false),

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEventProcessor.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEventProcessor.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEventProcessor.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixEventProcessor.h Wed Feb 24 18:48:42 2010
@@ -28,7 +28,7 @@
 const int LOAD_BALANCE_INTERVAL = 1;
 
 
-INK_INLINE
+inline
 EventProcessor::EventProcessor():
 n_ethreads(0),
 n_thread_groups(0),
@@ -41,11 +41,11 @@
   memset(next_thread_for_type, 0, sizeof(next_thread_for_type));
 }
 
-INK_INLINE off_t
+inline off_t
 EventProcessor::allocate(int size)
 {
-  static off_t start = (offsetof(EThread, thread_private) + 7) & ~7;
-  static off_t loss = start - offsetof(EThread, thread_private);
+  static off_t start = (ink_offsetof(EThread, thread_private) + 7) & ~7;
+  static off_t loss = start - ink_offsetof(EThread, thread_private);
   size = (size + 7) & ~7;       // 8 byte alignment
 
   int old;
@@ -58,7 +58,7 @@
   return (off_t) (old + start);
 }
 
-INK_INLINE EThread *
+inline EThread *
 EventProcessor::assign_thread(EventType etype)
 {
   int next;
@@ -69,7 +69,7 @@
   return (eventthread[etype][next]);
 }
 
-INK_INLINE Event *
+inline Event *
 EventProcessor::schedule(Event * e, EventType etype)
 {
   e->ethread = assign_thread(etype);
@@ -83,7 +83,7 @@
 
 #if 0
 /* getting rid of this, i dont see anybody using this */
-INK_INLINE Event *
+inline Event *
 EventProcessor::schedule_spawn(Continuation * cont)
 {
   Event *e = eventAllocator.alloc();
@@ -91,7 +91,7 @@
 }
 #endif
 
-INK_INLINE Event *
+inline Event *
 EventProcessor::schedule_imm(Continuation * cont, EventType et, int callback_event, void *cookie)
 {
   Event *e = eventAllocator.alloc();
@@ -103,7 +103,7 @@
   return schedule(e->init(cont, 0, 0), et);
 }
 
-INK_INLINE Event *
+inline Event *
 EventProcessor::schedule_at(Continuation * cont, ink_hrtime t, EventType et, int callback_event, void *cookie)
 {
   ink_assert(t > 0);
@@ -113,7 +113,7 @@
   return schedule(e->init(cont, t, 0), et);
 }
 
-INK_INLINE Event *
+inline Event *
 EventProcessor::schedule_in(Continuation * cont, ink_hrtime t, EventType et, int callback_event, void *cookie)
 {
   Event *e = eventAllocator.alloc();
@@ -122,7 +122,7 @@
   return schedule(e->init(cont, ink_get_based_hrtime() + t, 0), et);
 }
 
-INK_INLINE Event *
+inline Event *
 EventProcessor::schedule_every(Continuation * cont, ink_hrtime t, EventType et, int callback_event, void *cookie)
 {
   ink_assert(t != 0);

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h Wed Feb 24 18:48:42 2010
@@ -31,6 +31,8 @@
 ****************************************************************************/
 #ifndef _P_UnixSocketManager_h_
 #define _P_UnixSocketManager_h_
+
+#include "inktomi++.h"
 #include "I_SocketManager.h"
 
 extern int monitor_read_activity;
@@ -43,7 +45,7 @@
 // 1024 - stdin, stderr, stdout
 #define EPOLL_MAX_DESCRIPTOR_SIZE                32768
 
-INK_INLINE bool
+inline bool
 transient_error()
 {
   bool transient = (errno == EINTR);
@@ -60,7 +62,7 @@
 //
 // Timing done in the connectionManager
 //
-INK_INLINE int
+inline int
 SocketManager::accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 {
   int r;
@@ -76,7 +78,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::open(char *path, int oflag, mode_t mode)
 {
   int s;
@@ -91,7 +93,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::read(int fd, void *buf, int size, void *pOLP)
 {
   int r = 0;
@@ -108,7 +110,7 @@
 
 void monitor_disk_read(int fd, void *buf, int size, off_t offset, char *tag);
 
-INK_INLINE int
+inline int
 SocketManager::pread(int fd, void *buf, int size, off_t offset, char *tag)
 {
   if (monitor_read_activity)
@@ -123,7 +125,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::read_from_middle_of_file(int fd, void *buf, int size, off_t offset, char *tag)
 {
   int r;
@@ -138,7 +140,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::readv(int fd, struct iovec *vector, size_t count, teFDType eT)
 {
   int r;
@@ -153,7 +155,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::vector_io(int fd, struct iovec *vector, size_t count, int read_request, void *pOLP)
 {
   const int max_iovecs_per_request = 16;
@@ -195,14 +197,14 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::read_vector(int fd, struct iovec *vector, size_t count, void *pOLP)
 {
   return vector_io(fd, vector, count, 1, pOLP);
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::recv(int fd, void *buf, int size, int flags)
 {
   int r;
@@ -216,7 +218,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::recvfrom(int fd, void *buf, int size, int flags, struct sockaddr *addr, socklen_t *addrlen)
 {
   int r;
@@ -230,7 +232,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::write(int fd, void *buf, int size, void *pOLP)
 {
   int r;
@@ -246,7 +248,7 @@
 
 void monitor_disk_write(int fd, void *buf, int size, off_t offset, char *tag);
 
-INK_INLINE int
+inline int
 SocketManager::pwrite(int fd, void *buf, int size, off_t offset, char *tag)
 {
   int r;
@@ -261,7 +263,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::write_to_middle_of_file(int fd, void *buf, int size, off_t offset, char *tag)
 {
   int r;
@@ -278,7 +280,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::writev(int fd, struct iovec *vector, size_t count, teFDType eT)
 {
   int r;
@@ -292,14 +294,14 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::write_vector(int fd, struct iovec *vector, size_t count, void *pOLP)
 {
   return vector_io(fd, vector, count, 0, pOLP);
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::send(int fd, void *buf, int size, int flags)
 {
   int r;
@@ -312,7 +314,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::sendto(int fd, void *buf, int len, int flags, struct sockaddr *to, int tolen)
 {
   int r;
@@ -325,7 +327,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::sendmsg(int fd, struct msghdr *m, int flags, void *pOLP)
 {
   int r;
@@ -338,7 +340,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::lseek(int fd, off_t offset, int whence)
 {
   int r;
@@ -351,7 +353,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::fstat(int fd, struct stat *buf)
 {
   int r;
@@ -365,7 +367,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::unlink(char *buf)
 {
   int r;
@@ -378,7 +380,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::fsync(int fildes)
 {
   int r;
@@ -391,7 +393,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::ftruncate(int fildes, off_t length)
 {
   int r;
@@ -404,7 +406,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::poll(struct pollfd *fds, unsigned long nfds, int timeout)
 {
   int r;
@@ -418,7 +420,7 @@
 }
 
 #if defined(USE_EPOLL)
-INK_INLINE int
+inline int
 SocketManager::epoll_create(int size)
 {
   int r;
@@ -434,7 +436,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::epoll_close(int epfd)
 {
   int r = 0;
@@ -450,7 +452,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
 {
   int r;
@@ -464,7 +466,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
 {
   int r;
@@ -478,14 +480,14 @@
 }
 
 #elif defined(USE_KQUEUE)
-INK_INLINE int
+inline int
 SocketManager::kqueue()
 {
   return ::kqueue();
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::kevent(int kq, const struct kevent *changelist, int nchanges,
                       struct kevent *eventlist, int nevents,
                       const struct timespec *timeout)
@@ -503,11 +505,50 @@
 
   return r;
 }
+#elif defined(USE_PORT)
+inline int
+SocketManager::port_create() 
+{
+  return ::port_create();
+}
 
-#endif
+inline int
+SocketManager::port_associate(int port, int source, uintptr_t obj,
+                              int events, void *user) 
+{
+  int r;
+  r =::port_associate(port, source, obj, events, user);
+  if(r < 0) 
+    r = -errno;
+  return r;
+}
+
+inline int
+SocketManager::port_dissociate(int port, int source, uintptr_t obj) 
+{
+  int r;
+  r =::port_dissociate(port, source, obj);
+  if(r < 0) 
+    r = -errno;
+  return r;
+}
+
+inline int
+SocketManager::port_getn(int port, port_event_t *list, uint_t max,
+                         uint_t *nget, timespec_t *timeout) 
+{
+  int r;
+  do {
+    if ((r =::port_getn(port, list, max, nget, timeout)) >= 0)
+      break;
+    r = -errno;
+  } while (errno == -EINTR); //TODO: possible EAGAIN(undocumented)
+  return r;
+}
+#endif /* USE_PORT */
 
 
-INK_INLINE int
+inline int
 SocketManager::get_sndbuf_size(int s)
 {
   int bsz = 0;
@@ -519,7 +560,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::get_rcvbuf_size(int s)
 {
   int bsz = 0;
@@ -531,42 +572,42 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::set_sndbuf_size(int s, int bsz)
 {
   return safe_setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *) &bsz, sizeof(bsz));
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::set_rcvbuf_size(int s, int bsz)
 {
   return safe_setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *) &bsz, sizeof(bsz));
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::getsockname(int s, struct sockaddr *sa, socklen_t *sz)
 {
   return::getsockname(s, sa, sz);
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::socket(int domain, int type, int protocol, bool bNonBlocking)
 {
   return::socket(domain, type, protocol);
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::mc_socket(int domain, int type, int protocol, bool bNonBlocking)
 {
   return SocketManager::socket(domain, type, protocol, bNonBlocking);
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::shutdown(int s, int how)
 {
   int res;
@@ -579,7 +620,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::lockf(int s, int f, long size)
 {
   int res;
@@ -592,7 +633,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::dup(int s)
 {
   int res;
@@ -606,7 +647,7 @@
 }
 
 
-INK_INLINE int
+inline int
 SocketManager::fast_close(int s)
 {
   int res;

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h Wed Feb 24 18:48:42 2010
@@ -26,7 +26,7 @@
 #define P_VConnection_h
 #include "I_EventSystem.h"
 
-INK_INLINE const char *
+inline const char *
 get_vc_event_name(int event)
 {
   switch (event) {
@@ -56,7 +56,7 @@
 }
 
 
-INK_INLINE
+inline
 VConnection::VConnection(ProxyMutex * aMutex)
   :
 Continuation(aMutex),
@@ -65,7 +65,7 @@
   SET_HANDLER(0);
 }
 
-INK_INLINE
+inline
 VConnection::~
 VConnection()
 {
@@ -75,7 +75,7 @@
 //
 //      DEPRECATED DEPRECATED DEPRECATED
 //
-//      INK_INLINE VIO * VConnection::do_io()
+//      inline VIO * VConnection::do_io()
 //
 //      This method enqueues a VIO operation onto the VIO queue, and
 //      activates the I/O operation if and operation of that type isn't
@@ -84,7 +84,7 @@
 //////////////////////////////////////////////////////////////////////////////
 
 static inline VIO *
-vc_do_io_write(VConnection * vc, Continuation * cont, int nbytes, MIOBuffer * buf, int offset)
+vc_do_io_write(VConnection * vc, Continuation * cont, ink64 nbytes, MIOBuffer * buf, ink64 offset)
 {
   IOBufferReader *reader = buf->alloc_reader();
 
@@ -94,8 +94,8 @@
   return vc->do_io_write(cont, nbytes, reader, true);
 }
 
-INK_INLINE VIO *
-VConnection::do_io(int op, Continuation * c, int nbytes, MIOBuffer * cb, int data)
+inline VIO *
+VConnection::do_io(int op, Continuation * c, ink64 nbytes, MIOBuffer * cb, int data)
 {
   switch (op) {
   case VIO::READ:
@@ -122,15 +122,15 @@
   return NULL;
 }
 
-INK_INLINE void
+inline void
 VConnection::set_continuation(VIO *, Continuation *)
 {
 }
-INK_INLINE void
+inline void
 VConnection::reenable(VIO *)
 {
 }
-INK_INLINE void
+inline void
 VConnection::reenable_re(VIO * vio)
 {
   reenable(vio);

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h Wed Feb 24 18:48:42 2010
@@ -26,7 +26,7 @@
 #define  P_VIO_h
 #include "I_VIO.h"
 
-INK_INLINE
+inline
 VIO::VIO(int aop)
   :
 _cont(NULL),
@@ -45,7 +45,7 @@
 //  VIO::VIO()
 //
 /////////////////////////////////////////////////////////////
-INK_INLINE
+inline
 VIO::VIO()
   :
 _cont(0),
@@ -59,37 +59,37 @@
   return;
 }
 
-INK_INLINE Continuation *
+inline Continuation *
 VIO::get_continuation()
 {
   return _cont;
 }
-INK_INLINE void
+inline void
 VIO::set_writer(MIOBuffer * writer)
 {
   buffer.writer_for(writer);
 }
-INK_INLINE void
+inline void
 VIO::set_reader(IOBufferReader * reader)
 {
   buffer.reader_for(reader);
 }
-INK_INLINE MIOBuffer *
+inline MIOBuffer *
 VIO::get_writer()
 {
   return buffer.writer();
 }
-INK_INLINE IOBufferReader *
+inline IOBufferReader *
 VIO::get_reader()
 {
   return (buffer.reader());
 }
-INK_INLINE int
+inline int
 VIO::ntodo()
 {
   return nbytes - ndone;
 }
-INK_INLINE void
+inline void
 VIO::done()
 {
   if (buffer.reader())
@@ -103,7 +103,7 @@
 //  VIO::set_continuation()
 //
 /////////////////////////////////////////////////////////////
-INK_INLINE void
+inline void
 VIO::set_continuation(Continuation * acont)
 {
   if (vc_server)
@@ -123,7 +123,7 @@
 //  VIO::reenable()
 //
 /////////////////////////////////////////////////////////////
-INK_INLINE void
+inline void
 VIO::reenable()
 {
   if (vc_server)
@@ -135,7 +135,7 @@
 //  VIO::reenable_re()
 //
 /////////////////////////////////////////////////////////////
-INK_INLINE void
+inline void
 VIO::reenable_re()
 {
   if (vc_server)

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/Processor.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/Processor.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/Processor.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/Processor.cc Wed Feb 24 18:48:42 2010
@@ -40,7 +40,7 @@
   
  ****************************************************************************/
 
-#include "I_EventSystem.h"
+#include "P_EventSystem.h"
 //////////////////////////////////////////////////////////////////////////////
 //
 //      Processor::Processor()

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/ProtectedQueue.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/ProtectedQueue.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/ProtectedQueue.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/ProtectedQueue.cc Wed Feb 24 18:48:42 2010
@@ -123,6 +123,8 @@
   for (i = 0; i < n; i++) {
     if (thr->ethreads_to_be_signalled[i]) {
       thr->ethreads_to_be_signalled[i]->EventQueueExternal.signal();
+      if (thr->ethreads_to_be_signalled[i]->signal_hook)
+        thr->ethreads_to_be_signalled[i]->signal_hook(thr->ethreads_to_be_signalled[i]);
       thr->ethreads_to_be_signalled[i] = 0;
     }
   }

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/SocketManager.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/SocketManager.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/SocketManager.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/SocketManager.cc Wed Feb 24 18:48:42 2010
@@ -25,12 +25,18 @@
 
   SocketManager.cc
  ****************************************************************************/
-#include "ink_unused.h"    /* MAGIC_EDITING_TAG */
+#include "inktomi++.h"
 
 #if (HOST_OS != linux)
 #include <sys/filio.h>
 #endif
 
+#if (HOST_OS == solaris)
+#include <sys/types.h>
+#include <sys/mman.h>
+extern "C" int madvise(caddr_t, size_t, int); // FIXME: why is this not being found
+#endif
+
 #include "P_EventSystem.h"
 
 

Modified: incubator/trafficserver/traffic/trunk/iocore/eventsystem/UnixEThread.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/eventsystem/UnixEThread.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/eventsystem/UnixEThread.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/eventsystem/UnixEThread.cc Wed Feb 24 18:48:42 2010
@@ -29,6 +29,8 @@
 #include "ink_unused.h"      /* MAGIC_EDITING_TAG */
 #include "P_EventSystem.h"
 
+extern "C" int eventfd(unsigned int initval, int flags);
+
 struct AIOCallback;
 
 #define MAX_HEARTBEATS_MISSED         	10
@@ -37,37 +39,54 @@
 #define NO_ETHREAD_ID                   -1
 
 EThread::EThread()
-:generator(time(NULL) ^ (long) this),
-ethreads_to_be_signalled(NULL),
-n_ethreads_to_be_signalled(0),
-main_accept_index(-1),
-id(NO_ETHREAD_ID), event_types(0), tt(REGULAR), eventsem(NULL)
+ : generator(time(NULL) ^ (long) this),
+   ethreads_to_be_signalled(NULL),
+   n_ethreads_to_be_signalled(0),
+   main_accept_index(-1),
+   id(NO_ETHREAD_ID), event_types(0), 
+   signal_hook(0),
+   tt(REGULAR), eventsem(NULL)
 {
   memset(thread_private, 0, PER_THREAD_DATA);
 }
 
 EThread::EThread(ThreadType att, int anid)
-  :
-generator(time(NULL) ^ (long) this),
-ethreads_to_be_signalled(NULL),
-n_ethreads_to_be_signalled(0),
-main_accept_index(-1),
-id(anid),
-event_types(0),
-tt(att),
-eventsem(NULL)
+  : generator(time(NULL) ^ (long) this),
+    ethreads_to_be_signalled(NULL),
+    n_ethreads_to_be_signalled(0),
+    main_accept_index(-1),
+    id(anid),
+    event_types(0),
+    signal_hook(0),
+    tt(att),
+    eventsem(NULL)
 {
   ethreads_to_be_signalled = (EThread **) xmalloc(MAX_EVENT_THREADS * sizeof(EThread *));
   memset((char *) ethreads_to_be_signalled, 0, MAX_EVENT_THREADS * sizeof(EThread *));
   memset(thread_private, 0, PER_THREAD_DATA);
+#ifdef HAVE_EVENTFD
+  evfd = eventfd(0, O_NONBLOCK | FD_CLOEXEC);
+  if (evfd < 0)
+    ink_release_assert((evfd = eventfd(0,0)) >= 0);
+  fcntl(evfd, F_SETFD, FD_CLOEXEC);
+  fcntl(evfd, F_SETFL, O_NONBLOCK);
+#else
+  ink_release_assert(pipe(evpipe) >= 0); 
+  fcntl(evpipe[0], F_SETFD, FD_CLOEXEC);
+  fcntl(evpipe[0], F_SETFL, O_NONBLOCK);
+  fcntl(evpipe[1], F_SETFD, FD_CLOEXEC);
+  fcntl(evpipe[1], F_SETFL, O_NONBLOCK);
+#endif
 }
 
 EThread::EThread(ThreadType att, Event * e, ink_sem * sem)
-:generator(time(NULL) ^ (long) this),
-ethreads_to_be_signalled(NULL),
-n_ethreads_to_be_signalled(0),
-main_accept_index(-1),
-id(NO_ETHREAD_ID), event_types(0), tt(att), oneevent(e), eventsem(sem)
+ : generator(time(NULL) ^ (long) this),
+   ethreads_to_be_signalled(NULL),
+   n_ethreads_to_be_signalled(0),
+   main_accept_index(-1),
+   id(NO_ETHREAD_ID), event_types(0), 
+   signal_hook(0),
+   tt(att), oneevent(e), eventsem(sem)
 {
   ink_assert(att == DEDICATED);
   memset(thread_private, 0, PER_THREAD_DATA);
@@ -141,56 +160,44 @@
 // lock. If successful, call the continuation, otherwise put the event back
 // into the queue.
 //
-#ifdef ENABLE_TIME_TRACE
-int immediate_events_time_dist[TIME_DIST_BUCKETS_SIZE];
-int cnt_immediate_events;
-#endif
 
-extern struct EventProcessor eventProcessor;
 void
-EThread::execute()
-{
-  Event *e;
-  ink_hrtime next_time = 0, sleep_time;
-  Que(Event, link) NegativeQueue;
+EThread::execute() {
   switch (tt) {
 
-  case REGULAR:{
-      // Try to give priority to immediate events.
+    case REGULAR: {
+      Event *e;
+      Que(Event, link) NegativeQueue;
+      ink_hrtime next_time = 0;
 
+      // give priority to immediate events
       for (;;) {
-        // Execute all the available external events that have
+        // execute all the available external events that have
         // already been dequeued
         cur_time = ink_get_based_hrtime_internal();
         while ((e = EventQueueExternal.dequeue_local())) {
-          if (!e->timeout_at) {
+          if (!e->timeout_at) { // IMMEDIATE
             ink_assert(e->period == 0);
             process_event(e, e->callback_event);
-          } else {
-
-            if (e->timeout_at < 0) {
-#ifdef FIXME
-              if (-e->timeout_at < min_neg_timeout)
-                min_neg_timeout = -e->timeout_at;
-#endif
-              Event *p = NULL;
-              Event *a = NegativeQueue.head;
-              while (a && a->timeout_at > e->timeout_at) {
-                p = a;
-                a = a->link.next;
-              }
-              if (!a)
-                NegativeQueue.enqueue(e);
-              else
-                NegativeQueue.insert(e, p);
-            } else
-              EventQueue.enqueue(e, cur_time);
+          } else if (e->timeout_at > 0) // INTERVAL
+            EventQueue.enqueue(e, cur_time);
+          else { // NEGATIVE
+            Event *p = NULL;
+            Event *a = NegativeQueue.head;
+            while (a && a->timeout_at > e->timeout_at) {
+              p = a;
+              a = a->link.next;
+            }
+            if (!a)
+              NegativeQueue.enqueue(e);
+            else
+              NegativeQueue.insert(e, p);
           }
         }
         bool done_one;
         do {
           done_one = false;
-          // Execute all the eligible internal events
+          // execute all the eligible internal events
           EventQueue.check_ready(cur_time, this);
           while ((e = EventQueue.dequeue_ready(cur_time))) {
             ink_assert(e);
@@ -203,12 +210,10 @@
             }
           }
         } while (done_one);
-
+        // execute any negative (poll) events
         if (NegativeQueue.head) {
           if (n_ethreads_to_be_signalled)
             flush_signals(this);
-
-
           // dequeue all the external events and put them in a local
           // queue. If there are no external events available, don't
           // do a cond_timedwait.
@@ -245,15 +250,13 @@
             }
           }
           // execute poll events
-          while ((e = NegativeQueue.dequeue()) != NULL) {
+          while ((e = NegativeQueue.dequeue()))
             process_event(e, EVENT_POLL);
-          }
-          // fixme min_neg_timeout = HRTIME_FOREVER;
           if (!INK_ATOMICLIST_EMPTY(EventQueueExternal.al))
             EventQueueExternal.dequeue_timed(cur_time, next_time, false);
         } else {                // Means there are no negative events
           next_time = EventQueue.earliest_timeout();
-          sleep_time = next_time - cur_time;
+          ink_hrtime sleep_time = next_time - cur_time;
           if (sleep_time > THREAD_MAX_HEARTBEAT_MSECONDS * HRTIME_MSECOND) {
             next_time = cur_time + THREAD_MAX_HEARTBEAT_MSECONDS * HRTIME_MSECOND;
             sleep_time = THREAD_MAX_HEARTBEAT_MSECONDS * HRTIME_MSECOND;
@@ -266,10 +269,9 @@
           EventQueueExternal.dequeue_timed(cur_time, next_time, true);
         }
       }
-
     }
-  case DEDICATED:{
-      // if (DEBUG) cout << "Inside execute (dedicated thread)\n";
+
+    case DEDICATED: {
       // coverity[lock]
       if (eventsem)
         ink_sem_wait(eventsem);
@@ -279,9 +281,10 @@
       free_event(oneevent);
       break;
     }
-  default:
-    ink_assert(!"bad case value (execute)");
-    break;
+
+    default:
+      ink_assert(!"bad case value (execute)");
+      break;
   }                             /* End switch */
   // coverity[missing_unlock]
 }

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc Wed Feb 24 18:48:42 2010
@@ -44,43 +44,25 @@
 #include "ink_apidefs.h"
 
 HostDBProcessor hostDBProcessor;
-int
-  HostDBProcessor::hostdb_strict_round_robin = 0;
-int
-  hostdb_enable = true;
-int
-  hostdb_migrate_on_demand = true;
-int
-  hostdb_cluster = false;
-int
-  hostdb_cluster_round_robin = false;
-int
-  hostdb_lookup_timeout = 120;
-int
-  hostdb_insert_timeout = 160;
-int
-  hostdb_re_dns_on_reload = false;
-int
-  hostdb_ttl_mode = TTL_OBEY;
-unsigned int
-  hostdb_current_interval = 0;
-unsigned int
-  hostdb_ip_stale_interval = HOST_DB_IP_STALE;
-unsigned int
-  hostdb_ip_timeout_interval = HOST_DB_IP_TIMEOUT;
-unsigned int
-  hostdb_ip_fail_timeout_interval = HOST_DB_IP_FAIL_TIMEOUT;
-unsigned int
-  hostdb_serve_stale_but_revalidate = 0;
-char
-  hostdb_filename[PATH_NAME_MAX + 1] = DEFAULT_HOST_DB_FILENAME;
-int
-  hostdb_size = DEFAULT_HOST_DB_SIZE;
+int HostDBProcessor::hostdb_strict_round_robin = 0;
+int hostdb_enable = true;
+int hostdb_migrate_on_demand = true;
+int hostdb_cluster = false;
+int hostdb_cluster_round_robin = false;
+int hostdb_lookup_timeout = 120;
+int hostdb_insert_timeout = 160;
+int hostdb_re_dns_on_reload = false;
+int hostdb_ttl_mode = TTL_OBEY;
+unsigned int hostdb_current_interval = 0;
+unsigned int hostdb_ip_stale_interval = HOST_DB_IP_STALE;
+unsigned int hostdb_ip_timeout_interval = HOST_DB_IP_TIMEOUT;
+unsigned int hostdb_ip_fail_timeout_interval = HOST_DB_IP_FAIL_TIMEOUT;
+unsigned int hostdb_serve_stale_but_revalidate = 0;
+char hostdb_filename[PATH_NAME_MAX + 1] = DEFAULT_HOST_DB_FILENAME;
+int hostdb_size = DEFAULT_HOST_DB_SIZE;
 //int hostdb_timestamp = 0;
-int
-  hostdb_sync_frequency = 60;
-int
-  hostdb_disable_reverse_lookup = 0;
+int hostdb_sync_frequency = 60;
+int hostdb_disable_reverse_lookup = 0;
 
 ClassAllocator<HostDBContinuation> hostDBContAllocator("hostDBContAllocator");
 
@@ -94,7 +76,7 @@
   remoteHostDBQueue[MULTI_CACHE_PARTITIONS];
 
 
-static INK_INLINE int
+static inline int
 corrupt_debugging_callout(HostDBInfo * e, RebuildMC & r)
 {
   Debug("hostdb", "corrupt %d part %d", (char *) &e->app.rr.offset - r.data, r.partition);
@@ -102,7 +84,7 @@
 }
 
 
-INK_INLINE void
+inline void
 hostdb_cont_free(HostDBContinuation * cont)
 {
   if (cont->pending_action)
@@ -958,11 +940,15 @@
   // Since ProxyMutexPtr has a cast operator, gcc-3.x get upset
   // about ambiguity when doing this comparison, so by reversing
   // the operands, I force it to pick the cast operation /leif.
+#ifdef USE_NCA
   if (thread->mutex == cont->mutex) {
     thread->schedule_in(c, MUTEX_RETRY_DELAY);
   } else {
     dnsProcessor.thread->schedule_imm(c);
   }
+#else
+  thread->schedule_in(c, MUTEX_RETRY_DELAY);
+#endif
 
   return &c->action;
 }

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/I_HostDB.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/I_HostDB.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/I_HostDB.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/I_HostDB.h Wed Feb 24 18:48:42 2010
@@ -32,10 +32,6 @@
 #ifndef _I_HostDB_h_
 #define _I_HostDB_h_
 
-#ifndef INK_INLINE
-#define INK_INLINE
-#endif
-
 #include "I_EventSystem.h"
 #include "I_Net.h"
 #include "I_Cache.h"

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/Makefile.am
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/Makefile.am?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/Makefile.am (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/Makefile.am Wed Feb 24 18:48:42 2010
@@ -17,16 +17,7 @@
 #  limitations under the License.
 
 AM_CPPFLAGS = \
-  -I$(top_srcdir)/libinktomi++ \
-  -I$(top_srcdir)/librecords \
-  -I$(top_srcdir)/iocore/eventsystem \
-  -I$(top_srcdir)/iocore/net \
-  -I$(top_srcdir)/iocore/cache \
-  -I$(top_srcdir)/iocore/aio \
-  -I$(top_srcdir)/iocore/utils \
-  -I$(top_srcdir)/iocore/cluster \
-  -I$(top_srcdir)/iocore/dns \
-  -I$(top_srcdir)/iocore/hostdb \
+  $(iocore_include_dirs) \
   -I$(top_srcdir)/proxy/mgmt2/snmp \
   -I$(top_srcdir)/proxy/mgmt2/web2 \
   -I$(top_srcdir)/proxy/mgmt2/api2/include \
@@ -47,7 +38,6 @@
 libinkhostdb_a_SOURCES = \
   HostDB.cc \
   I_HostDBProcessor.h \
-  Inline.cc \
   MultiCache.cc \
   P_HostDB.h \
   P_HostDBProcessor.h \

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc Wed Feb 24 18:48:42 2010
@@ -28,8 +28,7 @@
   
  ****************************************************************************/
 
-#include "ink_unused.h"     /* MAGIC_EDITING_TAG */
-#include <string.h>
+#include "inktomi++.h"
 
 #ifdef NON_MODULAR
 #include "P_HostDB.h"
@@ -427,26 +426,38 @@
     int fd = -1;
 
 // find a good address to start
+#if (HOST_OS != darwin)
     fd = socketManager.open("/dev/zero", O_RDONLY, 0645);
     if (fd < 0) {
       Warning("unable to open /dev/zero: %d, %s", errno, strerror(errno));
       goto Labort;
     }
+#endif
 
     // lots of useless stuff
-
+#if (HOST_OS == darwin)
+    cur = (char *) mmap(0, totalsize, PROT_READ, MAP_SHARED_MAP_NORESERVE | MAP_ANON, -1, 0);
+#else 
     cur = (char *) mmap(0, totalsize, PROT_READ, MAP_SHARED_MAP_NORESERVE, fd, 0);
-
+#endif
     if (cur == NULL || cur == (caddr_t) MAP_FAILED) {
       store = saved;
-      Warning("unable to mmap /dev/zero for %u bytes", totalsize);
+#if (HOST_OS == darwin)
+      Warning("unable to mmap anonymous region for %u bytes: %d, %s", totalsize, errno, strerror(errno));
+#else
+      Warning("unable to mmap /dev/zero for %u bytes: %d, %s", totalsize, errno, strerror(errno));
       close(fd);
+#endif
       goto Labort;
     }
     if (munmap(cur, totalsize)) {
       store = saved;
-      Warning("unable to munmap /dev/zero for %u bytes", totalsize);
+#if (HOST_OS == darwin)
+      Warning("unable to munmap anonymous region for %u bytes: %d, %s", totalsize, errno, strerror(errno));
+#else
+      Warning("unable to munmap /dev/zero for %u bytes: %d, %s", totalsize, errno, strerror(errno));
       close(fd);
+#endif
       goto Labort;
     }
     data = cur;
@@ -472,8 +483,9 @@
     mapped_header = (MultiCacheHeader *) cur;
     if (!mmap_region(1, fds, cur, private_flag, fd))
       goto Labort;
-
+#if (HOST_OS != darwin)
     ink_assert(!socketManager.close(fd, keFile));
+#endif
     store = saved;
   }
 
@@ -833,7 +845,7 @@
 
   ink_assert(data != new_data);
   if (new_data == NULL || new_data == (caddr_t) MAP_FAILED) {
-    Warning("unable to mmap /dev/zero for %u bytes", totalsize);
+    Warning("unable to mmap /dev/zero for %u bytes: %d, %s", totalsize,errno, strerror(errno));
     return -1;
   }
   ::close(fd);

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDB.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDB.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDB.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDB.h Wed Feb 24 18:48:42 2010
@@ -31,17 +31,13 @@
 #ifndef _P_HostDB_h_
 #define _P_HostDB_h_
 
-#ifndef INLINE_CC
-#undef INK_INLINE
-#define INK_INLINE inline
-#endif
+#include "inktomi++.h"
 
 #ifdef SPLIT_DNS
 #include "P_SplitDNS.h"
 #include "P_Cluster.h"
 #endif
 
-#include "inktomi++.h"
 #include "P_EventSystem.h"
 
 // HostDB files

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h Wed Feb 24 18:48:42 2010
@@ -158,7 +158,7 @@
   HostDBCache();
 };
 
-INK_INLINE HostDBInfo *
+inline HostDBInfo *
 HostDBRoundRobin::find_ip(unsigned int ip)
 {
   bool bad = (n <= 0 || n > HOST_DB_MAX_ROUND_ROBIN_INFO || good <= 0 || good > HOST_DB_MAX_ROUND_ROBIN_INFO);
@@ -176,7 +176,7 @@
   return NULL;
 }
 
-INK_INLINE HostDBInfo *
+inline HostDBInfo *
 HostDBRoundRobin::select_best(unsigned int client_ip, HostDBInfo * r)
 {
   (void) r;
@@ -203,7 +203,7 @@
   return &info[best];
 }
 
-INK_INLINE HostDBInfo *
+inline HostDBInfo *
 HostDBRoundRobin::select_best_http(unsigned int client_ip, time_t now, ink32 fail_window)
 {
   bool bad = (n <= 0 || n > HOST_DB_MAX_ROUND_ROBIN_INFO || good <= 0 || good > HOST_DB_MAX_ROUND_ROBIN_INFO);
@@ -383,24 +383,24 @@
 extern HostDBCache hostDB;
 //extern Queue<HostDBContinuation>  remoteHostDBQueue[MULTI_CACHE_PARTITIONS];
 
-INK_INLINE unsigned int
+inline unsigned int
 master_hash(INK_MD5 & md5)
 {
   return (int) (md5[1] >> 32);
 }
-INK_INLINE bool
+inline bool
 is_dotted_form_hostname(char *c)
 {
   return -1 != (int) ink_inet_addr(c);
 }
 
-INK_INLINE Queue<HostDBContinuation> &
+inline Queue<HostDBContinuation> &
 HostDBCache::pending_dns_for_hash(INK_MD5 & md5)
 {
   return pending_dns[partition_of_bucket((int) (fold_md5(md5) % hostDB.buckets))];
 }
 
-INK_INLINE int
+inline int
 HostDBContinuation::key_partition()
 {
   return hostDB.partition_of_bucket(fold_md5(md5) % hostDB.buckets);

Modified: incubator/trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h Wed Feb 24 18:48:42 2010
@@ -482,7 +482,7 @@
   return (md5.fold());
 }
 
-template<class C> INK_INLINE int MultiCache<C>::level_of_block(C * b)
+template<class C> inline int MultiCache<C>::level_of_block(C * b)
 {
   if ((char *) b - data >= level_offset[1]) {
     if ((char *) b - data >= level_offset[2])
@@ -492,7 +492,7 @@
   return 0;
 }
 
-template<class C> INK_INLINE C * MultiCache<C>::cache_bucket(inku64 folded_md5, int level)
+template<class C> inline C * MultiCache<C>::cache_bucket(inku64 folded_md5, int level)
 {
   int bucket = (int) (folded_md5 % buckets);
   char *offset = data + level_offset[level] + bucketsize[level] * bucket;
@@ -502,7 +502,7 @@
 //
 // Insert an entry
 //
-template<class C> INK_INLINE C * MultiCache<C>::insert_block(inku64 folded_md5, C * new_block, int level)
+template<class C> inline C * MultiCache<C>::insert_block(inku64 folded_md5, C * new_block, int level)
 {
   C *b = cache_bucket(folded_md5, level);
   C *block = NULL, *empty = NULL;
@@ -573,7 +573,7 @@
 //
 // This function ejects some number of entries.
 //
-template<class C> INK_INLINE void MultiCache<C>::flush(C * b, int bucket, int level)
+template<class C> inline void MultiCache<C>::flush(C * b, int bucket, int level)
 {
   C *block = NULL;
   if (level < levels - 1) {
@@ -594,7 +594,7 @@
 //
 // Match a cache line and a folded md5 key
 //
-template<class C> INK_INLINE bool MultiCache<C>::match(inku64 folded_md5, C * block)
+template<class C> inline bool MultiCache<C>::match(inku64 folded_md5, C * block)
 {
   return block->tag() == make_tag(folded_md5);
 }
@@ -602,7 +602,7 @@
 //
 // This code is a bit of a mess and should probably be rewritten
 //
-template<class C> INK_INLINE void MultiCache<C>::delete_block(C * b)
+template<class C> inline void MultiCache<C>::delete_block(C * b)
 {
   if (b->backed) {
     int l = level_of_block(b);
@@ -620,7 +620,7 @@
 //
 // Lookup an entry up to some level in the cache
 //
-template<class C> INK_INLINE C * MultiCache<C>::lookup_block(inku64 folded_md5, int level)
+template<class C> inline C * MultiCache<C>::lookup_block(inku64 folded_md5, int level)
 {
   C *b = cache_bucket(folded_md5, 0);
   inku64 tag = make_tag(folded_md5);
@@ -646,7 +646,7 @@
   return NULL;
 }
 
-template<class C> INK_INLINE void MultiCache<C>::rebuild_element(int bucket, char *elem, RebuildMC & r)
+template<class C> inline void MultiCache<C>::rebuild_element(int bucket, char *elem, RebuildMC & r)
 {
   C *e = (C *) elem;
   if (!e->is_empty()) {
@@ -671,7 +671,7 @@
   }
 }
 
-template<class C> INK_INLINE void MultiCache<C>::copy_heap(int partition, MultiCacheHeapGC * gc)
+template<class C> inline void MultiCache<C>::copy_heap(int partition, MultiCacheHeapGC * gc)
 {
   int b = first_bucket_of_partition(partition);
   int n = buckets_of_partition(partition);

Modified: incubator/trafficserver/traffic/trunk/iocore/net/Connection.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/Connection.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/Connection.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/Connection.cc Wed Feb 24 18:48:42 2010
@@ -29,7 +29,7 @@
 **************************************************************************/
 
 #include "ink_unused.h"   /* MAGIC_EDITING_TAG */
-#include "ink_platform.h"
+#include "inktomi++.h"
 
 #include "P_Net.h"
 
@@ -118,19 +118,17 @@
 
 
 int
-Connection::fast_connect(const unsigned int ip, const int port, NetVCOptions * opt, const int socketFd)
+Connection::fast_connect(const unsigned int ip, const int port, NetVCOptions * opt, const int sock)
 {
   inku32 *z;
-  ink_assert(fd == NO_FD);
   int res = 0;
 
-  if (socketFd == -1) {
-    if ((res = socketManager.socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+  if (sock < 0) {
+    ink_assert(fd == NO_FD);
+    if ((res = socketManager.socket(AF_INET, SOCK_STREAM, 0)) < 0)
       goto Lerror;
-    }
-  } else {
-    res = socketFd;
-  }
+  } else
+    res = sock;
 
   fd = res;
 
@@ -147,7 +145,7 @@
 
   // cannot do this after connection on non-blocking connect
 #ifdef SET_TCP_NO_DELAY
-  Debug("socket", "setting TCP_NODELAY in fast_connect");
+  NetDebug("socket", "setting TCP_NODELAY in fast_connect");
   if ((res = safe_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, ON, sizeof(int))) < 0)
     goto Lerror;
 #endif
@@ -183,18 +181,17 @@
     }
     if (opt->sockopt_flags & 1) {
       safe_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, ON, sizeof(int));
-      Debug("socket", "::fast_connect: setsockopt() TCP_NODELAY on socket");
+      NetDebug("socket", "::fast_connect: setsockopt() TCP_NODELAY on socket");
     }
     if (opt->sockopt_flags & 2) {
       safe_setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, ON, sizeof(int));
-      Debug("socket", "::fast_connect: setsockopt() SO_KEEPALIVE on socket");
+      NetDebug("socket", "::fast_connect: setsockopt() SO_KEEPALIVE on socket");
     }
   }
-  res =::connect(fd, (struct sockaddr *) &sa, sizeof(struct sockaddr_in));
+  res = ::connect(fd, (struct sockaddr *) &sa, sizeof(struct sockaddr_in));
 
-  if (res < 0 && errno != EINPROGRESS) {
+  if (res < 0 && errno != EINPROGRESS)
     goto Lerror;
-  }
 
   return 0;
 
@@ -237,7 +234,7 @@
       int p = time(NULL) + offset;
       p = (p % (LAST_RANDOM_PORT - FIRST_RANDOM_PORT)) + FIRST_RANDOM_PORT;
       bind_sa.sin_port = htons(p);
-      Debug("dns", "random port = %d\n", p);
+      NetDebug("dns", "random port = %d\n", p);
       if ((res = socketManager.ink_bind(fd, (struct sockaddr *) &bind_sa, sizeof(bind_sa), Proto)) < 0) {
         offset += 101;
         continue;

Modified: incubator/trafficserver/traffic/trunk/iocore/net/DetailedLog.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/DetailedLog.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/DetailedLog.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/DetailedLog.cc Wed Feb 24 18:48:42 2010
@@ -21,6 +21,7 @@
   limitations under the License.
  */
 
+#include "ink_config.h"
 #include "DetailedLog.h"
 
 static pthread_mutex_t logMutex = PTHREAD_MUTEX_INITIALIZER;

Modified: incubator/trafficserver/traffic/trunk/iocore/net/I_Net.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/I_Net.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/I_Net.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/I_Net.h Wed Feb 24 18:48:42 2010
@@ -41,11 +41,6 @@
 #ifndef __I_NET_H_
 #define __I_NET_H_
 
-
-#ifndef INK_INLINE
-#define INK_INLINE
-#endif
-
 #include "I_Version.h"
 #include "I_EventSystem.h"
 #include <netinet/in.h>

Modified: incubator/trafficserver/traffic/trunk/iocore/net/I_NetConfig.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/I_NetConfig.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/I_NetConfig.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/I_NetConfig.h Wed Feb 24 18:48:42 2010
@@ -29,7 +29,13 @@
  * net sub system.
  * For the default values look at NetConfig.cc
  */
+#if (HOST_OS == solaris)
+#define DEFAULT_POLL_TIMEOUT                      30  /* mseconds */
+#else
+#define DEFAULT_POLL_TIMEOUT                      10  /* mseconds */
+#endif
 
+extern int net_config_poll_timeout;
 extern int net_config_max_poll_delay;
 extern int net_config_fds_throttle;
 extern int net_config_listen_backlog;

Modified: incubator/trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h Wed Feb 24 18:48:42 2010
@@ -32,9 +32,9 @@
 #include "I_IOBuffer.h"
 #include "I_Socks.h"
 
-// #define WITH_DETTAILED_VCONNECTION_LOGGING 1
+// #define WITH_DETAILED_VCONNECTION_LOGGING 1
 
-#if WITH_DETTAILED_VCONNECTION_LOGGING
+#if WITH_DETAILED_VCONNECTION_LOGGING
 #include "DetailedLog.h"
 #endif
 
@@ -160,7 +160,7 @@
     @return vio
 
   */
-  virtual VIO * do_io_read(Continuation * c, int nbytes, MIOBuffer * buf) = 0;
+  virtual VIO * do_io_read(Continuation * c, ink64 nbytes, MIOBuffer * buf) = 0;
 
   /**
     Initiates write. Thread-safe, may be called when not handling
@@ -196,7 +196,7 @@
     @return vio pointer
 
   */
-  virtual VIO *do_io_write(Continuation * c, int nbytes, IOBufferReader * buf, bool owner = false) = 0;
+  virtual VIO *do_io_write(Continuation * c, ink64 nbytes, IOBufferReader * buf, bool owner = false) = 0;
 
   /**
     Closes the vconnection. A state machine MUST call do_io_close()
@@ -417,7 +417,7 @@
   /** Set remote sock addr struct. */
   virtual void set_remote_addr() = 0;
 
-#if WITH_DETTAILED_VCONNECTION_LOGGING
+#if WITH_DETAILED_VCONNECTION_LOGGING
   void loggingInit()
   {
     if (logging == NULL) {
@@ -428,6 +428,7 @@
   {
     if (logging != NULL) {
       logging->add(message);
+      logging->print();
     }
   }
   void printLogs() const
@@ -457,8 +458,10 @@
   {
     return (logging != NULL);
   }
+  DetailedLog *logging;
 #else
   void addLogMessage(const char *message) {}
+  void loggingInit() {}
   bool loggingEnabled() const { return false; }
   ink_hrtime getLogsTotalTime() const { return 0; }
   void printLogs() const {}
@@ -466,12 +469,8 @@
 #endif
 
 private:
-    NetVConnection(const NetVConnection &);
+  NetVConnection(const NetVConnection &);
   NetVConnection & operator =(const NetVConnection &);
-#if WITH_DETTAILED_VCONNECTION_LOGGING
-  /** Used to queue up messages for the connection. */
-  DetailedLog *logging;
-#endif
 
 protected:
   struct sockaddr_in local_addr;
@@ -486,7 +485,7 @@
 VConnection(NULL),
 attributes(0),
 thread(NULL),
-#if WITH_DETTAILED_VCONNECTION_LOGGING
+#if WITH_DETAILED_VCONNECTION_LOGGING
 logging(NULL),
 #endif
 got_local_addr(0),

Modified: incubator/trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h Wed Feb 24 18:48:42 2010
@@ -112,5 +112,5 @@
   virtual void UDPConnection_is_abstract() = 0;
 };
 
-INK_INLINE UDPConnection *new_UDPConnection(int fd);
+inline UDPConnection *new_UDPConnection(int fd);
 #endif //__I_UDPCONNECTION_H_

Modified: incubator/trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h Wed Feb 24 18:48:42 2010
@@ -85,7 +85,7 @@
    @param buf if !NULL, then len bytes copied from buf and made into packet.
    @param len # of bytes to copy from buf
  */
-INK_INLINE UDPPacket *new_UDPPacket(struct sockaddr_in *to, ink_hrtime when = 0, char *buf = NULL, int len = 0);
+inline UDPPacket *new_UDPPacket(struct sockaddr_in *to, ink_hrtime when = 0, char *buf = NULL, int len = 0);
 /**
    Create a new packet to be sent over UDPConnection. This clones and
    makes a reference to an existing IOBufferBlock chain.
@@ -97,19 +97,19 @@
    for packet
    @param len # of bytes to reference from block
  */
-INK_INLINE UDPPacket *new_UDPPacket(struct sockaddr_in *to,
+inline UDPPacket *new_UDPPacket(struct sockaddr_in *to,
                                     ink_hrtime when = 0, IOBufferBlock * block = NULL, int len = 0);
 /**
    Create a new packet to be sent over UDPConnection.  Packet has no
    destination or data.
 */
-INK_INLINE UDPPacket *new_UDPPacket();
+inline UDPPacket *new_UDPPacket();
 
 /**
    Create a new packet to be delivered to application.
    Internal function only
 */
-INK_INLINE UDPPacket *new_incoming_UDPPacket(struct sockaddr_in *from, char *buf, int len);
+inline UDPPacket *new_incoming_UDPPacket(struct sockaddr_in *from, char *buf, int len);
 
 //@}
 #endif //__I_UDPPACKET_H_

Modified: incubator/trafficserver/traffic/trunk/iocore/net/Makefile.am
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/Makefile.am?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/Makefile.am (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/Makefile.am Wed Feb 24 18:48:42 2010
@@ -17,15 +17,9 @@
 #  limitations under the License.
 
 AM_CPPFLAGS = \
-  -I$(top_srcdir)/iocore/eventsystem \
-  -I$(top_srcdir)/iocore/cache \
-  -I$(top_srcdir)/iocore/aio \
-  -I$(top_srcdir)/iocore/utils \
-  -I$(top_srcdir)/iocore/cluster \
-  -I$(top_srcdir)/iocore/hostdb \
-  -I$(top_srcdir)/iocore/dns \
-  -I$(top_srcdir)/librecords \
+  $(iocore_include_dirs) \
   -I$(top_srcdir)/libinktomi++ \
+  -I$(top_srcdir)/librecords \
   -I$(top_srcdir)/proxy \
   -I$(top_srcdir)/proxy/hdrs \
   -I$(top_srcdir)/proxy/mgmt2 \
@@ -33,6 +27,7 @@
   -I$(top_srcdir)/proxy/mgmt2/utils \
   -I$(top_srcdir)/proxy/mgmt2/web2
 
+
 DEFS += @IOCORE_MODULARIZED_DEFS@
 
 noinst_LIBRARIES = libinknet.a
@@ -46,7 +41,6 @@
   I_Net.h \
   I_NetProcessor.h \
   I_NetVConnection.h \
-  Inline.cc \
   I_Socks.h \
   I_UDPConnection.h \
   I_UDPNet.h \

Modified: incubator/trafficserver/traffic/trunk/iocore/net/NetConfig.cc
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/NetConfig.cc?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/NetConfig.cc (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/NetConfig.cc Wed Feb 24 18:48:42 2010
@@ -22,8 +22,10 @@
  */
 
 #include "I_NetConfig.h"
+
 #define NULL 0
 
+int net_config_poll_timeout = DEFAULT_POLL_TIMEOUT;
 int net_config_fds_throttle = 8000;
 int net_config_max_poll_delay = 0;
 int net_config_listen_backlog = 1024;

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_Connection.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_Connection.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_Connection.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_Connection.h Wed Feb 24 18:48:42 2010
@@ -58,7 +58,6 @@
 // Defines
 //
 
-//#define NO_FD                    (-1)
 #define NON_BLOCKING_CONNECT     true
 #define BLOCKING_CONNECT         false
 #define CONNECT_WITH_TCP         true
@@ -88,11 +87,11 @@
               bool non_blocking_connect = NON_BLOCKING_CONNECT,
               bool use_tcp = CONNECT_WITH_TCP, bool non_blocking = NON_BLOCKING, bool bind_random_port = BIND_ANY_PORT);
 
-  int fast_connect(const unsigned int ip, const int port, NetVCOptions * opt = NULL, const int socketFd = -1);
+  int fast_connect(const unsigned int ip, const int port, NetVCOptions * opt = NULL, const int sock = -1);
 
   int bind_connect(unsigned int target_ip, int target_port,
                    unsigned int my_ip,
-                   NetVCOptions * opt = NULL,
+                   NetVCOptions * opt = NULL, int sock = -1,
                    bool non_blocking_connect = NON_BLOCKING_CONNECT,
                    bool use_tcp = CONNECT_WITH_TCP,
                    bool non_blocking = NON_BLOCKING, bool bc_no_connect = BC_CONNECT, bool bc_no_bind = BC_BIND);
@@ -107,8 +106,8 @@
 
   int close();                  // 0 on success, -errno on failure
 
-    virtual ~ Connection();
-    Connection();
+  virtual ~ Connection();
+  Connection();
 };
 
 ///////////////////////////////////////////////////////////////////////
@@ -139,9 +138,7 @@
   int listen(int port, bool non_blocking = false, int recv_bufsize = 0, int send_bufsize = 0);
   int setup_fd_for_listen(bool non_blocking = false, int recv_bufsize = 0, int send_bufsize = 0);
 
-    Server():Connection(), accept_ip(INADDR_ANY)
-  {
-  }
+  Server():Connection(), accept_ip(INADDR_ANY) { }
 };
 
 #endif /*_Connection_h*/

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_LibBulkIO.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_LibBulkIO.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_LibBulkIO.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_LibBulkIO.h Wed Feb 24 18:48:42 2010
@@ -25,7 +25,7 @@
 #ifndef _LIB_BULK_IO_H
 #define _LIB_BULK_IO_H
 
-#if (HOST_OS == sunos)
+#if (HOST_OS == solaris)
 #include <stdio.h>
 #include <errno.h>
 #include <sys/types.h>

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_Net.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_Net.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_Net.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_Net.h Wed Feb 24 18:48:42 2010
@@ -30,10 +30,6 @@
 #ifndef __P_NET_H__
 #define __P_NET_H__
 
-#ifndef INLINE_CC
-#undef INK_INLINE
-#define INK_INLINE inline
-#endif
 // Net Stats 
 
 enum Net_Stats
@@ -93,6 +89,12 @@
 #define NET_DECREMENT_THREAD_DYN_STAT(_s, _t) \
   RecIncrRawStatSum(net_rsb, _t, (int) _s, -1);
 
+#ifndef DEBUG
+#define NetDebug if (0) dummy_debug
+#else
+#define NetDebug Debug
+#endif
+
 #include "inktomi++.h"
 #include "P_EventSystem.h"
 #include "I_Net.h"
@@ -122,5 +124,11 @@
                                        NET_SYSTEM_MODULE_MAJOR_VERSION, \
                                        NET_SYSTEM_MODULE_MINOR_VERSION, \
                                        PRIVATE_MODULE_HEADER)
+// libev backend flags
+#if (HOST_OS == solaris)
+#define LIBEV_BACKEND_LIST (EVBACKEND_POLL | EVBACKEND_SELECT) // Level-Triggered
+#else
+  #define LIBEV_BACKEND_LIST 0 /* auto */
+#endif
 
 #endif

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_NetAccept.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_NetAccept.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_NetAccept.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_NetAccept.h Wed Feb 24 18:48:42 2010
@@ -97,7 +97,7 @@
   unsigned long sockopt_flags;
   EventType etype;
   UnixNetVConnection *epoll_vc; // only storage for epoll events
-  struct epoll_data_ptr ep;
+  EventIO ep;
 
   // Functions all THREAD_FREE and THREAD_ALLOC to be performed
   // for both SSL and regular NetVConnection transparent to

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_NetVConnection.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_NetVConnection.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_NetVConnection.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_NetVConnection.h Wed Feb 24 18:48:42 2010
@@ -23,7 +23,7 @@
 
 #include "I_NetVConnection.h"
 
-INK_INLINE const struct sockaddr_in &
+inline const struct sockaddr_in &
 NetVConnection::get_remote_addr()
 {
   if (!got_remote_addr) {
@@ -33,20 +33,20 @@
   return remote_addr;
 }
 
-INK_INLINE unsigned int
+inline unsigned int
 NetVConnection::get_remote_ip()
 {
   return (unsigned int) get_remote_addr().sin_addr.s_addr;
 }
 
 
-INK_INLINE int
+inline int
 NetVConnection::get_remote_port()
 {
   return ntohs(get_remote_addr().sin_port);
 }
 
-INK_INLINE const struct sockaddr_in &
+inline const struct sockaddr_in &
 NetVConnection::get_local_addr()
 {
   if (!got_local_addr) {
@@ -58,13 +58,13 @@
   return local_addr;
 }
 
-INK_INLINE unsigned int
+inline unsigned int
 NetVConnection::get_local_ip()
 {
   return (unsigned int) get_local_addr().sin_addr.s_addr;
 }
 
-INK_INLINE int
+inline int
 NetVConnection::get_local_port()
 {
   return ntohs(get_local_addr().sin_port);

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_SSLConfig.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_SSLConfig.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_SSLConfig.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_SSLConfig.h Wed Feb 24 18:48:42 2010
@@ -31,9 +31,7 @@
 #ifndef __P_SSLCONFIG_H__
 #define __P_SSLCONFIG_H__
 
-
-#include <stdio.h>
-#include "ink_platform.h"
+#include "inktomi++.h"
 
 #define	    SSL_NO_ACCEL	    0
 #define     SSL_NCIPHER_ACCEL	    1

Modified: incubator/trafficserver/traffic/trunk/iocore/net/P_SSLNetAccept.h
URL: http://svn.apache.org/viewvc/incubator/trafficserver/traffic/trunk/iocore/net/P_SSLNetAccept.h?rev=915922&r1=915921&r2=915922&view=diff
==============================================================================
--- incubator/trafficserver/traffic/trunk/iocore/net/P_SSLNetAccept.h (original)
+++ incubator/trafficserver/traffic/trunk/iocore/net/P_SSLNetAccept.h Wed Feb 24 18:48:42 2010
@@ -39,6 +39,7 @@
 #if !defined (_SSLNetAccept_h_)
 #define _SSLNetAccept_h_
 
+#include "inktomi++.h"
 #include "P_Connection.h"
 #include "P_NetAccept.h"