[ViewVC] Diff of: cvs/libeio/eio.c

Comparing libeio/eio.c (file contents):
Revision 1.107 by root, Tue Sep 27 00:41:52 2011 UTC vs.
Revision 1.120 by root, Tue Apr 24 18:47:50 2012 UTC

 /*
  * libeio implementation
  *
- * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libeio@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libeio@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
  * tion, are permitted provided that the following conditions are met:
  *
   #endif
   #define D_NAME(entp) entp->d_name
   /* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
-  #if __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__
+  #if __FreeBSD__ || __NetBSD__ || __OpenBSD__
     #define _DIRENT_HAVE_D_TYPE /* sigh */
     #define D_INO(de) (de)->d_fileno
     #define D_NAMLEN(de) (de)->d_namlen
   #elif __linux || defined d_ino || _XOPEN_SOURCE >= 600
     #define D_INO(de) (de)->d_ino
 struct tmpbuf;
 #if _POSIX_VERSION >= 200809L
   #define HAVE_AT 1
-  # define WD2FD(wd) ((wd) ? (wd)->fd : AT_FDCWD)
+  #define WD2FD(wd) ((wd) ? (wd)->fd : AT_FDCWD)
   #ifndef O_SEARCH
     #define O_SEARCH O_RDONLY
   #endif
 #else
   #define HAVE_AT 0
 #define ETP_WORKER_LOCK(wrk)   X_LOCK   (wrklock)
 #define ETP_WORKER_UNLOCK(wrk) X_UNLOCK (wrklock)
 /* worker threads management */
-static void ecb_cold
+static void
 etp_worker_clear (etp_worker *wrk)
 {
 }
 static void ecb_cold
   int res;
 #if HAVE_SYS_SYNCFS
   res = (int)syscall (__NR_syncfs, (int)(fd));
 #else
-  res = -1;
+  res = EIO_ENOSYS ();
-  errno = ENOSYS;
 #endif
   if (res < 0 && errno == ENOSYS && fd >= 0)
     sync ();
 }
 static int
 eio__fallocate (int fd, int mode, off_t offset, size_t len)
 {
-#if HAVE_FALLOCATE
+#if HAVE_LINUX_FALLOCATE
   return fallocate (fd, mode, offset, len);
 #else
-  errno = ENOSYS;
+  return EIO_ENOSYS ();
-  return -1;
 #endif
 }
 #if !HAVE_READAHEAD
 # undef readahead
       todo   -= len;
     }
   FUBd;
-  errno = 0;
+  /* linux's readahead basically only fails for EBADF or EINVAL (not mmappable) */
+  /* but not for e.g. EIO or eof, so we also never fail */
-  return count;
+  return 0;
 }
 #endif
 /* sendfile always needs emulation */
       /* according to source inspection, this is correct, and useful behaviour */
       if (sbytes)
         res = sbytes;
-# elif defined (__APPLE__)
+# elif defined __APPLE__
       off_t sbytes = count;
       res = sendfile (ifd, ofd, offset, &sbytes, 0, 0);
       /* according to the manpage, sbytes is always valid */
       if (sbytes)
       HANDLE h = TO_SOCKET (ifd);
       SetFilePointer (h, offset, 0, FILE_BEGIN);
       res = TransmitFile (TO_SOCKET (ofd), h, count, 0, 0, 0, 0);
 #else
-      res = -1;
+      res = EIO_ENOSYS ();
-      errno = ENOSYS;
 #endif
       /* we assume sendfile can copy at least 128mb in one go */
       if (res <= 128 * 1024 * 1024)
         {
 }
 /*****************************************************************************/
 /* requests implemented outside eio_execute, because they are so large */
+static void
+eio__lseek (eio_req *req)
+{
+  /* this usually gets optimised away completely, or your compiler sucks, */
+  /* or the whence constants really are not 0, 1, 2 */
+  int whence = req->int2 == EIO_SEEK_SET ? SEEK_SET
+             : req->int2 == EIO_SEEK_CUR ? SEEK_CUR
+             : req->int2 == EIO_SEEK_END ? SEEK_END
+             : req->int2;
+  req->offs   = lseek (req->int1, req->offs, whence);
+  req->result = req->offs == (off_t)-1 ? -1 : 0;
+}
 /* result will always end up in tmpbuf, there is always space for adding a 0-byte */
 static int
 eio__realpath (struct tmpbuf *tmpbuf, eio_wd wd, const char *path)
 {
   const char *rel = path;
             }
         }
         errno = ENAMETOOLONG;
         if (res + 1 + len + 1 >= tmp1)
-          return;
+          return -1;
         /* copy one component */
         *res = '/';
         memcpy (res + 1, beg, len);
         if (fd < 0)
           return;
         dirp = fdopendir (fd);
+        if (!dirp)
+          close (fd);
       }
     else
       dirp = opendir (req->ptr1);
   #else
     dirp = opendir (wd_expand (&self->tmpbuf, req->wd, req->ptr1));
                 {
                   if (ent->type == EIO_DT_UNKNOWN)
                     {
                       if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
                         ent->score = 1;
-                      else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
+                      else if (!strchr (name, '.')) /* absence of dots indicate likely dirs */
                         ent->score = len <= 2 ? 4 - len : len <= 4 ? 4 : len <= 7 ? 5 : 6; /* shorter == more likely dir, but avoid too many classes */
                     }
                   else if (ent->type == EIO_DT_DIR)
                     ent->score = 0;
                 }
           req->result = -1;			\
           break;				\
         }					\
     }
+static void ecb_noinline ecb_cold
+etp_proc_init (void)
+{
+#if HAVE_PRCTL_SET_NAME
+  /* provide a more sensible "thread name" */
+  char name[16 + 1];
+  const int namelen = sizeof (name) - 1;
+  int len;
+  prctl (PR_GET_NAME, (unsigned long)name, 0, 0, 0);
+  name [namelen] = 0;
+  len = strlen (name);
+  strcpy (name + (len <= namelen - 4 ? len : namelen - 4), "/eio");
+  prctl (PR_SET_NAME, (unsigned long)name, 0, 0, 0);
+#endif
+}
 X_THREAD_PROC (etp_proc)
 {
   ETP_REQ *req;
   struct timespec ts;
   etp_worker *self = (etp_worker *)thr_arg;
-#if HAVE_PRCTL_SET_NAME
+  etp_proc_init ();
-  prctl (PR_SET_NAME, (unsigned long)"eio_thread", 0, 0, 0);
-#endif
   /* try to distribute timeouts somewhat evenly */
   ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
   for (;;)
   free (req);
   X_LOCK (wrklock);
   etp_worker_free (self);
   X_UNLOCK (wrklock);
-  return 0;
 }
 /*****************************************************************************/
 int ecb_cold
                           req->result = req->wd == EIO_INVALID_WD ? -1 : 0;
                           break;
       case EIO_WD_CLOSE:  req->result = 0;
                           eio_wd_close_sync (req->wd); break;
+      case EIO_SEEK:      eio__lseek (req); break;
       case EIO_READ:      ALLOC (req->size);
                           req->result = req->offs >= 0
                                       ? pread     (req->int1, req->ptr2, req->size, req->offs)
                                       : read      (req->int1, req->ptr2, req->size); break;
       case EIO_WRITE:     req->result = req->offs >= 0
       case EIO_CUSTOM:
         req->feed (req);
         break;
       default:
-        errno = ENOSYS;
-        req->result = -1;
+        req->result = EIO_ENOSYS ();
         break;
     }
   req->errorno = errno;
 }
 #ifndef EIO_NO_WRAPPERS
+eio_req *eio_wd_open (const char *path, int pri, eio_cb cb, void *data)
+{
+  REQ (EIO_WD_OPEN); PATH; SEND;
+}
+eio_req *eio_wd_close (eio_wd wd, int pri, eio_cb cb, void *data)
+{
+  REQ (EIO_WD_CLOSE); req->wd = wd; SEND;
+}
 eio_req *eio_nop (int pri, eio_cb cb, void *data)
 {
   REQ (EIO_NOP); SEND;
 }
 }
 eio_req *eio_readahead (int fd, off_t offset, size_t length, int pri, eio_cb cb, void *data)
 {
   REQ (EIO_READAHEAD); req->int1 = fd; req->offs = offset; req->size = length; SEND;
+}
+eio_req *eio_seek (int fd, off_t offset, int whence, int pri, eio_cb cb, void *data)
+{
+  REQ (EIO_SEEK); req->int1 = fd; req->offs = offset; req->int2 = whence; SEND;
 }
 eio_req *eio_read (int fd, void *buf, size_t length, off_t offset, int pri, eio_cb cb, void *data)
 {
   REQ (EIO_READ); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libeio/eio.c (file contents): Revision 1.107 by root, Tue Sep 27 00:41:52 2011 UTC vs. Revision 1.120 by root, Tue Apr 24 18:47:50 2012 UTC

Diff Legend

Comparing libeio/eio.c (file contents):
Revision 1.107 by root, Tue Sep 27 00:41:52 2011 UTC vs.
Revision 1.120 by root, Tue Apr 24 18:47:50 2012 UTC