/*
* lgetxattr
*/
int
lgetxattr(const char *path, const char *name, void *value, size_t size)
{
char *e, *gfarm_file;
char *url;
_gfs_hook_debug_v(fprintf(stderr,
"Hooking lgetxattr(%s, %s, %p, %lu)\n",
path, name, value, (unsigned long)size));
if (!gfs_hook_is_url(path, &url))
#ifdef SYS_lgetxattr
return syscall(SYS_lgetxattr, path, name, value, size);
#else
{
errno = ENODATA;
return (-1);
}
#endif
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking lgetxattr(%s, %s, %p, %lu)\n",
path, name, value, (unsigned long)size));
e = gfarm_url_make_path(url, &gfarm_file);
free(url);
if (e == NULL) {
e = GFARM_ERR_OPERATION_NOT_SUPPORTED;
free(gfarm_file);
}
_gfs_hook_debug(fprintf(stderr, "GFS: lgetxattr: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__chdir(const char *path)
{
const char *e;
char *url, *sec;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __chdir(%s)\n", path));
gfs_hook_cwd_is_gfarm = gfs_hook_is_url(path, &url, &sec);
if (!gfs_hook_cwd_is_gfarm)
return syscall(SYS_chdir, path);
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __chdir(%s)\n", path));
e = gfs_chdir(url);
free(url);
if (sec != NULL)
free(sec);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __chdir: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__chdir(const char *path)
{
const char *e;
char *url;
int r;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __chdir(%s)\n", path));
if (!gfs_hook_is_url(path, &url)) {
if ((r = syscall(SYS_chdir, path)) == 0)
gfs_hook_set_cwd_is_gfarm(0);
return (r);
}
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __chdir(%s)\n", path));
e = gfs_chdir(url);
free(url);
if (e == NULL) {
gfs_hook_set_cwd_is_gfarm(1);
return (0);
}
_gfs_hook_debug(fprintf(stderr, "GFS: __chdir: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__link(const char *oldpath, const char *newpath)
{
const char *e;
char *url;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __link(%s, %s)\n",
oldpath, newpath));
if (!gfs_hook_is_url(newpath, &url))
return (syscall(SYS_link, oldpath, newpath));
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __link(%s, %s)\n",
oldpath, newpath));
/*
* Gfarm file system does not support the creation of
* hard link yet.
*/
e = GFARM_ERR_OPERATION_NOT_PERMITTED; /* EPERM */
free(url);
_gfs_hook_debug(fprintf(stderr, "GFS: __link: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__utime(const char *path, const struct utimbuf *buf)
{
char *e, *url;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __utime(%s, %p)\n",
path, buf));
if (!gfs_hook_is_url(path, &url))
return syscall(SYS_utime, path, buf);
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __utime(%s)\n", url));
if (buf == NULL)
e = gfs_utimes(url, NULL);
else {
struct gfarm_timespec gt[2];
gt[0].tv_sec = buf->actime;
gt[0].tv_nsec= 0;
gt[1].tv_sec = buf->modtime;
gt[1].tv_nsec= 0;
e = gfs_utimes(url, gt);
}
free(url);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __utime: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__lchown(const char *path, uid_t owner, gid_t group)
{
const char *e;
char *url;
struct gfs_stat s;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __lchown(%s, %d, %d)\n",
path, uid, group));
if (!gfs_hook_is_url(path, &url))
return (__syscall_lchown(path, owner, group));
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __lchown(%s, %d, %d)\n",
path, owner, group));
/* XXX - gfs_lstat is not supported */
e = gfs_stat(url, &s);
free(url);
if (e == NULL) {
if (strcmp(s.st_user, gfarm_get_global_username()) != 0)
e = GFARM_ERR_OPERATION_NOT_PERMITTED; /* EPERM */
/* XXX - do nothing */
gfs_stat_free(&s);
}
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __lchown: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__rename(const char *oldpath, const char *newpath)
{
const char *e;
char *oldurl, *newurl;
int old_is_url, new_is_url;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __rename(%s, %s)\n",
oldpath, newpath));
old_is_url = gfs_hook_is_url(oldpath, &oldurl);
new_is_url = gfs_hook_is_url(newpath, &newurl);
if (!old_is_url || !new_is_url) {
if (old_is_url)
free(oldurl);
if (new_is_url)
free(newurl);
if (old_is_url != new_is_url) {
errno = EXDEV;
return (-1);
}
return (syscall(SYS_rename, oldpath, newpath));
}
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __rename(%s, %s)\n",
oldpath, newpath));
e = gfs_rename(oldurl, newurl);
free(oldurl);
free(newurl);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __rename: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__utimes(const char *path, const struct timeval *tvp)
{
char *e, *url, *sec;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __utimes(%s, %p)\n",
path, tvp));
if (!gfs_hook_is_url(path, &url, &sec)) {
#ifdef __linux__
if (tvp == NULL) {
return syscall(SYS_utime, path, NULL);
} else {
struct utimbuf ut;
ut.actime = tvp[0].tv_sec;
ut.modtime = tvp[1].tv_sec;
return syscall(SYS_utime, path, &ut);
}
#else
return syscall(SYS_utimes, path, tvp);
#endif
}
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __utimes(%s)\n", url));
if (tvp == NULL)
e = gfs_utimes(url, NULL);
else {
struct gfarm_timespec gt[2];
gt[0].tv_sec = tvp[0].tv_sec;
gt[0].tv_nsec= tvp[0].tv_usec * 1000;
gt[1].tv_sec = tvp[1].tv_sec;
gt[1].tv_nsec= tvp[1].tv_usec * 1000;
e = gfs_utimes(url, gt);
}
free(url);
if (sec != NULL)
free(sec);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __utimes: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__execve(const char *filename, char *const argv [], char *const envp[])
{
char *url, *e;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __execve(%s)\n", filename));
if (!gfs_hook_is_url(filename, &url))
return syscall(SYS_execve, filename, argv, envp);
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __execve(%s)\n", url));
e = gfs_execve(url, argv, envp);
free(url);
_gfs_hook_debug(fprintf(stderr, "GFS: __execve: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__unlink(const char *path)
{
const char *e;
char *url;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __unlink(%s)\n", path));
if (!gfs_hook_is_url(path, &url))
return syscall(SYS_unlink, path);
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __unlink(%s)\n", path));
e = gfs_unlink(url);
free(url);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __unlink: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__access(const char *path, int type)
{
char *e, *url;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __access(%s, %d)\n",
path, type));
if (!gfs_hook_is_url(path, &url))
return syscall(SYS_access, path, type);
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __access(%s, %d)\n",
path, type));
e = gfs_access(url, type);
free(url);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __access: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
__chmod(const char *path, mode_t mode)
{
const char *e;
char *url;
_gfs_hook_debug_v(fprintf(stderr, "Hooking __chmod(%s, 0%o)\n",
path, mode));
if (!gfs_hook_is_url(path, &url))
return syscall(SYS_chmod, path, mode);
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __chmod(%s, 0%o)\n",
path, mode));
e = gfs_chmod(url, mode);
free(url);
if (e == NULL)
return (0);
_gfs_hook_debug(fprintf(stderr, "GFS: __chmod: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
FUNC___OPEN(const char *path, int oflag, ...)
{
GFS_File gf;
const char *e;
char *url, *sec;
va_list ap;
mode_t mode;
int filedes;
va_start(ap, oflag);
mode = va_arg(ap, mode_t);
va_end(ap);
_gfs_hook_debug_v(fprintf(stderr,
"Hooking " S(FUNC___OPEN) "(%s, 0x%x)\n", path, oflag));
if (!gfs_hook_is_url(path, &url, &sec))
return (SYSCALL_OPEN(path, oflag, mode));
/* XXX - ROOT I/O creates a new file with O_CREAT|O_RDWR mode. */
/* XXX - FIXME */
if ((oflag & O_CREAT) != 0 || (oflag & O_TRUNC) != 0) {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s:%s, 0x%x, 0%o)\n",
url, sec != NULL ? sec : "(null)", oflag, mode));
if (oflag & O_TRUNC) {
/*
* Hooking open syscall does not mean to open
* an entire file but a file fragment in local and
* index file views. gfs_unlink() should not be
* called in both views.
*/
if (_gfs_hook_default_view == global_view)
gfs_unlink(url); /* XXX - FIXME */
e = gfs_pio_create(url, oflag, mode, &gf);
} else {
e = gfs_pio_open(url, oflag, &gf);
if (e == GFARM_ERR_NO_SUCH_OBJECT) /* XXX - FIXME */
e = gfs_pio_create(url, oflag, mode, &gf);
}
} else {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s:%s, 0x%x)\n",
url, sec != NULL ? sec : "(null)", oflag));
e = gfs_pio_open(url, oflag, &gf);
}
free(url);
if (e != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) ": %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
if (sec != NULL || _gfs_hook_default_view == index_view) {
if (sec != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_section(%s, %s)\n", url, sec));
e = gfs_pio_set_view_section(gf, sec, NULL, 0);
free(sec);
} else {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_index(%s, %d, %d)\n", url,
_gfs_hook_num_fragments, _gfs_hook_index));
e = gfs_pio_set_view_index(gf, _gfs_hook_num_fragments,
_gfs_hook_index, NULL, 0);
}
if (e != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_section: %s\n", e));
gfs_pio_close(gf);
errno = gfarm_error_to_errno(e);
return (-1);
}
} else if (_gfs_hook_default_view == local_view) {
int nf = -1, np;
/*
* If the number of fragments is not the same as the
* number of parallel processes, or the file is not
* fragmented, do not change to the local file view.
*/
if (gfs_pio_get_nfragment(gf, &nf) ==
GFARM_ERR_FRAGMENT_INDEX_NOT_AVAILABLE ||
(gfs_pio_get_node_size(&np) == NULL && nf == np)) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_local(%s (%d, %d))\n",
url, gfarm_node, gfarm_nnode));
if ((e = gfs_pio_set_view_local(gf, 0)) != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_local: %s\n", e));
gfs_pio_close(gf);
errno = gfarm_error_to_errno(e);
return (-1);
}
}
}
filedes = gfs_hook_insert_gfs_file(gf);
_gfs_hook_debug(
if (filedes != -1) {
fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) " --> %d(%d)\n",
filedes, gfs_pio_fileno(gf));
}
);
int
__execve(const char *filename, char *const argv [], char *const envp[])
{
char *url, *e;
int status, r;
pid_t pid;
_gfs_hook_debug(fprintf(stderr, "Hooking __execve(%s)\n", filename));
if (!gfs_hook_is_url(filename, &url)) {
if (gfs_hook_num_gfs_files() > 0) {
_gfs_hook_debug(
fprintf(stderr, "GFS: __execve(%s) - fork : %d\n",
filename, gfs_hook_num_gfs_files()));
/* flush all of buffer */
gfs_hook_flush_all();
/* all files may be accessed by the child process */
gfs_hook_mode_calc_digest_all();
pid = fork();
}
else
pid = 0;
switch (pid) {
case -1:
_gfs_hook_debug(perror("GFS: fork"));
status = 255;
break;
case 0:
r = syscall(SYS_execve, filename, argv, envp);
if (gfs_hook_num_gfs_files() == 0)
return (r);
_gfs_hook_debug(perror(filename));
exit(255);
default:
while ((r = waitpid(pid, &status, 0)) == -1 &&
errno == EINTR);
if (r == -1) {
_gfs_hook_debug(perror("GFS: waitpid"));
status = 255;
}
else if (WIFEXITED(status)) {
switch (WEXITSTATUS(status)) {
case 255:
/* child process fails in execve */
_gfs_hook_debug(
fprintf(stderr, "%s(%d): %s\n",
"GFS: waitpid", pid, "status 255"));
/* XXX - need to obtain from child */
errno = ENOENT;
return (-1);
default:
status = WEXITSTATUS(status);
break;
}
}
else if (WIFSIGNALED(status)) {
_gfs_hook_debug(
fprintf(stderr,
"%s(%d): signal %d received%s.\n",
"GFS: waitpid", pid, WTERMSIG(status),
WCOREDUMP(status) ? " (core dumped)" : ""));
/* propagate the signal */
raise(WTERMSIG(status));
status = 255;
}
break;
}
e = gfs_hook_close_all();
if (e != NULL)
_gfs_hook_debug(fprintf(stderr, "close_all: %s\n", e));
exit(status);
}
_gfs_hook_debug(fprintf(stderr, "GFS: Hooking __execve(%s)\n", url));
e = gfs_execve(url, argv, envp);
free(url);
_gfs_hook_debug(fprintf(stderr, "GFS: __execve: %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
FUNC___XSTAT(int ver, const char *path, STRUCT_STAT *buf)
{
const char *e;
char *url;
struct gfs_stat gs;
int nf = -1, np, errno_save = errno;
_gfs_hook_debug_v(gflog_info(GFARM_MSG_UNFIXED,
"Hooking " S(FUNC___XSTAT) "(%s)",
path));
if (!gfs_hook_is_url(path, &url))
return (SYSCALL_XSTAT(ver, path, buf));
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: Hooking " S(FUNC___XSTAT) "(%s)", path));
switch (gfs_hook_get_current_view()) {
case section_view:
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(GFS_STAT_SECTION) "(%s, %s)",
url, gfs_hook_get_current_section()));
e = GFS_STAT_SECTION(url, gfs_hook_get_current_section(), &gs);
break;
case index_view:
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(GFS_STAT_INDEX) "(%s, %d)",
url, gfs_hook_get_current_index()));
e = GFS_STAT_INDEX(url, gfs_hook_get_current_index(), &gs);
break;
case local_view:
/*
* If the number of fragments is not the same as the
* number of parallel processes, or the file is not
* fragmented, do not change to the local file view.
*/
if (gfarm_url_fragment_number(url, &nf) == NULL) {
if (gfs_pio_get_node_size(&np) == NULL && nf == np) {
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(GFS_STAT_INDEX) "(%s, %d)",
url, gfarm_node));
e = GFS_STAT_INDEX(url, gfarm_node, &gs);
}
else {
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(GFS_STAT) "(%s)", url));
e = GFS_STAT(url, &gs);
}
}
else {
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(GFS_STAT) "(%s)", url));
e = GFS_STAT(url, &gs);
}
break;
default:
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(GFS_STAT) "(%s)", url));
e = GFS_STAT(url, &gs);
}
free(url);
if (e == NULL) {
struct passwd *p;
memset(buf, 0, sizeof(*buf));
buf->st_dev = GFS_DEV;
buf->st_ino = gs.st_ino;
buf->st_mode = gs.st_mode;
buf->st_nlink = S_ISDIR(buf->st_mode) ? GFS_NLINK_DIR : 1;
/* XXX FIXME: need to convert gfarm global user to UNIX uid */
p = getpwnam(gfarm_get_local_username());
if (p != NULL) {
buf->st_uid = p->pw_uid;
buf->st_gid = p->pw_gid;
} else {
buf->st_uid = getuid(); /* XXX */
buf->st_gid = getgid(); /* XXX */
}
buf->st_size = gs.st_size;
buf->st_blksize = GFS_BLKSIZE;
buf->st_blocks = (gs.st_size + STAT_BLKSIZ - 1) / STAT_BLKSIZ;
buf->st_atime = gs.st_atimespec.tv_sec;
buf->st_mtime = gs.st_mtimespec.tv_sec;
buf->st_ctime = gs.st_ctimespec.tv_sec;
gfs_stat_free(&gs);
errno = errno_save;
return (0);
}
_gfs_hook_debug(gflog_info(GFARM_MSG_UNFIXED,
"GFS: " S(FUNC___XSTAT) ": %s", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
int
FUNC___OPEN(const char *path, int oflag, ...)
{
GFS_File gf;
const char *e;
char *url;
va_list ap;
mode_t mode;
int filedes;
struct gfs_stat gs;
int file_exist, file_size = 0, is_directory = 0;
int nf = -1, np;
va_start(ap, oflag);
mode = va_arg(ap, mode_t);
va_end(ap);
_gfs_hook_debug_v(fprintf(stderr,
"Hooking " S(FUNC___OPEN) "(%s, 0x%x)\n", path, oflag));
if (!gfs_hook_is_url(path, &url))
return (SYSCALL_OPEN(path, oflag, mode));
if (gfs_hook_get_current_view() == section_view)
e = gfs_stat_section(url, gfs_hook_get_current_section(), &gs);
else
e = gfs_stat(url, &gs);
if (e == GFARM_ERR_NO_SUCH_OBJECT)
file_exist = 0;
else if (e == NULL) {
file_exist = 1;
file_size = gs.st_size;
is_directory = GFARM_S_ISDIR(gs.st_mode);
gfs_stat_free(&gs);
}
else {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) ": gfs_stat: %s\n", e));
/* XXX - metadata may be incomplete. anyway, continue. */
file_exist = 1;
file_size = 0;
/* XXX - metadata of a directory should not be imcomplete */
is_directory = 0;
}
/*
* XXX - stopgap implementation of O_WRONLY/O_RDWR, O_CREAT,
* O_TRUNC flags
*/
if (!file_exist && (oflag & O_CREAT) != 0) {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s, 0x%x, 0%o)\n",
url, oflag, mode));
e = gfs_pio_create(url, oflag, mode, &gf);
if (e == NULL)
gfs_hook_add_creating_file(gf);
}
else if ((oflag & O_ACCMODE) == O_WRONLY
|| (oflag & O_ACCMODE) == O_RDWR) {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s, 0x%x, 0%o)\n",
url, oflag, mode));
if (file_exist && (file_size == 0 || (oflag & O_TRUNC) != 0)) {
/*
* XXX - O_TRUNC is basically supported in
* Gfarm v1 except in global file view.
* This case needs to be implemented in
* gfs_pio_set_view_global() in gfs_pio_global.c.
*/
if (gfs_hook_get_current_view() == global_view)
gfs_unlink(url); /* XXX - FIXME */
/*
* gfs_pio_create assumes GFARM_FILE_TRUNC.
* It is not necessary to set O_TRUNC explicitly.
*/
e = gfs_pio_create(url, oflag, mode, &gf);
if (e == NULL)
gfs_hook_add_creating_file(gf);
}
else if (file_exist) { /* read-write mode: not supported yet */
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN)
": unsupported flags 0%o\n", oflag));
free(url);
errno = ENOSYS;
return (-1);
}
else { /* no such file or directory */
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN)
": no such file or directory\n"));
free(url);
errno = ENOENT;
return (-1);
}
}
/* XXX - end of stopgap implementation */
else {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s, 0x%x)\n", url, oflag));
if (file_exist && is_directory) {
GFS_Dir dir;
e = gfs_opendir(url, &dir);
if (e == NULL) {
filedes = gfs_hook_insert_gfs_dir(dir, url);
_gfs_hook_debug(
if (filedes != -1) {
fprintf(stderr,
"GFS: Hooking "
S(FUNC___OPEN)
" --> %d\n", filedes);
}
);
free(url);
return (filedes);
}
int
FUNC___OPEN(const char *path, int oflag, ...)
{
GFS_File gf;
const char *e;
char *url;
va_list ap;
mode_t mode;
int filedes;
struct gfs_stat gs;
int is_directory, save_errno;
int nf = -1, np;
va_start(ap, oflag);
/*
* We need `int' instead of `mode_t' in va_arg() below, because
* sizeof(mode_t) < sizeof(int) on some platforms (e.g. FreeBSD),
* and gcc-3.4/gcc-4's builtin va_arg() warns the integer promotion.
* XXX this doesn't work, if sizeof(mode_t) > sizeof(int),
* but currently there isn't any such platform as far as we know.
*/
mode = va_arg(ap, int);
va_end(ap);
_gfs_hook_debug_v(gflog_info(
"Hooking " S(FUNC___OPEN) "(%s, 0%o)", path, oflag));
if (!gfs_hook_is_url(path, &url))
return (SYSCALL_OPEN(path, oflag, mode));
if (gfs_hook_get_current_view() == section_view)
e = gfs_stat_section(url, gfs_hook_get_current_section(), &gs);
else
e = gfs_stat(url, &gs);
if (e == NULL) {
is_directory = GFARM_S_ISDIR(gs.st_mode);
gfs_stat_free(&gs);
} else {
/* XXX - metadata may be incomplete. anyway, continue. */
/* XXX - metadata of a directory should not be imcomplete */
is_directory = 0;
if (e != GFARM_ERR_NO_SUCH_OBJECT)
_gfs_hook_debug(gflog_info(
"GFS: Hooking " S(FUNC___OPEN) ": gfs_stat: %s",
e));
}
if (is_directory) {
GFS_Dir dir;
_gfs_hook_debug(gflog_info(
"GFS: Hooking " S(FUNC___OPEN) "(%s, 0%o): dir",
url, oflag));
if ((oflag & (O_CREAT|O_TRUNC)) != 0 ||
(oflag & O_ACCMODE) != O_RDONLY) {
free(url);
errno = EISDIR;
return (-1);
}
e = gfs_opendir(url, &dir);
if (e == NULL) {
filedes = gfs_hook_insert_gfs_dir(dir, url);
save_errno = errno;
_gfs_hook_debug(
gflog_info("GFS: Hooking "
S(FUNC___OPEN) " --> %d", filedes);
);
free(url);
if (filedes == -1)
errno = save_errno;
return (filedes);
}
