Mercurial > hg > truffle
view src/os/solaris/vm/attachListener_solaris.cpp @ 20295:3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
author | tschatzl |
---|---|
date | Mon, 21 Jul 2014 10:00:31 +0200 |
parents | 2e8f19c2feef |
children |
line wrap: on
line source
/* * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "runtime/interfaceSupport.hpp" #include "runtime/os.hpp" #include "services/attachListener.hpp" #include "services/dtraceAttacher.hpp" #include <door.h> #include <string.h> #include <signal.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/stat.h> // stropts.h uses STR in stream ioctl defines #undef STR #include <stropts.h> #undef STR #define STR(a) #a // The attach mechanism on Solaris is implemented using the Doors IPC // mechanism. The first tool to attempt to attach causes the attach // listener thread to startup. This thread creats a door that is // associated with a function that enqueues an operation to the attach // listener. The door is attached to a file in the file system so that // client (tools) can locate it. To enqueue an operation to the VM the // client calls through the door which invokes the enqueue function in // this process. The credentials of the client are checked and if the // effective uid matches this process then the operation is enqueued. // When an operation completes the attach listener is required to send the // operation result and any result data to the client. In this implementation // the result is returned via a UNIX domain socket. A pair of connected // sockets (socketpair) is created in the enqueue function and the file // descriptor for one of the sockets is returned to the client as the // return from the door call. The other end is retained in this process. // When the operation completes the result is sent to the client and // the socket is closed. // forward reference class SolarisAttachOperation; class SolarisAttachListener: AllStatic { private: // the path to which we attach the door file descriptor static char _door_path[PATH_MAX+1]; static volatile bool _has_door_path; // door descriptor returned by door_create static int _door_descriptor; static void set_door_path(char* path) { if (path == NULL) { _has_door_path = false; } else { strncpy(_door_path, path, PATH_MAX); _door_path[PATH_MAX] = '\0'; // ensure it's nul terminated _has_door_path = true; } } static void set_door_descriptor(int dd) { _door_descriptor = dd; } // mutex to protect operation list static mutex_t _mutex; // semaphore to wakeup listener thread static sema_t _wakeup; static mutex_t* mutex() { return &_mutex; } static sema_t* wakeup() { return &_wakeup; } // enqueued operation list static SolarisAttachOperation* _head; static SolarisAttachOperation* _tail; static SolarisAttachOperation* head() { return _head; } static void set_head(SolarisAttachOperation* head) { _head = head; } static SolarisAttachOperation* tail() { return _tail; } static void set_tail(SolarisAttachOperation* tail) { _tail = tail; } // create the door static int create_door(); public: enum { ATTACH_PROTOCOL_VER = 1 // protocol version }; enum { ATTACH_ERROR_BADREQUEST = 100, // error code returned by ATTACH_ERROR_BADVERSION = 101, // the door call ATTACH_ERROR_RESOURCE = 102, ATTACH_ERROR_INTERNAL = 103, ATTACH_ERROR_DENIED = 104 }; // initialize the listener static int init(); static bool has_door_path() { return _has_door_path; } static char* door_path() { return _door_path; } static int door_descriptor() { return _door_descriptor; } // enqueue an operation static void enqueue(SolarisAttachOperation* op); // dequeue an operation static SolarisAttachOperation* dequeue(); }; // SolarisAttachOperation is an AttachOperation that additionally encapsulates // a socket connection to the requesting client/tool. SolarisAttachOperation // can additionally be held in a linked list. class SolarisAttachOperation: public AttachOperation { private: friend class SolarisAttachListener; // connection to client int _socket; // linked list support SolarisAttachOperation* _next; SolarisAttachOperation* next() { return _next; } void set_next(SolarisAttachOperation* next) { _next = next; } public: void complete(jint res, bufferedStream* st); int socket() const { return _socket; } void set_socket(int s) { _socket = s; } SolarisAttachOperation(char* name) : AttachOperation(name) { set_socket(-1); set_next(NULL); } }; // statics char SolarisAttachListener::_door_path[PATH_MAX+1]; volatile bool SolarisAttachListener::_has_door_path; int SolarisAttachListener::_door_descriptor = -1; mutex_t SolarisAttachListener::_mutex; sema_t SolarisAttachListener::_wakeup; SolarisAttachOperation* SolarisAttachListener::_head = NULL; SolarisAttachOperation* SolarisAttachListener::_tail = NULL; // Supporting class to help split a buffer into individual components class ArgumentIterator : public StackObj { private: char* _pos; char* _end; public: ArgumentIterator(char* arg_buffer, size_t arg_size) { _pos = arg_buffer; _end = _pos + arg_size - 1; } char* next() { if (*_pos == '\0') { return NULL; } char* res = _pos; char* next_pos = strchr(_pos, '\0'); if (next_pos < _end) { next_pos++; } _pos = next_pos; return res; } }; // Calls from the door function to check that the client credentials // match this process. Returns 0 if credentials okay, otherwise -1. static int check_credentials() { door_cred_t cred_info; // get client credentials if (door_cred(&cred_info) == -1) { return -1; // unable to get them } // get our euid/eguid (probably could cache these) uid_t euid = geteuid(); gid_t egid = getegid(); // check that the effective uid/gid matches - discuss this with Jeff. if (cred_info.dc_euid == euid && cred_info.dc_egid == egid) { return 0; // okay } else { return -1; // denied } } // Parses the argument buffer to create an AttachOperation that we should // enqueue to the attach listener. // The buffer is expected to be formatted as follows: // <ver>0<cmd>0<arg>0<arg>0<arg>0 // where <ver> is the version number (must be "1"), <cmd> is the command // name ("load, "datadump", ...) and <arg> is an argument. // static SolarisAttachOperation* create_operation(char* argp, size_t arg_size, int* err) { // assume bad request until parsed *err = SolarisAttachListener::ATTACH_ERROR_BADREQUEST; if (arg_size < 2 || argp[arg_size-1] != '\0') { return NULL; // no ver or not null terminated } // Use supporting class to iterate over the buffer ArgumentIterator args(argp, arg_size); // First check the protocol version char* ver = args.next(); if (ver == NULL) { return NULL; } if (atoi(ver) != SolarisAttachListener::ATTACH_PROTOCOL_VER) { *err = SolarisAttachListener::ATTACH_ERROR_BADVERSION; return NULL; } // Get command name and create the operation char* name = args.next(); if (name == NULL || strlen(name) > AttachOperation::name_length_max) { return NULL; } SolarisAttachOperation* op = new SolarisAttachOperation(name); // Iterate over the arguments for (int i=0; i<AttachOperation::arg_count_max; i++) { char* arg = args.next(); if (arg == NULL) { op->set_arg(i, NULL); } else { if (strlen(arg) > AttachOperation::arg_length_max) { delete op; return NULL; } op->set_arg(i, arg); } } // return operation *err = 0; return op; } // create special operation to indicate all clients have detached static SolarisAttachOperation* create_detachall_operation() { return new SolarisAttachOperation(AttachOperation::detachall_operation_name()); } // This is door function which the client executes via a door_call. extern "C" { static void enqueue_proc(void* cookie, char* argp, size_t arg_size, door_desc_t* dt, uint_t n_desc) { int return_fd = -1; SolarisAttachOperation* op = NULL; // no listener jint res = 0; if (!AttachListener::is_initialized()) { // how did we get here? debug_only(warning("door_call when not enabled")); res = (jint)SolarisAttachListener::ATTACH_ERROR_INTERNAL; } // check client credentials if (res == 0) { if (check_credentials() != 0) { res = (jint)SolarisAttachListener::ATTACH_ERROR_DENIED; } } // if we are stopped at ShowMessageBoxOnError then maybe we can // load a diagnostic library if (res == 0 && is_error_reported()) { if (ShowMessageBoxOnError) { // TBD - support loading of diagnostic library here } // can't enqueue operation after fatal error res = (jint)SolarisAttachListener::ATTACH_ERROR_RESOURCE; } // create the operation if (res == 0) { int err; op = create_operation(argp, arg_size, &err); res = (op == NULL) ? (jint)err : 0; } // create a pair of connected sockets. Store the file descriptor // for one end in the operation and enqueue the operation. The // file descriptor for the other end wil be returned to the client. if (res == 0) { int s[2]; if (socketpair(PF_UNIX, SOCK_STREAM, 0, s) < 0) { delete op; res = (jint)SolarisAttachListener::ATTACH_ERROR_RESOURCE; } else { op->set_socket(s[0]); return_fd = s[1]; SolarisAttachListener::enqueue(op); } } // Return 0 (success) + file descriptor, or non-0 (error) if (res == 0) { door_desc_t desc; // DOOR_RELEASE flag makes sure fd is closed after passing it to // the client. See door_return(3DOOR) man page. desc.d_attributes = DOOR_DESCRIPTOR | DOOR_RELEASE; desc.d_data.d_desc.d_descriptor = return_fd; door_return((char*)&res, sizeof(res), &desc, 1); } else { door_return((char*)&res, sizeof(res), NULL, 0); } } } // atexit hook to detach the door and remove the file extern "C" { static void listener_cleanup() { static int cleanup_done; if (!cleanup_done) { cleanup_done = 1; int dd = SolarisAttachListener::door_descriptor(); if (dd >= 0) { ::close(dd); } if (SolarisAttachListener::has_door_path()) { char* path = SolarisAttachListener::door_path(); ::fdetach(path); ::unlink(path); } } } } // Create the door int SolarisAttachListener::create_door() { char door_path[PATH_MAX+1]; char initial_path[PATH_MAX+1]; int fd, res; // register exit function ::atexit(listener_cleanup); // create the door descriptor int dd = ::door_create(enqueue_proc, NULL, 0); if (dd < 0) { return -1; } // create initial file to attach door descriptor snprintf(door_path, sizeof(door_path), "%s/.java_pid%d", os::get_temp_directory(), os::current_process_id()); snprintf(initial_path, sizeof(initial_path), "%s.tmp", door_path); RESTARTABLE(::creat(initial_path, S_IRUSR | S_IWUSR), fd); if (fd == -1) { debug_only(warning("attempt to create %s failed", initial_path)); ::door_revoke(dd); return -1; } assert(fd >= 0, "bad file descriptor"); ::close(fd); // attach the door descriptor to the file if ((res = ::fattach(dd, initial_path)) == -1) { // if busy then detach and try again if (errno == EBUSY) { ::fdetach(initial_path); res = ::fattach(dd, initial_path); } if (res == -1) { ::door_revoke(dd); dd = -1; } } // rename file so that clients can attach if (dd >= 0) { if (::rename(initial_path, door_path) == -1) { ::close(dd); ::fdetach(initial_path); dd = -1; } } if (dd >= 0) { set_door_descriptor(dd); set_door_path(door_path); } else { // unable to create door, attach it to file, or rename file into place ::unlink(initial_path); return -1; } return 0; } // Initialization - create the door, locks, and other initialization int SolarisAttachListener::init() { if (create_door()) { return -1; } int status = os::Solaris::mutex_init(&_mutex); assert_status(status==0, status, "mutex_init"); status = ::sema_init(&_wakeup, 0, NULL, NULL); assert_status(status==0, status, "sema_init"); set_head(NULL); set_tail(NULL); return 0; } // Dequeue an operation SolarisAttachOperation* SolarisAttachListener::dequeue() { for (;;) { int res; // wait for somebody to enqueue something while ((res = ::sema_wait(wakeup())) == EINTR) ; if (res) { warning("sema_wait failed: %s", strerror(res)); return NULL; } // lock the list res = os::Solaris::mutex_lock(mutex()); assert(res == 0, "mutex_lock failed"); // remove the head of the list SolarisAttachOperation* op = head(); if (op != NULL) { set_head(op->next()); if (head() == NULL) { set_tail(NULL); } } // unlock os::Solaris::mutex_unlock(mutex()); // if we got an operation when return it. if (op != NULL) { return op; } } } // Enqueue an operation void SolarisAttachListener::enqueue(SolarisAttachOperation* op) { // lock list int res = os::Solaris::mutex_lock(mutex()); assert(res == 0, "mutex_lock failed"); // enqueue at tail op->set_next(NULL); if (head() == NULL) { set_head(op); } else { tail()->set_next(op); } set_tail(op); // wakeup the attach listener RESTARTABLE(::sema_post(wakeup()), res); assert(res == 0, "sema_post failed"); // unlock os::Solaris::mutex_unlock(mutex()); } // support function - writes the (entire) buffer to a socket static int write_fully(int s, char* buf, int len) { do { int n = ::write(s, buf, len); if (n == -1) { if (errno != EINTR) return -1; } else { buf += n; len -= n; } } while (len > 0); return 0; } // Complete an operation by sending the operation result and any result // output to the client. At this time the socket is in blocking mode so // potentially we can block if there is a lot of data and the client is // non-responsive. For most operations this is a non-issue because the // default send buffer is sufficient to buffer everything. In the future // if there are operations that involves a very big reply then it the // socket could be made non-blocking and a timeout could be used. void SolarisAttachOperation::complete(jint res, bufferedStream* st) { if (this->socket() >= 0) { JavaThread* thread = JavaThread::current(); ThreadBlockInVM tbivm(thread); thread->set_suspend_equivalent(); // cleared by handle_special_suspend_equivalent_condition() or // java_suspend_self() via check_and_wait_while_suspended() // write operation result char msg[32]; sprintf(msg, "%d\n", res); int rc = write_fully(this->socket(), msg, strlen(msg)); // write any result data if (rc == 0) { write_fully(this->socket(), (char*) st->base(), st->size()); ::shutdown(this->socket(), 2); } // close socket and we're done ::close(this->socket()); // were we externally suspended while we were waiting? thread->check_and_wait_while_suspended(); } delete this; } // AttachListener functions AttachOperation* AttachListener::dequeue() { JavaThread* thread = JavaThread::current(); ThreadBlockInVM tbivm(thread); thread->set_suspend_equivalent(); // cleared by handle_special_suspend_equivalent_condition() or // java_suspend_self() via check_and_wait_while_suspended() AttachOperation* op = SolarisAttachListener::dequeue(); // were we externally suspended while we were waiting? thread->check_and_wait_while_suspended(); return op; } // Performs initialization at vm startup // For Solaris we remove any stale .java_pid file which could cause // an attaching process to think we are ready to receive a door_call // before we are properly initialized void AttachListener::vm_start() { char fn[PATH_MAX+1]; struct stat64 st; int ret; int n = snprintf(fn, sizeof(fn), "%s/.java_pid%d", os::get_temp_directory(), os::current_process_id()); assert(n < sizeof(fn), "java_pid file name buffer overflow"); RESTARTABLE(::stat64(fn, &st), ret); if (ret == 0) { ret = ::unlink(fn); if (ret == -1) { debug_only(warning("failed to remove stale attach pid file at %s", fn)); } } } int AttachListener::pd_init() { JavaThread* thread = JavaThread::current(); ThreadBlockInVM tbivm(thread); thread->set_suspend_equivalent(); // cleared by handle_special_suspend_equivalent_condition() or // java_suspend_self() int ret_code = SolarisAttachListener::init(); // were we externally suspended while we were waiting? thread->check_and_wait_while_suspended(); return ret_code; } // Attach Listener is started lazily except in the case when // +ReduseSignalUsage is used bool AttachListener::init_at_startup() { if (ReduceSignalUsage) { return true; } else { return false; } } // If the file .attach_pid<pid> exists in the working directory // or /tmp then this is the trigger to start the attach mechanism bool AttachListener::is_init_trigger() { if (init_at_startup() || is_initialized()) { return false; // initialized at startup or already initialized } char fn[PATH_MAX+1]; sprintf(fn, ".attach_pid%d", os::current_process_id()); int ret; struct stat64 st; RESTARTABLE(::stat64(fn, &st), ret); if (ret == -1) { snprintf(fn, sizeof(fn), "%s/.attach_pid%d", os::get_temp_directory(), os::current_process_id()); RESTARTABLE(::stat64(fn, &st), ret); } if (ret == 0) { // simple check to avoid starting the attach mechanism when // a bogus user creates the file if (st.st_uid == geteuid()) { init(); return true; } } return false; } // if VM aborts then detach/cleanup void AttachListener::abort() { listener_cleanup(); } void AttachListener::pd_data_dump() { os::signal_notify(SIGQUIT); } static jint enable_dprobes(AttachOperation* op, outputStream* out) { const char* probe = op->arg(0); if (probe == NULL || probe[0] == '\0') { out->print_cr("No probe specified"); return JNI_ERR; } else { int probe_typess = atoi(probe); if (errno) { out->print_cr("invalid probe type"); return JNI_ERR; } else { DTrace::enable_dprobes(probe_typess); return JNI_OK; } } } // platform specific operations table static AttachOperationFunctionInfo funcs[] = { { "enabledprobes", enable_dprobes }, { NULL, NULL } }; AttachOperationFunctionInfo* AttachListener::pd_find_operation(const char* name) { int i; for (i = 0; funcs[i].name != NULL; i++) { if (strcmp(funcs[i].name, name) == 0) { return &funcs[i]; } } return NULL; } // Solaris specific global flag set. Currently, we support only // changing ExtendedDTraceProbes flag. jint AttachListener::pd_set_flag(AttachOperation* op, outputStream* out) { const char* name = op->arg(0); assert(name != NULL, "flag name should not be null"); bool flag = true; const char* arg1; if ((arg1 = op->arg(1)) != NULL) { flag = (atoi(arg1) != 0); if (errno) { out->print_cr("flag value has to be an integer"); return JNI_ERR; } } if (strcmp(name, "ExtendedDTraceProbes") == 0) { DTrace::set_extended_dprobes(flag); return JNI_OK; } if (strcmp(name, "DTraceMonitorProbes") == 0) { DTrace::set_monitor_dprobes(flag); return JNI_OK; } out->print_cr("flag '%s' cannot be changed", name); return JNI_ERR; } void AttachListener::pd_detachall() { DTrace::detach_all_clients(); }