#include <rmt.h>
#include "common.h"
#include <quotearg.h>
-#include <save-cwd.h>
#include <xgetcwd.h>
#include <unlinkdir.h>
+#include <utimens.h>
#ifndef DOUBLE_SLASH_IS_DISTINCT_ROOT
# define DOUBLE_SLASH_IS_DISTINCT_ROOT 0
void
assign_string (char **string, const char *value)
{
- if (*string)
- free (*string);
+ free (*string);
*string = value ? xstrdup (value) : 0;
}
completes the unquoting anyway.
This is used for reading the saved directory file in incremental
- dumps. It is used for decoding old `N' records (demangling names).
+ dumps. It is used for decoding old 'N' records (demangling names).
But also, it is used for decoding file arguments, would they come
from the shell or a -T file, and for decoding the --exclude
argument. */
return -1;
}
- return rmdir (file_name);
+ return unlinkat (chdir_fd, file_name, AT_REMOVEDIR);
}
/* Remove FILE_NAME, returning 1 on success. If FILE_NAME is a directory,
if (try_unlink_first)
{
- if (unlink (file_name) == 0)
+ if (unlinkat (chdir_fd, file_name, 0) == 0)
return 1;
/* POSIX 1003.1-2001 requires EPERM when attempting to unlink a
switch (errno)
{
case ENOTDIR:
- return !try_unlink_first && unlink (file_name) == 0;
+ return !try_unlink_first && unlinkat (chdir_fd, file_name, 0) == 0;
case 0:
case EEXIST:
if (this_is_the_archive && _remdev (file_name))
return true;
- if (stat (file_name, &file_stat))
+ if (deref_stat (file_name, &file_stat) != 0)
{
if (errno == ENOENT)
return true;
if (! after_backup_name)
xalloc_die ();
- if (rename (before_backup_name, after_backup_name) == 0)
+ if (renameat (chdir_fd, before_backup_name, chdir_fd, after_backup_name)
+ == 0)
{
if (verbose_option)
fprintf (stdlis, _("Renaming %s to %s\n"),
{
if (after_backup_name)
{
- if (rename (after_backup_name, before_backup_name) != 0)
+ if (renameat (chdir_fd, after_backup_name, chdir_fd, before_backup_name)
+ != 0)
{
int e = errno;
ERROR ((0, e, _("%s: Cannot rename to %s"),
}
}
-/* Depending on DEREF, apply either stat or lstat to (NAME, BUF). */
+/* Apply either stat or lstat to (NAME, BUF), depending on the
+ presence of the --dereference option. NAME is relative to the
+ most-recent argument to chdir_do. */
int
-deref_stat (bool deref, char const *name, struct stat *buf)
+deref_stat (char const *name, struct stat *buf)
{
- return deref ? stat (name, buf) : lstat (name, buf);
+ return fstatat (chdir_fd, name, buf, fstatat_flags);
}
-/* Use futimens if possible, utimensat otherwise. */
-int
-fd_utimensat (int fd, int parentfd, char const *file,
- struct timespec const ts[2], int atflag)
+/* Read from FD into the buffer BUF with COUNT bytes. Attempt to fill
+ BUF. Wait until input is available; this matters because files are
+ opened O_NONBLOCK for security reasons, and on some file systems
+ this can cause read to fail with errno == EAGAIN. Return the
+ actual number of bytes read, zero for EOF, or
+ SAFE_READ_ERROR upon error. */
+size_t
+blocking_read (int fd, void *buf, size_t count)
{
- if (0 <= fd)
+ size_t bytes = safe_read (fd, buf, count);
+
+#if defined F_SETFL && O_NONBLOCK
+ if (bytes == SAFE_READ_ERROR && errno == EAGAIN)
{
- int result = futimens (fd, ts);
- if (! (result < 0 && errno == ENOSYS))
- return result;
+ int flags = fcntl (fd, F_GETFL);
+ if (0 <= flags && flags & O_NONBLOCK
+ && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
+ bytes = safe_read (fd, buf, count);
}
+#endif
- return utimensat (parentfd, file, ts, atflag);
+ return bytes;
+}
+
+/* Write to FD from the buffer BUF with COUNT bytes. Do a full write.
+ Wait until an output buffer is available; this matters because
+ files are opened O_NONBLOCK for security reasons, and on some file
+ systems this can cause write to fail with errno == EAGAIN. Return
+ the actual number of bytes written, setting errno if that is less
+ than COUNT. */
+size_t
+blocking_write (int fd, void const *buf, size_t count)
+{
+ size_t bytes = full_write (fd, buf, count);
+
+#if defined F_SETFL && O_NONBLOCK
+ if (bytes < count && errno == EAGAIN)
+ {
+ int flags = fcntl (fd, F_GETFL);
+ if (0 <= flags && flags & O_NONBLOCK
+ && fcntl (fd, F_SETFL, flags & ~O_NONBLOCK) != -1)
+ {
+ char const *buffer = buf;
+ bytes += full_write (fd, buffer + bytes, count - bytes);
+ }
+ }
+#endif
+
+ return bytes;
}
/* Set FD's (i.e., assuming the working directory is PARENTFD, FILE's)
- access time to ATIME. ATFLAG controls symbolic-link following, in
- the style of openat. */
+ access time to ATIME. */
int
-set_file_atime (int fd, int parentfd, char const *file, struct timespec atime,
- int atflag)
+set_file_atime (int fd, int parentfd, char const *file, struct timespec atime)
{
struct timespec ts[2];
ts[0] = atime;
ts[1].tv_nsec = UTIME_OMIT;
- return fd_utimensat (fd, parentfd, file, ts, atflag);
+ return fdutimensat (fd, parentfd, file, ts, fstatat_flags);
}
/* A description of a working directory. */
/* The directory's name. */
char const *name;
- /* A negative value if no attempt has been made to save the
- directory, 0 if it was saved successfully, and a positive errno
- value if it was not saved successfully. */
- int err;
-
- /* The saved version of the directory, if ERR == 0. */
- struct saved_cwd saved_cwd;
+ /* If nonzero, the file descriptor of the directory, or AT_FDCWD if
+ the working directory. If zero, the directory needs to be opened
+ to be used. */
+ int fd;
};
/* A vector of chdir targets. wd[0] is the initial working directory. */
/* The allocated size of the vector. */
static size_t wd_alloc;
+/* The maximum number of chdir targets with open directories.
+ Don't make it too large, as many operating systems have a small
+ limit on the number of open file descriptors. Also, the current
+ implementation does not scale well. */
+enum { CHDIR_CACHE_SIZE = 16 };
+
+/* Indexes into WD of chdir targets with open file descriptors, sorted
+ most-recently used first. Zero indexes are unused. */
+static int wdcache[CHDIR_CACHE_SIZE];
+
+/* Number of nonzero entries in WDCACHE. */
+static size_t wdcache_count;
+
int
chdir_count ()
{
if (! wd_count)
{
wd[wd_count].name = ".";
- wd[wd_count].err = -1;
+ wd[wd_count].fd = AT_FDCWD;
wd_count++;
}
}
}
wd[wd_count].name = dir;
- wd[wd_count].err = -1;
+ wd[wd_count].fd = 0;
return wd_count++;
}
/* Index of current directory. */
int chdir_current;
-/* Change to directory I. If I is 0, change to the initial working
- directory; otherwise, I must be a value returned by chdir_arg. */
+/* Value suitable for use as the first argument to openat, and in
+ similar locations for fstatat, etc. This is an open file
+ descriptor, or AT_FDCWD if the working directory is current. It is
+ valid until the next invocation of chdir_do. */
+int chdir_fd = AT_FDCWD;
+
+/* Change to directory I, in a virtual way. This does not actually
+ invoke chdir; it merely sets chdir_fd to an int suitable as the
+ first argument for openat, etc. If I is 0, change to the initial
+ working directory; otherwise, I must be a value returned by
+ chdir_arg. */
void
chdir_do (int i)
{
if (chdir_current != i)
{
- struct wd *prev = &wd[chdir_current];
struct wd *curr = &wd[i];
+ int fd = curr->fd;
- if (prev->err < 0)
+ if (! fd)
{
- prev->err = 0;
- if (save_cwd (&prev->saved_cwd) != 0)
- prev->err = errno;
- else if (0 <= prev->saved_cwd.desc)
+ if (! IS_ABSOLUTE_FILE_NAME (curr->name))
+ chdir_do (i - 1);
+ fd = openat (chdir_fd, curr->name,
+ open_searchdir_flags & ~ O_NOFOLLOW);
+ if (fd < 0)
+ open_fatal (curr->name);
+
+ curr->fd = fd;
+
+ /* Add I to the cache, tossing out the lowest-ranking entry if the
+ cache is full. */
+ if (wdcache_count < CHDIR_CACHE_SIZE)
+ wdcache[wdcache_count++] = i;
+ else
{
- /* Make sure we still have at least one descriptor available. */
- int fd1 = prev->saved_cwd.desc;
- int fd2 = dup (fd1);
- if (0 <= fd2)
- close (fd2);
- else if (errno == EMFILE)
- {
- /* Force restore_cwd to use chdir_long. */
- close (fd1);
- prev->saved_cwd.desc = -1;
- prev->saved_cwd.name = xgetcwd ();
- if (! prev->saved_cwd.name)
- prev->err = errno;
- }
- else
- prev->err = errno;
+ struct wd *stale = &wd[wdcache[CHDIR_CACHE_SIZE - 1]];
+ if (close (stale->fd) != 0)
+ close_diag (stale->name);
+ stale->fd = 0;
+ wdcache[CHDIR_CACHE_SIZE - 1] = i;
}
}
- if (0 <= curr->err)
- {
- int err = curr->err;
- if (err == 0 && restore_cwd (&curr->saved_cwd) != 0)
- err = errno;
- if (err)
- FATAL_ERROR ((0, err, _("Cannot restore working directory")));
- }
- else
+ if (0 < fd)
{
- if (i && ! ISSLASH (curr->name[0]))
- chdir_do (i - 1);
- if (chdir (curr->name) != 0)
- chdir_fatal (curr->name);
+ /* Move the i value to the front of the cache. This is
+ O(CHDIR_CACHE_SIZE), but the cache is small. */
+ size_t ci;
+ int prev = wdcache[0];
+ for (ci = 1; prev != i; ci++)
+ {
+ int curr = wdcache[ci];
+ wdcache[ci] = prev;
+ if (curr == i)
+ break;
+ prev = curr;
+ }
+ wdcache[0] = i;
}
chdir_current = i;
+ chdir_fd = fd;
}
}
\f
diagfn (name);
}
-void
-dir_removed_diag (const char *name, bool top_level,
- void (*diagfn) (char const *name))
-{
- if (!top_level && errno == ENOENT)
- {
- WARNOPT (WARN_FILE_REMOVED,
- (0, 0, _("%s: Directory removed before we read it"),
- quotearg_colon (name)));
- set_exit_status (TAREXIT_DIFFERS);
- }
- else
- diagfn (name);
-}
-
void
write_fatal_details (char const *name, ssize_t status, size_t size)
{
struct namebuf
{
- char *buffer; /* directory, `/', and directory member */
+ char *buffer; /* directory, '/', and directory member */
size_t buffer_size; /* allocated size of name_buffer */
size_t dir_length; /* length of directory part in buffer */
};