extern "C" char *getcwd(char *buf, size_t size)
{
WRAPPER_HEADER(char *, getcwd, _real_getcwd, buf, size);
if (SYNC_IS_REPLAY) {
WRAPPER_REPLAY_START_TYPED(char*, getcwd);
if (retval != NULL) {
/* retval will be a pointer to whatever buffer was used. If the
user provided a NULL buffer, _real_getcwd allocated one on
RECORD, but the optional event handler allocated it on REPLAY
before we arrive here. Memory accurate replay allows us to
depend on 'retval' pointing to the allocated buffer by the
optional event handler. If the user provided a buffer, retval
points to it. */
WRAPPER_REPLAY_READ_FROM_READ_LOG(getcwd, retval, size);
}
WRAPPER_REPLAY_END(getcwd);
} else if (SYNC_IS_RECORD) {
dmtcp::ThreadInfo::setOptionalEvent();
retval = _real_getcwd(buf, size);
dmtcp::ThreadInfo::unsetOptionalEvent();
if (retval != NULL) {
/* retval will be a pointer to whatever buffer was used. If the
user provided a NULL buffer, _real_getcwd will allocate one
and retval points to it. If the user provided a buffer,
retval points to it. */
JASSERT(size > 0).Text("Unimplemented.");
WRAPPER_LOG_WRITE_INTO_READ_LOG(getcwd, retval, size);
}
WRAPPER_LOG_WRITE_ENTRY(getcwd);
}
return retval;
}
extern "C" int getgrgid_r(gid_t gid, struct group *grp,
char *buf, size_t buflen, struct group **result)
{
WRAPPER_HEADER(int, getgrgid_r, _real_getgrgid_r, gid, grp, buf, buflen, result);
if (SYNC_IS_REPLAY) {
WRAPPER_REPLAY_START(getgrgid_r);
if (retval == 0 &&
GET_FIELD(my_entry, getgrgid_r, ret_result) != NULL) {
*grp = GET_FIELD(my_entry, getgrgid_r, ret_grp);
WRAPPER_REPLAY_READ_FROM_READ_LOG(getgrgid_r, buf, buflen);
}
*result = GET_FIELD(my_entry, getgrgid_r, ret_result);
WRAPPER_REPLAY_END(getgrgid_r);
} else if (SYNC_IS_RECORD) {
isOptionalEvent = true;
retval = _real_getgrgid_r(gid, grp, buf, buflen, result);
isOptionalEvent = false;
if (retval == 0 && result != NULL) {
SET_FIELD2(my_entry, getgrgid_r, ret_grp, *grp);
WRAPPER_LOG_WRITE_INTO_READ_LOG(getgrgid_r, buf, buflen);
}
SET_FIELD2(my_entry, getgrgid_r, ret_result, *result);
WRAPPER_LOG_WRITE_ENTRY(my_entry);
}
return retval;
}
extern "C" int getpwuid_r(uid_t uid, struct passwd *pwd,
char *buf, size_t buflen, struct passwd **result)
{
WRAPPER_HEADER(int, getpwuid_r, _real_getpwuid_r, uid, pwd, buf, buflen, result);
if (SYNC_IS_REPLAY) {
WRAPPER_REPLAY_START(getpwuid_r);
if (retval == 0 &&
GET_FIELD(my_entry, getpwuid_r, ret_result) != NULL) {
*pwd = GET_FIELD(my_entry, getpwuid_r, ret_pwd);
WRAPPER_REPLAY_READ_FROM_READ_LOG(getpwuid_r, buf, buflen);
}
*result = GET_FIELD(my_entry, getpwuid_r, ret_result);
WRAPPER_REPLAY_END(getpwuid_r);
} else if (SYNC_IS_RECORD) {
isOptionalEvent = true;
retval = _real_getpwuid_r(uid, pwd, buf, buflen, result);
isOptionalEvent = false;
if (retval == 0 && result != NULL) {
SET_FIELD2(my_entry, getpwuid_r, ret_pwd, *pwd);
WRAPPER_LOG_WRITE_INTO_READ_LOG(getpwuid_r, buf, buflen);
}
SET_FIELD2(my_entry, getpwuid_r, ret_result, *result);
WRAPPER_LOG_WRITE_ENTRY(my_entry);
}
return retval;
}
/* mmap/mmap64
* TODO: Remove the PROT_WRITE flag on REPLAY phase if it was not part of
* original flags.
* FIXME: MAP_SHARED areas are restored as MAP_PRIVATE, check for correctness.
*/
extern "C" void *mmap(void *addr, size_t length, int prot, int flags,
int fd, off_t offset)
{
SET_IN_MMAP_WRAPPER();
MMAP_WRAPPER_HEADER(mmap, addr, length, prot, flags, fd, offset);
if (SYNC_IS_REPLAY) {
bool mmap_read_from_readlog = false;
MMAP_WRAPPER_REPLAY_START(mmap);
//JWARNING ( addr == NULL ).Text("Unimplemented to have non-null addr.");
addr = GET_COMMON(my_entry, retval);
if (retval != MAP_FAILED && fd != -1 &&
((flags & MAP_PRIVATE) != 0 || (flags & MAP_SHARED) != 0)) {
flags &= ~MAP_SHARED;
flags |= MAP_PRIVATE;
flags |= MAP_ANONYMOUS;
fd = -1;
offset = 0;
size_t page_size = sysconf(_SC_PAGESIZE);
size_t page_mask = ~(page_size - 1);
length = (length + page_size - 1) & page_mask ;
mmap_read_from_readlog = true;
}
flags |= MAP_FIXED;
retval = _real_mmap (addr, length, prot | PROT_WRITE, flags, fd, offset);
if (retval != GET_COMMON(my_entry, retval)) sleep(20);
JASSERT ( retval == GET_COMMON(my_entry, retval) ) (retval)
(GET_COMMON(my_entry, retval)) (JASSERT_ERRNO);
if (mmap_read_from_readlog) {
WRAPPER_REPLAY_READ_FROM_READ_LOG(mmap, retval, length);
}
MMAP_WRAPPER_REPLAY_END(mmap);
} else if (SYNC_IS_RECORD) {
_real_pthread_mutex_lock(&mmap_lock);
retval = _real_mmap (addr, length, prot, flags, fd, offset);
if (retval != MAP_FAILED && fd != -1 &&
((flags & MAP_PRIVATE) != 0 || (flags & MAP_SHARED) != 0)) {
WRAPPER_LOG_WRITE_INTO_READ_LOG(mmap, retval, length);
}
WRAPPER_LOG_WRITE_ENTRY(my_entry);
_real_pthread_mutex_unlock(&mmap_lock);
}
UNSET_IN_MMAP_WRAPPER();
return retval;
}
extern "C" int getaddrinfo(const char *node, const char *service,
const struct addrinfo *hints, struct addrinfo **res)
{
struct addrinfo_extended addrinfo_res[ADDRINFO_MAX_RES];
struct addrinfo *rp;
int numResults = 0;
WRAPPER_HEADER(int, getaddrinfo, _real_getaddrinfo, node, service, hints,
res);
if (SYNC_IS_REPLAY) {
WRAPPER_REPLAY_START(getaddrinfo);
if (retval == 0) {
*res = GET_FIELD(my_entry, getaddrinfo, ret_res);
numResults = GET_FIELD(my_entry, getaddrinfo, num_res);
WRAPPER_REPLAY_READ_FROM_READ_LOG(getaddrinfo, (void*) addrinfo_res,
(numResults *
sizeof (struct addrinfo_extended)));
for (int i = 0; i < numResults; i++) {
struct addrinfo_extended *ext_info = &addrinfo_res[i];
struct addrinfo *_addrinfo = &(addrinfo_res[i]._addrinfo);
struct sockaddr *_sockaddr = &(addrinfo_res[i]._sockaddr);
memcpy(ext_info->_addrinfo_p, _addrinfo, sizeof(struct addrinfo));
memcpy(_addrinfo->ai_addr, _sockaddr, _addrinfo->ai_addrlen);
if (_addrinfo->ai_canonname != NULL) {
strncpy(_addrinfo->ai_canonname, ext_info->canonname,
sizeof(ext_info->canonname));
}
}
}
WRAPPER_REPLAY_END(getaddrinfo);
} else if (SYNC_IS_RECORD) {
isOptionalEvent = true;
retval = _real_getaddrinfo(node, service, hints, res);
isOptionalEvent = false;
if (retval == 0) {
SET_FIELD2(my_entry, getaddrinfo, ret_res, *res);
for (rp = *res; rp != NULL; rp = rp->ai_next) {
JASSERT(numResults < ADDRINFO_MAX_RES);
struct addrinfo_extended *ext_info = &addrinfo_res[numResults];
struct addrinfo *_addrinfo = &(addrinfo_res[numResults]._addrinfo);
struct sockaddr *_sockaddr = &(addrinfo_res[numResults]._sockaddr);
ext_info->_addrinfo_p = rp;
memcpy(_addrinfo, rp, sizeof (struct addrinfo));
memcpy(_sockaddr, rp->ai_addr, rp->ai_addrlen);
if (rp->ai_canonname != NULL) {
strncpy(ext_info->canonname, rp->ai_canonname,
sizeof(ext_info->canonname));
}
numResults++;
}
WRAPPER_LOG_WRITE_INTO_READ_LOG(getaddrinfo, (void*) addrinfo_res,
(numResults *
sizeof (struct addrinfo_extended)));
}
SET_FIELD2(my_entry, getaddrinfo, num_res, numResults);
WRAPPER_LOG_WRITE_ENTRY(my_entry);
}
return retval;
}
