jvm_dtrace.c revision 8819:c9eddfded3e5 
1/*
2 * Copyright (c) 2006, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#include <door.h>
26#include <errno.h>
27#include <fcntl.h>
28#include <limits.h>
29#include <poll.h>
30#include <signal.h>
31#include <stdarg.h>
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h>
35#include <sys/types.h>
36#include <sys/stat.h>
37#include <thread.h>
38#include <unistd.h>
39#include "jvm_dtrace.h"
40
41// NOTE: These constants are used in JVM code as well.
42// KEEP JVM CODE IN SYNC if you are going to change these...
43
44#define DTRACE_ALLOC_PROBES   0x1
45#define DTRACE_METHOD_PROBES  0x2
46#define DTRACE_MONITOR_PROBES 0x4
47#define DTRACE_ALL_PROBES     -1
48
49// generic error messages
50#define JVM_ERR_OUT_OF_MEMORY            "out of memory (native heap)"
51#define JVM_ERR_INVALID_PARAM            "invalid input parameter(s)"
52#define JVM_ERR_NULL_PARAM               "input paramater is NULL"
53
54// error messages for attach
55#define JVM_ERR_CANT_OPEN_DOOR           "cannot open door file"
56#define JVM_ERR_CANT_CREATE_ATTACH_FILE  "cannot create attach file"
57#define JVM_ERR_DOOR_FILE_PERMISSION     "door file is not secure"
58#define JVM_ERR_CANT_SIGNAL              "cannot send SIGQUIT to target"
59
60// error messages for enable probe
61#define JVM_ERR_DOOR_CMD_SEND            "door command send failed"
62#define JVM_ERR_DOOR_CANT_READ_STATUS    "cannot read door command status"
63#define JVM_ERR_DOOR_CMD_STATUS          "door command error status"
64
65// error message for detach
66#define JVM_ERR_CANT_CLOSE_DOOR          "cannot close door file"
67
68#define RESTARTABLE(_cmd, _result) do { \
69    do { \
70        _result = _cmd; \
71    } while((_result == -1) && (errno == EINTR)); \
72} while(0)
73
74struct _jvm_t {
75    pid_t pid;
76    int door_fd;
77};
78
79static int libjvm_dtrace_debug;
80static void print_debug(const char* fmt,...) {
81    if (libjvm_dtrace_debug) {
82        va_list alist;
83        va_start(alist, fmt);
84        fputs("libjvm_dtrace DEBUG: ", stderr);
85        vfprintf(stderr, fmt, alist);
86        va_end(alist);
87    }
88}
89
90/* Key for thread local error message */
91static thread_key_t jvm_error_key;
92
93/* init function for this library */
94static void init_jvm_dtrace() {
95    /* check for env. var for debug mode */
96    libjvm_dtrace_debug = getenv("LIBJVM_DTRACE_DEBUG") != NULL;
97    /* create key for thread local error message */
98    if (thr_keycreate(&jvm_error_key, NULL) != 0) {
99        print_debug("can't create thread_key_t for jvm error key\n");
100        // exit(1); ?
101    }
102}
103
104#pragma init(init_jvm_dtrace)
105
106/* set thread local error message */
107static void set_jvm_error(const char* msg) {
108    thr_setspecific(jvm_error_key, (void*)msg);
109}
110
111/* clear thread local error message */
112static void clear_jvm_error() {
113    thr_setspecific(jvm_error_key, NULL);
114}
115
116/* file handling functions that can handle interrupt */
117
118static int file_open(const char* path, int flag) {
119    int ret;
120    RESTARTABLE(open(path, flag), ret);
121    return ret;
122}
123
124static int file_close(int fd) {
125    return close(fd);
126}
127
128static int file_read(int fd, char* buf, int len) {
129    int ret;
130    RESTARTABLE(read(fd, buf, len), ret);
131    return ret;
132}
133
134/* send SIGQUIT signal to given process */
135static int send_sigquit(pid_t pid) {
136    int ret;
137    RESTARTABLE(kill(pid, SIGQUIT), ret);
138    return ret;
139}
140
141/* called to check permissions on attach file */
142static int check_permission(const char* path) {
143    struct stat64 sb;
144    uid_t uid, gid;
145    int res;
146
147    /*
148     * Check that the path is owned by the effective uid/gid of this
149     * process. Also check that group/other access is not allowed.
150     */
151    uid = geteuid();
152    gid = getegid();
153
154    res = stat64(path, &sb);
155    if (res != 0) {
156        print_debug("stat failed for %s\n", path);
157        return -1;
158    }
159
160    if ((sb.st_uid != uid) || (sb.st_gid != gid) ||
161        ((sb.st_mode & (S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)) != 0)) {
162        print_debug("well-known file %s is not secure\n", path);
163        return -1;
164    }
165    return 0;
166}
167
168#define ATTACH_FILE_PATTERN "/tmp/.attach_pid%d"
169
170/* fill-in the name of attach file name in given buffer */
171static void fill_attach_file_name(char* path, int len, pid_t pid) {
172    memset(path, 0, len);
173    sprintf(path, ATTACH_FILE_PATTERN, pid);
174}
175
176#define DOOR_FILE_PATTERN "/tmp/.java_pid%d"
177
178/* open door file for the given JVM */
179static int open_door(pid_t pid) {
180    char path[PATH_MAX + 1];
181    int fd;
182
183    sprintf(path, DOOR_FILE_PATTERN, pid);
184    fd = file_open(path, O_RDONLY);
185    if (fd < 0) {
186        set_jvm_error(JVM_ERR_CANT_OPEN_DOOR);
187        print_debug("cannot open door file %s\n", path);
188        return -1;
189    }
190    print_debug("opened door file %s\n", path);
191    if (check_permission(path) != 0) {
192        set_jvm_error(JVM_ERR_DOOR_FILE_PERMISSION);
193        print_debug("check permission failed for %s\n", path);
194        file_close(fd);
195        fd = -1;
196    }
197    return fd;
198}
199
200/* create attach file for given process */
201static int create_attach_file(pid_t pid) {
202    char path[PATH_MAX + 1];
203    int fd;
204    fill_attach_file_name(path, sizeof(path), pid);
205    fd = file_open(path, O_CREAT | O_RDWR);
206    if (fd < 0) {
207        set_jvm_error(JVM_ERR_CANT_CREATE_ATTACH_FILE);
208        print_debug("cannot create file %s\n", path);
209    } else {
210        print_debug("created attach file %s\n", path);
211    }
212    return fd;
213}
214
215/* delete attach file for given process */
216static void delete_attach_file(pid_t pid) {
217    char path[PATH_MAX + 1];
218    fill_attach_file_name(path, sizeof(path), pid);
219    int res = unlink(path);
220    if (res) {
221        print_debug("cannot delete attach file %s\n", path);
222    } else {
223        print_debug("deleted attach file %s\n", path);
224    }
225}
226
227/* attach to given JVM */
228jvm_t* jvm_attach(pid_t pid) {
229    jvm_t* jvm;
230    int door_fd, attach_fd, i = 0;
231
232    jvm = (jvm_t*) calloc(1, sizeof(jvm_t));
233    if (jvm == NULL) {
234        set_jvm_error(JVM_ERR_OUT_OF_MEMORY);
235        print_debug("calloc failed in %s at %d\n", __FILE__, __LINE__);
236        return NULL;
237    }
238    jvm->pid = pid;
239    attach_fd = -1;
240
241    door_fd = open_door(pid);
242    if (door_fd < 0) {
243        print_debug("trying to create attach file\n");
244        if ((attach_fd = create_attach_file(pid)) < 0) {
245            goto quit;
246        }
247
248        /* send QUIT signal to the target so that it will
249         * check for the attach file.
250         */
251        if (send_sigquit(pid) != 0) {
252            set_jvm_error(JVM_ERR_CANT_SIGNAL);
253            print_debug("sending SIGQUIT failed\n");
254            goto quit;
255        }
256
257        /* give the target VM time to start the attach mechanism */
258        do {
259            int res;
260            RESTARTABLE(poll(0, 0, 200), res);
261            door_fd = open_door(pid);
262            i++;
263        } while (i <= 50 && door_fd == -1);
264        if (door_fd < 0) {
265            print_debug("Unable to open door to process %d\n", pid);
266            goto quit;
267        }
268    }
269
270quit:
271    if (attach_fd >= 0) {
272        file_close(attach_fd);
273        delete_attach_file(jvm->pid);
274    }
275    if (door_fd >= 0) {
276        jvm->door_fd = door_fd;
277        clear_jvm_error();
278    } else {
279        free(jvm);
280        jvm = NULL;
281    }
282    return jvm;
283}
284
285/* return the last thread local error message */
286const char* jvm_get_last_error() {
287    const char* res = NULL;
288    thr_getspecific(jvm_error_key, (void**)&res);
289    return res;
290}
291
292/* detach the givenb JVM */
293int jvm_detach(jvm_t* jvm) {
294    if (jvm) {
295        int res = 0;
296        if (jvm->door_fd != -1) {
297            if (file_close(jvm->door_fd) != 0) {
298                set_jvm_error(JVM_ERR_CANT_CLOSE_DOOR);
299                res = -1;
300            } else {
301                clear_jvm_error();
302            }
303        }
304        free(jvm);
305        return res;
306    } else {
307        set_jvm_error(JVM_ERR_NULL_PARAM);
308        print_debug("jvm_t* is NULL\n");
309        return -1;
310    }
311}
312
313/*
314 * A simple table to translate some known errors into reasonable
315 * error messages
316 */
317static struct {
318    int err;
319    const char* msg;
320} const error_messages[] = {
321    { 100,      "Bad request" },
322    { 101,      "Protocol mismatch" },
323    { 102,      "Resource failure" },
324    { 103,      "Internal error" },
325    { 104,      "Permission denied" },
326};
327
328/*
329 * Lookup the given error code and return the appropriate
330 * message. If not found return NULL.
331 */
332static const char* translate_error(int err) {
333    int table_size = sizeof(error_messages) / sizeof(error_messages[0]);
334    int i;
335
336    for (i=0; i<table_size; i++) {
337        if (err == error_messages[i].err) {
338            return error_messages[i].msg;
339        }
340    }
341    return NULL;
342}
343
344/*
345 * Current protocol version
346 */
347static const char* PROTOCOL_VERSION = "1";
348
349#define RES_BUF_SIZE 128
350
351/*
352 * Enqueue attach-on-demand command to the given JVM
353 */
354static
355int enqueue_command(jvm_t* jvm, const char* cstr, int arg_count, const char** args) {
356    size_t size;
357    door_arg_t door_args;
358    char res_buffer[RES_BUF_SIZE];
359    int rc, i;
360    char* buf = NULL;
361    int result = -1;
362
363    /*
364     * First we get the command string and create the start of the
365     * argument string to send to the target VM:
366     * <ver>\0<cmd>\0
367     */
368    if (cstr == NULL) {
369        print_debug("command name is NULL\n");
370        goto quit;
371    }
372    size = strlen(PROTOCOL_VERSION) + strlen(cstr) + 2;
373    buf = (char*)malloc(size);
374    if (buf != NULL) {
375        char* pos = buf;
376        strcpy(buf, PROTOCOL_VERSION);
377        pos += strlen(PROTOCOL_VERSION)+1;
378        strcpy(pos, cstr);
379    } else {
380        set_jvm_error(JVM_ERR_OUT_OF_MEMORY);
381        print_debug("malloc failed at %d in %s\n", __LINE__, __FILE__);
382        goto quit;
383    }
384
385    /*
386     * Next we iterate over the arguments and extend the buffer
387     * to include them.
388     */
389    for (i=0; i<arg_count; i++) {
390        cstr = args[i];
391        if (cstr != NULL) {
392            size_t len = strlen(cstr);
393            char* newbuf = (char*)realloc(buf, size+len+1);
394            if (newbuf == NULL) {
395                set_jvm_error(JVM_ERR_OUT_OF_MEMORY);
396                print_debug("realloc failed in %s at %d\n", __FILE__, __LINE__);
397                goto quit;
398            }
399            buf = newbuf;
400            strcpy(buf+size, cstr);
401            size += len+1;
402        }
403    }
404
405    /*
406     * The arguments to the door function are in 'buf' so we now
407     * do the door call
408     */
409    door_args.data_ptr = buf;
410    door_args.data_size = size;
411    door_args.desc_ptr = NULL;
412    door_args.desc_num = 0;
413    door_args.rbuf = (char*)&res_buffer;
414    door_args.rsize = sizeof(res_buffer);
415
416    RESTARTABLE(door_call(jvm->door_fd, &door_args), rc);
417
418    /*
419     * door_call failed
420     */
421    if (rc == -1) {
422        print_debug("door_call failed\n");
423    } else {
424        /*
425         * door_call succeeded but the call didn't return the the expected jint.
426         */
427        if (door_args.data_size < sizeof(int)) {
428            print_debug("Enqueue error - reason unknown as result is truncated!");
429        } else {
430            int* res = (int*)(door_args.data_ptr);
431            if (*res != 0) {
432                const char* msg = translate_error(*res);
433                if (msg == NULL) {
434                    print_debug("Unable to enqueue command to target VM: %d\n", *res);
435                } else {
436                    print_debug("Unable to enqueue command to target VM: %s\n", msg);
437                }
438            } else {
439                /*
440                 * The door call should return a file descriptor to one end of
441                 * a socket pair
442                 */
443                if ((door_args.desc_ptr != NULL) &&
444                    (door_args.desc_num == 1) &&
445                    (door_args.desc_ptr->d_attributes & DOOR_DESCRIPTOR)) {
446                    result = door_args.desc_ptr->d_data.d_desc.d_descriptor;
447                } else {
448                    print_debug("Reply from enqueue missing descriptor!\n");
449                }
450            }
451        }
452    }
453
454quit:
455    if (buf) free(buf);
456    return result;
457}
458
459/* read status code for a door command */
460static int read_status(int fd) {
461    char ch, buf[16];
462    int index = 0;
463
464    while (1) {
465        if (file_read(fd, &ch, sizeof(ch)) != sizeof(ch)) {
466            set_jvm_error(JVM_ERR_DOOR_CANT_READ_STATUS);
467            print_debug("door cmd status: read status failed\n");
468            return -1;
469        }
470        buf[index++] = ch;
471        if (ch == '\n') {
472            buf[index - 1] = '\0';
473            return atoi(buf);
474        }
475        if (index == sizeof(buf)) {
476            set_jvm_error(JVM_ERR_DOOR_CANT_READ_STATUS);
477            print_debug("door cmd status: read status overflow\n");
478            return -1;
479        }
480    }
481}
482
483static const char* ENABLE_DPROBES_CMD = "enabledprobes";
484
485/* enable one or more DTrace probes for a given JVM */
486int jvm_enable_dtprobes(jvm_t* jvm, int num_probe_types, const char** probe_types) {
487    int fd, status = 0;
488    char ch;
489    const char* args[1];
490    char buf[16];
491    int probe_type = 0, index;
492    int count = 0;
493
494    if (jvm == NULL) {
495        set_jvm_error(JVM_ERR_NULL_PARAM);
496        print_debug("jvm_t* is NULL\n");
497        return -1;
498    }
499
500    if (num_probe_types == 0 || probe_types == NULL ||
501        probe_types[0] == NULL) {
502        set_jvm_error(JVM_ERR_INVALID_PARAM);
503        print_debug("invalid probe type argument(s)\n");
504        return -1;
505    }
506
507    for (index = 0; index < num_probe_types; index++) {
508        const char* p = probe_types[index];
509        if (strcmp(p, JVM_DTPROBE_OBJECT_ALLOC) == 0) {
510            probe_type |= DTRACE_ALLOC_PROBES;
511            count++;
512        } else if (strcmp(p, JVM_DTPROBE_METHOD_ENTRY) == 0 ||
513                   strcmp(p, JVM_DTPROBE_METHOD_RETURN) == 0) {
514            probe_type |= DTRACE_METHOD_PROBES;
515            count++;
516        } else if (strcmp(p, JVM_DTPROBE_MONITOR_ENTER) == 0   ||
517                   strcmp(p, JVM_DTPROBE_MONITOR_ENTERED) == 0 ||
518                   strcmp(p, JVM_DTPROBE_MONITOR_EXIT) == 0    ||
519                   strcmp(p, JVM_DTPROBE_MONITOR_WAIT) == 0    ||
520                   strcmp(p, JVM_DTPROBE_MONITOR_WAITED) == 0  ||
521                   strcmp(p, JVM_DTPROBE_MONITOR_NOTIFY) == 0  ||
522                   strcmp(p, JVM_DTPROBE_MONITOR_NOTIFYALL) == 0) {
523            probe_type |= DTRACE_MONITOR_PROBES;
524            count++;
525        } else if (strcmp(p, JVM_DTPROBE_ALL) == 0) {
526            probe_type |= DTRACE_ALL_PROBES;
527            count++;
528        }
529    }
530
531    if (count == 0) {
532        return count;
533    }
534    sprintf(buf, "%d", probe_type);
535    args[0] = buf;
536
537    fd = enqueue_command(jvm, ENABLE_DPROBES_CMD, 1, args);
538    if (fd < 0) {
539        set_jvm_error(JVM_ERR_DOOR_CMD_SEND);
540        return -1;
541    }
542
543    status = read_status(fd);
544    // non-zero status is error
545    if (status) {
546        set_jvm_error(JVM_ERR_DOOR_CMD_STATUS);
547        print_debug("%s command failed (status: %d) in target JVM\n",
548                    ENABLE_DPROBES_CMD, status);
549        file_close(fd);
550        return -1;
551    }
552    // read from stream until EOF
553    while (file_read(fd, &ch, sizeof(ch)) == sizeof(ch)) {
554        if (libjvm_dtrace_debug) {
555            printf("%c", ch);
556        }
557    }
558
559    file_close(fd);
560    clear_jvm_error();
561    return count;
562}
563