src/posix/jattach_hotspot.c

   1 /*
   2  * Copyright 2021 Andrei Pangin
   3  *
   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
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/socket.h>
  21 #include <sys/stat.h>
  22 #include <sys/un.h>
  23 #include <fcntl.h>
  24 #include <signal.h>
  25 #include <time.h>
  26 #include <unistd.h>
  27 #include "psutil.h"
  28
  29
  30 // Check if remote JVM has already opened socket for Dynamic Attach
  31 static int check_socket(int pid) {
  32     char path[MAX_PATH];
  33     snprintf(path, sizeof(path), "%s/.java_pid%d", tmp_path, pid);
  34
  35     struct stat stats;
  36     return stat(path, &stats) == 0 && S_ISSOCK(stats.st_mode) ? 0 : -1;
  37 }
  38
  39 // Check if a file is owned by current user
  40 static uid_t get_file_owner(const char* path) {
  41     struct stat stats;
  42     return stat(path, &stats) == 0 ? stats.st_uid : (uid_t)-1;
  43 }
  44
  45 // Force remote JVM to start Attach listener.
  46 // HotSpot will start Attach listener in response to SIGQUIT if it sees .attach_pid file
  47 static int start_attach_mechanism(int pid, int nspid) {
  48     char path[MAX_PATH];
  49     snprintf(path, sizeof(path), "/proc/%d/cwd/.attach_pid%d", nspid, nspid);
  50
  51     int fd = creat(path, 0660);
  52     if (fd == -1 || (close(fd) == 0 && get_file_owner(path) != geteuid())) {
  53         // Some mounted filesystems may change the ownership of the file.
  54         // JVM will not trust such file, so it's better to remove it and try a different path
  55         unlink(path);
  56
  57         // Failed to create attach trigger in current directory. Retry in /tmp
  58         snprintf(path, sizeof(path), "%s/.attach_pid%d", tmp_path, nspid);
  59         fd = creat(path, 0660);
  60         if (fd == -1) {
  61             return -1;
  62         }
  63         close(fd);
  64     }
  65
  66     // We have to still use the host namespace pid here for the kill() call
  67     kill(pid, SIGQUIT);
  68
  69     // Start with 20 ms sleep and increment delay each iteration. Total timeout is 6000 ms
  70     struct timespec ts = {0, 20000000};
  71     int result;
  72     do {
  73         nanosleep(&ts, NULL);
  74         result = check_socket(nspid);
  75     } while (result != 0 && (ts.tv_nsec += 20000000) < 500000000);
  76
  77     unlink(path);
  78     return result;
  79 }
  80
  81 // Connect to UNIX domain socket created by JVM for Dynamic Attach
  82 static int connect_socket(int pid) {
  83     int fd = socket(PF_UNIX, SOCK_STREAM, 0);
  84     if (fd == -1) {
  85         return -1;
  86     }
  87
  88     struct sockaddr_un addr;
  89     addr.sun_family = AF_UNIX;
  90
  91     int bytes = snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/.java_pid%d", tmp_path, pid);
  92     if (bytes >= sizeof(addr.sun_path)) {
  93         addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
  94     }
  95
  96     if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
  97         close(fd);
  98         return -1;
  99     }
 100     return fd;
 101 }
 102
 103 // Send command with arguments to socket
 104 static int write_command(int fd, int argc, char** argv) {
 105     // Protocol version
 106     if (write(fd, "1", 2) <= 0) {
 107         return -1;
 108     }
 109
 110     int i;
 111     for (i = 0; i < 4; i++) {
 112         const char* arg = i < argc ? argv[i] : "";
 113         if (write(fd, arg, strlen(arg) + 1) <= 0) {
 114             return -1;
 115         }
 116     }
 117     return 0;
 118 }
 119
 120 // Mirror response from remote JVM to stdout
 121 static int read_response(int fd, int argc, char** argv) {
 122     char buf[8192];
 123     ssize_t bytes = read(fd, buf, sizeof(buf) - 1);
 124     if (bytes == 0) {
 125         fprintf(stderr, "Unexpected EOF reading response\n");
 126         return 1;
 127     } else if (bytes < 0) {
 128         perror("Error reading response");
 129         return 1;
 130     }
 131
 132     // First line of response is the command result code
 133     buf[bytes] = 0;
 134     int result = atoi(buf);
 135
 136     // Special treatment of 'load' command
 137     if (result == 0 && argc > 0 && strcmp(argv[0], "load") == 0) {
 138         size_t total = bytes;
 139         while (total < sizeof(buf) - 1 && (bytes = read(fd, buf + total, sizeof(buf) - 1 - total)) > 0) {
 140             total += (size_t)bytes;
 141         }
 142         bytes = total;
 143
 144         // The second line is the result of 'load' command; since JDK 9 it starts from "return code: "
 145         buf[bytes] = 0;
 146         result = atoi(strncmp(buf + 2, "return code: ", 13) == 0 ? buf + 15 : buf + 2);
 147     }
 148
 149     // Mirror JVM response to stdout
 150     printf("JVM response code = ");
 151     do {
 152         fwrite(buf, 1, bytes, stdout);
 153         bytes = read(fd, buf, sizeof(buf));
 154     } while (bytes > 0);
 155     printf("\n");
 156
 157     return result;
 158 }
 159
 160 int jattach_hotspot(int pid, int nspid, int argc, char** argv) {
 161     if (check_socket(nspid) != 0 && start_attach_mechanism(pid, nspid) != 0) {
 162         perror("Could not start attach mechanism");
 163         return 1;
 164     }
 165
 166     int fd = connect_socket(nspid);
 167     if (fd == -1) {
 168         perror("Could not connect to socket");
 169         return 1;
 170     }
 171
 172     printf("Connected to remote JVM\n");
 173
 174     if (write_command(fd, argc, argv) != 0) {
 175         perror("Error writing to socket");
 176         close(fd);
 177         return 1;
 178     }
 179
 180     int result = read_response(fd, argc, argv);
 181     close(fd);
 182
 183     return result;
 184 }