1 /*
   2  * Copyright (c) 2005, 2019, 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 "precompiled.hpp"
  26 #include "runtime/interfaceSupport.hpp"
  27 #include "runtime/os.hpp"
  28 #include "services/attachListener.hpp"
  29 #include "services/dtraceAttacher.hpp"
  30 
  31 #include <unistd.h>
  32 #include <signal.h>
  33 #include <sys/types.h>
  34 #include <sys/socket.h>
  35 #include <sys/un.h>
  36 #include <sys/stat.h>
  37 
  38 #ifndef UNIX_PATH_MAX
  39 #define UNIX_PATH_MAX   sizeof(((struct sockaddr_un *)0)->sun_path)
  40 #endif
  41 
  42 // The attach mechanism on Linux uses a UNIX domain socket. An attach listener
  43 // thread is created at startup or is created on-demand via a signal from
  44 // the client tool. The attach listener creates a socket and binds it to a file
  45 // in the filesystem. The attach listener then acts as a simple (single-
  46 // threaded) server - it waits for a client to connect, reads the request,
  47 // executes it, and returns the response to the client via the socket
  48 // connection.
  49 //
  50 // As the socket is a UNIX domain socket it means that only clients on the
  51 // local machine can connect. In addition there are two other aspects to
  52 // the security:
  53 // 1. The well known file that the socket is bound to has permission 400
  54 // 2. When a client connect, the SO_PEERCRED socket option is used to
  55 //    obtain the credentials of client. We check that the effective uid
  56 //    of the client matches this process.
  57 
  58 // forward reference
  59 class LinuxAttachOperation;
  60 
  61 class LinuxAttachListener: AllStatic {
  62  private:
  63   // the path to which we bind the UNIX domain socket
  64   static char _path[UNIX_PATH_MAX];
  65   static bool _has_path;
  66 
  67   // the file descriptor for the listening socket
  68   static int _listener;
  69 
  70   static bool _atexit_registered;
  71 
  72   // reads a request from the given connected socket
  73   static LinuxAttachOperation* read_request(int s);
  74 
  75  public:
  76   enum {
  77     ATTACH_PROTOCOL_VER = 1                     // protocol version
  78   };
  79   enum {
  80     ATTACH_ERROR_BADVERSION     = 101           // error codes
  81   };
  82 
  83   static void set_path(char* path) {
  84     if (path == NULL) {
  85       _path[0] = '\0';
  86       _has_path = false;
  87     } else {
  88       strncpy(_path, path, UNIX_PATH_MAX);
  89       _path[UNIX_PATH_MAX-1] = '\0';
  90       _has_path = true;
  91     }
  92   }
  93 
  94   static void set_listener(int s)               { _listener = s; }
  95 
  96   // initialize the listener, returns 0 if okay
  97   static int init();
  98 
  99   static char* path()                   { return _path; }
 100   static bool has_path()                { return _has_path; }
 101   static int listener()                 { return _listener; }
 102 
 103   // write the given buffer to a socket
 104   static int write_fully(int s, char* buf, int len);
 105 
 106   static LinuxAttachOperation* dequeue();
 107 };
 108 
 109 class LinuxAttachOperation: public AttachOperation {
 110  private:
 111   // the connection to the client
 112   int _socket;
 113 
 114  public:
 115   void complete(jint res, bufferedStream* st);
 116 
 117   void set_socket(int s)                                { _socket = s; }
 118   int socket() const                                    { return _socket; }
 119 
 120   LinuxAttachOperation(char* name) : AttachOperation(name) {
 121     set_socket(-1);
 122   }
 123 };
 124 
 125 // statics
 126 char LinuxAttachListener::_path[UNIX_PATH_MAX];
 127 bool LinuxAttachListener::_has_path;
 128 int LinuxAttachListener::_listener = -1;
 129 bool LinuxAttachListener::_atexit_registered = false;
 130 
 131 // Supporting class to help split a buffer into individual components
 132 class ArgumentIterator : public StackObj {
 133  private:
 134   char* _pos;
 135   char* _end;
 136  public:
 137   ArgumentIterator(char* arg_buffer, size_t arg_size) {
 138     _pos = arg_buffer;
 139     _end = _pos + arg_size - 1;
 140   }
 141   char* next() {
 142     if (*_pos == '\0') {
 143       return NULL;
 144     }
 145     char* res = _pos;
 146     char* next_pos = strchr(_pos, '\0');
 147     if (next_pos < _end)  {
 148       next_pos++;
 149     }
 150     _pos = next_pos;
 151     return res;
 152   }
 153 };
 154 
 155 
 156 // atexit hook to stop listener and unlink the file that it is
 157 // bound too.
 158 extern "C" {
 159   static void listener_cleanup() {
 160     int s = LinuxAttachListener::listener();
 161     if (s != -1) {
 162       LinuxAttachListener::set_listener(-1);
 163       ::shutdown(s, SHUT_RDWR);
 164       ::close(s);
 165     }
 166     if (LinuxAttachListener::has_path()) {
 167       ::unlink(LinuxAttachListener::path());
 168       LinuxAttachListener::set_path(NULL);
 169     }
 170   }
 171 }
 172 
 173 // Initialization - create a listener socket and bind it to a file
 174 
 175 int LinuxAttachListener::init() {
 176   char path[UNIX_PATH_MAX];          // socket file
 177   char initial_path[UNIX_PATH_MAX];  // socket file during setup
 178   int listener;                      // listener socket (file descriptor)
 179 
 180   // register function to cleanup
 181   if (!_atexit_registered) {
 182     _atexit_registered = true;
 183     ::atexit(listener_cleanup);
 184   }
 185 
 186   int n = snprintf(path, UNIX_PATH_MAX, "%s/.java_pid%d",
 187                    os::get_temp_directory(), os::current_process_id());
 188   if (n < (int)UNIX_PATH_MAX) {
 189     n = snprintf(initial_path, UNIX_PATH_MAX, "%s.tmp", path);
 190   }
 191   if (n >= (int)UNIX_PATH_MAX) {
 192     return -1;
 193   }
 194 
 195   // create the listener socket
 196   listener = ::socket(PF_UNIX, SOCK_STREAM, 0);
 197   if (listener == -1) {
 198     return -1;
 199   }
 200 
 201   // bind socket
 202   struct sockaddr_un addr;
 203   addr.sun_family = AF_UNIX;
 204   strcpy(addr.sun_path, initial_path);
 205   ::unlink(initial_path);
 206   int res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
 207   if (res == -1) {
 208     ::close(listener);
 209     return -1;
 210   }
 211 
 212   // put in listen mode, set permissions, and rename into place
 213   res = ::listen(listener, 5);
 214   if (res == 0) {
 215       RESTARTABLE(::chmod(initial_path, S_IREAD|S_IWRITE), res);
 216       if (res == 0) {
 217           res = ::rename(initial_path, path);
 218       }
 219   }
 220   if (res == -1) {
 221     ::close(listener);
 222     ::unlink(initial_path);
 223     return -1;
 224   }
 225   set_path(path);
 226   set_listener(listener);
 227 
 228   return 0;
 229 }
 230 
 231 // Given a socket that is connected to a peer we read the request and
 232 // create an AttachOperation. As the socket is blocking there is potential
 233 // for a denial-of-service if the peer does not response. However this happens
 234 // after the peer credentials have been checked and in the worst case it just
 235 // means that the attach listener thread is blocked.
 236 //
 237 LinuxAttachOperation* LinuxAttachListener::read_request(int s) {
 238   char ver_str[8];
 239   sprintf(ver_str, "%d", ATTACH_PROTOCOL_VER);
 240 
 241   // The request is a sequence of strings so we first figure out the
 242   // expected count and the maximum possible length of the request.
 243   // The request is:
 244   //   <ver>0<cmd>0<arg>0<arg>0<arg>0
 245   // where <ver> is the protocol version (1), <cmd> is the command
 246   // name ("load", "datadump", ...), and <arg> is an argument
 247   int expected_str_count = 2 + AttachOperation::arg_count_max;
 248   const int max_len = (sizeof(ver_str) + 1) + (AttachOperation::name_length_max + 1) +
 249     AttachOperation::arg_count_max*(AttachOperation::arg_length_max + 1);
 250 
 251   char buf[max_len];
 252   int str_count = 0;
 253 
 254   // Read until all (expected) strings have been read, the buffer is
 255   // full, or EOF.
 256 
 257   int off = 0;
 258   int left = max_len;
 259 
 260   do {
 261     int n;
 262     RESTARTABLE(read(s, buf+off, left), n);
 263     if (n == -1) {
 264       return NULL;      // reset by peer or other error
 265     }
 266     if (n == 0) {
 267       break;
 268     }
 269     for (int i=0; i<n; i++) {
 270       if (buf[off+i] == 0) {
 271         // EOS found
 272         str_count++;
 273 
 274         // The first string is <ver> so check it now to
 275         // check for protocol mis-match
 276         if (str_count == 1) {
 277           if ((strlen(buf) != strlen(ver_str)) ||
 278               (atoi(buf) != ATTACH_PROTOCOL_VER)) {
 279             char msg[32];
 280             sprintf(msg, "%d\n", ATTACH_ERROR_BADVERSION);
 281             write_fully(s, msg, strlen(msg));
 282             return NULL;
 283           }
 284         }
 285       }
 286     }
 287     off += n;
 288     left -= n;
 289   } while (left > 0 && str_count < expected_str_count);
 290 
 291   if (str_count != expected_str_count) {
 292     return NULL;        // incomplete request
 293   }
 294 
 295   // parse request
 296 
 297   ArgumentIterator args(buf, (max_len)-left);
 298 
 299   // version already checked
 300   char* v = args.next();
 301 
 302   char* name = args.next();
 303   if (name == NULL || strlen(name) > AttachOperation::name_length_max) {
 304     return NULL;
 305   }
 306 
 307   LinuxAttachOperation* op = new LinuxAttachOperation(name);
 308 
 309   for (int i=0; i<AttachOperation::arg_count_max; i++) {
 310     char* arg = args.next();
 311     if (arg == NULL) {
 312       op->set_arg(i, NULL);
 313     } else {
 314       if (strlen(arg) > AttachOperation::arg_length_max) {
 315         delete op;
 316         return NULL;
 317       }
 318       op->set_arg(i, arg);
 319     }
 320   }
 321 
 322   op->set_socket(s);
 323   return op;
 324 }
 325 
 326 
 327 // Dequeue an operation
 328 //
 329 // In the Linux implementation there is only a single operation and clients
 330 // cannot queue commands (except at the socket level).
 331 //
 332 LinuxAttachOperation* LinuxAttachListener::dequeue() {
 333   for (;;) {
 334     int s;
 335 
 336     // wait for client to connect
 337     struct sockaddr addr;
 338     socklen_t len = sizeof(addr);
 339     RESTARTABLE(::accept(listener(), &addr, &len), s);
 340     if (s == -1) {
 341       return NULL;      // log a warning?
 342     }
 343 
 344     // get the credentials of the peer and check the effective uid/guid
 345     // - check with jeff on this.
 346     struct ucred cred_info;
 347     socklen_t optlen = sizeof(cred_info);
 348     if (::getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void*)&cred_info, &optlen) == -1) {
 349       ::close(s);
 350       continue;
 351     }
 352     uid_t euid = geteuid();
 353     gid_t egid = getegid();
 354 
 355     if (cred_info.uid != euid || cred_info.gid != egid) {
 356       ::close(s);
 357       continue;
 358     }
 359 
 360     // peer credential look okay so we read the request
 361     LinuxAttachOperation* op = read_request(s);
 362     if (op == NULL) {
 363       ::close(s);
 364       continue;
 365     } else {
 366       return op;
 367     }
 368   }
 369 }
 370 
 371 // write the given buffer to the socket
 372 int LinuxAttachListener::write_fully(int s, char* buf, int len) {
 373   do {
 374     int n = ::write(s, buf, len);
 375     if (n == -1) {
 376       if (errno != EINTR) return -1;
 377     } else {
 378       buf += n;
 379       len -= n;
 380     }
 381   }
 382   while (len > 0);
 383   return 0;
 384 }
 385 
 386 // Complete an operation by sending the operation result and any result
 387 // output to the client. At this time the socket is in blocking mode so
 388 // potentially we can block if there is a lot of data and the client is
 389 // non-responsive. For most operations this is a non-issue because the
 390 // default send buffer is sufficient to buffer everything. In the future
 391 // if there are operations that involves a very big reply then it the
 392 // socket could be made non-blocking and a timeout could be used.
 393 
 394 void LinuxAttachOperation::complete(jint result, bufferedStream* st) {
 395   JavaThread* thread = JavaThread::current();
 396   ThreadBlockInVM tbivm(thread);
 397 
 398   thread->set_suspend_equivalent();
 399   // cleared by handle_special_suspend_equivalent_condition() or
 400   // java_suspend_self() via check_and_wait_while_suspended()
 401 
 402   // write operation result
 403   char msg[32];
 404   sprintf(msg, "%d\n", result);
 405   int rc = LinuxAttachListener::write_fully(this->socket(), msg, strlen(msg));
 406 
 407   // write any result data
 408   if (rc == 0) {
 409     LinuxAttachListener::write_fully(this->socket(), (char*) st->base(), st->size());
 410     ::shutdown(this->socket(), 2);
 411   }
 412 
 413   // done
 414   ::close(this->socket());
 415 
 416   // were we externally suspended while we were waiting?
 417   thread->check_and_wait_while_suspended();
 418 
 419   delete this;
 420 }
 421 
 422 
 423 // AttachListener functions
 424 
 425 AttachOperation* AttachListener::dequeue() {
 426   JavaThread* thread = JavaThread::current();
 427   ThreadBlockInVM tbivm(thread);
 428 
 429   thread->set_suspend_equivalent();
 430   // cleared by handle_special_suspend_equivalent_condition() or
 431   // java_suspend_self() via check_and_wait_while_suspended()
 432 
 433   AttachOperation* op = LinuxAttachListener::dequeue();
 434 
 435   // were we externally suspended while we were waiting?
 436   thread->check_and_wait_while_suspended();
 437 
 438   return op;
 439 }
 440 
 441 
 442 // Performs initialization at vm startup
 443 // For Linux we remove any stale .java_pid file which could cause
 444 // an attaching process to think we are ready to receive on the
 445 // domain socket before we are properly initialized
 446 
 447 void AttachListener::vm_start() {
 448   char fn[UNIX_PATH_MAX];
 449   struct stat64 st;
 450   int ret;
 451 
 452   int n = snprintf(fn, UNIX_PATH_MAX, "%s/.java_pid%d",
 453            os::get_temp_directory(), os::current_process_id());
 454   assert(n < (int)UNIX_PATH_MAX, "java_pid file name buffer overflow");
 455 
 456   RESTARTABLE(::stat64(fn, &st), ret);
 457   if (ret == 0) {
 458     ret = ::unlink(fn);
 459     if (ret == -1) {
 460       debug_only(warning("failed to remove stale attach pid file at %s", fn));
 461     }
 462   }
 463 }
 464 
 465 int AttachListener::pd_init() {
 466   JavaThread* thread = JavaThread::current();
 467   ThreadBlockInVM tbivm(thread);
 468 
 469   thread->set_suspend_equivalent();
 470   // cleared by handle_special_suspend_equivalent_condition() or
 471   // java_suspend_self() via check_and_wait_while_suspended()
 472 
 473   int ret_code = LinuxAttachListener::init();
 474 
 475   // were we externally suspended while we were waiting?
 476   thread->check_and_wait_while_suspended();
 477 
 478   return ret_code;
 479 }
 480 
 481 bool AttachListener::check_socket_file() {
 482   int ret;
 483   struct stat64 st;
 484   ret = stat64(LinuxAttachListener::path(), &st);
 485   if (ret == -1) { // need to restart attach listener.
 486     debug_only(warning("Socket file %s does not exist - Restart Attach Listener",
 487                       LinuxAttachListener::path()));
 488 
 489     listener_cleanup();
 490 
 491     // wait to terminate current attach listener instance...
 492     while (AttachListener::transit_state(AL_INITIALIZING,
 493                                          AL_NOT_INITIALIZED) != AL_NOT_INITIALIZED) {
 494       os::yield();
 495     }
 496     return is_init_trigger();
 497   }
 498   return false;
 499 }
 500 
 501 // Attach Listener is started lazily except in the case when
 502 // +ReduseSignalUsage is used
 503 bool AttachListener::init_at_startup() {
 504   if (ReduceSignalUsage) {
 505     return true;
 506   } else {
 507     return false;
 508   }
 509 }
 510 
 511 // If the file .attach_pid<pid> exists in the working directory
 512 // or /tmp then this is the trigger to start the attach mechanism
 513 bool AttachListener::is_init_trigger() {
 514   if (init_at_startup() || is_initialized()) {
 515     return false;               // initialized at startup or already initialized
 516   }
 517   char fn[PATH_MAX+1];
 518   sprintf(fn, ".attach_pid%d", os::current_process_id());
 519   int ret;
 520   struct stat64 st;
 521   RESTARTABLE(::stat64(fn, &st), ret);
 522   if (ret == -1) {
 523     snprintf(fn, sizeof(fn), "%s/.attach_pid%d",
 524              os::get_temp_directory(), os::current_process_id());
 525     RESTARTABLE(::stat64(fn, &st), ret);
 526   }
 527   if (ret == 0) {
 528     // simple check to avoid starting the attach mechanism when
 529     // a bogus user creates the file
 530     if (st.st_uid == geteuid()) {
 531       init();
 532       return true;
 533     }
 534   }
 535   return false;
 536 }
 537 
 538 // if VM aborts then remove listener
 539 void AttachListener::abort() {
 540   listener_cleanup();
 541 }
 542 
 543 void AttachListener::pd_data_dump() {
 544   os::signal_notify(SIGQUIT);
 545 }
 546 
 547 AttachOperationFunctionInfo* AttachListener::pd_find_operation(const char* n) {
 548   return NULL;
 549 }
 550 
 551 jint AttachListener::pd_set_flag(AttachOperation* op, outputStream* out) {
 552   out->print_cr("flag '%s' cannot be changed", op->arg(0));
 553   return JNI_ERR;
 554 }
 555 
 556 void AttachListener::pd_detachall() {
 557   // do nothing for now
 558 }