1 /*

     2  * Copyright (c) 2000, 2002, 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 // This is the implementation of a very simple dbx import module which

    26 // handles requests from the VM which come in over a socket. The

    27 // higher-level Java wrapper for dbx starts the debugger, attaches to

    28 // the process, imports this command, and runs it. After that, the SA

    29 // writes commands to this agent via its own private communications

    30 // channel. The intent is to move away from the text-based front-end

    31 // completely in the near future (no more calling "debug" by printing

    32 // text to dbx's stdin).

    33 

    34 #include <stdio.h>

    35 #include <errno.h>

    36 #include <ctype.h>

    37 #include <sys/types.h>

    38 #include <sys/socket.h>

    39 #include <unistd.h>

    40 #include <string.h>

    41 #include <stropts.h>

    42 #include <netinet/in.h>

    43 #include <netinet/tcp.h>

    44 

    45 #include <proc_service.h>

    46 #include <sys/procfs_isa.h>

    47 #include <rtld_db.h>

    48 #include "proc_service_2.h"

    49 #include "svc_agent_dbx.hpp"

    50 

    51 static ServiceabilityAgentDbxModule* module = NULL;

    52 #define NEEDS_CLEANUP

    53 

    54 // Useful for debugging

    55 #define VERBOSE_DEBUGGING

    56 

    57 #ifdef VERBOSE_DEBUGGING

    58 # define debug_only(x) x

    59 #else

    60 # define debug_only(x)

    61 #endif

    62 

    63 // For profiling

    64 //#define PROFILING

    65 

    66 #ifdef PROFILING

    67 #define PROFILE_COUNT 200

    68 static Timer scanTimer;

    69 static Timer workTimer;

    70 static Timer writeTimer;

    71 static int numRequests = 0;

    72 #endif /* PROFILING */

    73 

    74 const char* ServiceabilityAgentDbxModule::CMD_ADDRESS_SIZE   = "address_size";

    75 const char* ServiceabilityAgentDbxModule::CMD_PEEK_FAIL_FAST = "peek_fail_fast";

    76 const char* ServiceabilityAgentDbxModule::CMD_PEEK           = "peek";

    77 const char* ServiceabilityAgentDbxModule::CMD_POKE           = "poke";

    78 const char* ServiceabilityAgentDbxModule::CMD_MAPPED         = "mapped";

    79 const char* ServiceabilityAgentDbxModule::CMD_LOOKUP         = "lookup";

    80 const char* ServiceabilityAgentDbxModule::CMD_THR_GREGS      = "thr_gregs";

    81 const char* ServiceabilityAgentDbxModule::CMD_EXIT           = "exit";

    82 

    83 // The initialization routines must not have C++ name mangling

    84 extern "C" {

    85 

    86 /** This is the initialization routine called by dbx upon importing of

    87     this module. Returns 0 upon successful initialization, -1 upon

    88     failure. */

    89 int shell_imp_init(int major, int minor,

    90                    shell_imp_interp_t interp, int argc, char *argv[])

    91 {

    92   // Ensure shell interpreter data structure is laid out the way we

    93   // expect

    94   if (major != SHELL_IMP_MAJOR) {

    95     debug_only(fprintf(stderr, "Serviceability agent: unexpected value for SHELL_IMP_MAJOR (got %d, expected %d)\n", major, SHELL_IMP_MAJOR);)

    96     return -1;

    97   }

    98   if (minor < SHELL_IMP_MINOR) {

    99     debug_only(fprintf(stderr, "Serviceability agent: unexpected value for SHELL_IMP_MINOR (got %d, expected >= %d)\n", minor, SHELL_IMP_MINOR);)

   100     return -1;

   101   }

   102 

   103   if (module != NULL) {

   104     debug_only(fprintf(stderr, "Serviceability agent: module appears to already be initialized (should not happen)\n");)

   105     // Already initialized. Should not happen.

   106     return -1;

   107   }

   108 

   109   module = new ServiceabilityAgentDbxModule(major, minor, interp, argc, argv);

   110   if (!module->install()) {

   111     debug_only(fprintf(stderr, "Serviceability agent: error installing import module\n");)

   112     delete module;

   113     module = NULL;

   114     return -1;

   115   }

   116 

   117   // Installation was successful. Next step will be for the user to

   118   // enter the appropriate command on the command line, which will

   119   // make the SA's dbx module wait for commands to come in over the

   120   // socket.

   121   return 0;

   122 }

   123 

   124 /** This is the routine called by dbx upon unloading of this module.

   125     Returns 0 upon success, -1 upon failure. */

   126 int

   127 shell_imp_fini(shell_imp_interp_t)

   128 {

   129   if (module == NULL) {

   130     return -1;

   131   }

   132 

   133   bool res = module->uninstall();

   134   delete module;

   135   module = NULL;

   136   if (!res) {

   137     return -1;

   138   }

   139   return 0;

   140 }

   141 

   142 } // extern "C"

   143 

   144 /** This is the routine which is called by the dbx shell when the user

   145     requests the serviceability agent module to run. This delegates to

   146     ServiceabilityAgentDbxModule::run. This routine's signature must

   147     match that of shell_imp_fun_t. */

   148 extern "C" {

   149 static int

   150 svc_agent_run(shell_imp_interp_t, int, char **, void *) {

   151   if (module == NULL) {

   152     return -1;

   153   }

   154 

   155   module->run();

   156   return 0;

   157 }

   158 }

   159 

   160 /*

   161  * Implementation of ServiceabilityAgentDbxModule class

   162  */

   163 

   164 // NOTE: we need to forward declare the special "ps_get_prochandle2"

   165 // function which allows examination of core files as well. It isn't

   166 // currently in proc_service_2.h. Note also that it has name mangling

   167 // because it isn't declared extern "C".

   168 //const struct ps_prochandle *ps_get_prochandle2(int cores_too);

   169 

   170 ServiceabilityAgentDbxModule::ServiceabilityAgentDbxModule(int, int, shell_imp_interp_t interp,

   171                                                            int argc, char *argv[])

   172   :myComm(32768, 131072)

   173 {

   174   _interp = interp;

   175   _argc = argc;

   176   _argv = argv;

   177   _tdb_agent = NULL;

   178   peek_fail_fast = false;

   179   libThreadName = NULL;

   180 }

   181 

   182 ServiceabilityAgentDbxModule::~ServiceabilityAgentDbxModule() {

   183   if (_command != NULL) {

   184     uninstall();

   185   }

   186 }

   187 

   188 char*

   189 readCStringFromProcess(psaddr_t addr) {

   190   char c;

   191   int num = 0;

   192   ps_prochandle* cur_proc = (ps_prochandle*) ps_get_prochandle2(1);

   193 

   194   // Search for null terminator

   195   do {

   196     if (ps_pread(cur_proc, addr + num, &c, 1) != PS_OK) {

   197       return NULL;

   198     }

   199     ++num;

   200   } while (c != 0);

   201 

   202   // Allocate string

   203   char* res = new char[num];

   204   if (ps_pread(cur_proc, addr, res, num) != PS_OK) {

   205     delete[] res;

   206     return NULL;

   207   }

   208   return res;

   209 }

   210 

   211 int

   212 findLibThreadCB(const rd_loadobj_t* lo, void* data) {

   213   ServiceabilityAgentDbxModule* module = (ServiceabilityAgentDbxModule*) data;

   214   char* name = readCStringFromProcess(lo->rl_nameaddr);

   215   if (strstr(name, "libthread.so") != NULL) {

   216     module->libThreadName = name;

   217     return 0;

   218   } else {

   219     delete[] name;

   220     return 1;

   221   }

   222 }

   223 

   224 bool

   225 ServiceabilityAgentDbxModule::install() {

   226   // NOTE interdependency between here and Java side wrapper

   227   // FIXME: casts of string literal to char * to match prototype

   228   _command = shell_imp_define_command((char *) "svc_agent_run",

   229                                       &svc_agent_run,

   230                                       0,

   231                                       NULL,

   232                                       (char *) "Run the serviceability agent's dbx module.\n"

   233                                       "This routine causes the module to listen on a socket for requests.\n"

   234                                       "It does not return until the Java-side code tells it to exit, at\n"

   235                                       "which point control is returned to the dbx shell.");

   236   if (_command == NULL) {

   237     debug_only(fprintf(stderr, "Serviceability agent: Failed to install svc_agent_run command\n"));

   238     return false;

   239   }

   240 

   241   // This is fairly painful. Since dbx doesn't currently load

   242   // libthread_db with RTLD_GLOBAL, we can't just use RTLD_DEFAULT for

   243   // the argument to dlsym. Instead, we have to use rtld_db to search

   244   // through the loaded objects in the target process for libthread.so and

   245 

   246   // Try rtld_db

   247   if (rd_init(RD_VERSION) != RD_OK) {

   248     debug_only(fprintf(stderr, "Serviceability agent: Unable to init rtld_db\n"));

   249     return false;

   250   }

   251 

   252   rd_agent_t* rda = rd_new((struct ps_prochandle*) ps_get_prochandle2(1));

   253   if (rda == NULL) {

   254     debug_only(fprintf(stderr, "Serviceability agent: Unable to allocate rtld_db agent\n"));

   255     return false;

   256   }

   257 

   258   if (rd_loadobj_iter(rda, (rl_iter_f*) findLibThreadCB, this) != RD_OK) {

   259     debug_only(fprintf(stderr, "Serviceability agent: Loadobject iteration failed\n"));

   260     return false;

   261   }

   262 

   263   if (libThreadName == NULL) {

   264     debug_only(fprintf(stderr, "Serviceability agent: Failed to find pathname to libthread.so in target process\n"));

   265     return false;

   266   }

   267 

   268   // Find and open libthread_db.so

   269   char* slash = strrchr(libThreadName, '/');

   270   if (slash == NULL) {

   271     debug_only(fprintf(stderr, "Serviceability agent: can't parse path to libthread.so \"%s\"\n"));

   272     return false;

   273   }

   274 

   275   int slashPos = slash - libThreadName;

   276   char* buf = new char[slashPos + strlen("libthread_db.so") + 20]; // slop

   277   if (buf == NULL) {

   278     debug_only(fprintf(stderr, "Serviceability agent: error allocating libthread_db.so pathname\n"));

   279     return false;

   280   }

   281   strncpy(buf, libThreadName, slashPos + 1);

   282 

   283   // Check dbx's data model; use sparcv9/ subdirectory if 64-bit and

   284   // if target process is 32-bit

   285   if ((sizeof(void*) == 8) &&

   286       (strstr(libThreadName, "sparcv9") == NULL)) {

   287     strcpy(buf + slashPos + 1, "sparcv9/");

   288     slashPos += strlen("sparcv9/");

   289   }

   290 

   291   strcpy(buf + slashPos + 1, "libthread_db.so");

   292 

   293   libThreadDB = dlopen(buf, RTLD_LAZY);

   294   void* tmpDB = libThreadDB;

   295   if (libThreadDB == NULL) {

   296     debug_only(fprintf(stderr, "Serviceability agent: Warning: unable to find libthread_db.so at \"%s\"\n", buf));

   297     // Would like to handle this case as well. Maybe dbx has a better

   298     // idea of where libthread_db.so lies. If the problem with dbx

   299     // loading libthread_db without RTLD_GLOBAL specified ever gets

   300     // fixed, we could run this code all the time.

   301     tmpDB = RTLD_DEFAULT;

   302   }

   303 

   304   delete[] buf;

   305 

   306   // Initialize access to libthread_db

   307   td_init_fn          = (td_init_fn_t*)          dlsym(tmpDB, "td_init");

   308   td_ta_new_fn        = (td_ta_new_fn_t*)        dlsym(tmpDB, "td_ta_new");

   309   td_ta_delete_fn     = (td_ta_delete_fn_t*)     dlsym(tmpDB, "td_ta_delete");

   310   td_ta_map_id2thr_fn = (td_ta_map_id2thr_fn_t*) dlsym(tmpDB, "td_ta_map_id2thr");

   311   td_thr_getgregs_fn  = (td_thr_getgregs_fn_t*)  dlsym(tmpDB, "td_thr_getgregs");

   312 

   313   if (td_init_fn == NULL ||

   314       td_ta_new_fn == NULL ||

   315       td_ta_delete_fn == NULL ||

   316       td_ta_map_id2thr_fn == NULL ||

   317       td_thr_getgregs_fn == NULL) {

   318     debug_only(fprintf(stderr, "Serviceability agent: Failed to find one or more libthread_db symbols:\n"));

   319     debug_only(if (td_init_fn == NULL)          fprintf(stderr, "  td_init\n"));

   320     debug_only(if (td_ta_new_fn == NULL)        fprintf(stderr, "  td_ta_new\n"));

   321     debug_only(if (td_ta_delete_fn == NULL)     fprintf(stderr, "  td_ta_delete\n"));

   322     debug_only(if (td_ta_map_id2thr_fn == NULL) fprintf(stderr, "  td_ta_map_id2thr\n"));

   323     debug_only(if (td_thr_getgregs_fn == NULL)  fprintf(stderr, "  td_thr_getgregs\n"));

   324     return false;

   325   }

   326 

   327   if ((*td_init_fn)() != TD_OK) {

   328     debug_only(fprintf(stderr, "Serviceability agent: Failed to initialize libthread_db\n"));

   329     return false;

   330   }

   331 

   332   return true;

   333 }

   334 

   335 bool

   336 ServiceabilityAgentDbxModule::uninstall() {

   337   if (_command == NULL) {

   338     return false;

   339   }

   340 

   341   if (libThreadDB != NULL) {

   342     dlclose(libThreadDB);

   343     libThreadDB = NULL;

   344   }

   345 

   346   int res = shell_imp_undefine_command(_command);

   347 

   348   if (res != 0) {

   349     return false;

   350   }

   351 

   352   return true;

   353 }

   354 

   355 bool

   356 ServiceabilityAgentDbxModule::run() {

   357   // This is where most of the work gets done.

   358   // The command processor loop looks like the following:

   359   //  - create listening socket

   360   //  - accept a connection (only one for now)

   361   //  - while that connection is open and the "exit" command has not

   362   //    been received:

   363   //    - read command

   364   //    - if it's the exit command, cleanup and return

   365   //    - otherwise, process command and write result

   366 

   367   int listening_socket = socket(AF_INET, SOCK_STREAM, 0);

   368   if (listening_socket < 0) {

   369     return false;

   370   }

   371 

   372   // Set the SO_REUSEADDR property on the listening socket. This

   373   // prevents problems with calls to bind() to the same port failing

   374   // after this process exits. This seems to work on all platforms.

   375   int reuse_address = 1;

   376   if (setsockopt(listening_socket, SOL_SOCKET, SO_REUSEADDR,

   377                  (char *)&reuse_address, sizeof(reuse_address)) < 0) {

   378     close(listening_socket);

   379     return false;

   380   }

   381 

   382   sockaddr_in server_address;

   383   // Build the server address. We can bind the listening socket to the

   384   // INADDR_ANY internet address.

   385   memset((char*)&server_address, 0, sizeof(server_address));

   386   server_address.sin_family = AF_INET;

   387   server_address.sin_addr.s_addr = (unsigned long)htonl(INADDR_ANY);

   388   server_address.sin_port = htons((short)PORT);

   389 

   390   // Bind socket to port

   391   if (bind(listening_socket, (sockaddr*) &server_address,

   392            sizeof(server_address)) < 0) {

   393     close(listening_socket);

   394     return false;

   395   }

   396 

   397   // Arbitrarily chosen backlog of 5 (shouldn't matter since we expect

   398   // at most one connection)

   399   if (listen(listening_socket, 5) < 0) {

   400     close(listening_socket);

   401     return false;

   402   }

   403 

   404   // OK, now ready to wait for a data connection. This call to

   405   // accept() will block.

   406   struct sockaddr_in client_address;

   407   int address_len   = sizeof(client_address);

   408   int client_socket = accept(listening_socket, (sockaddr*) &client_address,

   409                          &address_len);

   410   // Close listening socket regardless of whether accept() succeeded.

   411   // (FIXME: this may be annoying, especially during debugging, but I

   412   // really feel that robustness and multiple connections should be

   413   // handled higher up, e.g., at the Java level -- multiple clients

   414   // could conceivably connect to the SA via RMI, and that would be a

   415   // more robust solution than implementing multiple connections at

   416   // this level)

   417   NEEDS_CLEANUP;

   418 

   419   // NOTE: the call to shutdown() usually fails, so don't panic if this happens

   420   shutdown(listening_socket, 2);

   421 

   422   if (close(listening_socket) < 0) {

   423     debug_only(fprintf(stderr, "Serviceability agent: Error closing listening socket\n"));

   424     return false;

   425   }

   426 

   427   if (client_socket < 0) {

   428     debug_only(fprintf(stderr, "Serviceability agent: Failed to open client socket\n"));

   429     // No more cleanup necessary

   430     return false;

   431   }

   432 

   433   // Attempt to disable TCP buffering on this socket. We send small

   434   // amounts of data back and forth and don't want buffering.

   435   int buffer_val = 1;

   436   if (setsockopt(client_socket, IPPROTO_IP, TCP_NODELAY, (char *) &buffer_val, sizeof(buffer_val)) < 0) {

   437     debug_only(fprintf(stderr, "Serviceability agent: Failed to set TCP_NODELAY option on client socket\n"));

   438     cleanup(client_socket);

   439     return false;

   440   }

   441 

   442   // OK, we have the data socket through which we will communicate

   443   // with the Java side. Wait for commands or until reading or writing

   444   // caused an error.

   445 

   446   bool should_continue = true;

   447 

   448   myComm.setSocket(client_socket);

   449 

   450 #ifdef PROFILING

   451   scanTimer.reset();

   452   workTimer.reset();

   453   writeTimer.reset();

   454 #endif

   455 

   456   // Allocate a new thread agent for libthread_db

   457   if ((*td_ta_new_fn)((ps_prochandle*) ps_get_prochandle2(1), &_tdb_agent) !=

   458       TD_OK) {

   459     debug_only(fprintf(stderr, "Serviceability agent: Failed to allocate thread agent\n"));

   460     cleanup(client_socket);

   461     return false;

   462   }

   463 

   464   do {

   465     // Decided to use text to communicate between these processes.

   466     // Probably will make debugging easier -- could telnet in if

   467     // necessary. Will make scanning harder, but probably doesn't

   468     // matter.

   469 

   470     // Why not just do what workshop does and parse dbx's console?

   471     // Probably could do that, but at least this way we are in control

   472     // of the text format on both ends.

   473 

   474     // FIXME: should have some way of synchronizing these commands

   475     // between the C and Java sources.

   476 

   477     NEEDS_CLEANUP;

   478 

   479     // Do a blocking read of a line from the socket.

   480     char *input_buffer = myComm.readLine();

   481     if (input_buffer == NULL) {

   482       debug_only(fprintf(stderr, "Serviceability agent: error during read: errno = %d\n", errno));

   483       debug_only(perror("Serviceability agent"));

   484       // Error occurred during read.

   485       // FIXME: should guard against SIGPIPE

   486       cleanup(client_socket);

   487       return false;

   488     }

   489 

   490     // OK, now ready to scan. See README-commands.txt for syntax

   491     // descriptions.

   492 

   493     bool res = false;

   494     if (!strncmp(input_buffer, CMD_ADDRESS_SIZE, strlen(CMD_ADDRESS_SIZE))) {

   495       res = handleAddressSize(input_buffer + strlen(CMD_ADDRESS_SIZE));

   496     } else if (!strncmp(input_buffer, CMD_PEEK_FAIL_FAST, strlen(CMD_PEEK_FAIL_FAST))) {

   497       res = handlePeekFailFast(input_buffer + strlen(CMD_PEEK_FAIL_FAST));

   498     } else if (!strncmp(input_buffer, CMD_PEEK, strlen(CMD_PEEK))) {

   499       res = handlePeek(input_buffer + strlen(CMD_PEEK));

   500     } else if (!strncmp(input_buffer, CMD_POKE, strlen(CMD_POKE))) {

   501       res = handlePoke(input_buffer + strlen(CMD_POKE));

   502     } else if (!strncmp(input_buffer, CMD_MAPPED, strlen(CMD_MAPPED))) {

   503       res = handleMapped(input_buffer + strlen(CMD_MAPPED));

   504     } else if (!strncmp(input_buffer, CMD_LOOKUP, strlen(CMD_LOOKUP))) {

   505       res = handleLookup(input_buffer + strlen(CMD_LOOKUP));

   506     } else if (!strncmp(input_buffer, CMD_THR_GREGS, strlen(CMD_THR_GREGS))) {

   507       res = handleThrGRegs(input_buffer + strlen(CMD_THR_GREGS));

   508     } else if (!strncmp(input_buffer, CMD_EXIT, strlen(CMD_EXIT))) {

   509       should_continue = false;

   510     }

   511 

   512     if (should_continue) {

   513       if (!res) {

   514         cleanup(client_socket);

   515         return false;

   516       }

   517     }

   518 

   519 #ifdef PROFILING

   520     if (++numRequests == PROFILE_COUNT) {

   521       fprintf(stderr, "%d requests: %d ms scanning, %d ms work, %d ms writing\n",

   522               PROFILE_COUNT, scanTimer.total(), workTimer.total(), writeTimer.total());

   523       fflush(stderr);

   524       scanTimer.reset();

   525       workTimer.reset();

   526       writeTimer.reset();

   527       numRequests = 0;

   528     }

   529 #endif

   530 

   531   } while (should_continue);

   532 

   533   // Successful exit

   534   cleanup(client_socket);

   535   return true;

   536 }

   537 

   538 void

   539 ServiceabilityAgentDbxModule::cleanup(int client_socket) {

   540   shutdown(client_socket, 2);

   541   close(client_socket);

   542   if (_tdb_agent != NULL) {

   543     (*td_ta_delete_fn)(_tdb_agent);

   544   }

   545 }

   546 

   547 bool

   548 ServiceabilityAgentDbxModule::handleAddressSize(char* data) {

   549   int data_model;

   550   ps_err_e result = ps_pdmodel((ps_prochandle*) ps_get_prochandle2(1),

   551                                &data_model);

   552   if (result != PS_OK) {

   553     myComm.writeString("0");

   554     myComm.flush();

   555     return false;

   556   }

   557 

   558   int val;

   559   switch (data_model) {

   560   case PR_MODEL_ILP32:

   561     val = 32;

   562     break;

   563   case PR_MODEL_LP64:

   564     val = 64;

   565     break;

   566   default:

   567     val = 0;

   568     break;

   569   }

   570 

   571   if (!myComm.writeInt(val)) {

   572     return false;

   573   }

   574   if (!myComm.writeEOL()) {

   575     return false;

   576   }

   577   return myComm.flush();

   578 }

   579 

   580 bool

   581 ServiceabilityAgentDbxModule::handlePeekFailFast(char* data) {

   582   unsigned int val;

   583   if (!scanUnsignedInt(&data, &val)) {

   584     return false;

   585   }

   586   peek_fail_fast = (val ? true : false);

   587   return true;

   588 }

   589 

   590 bool

   591 ServiceabilityAgentDbxModule::handlePeek(char* data) {

   592   // Scan hex address, return false if failed

   593   psaddr_t addr;

   594 #ifdef PROFILING

   595   scanTimer.start();

   596 #endif /* PROFILING */

   597   if (!scanAddress(&data, &addr)) {

   598     return false;

   599   }

   600   unsigned int num;

   601   if (!scanUnsignedInt(&data, &num)) {

   602     return false;

   603   }

   604   if (num == 0) {

   605 #ifdef PROFILING

   606     writeTimer.start();

   607 #endif /* PROFILING */

   608     myComm.writeBinChar('B');

   609     myComm.writeBinChar(1);

   610     myComm.writeBinUnsignedInt(0);

   611     myComm.writeBinChar(0);

   612 #ifdef PROFILING

   613     writeTimer.stop();

   614 #endif /* PROFILING */

   615     return true;

   616   }

   617 #ifdef PROFILING

   618   scanTimer.stop();

   619   workTimer.start();

   620 #endif /* PROFILING */

   621   char* buf = new char[num];

   622   ps_prochandle* cur_proc = (ps_prochandle*) ps_get_prochandle2(1);

   623   ps_err_e result = ps_pread(cur_proc, addr, buf, num);

   624   if (result == PS_OK) {

   625     // Fast case; entire read succeeded.

   626 #ifdef PROFILING

   627     workTimer.stop();

   628     writeTimer.start();

   629 #endif /* PROFILING */

   630     myComm.writeBinChar('B');

   631     myComm.writeBinChar(1);

   632     myComm.writeBinUnsignedInt(num);

   633     myComm.writeBinChar(1);

   634     myComm.writeBinBuf(buf, num);

   635 #ifdef PROFILING

   636     writeTimer.stop();

   637 #endif /* PROFILING */

   638   } else {

   639 #ifdef PROFILING

   640     workTimer.stop();

   641 #endif /* PROFILING */

   642 

   643     if (peek_fail_fast) {

   644 #ifdef PROFILING

   645     writeTimer.start();

   646 #endif /* PROFILING */

   647       // Fail fast

   648       myComm.writeBinChar('B');

   649       myComm.writeBinChar(1);

   650       myComm.writeBinUnsignedInt(num);

   651       myComm.writeBinChar(0);

   652 #ifdef PROFILING

   653     writeTimer.stop();

   654 #endif /* PROFILING */

   655     } else {

   656       // Slow case: try to read one byte at a time

   657       // FIXME: need better way of handling this, a la VirtualQuery

   658 

   659       unsigned int  strideLen      = 0;

   660       int           bufIdx         = 0;

   661       bool          lastByteMapped = (ps_pread(cur_proc, addr, buf, 1) == PS_OK ? true : false);

   662 

   663 #ifdef PROFILING

   664       writeTimer.start();

   665 #endif /* PROFILING */

   666       myComm.writeBinChar('B');

   667       myComm.writeBinChar(1);

   668 #ifdef PROFILING

   669       writeTimer.stop();

   670 #endif /* PROFILING */

   671 

   672       for (int i = 0; i < num; ++i, ++addr) {

   673 #ifdef PROFILING

   674         workTimer.start();

   675 #endif /* PROFILING */

   676         result = ps_pread(cur_proc, addr, &buf[bufIdx], 1);

   677 #ifdef PROFILING

   678         workTimer.stop();

   679 #endif /* PROFILING */

   680         bool tmpMapped = (result == PS_OK ? true : false);

   681 #ifdef PROFILING

   682         writeTimer.start();

   683 #endif /* PROFILING */

   684         if (tmpMapped != lastByteMapped) {

   685           // State change. Write the length of the last stride.

   686           myComm.writeBinUnsignedInt(strideLen);

   687           if (lastByteMapped) {

   688             // Stop gathering data. Write the data of the last stride.

   689             myComm.writeBinChar(1);

   690             myComm.writeBinBuf(buf, strideLen);

   691             bufIdx = 0;

   692           } else {

   693             // Start gathering data to write.

   694             myComm.writeBinChar(0);

   695           }

   696           strideLen = 0;

   697           lastByteMapped = tmpMapped;

   698         }

   699 #ifdef PROFILING

   700         writeTimer.stop();

   701 #endif /* PROFILING */

   702         if (lastByteMapped) {

   703           ++bufIdx;

   704         }

   705         ++strideLen;

   706       }

   707 

   708       // Write last stride (must be at least one byte long by definition)

   709 #ifdef PROFILING

   710       writeTimer.start();

   711 #endif /* PROFILING */

   712       myComm.writeBinUnsignedInt(strideLen);

   713       if (lastByteMapped) {

   714         myComm.writeBinChar(1);

   715         myComm.writeBinBuf(buf, strideLen);

   716       } else {

   717         myComm.writeBinChar(0);

   718       }

   719 #ifdef PROFILING

   720       writeTimer.stop();

   721 #endif /* PROFILING */

   722     }

   723   }

   724   delete[] buf;

   725   myComm.flush();

   726   return true;

   727 }

   728 

   729 bool

   730 ServiceabilityAgentDbxModule::handlePoke(char* data) {

   731   // FIXME: not yet implemented

   732   NEEDS_CLEANUP;

   733   bool res = myComm.writeBoolAsInt(false);

   734   myComm.flush();

   735   return res;

   736 }

   737 

   738 bool

   739 ServiceabilityAgentDbxModule::handleMapped(char* data) {

   740   // Scan address

   741   psaddr_t addr;

   742   if (!scanAddress(&data, &addr)) {

   743     return false;

   744   }

   745   unsigned int num;

   746   if (!scanUnsignedInt(&data, &num)) {

   747     return false;

   748   }

   749   unsigned char val;

   750   ps_prochandle* cur_proc = (ps_prochandle*) ps_get_prochandle2(1);

   751   char* buf = new char[num];

   752   if (ps_pread(cur_proc, addr, buf, num) == PS_OK) {

   753     myComm.writeBoolAsInt(true);

   754   } else {

   755     myComm.writeBoolAsInt(false);

   756   }

   757   delete[] buf;

   758   myComm.writeEOL();

   759   myComm.flush();

   760   return true;

   761 }

   762 

   763 extern "C"

   764 int loadobj_iterator(const rd_loadobj_t* loadobj, void *) {

   765   if (loadobj != NULL) {

   766     fprintf(stderr, "loadobj_iterator: visited loadobj \"%p\"\n", (void*) loadobj->rl_nameaddr);

   767     return 1;

   768   }

   769 

   770   fprintf(stderr, "loadobj_iterator: NULL loadobj\n");

   771   return 0;

   772 }

   773 

   774 bool

   775 ServiceabilityAgentDbxModule::handleLookup(char* data) {

   776   // Debugging: iterate over loadobjs

   777   /*

   778   rd_agent_t* rld_agent = rd_new((ps_prochandle*) ps_get_prochandle2(1));

   779   rd_loadobj_iter(rld_agent, &loadobj_iterator, NULL);

   780   rd_delete(rld_agent);

   781   */

   782 

   783 #ifdef PROFILING

   784   scanTimer.start();

   785 #endif /* PROFILING */

   786 

   787   char* object_name = scanSymbol(&data);

   788   if (object_name == NULL) {

   789     return false;

   790   }

   791   char* symbol_name = scanSymbol(&data);

   792   if (symbol_name == NULL) {

   793     delete[] object_name;

   794     return false;

   795   }

   796 

   797 #ifdef PROFILING

   798   scanTimer.stop();

   799   workTimer.start();

   800 #endif /* PROFILING */

   801 

   802   ps_sym_t sym;

   803   // FIXME: check return values from write routines

   804   ps_prochandle* process = (ps_prochandle*) ps_get_prochandle2(1);

   805   ps_err_e lookup_res = ps_pglobal_sym(process,

   806                                        object_name, symbol_name, &sym);

   807 #ifdef PROFILING

   808   workTimer.stop();

   809   writeTimer.start();

   810 #endif /* PROFILING */

   811 

   812   delete[] object_name;

   813   delete[] symbol_name;

   814   if (lookup_res != PS_OK) {

   815     // This is too noisy

   816     //    debug_only(fprintf(stderr, "ServiceabilityAgentDbxModule::handleLookup: error %d\n", lookup_res));

   817     myComm.writeString("0x0");

   818   } else {

   819     myComm.writeAddress((void *)sym.st_value);

   820   }

   821   myComm.writeEOL();

   822   myComm.flush();

   823 

   824 #ifdef PROFILING

   825   writeTimer.stop();

   826 #endif /* PROFILING */

   827 

   828   return true;

   829 }

   830 

   831 bool

   832 ServiceabilityAgentDbxModule::handleThrGRegs(char* data) {

   833 #ifdef PROFILING

   834   scanTimer.start();

   835 #endif /* PROFILING */

   836 

   837   unsigned int num;

   838   // Get the thread ID

   839   if (!scanUnsignedInt(&data, &num)) {

   840     return false;

   841   }

   842 

   843 #ifdef PROFILING

   844   scanTimer.stop();

   845   workTimer.start();

   846 #endif /* PROFILING */

   847 

   848   // Map tid to thread handle

   849   td_thrhandle_t thread_handle;

   850   if ((*td_ta_map_id2thr_fn)(_tdb_agent, num, &thread_handle) != TD_OK) {

   851     //    fprintf(stderr, "Error mapping thread ID %d to thread handle\n", num);

   852     return false;

   853   }

   854 

   855   // Fetch register set

   856   prgregset_t reg_set;

   857   memset(reg_set, 0, sizeof(reg_set));

   858   td_err_e result = (*td_thr_getgregs_fn)(&thread_handle, reg_set);

   859   if ((result != TD_OK) && (result != TD_PARTIALREG)) {

   860     //    fprintf(stderr, "Error fetching registers for thread handle %d: error = %d\n", num, result);

   861     return false;

   862   }

   863 

   864 #ifdef PROFILING

   865   workTimer.stop();

   866   writeTimer.start();

   867 #endif /* PROFILING */

   868 

   869 #if (defined(__sparc) || defined(__i386))

   870   myComm.writeInt(NPRGREG);

   871   myComm.writeSpace();

   872   for (int i = 0; i < NPRGREG; i++) {

   873     myComm.writeAddress((void *)reg_set[i]);

   874     if (i == NPRGREG - 1) {

   875       myComm.writeEOL();

   876     } else {

   877       myComm.writeSpace();

   878     }

   879   }

   880 #else

   881 #error  Please port ServiceabilityAgentDbxModule::handleThrGRegs to your current platform

   882 #endif

   883 

   884   myComm.flush();

   885 

   886 #ifdef PROFILING

   887   writeTimer.stop();

   888 #endif /* PROFILING */

   889 

   890   return true;

   891 }

   892 

   893 //

   894 // Input routines

   895 //

   896 

   897 bool

   898 ServiceabilityAgentDbxModule::scanAddress(char** data, psaddr_t* addr) {

   899   *addr = 0;

   900 

   901   // Skip whitespace

   902   while ((**data != 0) && (isspace(**data))) {

   903     ++*data;

   904   }

   905 

   906   if (**data == 0) {

   907     return false;

   908   }

   909 

   910   if (strncmp(*data, "0x", 2) != 0) {

   911     return false;

   912   }

   913 

   914   *data += 2;

   915 

   916   while ((**data != 0) && (!isspace(**data))) {

   917     int val;

   918     bool res = charToNibble(**data, &val);

   919     if (!res) {

   920       return false;

   921     }

   922     *addr <<= 4;

   923     *addr |= val;

   924     ++*data;

   925   }

   926 

   927   return true;

   928 }

   929 

   930 bool

   931 ServiceabilityAgentDbxModule::scanUnsignedInt(char** data, unsigned int* num) {

   932   *num = 0;

   933 

   934   // Skip whitespace

   935   while ((**data != 0) && (isspace(**data))) {

   936     ++*data;

   937   }

   938 

   939   if (**data == 0) {

   940     return false;

   941   }

   942 

   943   while ((**data != 0) && (!isspace(**data))) {

   944     char cur = **data;

   945     if ((cur < '0') || (cur > '9')) {

   946       return false;

   947     }

   948     *num *= 10;

   949     *num += cur - '0';

   950     ++*data;

   951   }

   952 

   953   return true;

   954 }

   955 

   956 char*

   957 ServiceabilityAgentDbxModule::scanSymbol(char** data) {

   958   // Skip whitespace

   959   while ((**data != 0) && (isspace(**data))) {

   960     ++*data;

   961   }

   962 

   963   if (**data == 0) {

   964     return NULL;

   965   }

   966 

   967   // First count length

   968   int len = 1; // Null terminator

   969   char* tmpData = *data;

   970   while ((*tmpData != 0) && (!isspace(*tmpData))) {

   971     ++tmpData;

   972     ++len;

   973   }

   974   char* buf = new char[len];

   975   strncpy(buf, *data, len - 1);

   976   buf[len - 1] = 0;

   977   *data += len - 1;

   978   return buf;

   979 }

   980 

   981 bool

   982 ServiceabilityAgentDbxModule::charToNibble(char ascii, int* value) {

   983   if (ascii >= '0' && ascii <= '9') {

   984     *value = ascii - '0';

   985     return true;

   986   } else if (ascii >= 'A' && ascii <= 'F') {

   987     *value = 10 + ascii - 'A';

   988     return true;

   989   } else if (ascii >= 'a' && ascii <= 'f') {

   990     *value = 10 + ascii - 'a';

   991     return true;

   992   }

   993 

   994   return false;

   995 }

   996 

   997 

   998 char*

   999 ServiceabilityAgentDbxModule::readCStringFromProcess(psaddr_t addr) {

  1000   char c;

  1001   int num = 0;

  1002   ps_prochandle* cur_proc = (ps_prochandle*) ps_get_prochandle2(1);

  1003 

  1004   // Search for null terminator

  1005   do {

  1006     if (ps_pread(cur_proc, addr + num, &c, 1) != PS_OK) {

  1007       return NULL;

  1008     }

  1009     ++num;

  1010   } while (c != 0);

  1011 

  1012   // Allocate string

  1013   char* res = new char[num];

  1014   if (ps_pread(cur_proc, addr, res, num) != PS_OK) {

  1015     delete[] res;

  1016     return NULL;

  1017   }

  1018   return res;

  1019 }

  1020 

  1021 

  1022 //--------------------------------------------------------------------------------

  1023 // Class Timer

  1024 //

  1025 

  1026 Timer::Timer() {

  1027   reset();

  1028 }

  1029 

  1030 Timer::~Timer() {

  1031 }

  1032 

  1033 void

  1034 Timer::start() {

  1035   gettimeofday(&startTime, NULL);

  1036 }

  1037 

  1038 void

  1039 Timer::stop() {

  1040   struct timeval endTime;

  1041   gettimeofday(&endTime, NULL);

  1042   totalMicroseconds += timevalDiff(&startTime, &endTime);

  1043   ++counter;

  1044 }

  1045 

  1046 long

  1047 Timer::total() {

  1048   return (totalMicroseconds / 1000);

  1049 }

  1050 

  1051 long

  1052 Timer::average() {

  1053   return (long) ((double) total() / (double) counter);

  1054 }

  1055 

  1056 void

  1057 Timer::reset() {

  1058   totalMicroseconds = 0;

  1059   counter = 0;

  1060 }

  1061 

  1062 long long

  1063 Timer::timevalDiff(struct timeval* start, struct timeval* end) {

  1064   long long secs = end->tv_sec - start->tv_sec;

  1065   secs *= 1000000;

  1066   long long usecs = end->tv_usec - start->tv_usec;

  1067   return (secs + usecs);

  1068 }