jdk-sandbox: comparison hotspot/src/os/linux/vm/os

equal deleted inserted replaced

-:77349b58b4c0
+:68fa8b6c4340
 # include <link.h>
 # include <stdint.h>
 # include <inttypes.h>
 # include <sys/ioctl.h>
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 // if RUSAGE_THREAD for getrusage() has not been defined, do it here. The code calling
 // getrusage() is prepared to handle the associated failure.
 #ifndef RUSAGE_THREAD
 #define RUSAGE_THREAD   (1)               /* only the calling thread */
 #endif
 char permissions[5];
 char device[6];
 char name[PATH_MAX + 1];
 // Parse fields from line
-sscanf(line, "%lx-%lx %4s %lx %5s %ld %s", &base, &top, permissions, &offset, device, &inode, name);
+sscanf(line, UINT64_FORMAT_X "-" UINT64_FORMAT_X " %4s " UINT64_FORMAT_X " %5s " INT64_FORMAT " %s",
+&base, &top, permissions, &offset, device, &inode, name);
 // Filter by device id '00:00' so that we only get file system mapped files.
 if (strcmp(device, "00:00") != 0) {
 // Call callback with the fields of interest
 }
 static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
 int err) {
 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
-", %d) failed; error='%s' (errno=%d)", addr, size, exec,
+", %d) failed; error='%s' (errno=%d)", p2i(addr), size, exec,
 strerror(err), err);
 }
 static void warn_fail_commit_memory(char* addr, size_t size,
 size_t alignment_hint, bool exec,
 int err) {
 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
-", " SIZE_FORMAT ", %d) failed; error='%s' (errno=%d)", addr, size,
+", " SIZE_FORMAT ", %d) failed; error='%s' (errno=%d)", p2i(addr), size,
 alignment_hint, exec, strerror(err), err);
 }
 // NOTE: Linux kernel does not really reserve the pages for us.
 //       All it does is to check if there are enough free pages
 size_t threadStackSizeInBytes = ThreadStackSize * K;
 if (threadStackSizeInBytes != 0 &&
 threadStackSizeInBytes < os::Linux::min_stack_allowed) {
 tty->print_cr("\nThe stack size specified is too small, "
-"Specify at least %dk",
+"Specify at least " SIZE_FORMAT "k",
 os::Linux::min_stack_allowed/ K);
 return JNI_ERR;
 }
 // Make the stack size a multiple of the page size so that
 bool os::find(address addr, outputStream* st) {
 Dl_info dlinfo;
 memset(&dlinfo, 0, sizeof(dlinfo));
 if (dladdr(addr, &dlinfo) != 0) {
-st->print(PTR_FORMAT ": ", addr);
+st->print(PTR_FORMAT ": ", p2i(addr));
 if (dlinfo.dli_sname != NULL && dlinfo.dli_saddr != NULL) {
-st->print("%s+%#x", dlinfo.dli_sname,
+st->print("%s+" PTR_FORMAT, dlinfo.dli_sname,
-addr - (intptr_t)dlinfo.dli_saddr);
+p2i(addr) - p2i(dlinfo.dli_saddr));
 } else if (dlinfo.dli_fbase != NULL) {
-st->print("<offset %#x>", addr - (intptr_t)dlinfo.dli_fbase);
+st->print("<offset " PTR_FORMAT ">", p2i(addr) - p2i(dlinfo.dli_fbase));
 } else {
 st->print("<absolute address>");
 }
 if (dlinfo.dli_fname != NULL) {
 st->print(" in %s", dlinfo.dli_fname);
 }
 if (dlinfo.dli_fbase != NULL) {
-st->print(" at " PTR_FORMAT, dlinfo.dli_fbase);
+st->print(" at " PTR_FORMAT, p2i(dlinfo.dli_fbase));
 }
 st->cr();
 if (Verbose) {
 // decode some bytes around the PC
 }
 void os::pause() {
 char filename[MAX_PATH];
 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
-jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
+jio_snprintf(filename, MAX_PATH, "%s", PauseAtStartupFile);
 } else {
 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
 }
 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 char *pid_pos = strstr(core_pattern, "%p");
 int written;
 if (core_pattern[0] == '/') {
-written = jio_snprintf(buffer, bufferSize, core_pattern);
+written = jio_snprintf(buffer, bufferSize, "%s", core_pattern);
 } else {
 char cwd[PATH_MAX];
 const char* p = get_current_directory(cwd, PATH_MAX);
 if (p == NULL) {
 for (int i = 0; i < num_sizes; i++) {
 const size_t size = sizes[i];
 for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
 char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, NULL, false);
 test_log(SIZE_FORMAT_HEX " " SIZE_FORMAT_HEX " ->  " PTR_FORMAT " %s",
-size, alignment, p, (p != NULL ? "" : "(failed)"));
+size, alignment, p2i(p), (p != NULL ? "" : "(failed)"));
 if (p != NULL) {
 assert(is_ptr_aligned(p, alignment), "must be");
 small_page_write(p, size);
 os::Linux::release_memory_special_huge_tlbfs(p, size);
 }
 const size_t size = sizes[i];
 for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
 char* const req_addr = (char*) align_ptr_up(mapping1, alignment);
 char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
 test_log(SIZE_FORMAT_HEX " " SIZE_FORMAT_HEX " " PTR_FORMAT " ->  " PTR_FORMAT " %s",
-size, alignment, req_addr, p,
+size, alignment, p2i(req_addr), p2i(p),
 ((p != NULL ? (p == req_addr ? "(exact match)" : "") : "(failed)")));
 if (p != NULL) {
 assert(p == req_addr, "must be");
 small_page_write(p, size);
 os::Linux::release_memory_special_huge_tlbfs(p, size);
 }
 const size_t size = sizes[i];
 for (size_t alignment = ag; is_size_aligned(size, alignment); alignment *= 2) {
 char* const req_addr = (char*) align_ptr_up(mapping2, alignment);
 char* p = os::Linux::reserve_memory_special_huge_tlbfs_mixed(size, alignment, req_addr, false);
 test_log(SIZE_FORMAT_HEX " " SIZE_FORMAT_HEX " " PTR_FORMAT " ->  " PTR_FORMAT " %s",
-size, alignment, req_addr, p,
+size, alignment, p2i(req_addr), p2i(p), ((p != NULL ? "" : "(failed)")));
-((p != NULL ? "" : "(failed)")));
 // as the area around req_addr contains already existing mappings, the API should always
 // return NULL (as per contract, it cannot return another address)
 assert(p == NULL, "must be");
 }
 }

changeset 33148	68fa8b6c4340
parent 33105	294e48b4f704
child 33589	7cbd1b2c139b
child 33593	60764a78fa5c