This is the mail archive of the
cygwin-developers
mailing list for the Cygwin project.
Re: Cygwin Filesystem Performance degradation 1.7.5 vs 1.7.7, and methods for improving performance
Hi,
> Attached is a preliminary version of the new symlink_info::xcheck
> function, which uses NtQueryDirectoryFile. First tests show that
> `ls -l' is about three times faster than when using symlink_info::check.
> To activate the function you can use the "CYGWIN=xcheck" setting.
> Of course you will not get correct ACLs and a wrong st_nlink but
> that has been discussed to death already.
I got rejects when applying the patch on latest code from CVS.
attached is an updated patch.
Yoni.
Index: environ.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/environ.cc,v
retrieving revision 1.183
diff -u -p -r1.183 environ.cc
--- environ.cc 18 May 2010 14:30:50 -0000 1.183
+++ environ.cc 10 Oct 2010 14:09:48 -0000
@@ -31,6 +31,7 @@ details. */
#include "child_info.h"
#include "ntdll.h"
+extern bool use_xcheck;
extern bool dos_file_warning;
extern bool ignore_case_with_glob;
extern bool allow_winsymlinks;
@@ -605,6 +606,7 @@ static struct parse_thing
{"tty", {NULL}, set_process_state, NULL, {{0}, {PID_USETTY}}},
{"upcaseenv", {&create_upcaseenv}, justset, NULL, {{false}, {true}}},
{"winsymlinks", {&allow_winsymlinks}, justset, NULL, {{false}, {true}}},
+ {"xcheck", {&use_xcheck}, justset, NULL, {{false}, {true}}},
{NULL, {0}, justset, 0, {{0}, {0}}}
};
Index: fhandler_disk_file.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/fhandler_disk_file.cc,v
retrieving revision 1.345
diff -u -p -r1.345 fhandler_disk_file.cc
--- fhandler_disk_file.cc 7 Oct 2010 14:03:26 -0000 1.345
+++ fhandler_disk_file.cc 10 Oct 2010 14:09:49 -0000
@@ -345,11 +345,11 @@ fhandler_base::fstat_by_handle (struct _
IO_STATUS_BLOCK io;
/* If the file has been opened for other purposes than stat, we
can't rely
- on the information stored in pc.fnoi. So we overwrite them here. */
+ on the information stored in pc.finfo. So we overwrite them here. */
if (get_io_handle ())
{
- PFILE_NETWORK_OPEN_INFORMATION pfnoi = pc.fnoi ();
- status = NtQueryInformationFile (h, &io, pfnoi, sizeof *pfnoi,
+ PFILE_CYGWIN_INFORMATION pfci = pc.finfo ();
+ status = NtQueryInformationFile (h, &io, pfci, sizeof *pfci,
FileNetworkOpenInformation);
if (!NT_SUCCESS (status))
{
@@ -403,6 +403,8 @@ fhandler_base::fstat_by_name (struct __s
WCHAR buf[NAME_MAX + 1];
} fdi_buf;
+ if (!ino)
+ ino = pc.finfo ()->FileId.QuadPart;
if (!ino && pc.hasgood_inode ()
&& wincap.has_fileid_dirinfo () && !pc.has_buggy_fileid_dirinfo ())
{
@@ -441,14 +443,20 @@ fhandler_base::fstat_fs (struct __stat64
int oret;
int open_flags = O_RDONLY | O_BINARY;
+ if (pc.fs_is_nfs ())
+ return fstat_by_nfs_ea (buf);
+
if (get_stat_handle ())
{
if (!nohandle () && !is_fs_special ())
- res = pc.fs_is_nfs () ? fstat_by_nfs_ea (buf) : fstat_by_handle (buf);
+ res = fstat_by_handle (buf);
if (res)
res = fstat_by_name (buf);
return res;
}
+ else if (pc.xchecked ())
+ return fstat_by_name (buf);
+
/* First try to open with generic read access. This allows to read
the file
in fstat_helper (when checking for executability) without having to
re-open it. Opening a file can take a lot of time on network drives
@@ -485,19 +493,19 @@ fhandler_base::fstat_helper (struct __st
IO_STATUS_BLOCK st;
FILE_COMPRESSION_INFORMATION fci;
HANDLE h = get_stat_handle ();
- PFILE_NETWORK_OPEN_INFORMATION pfnoi = pc.fnoi ();
+ PFILE_CYGWIN_INFORMATION pfci = pc.finfo ();
ULONG attributes = pc.file_attributes ();
- to_timestruc_t ((PFILETIME) &pfnoi->LastAccessTime, &buf->st_atim);
- to_timestruc_t ((PFILETIME) &pfnoi->LastWriteTime, &buf->st_mtim);
+ to_timestruc_t ((PFILETIME) &pfci->LastAccessTime, &buf->st_atim);
+ to_timestruc_t ((PFILETIME) &pfci->LastWriteTime, &buf->st_mtim);
/* If the ChangeTime is 0, the underlying FS doesn't support this
timestamp
(FAT for instance). If so, it's faked using LastWriteTime. */
- to_timestruc_t (pfnoi->ChangeTime.QuadPart ? (PFILETIME)
&pfnoi->ChangeTime
- : (PFILETIME) &pfnoi->LastWriteTime,
+ to_timestruc_t (pfci->ChangeTime.QuadPart ? (PFILETIME) &pfci->ChangeTime
+ : (PFILETIME) &pfci->LastWriteTime,
&buf->st_ctim);
- to_timestruc_t ((PFILETIME) &pfnoi->CreationTime, &buf->st_birthtim);
+ to_timestruc_t ((PFILETIME) &pfci->CreationTime, &buf->st_birthtim);
buf->st_rdev = buf->st_dev = get_dev ();
- buf->st_size = (_off64_t) pfnoi->EndOfFile.QuadPart;
+ buf->st_size = (_off64_t) pfci->EndOfFile.QuadPart;
/* The number of links to a directory includes the number of
subdirectories
in the directory, since all those subdirectories point to it.
However,
this is painfully slow, so we do without it. */
@@ -515,10 +523,10 @@ fhandler_base::fstat_helper (struct __st
buf->st_blksize = PREFERRED_IO_BLKSIZE;
- if (pfnoi->AllocationSize.QuadPart >= 0LL)
+ if (pfci->AllocationSize.QuadPart >= 0LL)
/* A successful NtQueryInformationFile returns the allocation size
correctly for compressed and sparse files as well. */
- buf->st_blocks = (pfnoi->AllocationSize.QuadPart + S_BLKSIZE - 1)
+ buf->st_blocks = (pfci->AllocationSize.QuadPart + S_BLKSIZE - 1)
/ S_BLKSIZE;
else if (::has_attribute (attributes, FILE_ATTRIBUTE_COMPRESSED
| FILE_ATTRIBUTE_SPARSE_FILE)
Index: ntdll.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/ntdll.h,v
retrieving revision 1.106
diff -u -p -r1.106 ntdll.h
--- ntdll.h 9 Oct 2010 10:54:12 -0000 1.106
+++ ntdll.h 10 Oct 2010 14:09:49 -0000
@@ -1078,8 +1078,12 @@ extern "C"
if (dirname)
RtlInitCountedUnicodeString (dirname, path->Buffer, len * sizeof
(WCHAR));
if (basename)
- RtlInitCountedUnicodeString (basename, &path->Buffer[len],
- path->Length - len * sizeof (WCHAR));
+ {
+ RtlInitCountedUnicodeString (basename, &path->Buffer[len],
+ path->Length - len * sizeof (WCHAR));
+ /* Preserve MaximumLength! */
+ basename->MaximumLength = path->MaximumLength - len * sizeof (WCHAR);
+ }
}
/* Check if prefix is a prefix of path. */
inline
Index: path.cc
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/path.cc,v
retrieving revision 1.617
diff -u -p -r1.617 path.cc
--- path.cc 9 Oct 2010 10:54:13 -0000 1.617
+++ path.cc 10 Oct 2010 14:09:52 -0000
@@ -95,6 +95,8 @@ struct symlink_info
_major_t major;
_minor_t minor;
_mode_t mode;
+ int xcheck (char *path, const suffix_info *suffixes, fs_info &fs,
+ path_conv_handle &conv_hdl);
int check (char *path, const suffix_info *suffixes, fs_info &fs,
path_conv_handle &conv_hdl);
int set (char *path);
@@ -105,6 +107,10 @@ struct symlink_info
int check_nfs_symlink (HANDLE h);
int posixify (char *srcbuf);
bool set_error (int);
+ bool set_error_from_nt_status (NTSTATUS status)
+ {
+ return set_error (geterrno_from_win_error (RtlNtStatusToDosError
(status)));
+ }
};
muto NO_COPY cwdstuff::cwd_lock;
@@ -435,7 +441,7 @@ get_nt_native_path (const char *path, UN
if (dos)
{
/* Unfortunately we can't just use transform_chars with the
tfx_rev_chars
- table since only leading and trainlig spaces and dots are
affected.
+ table since only leading and trailing spaces and dots are
affected.
So we step to every backslash and fix surrounding dots and spaces.
That makes these broken filesystems a bit slower, but, hey. */
PWCHAR cp = upath.Buffer + 7;
@@ -586,6 +592,8 @@ path_conv::check (const UNICODE_STRING *
path_conv::check (path, opt, suffixes);
}
+bool use_xcheck = false;
+
void
path_conv::check (const char *src, unsigned opt,
const suffix_info *suffixes)
@@ -651,6 +659,8 @@ path_conv::check (const char *src, unsig
error = ENOENT;
return;
}
+ if (use_xcheck)
+ opt |= PC_XCHECK;
bool is_msdos = false;
/* This loop handles symlink expansion. */
@@ -860,7 +870,10 @@ path_conv::check (const char *src, unsig
is_fs_via_procsys:
- symlen = sym.check (full_path, suff, fs, conv_handle);
+ if (opt & PC_XCHECK)
+ symlen = sym.xcheck (full_path, suff, fs, conv_handle);
+ else
+ symlen = sym.check (full_path, suff, fs, conv_handle);
is_virtual_symlink:
@@ -2196,6 +2209,186 @@ symlink_info::parse_device (const char *
return isdevice = true;
}
+/* Private class to store a single suffix. Used by ucs_suffixes
exclusively. */
+#define UCS_MAX_LEN 6
+class ucs_suffix
+{
+ UNICODE_STRING name;
+ WCHAR buf[UCS_MAX_LEN];
+ void set (const suffix_info *sin)
+ {
+ sys_mbstowcs (buf, UCS_MAX_LEN, sin->name);
+ RtlInitUnicodeString (&name, buf);
+ }
+ void add_lnk ()
+ { RtlInitUnicodeString (&name, wcscpy (buf, L".lnk")); }
+ bool check (PUNICODE_STRING fname)
+ { return RtlEqualUnicodePathSuffix (fname, &name, TRUE); }
+ PCWSTR get () const { return buf; }
+ friend class ucs_suffixes;
+};
+
+/* Replacement class to store the incoming suffixes to
symlink_info::xcheck.
+ The suffixes are stored as UNICODE_STRINGS for quicker comparison.
+ Ultimately this can be used for symlink_info::check as well. The
+ constructor also takes over the job of suffix_scan::has */
+#define UCS_MAX_SUFFIXES 8
+class ucs_suffixes
+{
+ ucs_suffix suf[UCS_MAX_SUFFIXES];
+ int cnt;
+ int lnk_idx;
+public:
+ ucs_suffixes (const suffix_info *sin, const char *path, char *&ext_here)
+ : cnt (0), lnk_idx (-1)
+ {
+ if (sin)
+ for (int i = 0; i < UCS_MAX_SUFFIXES - 1 && sin[i].name; ++i)
+ if (*sin[i].name)
+ suf[cnt++].set (sin + i);
+
+ const char *fname = strrchr (path, '\\');
+ fname = fname ? fname + 1 : path;
+ ext_here = strrchr (fname, '.');
+ char *eopath = strchr (path, '\0');
+
+ if (ext_here)
+ {
+ if (sin)
+ {
+ /* Check if the extension matches a known extension */
+ for (const suffix_info *ex = sin; ex->name != NULL; ex++)
+ if (ascii_strcasematch (ext_here, ex->name))
+ {
+ cnt = 0;
+ return;
+ }
+ }
+ /* Didn't match. Use last resort -- .lnk. */
+ if (ascii_strcasematch (ext_here, ".lnk"))
+ {
+ cnt = 0;
+ return;
+ }
+ }
+ ext_here = eopath;
+ /* Avoid attaching suffixes if the resulting filename would be
invalid. */
+ if (eopath - fname > NAME_MAX - 4)
+ cnt = 0;
+ }
+ void add_lnk () { lnk_idx = cnt; suf[cnt++].add_lnk (); }
+ int check (PUNICODE_STRING fname)
+ {
+ for (int i = 0; i < cnt; ++i)
+ if (suf[i].check (fname))
+ return i;
+ return -1;
+ }
+ PCWSTR get (int i) const { return i < 0 || i >= cnt ? L"" :
suf[i].get (); }
+ int count () const { return cnt; }
+ bool lnk_match (int i) const { return i >= 0 && i == lnk_idx; }
+};
+
+/* This class is an abstraction for the various FILE_INFO classes used by
+ symlink_info::xcheck. The constructor chooses the right info class
+ based on the information fetched from fs_info::update. The idea here is
+ that symlink_info::xcheck doesn't have to know the actual info class
+ used to get the necessary information. The caller has to provide the
+ buffer and the buffer size for the file info. */
+class file_info
+{
+ FILE_INFORMATION_CLASS fic;
+ PBYTE buffer;
+ PBYTE curptr;
+ size_t size;
+ UNICODE_STRING uname;
+public:
+ file_info (fs_info &fs, PVOID buf, size_t siz)
+ : buffer ((PBYTE) buf), curptr (NULL), size (siz)
+ {
+ if (fs.is_nfs ())
+ fic = FileNamesInformation;
+ else if (fs.hasgood_inode () && wincap.has_fileid_dirinfo ()
+ && !fs.has_buggy_fileid_dirinfo ())
+ fic = FileIdBothDirectoryInformation;
+ else
+ fic = FileBothDirectoryInformation;
+ }
+ operator PVOID () const { return buffer; }
+ operator ULONG () const { return size; }
+ operator FILE_INFORMATION_CLASS () const { return fic; }
+ bool next ()
+ {
+ bool ret = true;
+
+ if (!curptr)
+ curptr = buffer;
+ else if (PFILE_NAMES_INFORMATION (curptr)->NextEntryOffset != 0)
+ curptr += PFILE_NAMES_INFORMATION (curptr)->NextEntryOffset;
+ else
+ {
+ curptr = NULL;
+ ret = false;
+ }
+ return ret;
+ }
+ PUNICODE_STRING name ()
+ {
+ if (!curptr)
+ return NULL;
+ switch (fic)
+ {
+ case FileNamesInformation:
+ uname.Length = uname.MaximumLength
+ = PFILE_NAMES_INFORMATION (curptr)->FileNameLength;
+ uname.Buffer = PFILE_NAMES_INFORMATION (curptr)->FileName;
+ break;
+ case FileBothDirectoryInformation:
+ uname.Length = uname.MaximumLength
+ = PFILE_BOTH_DIRECTORY_INFORMATION (curptr)->FileNameLength;
+ uname.Buffer = PFILE_BOTH_DIRECTORY_INFORMATION (curptr)->FileName;
+ break;
+ case FileIdBothDirectoryInformation:
+ uname.Length = uname.MaximumLength
+ = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->FileNameLength;
+ uname.Buffer = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->FileName;
+ break;
+ default:
+ return NULL;
+ }
+ return &uname;
+ }
+ ULONG file_attributes ()
+ {
+ if (curptr && fic != FileNamesInformation)
+ return PFILE_BOTH_DIRECTORY_INFORMATION (curptr)->FileAttributes;
+ return INVALID_FILE_ATTRIBUTES;
+ }
+ void copy (PFILE_CYGWIN_INFORMATION pfci, PUNICODE_STRING dir,
+ PUNICODE_STRING file)
+ {
+ if (curptr && fic != FileNamesInformation)
+ {
+ memcpy (pfci, &PFILE_ID_BOTH_DIR_INFORMATION (curptr)->CreationTime,
+ 4 * sizeof (LARGE_INTEGER));
+ pfci->EndOfFile.QuadPart
+ = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->EndOfFile.QuadPart;
+ pfci->AllocationSize.QuadPart
+ = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->AllocationSize.QuadPart;
+ pfci->FileAttributes
+ = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->FileAttributes;
+ pfci->ReparseTag
+ = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->EaSize;
+ if (fic == FileIdBothDirectoryInformation)
+ pfci->FileId.QuadPart
+ = PFILE_ID_BOTH_DIR_INFORMATION (curptr)->FileId.QuadPart;
+ else
+ pfci->FileId.QuadPart = hash_path_name (hash_path_name (0, dir),
+ file);
+ }
+ }
+};
+
/* Check if PATH is a symlink. PATH must be a valid Win32 path name.
If PATH is a symlink, put the value of the symlink--the file to
@@ -2214,6 +2407,325 @@ symlink_info::parse_device (const char *
stored into BUF if PATH is a symlink. */
int
+symlink_info::xcheck (char *path, const suffix_info *suffixes, fs_info &fs,
+ path_conv_handle &conv_hdl)
+{
+ int res = 0;
+ HANDLE dh;
+ NTSTATUS status;
+ UNICODE_STRING upath, dirname, basename, filter;
+ OBJECT_ATTRIBUTES attr;
+ IO_STATUS_BLOCK io;
+ bool is_root_dir = false;
+ const ULONG ci_flag = cygwin_shared->obcaseinsensitive
+ || (pflags & PATH_NOPOSIX) ? OBJ_CASE_INSENSITIVE : 0;
+
+ contents[0] = '\0';
+ issymlink = isdevice = ext_tacked_on = false;
+ error = major = minor = mode = 0;
+ fileattr = INVALID_FILE_ATTRIBUTES;
+
+ ucs_suffixes suff (suffixes, path, ext_here);
+ extn = ext_here - path;
+ pflags &= ~(PATH_SYMLINK | PATH_LNK | PATH_REP | PC_KEEP_HANDLE);
+ pflags |= PATH_NOACL | PATH_NOTEXEC | PATH_XCHECKED;
+
+ tmp_pathbuf tp;
+ tp.u_get (&upath);
+ get_nt_native_path (path, upath, pflags & PATH_DOS);
+ /* First check if we the path is the root dir of a drive or share.
+ Checking the root dir info requires to open a handle to the root
+ dir directly since there's no (accessible) parent dir anyway. */
+ if (upath.Buffer[upath.Length / sizeof (WCHAR) - 1] == L'\\') /*
\??\X:\ */
+ is_root_dir = true;
+ else if (RtlEqualUnicodePathPrefix (&upath, &ro_u_uncp, FALSE))
+ {
+ /* The idea here is that a valid path to the root dir of a share has
+ only one additional backslash following the UNC path prefix, while
+ any deeper path has at least two following backslashes. */
+ PWCHAR p;
+ p = wcschr (upath.Buffer + (ro_u_uncp.Length / sizeof (WCHAR)),
L'\\');
+ if (p && !wcschr (p + 1, L'\\'))
+ is_root_dir = true;
+ }
+ if (is_root_dir)
+ {
+ InitializeObjectAttributes (&attr, &upath, ci_flag, NULL, NULL);
+ status = NtOpenFile (&dh,
+ READ_CONTROL | FILE_READ_ATTRIBUTES | FILE_READ_EA,
+ &attr, &io, FILE_SHARE_VALID_FLAGS,
+ FILE_OPEN_FOR_BACKUP_INTENT);
+ if (!NT_SUCCESS (status))
+ {
+ set_error_from_nt_status (status);
+ return 0;
+ }
+ fs.update (&upath, dh);
+ if (fs.is_nfs ())
+ {
+ status = nfs_fetch_fattr3 (dh, conv_hdl.nfsattr ());
+ if (NT_SUCCESS (status))
+ fileattr = ((conv_hdl.nfsattr ()->type & 7) == NF3DIR)
+ ? FILE_ATTRIBUTE_DIRECTORY : 0;
+ }
+ else
+ {
+ PFILE_CYGWIN_INFORMATION pfci = conv_hdl.finfo ();
+
+ status = NtQueryInformationFile (dh, &io, pfci, sizeof *pfci,
+ FileNetworkOpenInformation);
+ if ((status == STATUS_INVALID_PARAMETER
+ || status == STATUS_NOT_IMPLEMENTED)
+ && RtlEqualUnicodePathPrefix (&upath, &ro_u_uncp, FALSE))
+ {
+ /* This occurs when accessing SMB share root dirs hosted on
+ NT4 (STATUS_INVALID_PARAMETER), or when trying to access
+ SMB share root dirs from NT4 (STATUS_NOT_IMPLEMENTED). */
+ FILE_BASIC_INFORMATION fbi;
+
+ status = NtQueryInformationFile (dh, &io, &fbi, sizeof fbi,
+ FileBasicInformation);
+ if (NT_SUCCESS (status))
+ {
+ memcpy (pfci, &fbi, 4 * sizeof (LARGE_INTEGER));
+ pfci->EndOfFile.QuadPart
+ = pfci->AllocationSize.QuadPart = 0;
+ pfci->FileAttributes = fbi.FileAttributes;
+ }
+ }
+ pfci->ReparseTag = 0;
+ if (!fs.hasgood_inode ()
+ || !NT_SUCCESS (NtQueryInformationFile (dh, &io, &pfci->FileId,
+ sizeof pfci->FileId,
+ FileInternalInformation)))
+ pfci->FileId.QuadPart = hash_path_name (0, &upath);
+ if (NT_SUCCESS (status))
+ fileattr = pfci->FileAttributes;
+ }
+ NtClose (dh);
+ if (!NT_SUCCESS (status))
+ set_error_from_nt_status (status);
+ return 0;
+ }
+ /* The default case. We open the parent dir and fetch the file info by
+ NtQueryDirectoryFile. */
+ RtlSplitUnicodePath (&upath, &dirname, &basename);
+ InitializeObjectAttributes (&attr, &dirname, ci_flag, NULL, NULL);
+ status = NtOpenFile (&dh, SYNCHRONIZE | FILE_LIST_DIRECTORY, &attr, &io,
+ FILE_SHARE_VALID_FLAGS,
+ FILE_SYNCHRONOUS_IO_NONALERT
+ | FILE_OPEN_FOR_BACKUP_INTENT
+ | FILE_DIRECTORY_FILE);
+ if (!NT_SUCCESS (status))
+ {
+ set_error_from_nt_status (status);
+ return 0;
+ }
+ /* Check the fs info. This tells us which info class to use. */
+ fs.update (&upath, dh);
+ /* Only add the .lnk suffix if not on NFS. */
+ if (!fs.is_nfs ())
+ suff.add_lnk ();
+ else if (fs.has_dos_filenames_only () && !(pflags & PATH_DOS))
+ {
+ /* Filesystem doesn't grok leading spaces or trailing dots or spaces.
+ Regenerate unicode path accordingly. */
+ pflags |= PATH_DOS;
+ get_nt_native_path (path, upath, true);
+ RtlSplitUnicodePath (&upath, &dirname, &basename);
+ }
+ /* Copy basename into filter and check if we have to test for suffixes.
+ If so, append the wildcard expression. We use a more or less
undocumented
+ wildcard style, which is also used by CMD. It allows to specify
filter
+ expressions following the old DOS rules back when only 8+3 filenames
+ existed. Our filter expression only allows the filename itself, plus
+ all files which start with filename, then a dot, then a maximum of
three
+ characters. This fortunately avoids the usage of the '*' wildcard
which
+ could easily become a PITA in some directories... */
+ filter = basename;
+ if (!*ext_here && suff.count() > 0)
+ RtlAppendUnicodeToString (&filter, L"\">>>"); /* DOS_DOT, 3 * DOS_QM */
+
+ bool found = false;
+ int suff_idx = -1;
+ PUNICODE_STRING fname = NULL;
+ file_info fi (fs, tp.w_get (), USHRT_MAX);
+
+ /* Now call NtQueryDirectoryFile until we find the file or there is
no more
+ file. */
+ for (BOOLEAN restart = TRUE; !found; restart = FALSE)
+ {
+ status = NtQueryDirectoryFile (dh, NULL, NULL, NULL, &io, fi, fi, fi,
+ FALSE, &filter, restart);
+ if (!NT_SUCCESS (status))
+ break;
+ while (fi.next ())
+ {
+ fname = fi.name ();
+ /* This expression *only* allows the filename itself, or any
+ suffix with exactly three chars. */
+ if (fname->Length != basename.Length
+ && fname->Length != basename.Length + 4 * sizeof (WCHAR))
+ continue;
+ /* Even if the directory handle has been opened case-sensitive,
+ the filter expression is *always* evaluated case-insensitive.
+ That means, if case-sensitivity is switched on, we have to
+ check that the returned filename matches the case of our
+ incoming filename. Grrr! */
+ if (!ci_flag && !RtlEqualUnicodePathPrefix (fname, &basename, FALSE))
+ continue;
+ if (fname->Length == basename.Length
+ || (suff_idx = suff.check (fname)) >= 0)
+ {
+ /* Yeah! */
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ set_error (ENOENT);
+ else
+ {
+ HANDLE fh;
+
+ /* Append suffix (if any) to the incoming path buffer. */
+ if (suff_idx >= 0)
+ {
+ sys_wcstombs (ext_here, 5, suff.get (suff_idx));
+ ext_tacked_on = true;
+ }
+ if (fs.is_nfs ())
+ {
+ /* On NFS, we need the real stat info. So, given that we
+ have to open the file anyway, this method is slower than
+ symlink_info::check on NFS! Something to keep in mind. */
+ fileattr = 0;
+ InitializeObjectAttributes (&attr, fname, ci_flag, dh, NULL);
+ status = NtCreateFile (&fh, FILE_READ_EA, &attr, &io, NULL, 0,
+ FILE_SHARE_VALID_FLAGS, FILE_OPEN,
+ FILE_OPEN_FOR_BACKUP_INTENT,
+ &nfs_aol_ffei, sizeof nfs_aol_ffei);
+ if (!NT_SUCCESS (status))
+ {
+ set_error_from_nt_status (status);
+ goto out;
+ }
+ status = nfs_fetch_fattr3 (fh, conv_hdl.nfsattr ());
+ if (NT_SUCCESS (status))
+ {
+ if ((conv_hdl.nfsattr ()->type & 7) == NF3DIR)
+ {
+ if (ext_tacked_on)
+ {
+ fileattr = INVALID_FILE_ATTRIBUTES;
+ set_error (ENOENT);
+ }
+ else
+ fileattr = FILE_ATTRIBUTE_DIRECTORY;
+ }
+ /* Eventually, check for symlink. */
+ else if ((conv_hdl.nfsattr ()->type & 7) == NF3LNK)
+ res = check_nfs_symlink (fh);
+ }
+ NtClose (fh);
+ }
+ else
+ {
+ PFILE_CYGWIN_INFORMATION pfci;
+
+ /* Copy file info over to path_conv. */
+ fileattr = fi.file_attributes ();
+ if (ext_tacked_on && (fileattr & FILE_ATTRIBUTE_DIRECTORY))
+ {
+ set_error (ENOENT);
+ fileattr = INVALID_FILE_ATTRIBUTES;
+ goto out;
+ }
+ fi.copy (pfci = conv_hdl.finfo (), &dirname, fname);
+ /* Eventually, check for various symlink types. */
+ if ((fileattr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY))
+ == FILE_ATTRIBUTE_READONLY && suff.lnk_match (suff_idx))
+ {
+ InitializeObjectAttributes (&attr, fname, ci_flag, dh, NULL);
+ status = NtOpenFile (&fh, SYNCHRONIZE | GENERIC_READ, &attr,
+ &io, FILE_SHARE_VALID_FLAGS,
+ FILE_OPEN_FOR_BACKUP_INTENT);
+ if (!NT_SUCCESS (status))
+ goto out;
+ res = check_shortcut (fh);
+ if (!res)
+ {
+ if (ext_tacked_on)
+ {
+ fileattr = INVALID_FILE_ATTRIBUTES;
+ set_error (ENOENT);
+ }
+ }
+ else if (contents[0] != ':' || contents[1] != '\\')
+ parse_device (contents);
+ NtClose (fh);
+ }
+ else if (suff.lnk_match (suff_idx))
+ {
+ set_error (ENOENT);
+ fileattr = INVALID_FILE_ATTRIBUTES;
+ goto out;
+ }
+ else if ((fileattr & FILE_ATTRIBUTE_REPARSE_POINT)
+ && !fs.is_remote_drive())
+ {
+ if (pfci->ReparseTag != IO_REPARSE_TAG_SYMLINK
+ && pfci->ReparseTag != IO_REPARSE_TAG_MOUNT_POINT)
+ {
+ fileattr &= ~FILE_ATTRIBUTE_REPARSE_POINT;
+ goto out;
+ }
+ InitializeObjectAttributes (&attr, fname, ci_flag, dh, NULL);
+ status = NtOpenFile (&fh, READ_CONTROL, &attr, &io,
+ FILE_SHARE_VALID_FLAGS,
+ FILE_OPEN_REPARSE_POINT
+ | FILE_OPEN_FOR_BACKUP_INTENT);
+ if (!NT_SUCCESS (status))
+ {
+ fileattr &= ~FILE_ATTRIBUTE_REPARSE_POINT;
+ goto out;
+ }
+ res = check_reparse_point (fh);
+ if (res == -1)
+ {
+ fs.update (&upath, NULL);
+ res = 0;
+ }
+ else if (res)
+ conv_hdl.finfo ()->FileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY;
+ NtClose (fh);
+ }
+ else if ((fileattr & (FILE_ATTRIBUTE_SYSTEM
+ | FILE_ATTRIBUTE_DIRECTORY))
+ == FILE_ATTRIBUTE_SYSTEM)
+ {
+ InitializeObjectAttributes (&attr, fname, ci_flag, dh, NULL);
+ status = NtOpenFile (&fh, SYNCHRONIZE | GENERIC_READ, &attr,
+ &io, FILE_SHARE_VALID_FLAGS,
+ FILE_OPEN_FOR_BACKUP_INTENT);
+ if (!NT_SUCCESS (status))
+ goto out;
+ res = check_sysfile (fh);
+ NtClose (fh);
+ }
+ }
+ }
+
+out:
+ NtClose (dh);
+ syscall_printf ("%d = symlink.xcheck (%s, %p) (%p)",
+ res, path, contents, pflags);
+ issymlink = res > 0;
+ return res;
+}
+
+int
symlink_info::check (char *path, const suffix_info *suffixes, fs_info &fs,
path_conv_handle &conv_hdl)
{
@@ -2386,9 +2898,9 @@ restart:
}
else
{
- PFILE_NETWORK_OPEN_INFORMATION pfnoi = conv_hdl.fnoi ();
+ PFILE_CYGWIN_INFORMATION pfci = conv_hdl.finfo ();
- status = NtQueryInformationFile (h, &io, pfnoi, sizeof *pfnoi,
+ status = NtQueryInformationFile (h, &io, pfci, sizeof *pfci,
FileNetworkOpenInformation);
if ((status == STATUS_INVALID_PARAMETER
|| status == STATUS_NOT_IMPLEMENTED)
@@ -2403,14 +2915,16 @@ restart:
FileBasicInformation);
if (NT_SUCCESS (status))
{
- memcpy (pfnoi, &fbi, 4 * sizeof (LARGE_INTEGER));
- pfnoi->EndOfFile.QuadPart
- = pfnoi->AllocationSize.QuadPart = 0;
- pfnoi->FileAttributes = fbi.FileAttributes;
+ memcpy (pfci, &fbi, 4 * sizeof (LARGE_INTEGER));
+ pfci->EndOfFile.QuadPart
+ = pfci->AllocationSize.QuadPart = 0;
+ pfci->FileAttributes = fbi.FileAttributes;
}
}
+ pfci->ReparseTag = 0;
+ pfci->FileId.QuadPart = 0;
if (NT_SUCCESS (status))
- fileattr = pfnoi->FileAttributes;
+ fileattr = pfci->FileAttributes;
}
}
if (!NT_SUCCESS (status))
@@ -2500,18 +3014,22 @@ restart:
}
else
{
- PFILE_NETWORK_OPEN_INFORMATION pfnoi = conv_hdl.fnoi ();
+ PFILE_CYGWIN_INFORMATION pfci = conv_hdl.finfo ();
fileattr = fdi_buf.fdi.FileAttributes;
- memcpy (pfnoi, &fdi_buf.fdi.CreationTime, sizeof *pfnoi);
+ memcpy (pfci, &fdi_buf.fdi.CreationTime,
+ 4 * sizeof (LARGE_INTEGER));
/* Amazing, but true: The FILE_NETWORK_OPEN_INFORMATION
structure has the AllocationSize and EndOfFile members
interchanged relative to the directory information
classes. */
- pfnoi->AllocationSize.QuadPart
+ pfci->AllocationSize.QuadPart
= fdi_buf.fdi.AllocationSize.QuadPart;
- pfnoi->EndOfFile.QuadPart
+ pfci->EndOfFile.QuadPart
= fdi_buf.fdi.EndOfFile.QuadPart;
+ pfci->FileAttributes = fdi_buf.fdi.FileAttributes;
+ pfci->ReparseTag = fdi_buf.fdi.EaSize;
+ pfci->FileId.QuadPart = 0;
}
}
ext_tacked_on = !!*ext_here;
@@ -2567,7 +3085,7 @@ restart:
else if (res)
{
/* A symlink is never a directory. */
- conv_hdl.fnoi ()->FileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY;
+ conv_hdl.finfo ()->FileAttributes &= ~FILE_ATTRIBUTE_DIRECTORY;
break;
}
}
Index: path.h
===================================================================
RCS file: /cvs/src/src/winsup/cygwin/path.h,v
retrieving revision 1.152
diff -u -p -r1.152 path.h
--- path.h 7 Oct 2010 14:03:26 -0000 1.152
+++ path.h 10 Oct 2010 14:09:52 -0000
@@ -59,6 +59,7 @@ enum pathconv_arg
PC_NULLEMPTY = 0x0020,
PC_POSIX = 0x0080,
PC_NOWARN = 0x0100,
+ PC_XCHECK = 0x00200000,
PC_KEEP_HANDLE = 0x00400000,
PC_NO_ACCESS_CHECK = 0x00800000
};
@@ -86,27 +87,29 @@ enum path_types
PATH_TEXT = 0x02000000,
PATH_REP = 0x04000000,
PATH_HAS_SYMLINKS = 0x10000000,
+ PATH_XCHECKED = 0x20000000,
PATH_SOCKET = 0x40000000
};
class symlink_info;
-struct _FILE_NETWORK_OPEN_INFORMATION;
+
+typedef struct _FILE_CYGWIN_INFORMATION
+{
+ LARGE_INTEGER CreationTime;
+ LARGE_INTEGER LastAccessTime;
+ LARGE_INTEGER LastWriteTime;
+ LARGE_INTEGER ChangeTime;
+ LARGE_INTEGER AllocationSize;
+ LARGE_INTEGER EndOfFile;
+ ULONG FileAttributes;
+ ULONG ReparseTag;
+ LARGE_INTEGER FileId;
+} FILE_CYGWIN_INFORMATION, *PFILE_CYGWIN_INFORMATION;
class path_conv_handle
{
HANDLE hdl;
union {
- /* Identical to FILE_NETWORK_OPEN_INFORMATION. We don't want to
pull in
- ntdll.h here, though. */
- struct {
- LARGE_INTEGER CreationTime;
- LARGE_INTEGER LastAccessTime;
- LARGE_INTEGER LastWriteTime;
- LARGE_INTEGER ChangeTime;
- LARGE_INTEGER AllocationSize;
- LARGE_INTEGER EndOfFile;
- ULONG FileAttributes;
- } _fnoi;
+ FILE_CYGWIN_INFORMATION fci;
/* For NFS. */
fattr3 _fattr3;
} attribs;
@@ -127,8 +130,8 @@ public:
hdl = NULL;
}
inline HANDLE handle () const { return hdl; }
- inline struct _FILE_NETWORK_OPEN_INFORMATION *fnoi ()
- { return (struct _FILE_NETWORK_OPEN_INFORMATION *) &attribs._fnoi; }
+ inline PFILE_CYGWIN_INFORMATION finfo ()
+ { return (PFILE_CYGWIN_INFORMATION) &attribs.fci; }
inline struct fattr3 *nfsattr ()
{ return (struct fattr3 *) &attribs._fattr3; }
};
@@ -170,6 +173,7 @@ class path_conv
return O_TEXT;
return 0;
}
+ int xchecked () const { return path_flags & PATH_XCHECKED; }
int issymlink () const {return path_flags & PATH_SYMLINK;}
int is_lnk_symlink () const {return path_flags & PATH_LNK;}
int is_rep_symlink () const {return path_flags & PATH_REP;}
@@ -320,7 +324,7 @@ class path_conv
bool is_binary ();
HANDLE handle () const { return conv_handle.handle (); }
- struct _FILE_NETWORK_OPEN_INFORMATION *fnoi () { return
conv_handle.fnoi (); }
+ PFILE_CYGWIN_INFORMATION finfo () { return conv_handle.finfo (); }
struct fattr3 *nfsattr () { return conv_handle.nfsattr (); }
void reset_conv_handle () { conv_handle.set (NULL); }
void close_conv_handle () { conv_handle.close (); }