jdk8-mips64-public/hotspot: src/os/linux/vm/attachListener

src/os/linux/vm/attachListener_linux.cpp@f90c822e73f8 (annotated)

src/os/linux/vm/attachListener_linux.cpp

Wed, 27 Apr 2016 01:25:04 +0800

author: aoqi
date: Wed, 27 Apr 2016 01:25:04 +0800
changeset 0: f90c822e73f8
child 6876: 710a3c8b516e
permissions: -rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/
changeset: 6782:28b50d07f6f8
tag: jdk8u25-b17

 /*
  * 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 <unistd.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <sys/stat.h>
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX   sizeof(((struct sockaddr_un *)0)->sun_path)
 #endif
 // 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 - it 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[UNIX_PATH_MAX];
   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, UNIX_PATH_MAX);
       _path[UNIX_PATH_MAX-1] = '\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[UNIX_PATH_MAX];
 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[UNIX_PATH_MAX];          // socket file
   char initial_path[UNIX_PATH_MAX];  // socket file during setup
   int listener;                      // listener socket (file descriptor)
   // register function to cleanup
   ::atexit(listener_cleanup);
   int n = snprintf(path, UNIX_PATH_MAX, "%s/.java_pid%d",
                    os::get_temp_directory(), os::current_process_id());
   if (n < (int)UNIX_PATH_MAX) {
     n = snprintf(initial_path, UNIX_PATH_MAX, "%s.tmp", path);
   }
   if (n >= (int)UNIX_PATH_MAX) {
     return -1;
   }
   // create the listener socket
   listener = ::socket(PF_UNIX, SOCK_STREAM, 0);
   if (listener == -1) {
     return -1;
   }
   // bind socket
   struct sockaddr_un addr;
   addr.sun_family = AF_UNIX;
   strcpy(addr.sun_path, initial_path);
   ::unlink(initial_path);
   int res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
   if (res == -1) {
     ::close(listener);
     return -1;
   }
   // put in listen mode, set permissions, and rename into place
   res = ::listen(listener, 5);
   if (res == 0) {
       RESTARTABLE(::chmod(initial_path, S_IREAD|S_IWRITE), res);
       if (res == 0) {
           res = ::rename(initial_path, path);
       }
   }
   if (res == -1) {
     ::close(listener);
     ::unlink(initial_path);
     return -1;
   }
   set_path(path);
   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;
   const int max_len = (sizeof(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) {
       ::close(s);
       continue;
     }
     uid_t euid = geteuid();
     gid_t egid = getegid();
     if (cred_info.uid != euid || cred_info.gid != egid) {
       ::close(s);
       continue;
     }
     // peer credential look okay so we read the request
     LinuxAttachOperation* op = read_request(s);
     if (op == NULL) {
       ::close(s);
       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
   ::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 = LinuxAttachListener::dequeue();
   // were we externally suspended while we were waiting?
   thread->check_and_wait_while_suspended();
   return op;
 }
 // Performs initialization at vm startup
 // For Linux we remove any stale .java_pid file which could cause
 // an attaching process to think we are ready to receive on the
 // domain socket before we are properly initialized
 void AttachListener::vm_start() {
   char fn[UNIX_PATH_MAX];
   struct stat64 st;
   int ret;
   int n = snprintf(fn, UNIX_PATH_MAX, "%s/.java_pid%d",
            os::get_temp_directory(), os::current_process_id());
   assert(n < (int)UNIX_PATH_MAX, "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() 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[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 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 > jdk8-mips64-public > hotspot / annotate

src/os/linux/vm/attachListener_linux.cpp@f90c822e73f8 (annotated)

src/os/linux/vm/attachListener_linux.cpp