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

src/os/solaris/vm/attachListener_solaris.cpp@f73af4455d7d (annotated)

src/os/solaris/vm/attachListener_solaris.cpp

Thu, 29 May 2014 09:56:06 -0700

author: asaha
date: Thu, 29 May 2014 09:56:06 -0700
changeset 6782: f73af4455d7d
parent 5412: 2e8f19c2feef
child 6876: 710a3c8b516e
permissions: -rw-r--r--

Merge

 /*
  * 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();
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/os/solaris/vm/attachListener_solaris.cpp@f73af4455d7d (annotated)

src/os/solaris/vm/attachListener_solaris.cpp