refresh (create temporary patch)

diff --git a/meta b/meta
index b61eac605e26ef8aeeb58ca9e9e1dd622a24e0ca..0070404f2b2623c9b76020eeb0031c0738e9ac3d 100644 (file)
--- a/meta
+++ b/meta
@@ -1,11 +1,12 @@
 Version: 1
-Previous: 730803fd4b54cc957dabe2dc0fd447b38caefd60
-Head: 10f8a3f709f58fda4072dbd847e9fe2e892a65f7
+Previous: 5c4b4489cce95156bf7e607a77f3d07fe8f0fab8
+Head: 124af5c0388f70afb7680d5551b45deb3f232183
 Applied:
   real-close: 3409f8d6af187d25c63a5d1f8ee8bff5f14555e2
   dup2: ca5813e7cf95dee5933fc417e4a34d26f2b01824
   oobinline: ac51c1095f505373a6ec54b8f1d990259fb34d97
   fork-connect: 10f8a3f709f58fda4072dbd847e9fe2e892a65f7
+  refresh-temp: 124af5c0388f70afb7680d5551b45deb3f232183
 Unapplied:
   dbg-out: 04273ee712db4d53efb390462c1b738bb54a57df
   fstat: a62c653906870422edef5f6388dac9f76c953e35

diff --git a/patches/refresh-temp b/patches/refresh-temp
new file mode 100644 (file)
index 0000000..5d465c1
--- /dev/null
+++ b/patches/refresh-temp
@@ -0,0 +1,181 @@
+Bottom: 3ea2748a5c41b11a2e7033c56bddd938d2770b6c
+Top:    216390f24bdb1fa45d9326571f8dd46b1fd804ef
+Author: Sean Hefty <sean.hefty@intel.com>
+Date:   2012-08-10 22:06:41 -0700
+
+Refresh of fork-connect
+
+---
+
+diff --git a/src/preload.c b/src/preload.c
+index b18d310..c61d092 100644
+--- a/src/preload.c
++++ b/src/preload.c
+@@ -99,12 +99,20 @@ static int fork_support;
+ 
+ enum fd_type {
+       fd_normal,
+-      fd_rsocket,
+-      fd_fork
++      fd_rsocket
++};
++
++enum fd_fork_state {
++      fd_ready,
++      fd_fork,
++      fd_fork_listen,
++      fd_fork_active,
++      fd_fork_passive
+ };
+ 
+ struct fd_info {
+       enum fd_type type;
++      enum fd_fork_state state;
+       int fd;
+       int dupfd;
+       atomic_t refcnt;
+@@ -143,13 +151,14 @@ err1:
+       return ret;
+ }
+ 
+-static void fd_store(int index, int fd, enum fd_type type)
++static void fd_store(int index, int fd, enum fd_type type, enum fd_fork_state state)
+ {
+       struct fd_info *fdi;
+ 
+       fdi = idm_at(&idm, index);
+       fdi->fd = fd;
+       fdi->type = type;
++      fdi->state = state;
+ }
+ 
+ static inline enum fd_type fd_get(int index, int *fd)
+@@ -175,6 +184,14 @@ static inline int fd_getd(int index)
+       return fdi ? fdi->fd : index;
+ }
+ 
++static inline enum fd_state fd_gets(int index)
++{
++      struct fd_info *fdi;
++
++      fdi = idm_lookup(&idm, index);
++      return fdi ? fdi->state : fd_ready;
++}
++
+ static inline enum fd_type fd_gett(int index)
+ {
+       struct fd_info *fdi;
+@@ -353,7 +370,7 @@ static int transpose_socket(int socket, enum fd_type new_type)
+       if (ret)
+               goto err;
+ 
+-      fd_store(socket, dfd, new_type);
++      fd_store(socket, dfd, new_type, fd_ready);
+       return dfd;
+ 
+ err:
+@@ -398,9 +415,9 @@ int socket(int domain, int type, int protocol)
+                       ret = real.socket(domain, type, protocol);
+                       if (ret < 0)
+                               return ret;
+-                      fd_store(index, ret, fd_fork);
++                      fd_store(index, ret, fd_normal, fd_fork);
+               } else {
+-                      fd_store(index, ret, fd_rsocket);
++                      fd_store(index, ret, fd_rsocket, fd_ready);
+                       set_rsocket_options(ret);
+               }
+               return index;
+@@ -427,22 +444,32 @@ int listen(int socket, int backlog)
+ int accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
+ {
+       int fd, index, ret;
+-      enum fd_type type;
+ 
+-      type = fd_get(socket, &fd);
+-      if (type == fd_rsocket || type == fd_fork) {
++      if (fd_get(socket, &fd) == fd_rsocket) {
++              index = fd_open();
++              if (index < 0)
++                      return index;
++
++              ret = raccept(fd, addr, addrlen);
++              if (ret < 0) {
++                      fd_close(index, &fd);
++                      return ret;
++              }
++
++              fd_store(index, ret, fd_rsocket, fd_ready);
++              return index;
++      } else if (fd_gets(socket) == fd_fork_listen) {
+               index = fd_open();
+               if (index < 0)
+                       return index;
+ 
+-              ret = (type == fd_rsocket) ? raccept(fd, addr, addrlen) :
+-                                           real.accept(fd, addr, addrlen);
++              ret = real.accept(fd, addr, addrlen);
+               if (ret < 0) {
+                       fd_close(index, &fd);
+                       return ret;
+               }
+ 
+-              fd_store(index, ret, type);
++              fd_store(index, ret, fd_normal, fd_fork_passive);
+               return index;
+       } else {
+               return real.accept(fd, addr, addrlen);
+@@ -471,7 +498,7 @@ static int fork_active(int socket, const struct sockaddr *addr, socklen_t addrle
+ 
+       ret = real.recv(fd, &msg, sizeof msg, MSG_PEEK);
+       if ((ret != sizeof msg) || msg) {
+-              fd_store(socket, fd, fd_normal);
++              fd_store(socket, fd, fd_normal, fd_ready);
+               return 0;
+       }
+ 
+@@ -544,7 +571,7 @@ static void fork_passive(int socket)
+       copysockopts(dfd, sfd, &rs, &real);
+       real.shutdown(sfd, SHUT_RDWR);
+       real.close(sfd);
+-      fd_store(socket, dfd, fd_rsocket);
++      fd_store(socket, dfd, fd_rsocket, fd_ready);
+ 
+ lclose:
+       rclose(lfd);
+@@ -553,7 +580,7 @@ sclose:
+       sem_close(sem);
+ out:
+       if (ret)
+-              fd_store(socket, sfd, fd_normal);
++              fd_store(socket, sfd, fd_normal, fd_ready);
+ }
+ 
+ static inline enum fd_type fd_fork_get(int index, int *fd)
+@@ -577,10 +604,7 @@ int connect(int socket, const struct sockaddr *addr, socklen_t addrlen)
+ {
+       int fd, ret;
+ 
+-      switch (fd_get(socket, &fd)) {
+-      case fd_fork:
+-              return fork_active(socket, addr, addrlen);
+-      case fd_rsocket:
++      if (fd_get(socket, &fd) == fd_rsocket) {
+               ret = rconnect(fd, addr, addrlen);
+               if (!ret || errno == EINPROGRESS)
+                       return ret;
+@@ -591,12 +615,9 @@ int connect(int socket, const struct sockaddr *addr, socklen_t addrlen)
+ 
+               rclose(fd);
+               fd = ret;
+-              break;
+-      default:
+-              break;
++      } else {
++              return real.connect(fd, addr, addrlen);
+       }
+-
+-      return real.connect(fd, addr, addrlen);
+ }
+ 
+ ssize_t recv(int socket, void *buf, size_t len, int flags)