diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog index 33b3df380..a275a960a 100644 --- a/winsup/cygwin/ChangeLog +++ b/winsup/cygwin/ChangeLog @@ -1,3 +1,21 @@ +2003-03-09 Christopher Faylor + + Do some minor reformatting of 'extern "C"' use throughout. + +2003-03-06 Christopher January + + * autoload.cc (GetSystemTimes): Define new autoload function. + * fhandler_proc.cc (proc_listing): Add cpuinfo and partitions entries. + (fhandler_proc::fill_filebuf): Add PROC_CPUINFO and PROC_PARTITIONS + cases. + (format_proc_uptime): Use GetSystemTimes if available. + (read_value): New macro. + (print): New macro. + (cpuid): New function. + (can_set_flag): New function. + (format_proc_cpuinfo): New function. + (format_proc_partitions): New function. + 2003-03-09 Christopher Faylor * syscalls.cc (unlink): Attempt to be more clever about setting diff --git a/winsup/cygwin/autoload.cc b/winsup/cygwin/autoload.cc index b29c9d269..659ca2be2 100644 --- a/winsup/cygwin/autoload.cc +++ b/winsup/cygwin/autoload.cc @@ -501,6 +501,7 @@ LoadDLLfuncEx (CreateHardLinkA, 12, kernel32, 1) LoadDLLfuncEx (CreateToolhelp32Snapshot, 8, kernel32, 1) LoadDLLfuncEx2 (GetCompressedFileSizeA, 8, kernel32, 1, 0xffffffff) LoadDLLfuncEx (GetConsoleWindow, 0, kernel32, 1) +LoadDLLfuncEx (GetSystemTimes, 12, kernel32, 1) LoadDLLfuncEx2 (IsDebuggerPresent, 0, kernel32, 1, 1) LoadDLLfuncEx (Process32First, 8, kernel32, 1) LoadDLLfuncEx (Process32Next, 8, kernel32, 1) diff --git a/winsup/cygwin/fcntl.cc b/winsup/cygwin/fcntl.cc index 0ba704991..f67f43f6c 100644 --- a/winsup/cygwin/fcntl.cc +++ b/winsup/cygwin/fcntl.cc @@ -20,8 +20,7 @@ details. */ #include "cygheap.h" #include "thread.h" -extern "C" -int +extern "C" int _fcntl (int fd, int cmd,...) { void *arg = NULL; diff --git a/winsup/cygwin/fhandler_proc.cc b/winsup/cygwin/fhandler_proc.cc index ebdeedd0b..d819a17cc 100644 --- a/winsup/cygwin/fhandler_proc.cc +++ b/winsup/cygwin/fhandler_proc.cc @@ -8,6 +8,8 @@ This software is a copyrighted work licensed under the terms of the Cygwin license. Please consult the file "CYGWIN_LICENSE" for details. */ +#define _WIN32_WINNT 0x0501 + #include "winsup.h" #include #include @@ -25,6 +27,7 @@ details. */ #include #include #include "ntdll.h" +#include #define _COMPILING_NEWLIB #include @@ -36,6 +39,8 @@ static const int PROC_REGISTRY = 4; // /proc/registry static const int PROC_STAT = 5; // /proc/stat static const int PROC_VERSION = 6; // /proc/version static const int PROC_UPTIME = 7; // /proc/uptime +static const int PROC_CPUINFO = 8; // /proc/cpuinfo +static const int PROC_PARTITIONS = 9; // /proc/partitions /* names of objects in /proc */ static const char *proc_listing[] = { @@ -47,6 +52,8 @@ static const char *proc_listing[] = { "stat", "version", "uptime", + "cpuinfo", + "partitions", NULL }; @@ -63,7 +70,9 @@ static const DWORD proc_fhandlers[PROC_LINK_COUNT] = { FH_REGISTRY, FH_PROC, FH_PROC, - FH_PROC + FH_PROC, + FH_PROC, + FH_PROC, }; /* name of the /proc filesystem */ @@ -73,20 +82,20 @@ const int proc_len = sizeof (proc) - 1; static __off64_t format_proc_meminfo (char *destbuf, size_t maxsize); static __off64_t format_proc_stat (char *destbuf, size_t maxsize); static __off64_t format_proc_uptime (char *destbuf, size_t maxsize); +static __off64_t format_proc_cpuinfo (char *destbuf, size_t maxsize); +static __off64_t format_proc_partitions (char *destbuf, size_t maxsize); -/* auxillary function that returns the fhandler associated with the given path - * this is where it would be nice to have pattern matching in C - polymorphism - * just doesn't cut it - */ +/* Auxillary function that returns the fhandler associated with the given path + this is where it would be nice to have pattern matching in C - polymorphism + just doesn't cut it. */ DWORD fhandler_proc::get_proc_fhandler (const char *path) { debug_printf ("get_proc_fhandler(%s)", path); path += proc_len; /* Since this method is called from path_conv::check we can't rely on - * it being normalised and therefore the path may have runs of slashes - * in it. - */ + it being normalised and therefore the path may have runs of slashes + in it. */ while (isdirsep (*path)) path++; @@ -121,8 +130,7 @@ fhandler_proc::get_proc_fhandler (const char *path) } /* Returns 0 if path doesn't exist, >0 if path is a directory, - * <0 if path is a file. - */ + <0 if path is a file. */ int fhandler_proc::exists () { @@ -363,6 +371,18 @@ fhandler_proc::fill_filebuf () filesize = format_proc_meminfo (filebuf, bufalloc); break; } + case PROC_CPUINFO: + { + filebuf = (char *) realloc (filebuf, bufalloc = 16384); + filesize = format_proc_cpuinfo (filebuf, bufalloc); + break; + } + case PROC_PARTITIONS: + { + filebuf = (char *) realloc (filebuf, bufalloc = 4096); + filesize = format_proc_partitions (filebuf, bufalloc); + break; + } } return true; } @@ -403,24 +423,30 @@ format_proc_uptime (char *destbuf, size_t maxsize) unsigned long long uptime = 0ULL, idle_time = 0ULL; SYSTEM_PROCESSOR_TIMES spt; - NTSTATUS ret = NtQuerySystemInformation (SystemProcessorTimes, (PVOID) &spt, - sizeof spt, NULL); - if (!ret && GetLastError () == ERROR_PROC_NOT_FOUND) - uptime = GetTickCount () / 10; - else if (ret != STATUS_SUCCESS) + if (!GetSystemTimes ((FILETIME *) &spt.IdleTime, (FILETIME *) &spt.KernelTime, + (FILETIME *) &spt.UserTime) + && GetLastError () == ERROR_PROC_NOT_FOUND) { - __seterrno_from_win_error (RtlNtStatusToDosError (ret)); - debug_printf("NtQuerySystemInformation: ret = %d, " - "Dos(ret) = %d", - ret, RtlNtStatusToDosError (ret)); - return 0; - } - else - { - idle_time = spt.IdleTime.QuadPart / 100000ULL; - uptime = (spt.KernelTime.QuadPart + - spt.UserTime.QuadPart) / 100000ULL; + NTSTATUS ret = NtQuerySystemInformation (SystemProcessorTimes, (PVOID) &spt, + sizeof spt, NULL); + if (!ret && GetLastError () == ERROR_PROC_NOT_FOUND) + { + uptime = GetTickCount () / 10; + goto out; + } + else if (ret != STATUS_SUCCESS) + { + __seterrno_from_win_error (RtlNtStatusToDosError (ret)); + debug_printf("NtQuerySystemInformation: ret = %d, " + "Dos(ret) = %d", + ret, RtlNtStatusToDosError (ret)); + return 0; + } } + idle_time = spt.IdleTime.QuadPart / 100000ULL; + uptime = (spt.KernelTime.QuadPart + + spt.UserTime.QuadPart) / 100000ULL; +out: return __small_sprintf (destbuf, "%U.%02u %U.%02u\n", uptime / 100, long (uptime % 100), @@ -500,3 +526,398 @@ format_proc_stat (char *destbuf, size_t maxsize) context_switches, boot_time); } + +#define read_value(x,y) \ + do {\ + dwCount = BUFSIZE; \ + if ((dwError = RegQueryValueEx (hKey, x, NULL, &dwType, (BYTE *) szBuffer, &dwCount)), \ + (dwError != ERROR_SUCCESS && dwError != ERROR_MORE_DATA)) \ + { \ + __seterrno_from_win_error (dwError); \ + debug_printf ("RegQueryValueEx failed retcode %d", dwError); \ + return 0; \ + } \ + if (dwType != y) \ + { \ + debug_printf ("Value %s had an unexpected type (expected %d, found %d)", y, dwType); \ + return 0; \ + }\ + } while (0) + +#define print(x) \ + do { \ + strcpy (bufptr, x), \ + bufptr += sizeof (x) - 1; \ + } while (0) + +static inline void +cpuid (unsigned *a, unsigned *b, unsigned *c, unsigned *d, unsigned in) +{ + asm ("cpuid" + : "=a" (*a), + "=b" (*b), + "=c" (*c), + "=d" (*d) + : "a" (in)); +} + +static inline bool +can_set_flag (unsigned flag) +{ + unsigned r1, r2; + asm("pushfl\n" + "popl %0\n" + "movl %0, %1\n" + "xorl %2, %0\n" + "pushl %0\n" + "popfl\n" + "pushfl\n" + "popl %0\n" + "pushl %1\n" + "popfl\n" + : "=&r" (r1), "=&r" (r2) + : "ir" (flag) + ); + return ((r1 ^ r2) & flag) != 0; +} + +static __off64_t +format_proc_cpuinfo (char *destbuf, size_t maxsize) +{ + SYSTEM_INFO siSystemInfo; + HKEY hKey; + DWORD dwError, dwCount, dwType; + DWORD dwOldThreadAffinityMask; + int cpu_number; + const int BUFSIZE = 256; + CHAR szBuffer[BUFSIZE]; + char *bufptr = destbuf; + + GetSystemInfo (&siSystemInfo); + + for (cpu_number = 0;;cpu_number++) + { + __small_sprintf (szBuffer, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\%d", cpu_number); + + if ((dwError = RegOpenKeyEx (HKEY_LOCAL_MACHINE, szBuffer, 0, KEY_QUERY_VALUE, &hKey)) != ERROR_SUCCESS) + { + if (dwError == ERROR_FILE_NOT_FOUND) + break; + __seterrno_from_win_error (dwError); + debug_printf ("RegOpenKeyEx failed retcode %d", dwError); + return 0; + } + + dwOldThreadAffinityMask = SetThreadAffinityMask (GetCurrentThread (), 1 << cpu_number); + if (dwOldThreadAffinityMask == 0) + debug_printf ("SetThreadAffinityMask failed %E"); + // I'm not sure whether the thread changes processor immediately + // and I'm not sure whether this function will cause the thread to be rescheduled + low_priority_sleep (0); + + bool has_cpuid = false; + + if (!can_set_flag (0x00040000)) + debug_printf ("386 processor - no cpuid"); + else + { + debug_printf ("486 processor"); + if (can_set_flag (0x00200000)) + { + debug_printf ("processor supports CPUID instruction"); + has_cpuid = true; + } + else + debug_printf ("processor does not support CPUID instruction"); + } + + if (!has_cpuid) + { + bufptr += __small_sprintf (bufptr, "processor : %d\n", cpu_number); + read_value ("VendorIdentifier", REG_SZ); + bufptr += __small_sprintf (bufptr, "vendor id : %s\n", szBuffer); + read_value ("Identifier", REG_SZ); + bufptr += __small_sprintf (bufptr, "identifier : %s\n", szBuffer); + read_value ("~Mhz", REG_DWORD); + bufptr += __small_sprintf (bufptr, "cpu MHz : %u\n", *(DWORD *) szBuffer); + + print ("flags :"); + if (IsProcessorFeaturePresent (PF_3DNOW_INSTRUCTIONS_AVAILABLE)) + print (" 3dnow"); + if (IsProcessorFeaturePresent (PF_COMPARE_EXCHANGE_DOUBLE)) + print (" cx8"); + if (!IsProcessorFeaturePresent (PF_FLOATING_POINT_EMULATED)) + print (" fpu"); + if (IsProcessorFeaturePresent (PF_MMX_INSTRUCTIONS_AVAILABLE)) + print (" mmx"); + if (IsProcessorFeaturePresent (PF_PAE_ENABLED)) + print (" pae"); + if (IsProcessorFeaturePresent (PF_RDTSC_INSTRUCTION_AVAILABLE)) + print (" tsc"); + if (IsProcessorFeaturePresent (PF_XMMI_INSTRUCTIONS_AVAILABLE)) + print (" sse"); + if (IsProcessorFeaturePresent (PF_XMMI64_INSTRUCTIONS_AVAILABLE)) + print (" sse2"); + } + else + { + bufptr += __small_sprintf (bufptr, "processor : %d\n", cpu_number); + unsigned maxf, vendor_id[4], unused; + cpuid (&maxf, &vendor_id[0], &vendor_id[1], &vendor_id[2], 0); + maxf &= 0xffff; + vendor_id[3] = 0; + bufptr += __small_sprintf (bufptr, "vendor id : %s\n", (char *)vendor_id); + read_value ("~Mhz", REG_DWORD); + unsigned cpu_mhz = *(DWORD *)szBuffer; + if (maxf >= 1) + { + unsigned features2, features1, extra_info, cpuid_sig; + cpuid (&cpuid_sig, &extra_info, &features2, &features1, 1); + /* unsigned extended_family = (cpuid_sig & 0x0ff00000) >> 20, + extended_model = (cpuid_sig & 0x000f0000) >> 16; */ + unsigned type = (cpuid_sig & 0x00003000) >> 12, + family = (cpuid_sig & 0x00000f00) >> 8, + model = (cpuid_sig & 0x000000f0) >> 4, + stepping = cpuid_sig & 0x0000000f; + unsigned brand_id = extra_info & 0x0000000f, + cpu_count = (extra_info & 0x00ff0000) >> 16, + apic_id = (extra_info & 0xff000000) >> 24; + const char *type_str; + switch (type) + { + case 0: + type_str = "primary processor"; + break; + case 1: + type_str = "overdrive processor"; + break; + case 2: + type_str = "secondary processor"; + break; + case 3: + default: + type_str = "reserved"; + break; + } + unsigned maxe = 0; + cpuid (&maxe, &unused, &unused, &unused, 0x80000000); + if (maxe >= 0x80000004) + { + unsigned *model_name = (unsigned *) szBuffer; + cpuid (&model_name[0], &model_name[1], &model_name[2], &model_name[3], 0x80000002); + cpuid (&model_name[4], &model_name[5], &model_name[6], &model_name[7], 0x80000003); + cpuid (&model_name[8], &model_name[9], &model_name[10], &model_name[11], 0x80000004); + model_name[12] = 0; + } + else + { + // could implement a lookup table here if someone needs it + strcpy (szBuffer, "unknown"); + } + bufptr += __small_sprintf (bufptr, "type : %s\n" + "cpu family : %d\n" + "model : %d\n" + "model name : %s\n" + "stepping : %d\n" + "brand id : %d\n" + "cpu count : %d\n" + "apic id : %d\n" + "cpu MHz : %d\n" + "fpu : %s\n", + type_str, + family, + model, + szBuffer, + stepping, + brand_id, + cpu_count, + apic_id, + cpu_mhz, + IsProcessorFeaturePresent (PF_FLOATING_POINT_EMULATED) ? "no" : "yes"); + print ("flags :"); + if (features1 & (1 << 0)) + print (" fpu"); + if (features1 & (1 << 1)) + print (" vme"); + if (features1 & (1 << 2)) + print (" de"); + if (features1 & (1 << 3)) + print (" pse"); + if (features1 & (1 << 4)) + print (" tsc"); + if (features1 & (1 << 5)) + print (" msr"); + if (features1 & (1 << 6)) + print (" pae"); + if (features1 & (1 << 7)) + print (" mce"); + if (features1 & (1 << 8)) + print (" cx8"); + if (features1 & (1 << 9)) + print (" apic"); + if (features1 & (1 << 11)) + print (" sep"); + if (features1 & (1 << 12)) + print (" mtrr"); + if (features1 & (1 << 13)) + print (" pge"); + if (features1 & (1 << 14)) + print (" mca"); + if (features1 & (1 << 15)) + print (" cmov"); + if (features1 & (1 << 16)) + print (" pat"); + if (features1 & (1 << 17)) + print (" pse36"); + if (features1 & (1 << 18)) + print (" psn"); + if (features1 & (1 << 19)) + print (" clfl"); + if (features1 & (1 << 21)) + print (" dtes"); + if (features1 & (1 << 22)) + print (" acpi"); + if (features1 & (1 << 23)) + print (" mmx"); + if (features1 & (1 << 24)) + print (" fxsr"); + if (features1 & (1 << 25)) + print (" sse"); + if (features1 & (1 << 26)) + print (" sse2"); + if (features1 & (1 << 27)) + print (" ss"); + if (features1 & (1 << 28)) + print (" htt"); + if (features1 & (1 << 29)) + print (" tmi"); + if (features1 & (1 << 30)) + print (" ia-64"); + if (features1 & (1 << 31)) + print (" pbe"); + if (features2 & (1 << 0)) + print (" sse3"); + if (features2 & (1 << 3)) + print (" mon"); + if (features2 & (1 << 4)) + print (" dscpl"); + if (features2 & (1 << 8)) + print (" tm2"); + if (features2 & (1 << 10)) + print (" cid"); + } + else + { + bufptr += __small_sprintf (bufptr, "cpu MHz : %d\n" + "fpu : %s\n", + cpu_mhz, + IsProcessorFeaturePresent (PF_FLOATING_POINT_EMULATED) ? "no" : "yes"); + } + } + if (dwOldThreadAffinityMask != 0) + SetThreadAffinityMask (GetCurrentThread (), dwOldThreadAffinityMask); + + RegCloseKey (hKey); + bufptr += __small_sprintf (bufptr, "\n"); + } + + return bufptr - destbuf; +} + +#undef read_value + +static __off64_t +format_proc_partitions (char *destbuf, size_t maxsize) +{ + char *bufptr = destbuf; + print ("major minor #blocks name\n\n"); + + if (wincap.is_winnt ()) + { + for (int drive_number=0;;drive_number++) + { + CHAR szDriveName[MAX_PATH]; + __small_sprintf (szDriveName, "\\\\.\\PHYSICALDRIVE%d", drive_number); + HANDLE hDevice; + hDevice = CreateFile (szDriveName, + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (hDevice == INVALID_HANDLE_VALUE) + { + if (GetLastError () == ERROR_PATH_NOT_FOUND) + break; + __seterrno (); + debug_printf ("CreateFile %d %E", GetLastError ()); + break; + } + else + { + DWORD dwBytesReturned, dwRetCode; + DISK_GEOMETRY dg; + int buf_size = 4096; + char buf[buf_size]; + dwRetCode = DeviceIoControl (hDevice, + IOCTL_DISK_GET_DRIVE_GEOMETRY, + NULL, + 0, + &dg, + sizeof (dg), + &dwBytesReturned, + NULL); + if (!dwRetCode) + debug_printf ("DeviceIoControl %E"); + else + { + bufptr += __small_sprintf (bufptr, "%5d %5d %9U sd%c\n", + FH_FLOPPY, + drive_number * 16 + 32, + (long long)((dg.Cylinders.QuadPart * dg.TracksPerCylinder * + dg.SectorsPerTrack * dg.BytesPerSector) >> 6), + drive_number + 'a'); + } + while (dwRetCode = DeviceIoControl (hDevice, + IOCTL_DISK_GET_DRIVE_LAYOUT, + NULL, + 0, + (DRIVE_LAYOUT_INFORMATION *) buf, + buf_size, + &dwBytesReturned, + NULL), + !dwRetCode && GetLastError () == ERROR_INSUFFICIENT_BUFFER) + buf_size *= 2; + if (!dwRetCode) + debug_printf ("DeviceIoControl %E"); + else + { + DRIVE_LAYOUT_INFORMATION *dli = (DRIVE_LAYOUT_INFORMATION *) buf; + for (unsigned partition = 0; partition < dli->PartitionCount; partition++) + { + if (dli->PartitionEntry[partition].PartitionLength.QuadPart == 0) + continue; + bufptr += __small_sprintf (bufptr, "%5d %5d %9U sd%c%d\n", + FH_FLOPPY, + drive_number * 16 + partition + 33, + (long long)(dli->PartitionEntry[partition].PartitionLength.QuadPart >> 6), + drive_number + 'a', + partition + 1); + } + } + + CloseHandle (hDevice); + } + } + } + else + { + // not worth the effort + // you need a 16 bit thunk DLL to access the partition table on Win9x + // and then you have to decode it yourself + } + return bufptr - destbuf; +} + +#undef print diff --git a/winsup/cygwin/mmap.cc b/winsup/cygwin/mmap.cc index 6a300962e..27b525a39 100644 --- a/winsup/cygwin/mmap.cc +++ b/winsup/cygwin/mmap.cc @@ -421,8 +421,7 @@ map::erase (int i) static map *mmapped_areas; -extern "C" -caddr_t +extern "C" caddr_t mmap64 (caddr_t addr, size_t len, int prot, int flags, int fd, __off64_t off) { syscall_printf ("addr %x, len %d, prot %x, flags %x, fd %d, off %D", @@ -583,8 +582,7 @@ mmap64 (caddr_t addr, size_t len, int prot, int flags, int fd, __off64_t off) return ret; } -extern "C" -caddr_t +extern "C" caddr_t mmap (caddr_t addr, size_t len, int prot, int flags, int fd, __off32_t off) { return mmap64 (addr, len, prot, flags, fd, (__off64_t)off); @@ -593,8 +591,7 @@ mmap (caddr_t addr, size_t len, int prot, int flags, int fd, __off32_t off) /* munmap () removes an mmapped area. It insists that base area requested is the same as that mmapped, error if not. */ -extern "C" -int +extern "C" int munmap (caddr_t addr, size_t len) { syscall_printf ("munmap (addr %x, len %d)", addr, len); @@ -654,8 +651,7 @@ munmap (caddr_t addr, size_t len) /* Sync file with memory. Ignore flags for now. */ -extern "C" -int +extern "C" int msync (caddr_t addr, size_t len, int flags) { syscall_printf ("addr = %x, len = %d, flags = %x", @@ -878,8 +874,7 @@ fhandler_disk_file::fixup_mmap_after_fork (HANDLE h, DWORD access, DWORD offset, /* Set memory protection */ -extern "C" -int +extern "C" int mprotect (caddr_t addr, size_t len, int prot) { DWORD old_prot; diff --git a/winsup/cygwin/ntea.cc b/winsup/cygwin/ntea.cc index 95b5444a3..7ddff7770 100644 --- a/winsup/cygwin/ntea.cc +++ b/winsup/cygwin/ntea.cc @@ -142,8 +142,7 @@ NTReadEA (const char *file, const char *attrname, char *attrbuf, int len) * pointer to buffer with file's EAs, or NULL if any error occured. */ -static -PFILE_FULL_EA_INFORMATION +static PFILE_FULL_EA_INFORMATION NTReadEARaw (HANDLE hFileSource, int *len) { WIN32_STREAM_ID StreamId; diff --git a/winsup/cygwin/poll.cc b/winsup/cygwin/poll.cc index 4e3028fff..e12ed969d 100644 --- a/winsup/cygwin/poll.cc +++ b/winsup/cygwin/poll.cc @@ -26,8 +26,7 @@ #include "cygheap.h" #include "sigproc.h" -extern "C" -int +extern "C" int poll (struct pollfd *fds, unsigned int nfds, int timeout) { int max_fd = 0; diff --git a/winsup/cygwin/sec_acl.cc b/winsup/cygwin/sec_acl.cc index 3a9f08b55..8863da1f2 100644 --- a/winsup/cygwin/sec_acl.cc +++ b/winsup/cygwin/sec_acl.cc @@ -413,8 +413,7 @@ getacl (const char *file, DWORD attr, int nentries, __aclent32_t *aclbufp) return pos; } -static -int +static int acl_worker (const char *path, int cmd, int nentries, __aclent32_t *aclbufp, int nofollow) { @@ -493,22 +492,19 @@ acl_worker (const char *path, int cmd, int nentries, __aclent32_t *aclbufp, return -1; } -extern "C" -int +extern "C" int acl32 (const char *path, int cmd, int nentries, __aclent32_t *aclbufp) { return acl_worker (path, cmd, nentries, aclbufp, 0); } -extern "C" -int +extern "C" int lacl32 (const char *path, int cmd, int nentries, __aclent32_t *aclbufp) { return acl_worker (path, cmd, nentries, aclbufp, 1); } -extern "C" -int +extern "C" int facl32 (int fd, int cmd, int nentries, __aclent32_t *aclbufp) { cygheap_fdget cfd (fd); @@ -528,8 +524,7 @@ facl32 (int fd, int cmd, int nentries, __aclent32_t *aclbufp) return acl_worker (path, cmd, nentries, aclbufp, 0); } -extern "C" -int +extern "C" int aclcheck32 (__aclent32_t *aclbufp, int nentries, int *which) { BOOL has_user_obj = FALSE; @@ -661,8 +656,8 @@ aclcheck32 (__aclent32_t *aclbufp, int nentries, int *which) return 0; } -static -int acecmp (const void *a1, const void *a2) +static int +acecmp (const void *a1, const void *a2) { #define ace(i) ((const __aclent32_t *) a##i) int ret = ace (1)->a_type - ace (2)->a_type; @@ -672,8 +667,7 @@ int acecmp (const void *a1, const void *a2) #undef ace } -extern "C" -int +extern "C" int aclsort32 (int nentries, int, __aclent32_t *aclbufp) { if (aclcheck32 (aclbufp, nentries, NULL)) @@ -687,8 +681,7 @@ aclsort32 (int nentries, int, __aclent32_t *aclbufp) return 0; } -extern "C" -int +extern "C" int acltomode32 (__aclent32_t *aclbufp, int nentries, mode_t *modep) { int pos; @@ -727,8 +720,7 @@ acltomode32 (__aclent32_t *aclbufp, int nentries, mode_t *modep) return 0; } -extern "C" -int +extern "C" int aclfrommode32 (__aclent32_t *aclbufp, int nentries, mode_t *modep) { int pos; @@ -765,15 +757,13 @@ aclfrommode32 (__aclent32_t *aclbufp, int nentries, mode_t *modep) return 0; } -extern "C" -int +extern "C" int acltopbits32 (__aclent32_t *aclbufp, int nentries, mode_t *pbitsp) { return acltomode32 (aclbufp, nentries, pbitsp); } -extern "C" -int +extern "C" int aclfrompbits32 (__aclent32_t *aclbufp, int nentries, mode_t *pbitsp) { return aclfrommode32 (aclbufp, nentries, pbitsp); @@ -791,8 +781,7 @@ permtostr (mode_t perm) return pbuf; } -extern "C" -char * +extern "C" char * acltotext32 (__aclent32_t *aclbufp, int aclcnt) { if (!aclbufp || aclcnt < 1 || aclcnt > MAX_ACL_ENTRIES @@ -868,8 +857,7 @@ permfromstr (char *perm) return mode; } -extern "C" -__aclent32_t * +extern "C" __aclent32_t * aclfromtext32 (char *acltextp, int *) { if (!acltextp) @@ -992,79 +980,68 @@ acl16to32 (__aclent16_t *aclbufp, int nentries) return aclbufp32; } -extern "C" -int +extern "C" int acl (const char *path, int cmd, int nentries, __aclent16_t *aclbufp) { return acl32 (path, cmd, nentries, acl16to32 (aclbufp, nentries)); } -extern "C" -int +extern "C" int facl (int fd, int cmd, int nentries, __aclent16_t *aclbufp) { return facl32 (fd, cmd, nentries, acl16to32 (aclbufp, nentries)); } -extern "C" -int +extern "C" int lacl (const char *path, int cmd, int nentries, __aclent16_t *aclbufp) { return lacl32 (path, cmd, nentries, acl16to32 (aclbufp, nentries)); } -extern "C" -int +extern "C" int aclcheck (__aclent16_t *aclbufp, int nentries, int *which) { return aclcheck32 (acl16to32 (aclbufp, nentries), nentries, which); } -extern "C" -int +extern "C" int aclsort (int nentries, int i, __aclent16_t *aclbufp) { return aclsort32 (nentries, i, acl16to32 (aclbufp, nentries)); } -extern "C" -int +extern "C" int acltomode (__aclent16_t *aclbufp, int nentries, mode_t *modep) { return acltomode32 (acl16to32 (aclbufp, nentries), nentries, modep); } -extern "C" -int +extern "C" int aclfrommode (__aclent16_t *aclbufp, int nentries, mode_t *modep) { return aclfrommode32 ((__aclent32_t *)aclbufp, nentries, modep); } -extern "C" -int +extern "C" int acltopbits (__aclent16_t *aclbufp, int nentries, mode_t *pbitsp) { return acltopbits32 (acl16to32 (aclbufp, nentries), nentries, pbitsp); } -extern "C" -int +extern "C" int aclfrompbits (__aclent16_t *aclbufp, int nentries, mode_t *pbitsp) { return aclfrompbits32 ((__aclent32_t *)aclbufp, nentries, pbitsp); } -extern "C" -char * +extern "C" char * acltotext (__aclent16_t *aclbufp, int aclcnt) { return acltotext32 (acl16to32 (aclbufp, aclcnt), aclcnt); } -extern "C" -__aclent16_t * +extern "C" __aclent16_t * aclfromtext (char *acltextp, int * aclcnt) { return (__aclent16_t *) aclfromtext32 (acltextp, aclcnt); diff --git a/winsup/cygwin/select.cc b/winsup/cygwin/select.cc index 72919241e..1a9069626 100644 --- a/winsup/cygwin/select.cc +++ b/winsup/cygwin/select.cc @@ -95,8 +95,7 @@ typedef long fd_mask; /* The main select code. */ -extern "C" -int +extern "C" int cygwin_select (int maxfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *to) { diff --git a/winsup/cygwin/strsep.cc b/winsup/cygwin/strsep.cc index 0a421f6e1..f03df3d94 100644 --- a/winsup/cygwin/strsep.cc +++ b/winsup/cygwin/strsep.cc @@ -35,8 +35,7 @@ * SUCH DAMAGE. */ -extern "C" -char * +extern "C" char * strsep (char **stringp, const char *delim) { diff --git a/winsup/cygwin/syslog.cc b/winsup/cygwin/syslog.cc index 1d1ffd0e7..b39640524 100644 --- a/winsup/cygwin/syslog.cc +++ b/winsup/cygwin/syslog.cc @@ -60,8 +60,7 @@ static int process_logmask = LOG_UPTO (LOG_DEBUG); * openlog: save the passed args. Don't open the * system log (NT) or log file (95) yet. */ -extern "C" -void +extern "C" void openlog (const char *ident, int logopt, int facility) { debug_printf ("openlog called with (%s, %d, %d)", @@ -208,8 +207,7 @@ pass_handler::print_va (const char *fmt, va_list list) * always point to that. */ -extern "C" -void +extern "C" void syslog (int priority, const char *message, ...) { debug_printf ("%x %s", priority, message); @@ -410,8 +408,7 @@ syslog (int priority, const char *message, ...) } } -extern "C" -void +extern "C" void closelog (void) { ; diff --git a/winsup/cygwin/tty.cc b/winsup/cygwin/tty.cc index 371887c20..ef3252be7 100644 --- a/winsup/cygwin/tty.cc +++ b/winsup/cygwin/tty.cc @@ -28,22 +28,19 @@ details. */ extern fhandler_tty_master *tty_master; -extern "C" -int +extern "C" int grantpt (int fd) { return 0; } -extern "C" -int +extern "C" int unlockpt (int fd) { return 0; } -extern "C" -int +extern "C" int ttyslot (void) { if (NOTSTATE (myself, PID_USETTY)) diff --git a/winsup/cygwin/wait.cc b/winsup/cygwin/wait.cc index 969aafd5f..3b6427ad9 100644 --- a/winsup/cygwin/wait.cc +++ b/winsup/cygwin/wait.cc @@ -20,20 +20,19 @@ details. */ /* This is called _wait and not wait because the real wait is defined in libc/syscalls/syswait.c. It calls us. */ -extern "C" -pid_t +extern "C" pid_t wait (int *status) { return wait4 (-1, status, 0, NULL); } -pid_t +extern "C" pid_t waitpid (pid_t intpid, int *status, int options) { return wait4 (intpid, status, options, NULL); } -pid_t +extern "C" pid_t wait3 (int *status, int options, struct rusage *r) { return wait4 (-1, status, options, r); @@ -44,7 +43,7 @@ wait3 (int *status, int options, struct rusage *r) * not work correctly. */ -pid_t +extern "C" pid_t wait4 (int intpid, int *status, int options, struct rusage *r) { int res;