113 lines
3.3 KiB
C++
113 lines
3.3 KiB
C++
#include "GbCopyFile.h"
|
|
#include "Log.h"
|
|
#include "Sanity.h"
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/sendfile.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
|
|
//note: keep copy functionality in-sync with moveFile()
|
|
|
|
static const size_t io_buffer_size = 1024*1024;
|
|
|
|
int copyFile(const char *src, const char *dst)
|
|
{
|
|
//Allocate IO buffer
|
|
char *buffer = new char[io_buffer_size];
|
|
//Use O_DIRECT because the source file will soon be gone and shouldn't
|
|
//pollute the kernels file system cache
|
|
int fd_src = open(src,O_RDONLY|O_DIRECT);
|
|
if(fd_src<0) {
|
|
int saved_errno = errno;
|
|
if(errno==EINVAL) {
|
|
//open(...O_DIRECT) can fail due to filesystem (eg. on development machines /tmp can be a
|
|
//tmpfs which curiously doesn't support O_DIRECT. Other file systems, eg. NFS have the same issue.
|
|
fd_src = open(src,O_RDONLY);
|
|
if(fd_src<0) {
|
|
saved_errno = errno;
|
|
log(LOG_ERROR,"copyFile:open(%s) failed with errno=%d (%s)", src, errno, strerror(errno));
|
|
delete[] buffer;
|
|
errno = saved_errno;
|
|
return -1;
|
|
}
|
|
} else {
|
|
log(LOG_ERROR,"copyFile:open(%s) failed with errno=%d (%s)", src, errno, strerror(errno));
|
|
delete[] buffer;
|
|
errno = saved_errno;
|
|
return -1;
|
|
}
|
|
}
|
|
//Tell the OS that we are going to read the source file sequentially
|
|
(void)posix_fadvise(fd_src,0,0,POSIX_FADV_SEQUENTIAL);
|
|
|
|
//Open destination. We use O_TRUNC instead of O_EXCL because if we crashed
|
|
//during a copy the destination file will be left over (it is a bit risky).
|
|
//We don't use O_DIRECT nor posix_fadvise(fd_dst,0,0,POSIX_FADV_SEQUENTIAL)
|
|
//because the destination is likely to be used immediately when finished
|
|
int fd_dst = open(dst,O_CREAT|O_TRUNC|O_WRONLY,0666);
|
|
if(fd_dst<0) {
|
|
int saved_errno = errno;
|
|
log(LOG_ERROR,"move_file:open(%s) failed with errno=%d (%s)", dst,errno,strerror(errno));
|
|
(void)close(fd_src);
|
|
delete[] buffer;
|
|
errno = saved_errno;
|
|
return -1;
|
|
}
|
|
|
|
struct stat st_src;
|
|
(void)fstat(fd_src, &st_src);
|
|
|
|
//sendfile() should be the most efficient way, but it may fail on some (older) kernels
|
|
long rc = sendfile(fd_dst, fd_src, NULL, st_src.st_size);
|
|
if(rc<0) {
|
|
//fallback:
|
|
//if sendfile() fails, then do a traditional roll-your-own copy loop
|
|
for(;;) {
|
|
long bytes_read = read(fd_src, buffer, io_buffer_size);
|
|
if(bytes_read==0)
|
|
break;
|
|
if(bytes_read<0) {
|
|
int saved_errno = errno;
|
|
log(LOG_ERROR,"moveFile:open(%s) failed with errno=%d (%s)", src,errno,strerror(errno));
|
|
close(fd_src);
|
|
close(fd_dst);
|
|
unlink(dst);
|
|
delete[] buffer;
|
|
errno = saved_errno;
|
|
return -1;
|
|
}
|
|
long bytes_written = write(fd_dst, buffer, (size_t)bytes_read);
|
|
if(bytes_written!=bytes_read) {
|
|
int saved_errno = errno;
|
|
log(LOG_ERROR,"moveFile:write(%s) failed with errno=%d (%s)", dst,errno,strerror(errno));
|
|
close(fd_src);
|
|
close(fd_dst);
|
|
unlink(dst);
|
|
delete[] buffer;
|
|
errno = saved_errno;
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct stat st_dst;
|
|
(void)fstat(fd_dst, &st_dst);
|
|
|
|
if (st_dst.st_size != st_src.st_size) {
|
|
logError("copying file from src=%s to dst=%s ends up with different file sizes. src=%ld bytes dst=%ld bytes",
|
|
src, dst, st_src.st_size, st_dst.st_size);
|
|
gbshutdownCorrupted();
|
|
}
|
|
|
|
close(fd_src);
|
|
close(fd_dst);
|
|
delete[] buffer;
|
|
|
|
return 0;
|
|
}
|