root/nosyscallsreal.c

DEFINITIONS

1. _dmtcp_lock
2. _dmtcp_unlock
3. initialize_wrappers
4. _real_pthread_mutex_lock
5. _real_pthread_mutex_trylock
6. _real_pthread_mutex_unlock
7. _real_pthread_rwlock_unlock
8. _real_pthread_rwlock_rdlock
9. _real_pthread_rwlock_wrlock
10. _real_read
11. _real_write
12. _real_select
13. _real_socket
14. _real_connect
15. _real_bind
16. _real_listen
17. _real_accept
18. _real_setsockopt
19. _real_getsockopt
20. _real_execve
21. _real_execv
22. _real_execvp
23. _real_system
24. _real_fork
25. _real_close
26. _real_fclose
27. _real_dup
28. _real_dup2
29. _real_exit
30. _real_fcntl
31. _real_ptsname_r
32. _real_socketpair
33. _real_openlog
34. _real_closelog
35. _dmtcp_unsetenv
36. _real_lseek
37. _real_getpid
38. _real_getppid
39. _real_tcsetpgrp
40. _real_tcgetpgrp
41. _real_getpgrp
42. _real_setpgrp
43. _real_getpgid
44. _real_setpgid
45. _real_getsid
46. _real_setsid
47. _real_kill
48. _real_wait
49. _real_waitpid
50. _real_waitid
51. _real_wait3
52. _real_wait4
53. _real_ioctl
54. _real_mmap
55. _real_munmap
56. _real_syscall
57. dmtcp_gettid
58. dmtcp_tkill
59. dmtcp_tgkill
60. _real_open
61. _real_open64
62. _real_fopen
63. _real_fopen64
64. _real_shmget
65. _real_shmat
66. _real_shmdt
67. _real_shmctl
68. _real_poll
69. _real_readlink
70. _dmtcp_setup_trampolines

   1 /****************************************************************************
   2  *   Copyright (C) 2006-2010 by Jason Ansel, Kapil Arya, and Gene Cooperman *
   3  *   jansel@csail.mit.edu, kapil@ccs.neu.edu, gene@ccs.neu.edu              *
   4  *                                                                          *
   5  *  This file is part of DMTCP.                                             *
   6  *                                                                          *
   7  *  DMTCP is free software: you can redistribute it and/or                  *
   8  *  modify it under the terms of the GNU Lesser General Public License as   *
   9  *  published by the Free Software Foundation, either version 3 of the      *
  10  *  License, or (at your option) any later version.                         *
  11  *                                                                          *
  12  *  DMTCP is distributed in the hope that it will be useful,                *
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  15  *  GNU Lesser General Public License for more details.                     *
  16  *                                                                          *
  17  *  You should have received a copy of the GNU Lesser General Public        *
  18  *  License along with DMTCP:dmtcp/src.  If not, see                        *
  19  *  <http://www.gnu.org/licenses/>.                                         *
  20  ****************************************************************************/
  23 #define _GNU_SOURCE
  24 #define _XOPEN_SOURCE 500
  25 // These next two are defined in features.h based on the user macros above.
  26 // #define GNU_SRC
  27 // #define __USE_UNIX98
  29 #include <pthread.h>
  30 // We should not need dlopen/dlsym
  31 // #include <dlfcn.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <sys/select.h>
  36 #include <sys/time.h>
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <fcntl.h>
  40 #include <sys/syscall.h>
  41 #include <sys/ioctl.h>
  42 #include <unistd.h>
  43 #include <ctype.h>
  44 #include <syslog.h>
  45 #include "constants.h"
  46 #include "syscallwrappers.h"
  48 // See syscallsreal.c for original model.  In libdmtcp.so, system calls
  49 //   for XXX() in jalib call a wrapper which modifies it and calls
  50 //   syscallsreal.c:_real_XXX(), to directly calls kernel.
  51 // For other functions (dmtcp_launch, dmtcp_restart, etc.),
  52 //   we want their invocations of jalib to directly call glibc with no wrappers.
  53 // Jalib has some calls to real_XXX() to avoid going through the wrapper.
  54 //   Those are defined in syscallsreal.cpp, but this is a simpler interface
  55 //   that avoids calling on dlsym() and syscallsreal.cpp (by calling this
  56 //   smaller image, jnosyscallsreal.cpp), in order to keep those
  57 //   binaries smaller, and to keep the code simpler and more maintainable.
  58 //   Can add wrapper code for libhijack.so without fear of contaminating
  59 //   the other DMTCP executables with that wrapper.
  61 // NOTE:  An alternative to this strategy would be to put this in a file,
  62 //   nosyscallwrappers.h and #define away the real_XXX() calls.
  63 //   But some files like uniquepid.cpp and connection.cpp could be
  64 //   linked either to libdmtcp.so or to dmtcp_restart.
  66 /// FIXME:  dmtcpworker.cpp is linked into some ordinary executables.
  67 ///         It should be modified to avoid this, so we don't need gratuitous
  68 ///         extra reall_syscalls here like dmtcp_unsetenv(), dmtcp_lock()
  70 //////////////////////////
  71 //// DEFINE REAL VERSIONS OF NEEDED FUNCTIONS (based on syscallsreal.cpp)
  72 //// (Define only functions needed for dmtcp_launch, dmtcp_restart, etc.
  74 static pthread_mutex_t theMutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
  76 #define REAL_FUNC_PASSTHROUGH(name) return name
  78 #define REAL_FUNC_PASSTHROUGH_TYPED(type, name) REAL_FUNC_PASSTHROUGH(name)
  79 #define REAL_FUNC_PASSTHROUGH_TYPED_DLSYM(type, name) return dlsym(RTLD_NEXT, #name)
  81 #define REAL_FUNC_PASSTHROUGH_PID_T(name) REAL_FUNC_PASSTHROUGH(name)
  83 // No return statement for functions returning void:
  84 #define REAL_FUNC_PASSTHROUGH_VOID(name) name
  86 #define SYMBOL_NOT_FOUND_ERROR(name) \
fprintf(stderr, "ERROR: DMTCP internal error.\n" \
  88                   "  Symbol %s not found!\n", #name); \
abort(); \
  90   return -1;
  92 void _dmtcp_lock() { pthread_mutex_lock (&theMutex); }
  93 void _dmtcp_unlock() { pthread_mutex_unlock (&theMutex); }
  95 void initialize_wrappers() {
  96   return;
  97 }
  99 int _real_pthread_mutex_lock(pthread_mutex_t *mutex) {
REAL_FUNC_PASSTHROUGH_TYPED (int,pthread_mutex_lock) (mutex);
 101 }
 103 int _real_pthread_mutex_trylock(pthread_mutex_t *mutex) {
REAL_FUNC_PASSTHROUGH_TYPED (int,pthread_mutex_trylock) (mutex);
 105 }
 107 int _real_pthread_mutex_unlock(pthread_mutex_t *mutex) {
REAL_FUNC_PASSTHROUGH_TYPED (int,pthread_mutex_unlock) (mutex);
 109 }
 111 int _real_pthread_rwlock_unlock(pthread_rwlock_t *rwlock) {
REAL_FUNC_PASSTHROUGH_TYPED (int,pthread_rwlock_unlock) (rwlock);
 113 }
 115 int _real_pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) {
REAL_FUNC_PASSTHROUGH_TYPED (int,pthread_rwlock_rdlock) (rwlock);
 117 }
 119 int _real_pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) {
REAL_FUNC_PASSTHROUGH_TYPED (int,pthread_rwlock_wrlock) (rwlock);
 121 }
ssize_t _real_read(int fd, void *buf, size_t count) {
REAL_FUNC_PASSTHROUGH (read) (fd,buf,count);
 125 }
ssize_t _real_write(int fd, const void *buf, size_t count) {
REAL_FUNC_PASSTHROUGH_TYPED (ssize_t,write) (fd,buf,count);
 129 }
 131 int _real_select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout) {
REAL_FUNC_PASSTHROUGH (select) (nfds,readfds,writefds,exceptfds,timeout);
 134 }
 136 /// call the libc version of this function via dlopen/dlsym
 137 int _real_socket (int domain, int type, int protocol)
 138 {
REAL_FUNC_PASSTHROUGH (socket) (domain,type,protocol);
 140 }
 142 /// call the libc version of this function via dlopen/dlsym
 143 int _real_connect (int sockfd,  const  struct sockaddr *serv_addr, socklen_t addrlen)
 144 {
REAL_FUNC_PASSTHROUGH (connect) (sockfd,serv_addr,addrlen);
 146 }
 148 /// call the libc version of this function via dlopen/dlsym
 149 int _real_bind (int sockfd,  const struct  sockaddr  *my_addr,  socklen_t addrlen)
 150 {
REAL_FUNC_PASSTHROUGH (bind) (sockfd,my_addr,addrlen);
 152 }
 154 /// call the libc version of this function via dlopen/dlsym
 155 int _real_listen (int sockfd, int backlog)
 156 {
REAL_FUNC_PASSTHROUGH (listen) (sockfd,backlog);
 158 }
 160 /// call the libc version of this function via dlopen/dlsym
 161 int _real_accept (int sockfd, struct sockaddr *addr, socklen_t *addrlen)
 162 {
REAL_FUNC_PASSTHROUGH (accept) (sockfd,addr,addrlen);
 164 }
 166 /// call the libc version of this function via dlopen/dlsym
 167 int _real_setsockopt (int s, int  level,  int  optname,  const  void  *optval,
socklen_t optlen)
 169 {
REAL_FUNC_PASSTHROUGH (setsockopt) (s,level,optname,optval,optlen);
 171 }
 173 int _real_getsockopt (int s, int  level,  int  optname,  void  *optval,
socklen_t* optlen)
 175 {
REAL_FUNC_PASSTHROUGH (getsockopt) (s,level,optname,optval,optlen);
 177 }
 179 int _real_execve (const char *filename, char *const argv[],
 180                    char *const envp[])
 181 {
REAL_FUNC_PASSTHROUGH (execve) (filename,argv,envp);
 183 }
 185 int _real_execv (const char *path, char *const argv[])
 186 {
REAL_FUNC_PASSTHROUGH (execv) (path,argv);
 188 }
 190 int _real_execvp (const char *file, char *const argv[])
 191 {
REAL_FUNC_PASSTHROUGH (execvp) (file,argv);
 193 }
 195 int _real_system (const char *cmd)
 196 {
REAL_FUNC_PASSTHROUGH (system) (cmd);
 198 }
pid_t _real_fork(void)
 201 {
REAL_FUNC_PASSTHROUGH_PID_T (fork) ();
 203 }
 205 int _real_close (int fd)
 206 {
REAL_FUNC_PASSTHROUGH (close) (fd);
 208 }
 210 int _real_fclose (FILE *fp)
 211 {
REAL_FUNC_PASSTHROUGH (fclose) (fp);
 213 }
 215 int _real_dup (int oldfd)
 216 {
REAL_FUNC_PASSTHROUGH (dup) (oldfd);
 218 }
 220 int _real_dup2 (int oldfd, int newfd)
 221 {
REAL_FUNC_PASSTHROUGH (dup2) (oldfd, newfd);
 223 }
 225 //int _real_dup3 (int oldfd, int newfd, int flags)
 226 //{
 227 //  REAL_FUNC_PASSTHROUGH (dup3) (oldfd, newfd, flags);
 228 //}
 230 void _real_exit (int status)
 231 {
REAL_FUNC_PASSTHROUGH_VOID (exit) (status);
 233 }
LIB_PRIVATE
 236 int _real_fcntl(int fd, int cmd, void *arg)
 237 {
REAL_FUNC_PASSTHROUGH (fcntl) (fd, cmd, arg);
 239 }
 241 int _real_ptsname_r (int fd, char * buf, size_t buflen)
 242 {
REAL_FUNC_PASSTHROUGH (ptsname_r) (fd, buf, buflen);
 244 }
 246 int _real_socketpair (int d, int type, int protocol, int sv[2])
 247 {
REAL_FUNC_PASSTHROUGH (socketpair) (d,type,protocol,sv);
 249 }
 251 void _real_openlog (const char *ident, int option, int facility)
 252 {
REAL_FUNC_PASSTHROUGH_VOID (openlog) (ident,option,facility);
 254 }
 256 void _real_closelog (void)
 257 {
REAL_FUNC_PASSTHROUGH_VOID (closelog) ();
 259 }
 261 int _dmtcp_unsetenv(const char *name) {
REAL_FUNC_PASSTHROUGH (unsetenv) (name);
 263 }
off_t _real_lseek(int fd, off_t offset, int whence) {
REAL_FUNC_PASSTHROUGH_TYPED (off_t,lseek) (fd,offset,whence);
 267 }
pid_t _real_getpid(void) {
REAL_FUNC_PASSTHROUGH_PID_T (getpid) ();
 271 }
pid_t _real_getppid(void) {
REAL_FUNC_PASSTHROUGH_PID_T (getppid) ();
 275 }
 277 int _real_tcsetpgrp(int fd, pid_t pgrp) {
REAL_FUNC_PASSTHROUGH (tcsetpgrp) (fd, pgrp);
 279 }
 281 int _real_tcgetpgrp(int fd) {
REAL_FUNC_PASSTHROUGH (tcgetpgrp) (fd);
 283 }
pid_t _real_getpgrp(void) {
REAL_FUNC_PASSTHROUGH_PID_T (getpgrp) ();
 287 }
pid_t _real_setpgrp(void) {
REAL_FUNC_PASSTHROUGH_PID_T (setpgrp) ();
 291 }
pid_t _real_getpgid(pid_t pid) {
REAL_FUNC_PASSTHROUGH_PID_T (getpgid) (pid);
 295 }
 297 int   _real_setpgid(pid_t pid, pid_t pgid) {
REAL_FUNC_PASSTHROUGH (setpgid) (pid, pgid);
 299 }
pid_t _real_getsid(pid_t pid) {
REAL_FUNC_PASSTHROUGH_PID_T (getsid) (pid);
 303 }
pid_t _real_setsid(void) {
REAL_FUNC_PASSTHROUGH_PID_T (setsid) ();
 307 }
 309 int   _real_kill(pid_t pid, int sig) {
REAL_FUNC_PASSTHROUGH (kill) (pid, sig);
 311 }
pid_t _real_wait(__WAIT_STATUS stat_loc) {
REAL_FUNC_PASSTHROUGH_PID_T (wait) (stat_loc);
 315 }
pid_t _real_waitpid(pid_t pid, int *stat_loc, int options) {
REAL_FUNC_PASSTHROUGH_PID_T (waitpid) (pid, stat_loc, options);
 319 }
 321 int   _real_waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options) {
REAL_FUNC_PASSTHROUGH (waitid) (idtype, id, infop, options);
 323 }
pid_t _real_wait3(__WAIT_STATUS status, int options, struct rusage *rusage) {
REAL_FUNC_PASSTHROUGH_PID_T (wait3) (status, options, rusage);
 327 }
pid_t _real_wait4(pid_t pid, __WAIT_STATUS status, int options, struct rusage *rusage) {
REAL_FUNC_PASSTHROUGH_PID_T (wait4) (pid, status, options, rusage);
 331 }
 333 int send_sigwinch; /* not used.  Only version in pidwrappers.cpp is used */
 334 int _real_ioctl(int d, unsigned long int request, ...) {
 335   void * arg;
va_list ap;
 338   // Most calls to ioctl take 'void *', 'int' or no extra argument
 339   // A few specialized ones take more args, but we don't need to handle those.
va_start(ap, request);
arg = va_arg(ap, void *);
va_end(ap);
 344   // /usr/include/unistd.h says syscall returns long int (contrary to man page)
REAL_FUNC_PASSTHROUGH_TYPED (int, ioctl) (d, request, arg);
 346 }
LIB_PRIVATE
 349 void *_real_mmap(void *addr, size_t length, int prot, int flags,
 350     int fd, off_t offset) {
REAL_FUNC_PASSTHROUGH_TYPED (void*, mmap) (addr,length,prot,flags,fd,offset);
 352 }
LIB_PRIVATE
 355 int _real_munmap(void *addr, size_t length) {
REAL_FUNC_PASSTHROUGH_TYPED (int, munmap) (addr, length);
 357 }
 360 // Needed for _real_gettid, etc.
 361 long _real_syscall(long sys_num, ...) {
 362   int i;
 363   void * arg[7];
va_list ap;
va_start(ap, sys_num);
 367   for (i = 0; i < 7; i++)
arg[i] = va_arg(ap, void *);
va_end(ap);
 371   // /usr/include/unistd.h says syscall returns long int (contrary to man page)
REAL_FUNC_PASSTHROUGH_TYPED (long, syscall) (sys_num, arg[0],
arg[1], arg[2],
arg[3], arg[4],
arg[5], arg[6]);
 376 }
LIB_PRIVATE pid_t dmtcp_gettid() {
 379   return syscall(SYS_gettid);
 380 }
LIB_PRIVATE int dmtcp_tkill(int tid, int sig) {
 382   return syscall(SYS_tkill, tid, sig);
 383 }
LIB_PRIVATE int dmtcp_tgkill(int tgid, int tid, int sig) {
 385   return syscall(SYS_tgkill, tgid, tid, sig);
 386 }
 388 int _real_open (const char *pathname, int flags, ...) {
mode_t mode = 0;
 390   // Handling the variable number of arguments
 391   if (flags & O_CREAT) {
va_list arg;
va_start (arg, flags);
mode = va_arg (arg, int);
va_end (arg);
 396   }
REAL_FUNC_PASSTHROUGH (open) (pathname, flags, mode);
 398 }
 400 int _real_open64 (const char *pathname, int flags, ...) {
mode_t mode = 0;
 402   // Handling the variable number of arguments
 403   if (flags & O_CREAT) {
va_list arg;
va_start (arg, flags);
mode = va_arg (arg, int);
va_end (arg);
 408   }
REAL_FUNC_PASSTHROUGH (open) (pathname, flags, mode);
 410 }
FILE * _real_fopen(const char *path, const char *mode) {
REAL_FUNC_PASSTHROUGH_TYPED (FILE *, fopen) (path, mode);
 414 }
FILE * _real_fopen64(const char *path, const char *mode) {
REAL_FUNC_PASSTHROUGH_TYPED (FILE *, fopen64) (path, mode);
 418 }
 420 int _real_shmget (key_t key, size_t size, int shmflg) {
REAL_FUNC_PASSTHROUGH (shmget) (key, size, shmflg);
 422 }
 424 void* _real_shmat (int shmid, const void *shmaddr, int shmflg) {
REAL_FUNC_PASSTHROUGH_TYPED (void*, shmat) (shmid, shmaddr, shmflg);
 426 }
 428 int _real_shmdt (const void *shmaddr) {
REAL_FUNC_PASSTHROUGH (shmdt) (shmaddr);
 430 }
 432 int _real_shmctl (int shmid, int cmd, struct shmid_ds *buf) {
REAL_FUNC_PASSTHROUGH (shmctl) (shmid, cmd, buf);
 434 }
LIB_PRIVATE
 437 int _real_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
REAL_FUNC_PASSTHROUGH (poll) (fds, nfds, timeout);
 439 }
ssize_t _real_readlink(const char *path, char *buf, size_t bufsiz) {
REAL_FUNC_PASSTHROUGH_TYPED (ssize_t, readlink) (path, buf, bufsiz);
 443 }
 445 // Used for wrappers for mmap, sbrk
 446 void _dmtcp_setup_trampolines() {}