40 #include "prims/jvm.h" |
40 #include "prims/jvm.h" |
41 #include "prims/jvm_misc.hpp" |
41 #include "prims/jvm_misc.hpp" |
42 #include "runtime/arguments.hpp" |
42 #include "runtime/arguments.hpp" |
43 #include "runtime/extendedPC.hpp" |
43 #include "runtime/extendedPC.hpp" |
44 #include "runtime/globals.hpp" |
44 #include "runtime/globals.hpp" |
45 #include "runtime/hpi.hpp" |
|
46 #include "runtime/interfaceSupport.hpp" |
45 #include "runtime/interfaceSupport.hpp" |
47 #include "runtime/java.hpp" |
46 #include "runtime/java.hpp" |
48 #include "runtime/javaCalls.hpp" |
47 #include "runtime/javaCalls.hpp" |
49 #include "runtime/mutexLocker.hpp" |
48 #include "runtime/mutexLocker.hpp" |
50 #include "runtime/objectMonitor.hpp" |
49 #include "runtime/objectMonitor.hpp" |
218 80, 96, 112, 124, 127 }; |
218 80, 96, 112, 124, 127 }; |
219 |
219 |
220 // System parameters used internally |
220 // System parameters used internally |
221 static clock_t clock_tics_per_sec = 100; |
221 static clock_t clock_tics_per_sec = 100; |
222 |
222 |
|
223 // Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+) |
|
224 static bool enabled_extended_FILE_stdio = false; |
|
225 |
223 // For diagnostics to print a message once. see run_periodic_checks |
226 // For diagnostics to print a message once. see run_periodic_checks |
224 static bool check_addr0_done = false; |
227 static bool check_addr0_done = false; |
225 static sigset_t check_signal_done; |
228 static sigset_t check_signal_done; |
226 static bool check_signals = true; |
229 static bool check_signals = true; |
227 |
230 |
1749 } |
1752 } |
1750 |
1753 |
1751 bool os::supports_vtime() { return true; } |
1754 bool os::supports_vtime() { return true; } |
1752 |
1755 |
1753 bool os::enable_vtime() { |
1756 bool os::enable_vtime() { |
1754 int fd = open("/proc/self/ctl", O_WRONLY); |
1757 int fd = ::open("/proc/self/ctl", O_WRONLY); |
1755 if (fd == -1) |
1758 if (fd == -1) |
1756 return false; |
1759 return false; |
1757 |
1760 |
1758 long cmd[] = { PCSET, PR_MSACCT }; |
1761 long cmd[] = { PCSET, PR_MSACCT }; |
1759 int res = write(fd, cmd, sizeof(long) * 2); |
1762 int res = ::write(fd, cmd, sizeof(long) * 2); |
1760 close(fd); |
1763 ::close(fd); |
1761 if (res != sizeof(long) * 2) |
1764 if (res != sizeof(long) * 2) |
1762 return false; |
1765 return false; |
1763 |
1766 |
1764 return true; |
1767 return true; |
1765 } |
1768 } |
1766 |
1769 |
1767 bool os::vtime_enabled() { |
1770 bool os::vtime_enabled() { |
1768 int fd = open("/proc/self/status", O_RDONLY); |
1771 int fd = ::open("/proc/self/status", O_RDONLY); |
1769 if (fd == -1) |
1772 if (fd == -1) |
1770 return false; |
1773 return false; |
1771 |
1774 |
1772 pstatus_t status; |
1775 pstatus_t status; |
1773 int res = read(fd, (void*) &status, sizeof(pstatus_t)); |
1776 int res = os::read(fd, (void*) &status, sizeof(pstatus_t)); |
1774 close(fd); |
1777 ::close(fd); |
1775 if (res != sizeof(pstatus_t)) |
1778 if (res != sizeof(pstatus_t)) |
1776 return false; |
1779 return false; |
1777 |
1780 |
1778 return status.pr_flags & PR_MSACCT; |
1781 return status.pr_flags & PR_MSACCT; |
1779 } |
1782 } |
2196 |
2198 |
2197 void* os::dll_lookup(void* handle, const char* name) { |
2199 void* os::dll_lookup(void* handle, const char* name) { |
2198 return dlsym(handle, name); |
2200 return dlsym(handle, name); |
2199 } |
2201 } |
2200 |
2202 |
2201 |
2203 int os::stat(const char *path, struct stat *sbuf) { |
2202 bool _print_ascii_file(const char* filename, outputStream* st) { |
2204 char pathbuf[MAX_PATH]; |
2203 int fd = open(filename, O_RDONLY); |
2205 if (strlen(path) > MAX_PATH - 1) { |
|
2206 errno = ENAMETOOLONG; |
|
2207 return -1; |
|
2208 } |
|
2209 os::native_path(strcpy(pathbuf, path)); |
|
2210 return ::stat(pathbuf, sbuf); |
|
2211 } |
|
2212 |
|
2213 static bool _print_ascii_file(const char* filename, outputStream* st) { |
|
2214 int fd = ::open(filename, O_RDONLY); |
2204 if (fd == -1) { |
2215 if (fd == -1) { |
2205 return false; |
2216 return false; |
2206 } |
2217 } |
2207 |
2218 |
2208 char buf[32]; |
2219 char buf[32]; |
2209 int bytes; |
2220 int bytes; |
2210 while ((bytes = read(fd, buf, sizeof(buf))) > 0) { |
2221 while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) { |
2211 st->print_raw(buf, bytes); |
2222 st->print_raw(buf, bytes); |
2212 } |
2223 } |
2213 |
2224 |
2214 close(fd); |
2225 ::close(fd); |
2215 |
2226 |
2216 return true; |
2227 return true; |
2217 } |
2228 } |
2218 |
2229 |
2219 void os::print_os_info(outputStream* st) { |
2230 void os::print_os_info(outputStream* st) { |
2272 } |
2283 } |
2273 |
2284 |
2274 |
2285 |
2275 static bool check_addr0(outputStream* st) { |
2286 static bool check_addr0(outputStream* st) { |
2276 jboolean status = false; |
2287 jboolean status = false; |
2277 int fd = open("/proc/self/map",O_RDONLY); |
2288 int fd = ::open("/proc/self/map",O_RDONLY); |
2278 if (fd >= 0) { |
2289 if (fd >= 0) { |
2279 prmap_t p; |
2290 prmap_t p; |
2280 while(read(fd, &p, sizeof(p)) > 0) { |
2291 while(::read(fd, &p, sizeof(p)) > 0) { |
2281 if (p.pr_vaddr == 0x0) { |
2292 if (p.pr_vaddr == 0x0) { |
2282 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname); |
2293 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname); |
2283 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname); |
2294 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname); |
2284 st->print("Access:"); |
2295 st->print("Access:"); |
2285 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-"); |
2296 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-"); |
2286 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-"); |
2297 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-"); |
2287 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-"); |
2298 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-"); |
2288 st->cr(); |
2299 st->cr(); |
2289 status = true; |
2300 status = true; |
2290 } |
2301 } |
2291 close(fd); |
2302 ::close(fd); |
2292 } |
2303 } |
2293 } |
2304 } |
2294 return status; |
2305 return status; |
2295 } |
2306 } |
2296 |
2307 |
2534 |
2545 |
2535 if (0 == access(buf, F_OK)) { |
2546 if (0 == access(buf, F_OK)) { |
2536 // Use current module name "libjvm[_g].so" instead of |
2547 // Use current module name "libjvm[_g].so" instead of |
2537 // "libjvm"debug_only("_g")".so" since for fastdebug version |
2548 // "libjvm"debug_only("_g")".so" since for fastdebug version |
2538 // we should have "libjvm.so" but debug_only("_g") adds "_g"! |
2549 // we should have "libjvm.so" but debug_only("_g") adds "_g"! |
2539 // It is used when we are choosing the HPI library's name |
|
2540 // "libhpi[_g].so" in hpi::initialize_get_interface(). |
|
2541 len = strlen(buf); |
2550 len = strlen(buf); |
2542 snprintf(buf + len, buflen-len, "/hotspot/libjvm%s.so", p); |
2551 snprintf(buf + len, buflen-len, "/hotspot/libjvm%s.so", p); |
2543 } else { |
2552 } else { |
2544 // Go back to path of .so |
2553 // Go back to path of .so |
2545 realpath((char *)dlinfo.dli_fname, buf); |
2554 realpath((char *)dlinfo.dli_fname, buf); |
3466 } |
3492 } |
3467 |
3493 |
3468 // Read calls from inside the vm need to perform state transitions |
3494 // Read calls from inside the vm need to perform state transitions |
3469 size_t os::read(int fd, void *buf, unsigned int nBytes) { |
3495 size_t os::read(int fd, void *buf, unsigned int nBytes) { |
3470 INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); |
3496 INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); |
|
3497 } |
|
3498 |
|
3499 size_t os::restartable_read(int fd, void *buf, unsigned int nBytes) { |
|
3500 INTERRUPTIBLE_RETURN_INT(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); |
3471 } |
3501 } |
3472 |
3502 |
3473 int os::sleep(Thread* thread, jlong millis, bool interruptible) { |
3503 int os::sleep(Thread* thread, jlong millis, bool interruptible) { |
3474 assert(thread == Thread::current(), "thread consistency check"); |
3504 assert(thread == Thread::current(), "thread consistency check"); |
3475 |
3505 |
4637 bool isT2 = false; |
4667 bool isT2 = false; |
4638 |
4668 |
4639 #define ADR(x) ((uintptr_t)(x)) |
4669 #define ADR(x) ((uintptr_t)(x)) |
4640 #define LWPINDEX(ary,ix) ((lwpstatus_t *)(((ary)->pr_entsize * (ix)) + (ADR((ary) + 1)))) |
4670 #define LWPINDEX(ary,ix) ((lwpstatus_t *)(((ary)->pr_entsize * (ix)) + (ADR((ary) + 1)))) |
4641 |
4671 |
4642 lwpFile = open("/proc/self/lstatus", O_RDONLY, 0); |
4672 lwpFile = ::open("/proc/self/lstatus", O_RDONLY, 0); |
4643 if (lwpFile < 0) { |
4673 if (lwpFile < 0) { |
4644 if (ThreadPriorityVerbose) warning ("Couldn't open /proc/self/lstatus\n"); |
4674 if (ThreadPriorityVerbose) warning ("Couldn't open /proc/self/lstatus\n"); |
4645 return false; |
4675 return false; |
4646 } |
4676 } |
4647 lwpSize = 16*1024; |
4677 lwpSize = 16*1024; |
4648 for (;;) { |
4678 for (;;) { |
4649 lseek (lwpFile, 0, SEEK_SET); |
4679 ::lseek64 (lwpFile, 0, SEEK_SET); |
4650 lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize); |
4680 lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize); |
4651 if (read(lwpFile, lwpArray, lwpSize) < 0) { |
4681 if (::read(lwpFile, lwpArray, lwpSize) < 0) { |
4652 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n"); |
4682 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n"); |
4653 break; |
4683 break; |
4654 } |
4684 } |
4655 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) { |
4685 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) { |
4656 // We got a good snapshot - now iterate over the list. |
4686 // We got a good snapshot - now iterate over the list. |
5098 if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 ) |
5121 if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 ) |
5099 fatal("Could not enable polling page"); |
5122 fatal("Could not enable polling page"); |
5100 }; |
5123 }; |
5101 |
5124 |
5102 // OS interface. |
5125 // OS interface. |
5103 |
|
5104 int os::stat(const char *path, struct stat *sbuf) { |
|
5105 char pathbuf[MAX_PATH]; |
|
5106 if (strlen(path) > MAX_PATH - 1) { |
|
5107 errno = ENAMETOOLONG; |
|
5108 return -1; |
|
5109 } |
|
5110 hpi::native_path(strcpy(pathbuf, path)); |
|
5111 return ::stat(pathbuf, sbuf); |
|
5112 } |
|
5113 |
|
5114 |
5126 |
5115 bool os::check_heap(bool force) { return true; } |
5127 bool os::check_heap(bool force) { return true; } |
5116 |
5128 |
5117 typedef int (*vsnprintf_t)(char* buf, size_t count, const char* fmt, va_list argptr); |
5129 typedef int (*vsnprintf_t)(char* buf, size_t count, const char* fmt, va_list argptr); |
5118 static vsnprintf_t sol_vsnprintf = NULL; |
5130 static vsnprintf_t sol_vsnprintf = NULL; |
5154 } |
5166 } |
5155 closedir(dir); |
5167 closedir(dir); |
5156 return result; |
5168 return result; |
5157 } |
5169 } |
5158 |
5170 |
|
5171 // This code originates from JDK's sysOpen and open64_w |
|
5172 // from src/solaris/hpi/src/system_md.c |
|
5173 |
|
5174 #ifndef O_DELETE |
|
5175 #define O_DELETE 0x10000 |
|
5176 #endif |
|
5177 |
|
5178 // Open a file. Unlink the file immediately after open returns |
|
5179 // if the specified oflag has the O_DELETE flag set. |
|
5180 // O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c |
|
5181 |
|
5182 int os::open(const char *path, int oflag, int mode) { |
|
5183 if (strlen(path) > MAX_PATH - 1) { |
|
5184 errno = ENAMETOOLONG; |
|
5185 return -1; |
|
5186 } |
|
5187 int fd; |
|
5188 int o_delete = (oflag & O_DELETE); |
|
5189 oflag = oflag & ~O_DELETE; |
|
5190 |
|
5191 fd = ::open(path, oflag, mode); |
|
5192 if (fd == -1) return -1; |
|
5193 |
|
5194 //If the open succeeded, the file might still be a directory |
|
5195 { |
|
5196 struct stat64 buf64; |
|
5197 int ret = ::fstat64(fd, &buf64); |
|
5198 int st_mode = buf64.st_mode; |
|
5199 |
|
5200 if (ret != -1) { |
|
5201 if ((st_mode & S_IFMT) == S_IFDIR) { |
|
5202 errno = EISDIR; |
|
5203 ::close(fd); |
|
5204 return -1; |
|
5205 } |
|
5206 } else { |
|
5207 ::close(fd); |
|
5208 return -1; |
|
5209 } |
|
5210 } |
|
5211 /* |
|
5212 * 32-bit Solaris systems suffer from: |
|
5213 * |
|
5214 * - an historical default soft limit of 256 per-process file |
|
5215 * descriptors that is too low for many Java programs. |
|
5216 * |
|
5217 * - a design flaw where file descriptors created using stdio |
|
5218 * fopen must be less than 256, _even_ when the first limit above |
|
5219 * has been raised. This can cause calls to fopen (but not calls to |
|
5220 * open, for example) to fail mysteriously, perhaps in 3rd party |
|
5221 * native code (although the JDK itself uses fopen). One can hardly |
|
5222 * criticize them for using this most standard of all functions. |
|
5223 * |
|
5224 * We attempt to make everything work anyways by: |
|
5225 * |
|
5226 * - raising the soft limit on per-process file descriptors beyond |
|
5227 * 256 |
|
5228 * |
|
5229 * - As of Solaris 10u4, we can request that Solaris raise the 256 |
|
5230 * stdio fopen limit by calling function enable_extended_FILE_stdio. |
|
5231 * This is done in init_2 and recorded in enabled_extended_FILE_stdio |
|
5232 * |
|
5233 * - If we are stuck on an old (pre 10u4) Solaris system, we can |
|
5234 * workaround the bug by remapping non-stdio file descriptors below |
|
5235 * 256 to ones beyond 256, which is done below. |
|
5236 * |
|
5237 * See: |
|
5238 * 1085341: 32-bit stdio routines should support file descriptors >255 |
|
5239 * 6533291: Work around 32-bit Solaris stdio limit of 256 open files |
|
5240 * 6431278: Netbeans crash on 32 bit Solaris: need to call |
|
5241 * enable_extended_FILE_stdio() in VM initialisation |
|
5242 * Giri Mandalika's blog |
|
5243 * http://technopark02.blogspot.com/2005_05_01_archive.html |
|
5244 */ |
|
5245 #ifndef _LP64 |
|
5246 if ((!enabled_extended_FILE_stdio) && fd < 256) { |
|
5247 int newfd = ::fcntl(fd, F_DUPFD, 256); |
|
5248 if (newfd != -1) { |
|
5249 ::close(fd); |
|
5250 fd = newfd; |
|
5251 } |
|
5252 } |
|
5253 #endif // 32-bit Solaris |
|
5254 /* |
|
5255 * All file descriptors that are opened in the JVM and not |
|
5256 * specifically destined for a subprocess should have the |
|
5257 * close-on-exec flag set. If we don't set it, then careless 3rd |
|
5258 * party native code might fork and exec without closing all |
|
5259 * appropriate file descriptors (e.g. as we do in closeDescriptors in |
|
5260 * UNIXProcess.c), and this in turn might: |
|
5261 * |
|
5262 * - cause end-of-file to fail to be detected on some file |
|
5263 * descriptors, resulting in mysterious hangs, or |
|
5264 * |
|
5265 * - might cause an fopen in the subprocess to fail on a system |
|
5266 * suffering from bug 1085341. |
|
5267 * |
|
5268 * (Yes, the default setting of the close-on-exec flag is a Unix |
|
5269 * design flaw) |
|
5270 * |
|
5271 * See: |
|
5272 * 1085341: 32-bit stdio routines should support file descriptors >255 |
|
5273 * 4843136: (process) pipe file descriptor from Runtime.exec not being closed |
|
5274 * 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9 |
|
5275 */ |
|
5276 #ifdef FD_CLOEXEC |
|
5277 { |
|
5278 int flags = ::fcntl(fd, F_GETFD); |
|
5279 if (flags != -1) |
|
5280 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC); |
|
5281 } |
|
5282 #endif |
|
5283 |
|
5284 if (o_delete != 0) { |
|
5285 ::unlink(path); |
|
5286 } |
|
5287 return fd; |
|
5288 } |
|
5289 |
5159 // create binary file, rewriting existing file if required |
5290 // create binary file, rewriting existing file if required |
5160 int os::create_binary_file(const char* path, bool rewrite_existing) { |
5291 int os::create_binary_file(const char* path, bool rewrite_existing) { |
5161 int oflags = O_WRONLY | O_CREAT; |
5292 int oflags = O_WRONLY | O_CREAT; |
5162 if (!rewrite_existing) { |
5293 if (!rewrite_existing) { |
5163 oflags |= O_EXCL; |
5294 oflags |= O_EXCL; |
5171 } |
5302 } |
5172 |
5303 |
5173 // move file pointer to the specified offset |
5304 // move file pointer to the specified offset |
5174 jlong os::seek_to_file_offset(int fd, jlong offset) { |
5305 jlong os::seek_to_file_offset(int fd, jlong offset) { |
5175 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET); |
5306 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET); |
|
5307 } |
|
5308 |
|
5309 jlong os::lseek(int fd, jlong offset, int whence) { |
|
5310 return (jlong) ::lseek64(fd, offset, whence); |
|
5311 } |
|
5312 |
|
5313 char * os::native_path(char *path) { |
|
5314 return path; |
|
5315 } |
|
5316 |
|
5317 int os::ftruncate(int fd, jlong length) { |
|
5318 return ::ftruncate64(fd, length); |
|
5319 } |
|
5320 |
|
5321 int os::fsync(int fd) { |
|
5322 RESTARTABLE_RETURN_INT(::fsync(fd)); |
|
5323 } |
|
5324 |
|
5325 int os::available(int fd, jlong *bytes) { |
|
5326 jlong cur, end; |
|
5327 int mode; |
|
5328 struct stat64 buf64; |
|
5329 |
|
5330 if (::fstat64(fd, &buf64) >= 0) { |
|
5331 mode = buf64.st_mode; |
|
5332 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) { |
|
5333 /* |
|
5334 * XXX: is the following call interruptible? If so, this might |
|
5335 * need to go through the INTERRUPT_IO() wrapper as for other |
|
5336 * blocking, interruptible calls in this file. |
|
5337 */ |
|
5338 int n,ioctl_return; |
|
5339 |
|
5340 INTERRUPTIBLE(::ioctl(fd, FIONREAD, &n),ioctl_return,os::Solaris::clear_interrupted); |
|
5341 if (ioctl_return>= 0) { |
|
5342 *bytes = n; |
|
5343 return 1; |
|
5344 } |
|
5345 } |
|
5346 } |
|
5347 if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) { |
|
5348 return 0; |
|
5349 } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) { |
|
5350 return 0; |
|
5351 } else if (::lseek64(fd, cur, SEEK_SET) == -1) { |
|
5352 return 0; |
|
5353 } |
|
5354 *bytes = end - cur; |
|
5355 return 1; |
5176 } |
5356 } |
5177 |
5357 |
5178 // Map a block of memory. |
5358 // Map a block of memory. |
5179 char* os::map_memory(int fd, const char* file_name, size_t file_offset, |
5359 char* os::map_memory(int fd, const char* file_name, size_t file_offset, |
5180 char *addr, size_t bytes, bool read_only, |
5360 char *addr, size_t bytes, bool read_only, |
5428 int fd; |
5608 int fd; |
5429 |
5609 |
5430 sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage", |
5610 sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage", |
5431 getpid(), |
5611 getpid(), |
5432 thread->osthread()->lwp_id()); |
5612 thread->osthread()->lwp_id()); |
5433 fd = open(proc_name, O_RDONLY); |
5613 fd = ::open(proc_name, O_RDONLY); |
5434 if ( fd == -1 ) return -1; |
5614 if ( fd == -1 ) return -1; |
5435 |
5615 |
5436 do { |
5616 do { |
5437 count = pread(fd, |
5617 count = ::pread(fd, |
5438 (void *)&prusage.pr_utime, |
5618 (void *)&prusage.pr_utime, |
5439 thr_time_size, |
5619 thr_time_size, |
5440 thr_time_off); |
5620 thr_time_off); |
5441 } while (count < 0 && errno == EINTR); |
5621 } while (count < 0 && errno == EINTR); |
5442 close(fd); |
5622 ::close(fd); |
5443 if ( count < 0 ) return -1; |
5623 if ( count < 0 ) return -1; |
5444 |
5624 |
5445 if (user_sys_cpu_time) { |
5625 if (user_sys_cpu_time) { |
5446 // user + system CPU time |
5626 // user + system CPU time |
5447 lwp_time = (((jlong)prusage.pr_stime.tv_sec + |
5627 lwp_time = (((jlong)prusage.pr_stime.tv_sec + |
6109 if (::stat(libmawtpath, &statbuf) == 0) return false; |
6289 if (::stat(libmawtpath, &statbuf) == 0) return false; |
6110 |
6290 |
6111 return true; |
6291 return true; |
6112 } |
6292 } |
6113 |
6293 |
6114 |
6294 size_t os::write(int fd, const void *buf, unsigned int nBytes) { |
|
6295 INTERRUPTIBLE_RETURN_INT(::write(fd, buf, nBytes), os::Solaris::clear_interrupted); |
|
6296 } |
|
6297 |
|
6298 int os::close(int fd) { |
|
6299 RESTARTABLE_RETURN_INT(::close(fd)); |
|
6300 } |
|
6301 |
|
6302 int os::socket_close(int fd) { |
|
6303 RESTARTABLE_RETURN_INT(::close(fd)); |
|
6304 } |
|
6305 |
|
6306 int os::recv(int fd, char *buf, int nBytes, int flags) { |
|
6307 INTERRUPTIBLE_RETURN_INT(::recv(fd, buf, nBytes, flags), os::Solaris::clear_interrupted); |
|
6308 } |
|
6309 |
|
6310 |
|
6311 int os::send(int fd, char *buf, int nBytes, int flags) { |
|
6312 INTERRUPTIBLE_RETURN_INT(::send(fd, buf, nBytes, flags), os::Solaris::clear_interrupted); |
|
6313 } |
|
6314 |
|
6315 int os::raw_send(int fd, char *buf, int nBytes, int flags) { |
|
6316 RESTARTABLE_RETURN_INT(::send(fd, buf, nBytes, flags)); |
|
6317 } |
|
6318 |
|
6319 // As both poll and select can be interrupted by signals, we have to be |
|
6320 // prepared to restart the system call after updating the timeout, unless |
|
6321 // a poll() is done with timeout == -1, in which case we repeat with this |
|
6322 // "wait forever" value. |
|
6323 |
|
6324 int os::timeout(int fd, long timeout) { |
|
6325 int res; |
|
6326 struct timeval t; |
|
6327 julong prevtime, newtime; |
|
6328 static const char* aNull = 0; |
|
6329 struct pollfd pfd; |
|
6330 pfd.fd = fd; |
|
6331 pfd.events = POLLIN; |
|
6332 |
|
6333 gettimeofday(&t, &aNull); |
|
6334 prevtime = ((julong)t.tv_sec * 1000) + t.tv_usec / 1000; |
|
6335 |
|
6336 for(;;) { |
|
6337 INTERRUPTIBLE_NORESTART(::poll(&pfd, 1, timeout), res, os::Solaris::clear_interrupted); |
|
6338 if(res == OS_ERR && errno == EINTR) { |
|
6339 if(timeout != -1) { |
|
6340 gettimeofday(&t, &aNull); |
|
6341 newtime = ((julong)t.tv_sec * 1000) + t.tv_usec /1000; |
|
6342 timeout -= newtime - prevtime; |
|
6343 if(timeout <= 0) |
|
6344 return OS_OK; |
|
6345 prevtime = newtime; |
|
6346 } |
|
6347 } else return res; |
|
6348 } |
|
6349 } |
|
6350 |
|
6351 int os::connect(int fd, struct sockaddr *him, int len) { |
|
6352 int _result; |
|
6353 INTERRUPTIBLE_NORESTART(::connect(fd, him, len), _result, |
|
6354 os::Solaris::clear_interrupted); |
|
6355 |
|
6356 // Depending on when thread interruption is reset, _result could be |
|
6357 // one of two values when errno == EINTR |
|
6358 |
|
6359 if (((_result == OS_INTRPT) || (_result == OS_ERR)) |
|
6360 && (errno == EINTR)) { |
|
6361 /* restarting a connect() changes its errno semantics */ |
|
6362 INTERRUPTIBLE(::connect(fd, him, len), _result, |
|
6363 os::Solaris::clear_interrupted); |
|
6364 /* undo these changes */ |
|
6365 if (_result == OS_ERR) { |
|
6366 if (errno == EALREADY) { |
|
6367 errno = EINPROGRESS; /* fall through */ |
|
6368 } else if (errno == EISCONN) { |
|
6369 errno = 0; |
|
6370 return OS_OK; |
|
6371 } |
|
6372 } |
|
6373 } |
|
6374 return _result; |
|
6375 } |
|
6376 |
|
6377 int os::accept(int fd, struct sockaddr *him, int *len) { |
|
6378 if (fd < 0) |
|
6379 return OS_ERR; |
|
6380 INTERRUPTIBLE_RETURN_INT((int)::accept(fd, him,\ |
|
6381 (socklen_t*) len), os::Solaris::clear_interrupted); |
|
6382 } |
|
6383 |
|
6384 int os::recvfrom(int fd, char *buf, int nBytes, int flags, |
|
6385 sockaddr *from, int *fromlen) { |
|
6386 //%%note jvm_r11 |
|
6387 INTERRUPTIBLE_RETURN_INT((int)::recvfrom(fd, buf, nBytes,\ |
|
6388 flags, from, fromlen), os::Solaris::clear_interrupted); |
|
6389 } |
|
6390 |
|
6391 int os::sendto(int fd, char *buf, int len, int flags, |
|
6392 struct sockaddr *to, int tolen) { |
|
6393 //%%note jvm_r11 |
|
6394 INTERRUPTIBLE_RETURN_INT((int)::sendto(fd, buf, len, flags,\ |
|
6395 to, tolen), os::Solaris::clear_interrupted); |
|
6396 } |
|
6397 |
|
6398 int os::socket_available(int fd, jint *pbytes) { |
|
6399 if (fd < 0) |
|
6400 return OS_OK; |
|
6401 |
|
6402 int ret; |
|
6403 |
|
6404 RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret); |
|
6405 |
|
6406 //%% note ioctl can return 0 when successful, JVM_SocketAvailable |
|
6407 // is expected to return 0 on failure and 1 on success to the jdk. |
|
6408 |
|
6409 return (ret == OS_ERR) ? 0 : 1; |
|
6410 } |
|
6411 |
|
6412 |
|
6413 int os::bind(int fd, struct sockaddr *him, int len) { |
|
6414 INTERRUPTIBLE_RETURN_INT_NORESTART(::bind(fd, him, len),\ |
|
6415 os::Solaris::clear_interrupted); |
|
6416 } |
|
6417 |