3732 if (addr != NULL) {
3733 // mmap() is successful but it fails to reserve at the requested address
3734 anon_munmap(addr, bytes);
3735 }
3736
3737 int i;
3738 for (i = 0; i < max_tries; ++i) {
3739 base[i] = reserve_memory(bytes);
3740
3741 if (base[i] != NULL) {
3742 // Is this the block we wanted?
3743 if (base[i] == requested_addr) {
3744 size[i] = bytes;
3745 break;
3746 }
3747
3748 // Does this overlap the block we wanted? Give back the overlapped
3749 // parts and try again.
3750
3751 size_t top_overlap = requested_addr + (bytes + gap) - base[i];
3752 if (top_overlap >= 0 && top_overlap < bytes) {
3753 unmap_memory(base[i], top_overlap);
3754 base[i] += top_overlap;
3755 size[i] = bytes - top_overlap;
3756 } else {
3757 size_t bottom_overlap = base[i] + bytes - requested_addr;
3758 if (bottom_overlap >= 0 && bottom_overlap < bytes) {
3759 unmap_memory(requested_addr, bottom_overlap);
3760 size[i] = bytes - bottom_overlap;
3761 } else {
3762 size[i] = bytes;
3763 }
3764 }
3765 }
3766 }
3767
3768 // Give back the unused reserved pieces.
3769
3770 for (int j = 0; j < i; ++j) {
3771 if (base[j] != NULL) {
3772 unmap_memory(base[j], size[j]);
3773 }
3774 }
3775
3776 if (i < max_tries) {
3777 _highest_vm_reserved_address = MAX2(old_highest, (address)requested_addr + bytes);
3778 return requested_addr;
6006
6007 int core_pattern_file = ::open("/proc/sys/kernel/core_pattern", O_RDONLY);
6008 if (core_pattern_file != -1) {
6009 ssize_t ret = ::read(core_pattern_file, core_pattern, core_pattern_len);
6010 ::close(core_pattern_file);
6011
6012 if (ret > 0) {
6013 char *last_char = core_pattern + strlen(core_pattern) - 1;
6014
6015 if (*last_char == '\n') {
6016 *last_char = '\0';
6017 }
6018 }
6019 }
6020
6021 if (strlen(core_pattern) == 0) {
6022 return 0;
6023 }
6024
6025 char *pid_pos = strstr(core_pattern, "%p");
6026 size_t written;
6027
6028 if (core_pattern[0] == '/') {
6029 written = jio_snprintf(buffer, bufferSize, core_pattern);
6030 } else {
6031 char cwd[PATH_MAX];
6032
6033 const char* p = get_current_directory(cwd, PATH_MAX);
6034 if (p == NULL) {
6035 assert(p != NULL, "failed to get current directory");
6036 return 0;
6037 }
6038
6039 if (core_pattern[0] == '|') {
6040 written = jio_snprintf(buffer, bufferSize,
6041 "\"%s\" (or dumping to %s/core.%d)",
6042 &core_pattern[1], p, current_process_id());
6043 } else {
6044 written = jio_snprintf(buffer, bufferSize, "%s/%s", p, core_pattern);
6045 }
6046 }
6047
6048 if ((written >= 0) && (written < bufferSize)
6049 && (pid_pos == NULL) && (core_pattern[0] != '|')) {
6050 int core_uses_pid_file = ::open("/proc/sys/kernel/core_uses_pid", O_RDONLY);
6051
6052 if (core_uses_pid_file != -1) {
6053 char core_uses_pid = 0;
6054 ssize_t ret = ::read(core_uses_pid_file, &core_uses_pid, 1);
6055 ::close(core_uses_pid_file);
6056
6057 if (core_uses_pid == '1'){
6058 jio_snprintf(buffer + written, bufferSize - written,
6059 ".%d", current_process_id());
6060 }
6061 }
6062 }
6063
6064 return strlen(buffer);
6065 }
6066
6067 /////////////// Unit tests ///////////////
6068
6069 #ifndef PRODUCT
|
3732 if (addr != NULL) {
3733 // mmap() is successful but it fails to reserve at the requested address
3734 anon_munmap(addr, bytes);
3735 }
3736
3737 int i;
3738 for (i = 0; i < max_tries; ++i) {
3739 base[i] = reserve_memory(bytes);
3740
3741 if (base[i] != NULL) {
3742 // Is this the block we wanted?
3743 if (base[i] == requested_addr) {
3744 size[i] = bytes;
3745 break;
3746 }
3747
3748 // Does this overlap the block we wanted? Give back the overlapped
3749 // parts and try again.
3750
3751 size_t top_overlap = requested_addr + (bytes + gap) - base[i];
3752 if (requested_addr + (bytes + gap) >= base[i] && // Check underflow.
3753 top_overlap < bytes) {
3754 unmap_memory(base[i], top_overlap);
3755 base[i] += top_overlap;
3756 size[i] = bytes - top_overlap;
3757 } else {
3758 size_t bottom_overlap = base[i] + bytes - requested_addr;
3759 if (base[i] + bytes >= requested_addr && // Check underflow.
3760 bottom_overlap < bytes) {
3761 unmap_memory(requested_addr, bottom_overlap);
3762 size[i] = bytes - bottom_overlap;
3763 } else {
3764 size[i] = bytes;
3765 }
3766 }
3767 }
3768 }
3769
3770 // Give back the unused reserved pieces.
3771
3772 for (int j = 0; j < i; ++j) {
3773 if (base[j] != NULL) {
3774 unmap_memory(base[j], size[j]);
3775 }
3776 }
3777
3778 if (i < max_tries) {
3779 _highest_vm_reserved_address = MAX2(old_highest, (address)requested_addr + bytes);
3780 return requested_addr;
6008
6009 int core_pattern_file = ::open("/proc/sys/kernel/core_pattern", O_RDONLY);
6010 if (core_pattern_file != -1) {
6011 ssize_t ret = ::read(core_pattern_file, core_pattern, core_pattern_len);
6012 ::close(core_pattern_file);
6013
6014 if (ret > 0) {
6015 char *last_char = core_pattern + strlen(core_pattern) - 1;
6016
6017 if (*last_char == '\n') {
6018 *last_char = '\0';
6019 }
6020 }
6021 }
6022
6023 if (strlen(core_pattern) == 0) {
6024 return 0;
6025 }
6026
6027 char *pid_pos = strstr(core_pattern, "%p");
6028 int written;
6029
6030 if (core_pattern[0] == '/') {
6031 written = jio_snprintf(buffer, bufferSize, core_pattern);
6032 } else {
6033 char cwd[PATH_MAX];
6034
6035 const char* p = get_current_directory(cwd, PATH_MAX);
6036 if (p == NULL) {
6037 assert(p != NULL, "failed to get current directory");
6038 return 0;
6039 }
6040
6041 if (core_pattern[0] == '|') {
6042 written = jio_snprintf(buffer, bufferSize,
6043 "\"%s\" (or dumping to %s/core.%d)",
6044 &core_pattern[1], p, current_process_id());
6045 } else {
6046 written = jio_snprintf(buffer, bufferSize, "%s/%s", p, core_pattern);
6047 }
6048 }
6049
6050 if ((written >= 0) && ((size_t)written < bufferSize) &&
6051 (pid_pos == NULL) && (core_pattern[0] != '|')) {
6052 int core_uses_pid_file = ::open("/proc/sys/kernel/core_uses_pid", O_RDONLY);
6053
6054 if (core_uses_pid_file != -1) {
6055 char core_uses_pid = 0;
6056 ssize_t ret = ::read(core_uses_pid_file, &core_uses_pid, 1);
6057 ::close(core_uses_pid_file);
6058
6059 if (core_uses_pid == '1'){
6060 jio_snprintf(buffer + written, bufferSize - written,
6061 ".%d", current_process_id());
6062 }
6063 }
6064 }
6065
6066 return strlen(buffer);
6067 }
6068
6069 /////////////// Unit tests ///////////////
6070
6071 #ifndef PRODUCT
|