c - 'rename(2) old new' 然后 'stat(2) new' 序列可能失败？

Question

我正在使用我公司的旧软件调查客户问题，但证据不足(没有错误跟踪)。在对代码进行逆向工程时，我发现了一个我怀疑的 C 片段，这可能是根本原因。
虽然我可以解决这个问题，但我仍然无法解释原因。
为了说明我的怀疑，我构建了以下 C 程序。如果 rename(2)，该程序会愚蠢地在两个文件夹之间来回移动文件并退出 1或 stat(2)失败。
该程序运行在 Linux (RHEL 7) 上，文件系统为 xfs就我而言，ext4就我的客户而言。
我还要补充一点，当问题发生时，文件系统上没有系统崩溃、断电或空间不足问题。此外，竞争条件(在下面评论)不是问题的原因(据我所知)。
到目前为止，在运行这个程序时，我没有看到任何失败。这并不意味着它不会发生，不是吗？

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>

void movefiles(char *src, char *dst) {
  DIR* fd = opendir(src);
  struct dirent* dp;
  int res = 1;
  while ((dp = readdir(fd))) {
    if(strcmp(dp->d_name, ".") && strcmp(dp->d_name, "..")) {
      char fsrc[256]; /* may overflow, out of topic though */
      char fdst[256];
      fsrc[0] = '\0';
      fdst[0] = '\0';
      strcat(fsrc, src); strcat(fsrc, "/"); strcat(fsrc, dp->d_name);
      strcat(fdst, dst); strcat(fdst, "/"); strcat(fdst, dp->d_name);
      if(rename(fsrc, fdst) != 0) {
        perror("rename failed");
        exit(1);
      }
      struct stat sb;
      if(stat(fdst, &sb) != 0) { /* file name race condition */
        perror("stat failed"); /* can this happen ? */
        exit(1);
      }
    }
  }
  closedir(fd);
}

int main() {
  /* assume random content in either directories */
  char *src = "tmp/dir1";
  char *dst = "tmp/dir2";
  while (1) {
    movefiles(src, dst);
    movefiles(dst, src);
  }
  return 0;    
}

我知道文件系统是复杂的子系统，可能会出现故障/行为不同，因此提供了 rename 的原子 promise 。很难。
我的具体问题在代码中注释掉了:can rename报告成功后跟 stat报告失败？
是否有可能某些文件系统实现了 rename 的立即返回？而操作仍在异步进行，使得 stat可能/很少报告失败？
在四处搜索时，我可以看到人们在谈论 open - write - close - rename问题和 fsync推荐，但 rename - stat看起来我与众不同并且找不到任何链接来验证/使我的怀疑无效。
谢谢你的灯。

Answer 1

如果另一个进程(包括人类使用的 shell)同时干扰文件或其目录，则代码可能会以多种方式失败。
如果我们忽略所有常见原因(来自另一个进程的干扰，或者整个文件系统被卸载)，XFS 中有一个细节会影响这一点——假设它是一个 32 位二进制文​​件:XFS 文件的 inode 编号可能超过232-1 = 4,294,967,295 导致 fs/stat.c:cp_old_stat()或 fs/stat.c:cp_new_stat() EOVERFLOW 失败。
要验证，请使用 file 检查原始二进制文件.如果是 64 位，则不能是 inode 编号。如果是 32 位，则 inode 编号可能是罪魁祸首。要修复，请将二进制文件重新编译为 64 位。

不过，该代码确实令人怀疑。
问题在于在修改所述目录的内容时依赖于 readdir()。由于较新的文件系统如何工作，不能保证 readdir() 只能看到新文件，而看不到已移动的文件。
正确的方法是首先获取完整的文件列表——您可以使用例如scandir() , glob() , 或 nftw() ; scandir() 或 glob() 如果要将文件作为一个集合处理， nftw() 如果您移动回调函数中的每个文件。你看，两者都是glob()和 nftw()即使底层的 readdir() 没有，也应该正确处理“目录可能会在行走过程中改变”。
(还有 fts 系列遍历文件系统树，但在 Linux 上，2.23(2016 年 2 月发布)之前的 glibc 实现对于 64 位文件偏移是不安全的。)
考虑这个实现:

#define _POSIX_C_SOURCE  200809L
#define _GNU_SOURCE
#define _ATFILE_SOURCE
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <ftw.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

/* Because file_mover() does not descend into subdirectories, it needs a
   very small number of descriptors; four should always suffice. */
#define  FILE_MOVER_FDS  4

/* Per-thread state for file_mover(). Each thread sees separate variables! */
static __thread int   file_mover_destfd = -1;
static __thread int   file_mover_errno = 0;
static __thread long  file_mover_count = 0;

static int file_mover(const char *srcpath, const struct stat *srcinfo, int typeflag, struct FTW *details)
{
    /* Initial argument (srcpath)? */
    if (details->level == 0) {
        /* If it specifies a directory, move all its files. */
        if (typeflag == FTW_D)
            return FTW_CONTINUE;
        /* Otherwise fail. */
        file_mover_errno = ENODEV;
        return FTW_STOP;
    }

    /* Skip directories. */
    if (typeflag == FTW_D || typeflag == FTW_DNR || typeflag == FTW_DP)
        return FTW_SKIP_SUBTREE;

    /* Ignore all but ordinary files. */
    if (typeflag != FTW_F)
        return FTW_CONTINUE;

    /* Obtain file name part, and its length. */
    const char   *name = srcpath + details->base;
    const size_t  namelen = strlen(name);

    /* Zero-length files should never occur; detect them anyway. */
    if (namelen < 1) {
        file_mover_errno = ENOENT;
        return FTW_STOP;
    }

    /* Detect if destination descriptor is invalid. */
    if (file_mover_destfd == -1) {
        file_mover_errno = EBADF;
        return FTW_STOP;
    }

    /* Source path is either absolute, or relative to current working directory. */
    if (renameat(AT_FDCWD, srcpath, file_mover_destfd, name) == -1) {
        file_mover_errno = errno;
        return FTW_STOP;
    }

    /* Verify the target file exists and matches the original file. */
    {
        struct stat  destinfo;
        if (fstatat(file_mover_destfd, name, &destinfo, 0) == -1) {
            file_mover_errno = errno;
            return FTW_STOP;
        }

        /* Size and mode matches? */
        if (destinfo.st_size != srcinfo->st_size || destinfo.st_mode != srcinfo->st_mode) {
            file_mover_errno = EIO;
            return FTW_STOP;
        }
    }

    /* Add to the running count. */
    file_mover_count++;

    return FTW_CONTINUE;
}

/* Move files from directory srcdir to directory destdir.
   Returns -1 if an error occurs with errno set to indicate the error,
   and the number of files moved otherwise.
*/
static long move_files(const char *srcdir, const char *destdir)
{
    /* Paranoid sanity checks. */
    if (!srcdir || !destdir) {
        errno = EINVAL;
        return -1;
    }

    /* Open the destination directory as a handle. */
    do {
        file_mover_destfd = open(destdir, O_PATH | O_CLOEXEC);
    } while (file_mover_destfd == -1 && errno == EINTR);
    if (file_mover_destfd == -1) {
        return -1;
    }

    file_mover_errno = 0;
    file_mover_count = 0;

    if (nftw(srcdir, file_mover, FILE_MOVER_FDS, FTW_ACTIONRETVAL) != 0) {
        /* Failed. Return reason in errno. */
        close(file_mover_destfd);
        file_mover_destfd = -1;
        errno = file_mover_errno;
        return -1;
    }

    if (close(file_mover_destfd) == -1) {
        file_mover_destfd = -1;
        /* errno set by close() */
        return -1;
    }
    file_mover_destfd = -1;

    /* Success. (Note: technically, the count could overflow on 32-bit arches.) */
    return file_mover_count;
}


int main(int argc, char *argv[])
{
    long  n;

    if (argc != 3) {
        const char *cmd = (argc > 0 && argv[0] && argv[0][0]) ? argv[0] : "(this)";
        fprintf(stderr, "\n");
        fprintf(stderr, "Usage: %s [ -h | --help]\n", cmd);
        fprintf(stderr, "       %s SOURCE-DIRECTORY DESTINATION-DIRECTORY\n", cmd);
        fprintf(stderr, "\n");
        if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")))
            return EXIT_SUCCESS;
        else
            return EXIT_FAILURE;
    }

    n = move_files(argv[1], argv[2]);
    if (n < 0) {
        fprintf(stderr, "Failed: %s (%d)\n", strerror(errno), errno);
        return EXIT_FAILURE;
    } else
    if (!n) {
        fprintf(stderr, "No files to move.\n");
        return EXIT_SUCCESS;
    }

    if (n == 1)
        printf("1 file moved.\n");
    else
        printf("%ld files moved.\n", n);

    return EXIT_SUCCESS;
}

要无限循环地运行它，请使用

int main(int argc, char *argv[])
{
    long  n, expected = 0;

    if (argc != 3) {
        const char *cmd = (argc > 0 && argv[0] && argv[0][0]) ? argv[0] : "(this)";
        fprintf(stderr, "\n");
        fprintf(stderr, "Usage: %s [ -h | --help]\n", cmd);
        fprintf(stderr, "       %s SOURCE-DIRECTORY DESTINATION-DIRECTORY\n", cmd);
        fprintf(stderr, "\n");
        if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")))
            return EXIT_SUCCESS;
        else
            return EXIT_FAILURE;
    }

    while(1) {

        n = move_files(argv[1], argv[2]);
        if (n < 0) {
            fprintf(stderr, "Failed: %s (%d)\n", strerror(errno), errno);
            return EXIT_FAILURE;
        } else
        if (!n) {
            fprintf(stderr, "No files to move.\n");
            return EXIT_SUCCESS;
        }

        if (!expected) {
            expected = n;
            fprintf(stderr, "Moving %ld files around.\n", n);
        } else
        if (n != expected) {
            fprintf(stderr, "Moved %ld of %ld files!\n", n, expected);
            return EXIT_FAILURE;
        }

        n = move_files(argv[2], argv[1]);
        if (n < 0) {
            fprintf(stderr, "Failed: %s (%d)\n", strerror(errno), errno);
            return EXIT_FAILURE;
        } else
        if (n != expected) {
            fprintf(stderr, "Moved only %ld of %ld files!\n", n, expected);
            return EXIT_FAILURE;
        }
    }

    return EXIT_SUCCESS;
}

这将检测您是否例如在测试期间删除其中一个文件。