Is there fsync but with path parameter - c

Question

Is there linux system call similar to fsync but uses file path instead of file descriptor?
I modify file modification time using utime, the file is in USB, I need to make sure the time is flushed to usb after setting utime.

Answer 1

As far as I know there isn't.
To do so you need to
open() the file
call fsync() on the fd returned by 1.
close() the fd returned by 1.
open() the containing directory
call fsync() on the fd returned by 4.
close() the fd returned by 4.
As you are after updating the file's meta-data the steps 4 to 6 are necessary to get the directory's entries (which carry the file's meta data) to disk.
As per Throwback1986's comment please note that this is not working recursivly in any way.

Answer 2

Here is a snippet of code I lifted from some of my utility routines in a POSIX-like system. The code includes the synching helper function, as well as the recursive caller. It may not compile "out of the box" since it was from a specialized system, but it's close enough to get you on the right track.
static int sync_path(const char *path)
{
int fd = 0;
int ret = 0;
if (path == NULL)
{
printf("Invalid path (NULL)");
return -1;
}
fd = open(path, O_RDONLY);
if (fd < 0)
{
printf("Failed to open dir [%d:%s] (%s)",
errno, strerror(errno), path);
return errno;
}
ret = fsync(fd);
if (ret < 0)
{
printf("Failed to sync dir [%d:%s] (%s)",
errno, strerror(errno), path);
close(fd);
return errno;
}
ret = close(fd);
if (ret < 0)
{
printf("Failed to close dir [%d:%s] (%s)",
errno, strerror(errno), path);
return errno;
}
return 0;
}
int sync_tree(const char *path)
{
static size_t depth = 0;
struct dirent *entry = NULL;
DIR *dir = NULL;
const char *p = NULL;
int ret = 0;
if (path == NULL)
{
printf("Invalid path (NULL)");
return -1;
}
depth++;
if (depth > MAX_RECURSION_DEPTH)
{
printf("Recursion limit reached [%d]",
MAX_RECURSION_DEPTH);
return -1;
}
ret = chdir(path);
if (ret)
{
printf("Unable to chdir [%d:%s] (%s)",
errno, strerror(errno), path);
return errno;
}
// Operate on the current dir (after the chdir above)
dir = opendir("./");
if (dir == NULL)
{
printf("Unable to open dir [%d:%s] (%s)",
errno, strerror(errno), path);
return errno;
}
entry = readdir(dir);
while (entry && (ret == Success))
{
p = entry -> d_name;
if (!p)
{
break;
}
if (entry -> d_type != DT_DIR)
{
ret = sync_path(p);
}
else
{
// If not dir is not . or .., then process it (depth-first)
if (strnicmp(p, ".", 1) && strnicmp(p, "..", 2))
{
// Recursion here...
ret = sync_tree(p);
if (ret)
{
// Do nothing - any error message should already be handled
}
else
{
// Restore current dir
ret = chdir("../");
if (ret)
{
printf("Unable to chdir [%d:%s] (%s)",
errno, strerror(errno), "../");
}
else
{
// All is well...
}
}
}
}
if (ret == 0)
{
entry = readdir(dir);
}
}
closedir(dir);
// Sync this level
ret = sync_path("./");
if (ret)
{
// Any error message should already be printed, so just return
return -1;
}
else
{
// All is well..
}
depth--;
return Success;
}