2 * Copyright jattach authors
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include <sys/socket.h>
30 extern int mnt_changed;
32 // Check if remote JVM has already opened socket for Dynamic Attach
33 static int check_socket(int pid) {
35 snprintf(path, sizeof(path), "%s/.java_pid%d", tmp_path, pid);
38 return stat(path, &stats) == 0 && S_ISSOCK(stats.st_mode) ? 0 : -1;
41 // Check if a file is owned by current user
42 static uid_t get_file_owner(const char* path) {
44 return stat(path, &stats) == 0 ? stats.st_uid : (uid_t)-1;
47 // Force remote JVM to start Attach listener.
48 // HotSpot will start Attach listener in response to SIGQUIT if it sees .attach_pid file
49 static int start_attach_mechanism(int pid, int nspid) {
51 snprintf(path, sizeof(path), "/proc/%d/cwd/.attach_pid%d", mnt_changed > 0 ? nspid : pid, nspid);
53 int fd = creat(path, 0660);
54 if (fd == -1 || (close(fd) == 0 && get_file_owner(path) != geteuid())) {
55 // Some mounted filesystems may change the ownership of the file.
56 // JVM will not trust such file, so it's better to remove it and try a different path
59 // Failed to create attach trigger in current directory. Retry in /tmp
60 snprintf(path, sizeof(path), "%s/.attach_pid%d", tmp_path, nspid);
61 fd = creat(path, 0660);
68 // We have to still use the host namespace pid here for the kill() call
71 // Start with 20 ms sleep and increment delay each iteration. Total timeout is 6000 ms
72 struct timespec ts = {0, 20000000};
76 result = check_socket(nspid);
77 } while (result != 0 && (ts.tv_nsec += 20000000) < 500000000);
83 // Connect to UNIX domain socket created by JVM for Dynamic Attach
84 static int connect_socket(int pid) {
85 int fd = socket(PF_UNIX, SOCK_STREAM, 0);
90 struct sockaddr_un addr;
91 addr.sun_family = AF_UNIX;
93 int bytes = snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/.java_pid%d", tmp_path, pid);
94 if (bytes >= sizeof(addr.sun_path)) {
95 addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
98 if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
105 // Send command with arguments to socket
106 static int write_command(int fd, int argc, char** argv) {
108 const char* const limit = buf + sizeof(buf);
110 // jcmd has 2 arguments maximum; merge excessive arguments into one
111 int cmd_args = argc >= 2 && strcmp(argv[0], "jcmd") == 0 ? 2 : argc >= 4 ? 4 : argc;
114 char* p = stpncpy(buf, "1", sizeof(buf)) + 1;
117 for (i = 0; i < argc && p < limit; i++) {
118 if (i >= cmd_args) p[-1] = ' ';
119 p = stpncpy(p, argv[i], limit - p) + 1;
121 for (i = cmd_args; i < 4 && p < limit; i++) {
125 const char* q = p < limit ? p : limit;
126 for (p = buf; p < q; ) {
127 ssize_t bytes = write(fd, p, q - p);
136 // Mirror response from remote JVM to stdout
137 static int read_response(int fd, int argc, char** argv, int print_output) {
139 ssize_t bytes = read(fd, buf, sizeof(buf) - 1);
141 fprintf(stderr, "Unexpected EOF reading response\n");
143 } else if (bytes < 0) {
144 perror("Error reading response");
148 // First line of response is the command result code
150 int result = atoi(buf);
152 // Special treatment of 'load' command
153 if (result == 0 && argc > 0 && strcmp(argv[0], "load") == 0) {
154 size_t total = bytes;
155 while (total < sizeof(buf) - 1 && (bytes = read(fd, buf + total, sizeof(buf) - 1 - total)) > 0) {
156 total += (size_t)bytes;
160 // The second line is the result of 'load' command; since JDK 9 it starts from "return code: "
162 result = atoi(strncmp(buf + 2, "return code: ", 13) == 0 ? buf + 15 : buf + 2);
166 // Mirror JVM response to stdout
167 printf("JVM response code = ");
169 fwrite(buf, 1, bytes, stdout);
170 bytes = read(fd, buf, sizeof(buf));
178 int jattach_hotspot(int pid, int nspid, int argc, char** argv, int print_output) {
179 if (check_socket(nspid) != 0 && start_attach_mechanism(pid, nspid) != 0) {
180 perror("Could not start attach mechanism");
184 int fd = connect_socket(nspid);
186 perror("Could not connect to socket");
191 printf("Connected to remote JVM\n");
194 if (write_command(fd, argc, argv) != 0) {
195 perror("Error writing to socket");
200 int result = read_response(fd, argc, argv, print_output);