Adding support for libmemcached_ping().

[awesomized/libmemcached] / libmemcached / io.c

diff --git a/libmemcached/io.c b/libmemcached/io.c
index f1afc6695322fe961edc7a9dbd2c41a402def199..d6129b850f909862c8d8a24529f7c11fd4f60cae 100644 (file)
--- a/libmemcached/io.c
+++ b/libmemcached/io.c
@@ -32,8 +32,15 @@ static memcached_return_t io_wait(memcached_server_write_instance_st ptr,
   };
   int error;
 
-  unlikely (read_or_write == MEM_WRITE) /* write */
+  if (read_or_write == MEM_WRITE) /* write */
+  {
     fds.events= POLLOUT;
+    WATCHPOINT_SET(ptr->io_wait_count.write++);
+  }
+  else
+  {
+    WATCHPOINT_SET(ptr->io_wait_count.read++);
+  }
 
   /*
    ** We are going to block on write, but at least on Solaris we might block
@@ -62,22 +69,35 @@ static memcached_return_t io_wait(memcached_server_write_instance_st ptr,
     switch (error)
     {
     case 1:
+      WATCHPOINT_IF_LABELED_NUMBER(read_or_write && loop_max < 4, "read() times we had to loop, decremented down from 5", loop_max);
+      WATCHPOINT_IF_LABELED_NUMBER(!read_or_write && loop_max < 4, "write() times we had to loop, decremented down from 5", loop_max);
+
       return MEMCACHED_SUCCESS;
     case 0:
       return MEMCACHED_TIMEOUT;
+    default:
+      WATCHPOINT_ERRNO(errno);
+      {
+        switch (errno)
+        {
 #ifdef TARGET_OS_LINUX
-    case ERESTART:
+        case ERESTART:
 #endif
-    case EINTR:
-      continue;
-    default:
-      ptr->cached_errno= error;
-      memcached_quit_server(ptr, true);
+        case EINTR:
+          continue;
+        default:
+          ptr->cached_errno= error;
+          memcached_quit_server(ptr, true);
 
-      return MEMCACHED_FAILURE;
+          return MEMCACHED_FAILURE;
+        }
+      }
     }
   }
 
+  if (loop_max == 0 && error == 0)
+    return MEMCACHED_TIMEOUT;
+
   /* Imposssible for anything other then -1 */
   WATCHPOINT_ASSERT(error == -1);
   ptr->cached_errno= error;
@@ -252,11 +272,13 @@ memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
       {
         data_read= read(ptr->fd, ptr->read_buffer, MEMCACHED_MAX_BUFFER);
         if (data_read > 0)
+        {
           break;
+        }
         else if (data_read == -1)
         {
           ptr->cached_errno= errno;
-          memcached_return_t rc= MEMCACHED_UNKNOWN_READ_FAILURE;
+          memcached_return_t rc= MEMCACHED_ERRNO;
           switch (errno)
           {
           case EAGAIN:
@@ -287,6 +309,7 @@ memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
             for blocking I/O we do not return 0 and for non-blocking case
             it will return EGAIN if data is not immediatly available.
           */
+          WATCHPOINT_STRING("We had a zero length read()");
           memcached_quit_server(ptr, true);
           *nread= -1;
           return MEMCACHED_UNKNOWN_READ_FAILURE;
@@ -326,8 +349,8 @@ memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
   return MEMCACHED_SUCCESS;
 }
 
-ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
-                           const void *buffer, size_t length, bool with_flush)
+static ssize_t _io_write(memcached_server_write_instance_st ptr,
+                         const void *buffer, size_t length, bool with_flush)
 {
   size_t original_length;
   const char* buffer_ptr;
@@ -403,6 +426,41 @@ ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
   return (ssize_t) original_length;
 }
 
+ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
+                           const void *buffer, size_t length, bool with_flush)
+{
+  return _io_write(ptr, buffer, length, with_flush);
+}
+
+ssize_t memcached_io_writev(memcached_server_write_instance_st ptr,
+                            const struct __write_vector_st *vector,
+                            size_t number_of, bool with_flush)
+{
+  ssize_t total= 0;
+
+  for (size_t x= 0; x < number_of; x++, vector++)
+  {
+    ssize_t returnable;
+
+    if ((returnable= _io_write(ptr, vector->buffer, vector->length, false)) == -1)
+    {
+      return -1;
+    }
+    total+= returnable;
+  }
+
+  if (with_flush)
+  {
+    if (memcached_io_write(ptr, NULL, 0, true) == -1)
+    {
+      return -1;
+    }
+  }
+
+  return total;
+}
+
+
 memcached_return_t memcached_io_close(memcached_server_write_instance_st ptr)
 {
   if (ptr->fd == -1)
@@ -548,6 +606,8 @@ static ssize_t io_flush(memcached_server_write_instance_st ptr,
     if (sent_length == -1)
     {
       ptr->cached_errno= errno;
+      WATCHPOINT_ERRNO(errno);
+      WATCHPOINT_NUMBER(errno);
       switch (errno)
       {
       case ENOBUFS: