graal-jvmci-8: src/os/linux/vm/attachListener

comparison src/os/linux/vm/attachListener_linux.cpp @ 0:a61af66fc99e jdk7-b24

Initial load

author	duke
date	Sat, 01 Dec 2007 00:00:00 +0000
parents
children	485d403e94e1

comparison

equal deleted inserted replaced

--1:000000000000
+:a61af66fc99e
+/*
+* Copyright 2005-2006 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* CA 95054 USA or visit www.sun.com if you need additional information or
+* have any questions.
+*
+*/
+# include "incls/_precompiled.incl"
+# include "incls/_attachListener_linux.cpp.incl"
+#include <unistd.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+// The attach mechanism on Linux uses a UNIX domain socket. An attach listener
+// thread is created at startup or is created on-demand via a signal from
+// the client tool. The attach listener creates a socket and binds it to a file
+// in the filesystem. The attach listener then acts as a simple (single-
+// threaded) server - tt waits for a client to connect, reads the request,
+// executes it, and returns the response to the client via the socket
+// connection.
+//
+// As the socket is a UNIX domain socket it means that only clients on the
+// local machine can connect. In addition there are two other aspects to
+// the security:
+// 1. The well known file that the socket is bound to has permission 400
+// 2. When a client connect, the SO_PEERCRED socket option is used to
+//    obtain the credentials of client. We check that the effective uid
+//    of the client matches this process.
+// forward reference
+class LinuxAttachOperation;
+class LinuxAttachListener: AllStatic {
+private:
+// the path to which we bind the UNIX domain socket
+static char _path[PATH_MAX+1];
+static bool _has_path;
+// the file descriptor for the listening socket
+static int _listener;
+static void set_path(char* path) {
+if (path == NULL) {
+_has_path = false;
+} else {
+strncpy(_path, path, PATH_MAX);
+_path[PATH_MAX] = '\0';
+_has_path = true;
+}
+}
+static void set_listener(int s)               { _listener = s; }
+// reads a request from the given connected socket
+static LinuxAttachOperation* read_request(int s);
+public:
+enum {
+ATTACH_PROTOCOL_VER = 1                     // protocol version
+};
+enum {
+ATTACH_ERROR_BADVERSION     = 101           // error codes
+};
+// initialize the listener, returns 0 if okay
+static int init();
+static char* path()                   { return _path; }
+static bool has_path()                { return _has_path; }
+static int listener()                 { return _listener; }
+// write the given buffer to a socket
+static int write_fully(int s, char* buf, int len);
+static LinuxAttachOperation* dequeue();
+};
+class LinuxAttachOperation: public AttachOperation {
+private:
+// the connection to the client
+int _socket;
+public:
+void complete(jint res, bufferedStream* st);
+void set_socket(int s)                                { _socket = s; }
+int socket() const                                    { return _socket; }
+LinuxAttachOperation(char* name) : AttachOperation(name) {
+set_socket(-1);
+}
+};
+// statics
+char LinuxAttachListener::_path[PATH_MAX+1];
+bool LinuxAttachListener::_has_path;
+int LinuxAttachListener::_listener = -1;
+// 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;
+}
+};
+// atexit hook to stop listener and unlink the file that it is
+// bound too.
+extern "C" {
+static void listener_cleanup() {
+static int cleanup_done;
+if (!cleanup_done) {
+cleanup_done = 1;
+int s = LinuxAttachListener::listener();
+if (s != -1) {
+::close(s);
+}
+if (LinuxAttachListener::has_path()) {
+::unlink(LinuxAttachListener::path());
+}
+}
+}
+}
+// Initialization - create a listener socket and bind it to a file
+int LinuxAttachListener::init() {
+char path[PATH_MAX+1];        // socket file
+int listener;                 // listener socket (file descriptor)
+// register function to cleanup
+::atexit(listener_cleanup);
+// create the listener socket
+listener = ::socket(PF_UNIX, SOCK_STREAM, 0);
+if (listener == -1) {
+return -1;
+}
+int res = -1;
+struct sockaddr_un addr;
+addr.sun_family = AF_UNIX;
+// FIXME: Prior to b39 the tool-side API expected to find the well
+// known file in the working directory. To allow this libjvm.so work with
+// a pre-b39 SDK we create it in the working directory if
+// +StartAttachListener is used is used. All unit tests for this feature
+// currently used this flag. Once b39 SDK has been promoted we can remove
+// this code.
+if (StartAttachListener) {
+sprintf(path, ".java_pid%d", os::current_process_id());
+strcpy(addr.sun_path, path);
+::unlink(path);
+res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
+}
+if (res == -1) {
+sprintf(path, "%s/.java_pid%d", os::get_temp_directory(), os::current_process_id());
+strcpy(addr.sun_path, path);
+::unlink(path);
+res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
+}
+if (res == -1) {
+RESTARTABLE(::close(listener), res);
+return -1;
+}
+set_path(path);
+// put in listen mode and set permission
+if ((::listen(listener, 5) == -1) || (::chmod(path, S_IREAD|S_IWRITE) == -1)) {
+RESTARTABLE(::close(listener), res);
+::unlink(path);
+set_path(NULL);
+return -1;
+}
+set_listener(listener);
+return 0;
+}
+// Given a socket that is connected to a peer we read the request and
+// create an AttachOperation. As the socket is blocking there is potential
+// for a denial-of-service if the peer does not response. However this happens
+// after the peer credentials have been checked and in the worst case it just
+// means that the attach listener thread is blocked.
+//
+LinuxAttachOperation* LinuxAttachListener::read_request(int s) {
+char ver_str[8];
+sprintf(ver_str, "%d", ATTACH_PROTOCOL_VER);
+// The request is a sequence of strings so we first figure out the
+// expected count and the maximum possible length of the request.
+// The request is:
+//   <ver>0<cmd>0<arg>0<arg>0<arg>0
+// where <ver> is the protocol version (1), <cmd> is the command
+// name ("load", "datadump", ...), and <arg> is an argument
+int expected_str_count = 2 + AttachOperation::arg_count_max;
+int max_len = (strlen(ver_str) + 1) + (AttachOperation::name_length_max + 1) +
+AttachOperation::arg_count_max*(AttachOperation::arg_length_max + 1);
+char buf[max_len];
+int str_count = 0;
+// Read until all (expected) strings have been read, the buffer is
+// full, or EOF.
+int off = 0;
+int left = max_len;
+do {
+int n;
+RESTARTABLE(read(s, buf+off, left), n);
+if (n == -1) {
+return NULL;      // reset by peer or other error
+}
+if (n == 0) {
+break;
+}
+for (int i=0; i<n; i++) {
+if (buf[off+i] == 0) {
+// EOS found
+str_count++;
+// The first string is <ver> so check it now to
+// check for protocol mis-match
+if (str_count == 1) {
+if ((strlen(buf) != strlen(ver_str)) ||
+(atoi(buf) != ATTACH_PROTOCOL_VER)) {
+char msg[32];
+sprintf(msg, "%d\n", ATTACH_ERROR_BADVERSION);
+write_fully(s, msg, strlen(msg));
+return NULL;
+}
+}
+}
+}
+off += n;
+left -= n;
+} while (left > 0 && str_count < expected_str_count);
+if (str_count != expected_str_count) {
+return NULL;        // incomplete request
+}
+// parse request
+ArgumentIterator args(buf, (max_len)-left);
+// version already checked
+char* v = args.next();
+char* name = args.next();
+if (name == NULL || strlen(name) > AttachOperation::name_length_max) {
+return NULL;
+}
+LinuxAttachOperation* op = new LinuxAttachOperation(name);
+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);
+}
+}
+op->set_socket(s);
+return op;
+}
+// Dequeue an operation
+//
+// In the Linux implementation there is only a single operation and clients
+// cannot queue commands (except at the socket level).
+//
+LinuxAttachOperation* LinuxAttachListener::dequeue() {
+for (;;) {
+int s;
+// wait for client to connect
+struct sockaddr addr;
+socklen_t len = sizeof(addr);
+RESTARTABLE(::accept(listener(), &addr, &len), s);
+if (s == -1) {
+return NULL;      // log a warning?
+}
+// get the credentials of the peer and check the effective uid/guid
+// - check with jeff on this.
+struct ucred cred_info;
+socklen_t optlen = sizeof(cred_info);
+if (::getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void*)&cred_info, &optlen) == -1) {
+int res;
+RESTARTABLE(::close(s), res);
+continue;
+}
+uid_t euid = geteuid();
+gid_t egid = getegid();
+if (cred_info.uid != euid || cred_info.gid != egid) {
+int res;
+RESTARTABLE(::close(s), res);
+continue;
+}
+// peer credential look okay so we read the request
+LinuxAttachOperation* op = read_request(s);
+if (op == NULL) {
+int res;
+RESTARTABLE(::close(s), res);
+continue;
+} else {
+return op;
+}
+}
+}
+// write the given buffer to the socket
+int LinuxAttachListener::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 LinuxAttachOperation::complete(jint result, bufferedStream* st) {
+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", result);
+int rc = LinuxAttachListener::write_fully(this->socket(), msg, strlen(msg));
+// write any result data
+if (rc == 0) {
+LinuxAttachListener::write_fully(this->socket(), (char*) st->base(), st->size());
+::shutdown(this->socket(), 2);
+}
+// done
+RESTARTABLE(::close(this->socket()), rc);
+// 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 = LinuxAttachListener::dequeue();
+// were we externally suspended while we were waiting?
+thread->check_and_wait_while_suspended();
+return op;
+}
+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() via check_and_wait_while_suspended()
+int ret_code = LinuxAttachListener::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[32];
+sprintf(fn, ".attach_pid%d", os::current_process_id());
+int ret;
+struct stat64 st;
+RESTARTABLE(::stat64(fn, &st), ret);
+if (ret == -1) {
+sprintf(fn, "/tmp/.attach_pid%d", 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 remove listener
+void AttachListener::abort() {
+listener_cleanup();
+}
+void AttachListener::pd_data_dump() {
+os::signal_notify(SIGQUIT);
+}
+AttachOperationFunctionInfo* AttachListener::pd_find_operation(const char* n) {
+return NULL;
+}
+jint AttachListener::pd_set_flag(AttachOperation* op, outputStream* out) {
+out->print_cr("flag '%s' cannot be changed", op->arg(0));
+return JNI_ERR;
+}
+void AttachListener::pd_detachall() {
+// do nothing for now
+}

Mercurial > hg > graal-jvmci-8

comparison src/os/linux/vm/attachListener_linux.cpp @ 0:a61af66fc99e jdk7-b24