Merge branch 'master' into bgq_ramdisk_io
[dyninst.git] / proccontrol / src / bluegeneq.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #if !defined(_GNU_SOURCE)
32 #define _GNU_SOURCE
33 #endif
34
35 #include <dirent.h>
36 #include <limits.h>
37 #include <stdlib.h>
38 #include <fcntl.h>
39 #include <errno.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <sys/socket.h>
43 #include <sys/un.h>
44 #include <sys/syscall.h>
45 #include <signal.h>
46 #include <ucontext.h>
47 #include <elf.h>
48 #include <link.h>
49 #include <execinfo.h>
50 #include <unistd.h>
51
52 #include "proccontrol/src/bluegeneq.h"
53 #include "proccontrol/src/int_event.h"
54 #include "proccontrol/src/irpc.h"
55 #include "proccontrol/h/PCProcess.h"
56 #include "proccontrol/h/PlatFeatures.h"
57 #include "proccontrol/h/PCErrors.h"
58 #include "proccontrol/h/Mailbox.h"
59
60 #define USE_THREADED_IO
61
62 using namespace Dyninst;
63 using namespace ProcControlAPI;
64 using namespace std;
65
66 #include "symlite/h/SymLite-elf.h"
67
68 using namespace bgq;
69 using namespace std;
70
71 static bool emergency = false;
72
73 static void registerSignalHandlers(bool enable);
74
75 uint64_t bgq_process::jobid = 0;
76 uint32_t bgq_process::toolid = 0;
77 bool bgq_process::set_ids = false;
78 bool bgq_process::do_all_attach = true;
79
80 const char *getCommandName(uint16_t cmd_type);
81
82 static void printMessage(ToolMessage *msg, const char *str, bool short_msg = false)
83 {
84    if (!dyninst_debug_proccontrol)
85       return;
86    MessageHeader *header = &msg->header;
87
88    pc_print_lock();
89    if (!short_msg) 
90       pthrd_printf("%s MessageHeader:\n"
91                    "\tservice = %u\t"
92                    "\tversion = %u\t"
93                    "\ttype = %u\t"
94                    "\trank = %u\n"
95                    "\tsequenceId = %u\t"
96                    "\treturnCode = %u\t"
97                    "\terrCode = %u\t"
98                    "\tlength = %u\n"
99                    "\tjobID = %lu\t"
100                    "\ttoolId = %u\n\t",
101                    str,
102                    (unsigned) header->service,
103                    (unsigned) header->version,
104                    (unsigned) header->type,
105                    header->rank,
106                    header->sequenceId,
107                    header->returnCode,
108                    header->errorCode,
109                    header->length,
110                    (unsigned long) header->jobId,
111                    (unsigned) msg->toolId);
112    else
113       pthrd_printf("%s to %u: ", str, header->rank);
114   
115    switch (msg->header.type) {
116       case ControlAck: {
117          ControlAckMessage *cak = static_cast<ControlAckMessage *>(msg);
118          pclean_printf("ControlAck: controllingToolId - %u, toolTag - %.8s, priority - %u\n", 
119                        (unsigned) cak->controllingToolId, cak->toolTag, (unsigned) cak->priority);
120          break;
121       }
122       case AttachAck: {
123          AttachAckMessage *aak = static_cast<AttachAckMessage *>(msg);
124          pclean_printf("AttachAck: numProcess - %u, rank = [", (unsigned) aak->numProcess);
125          for (unsigned i=0; i<aak->numProcess; i++) {
126             pclean_printf("%u,", aak->rank[i]);
127          }
128          pclean_printf("]\n");
129          break;
130       }
131       case DetachAck: {
132          DetachAckMessage *dak = static_cast<DetachAckMessage *>(msg);
133          pclean_printf("DetachAck: numProcess - %u, rank = [", (unsigned) dak->numProcess);
134          for (unsigned i=0; i<dak->numProcess; i++) {
135             pclean_printf("%u, ", dak->rank[i]);
136          }
137          pclean_printf("]\n");
138          break;
139       }
140       case QueryAck: {
141          QueryAckMessage *m = static_cast<QueryAckMessage *>(msg);
142          pclean_printf("QueryAck: numCommands = %u\n", (unsigned) m->numCommands);
143          if (!short_msg) {
144             for (unsigned i=0; i<(unsigned) m->numCommands; i++) {
145                CommandDescriptor &c = m->cmdList[i];
146                pclean_printf("\t[%u] type = %s, reserved = %u, offset = %u, length = %u, returnCode = %u\n",
147                              i, getCommandName(c.type), (unsigned) c.reserved, c.offset,
148                              c.length, c.returnCode);
149             }
150             break;
151          }
152       }
153       case UpdateAck: {
154          UpdateAckMessage *m = static_cast<UpdateAckMessage *>(msg);
155          pclean_printf("UpdateAck: numCommands = %u\n", (unsigned) m->numCommands);
156          if (!short_msg) {
157             for (unsigned i=0; i<(unsigned) m->numCommands; i++) {
158                CommandDescriptor &c = m->cmdList[i];
159                pclean_printf("\t[%u] type = %s, reserved = %u, offset = %u, length = %u, returnCode = %u\n",
160                              i, getCommandName(c.type), (unsigned) c.reserved, c.offset,
161                              c.length, c.returnCode);
162             }
163          }
164          break;
165       }
166       case Query: {
167          QueryMessage *m = static_cast<QueryMessage *>(msg);
168          pclean_printf("Query: numCommands = %u\n", (unsigned) m->numCommands);
169          if (!short_msg) {
170             for (unsigned i=0; i<(unsigned) m->numCommands; i++) {
171                CommandDescriptor &c = m->cmdList[i];
172                pclean_printf("\t[%u] type = %s, reserved = %u, offset = %u, length = %u, returnCode = %u\n",
173                              i, getCommandName(c.type), (unsigned) c.reserved, c.offset,
174                              c.length, c.returnCode);
175             }
176          }
177          break;
178       }
179       case Update: {
180          UpdateMessage *m = static_cast<UpdateMessage *>(msg);
181          pclean_printf("Update: numCommands = %u\n", (unsigned) m->numCommands);
182          if (!short_msg) {
183             for (unsigned i=0; i<(unsigned) m->numCommands; i++) {
184                CommandDescriptor &c = m->cmdList[i];
185                pclean_printf("\t[%u] type = %s, reserved = %u, offset = %u, length = %u, returnCode = %u\n",
186                              i, getCommandName(c.type), (unsigned) c.reserved, c.offset,
187                              c.length, c.returnCode);
188             }
189          }
190          break;
191       }
192       case Notify: {
193          pclean_printf("Notify ");
194          NotifyMessage *no = static_cast<NotifyMessage *>(msg);
195          switch (no->notifyMessageType) {
196             case NotifyMessageType_Signal:
197                pclean_printf("Signal: signum = %u, threadId = %u, instAddress = 0x%lx, "
198                              "dataAddress = %lx, reason = %u, executeMode = %d\n",
199                              no->type.signal.signum, (unsigned) no->type.signal.threadID,
200                              no->type.signal.instAddress, no->type.signal.dataAddress, 
201                              (unsigned) no->type.signal.reason,
202                              (unsigned) no->type.signal.executeMode);
203                break;
204             case NotifyMessageType_Termination:
205                pclean_printf("Exit: exitStatus = %u\n", no->type.termination.exitStatus);
206                break;
207             case NotifyMessageType_Control:
208                pclean_printf("Control: toolid = %u, toolTag = %.8s, priority = %u, reason = %u\n",
209                              no->type.control.toolid, no->type.control.toolTag, (unsigned) no->type.control.priority,
210                              (unsigned) no->type.control.reason);
211                break;
212             default:
213                pclean_printf("Unknown: %u\n", (unsigned int) no->notifyMessageType);
214                break;
215          }
216          break;
217       }
218       case SetupJobAck: {
219          pclean_printf("SetupJobAck\n");
220          break;
221       }
222       case NotifyAck: {
223          pclean_printf("NotifyAck\n");
224          break;
225       }
226       case Attach: {
227          AttachMessage *am = static_cast<AttachMessage *>(msg);
228          pclean_printf("AttachMessage: toolTag = %.8s, priority = %u, procSelect = %u\n",
229                        am->toolTag, (unsigned) am->priority, (unsigned) am->procSelect);
230          break;
231       }
232       case Detach: {
233          DetachMessage *dm = static_cast<DetachMessage *>(msg);
234          pclean_printf("DetachMessage: procSelect = %u\n", (unsigned) dm->procSelect);
235          break;
236       }
237       case SetupJob: {
238          pclean_printf("SetupJobMessage\n");
239          break;
240       }
241       case Control: {
242          ControlMessage *cm = static_cast<ControlMessage *>(msg);
243          pclean_printf("ControlMessage: notifySet - %lx, sendSignal = %u, dynamicNotifyMode = %u, dacTrapMode = %u\n",
244                        cm->notifySet, cm->sndSignal, (unsigned) cm->dynamicNotifyMode, (unsigned) cm->dacTrapMode);
245          break;
246       }
247       default:
248          pclean_printf("Unknown message\n");
249          break;
250    }
251    pc_print_unlock();
252 }
253
254 int_process *int_process::createProcess(Dyninst::PID p, std::string e)
255 {
256    std::map<int,int> f;
257    std::vector<std::string> a;
258    std::vector<std::string> envp;
259    bgq_process *bgproc = new bgq_process(p, e, a, envp, f);
260    assert(bgproc);
261    return static_cast<int_process *>(bgproc);
262 }
263
264 int_process *int_process::createProcess(std::string e, std::vector<std::string> a, 
265                                         vector<string> envp, std::map<int,int> f)
266 {
267    bgq_process *bgproc = new bgq_process(0, e, a, envp, f);
268    assert(bgproc);
269    return static_cast<int_process *>(bgproc);
270 }
271
272 int_process *int_process::createProcess(Dyninst::PID, int_process *)
273 {
274    assert(0); //No fork on BlueGene
275    return NULL;
276 }
277
278 static Mutex id_init_lock;
279 bgq_process::bgq_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
280                          vector<string> envp, std::map<int, int> f) :
281    int_process(p, e, a, envp, f),
282    sysv_process(p, e, a, envp, f),
283    thread_db_process(p, e, a, envp, f),
284    ppc_process(p, e, a, envp, f),
285    hybrid_lwp_control_process(p, e, a, envp, f),
286    mmap_alloc_process(p, e, a, envp, f),
287    int_multiToolControl(p, e, a, envp, f),
288    int_signalMask(p, e, a, envp, f),
289    int_callStackUnwinding(p, e, a, envp, f),
290    int_BGQData(p, e, a, envp, f),
291    int_remoteIO(p, e, a, envp, f),
292    last_ss_thread(NULL),
293    lwp_tracker(NULL),
294    hasControlAuthority(false),
295    interp_base_set(false),
296    page_size_set(false),
297    debugger_suspended(false),
298    decoder_pending_stop(false),
299    is_doing_temp_detach(false),
300    stopped_on_startup(false),
301    held_on_startup(false),
302    got_startup_stop(false),
303    rank(pid),
304    page_size(0),
305    interp_base(0),
306    get_thread_list(NULL),
307    stopwait_on_control_authority(NULL),
308    priority(0),
309    mtool(NULL),
310    startup_state(issue_attach),
311    detach_state(no_detach_issued)
312 {
313    if (!set_ids) {
314       ScopeLock lock(id_init_lock);
315       if (!set_ids) {
316          char *jobid_env = getenv("BG_JOBID");
317          assert(jobid_env);
318          char *toolid_env = getenv("BG_TOOLID");
319          assert(toolid_env);
320          jobid = atoi(jobid_env);
321          toolid = atoi(toolid_env);
322          set_ids = true;
323       }
324    }
325    ReaderThread::get();
326
327    query_transaction = new QueryTransaction(this, Query);
328    update_transaction = new UpdateTransaction(this, Update);
329    cn = ComputeNode::getComputeNodeByRank(rank);
330    cn->procs.insert(this);
331    WriterThread::get()->addProcess(this);
332 }
333
334 bgq_process::~bgq_process()
335 {
336    WriterThread::get()->rmProcess(this);
337    if (get_thread_list) {
338       delete get_thread_list;
339       get_thread_list = NULL;
340    }
341    if (query_transaction) {
342       delete query_transaction;
343       query_transaction = NULL;
344    }
345    if (update_transaction) {
346       delete update_transaction;
347       update_transaction = NULL;
348    }
349    if (mtool) {
350       delete mtool;
351       mtool = NULL;
352    }
353    cn->removeNode(this);
354 }
355
356 bool bgq_process::plat_create()
357 {
358    pthrd_printf("Attempted to do an unsupported create on BlueGene\n");
359    setLastError(err_unsupported, "Create not yet supported on BlueGene\n");
360    return false;
361 }
362
363 bool bgq_process::plat_attach(bool, bool &needsSync)
364 {
365    bool result = handleStartupEvent(NULL);
366    if (!result) {
367       pthrd_printf("handleStartupEvent failed\n");
368       return false;
369    }
370
371    needsSync = true;
372    return true;
373 }
374
375 bool bgq_process::plat_forked()
376 {
377    assert(0); //No fork on BG/Q
378    return true;
379 }
380
381 bool bgq_process::plat_detach(result_response::ptr, bool)
382 {
383    if (detach_state == no_detach_issued) {
384       pthrd_printf("plat_detach for %d is resuming all threads\n", getPid());
385       int_threadPool *tp = threadPool();
386       for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
387          resumeThread(*i);
388       }
389       
390       //Record whether this is a temporary detach so that we can maintain
391       // the state if we throw a new detach event.
392       Event::ptr cur_event = handlerPool()->curEvent();
393       assert(cur_event);
394       EventDetach::ptr ev_detach = cur_event->getEventDetach();
395       assert(ev_detach);
396       is_doing_temp_detach = ev_detach->getInternal()->temporary_detach;
397
398       detach_state = issue_control_release;
399    }
400
401    if (detach_state == issue_control_release && !hasControlAuthority) {
402       pthrd_printf("plat_detach: Process %d doesn't have control authority, skipping release.\n", getPid());
403       detach_state = choose_detach_mechanism;
404    }
405
406    if (detach_state == issue_control_release) {
407       pthrd_printf("Releasing control of process %d\n", getPid());
408       detach_state = control_release_sent;
409
410       ReleaseControlCmd release;
411       release.notify = ReleaseControlNotify_Inactive;
412       release.threadID = 0;
413       bool result = sendCommand(release, ReleaseControl);
414       if (!result) {
415          perr_printf("Error writing release control tool message\n");
416          return false;
417       }
418
419       return true;
420    }
421
422    if (detach_state == control_release_sent) {
423       pthrd_printf("Handling release control ack to %d.\n", getPid());
424       hasControlAuthority = false;
425       detach_state = choose_detach_mechanism;
426    }
427
428    if (detach_state == choose_detach_mechanism) {
429       bool everyone_detaching = true;
430       bool is_last_detacher = true;
431       
432       { 
433          ScopeLock lock_this_scope(cn->detach_lock);
434          
435          for (set<bgq_process *>::iterator i = cn->procs.begin(); i != cn->procs.end(); i++) {
436             bgq_process *peer_proc = *i;
437             if (peer_proc == this)
438                continue;
439             
440             int_thread *peer_thread = peer_proc->threadPool()->initialThread();
441             if (!peer_thread->getDetachState().isDesynced()) {
442                pthrd_printf("Process %d is not detaching.  %d not doing group detach\n", 
443                             peer_proc->getPid(), getPid());
444                everyone_detaching = false;
445             }
446             if (peer_proc->detach_state != waitfor_all_detach) {
447                pthrd_printf("Process %d hasn't yet completed detach.  Postponing any group detach from %d\n",
448                             peer_proc->getPid(), getPid());
449                is_last_detacher = false;
450             }
451          }
452       }
453
454       if (everyone_detaching && !is_last_detacher) {
455          pthrd_printf("Process %d will wait for another proc to do all detach\n", getPid());
456          detach_state = waitfor_all_detach;
457          return true;
458       }
459
460       DetachMessage detach;
461       if (everyone_detaching) {
462          pthrd_printf("Process %d issuing all-detach for compute node %d\n",
463                       getPid(), cn->getID());
464          detach_state = issued_all_detach;
465          detach.procSelect = RanksInNode;
466       }
467       else {
468          pthrd_printf("Issuing targeted detach to process %d\n", getPid());
469          detach_state = issued_detach;
470          detach.procSelect = RankInHeader;
471       }
472       fillInToolMessage(detach, Detach);
473       bool result = cn->writeToolMessage(this, &detach, false);
474       if (!result) {
475          perr_printf("Error writing detach tool message\n");
476          return false;
477       }       
478    
479       return true;
480    }
481
482    if (detach_state == issued_all_detach || detach_state == issued_detach) {
483       pthrd_printf("Handling detach response to %d.\n", getPid());
484       detach_state = detach_cleanup;
485    }
486    else if (detach_state == waitfor_all_detach) {
487       pthrd_printf("Finished waiting for all detach on %d\n", getPid());
488       detach_state = detach_cleanup;
489    }
490
491    if (detach_state == detach_cleanup) {
492       getComputeNode()->removeNode(this);
493       detach_state = detach_done;
494       return true;
495    }
496
497    perr_printf("Unreachable code.  Bad detach state on %d: %lu\n",
498                getPid(), (unsigned long) detach_state);
499    assert(0);
500    return false;
501 }
502
503 bool bgq_process::plat_detachDone()
504 {
505    if (detach_state != detach_done)
506       return false;
507
508    //We're done.  Reset the detach states
509    detach_state = no_detach_issued;
510    is_doing_temp_detach = false;
511    return true;
512 }
513
514 bool bgq_process::plat_terminate(bool & /*needs_sync*/)
515 {
516    return false;
517 }
518
519 bool bgq_process::needIndividualThreadAttach()
520 {
521    return true;
522 }
523
524 bool bgq_process::getThreadLWPs(std::vector<Dyninst::LWP> &lwps)
525 {
526    if (!get_thread_list)
527       return true;
528
529    for (uint32_t i = 0; i < get_thread_list->numthreads; i++) {
530       lwps.push_back(get_thread_list->threadlist[i].tid);
531    }
532    delete get_thread_list;
533    get_thread_list = NULL;
534    return true;
535 }
536
537 bool bgq_process::plat_getInterpreterBase(Address &base)
538 {
539    if (interp_base_set) {
540       base = interp_base;
541       return true;
542    }
543       
544    uint32_t len = get_auxvectors_result.length;
545    Elf64_auxv_t *auxvs = (Elf64_auxv_t *) get_auxvectors_result.data;
546
547    for (uint32_t i = 0; i < len; i++) {
548       if (auxvs[i].a_type == AT_BASE) {
549          base = interp_base = (Address) auxvs[i].a_un.a_val;
550          interp_base_set = true;
551          return true;
552       }
553    }
554    
555    pthrd_printf("Didn't find interpreter base for %d. Statically linked\n", getPid());
556    pthrd_printf("%u auxv elements\n", len);
557    for (uint32_t i = 0; i < len; i += 2) {
558       pclean_printf("\t%lu - 0x%lx\n", get_auxvectors_result.data[i], get_auxvectors_result.data[i+1]);
559    }
560    base = 0;
561    return false;
562 }
563
564 bool bgq_process::plat_supportDOTF()
565 {
566    return false;
567 }
568
569 Dyninst::OSType bgq_process::getOS() const
570 {
571    return Dyninst::BlueGeneQ;
572 }
573
574 Dyninst::Architecture bgq_process::getTargetArch()
575 {
576    return Dyninst::Arch_ppc64;
577 }
578
579 unsigned int bgq_process::getTargetPageSize()
580 {
581    if (page_size_set) {
582       return page_size;
583    }
584
585    uint32_t len = get_auxvectors_result.length;
586    Elf64_auxv_t *auxvs = (Elf64_auxv_t *) get_auxvectors_result.data;
587    
588    for (uint32_t i = 0; i < len; i++) {
589       if (auxvs[i].a_type == AT_PAGESZ) {
590          page_size = (unsigned int) auxvs[i].a_un.a_val;
591          page_size_set = true;
592          return page_size;
593       }
594    }
595    
596    perr_printf("Failed to find page size for %d\n", getPid());
597    return false;      
598 }
599
600 Dyninst::Address bgq_process::plat_mallocExecMemory(Dyninst::Address addr, unsigned int)
601 {
602    return get_procdata_result.heapStartAddr + addr;
603 }
604
605 bool bgq_process::plat_individualRegAccess()
606 {
607    return true;
608 }
609
610 bool bgq_process::plat_supportLWPPostDestroy()
611 {
612    return false;
613 }
614
615 static SymbolReaderFactory *getElfReader()
616 {
617    static SymbolReaderFactory *symreader_factory = NULL;
618    if (symreader_factory)
619       return symreader_factory;
620
621    symreader_factory = (SymbolReaderFactory *) new SymElfFactory();
622    return symreader_factory;
623 }
624
625 SymbolReaderFactory *bgq_process::plat_defaultSymReader()
626 {
627    return getElfReader();
628 }
629
630 bool bgq_process::plat_readMem(int_thread *, void *, Dyninst::Address, size_t)
631 {
632    assert(0); //No synchronous IO
633    return false;
634 }
635
636 bool bgq_process::plat_writeMem(int_thread *, const void *, Dyninst::Address, size_t, bp_write_t)
637 {
638    assert(0); //No synchronous IO
639    return false;
640 }
641
642 bool bgq_process::plat_needsAsyncIO() const
643 {
644    return true;
645 }
646
647 bool bgq_process::plat_preAsyncWait()
648 {
649    return rotateTransaction();
650 }
651
652 bool bgq_process::plat_preHandleEvent()
653 {
654    return true;
655 }
656
657 bool bgq_process::plat_postHandleEvent()
658 {
659    return rotateTransaction();
660 }
661
662 bool bgq_process::rotateTransaction()
663 {
664    bool result;
665    pthrd_printf("Flushing and beginning transactions for %d\n", getPid());
666    if (query_transaction->activeTransaction()) {
667       pthrd_printf("Ending query transaction\n");
668       result = query_transaction->endTransaction();
669
670       pthrd_printf("Beginning new query transaction\n");
671       query_transaction->beginTransaction();
672
673       if (!result) {
674          perr_printf("Error flushing query transaction\n");
675          return false;
676       }
677    }
678
679    if (update_transaction->activeTransaction()) {
680       pthrd_printf("Ending update transaction\n");
681       result = update_transaction->endTransaction();
682
683       pthrd_printf("Beginning new update transaction\n");
684       update_transaction->beginTransaction();
685
686       if (!result) {
687          perr_printf("Error flushing update transaction\n");
688          return false;
689       }
690    }
691
692    return true;
693 }
694
695 bool bgq_process::plat_individualRegRead()
696 {
697    return false;
698 }
699
700 bool bgq_process::plat_individualRegSet()
701 {
702    return true;
703 }
704
705 bool bgq_process::internal_readMem(int_thread * /*stop_thr*/, Dyninst::Address addr, 
706                                    mem_response::ptr resp, int_thread *thr)
707 {
708    pthrd_printf("Reading from memory %lx +%lx on %d with response ID %d\n", 
709                 addr, (unsigned long) resp->getSize(), getPid(), resp->getID());
710
711    uint32_t size = resp->getSize();
712    int num_reads_needed = (size / MaxMemorySize);
713    if (size % MaxMemorySize)
714       num_reads_needed += 1;
715    if (num_reads_needed > 1)
716       resp->markAsMultiResponse(num_reads_needed);
717    resp->setLastBase(addr);
718
719    for (unsigned cur = 0, j = 0; cur < size; cur += MaxMemorySize, j++) {
720       uint32_t read_size;
721       if (cur + MaxMemorySize >= size)
722          read_size = size - cur;
723       else
724          read_size = MaxMemorySize;
725
726       GetMemoryCmd mem_cmd;
727       mem_cmd.threadID = thr ? thr->getLWP() : 0;
728       mem_cmd.addr = addr + cur;
729       mem_cmd.length = read_size;
730       mem_cmd.specAccess = thr ? SpecAccess_UseThreadState : SpecAccess_ForceNonSpeculative;
731
732       bool result = sendCommand(mem_cmd, GetMemory, resp);
733       if (!result) {
734          pthrd_printf("Error sending command to read memory\n");
735          return false;
736       }
737    }
738    return true;   
739 }
740
741 bool bgq_process::internal_writeMem(int_thread * /*stop_thr*/, const void *local, Dyninst::Address addr,
742                                     size_t size, result_response::ptr resp, int_thread *thr, bp_write_t bp_write)
743 {
744    if (bp_write == int_process::bp_install) {
745       pthrd_printf("Writing breakpoint memory %lx +%lu on %d with response ID %d\n",
746                    addr, (unsigned long) size, getPid(), resp->getID());
747       SetBreakpointCmd setbp;
748       setbp.threadID = thr ? thr->getLWP() : 0;
749       setbp.addr = addr;
750       setbp.instruction = *((int *) local);
751       bool result = sendCommand(setbp, SetBreakpoint, resp);
752       if (!result) {
753          pthrd_printf("Error sending SetBreakpoint\n");
754          return false;
755       }
756       return true;
757    }
758    if (bp_write == int_process::bp_clear) {
759       pthrd_printf("Reset breakpoint memory %lx +%lu on %d with response ID %d\n",
760                    addr, (unsigned long) size, getPid(), resp->getID());
761       ResetBreakpointCmd setbp;
762       setbp.threadID = thr ? thr->getLWP() : 0;
763       setbp.addr = addr;
764       setbp.instruction = *((int *) local);
765       bool result = sendCommand(setbp, ResetBreakpoint, resp);
766       if (!result) {
767          pthrd_printf("Error sending ResetBreakpoint\n");
768          return false;
769       }
770       return true;
771    }
772
773    pthrd_printf("Writing memory %lx +%lu on %d with response ID %d\n", 
774                 addr, (unsigned long) size, getPid(), resp->getID());
775
776    int num_writes_needed = (size / MaxMemorySize);
777    if (size % MaxMemorySize)
778       num_writes_needed += 1;
779    if (num_writes_needed > 1)
780       resp->markAsMultiResponse(num_writes_needed);
781    
782    for (unsigned cur = 0, j = 0; cur < size; cur += MaxMemorySize, j++) {
783       uint32_t write_size;
784       if (cur + MaxMemorySize >= size)
785          write_size = size - cur;
786       else
787          write_size = MaxMemorySize;
788       SetMemoryCmd *setmem = (SetMemoryCmd *) malloc(sizeof(SetMemoryCmd) + write_size + 1);
789       setmem->threadID = thr ? thr->getLWP() : 0;
790       setmem->addr = addr + cur;
791       setmem->length = write_size;
792       setmem->specAccess = thr ? SpecAccess_UseThreadState : SpecAccess_ForceNonSpeculative;
793       setmem->sharedMemoryAccess = SharedMemoryAccess_Allow;
794       memcpy(setmem->data, ((const char *) local) + cur, write_size);
795
796       bool result = sendCommand(*setmem, SetMemory, resp);
797       free(setmem);
798       if (!result) {
799          pthrd_printf("Error sending command to read memory\n");
800          return false;
801       }
802    }
803    return true;
804 }
805
806 bool bgq_process::plat_readMemAsync(int_thread *thr, Dyninst::Address addr, 
807                                     mem_response::ptr resp)
808 {
809    return internal_readMem(thr, addr, resp, NULL);
810 }
811
812 bool bgq_process::plat_writeMemAsync(int_thread *thr, const void *local, Dyninst::Address addr,
813                                      size_t size, result_response::ptr result, bp_write_t bp_write)
814 {
815    return internal_writeMem(thr, local, addr, size, result, NULL, bp_write);
816 }
817
818 bool bgq_process::plat_needsThreadForMemOps() const
819 {
820    return false;
821 }
822
823 bool bgq_process::plat_getOSRunningStates(std::map<Dyninst::LWP, bool> &)
824 {
825    return true;
826 }
827
828 bool bgq_process::plat_suspendThread(int_thread *thrd)
829 {
830    HoldThreadCmd hold_thrd;
831    hold_thrd.threadID = thrd->getLWP();
832
833    bool result = sendCommand(hold_thrd, HoldThread);
834    if (!result) {
835       pthrd_printf("Error sending HoldThread command\n");
836       return false;
837    }
838    return true;
839 }
840
841 bool bgq_process::plat_resumeThread(int_thread *thrd)
842 {
843    ReleaseThreadCmd release_thrd;
844    release_thrd.threadID = thrd->getLWP();
845
846    bool result = sendCommand(release_thrd, ReleaseThread);
847    if (!result) {
848       pthrd_printf("Error sending ReleaseThread command\n");
849       return false;
850    }
851    return true;
852 }
853
854 bool bgq_process::plat_debuggerSuspended()
855 {
856    return debugger_suspended;
857 }
858
859 void bgq_process::noteNewDequeuedEvent(Event::ptr ev)
860 {
861    if (ev->getSyncType() == Event::sync_process) {
862       debugger_suspended = true;
863    }
864 }
865
866 unsigned int bgq_process::plat_getCapabilities()
867 {
868    if (!hasControlAuthority)
869       return Process::pc_read;
870    return int_process::plat_getCapabilities();
871 }
872
873 Event::ptr bgq_process::plat_throwEventsBeforeContinue(int_thread *thr)
874 {
875    if (!pending_control_authority)
876       return Event::ptr();
877    if (thr != threadPool()->initialThread())
878       return Event::ptr();
879
880    pthrd_printf("Throwing new ControlAuthority event upon main thread continue in %d\n", getPid());
881    int_eventControlAuthority *iev = new int_eventControlAuthority();
882    *iev = *pending_control_authority->getInternalEvent();
883    iev->unset_desync = false;
884
885    thr->getControlAuthorityState().desyncStateProc(int_thread::stopped);
886
887    EventControlAuthority::ptr new_ev = EventControlAuthority::ptr(new EventControlAuthority(EventType::Post, iev));
888    new_ev->setProcess(proc());
889    int_thread *initial_thread = threadPool()->initialThread();
890    new_ev->setThread(initial_thread->thread());
891    new_ev->setSyncType(Event::async);
892
893    return new_ev;
894 }
895
896 void bgq_process::plat_threadAttachDone()
897 {
898    pthrd_printf("Adding bootstrap event to mailbox\n");
899    EventBootstrap::ptr ev = EventBootstrap::ptr(new EventBootstrap());
900    int_thread *thrd = threadPool()->initialThread();
901    ev->setProcess(proc());
902    ev->setThread(thrd->thread());
903
904    int_thread::State new_state = int_thread::none;
905    Event::SyncType new_ev_sync_state = Event::unset;
906
907    if (hasControlAuthority) {
908       new_ev_sync_state = Event::async;
909       new_state = int_thread::stopped;
910    }
911    else {
912       new_ev_sync_state = Event::async;
913       new_state = int_thread::running;
914    }
915
916    for (int_threadPool::iterator i = threadPool()->begin(); i != threadPool()->end(); i++) {
917       int_thread *thr = *i;
918       if (new_state == int_thread::stopped) {
919          thr->getGeneratorState().setState(new_state);
920          thr->getHandlerState().setState(new_state);
921       }
922       else {
923          //The order we set these in matters on whether we're doing stop/run operations
924          thr->getHandlerState().setState(new_state);
925          thr->getGeneratorState().setState(new_state);
926       }
927       thr->getUserState().setState(new_state);
928    }
929    ev->setSyncType(new_ev_sync_state);
930
931    getStartupTeardownProcs().inc();
932       
933    mbox()->enqueue(ev);
934 }
935
936 LWPTracking *bgq_process::getLWPTracking()
937 {
938    if (!lwp_tracker) {
939       lwp_tracker = new LWPTracking(proc());
940    }
941    return lwp_tracker;
942 }
943
944 bool bgq_process::plat_lwpRefresh(result_response::ptr resp)
945 {
946    lwp_tracking_resp = resp;
947    GetThreadListCmd cmd;
948    cmd.threadID = 0;
949    bool result = sendCommand(cmd, GetThreadList, resp);
950    if (!result) {
951       pthrd_printf("Error sending GetThreadList command\n");
952       return false;
953    }
954    return true;
955 }
956
957 bool bgq_process::plat_lwpRefreshNoteNewThread(int_thread *thr)
958 {
959    EventBootstrap::ptr newev = EventBootstrap::ptr(new EventBootstrap());
960    newev->setProcess(proc());
961    newev->setThread(thr->thread());
962    newev->setSyncType(Event::async);
963    mbox()->enqueue(newev);   
964    return true;
965 }
966
967 int bgq_process::threaddb_getPid()
968 {
969    return get_procdata_result.tgid;
970 }
971
972 bool bgq_process::handleStartupEvent(void *data)
973 {
974    ComputeNode *cn = getComputeNode();
975    enum {
976       action_none = 0,
977       do_lone_attach = 1,
978       do_group_attach = 2,
979       do_group_wait = 3,
980       group_done = 4
981    } attach_action = action_none;
982    bool expecting_stop = false;
983
984    /**
985     * Most of this complexity is for group attaches, which happen for
986     * each process on the CN.  We only want a group attach action to
987     * happen once, so only the first attach that's processed for that 
988     * group does the attach.  Other processes will either wait for the
989     * attach to be ack'd, or they will realize the attach is already ack'd
990     * and move on.
991     **/
992    if (startup_state == issue_attach) {
993       if (!cn->do_all_attach) {
994          attach_action = do_lone_attach;
995       }
996       else if (cn->all_attach_error) {
997          pthrd_printf("CN attach left us in an error state, failng attach to %d\n", getPid());
998          setState(int_process::errorstate);
999          return false;
1000       }
1001       else if (cn->all_attach_done) {
1002          attach_action = group_done;
1003       }
1004       else {
1005          ScopeLock lock(cn->attach_lock);
1006          pthrd_printf("Doing all attach\n");
1007          if (cn->all_attach_error) {
1008             pthrd_printf("CN attach left us in an error state, failng attach to %d\n", getPid());
1009             setState(int_process::errorstate);
1010             return false;
1011          }
1012          if (cn->all_attach_done)
1013             attach_action = group_done;
1014          else if (cn->issued_all_attach)
1015             attach_action = do_group_wait;
1016          else {
1017             attach_action = do_group_attach;
1018             cn->issued_all_attach = true;
1019          }
1020       }
1021       pthrd_printf("Doing attach on %d, using attach action %d\n", getPid(), (int) attach_action);
1022       getStartupTeardownProcs().inc();
1023       setForceGeneratorBlock(true);
1024       query_transaction->beginTransaction();
1025       update_transaction->beginTransaction();
1026       tooltag = MultiToolControl::getDefaultToolName();
1027       priority = (uint8_t) MultiToolControl::getDefaultToolPriority();
1028    }
1029
1030    /**
1031     * Short-cut the process startup state forward: If a group attach is done, move to 
1032     * the issue control request state.  If the process is in Query Mode (priority 0) then
1033     * skip requesting control authority and jump to the data collection stage.
1034     **/ 
1035    if (attach_action == group_done || attach_action == do_group_wait) {
1036       pthrd_printf("Already issued all attach, not re-doing attach to %d.\n", getPid());
1037       startup_state = issue_control_request;
1038    }
1039
1040    if (attach_action == do_lone_attach || attach_action == do_group_attach) {
1041       AttachMessage attach;
1042       strncpy(attach.toolTag, tooltag.c_str(), sizeof(attach.toolTag));
1043       attach.priority = priority;
1044       pthrd_printf("Sending attach with name %s, priority %u\n", tooltag.c_str(), attach.priority);
1045       fillInToolMessage(attach, Attach);
1046       if (attach_action == do_lone_attach) {
1047          pthrd_printf("Sending attach message to rank %d\n", getPid());
1048          attach.procSelect = RankInHeader;
1049       }
1050       else {
1051          pthrd_printf("Sending attach message to compute node %d\n", cn->getID());
1052          attach.procSelect = RanksInNode;
1053       }
1054       
1055       bool result = getComputeNode()->writeToolMessage(this, &attach, false);
1056       if (!result) {
1057          pthrd_printf("Error sending Attach from startup handler\n");
1058          return false;
1059       }
1060       startup_state = waitfor_attach;
1061       return true;
1062    }
1063
1064    if (startup_state == waitfor_attach) {
1065       AttachAckMessage *attach_ack = static_cast<AttachAckMessage *>(data);
1066       bool attach_retcode = attach_ack->header.returnCode;
1067       free(attach_ack);
1068       attach_ack = NULL;
1069       
1070       if (cn->issued_all_attach) {
1071          ScopeLock lock(cn->attach_lock);
1072          cn->all_attach_done = true;
1073          set<ToolMessage *>::iterator i;
1074          
1075          if (attach_retcode != Success) {
1076             perr_printf("Group attach returned error %d: %s\n", (int) attach_retcode,
1077                         bgq_process::bgqErrorMessage(attach_retcode));
1078             setState(int_process::errorstate);
1079             cn->all_attach_error = true;
1080             for (set<bgq_process *>::iterator i = cn->procs.begin(); i != cn->procs.end(); i++) {
1081                (*i)->setState(int_process::errorstate);
1082             }
1083             return false;
1084          }
1085       }
1086       else {
1087          pthrd_printf("Rank attach to %d done.\n", getPid());
1088       }
1089       startup_state = issue_control_request;
1090    }
1091    
1092    if (startup_state == issue_control_request && priority == QueryPriorityLevel) {
1093       pthrd_printf("In Query-Only mode (priority 0). Not issuing control request to %d\n", getPid());
1094       startup_state = skip_control_request_signal;
1095    }
1096
1097    if (startup_state == issue_control_request) {
1098       pthrd_printf("Issuing ControlMessage in startup handler\n");
1099       ControlMessage *ctrl_msg = (ControlMessage *) malloc(sizeof(ControlMessage));
1100       sigset_t sigs = getSigMask();;
1101       sigaddset(&sigs, SIGTRAP);
1102       sigaddset(&sigs, SIGSTOP);
1103       ctrl_msg->notifySignalSet(&sigs);
1104       ctrl_msg->sndSignal = SIGSTOP;
1105       ctrl_msg->dynamicNotifyMode = DynamicNotifyDLoader;
1106       ctrl_msg->dacTrapMode = DACTrap_NoChange;
1107       fillInToolMessage(*ctrl_msg, Control);
1108       
1109       startup_state = waitfor_control_request_ack;
1110       bool result = getComputeNode()->writeToolAttachMessage(this, ctrl_msg, true);
1111       if (!result) {
1112          pthrd_printf("Error writing ControlMessage in attach handler\n");
1113          delete ctrl_msg;
1114          return false;
1115       }
1116
1117       return true;
1118    }
1119    
1120    if (startup_state == waitfor_control_request_ack) {
1121       ControlAckMessage *ctrl_ack = static_cast<ControlAckMessage *>(data);
1122       uint16_t controllingToolId = ctrl_ack->controllingToolId;
1123       char toolTag[ToolTagSize];
1124       memcpy(toolTag, ctrl_ack->toolTag, ToolTagSize);
1125       uint8_t tool_priority = ctrl_ack->priority;
1126       uint32_t ctrl_retcode = ctrl_ack->header.returnCode;
1127       free(ctrl_ack);
1128       ctrl_ack = NULL;
1129
1130       if (ctrl_retcode != Success && ctrl_retcode != ToolControlConflict) {
1131          perr_printf("Error return in ControlAckMessage: %s\n",
1132                      bgqErrorMessage(ctrl_retcode));
1133          setLastError(err_internal, "Could not send ControlMessage\n");
1134          return false;
1135       }
1136       if (controllingToolId != bgq_process::getToolID()) {
1137          pthrd_printf("Tool '%s' with ID %d has authority at priority %d\n", 
1138                       toolTag, controllingToolId, tool_priority);
1139          if (tool_priority > priority) {
1140             pthrd_printf("WARNING: Tool %s has higher priority (%d > %d), running in Query-Only mode\n",
1141                          toolTag, tool_priority, priority);
1142             expecting_stop = false;
1143             startup_state = issue_data_collection;
1144          }
1145          else {
1146             pthrd_printf("Waiting for control priority release from %s (%d < %d)\n",
1147                          toolTag, tool_priority, priority);
1148             startup_state = waitfor_control_request_notice;
1149             return true;
1150          }
1151       }
1152       else {
1153          pthrd_printf("We are top priority tool, now have control authority\n");
1154          hasControlAuthority = true;
1155          expecting_stop = true;
1156          startup_state = issue_data_collection;
1157       }
1158    }
1159
1160    if (startup_state == waitfor_control_request_notice) {
1161       NotifyMessage *notify_msg = static_cast<NotifyMessage *>(data);
1162       if (notify_msg->type.control.reason == NotifyControl_Available) {
1163          pthrd_printf("ControlRequestNotify means we can now try to retake control\n");
1164          startup_state = issue_control_request;
1165          free(notify_msg);
1166          return handleStartupEvent(NULL);
1167       }
1168       else if (notify_msg->type.control.reason == NotifyControl_Conflict) {
1169          pthrd_printf("Conflict message from control request, moving to data collection\n");
1170          pthrd_printf("Conflicting tag is %s, id = %u, priority = %u\n",
1171                       notify_msg->type.control.toolTag,
1172                       notify_msg->type.control.toolid,
1173                       notify_msg->type.control.priority);
1174          startup_state = skip_control_request_signal;
1175          free(notify_msg);
1176       }
1177       else
1178          assert(0);
1179    }
1180
1181    /**
1182     * Send a set of query in a single CommandMessage.  We want:
1183     *  - GetProcessData
1184     *  - AuxVectors
1185     *  - GetThreadData
1186     *  - ThreadList
1187     **/
1188    if (startup_state == issue_data_collection || startup_state == skip_control_request_signal) {
1189       pthrd_printf("Issuing data request\n");
1190
1191       GetProcessDataCmd procdata_cmd;
1192       procdata_cmd.threadID = 0;
1193       sendCommand(procdata_cmd, GetProcessData);
1194
1195       GetAuxVectorsCmd auxv_cmd;
1196       auxv_cmd.threadID = 0;
1197       sendCommand(auxv_cmd, GetAuxVectors);
1198
1199       GetThreadDataCmd thrddata_cmd;
1200       thrddata_cmd.threadID = 0;
1201       sendCommand(thrddata_cmd, GetThreadData);
1202
1203       GetThreadListCmd thread_list;
1204       thread_list.threadID = 0;
1205       sendCommand(thread_list, GetThreadList);
1206
1207       if (expecting_stop && startup_state != skip_control_request_signal)
1208          startup_state = waitfor_data_or_stop;
1209       else
1210          startup_state = waitfor_data_collection;
1211       return true;
1212    }
1213
1214    bool data_on_either = false;
1215    bool stop_on_either = false;
1216    if (startup_state == waitfor_data_or_stop) {
1217       ToolMessage *msg = static_cast<ToolMessage *>(data);
1218       data_on_either = (msg->header.type == QueryAck);
1219       stop_on_either = (msg->header.type == Notify);
1220       pthrd_printf("Waiting for either data or stop, got %s\n", data_on_either ? "data" : "stop");
1221       assert((data_on_either || stop_on_either) && !(data_on_either && stop_on_either));
1222    }
1223
1224    if (startup_state == waitfor_control_request_signal || stop_on_either) {
1225       pthrd_printf("Received attach SIGNAL\n");
1226       NotifyMessage *notify_msg = static_cast<NotifyMessage *>(data);
1227       int_thread *thrd = threadPool()->initialThread();
1228       thrd->getUserState().setStateProc(int_thread::stopped);      
1229       assert(notify_msg->type.signal.reason == NotifySignal_Generic);
1230       assert(notify_msg->type.signal.signum == SIGSTOP);
1231       got_startup_stop = true;
1232       free(notify_msg);
1233       if (stop_on_either) {
1234          startup_state = waitfor_data_collection;
1235          return true;
1236       }
1237       else
1238          startup_state = waits_done;
1239    }
1240
1241    /**
1242     * Receive the data from the above query command.
1243     **/
1244    if (startup_state == waitfor_data_collection || data_on_either) {
1245       pthrd_printf("Handling getProcessDataAck for %d\n", getPid());
1246       QueryAckMessage *query_ack = static_cast<QueryAckMessage *>(data);
1247       assert(query_ack->numCommands == 4);
1248       GetThreadDataAckCmd *tdata = NULL;
1249
1250       for (unsigned i = 0; i < (unsigned) query_ack->numCommands; i++) {
1251          char *cmd_ptr = ((char *) data) + query_ack->cmdList[i].offset;
1252          if (query_ack->cmdList[i].type == GetProcessDataAck)
1253             get_procdata_result = *(GetProcessDataAckCmd *) cmd_ptr;
1254          else if (query_ack->cmdList[i].type == GetAuxVectorsAck)
1255             get_auxvectors_result = *(GetAuxVectorsAckCmd *) cmd_ptr;
1256          else if (query_ack->cmdList[i].type == GetThreadListAck) {
1257             if (!get_thread_list) 
1258                get_thread_list = new GetThreadListAckCmd();
1259             *get_thread_list = *(GetThreadListAckCmd *) cmd_ptr;
1260          }
1261          else if (query_ack->cmdList[i].type == GetThreadDataAck) {
1262             tdata = (GetThreadDataAckCmd *) cmd_ptr;
1263             BG_Thread_ToolState ts = tdata->toolState;
1264             stopped_on_startup = ((ts == Suspend) || (ts == HoldSuspend));
1265             held_on_startup = ((ts == Hold) || (ts == HoldSuspend));
1266             pthrd_printf("On startup, found stopped: %s, held: %s\n",
1267                          stopped_on_startup ? "true" : "false",
1268                          held_on_startup ? "true" : "false");
1269
1270
1271          }
1272       }
1273
1274       if (stopped_on_startup || held_on_startup) {
1275          debugger_stopped = true;
1276          debugger_suspended = true;
1277       }
1278
1279       if (data_on_either && (stopped_on_startup || held_on_startup)) {
1280          pthrd_printf("Attaching to already stopped tool.  Skipping wait for SIGSTOP\n");
1281          startup_state = waits_done;
1282       }
1283       else if (data_on_either) {
1284          pthrd_printf("Got data ack during startup.  Waiting for SIGSTOP\n");
1285          startup_state = waitfor_control_request_signal;
1286          return true;
1287       }
1288       else {
1289          startup_state = waits_done;
1290       }
1291    }
1292
1293    if (startup_state == waits_done) {
1294       pthrd_printf("In state waits_done for %d\n", getPid());
1295       int_thread *thrd = threadPool()->initialThread();
1296       assert(thrd);
1297
1298       setState(neonatal_intermediate);
1299
1300       if (hasControlAuthority) {
1301          thrd->getStartupState().desyncStateProc(int_thread::stopped);
1302          if (stopped_on_startup || held_on_startup || got_startup_stop) {
1303             thrd->getGeneratorState().setStateProc(int_thread::stopped);
1304             thrd->getHandlerState().setStateProc(int_thread::stopped);
1305             thrd->getUserState().setStateProc(int_thread::stopped);
1306          }
1307       }
1308       else {
1309          thrd->getStartupState().desyncStateProc(int_thread::running);
1310          thrd->getHandlerState().setStateProc(int_thread::running);
1311       }
1312     
1313       if (get_thread_list->numthreads > 0) {
1314          setState(running);
1315          getStartupTeardownProcs().dec();
1316          startup_state = startup_done;
1317          thrd->changeLWP(get_thread_list->threadlist[0].tid);
1318       }
1319       else {
1320          //BG/Q didn't give us the thread info we need on attach.
1321          // single-step one instruction and try again.
1322          pthrd_printf("Got 0 threads in thread list.  Single stepping process %d\n", getPid());
1323          startup_state = step_insn;
1324          thrd->getStartupState().setState(int_thread::running);
1325          thrd->setSingleStepMode(true);
1326          if (held_on_startup) {
1327             thrd->setSuspended(true);
1328             held_on_startup = false;
1329          }
1330       }
1331       
1332       return true;
1333    }
1334
1335    /**
1336     * If we didn't get the GetThreadList cmd accurately right off, then
1337     * step the app one instruction and try again.
1338     **/
1339    if (startup_state == step_insn) {
1340       pthrd_printf("In startup state step_insn for %d\n", getPid());
1341       int_thread *thrd = threadPool()->initialThread();
1342       if (hasControlAuthority)
1343          thrd->getStartupState().setState(int_thread::stopped);
1344       thrd->setSingleStepMode(false);
1345
1346       GetThreadListCmd thread_list;
1347       thread_list.threadID = 0;
1348       sendCommand(thread_list, GetThreadList);
1349
1350       startup_state = reissue_data_collection;
1351       return true;
1352    }
1353
1354    if (startup_state == reissue_data_collection) {
1355       QueryAckMessage *query_ack = static_cast<QueryAckMessage *>(data);
1356       assert(query_ack->cmdList[0].type = GetThreadListAck);
1357       *get_thread_list = *(GetThreadListAckCmd *) (((char *) data) + query_ack->cmdList[0].offset);
1358       
1359       assert(get_thread_list->numthreads > 0);
1360       int_thread *thrd = threadPool()->initialThread();
1361       thrd->changeLWP(get_thread_list->threadlist[0].tid);
1362       
1363       setState(running);
1364       getStartupTeardownProcs().dec();
1365
1366       startup_state = startup_done;
1367       return true;
1368    }
1369    
1370
1371    if (startup_state == startup_done) {
1372       pthrd_printf("Handling state startup_done for %d\n", getPid());
1373       int_thread *thrd = threadPool()->initialThread();
1374       thrd->getStartupState().restoreStateProc();
1375       getStartupTeardownProcs().dec();
1376       setForceGeneratorBlock(false);
1377       
1378       if (held_on_startup) {
1379          int_threadPool *tp = threadPool();
1380          for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
1381             int_thread *thrd = *i;
1382             pthrd_printf("Threads were held on startup.  Updating held state for %d/%d\n",
1383                          getPid(), thrd->getLWP());
1384             thrd->setSuspended(true);
1385          }
1386       }
1387       pthrd_printf("Startup done on %d\n", getPid());
1388       startup_state = startup_donedone;
1389    }
1390
1391    return true;
1392 }
1393
1394 void bgq_process::fillInToolMessage(ToolMessage &msg, uint16_t msg_type, response::ptr resp)
1395 {
1396    msg.header.service = ToolctlService;
1397    msg.header.version = ProtocolVersion;
1398    msg.header.type = msg_type;
1399    msg.header.rank = getRank();
1400    if (resp) {
1401       ResponseSet *resp_set = new ResponseSet();
1402       msg.header.sequenceId = resp_set->getID();
1403       resp_set->addID(resp->getID(), 0);
1404    }
1405    else {
1406       msg.header.sequenceId = 0;
1407    }
1408    msg.header.returnCode = 0;
1409    msg.header.errorCode = 0;
1410    msg.header.length = bgq_process::getMessageLength(msg);
1411    msg.header.jobId = bgq_process::getJobID();
1412    msg.toolId = bgq_process::getToolID();
1413 }
1414
1415 ComputeNode *bgq_process::getComputeNode() const
1416 {
1417    return cn;
1418 }
1419
1420 bool bgq_process::decoderPendingStop()
1421 {
1422    return decoder_pending_stop;
1423 }
1424
1425 void bgq_process::setDecoderPendingStop(bool b)
1426 {
1427    decoder_pending_stop = b;
1428 }
1429
1430 uint32_t bgq_process::getRank()
1431 {
1432    return rank;
1433 }
1434
1435 uint64_t bgq_process::getJobID()
1436 {
1437    return jobid;
1438 }
1439
1440 uint32_t bgq_process::getToolID()
1441 {
1442    return toolid;
1443 }
1444
1445 std::string bgq_process::mtool_getName()
1446 {
1447    return tooltag;
1448 }
1449
1450 MultiToolControl::priority_t bgq_process::mtool_getPriority()
1451 {
1452    return priority;
1453 }
1454
1455 MultiToolControl *bgq_process::mtool_getMultiToolControl()
1456 {
1457    if (!mtool) {
1458       mtool = new MultiToolControl(proc());
1459    }
1460    return mtool;
1461 }
1462
1463 void bgq_process::bgq_getProcCoordinates(unsigned &a, unsigned &b, unsigned &c, unsigned &d, unsigned &e, unsigned &t) const
1464 {
1465    a = get_procdata_result.aCoord;
1466    b = get_procdata_result.bCoord;
1467    c = get_procdata_result.cCoord;
1468    d = get_procdata_result.dCoord;
1469    e = get_procdata_result.eCoord;
1470    t = get_procdata_result.tCoord;
1471 }
1472
1473 unsigned int bgq_process::bgq_getComputeNodeID() const
1474 {
1475    return getComputeNode()->getID();
1476 }
1477
1478 void bgq_process::bgq_getSharedMemRange(Dyninst::Address &start, Dyninst::Address &end) const
1479 {
1480    start = get_procdata_result.sharedMemoryStartAddr;
1481    end = get_procdata_result.sharedMemoryEndAddr;
1482 }
1483
1484 void bgq_process::bgq_getPersistantMemRange(Dyninst::Address &start, Dyninst::Address &end) const
1485 {
1486    start = get_procdata_result.persistMemoryStartAddr;
1487    end = get_procdata_result.persistMemoryEndAddr;
1488 }
1489
1490 void bgq_process::bgq_getHeapMemRange(Dyninst::Address &start, Dyninst::Address &end) const
1491 {
1492    start = get_procdata_result.heapStartAddr;
1493    end = get_procdata_result.heapEndAddr;
1494 }
1495
1496 bool bgq_process::plat_waitAndHandleForProc()
1497 {
1498    pthrd_printf("Rotating transactions at top of plat_waitAndHandleForProc\n");
1499    rotateTransaction();
1500    return true;
1501 }
1502
1503 bool bgq_process::sendCommand(const ToolCommand &cmd, uint16_t cmd_type, response::ptr resp, unsigned int resp_mod)
1504 {
1505    uint16_t msg_type = getCommandMsgType(cmd_type);
1506    unsigned int resp_id = 0;
1507    bool use_respid = false;
1508    if (resp) {
1509       resp_id = resp->getID() + resp_mod;
1510       use_respid = true;
1511    }
1512    if (msg_type == Query) {
1513       return query_transaction->writeCommand(&cmd, cmd_type, resp_id, use_respid);
1514    }
1515    else if (msg_type == Update) {
1516       return update_transaction->writeCommand(&cmd, cmd_type, resp_id, use_respid);
1517    }
1518    else {
1519       assert(0); //Are we trying to send an Ack?
1520    }
1521    return false;
1522 }
1523
1524 bool bgq_process::sendCommand(const ToolCommand &cmd, uint16_t cmd_type, Resp::ptr resp)
1525 {
1526    uint16_t msg_type = getCommandMsgType(cmd_type);
1527    if (msg_type == Query) {
1528       return query_transaction->writeCommand(&cmd, cmd_type, resp->getID(), true);
1529    }
1530    else if (msg_type == Update) {
1531       return update_transaction->writeCommand(&cmd, cmd_type, resp->getID(), true);
1532    }
1533    else {
1534       assert(0); //Are we trying to send an Ack?
1535    }
1536    return false;
1537 }
1538
1539 bool bgq_process::isActionCommand(uint16_t cmd_type)
1540 {
1541    switch (cmd_type) {
1542       case StepThread:
1543       case ContinueProcess:
1544       case ReleaseControl:
1545          return true;
1546    }
1547    return false;
1548 }
1549
1550 bool bgq_process::plat_getStackInfo(int_thread *thr, stack_response::ptr stk_resp)
1551 {
1552    GetThreadDataCmd thr_cmd;
1553
1554    thr_cmd.threadID = thr->getLWP();
1555
1556    bool result = sendCommand(thr_cmd, GetThreadData, stk_resp);
1557    if (!result) {
1558       setLastError(err_internal, "Error while asking for thread data\n");
1559       perr_printf("Could not send GetThreadData to %d/%d\n", 
1560                   thr->llproc()->getPid(), thr->getLWP());
1561       return false;
1562    }
1563    
1564    //Needed to track to know when to free the ArchEventBGQ objects
1565    // associated with the stackwalks.
1566    num_pending_stackwalks++;
1567    return true;
1568 }
1569
1570 bool bgq_process::plat_handleStackInfo(stack_response::ptr stk_resp, CallStackCallback *cbs)
1571 {
1572    GetThreadDataAckCmd *thrdata = static_cast<GetThreadDataAckCmd *>(stk_resp->getData());
1573    int_thread *t = stk_resp->getThread();
1574    assert(stk_resp);
1575    assert(t);
1576    Thread::ptr thr = t->thread();
1577    bool had_error = false, result;
1578    
1579    assert(num_pending_stackwalks > 0);
1580    num_pending_stackwalks--;
1581
1582    if (stk_resp->hasError()) {
1583       perr_printf("Error getting thread data on %d/%d", t->llproc()->getPid(), thr->getLWP());
1584       setLastError(err_internal, "Error receiving thread data\n");
1585       had_error = true;
1586       goto done;
1587    }
1588
1589    pthrd_printf("Handling response with call stack %d/%d\n", t->llproc()->getPid(), t->getLWP());
1590
1591    result = cbs->beginStackWalk(thr);
1592    if (!result) {
1593       pthrd_printf("User choose not to receive call stack data for %d/%d\n",
1594                    t->llproc()->getPid(), t->getLWP());
1595       goto done;
1596    }
1597
1598    if (cbs->top_first) {
1599       for (signed int i=thrdata->numStackFrames-1; i >= 0; i--) {
1600          result = cbs->addStackFrame(thr, thrdata->stackInfo[i].savedLR, thrdata->stackInfo[i].frameAddr, 0);
1601          if (!result)
1602             break;
1603       }
1604    }
1605    else {
1606       for (unsigned int i=0; i < thrdata->numStackFrames; i++) {
1607          result = cbs->addStackFrame(thr, thrdata->stackInfo[i].savedLR, thrdata->stackInfo[i].frameAddr, 0);
1608          if (!result)
1609             break;
1610       }
1611    }
1612    if (!result) {
1613       pthrd_printf("User choose not to continue receive call stack data for %d/%d\n",
1614                    t->llproc()->getPid(), t->getLWP());
1615       goto done;
1616    }
1617
1618    cbs->endStackWalk(thr);
1619   done:
1620    if (!num_pending_stackwalks) {
1621       for (set<void *>::iterator i = held_msgs.begin(); i != held_msgs.end(); i++) {
1622          free(*i);
1623       }
1624       held_msgs.clear();
1625    }
1626    return !had_error;
1627 }
1628
1629 bool bgq_process::plat_getFileDataAsync(int_eventAsyncFileRead *fileread)
1630 {
1631    if (!fileread->orig_size)
1632       fileread->orig_size = MaxMemorySize;
1633
1634    FileReadResp_t *readresp = new FileReadResp_t(fileread, this);
1635    readresp->post();
1636
1637    GetFileContentsCmd getfile;
1638    getfile.threadID = 0;
1639    strncpy(getfile.pathname, fileread->filename.c_str(), MaxPersistPathnameSize);
1640    getfile.offset = fileread->offset;
1641    getfile.numbytes = fileread->orig_size;
1642    
1643    pthrd_printf("Sending GetFileContents for %s on %d from %lu to %lu\n", 
1644                 getfile.pathname, getPid(), fileread->offset, fileread->offset + fileread->orig_size);
1645    bool result = sendCommand(getfile, GetFileContents, readresp);
1646
1647    return result;
1648 }
1649
1650 bool bgq_process::plat_getFileStatData(std::string filename, Dyninst::ProcControlAPI::stat64_ptr *stat_results,
1651                                        std::set<StatResp_t *> &resps)
1652 {
1653    GetFileStatDataCmd filestat;
1654    filestat.threadID = 0;
1655    strncpy(filestat.pathname, filename.c_str(), MaxPersistPathnameSize);
1656    
1657    StatResp_t *statresp = new StatResp_t(stat_results, this);
1658    assert(statresp);
1659    statresp->post();
1660
1661    pthrd_printf("Sending GetFileStatDataCmd for %s to %d\n", filename.c_str(), getPid());
1662    bool result = sendCommand(filestat, GetFileStatData, statresp);
1663    if (!result) {
1664       perr_printf("Failed to send STAT command\n");
1665       delete statresp;
1666       return false;
1667    }
1668    
1669    resps.insert(statresp);
1670    return true;
1671 }
1672
1673 bool bgq_process::plat_getFileNames(FileSetResp_t *resp)
1674 {
1675    GetFilenamesCmd fnames;
1676    fnames.threadID = 0;
1677
1678    resp->post();
1679
1680    pthrd_printf("Sending getfilenames to %d\n", getPid());
1681    bool result = sendCommand(fnames, GetFilenames, resp);
1682    if (!result) {
1683       perr_printf("Failed to send GetFilenames command\n");
1684       return false;
1685    }
1686
1687    return true;
1688 }
1689
1690 bool bgq_process::allowSignal(int signal_no)
1691 {
1692    dyn_sigset_t mask = getSigMask();
1693    return sigismember(&mask, signal_no);   
1694 }
1695
1696 set<void *> bgq_process::held_msgs;
1697 unsigned int bgq_process::num_pending_stackwalks = 0;
1698
1699 int_thread *int_thread::createThreadPlat(int_process *proc, 
1700                                          Dyninst::THR_ID thr_id, 
1701                                          Dyninst::LWP lwp_id,
1702                                          bool /*initial_thrd*/)
1703 {
1704    bgq_thread *qthrd = new bgq_thread(proc, thr_id, lwp_id);
1705    assert(qthrd);
1706
1707    map<int, int> &states = proc->getProcDesyncdStates();
1708    int myid = StartupStateID;
1709    map<int, int>::iterator i = states.find(myid);
1710    if (i != states.end()) {
1711       int_thread::State ns = proc->threadPool()->initialThread()->getStartupState().getState();      
1712       for (int j = 0; j < i->second; j++) {
1713          qthrd->getStartupState().desyncState(ns);
1714       }
1715    }
1716
1717    return static_cast<int_thread *>(qthrd);
1718 }
1719
1720 bgq_thread::bgq_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
1721    int_thread(p, t, l),
1722    thread_db_thread(p, t, l),
1723    ppc_thread(p, t, l),
1724    last_signaled(false),
1725    unwinder(NULL)
1726 {
1727 }
1728
1729 bgq_thread::~bgq_thread()
1730 {
1731    if (unwinder) {
1732       delete unwinder;
1733       unwinder = NULL;
1734    }
1735 }
1736
1737 bool bgq_thread::plat_cont()
1738 {
1739    int_thread *signal_thrd = NULL, *resumed_thread = NULL;
1740    int cont_signal = 0;
1741    set<int_thread *> ss_threads;
1742    bgq_process *proc = dynamic_cast<bgq_process *>(llproc());
1743
1744    proc->debugger_suspended = false;
1745
1746    int_threadPool *tp = proc->threadPool();
1747    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
1748       bgq_thread *t = dynamic_cast<bgq_thread *>(*i);
1749       bool is_suspended = t->isSuspended();
1750       if (t->last_signaled && !is_suspended) {
1751          signal_thrd = t;
1752          t->last_signaled = false;
1753       }
1754       if (!is_suspended && !resumed_thread) {
1755          resumed_thread = t;
1756       }
1757       if (t->continueSig_) {
1758          cont_signal = t->continueSig_;
1759          t->continueSig_ = 0;
1760       }
1761       if (t->singleStep()) {
1762          ss_threads.insert(t);
1763       }
1764    }
1765
1766    if (cont_signal) {
1767       if (!signal_thrd) {
1768          pthrd_printf("The signaled thread is suspended, selecting a resumed thread to re-signal\n");
1769          signal_thrd = resumed_thread;
1770       }
1771       assert(signal_thrd);
1772       
1773       pthrd_printf("Sending SetContinueSignalCmd to %d/%d with signal %d\n",
1774                    proc->getPid(), signal_thrd->getLWP(), cont_signal);
1775       
1776       SetContinuationSignalCmd cont_signal_cmd;
1777       cont_signal_cmd.threadID = signal_thrd->getLWP();
1778       cont_signal_cmd.signum = cont_signal;
1779       bool result = proc->sendCommand(cont_signal_cmd, SetContinuationSignal);
1780       if (!result) {
1781          pthrd_printf("Error sending continuation signal\n");
1782          return false;
1783       }
1784    }
1785
1786    if (ss_threads.empty()) {
1787       pthrd_printf("Sending ContinueProcess command to %d\n", proc->getPid());
1788       proc->last_ss_thread = NULL;
1789       ContinueProcessCmd cont_process;
1790       cont_process.threadID = 0;
1791       bool result = proc->sendCommand(cont_process, ContinueProcess);
1792       if (!result) {
1793          pthrd_printf("Error sending continue process command\n");
1794          return false;
1795       }
1796       return true;
1797    }
1798
1799    pthrd_printf("%lu threads of process %d are in single step, selecting thread for single step\n",
1800                 (unsigned long) ss_threads.size(), proc->getPid());
1801    int_thread *ss_thread = NULL;
1802    if (ss_threads.size() > 1 && proc->last_ss_thread) {
1803       /**
1804        * Multiple threads are single-stepping at once, but the BG/Q debug interface only allows us to 
1805        * step one at a time.  We'll remember what thread we stepped last and rotate the next thread
1806        * that gets stepped with each call.
1807        **/
1808       for (set<int_thread *>::iterator i = ss_threads.begin(); i != ss_threads.end(); i++) {
1809          if (*i != proc->last_ss_thread)
1810             continue;
1811          i++;
1812          if (i == ss_threads.end())
1813             i = ss_threads.begin();
1814          ss_thread = proc->last_ss_thread = *i;
1815          break;
1816       }
1817    }
1818    if (!ss_thread) {
1819       ss_thread = proc->last_ss_thread = *ss_threads.begin();
1820    }
1821    assert(ss_thread);
1822
1823    StepThreadCmd step_thrd;
1824    pthrd_printf("Single stepping thread %d/%d\n", proc->getPid(), ss_thread->getLWP());
1825    if (ss_thread->getLWP() != -1)
1826       step_thrd.threadID = ss_thread->getLWP();
1827    else
1828       step_thrd.threadID = 0;
1829    bool result = proc->sendCommand(step_thrd, StepThread);
1830    if (!result) {
1831       pthrd_printf("Error doing sendCommand of StepThread\n");
1832       return false;
1833    }
1834    return true;
1835 }
1836
1837 bool bgq_thread::plat_stop()
1838 {
1839    pthrd_printf("Signaling %d/%d with SIGSTOP\n", llproc()->getPid(), getLWP());
1840    
1841    SendSignalCmd send_stop;
1842    send_stop.threadID = getLWP();
1843    send_stop.signum = SIGSTOP;
1844    bgq_process *bgproc = dynamic_cast<bgq_process *>(llproc());
1845
1846    bool result = bgproc->sendCommand(send_stop, SendSignal);
1847    if (!result) {
1848       pthrd_printf("Error doing sendCommand with SendSignal\n");
1849       return false;
1850    }
1851
1852    bgproc->setDecoderPendingStop(true);
1853
1854    return true;
1855 }
1856
1857 #define GPR_TO_POOL(REGNUM) reg.regs[ppc64::r ## REGNUM] = gprs[REGNUM];
1858 #define SPEC_TO_POOL(REGNAME) reg.regs[ppc64:: REGNAME] = sregs-> REGNAME;
1859 #define SPEC_TO_POOL2(REGNAME1, REGNAME2) reg.regs[ppc64:: REGNAME1] = sregs-> REGNAME2;
1860 void bgq_thread::regBufferToPool(BG_Reg_t *gprs, BG_Special_Regs *sregs, int_registerPool &reg)
1861 {
1862    if (gprs) {
1863       GPR_TO_POOL(0);     GPR_TO_POOL(1);     GPR_TO_POOL(2);
1864       GPR_TO_POOL(3);     GPR_TO_POOL(4);     GPR_TO_POOL(5);
1865       GPR_TO_POOL(6);     GPR_TO_POOL(7);     GPR_TO_POOL(8);
1866       GPR_TO_POOL(9);     GPR_TO_POOL(10);    GPR_TO_POOL(11);
1867       GPR_TO_POOL(12);    GPR_TO_POOL(13);    GPR_TO_POOL(14);
1868       GPR_TO_POOL(15);    GPR_TO_POOL(16);    GPR_TO_POOL(17);
1869       GPR_TO_POOL(18);    GPR_TO_POOL(19);    GPR_TO_POOL(20);
1870       GPR_TO_POOL(21);    GPR_TO_POOL(22);    GPR_TO_POOL(23);
1871       GPR_TO_POOL(24);    GPR_TO_POOL(25);    GPR_TO_POOL(26);
1872       GPR_TO_POOL(27);    GPR_TO_POOL(28);    GPR_TO_POOL(29);
1873       GPR_TO_POOL(30);    GPR_TO_POOL(31);
1874    }
1875    if (sregs) {
1876       SPEC_TO_POOL2(pc, iar);                 SPEC_TO_POOL(lr);
1877       SPEC_TO_POOL(msr);                      SPEC_TO_POOL(cr);
1878       SPEC_TO_POOL(ctr);                      SPEC_TO_POOL(xer);
1879       SPEC_TO_POOL2(fpscw, fpscr);
1880    }
1881 }
1882
1883 #define REG_TO_USER(R)                                      \
1884    int_registerPool::const_iter i = regs.find(ppc64:: R);   \
1885    assert(i != regs.end();                                  \
1886    
1887 #define NUM_REGS_IN_PT_REGS 44
1888 void bgq_thread::regPoolToUser(const int_registerPool &pool_regs, void *user_area)
1889 {
1890    static MachRegister regs[NUM_REGS_IN_PT_REGS];
1891    static bool regs_init = false;
1892
1893    if (!regs_init) {
1894       //Define the order of regs in the user region by order in this array
1895       regs[0] = ppc64::r0;       regs[1] = ppc64::r1;         regs[2] = ppc64::r2;
1896       regs[3] = ppc64::r3;       regs[4] = ppc64::r4;         regs[5] = ppc64::r5;
1897       regs[6] = ppc64::r6;       regs[7] = ppc64::r7;         regs[8] = ppc64::r8;
1898       regs[9] = ppc64::r9;       regs[10] = ppc64::r10;       regs[11] = ppc64::r11;
1899       regs[12] = ppc64::r12;     regs[13] = ppc64::r13;       regs[14] = ppc64::r14;
1900       regs[15] = ppc64::r15;     regs[16] = ppc64::r16;       regs[17] = ppc64::r17;
1901       regs[18] = ppc64::r18;     regs[19] = ppc64::r19;       regs[20] = ppc64::r20;
1902       regs[21] = ppc64::r21;     regs[22] = ppc64::r22;       regs[23] = ppc64::r23;
1903       regs[24] = ppc64::r24;     regs[25] = ppc64::r25;       regs[26] = ppc64::r26;
1904       regs[27] = ppc64::r27;     regs[28] = ppc64::r28;       regs[29] = ppc64::r29;
1905       regs[30] = ppc64::r30;     regs[31] = ppc64::r31;        
1906       regs[32] = ppc64::pc;
1907       regs[33] = ppc64::msr;
1908       regs[34] = InvalidReg; //orig_gpr3
1909       regs[35] = ppc64::ctr;
1910       regs[36] = ppc64::lr;
1911       regs[37] = ppc64::xer;
1912       regs[38] = InvalidReg; //ccr
1913       regs[39] = InvalidReg; //softe
1914       regs[40] = ppc64::trap;
1915       regs[41] = ppc64::dar;
1916       regs[42] = ppc64::dsisr;
1917       regs[43] = InvalidReg; //result;
1918       regs_init = true;
1919    }
1920
1921    for (unsigned i=0; i < NUM_REGS_IN_PT_REGS; i++) {
1922       MachRegister r = regs[i];
1923       uint64_t val = 0;
1924       if (r != InvalidReg) {
1925          int_registerPool::const_iterator j = pool_regs.regs.find(r);
1926          if (j != pool_regs.regs.end()) {
1927             val = j->second;
1928          }
1929       }
1930       ((uint64_t *) user_area)[i] = val;
1931    }
1932 }
1933
1934 #define GPR_TO_BUFFER(REGNUM) gprs[REGNUM] = reg.regs[ppc64::r ## REGNUM];
1935 #define SPEC_TO_BUFFER(REGNAME) sregs->REGNAME = reg.regs[ppc64:: REGNAME];
1936 #define SPEC_TO_BUFFER2(REGNAME1, REGNAME2) sregs-> REGNAME2 = reg.regs[ppc64:: REGNAME1];
1937 void bgq_thread::regPoolToBuffer(int_registerPool &reg, BG_Reg_t *gprs, BG_Special_Regs *sregs)
1938 {
1939    GPR_TO_BUFFER(0);     GPR_TO_BUFFER(1);     GPR_TO_BUFFER(2);
1940    GPR_TO_BUFFER(3);     GPR_TO_BUFFER(4);     GPR_TO_BUFFER(5);
1941    GPR_TO_BUFFER(6);     GPR_TO_BUFFER(7);     GPR_TO_BUFFER(8);
1942    GPR_TO_BUFFER(9);     GPR_TO_BUFFER(10);    GPR_TO_BUFFER(11);
1943    GPR_TO_BUFFER(12);    GPR_TO_BUFFER(13);    GPR_TO_BUFFER(14);
1944    GPR_TO_BUFFER(15);    GPR_TO_BUFFER(16);    GPR_TO_BUFFER(17);
1945    GPR_TO_BUFFER(18);    GPR_TO_BUFFER(19);    GPR_TO_BUFFER(20);
1946    GPR_TO_BUFFER(21);    GPR_TO_BUFFER(22);    GPR_TO_BUFFER(23);
1947    GPR_TO_BUFFER(24);    GPR_TO_BUFFER(25);    GPR_TO_BUFFER(26);
1948    GPR_TO_BUFFER(27);    GPR_TO_BUFFER(28);    GPR_TO_BUFFER(29);
1949    GPR_TO_BUFFER(30);    GPR_TO_BUFFER(31);
1950    SPEC_TO_BUFFER2(pc, iar);                    SPEC_TO_BUFFER(lr);
1951    SPEC_TO_BUFFER(msr);                        SPEC_TO_BUFFER(cr);
1952    SPEC_TO_BUFFER(ctr);                        SPEC_TO_BUFFER(xer);
1953    SPEC_TO_BUFFER2(fpscw, fpscr);
1954 }
1955
1956 bool bgq_thread::genRegToSystem(MachRegister reg, GeneralRegSelect &result) {
1957    if (!(reg.val() & ppc64::GPR))
1958       return false;
1959
1960    result = (GeneralRegSelect) (reg.val() & 0x0000ffff);
1961    return true;
1962 }
1963
1964 bool bgq_thread::specRegToSystem(MachRegister reg, SpecialRegSelect &result) {
1965 #define CASE_REG(DNAME, QNAME) case ppc64::i ## DNAME : result = QNAME; return true
1966    switch (reg.val()) {
1967       CASE_REG(pc, iar);
1968       CASE_REG(lr, lr);
1969       CASE_REG(msr, msr);
1970       CASE_REG(cr, cr);
1971       CASE_REG(ctr, ctr);
1972       CASE_REG(xer, xer);
1973       CASE_REG(fpscw, fpscr);
1974    }
1975    return false;
1976 }
1977
1978 bool bgq_thread::plat_getAllRegisters(int_registerPool &)
1979 {
1980    assert(0); //Async only
1981    return false;
1982 }
1983
1984 bool bgq_thread::plat_getRegister(Dyninst::MachRegister, Dyninst::MachRegisterVal &)
1985 {
1986    assert(0); //Async only
1987    return false;
1988 }
1989
1990 bool bgq_thread::plat_setAllRegisters(int_registerPool &)
1991 {
1992    assert(0); //Async only
1993    return false;
1994 }
1995
1996 bool bgq_thread::plat_setRegister(Dyninst::MachRegister, Dyninst::MachRegisterVal)
1997 {
1998    assert(0); //Async only
1999    return false;
2000 }
2001
2002 bool bgq_thread::attach()
2003 {
2004    return true;
2005 }
2006
2007 bool bgq_thread::plat_getAllRegistersAsync(allreg_response::ptr resp)
2008 {
2009    GetGeneralRegsCmd get_gpr_regs;
2010    GetSpecialRegsCmd get_spec_regs;
2011    bgq_process *bgproc = dynamic_cast<bgq_process *>(llproc());
2012
2013    get_gpr_regs.threadID = get_spec_regs.threadID = getLWP();
2014    
2015    pthrd_printf("getAllRegisters for %d/%d\n", llproc()->getPid(), getLWP());
2016
2017    resp->markAsMultiResponse(2); //2 commands need to complete: gpr and spec
2018
2019    bool result = bgproc->sendCommand(get_gpr_regs, GetGeneralRegs, resp, 0);
2020    if (!result) {
2021       pthrd_printf("Error in sendCommand for GetGeneralRegs\n");
2022       return false;
2023    }
2024
2025    result = bgproc->sendCommand(get_spec_regs, GetSpecialRegs, resp, 1);
2026    if (!result) {
2027       pthrd_printf("Error in sendCommand for GetSpecialRegs\n");
2028       return false;
2029    }
2030
2031    return true;
2032 }
2033
2034 bool bgq_thread::plat_getRegisterAsync(Dyninst::MachRegister,
2035                                        reg_response::ptr)
2036 {
2037    assert(0); //No individual reg access on this platform.
2038    return false;
2039 }
2040
2041 bool bgq_thread::plat_setAllRegistersAsync(int_registerPool &pool,
2042                                            result_response::ptr resp)
2043 {
2044    SetGeneralRegsCmd set_gen;
2045    SetSpecialRegsCmd set_spec;
2046    bgq_process *bgproc = dynamic_cast<bgq_process *>(llproc());
2047
2048    pthrd_printf("setAllRegisters for %d/%d\n", llproc()->getPid(), getLWP());
2049
2050    set_gen.threadID = set_spec.threadID = getLWP();
2051    regPoolToBuffer(pool, set_gen.gpr, &set_spec.sregs);
2052
2053    resp->markAsMultiResponse(2);
2054    
2055    bool result = bgproc->sendCommand(set_gen, SetGeneralRegs, resp, 0);
2056    if (!result) {
2057       pthrd_printf("Error in sendCommand for SetGeneralRegs\n");
2058       return false;
2059    }
2060
2061    result = bgproc->sendCommand(set_spec, SetSpecialRegs, resp, 1);
2062    if (!result) {
2063       pthrd_printf("Error in sendCommand for SetSpecialRegs\n");
2064       return false;
2065    }
2066    return true;
2067 }
2068
2069 bool bgq_thread::plat_setRegisterAsync(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val,
2070                                        result_response::ptr resp)
2071 {
2072    GeneralRegSelect gen_reg;
2073    SpecialRegSelect spec_reg;
2074    bgq_process *bgproc = dynamic_cast<bgq_process *>(llproc());
2075
2076    if (genRegToSystem(reg, gen_reg)) {
2077       pthrd_printf("Doing set of GPR %d to %lx on %d/%d\n", (int) gen_reg, val, llproc()->getPid(), getLWP());
2078       SetGeneralRegCmd set_reg;
2079       set_reg.threadID = getLWP();
2080       set_reg.reg_select = gen_reg;
2081       set_reg.value = val;
2082       bool result = bgproc->sendCommand(set_reg, SetGeneralReg, resp);
2083       if (!result) {
2084          pthrd_printf("Error doing sendCommand with SetGeneralReg\n");
2085          return false;
2086       }
2087       return true;
2088    }
2089    else if (specRegToSystem(reg, spec_reg)) {
2090       pthrd_printf("Doing set of spec #%d to %lx on %d/%d\n", (int) gen_reg, val, llproc()->getPid(), getLWP());
2091       SetSpecialRegCmd set_reg;
2092       set_reg.threadID = getLWP();
2093       set_reg.reg_select = spec_reg;
2094       set_reg.value = val;
2095       bool result = bgproc->sendCommand(set_reg, SetSpecialReg, resp);
2096       if (!result) {
2097          pthrd_printf("Error doing sendCommand with SetGeneralReg\n");
2098          return false;
2099       }
2100       return true;
2101    }
2102
2103    setLastError(err_badparam, "Invalid register specified to setRegister");
2104    return false;
2105 }
2106
2107 bool bgq_thread::plat_convertToSystemRegs(const int_registerPool &pool, unsigned char *output_buffer, bool /*gpr_only*/)
2108 {
2109    bgq_thread::regPoolToUser(pool, output_buffer);
2110    return true;
2111 }
2112
2113 CallStackUnwinding *bgq_thread::getStackUnwinder()
2114 {
2115    if (!unwinder) {
2116       unwinder = new CallStackUnwinding(thread());
2117    }
2118    return unwinder;
2119 }
2120
2121 map<int, ComputeNode *> ComputeNode::id_to_cn;
2122 map<string, int> ComputeNode::socket_to_id;
2123 set<ComputeNode *> ComputeNode::all_compute_nodes;
2124
2125 ComputeNode *ComputeNode::getComputeNodeByID(int cn_id)
2126 {
2127    map<int, ComputeNode *>::iterator i = id_to_cn.find(cn_id);
2128    if (i != id_to_cn.end())
2129       return i->second;
2130
2131    pthrd_printf("Constructing new compute node for id: %d\n", cn_id);
2132    ComputeNode *new_cn = new ComputeNode(cn_id);
2133    if (!new_cn || new_cn->fd == -1) {
2134       perr_printf("Failed to create new ComputeNode object\n");
2135       if (new_cn) delete new_cn;
2136       return NULL;
2137    }
2138    id_to_cn[cn_id] = new_cn;
2139    return new_cn;
2140 }
2141
2142 bool ComputeNode::constructSocketToID()
2143 {
2144    char id_dir[64];
2145    char target_path[PATH_MAX];
2146    int dir_length;
2147
2148    if (!socket_to_id.empty())
2149       return true;
2150
2151    snprintf(id_dir, 64, "/jobs/%lu/toolctl_node", bgq_process::getJobID());
2152    
2153    pthrd_printf("Opening %s to parse links\n", id_dir);
2154    DIR *dir = opendir(id_dir);
2155    if (!dir) {
2156       int error = errno;
2157       perr_printf("Could not open directory %s: %s\n", id_dir, strerror(error));
2158       return false;
2159    }
2160
2161    dir_length = strlen(id_dir);
2162    id_dir[dir_length] = '/';
2163    dir_length++;
2164    id_dir[dir_length] = '\0';
2165
2166    for (struct dirent *dent = readdir(dir); dent; dent = readdir(dir)) {
2167       if (dent->d_name[0] == '.')
2168          continue;
2169       int node_id = atoi(dent->d_name);
2170       pthrd_printf("Parsing link %d\n", node_id);
2171
2172       strcpy(id_dir + dir_length, dent->d_name);
2173       char *target = realpath(id_dir, target_path);
2174       if (!target) {
2175          int error = errno;
2176          perr_printf("Could not resolve symbolic link for %s: %s\n", id_dir, strerror(error));
2177          closedir(dir);
2178          return false;
2179       }
2180       pthrd_printf("Real path of %d is %s\n", node_id, id_dir);
2181       
2182       string target_str(target);
2183       map<string, int>::iterator i = socket_to_id.find(target_str);
2184       if (i != socket_to_id.end()) {
2185          perr_printf("Compute nodes %d and %d share a socket %s\n", node_id, i->second, target_str.c_str());
2186          closedir(dir);
2187          return false;
2188       }
2189
2190       socket_to_id[target_str] = node_id;
2191    }
2192
2193    closedir(dir);
2194    return true;
2195 }
2196
2197 ComputeNode *ComputeNode::getComputeNodeByRank(uint32_t rank)
2198 {
2199    char rank_path[64];
2200    char target_path[PATH_MAX];
2201    snprintf(rank_path, 64, "/jobs/%lu/toolctl_rank/%u", bgq_process::getJobID(), rank);
2202
2203    char *target = realpath(rank_path, target_path);
2204    if (!target) {
2205       int error = errno;
2206       perr_printf("Error.  %s was not a symlink: %s\n", rank_path, strerror(error));
2207       return NULL;
2208    }
2209
2210    string target_str(target);
2211    if (!constructSocketToID()) {
2212       pthrd_printf("Error constructing socket/id mapping.\n");
2213       return NULL;
2214    }
2215
2216    map<string, int>::iterator i = socket_to_id.find(target_str);
2217    if (i == socket_to_id.end()) {
2218       perr_printf("Unable to find mapping for rank %d with socket %s\n", rank, target);
2219       return NULL;
2220    }
2221
2222    return getComputeNodeByID(i->second);
2223 }
2224
2225 ComputeNode::ComputeNode(int cid) :
2226    cn_id(cid),
2227    do_all_attach(bgq_process::do_all_attach),
2228    issued_all_attach(false),
2229    all_attach_done(false),
2230    all_attach_error(false),
2231    have_pending_message(false)
2232 {
2233    sockaddr_un saddr;
2234    int result;
2235    socklen_t socklen = sizeof(sockaddr_un);
2236    
2237    pthrd_printf("Constructing new ComputeNode %d\n", cid);
2238    fd = socket(PF_UNIX, SOCK_STREAM, 0);
2239    if (fd == -1) {
2240       int error = errno;
2241       perr_printf("Error creating socket for CN %d: %s\n", cid, strerror(error));
2242       return;
2243    }
2244
2245    bzero(&saddr, socklen);
2246    saddr.sun_family = AF_UNIX;
2247    snprintf(saddr.sun_path, sizeof(saddr.sun_path), "/jobs/%lu/toolctl_node/%d", bgq_process::getJobID(), cn_id);
2248    
2249    do {
2250       result = connect(fd, (struct sockaddr *) &saddr, socklen);
2251    } while (result == -1 && errno == EINTR);
2252    if (result == -1) {
2253       int error = errno;
2254       perr_printf("Error connecting to socket for CN %d: %s\n", cid, strerror(error));
2255       close(fd);
2256       fd = -1;
2257       return;
2258    }
2259
2260    all_compute_nodes.insert(this);
2261    ReaderThread::get()->addComputeNode(this);
2262    pthrd_printf("Successfully connected to CN %d on FD %d\n", cid, fd);
2263 }
2264
2265 ComputeNode::~ComputeNode()
2266 {
2267    ReaderThread::get()->rmComputeNode(this);
2268    if (fd != -1) {
2269       close(fd);
2270       fd = -1;
2271    }
2272    map<int, ComputeNode *>::iterator i = id_to_cn.find(cn_id);
2273    if (i != id_to_cn.end())
2274       id_to_cn.erase(i);
2275
2276    set<ComputeNode *>::iterator j = all_compute_nodes.find(this);
2277    assert(j != all_compute_nodes.end());
2278    all_compute_nodes.erase(j);
2279 }
2280
2281 int ComputeNode::getFD() const
2282 {
2283    return fd;
2284 }
2285
2286 int ComputeNode::getID() const
2287 {
2288    return cn_id;
2289 }
2290
2291 bool ComputeNode::reliableWrite(void *buffer, size_t buffer_size)
2292 {
2293    size_t bytes_written = 0;
2294    while (bytes_written < buffer_size) {
2295       int result = write(fd, ((char *) buffer) + bytes_written, buffer_size - bytes_written);
2296       if (result == -1 && errno == EINTR)
2297          continue;
2298       else if (result == -1 || result == 0) {
2299          int error = errno;
2300          perr_printf("Error writing to ComputeNode %d on FD %d: %s\n", cn_id, fd, strerror(error));
2301          return false;
2302       }
2303       bytes_written += result;
2304    }
2305    return true;
2306 }
2307
2308 bool ComputeNode::writeToolMessage(bgq_process *proc, ToolMessage *msg, bool heap_alloced)
2309 {
2310 #if defined(USE_THREADED_IO)
2311    printMessage(msg, "Writing");
2312    buffer_t newmsg;
2313    newmsg.size = msg->header.length;
2314    if (heap_alloced) {
2315       newmsg.buffer = msg;
2316    }
2317    else {
2318       newmsg.buffer = malloc(newmsg.size);
2319       memcpy(newmsg.buffer, msg, newmsg.size);
2320    }
2321    newmsg.is_heap_allocated = true;
2322
2323    WriterThread::get()->writeMessage(newmsg, proc->getComputeNode());
2324    return true;
2325 #else
2326    ScopeLock lock(send_lock);
2327
2328    if (have_pending_message) {
2329       pthrd_printf("Enqueuing message while another is pending\n");
2330       buffer_t newmsg;
2331       newmsg.size = msg->header.length;
2332       if (heap_alloced) {
2333          newmsg.buffer = msg;
2334       }
2335       else {
2336          newmsg.buffer = malloc(newmsg.size);
2337          memcpy(newmsg.buffer, msg, newmsg.size);
2338       }
2339       newmsg.is_heap_allocated = true;
2340       queued_pending_msgs.push(newmsg);
2341       return true;
2342    }
2343
2344    printMessage(msg, "Writing");
2345    bool result = reliableWrite(msg, msg->header.length);
2346    pthrd_printf("Wrote message of size %u to FD %d, result is %s\n", msg->header.length,
2347                 fd, result ? "true" : "false");
2348    if (heap_alloced) {
2349       free(msg);
2350    }
2351    if (!result) {
2352       pthrd_printf("Failed to write message to %d\n", proc->getPid());
2353       return false;
2354    }
2355
2356    have_pending_message = true;
2357    return true;
2358 #endif
2359 }
2360
2361 bool ComputeNode::flushNextMessage()
2362 {
2363    ScopeLock lock(send_lock);
2364    assert(have_pending_message);
2365
2366    if (queued_pending_msgs.empty()) {
2367       have_pending_message = false;
2368       return true;
2369    }
2370
2371    buffer_t buffer = queued_pending_msgs.front();
2372    queued_pending_msgs.pop();
2373    
2374    ToolMessage *msg = (ToolMessage *) buffer.buffer;
2375    printMessage(msg, "Writing");
2376    bool result = reliableWrite(msg, buffer.size);
2377    pthrd_printf("Flush wrote message of size %u to FD %d, result is %s\n", msg->header.length,
2378                 fd, result ? "true" : "false");
2379    free(buffer.buffer);
2380    if (!result) {
2381       pthrd_printf("Failed to flush message to compute-node %d\n", cn_id);
2382       have_pending_message = false;
2383       return false;
2384    }
2385    return true;
2386 }
2387
2388 bool ComputeNode::handleMessageAck()
2389 {
2390 #if !defined(USE_THREADED_IO)
2391    return flushNextMessage();
2392 #else
2393    return true;
2394 #endif
2395 }
2396
2397 bool ComputeNode::writeToolAttachMessage(bgq_process *proc, ToolMessage *msg, bool heap_alloced)
2398 {
2399 #if !defined(USE_THREADED_IO)
2400    if (all_attach_done || !do_all_attach) {
2401       return writeToolMessage(proc, msg, heap_alloced);
2402    }
2403
2404    ScopeLock lock(attach_lock);
2405
2406    if (!all_attach_done) {
2407       have_pending_message = true;
2408    }
2409    return writeToolMessage(proc, msg, heap_alloced);
2410 #else
2411    return writeToolMessage(proc, msg, heap_alloced);
2412 #endif
2413 }
2414
2415 void ComputeNode::removeNode(bgq_process *proc) {
2416    set<bgq_process *>::iterator i = procs.find(proc);
2417    if (i == procs.end())
2418       return;
2419
2420    procs.erase(i);
2421    issued_all_attach = false;
2422    all_attach_done = false;
2423    all_attach_error = false;
2424 }
2425
2426 const std::set<ComputeNode *> &ComputeNode::allNodes()
2427 {
2428    return all_compute_nodes;
2429 }
2430
2431 HandleBGQStartup::HandleBGQStartup() :
2432    Handler(std::string("BGQ Startup"))
2433 {
2434 }
2435
2436 HandleBGQStartup::~HandleBGQStartup()
2437 {
2438 }
2439
2440 Handler::handler_ret_t HandleBGQStartup::handleEvent(Event::ptr ev)
2441 {
2442    bgq_process *proc = dynamic_cast<bgq_process *>(ev->getProcess()->llproc());
2443    assert(proc);
2444    pthrd_printf("Handling int bootstrap for %d\n", proc->getPid());
2445    EventIntBootstrap::ptr int_bs = ev->getEventIntBootstrap();
2446    void *data = NULL;
2447    if (int_bs)
2448       data = int_bs->getData();
2449
2450    bool result = proc->handleStartupEvent(data);
2451    return result ? ret_success : ret_error;
2452 }
2453
2454 int HandleBGQStartup::getPriority() const
2455 {
2456    return Handler::PrePlatformPriority;
2457 }
2458
2459 void HandleBGQStartup::getEventTypesHandled(std::vector<EventType> &etypes)
2460 {
2461    etypes.push_back(EventType(EventType::None, EventType::IntBootstrap));
2462    etypes.push_back(EventType(EventType::None, EventType::Bootstrap));
2463 }
2464
2465 HandlePreControlAuthority::HandlePreControlAuthority() :
2466    Handler("BGQ Pre-ControlAuthority")
2467 {
2468 }
2469
2470 HandlePreControlAuthority::~HandlePreControlAuthority()
2471 {
2472 }
2473
2474 void HandlePreControlAuthority::getEventTypesHandled(vector<EventType> &etypes)
2475 {
2476    etypes.push_back(EventType(EventType::Pre, EventType::ControlAuthority));
2477 }
2478
2479 Handler::handler_ret_t HandlePreControlAuthority::handleEvent(Event::ptr ev)
2480 {
2481    EventControlAuthority::ptr ca = ev->getEventControlAuthority();
2482    int_eventControlAuthority *iev = ca->getInternalEvent();
2483    int_process *proc = ca->getProcess()->llproc();
2484    bgq_process *bgproc = dynamic_cast<bgq_process *>(proc);
2485
2486    pthrd_printf("Handling pre-controlauthority event on %d.  "
2487                 "Other tool is priority %d, name %s.  We are priority %d\n",
2488                 proc->getPid(), iev->priority, iev->toolname.c_str(), bgproc->priority);
2489
2490    if (iev->trigger == EventControlAuthority::ControlNoChange) {
2491       return ret_success;
2492    }
2493    bool gained = (iev->trigger == EventControlAuthority::ControlGained);
2494
2495    if (!iev->unset_desync) {
2496       ev->setSyncType(Event::sync_process);
2497       int_thread *thr = ca->getThread()->llthrd();
2498       thr->getControlAuthorityState().restoreStateProc();
2499       iev->unset_desync = true;
2500    }
2501    /**
2502     * If we've been allowed control authority, then submit the request
2503     **/
2504    if (gained && !iev->took_ca) {
2505       //Create a ControlMessage that requests control, and setup an async response object
2506       if (!iev->dresp) {
2507          pthrd_printf("Constructing ControlMessage in HandlePreControlAuthority handler\n");
2508          ControlMessage *ctrl_msg = (ControlMessage *) malloc(sizeof(ControlMessage));
2509          sigset_t sigs = bgproc->getSigMask();
2510          sigaddset(&sigs, SIGTRAP);
2511          sigaddset(&sigs, SIGSTOP);
2512          ctrl_msg->notifySignalSet(&sigs);
2513          ctrl_msg->sndSignal = SIGSTOP;
2514          ctrl_msg->dynamicNotifyMode = DynamicNotifyDLoader;
2515          ctrl_msg->dacTrapMode = DACTrap_NoChange;
2516          
2517          iev->dresp = data_response::createDataResponse();
2518          bgproc->fillInToolMessage(*ctrl_msg, Control, iev->dresp);
2519
2520          getResponses().lock();
2521          bool result = bgproc->getComputeNode()->writeToolMessage(bgproc, ctrl_msg, true);
2522          if (result) {
2523             getResponses().addResponse(iev->dresp, bgproc);
2524          }
2525          getResponses().unlock();
2526          getResponses().noteResponse();
2527          if (!result) {
2528             perr_printf("Failed to write tool message to CN for process %d\n", bgproc->getPid());
2529             return ret_error;
2530          }
2531       }
2532
2533       //Wait for async response to control request
2534       if (!iev->dresp->isReady()) {
2535          pthrd_printf("Postponing taking control authority as we wait for ControlAck on %d\n", bgproc->getPid());
2536          bgproc->handlerPool()->notifyOfPendingAsyncs(iev->dresp, ev);
2537          return ret_async;
2538       }
2539
2540       //Have the ControlAck response.  Handle.
2541       ControlAckMessage *msg = (ControlAckMessage *) iev->dresp->getData();
2542       
2543       if (msg->controllingToolId == bgproc->getToolID()) {
2544          //Will mark haveControlAuthority after we get the SIGSTOP
2545          pthrd_printf("Yeah.  ControlAckMessage gave us control of %d\n", bgproc->getPid());
2546          iev->took_ca = true;
2547          free(msg);
2548       }
2549       else {
2550          char toolTag_cstr[ToolTagSize+1];
2551          bzero(toolTag_cstr, ToolTagSize+1);
2552          memcpy(toolTag_cstr, msg->toolTag, ToolTagSize);
2553          iev->toolname = toolTag_cstr;
2554          iev->toolid = msg->controllingToolId;
2555          iev->priority = msg->priority;
2556          iev->trigger = EventControlAuthority::ControlNoChange;
2557          pthrd_printf("Someone else grabbed Control Authority of us on %d: name = %s, id = %u, priority = %u\n",
2558                       bgproc->getPid(), iev->toolname.c_str(), iev->toolid, iev->priority);
2559          free(msg);
2560          return ret_success;
2561       }
2562    }
2563
2564    if (gained && !iev->waiting_on_stop) {
2565       //We've got CA.  The system should still throw us a SIGSTOP now.
2566       //We'll decode that SIGSTOP into a new CA event with the same int_eventControlAuthority
2567       pthrd_printf("Returning from CA handler as we wait for the SIGSTOP\n");
2568       bgproc->stopwait_on_control_authority = iev;
2569       iev->dont_delete = true;
2570       iev->waiting_on_stop = true;
2571       ev->setSuppressCB(true);
2572       return ret_success;
2573    }
2574
2575    /**
2576     * Disable or Resume breakpoints, depending on whether we're releasing or
2577     * taking control authority.  
2578     **/
2579    const char *action_str = gained ? "resuming" : "suspending";
2580    set<response::ptr> &async_responses = iev->async_responses;
2581    if (!iev->handled_bps) {
2582       pthrd_printf("%s all breakpoints before control authority release\n", action_str);
2583       for (std::map<Dyninst::Address, sw_breakpoint *>::iterator i = proc->memory()->breakpoints.begin();
2584            i != proc->memory()->breakpoints.end(); i++)
2585       {
2586          sw_breakpoint *bp = i->second;
2587          bool result;
2588          if (gained) 
2589             result = bp->resume(proc, async_responses);
2590          else
2591             result = bp->suspend(proc, async_responses);
2592          if (!result) {
2593             perr_printf("Error %s breakpoint at %lx in %d\n", action_str, i->first, bgproc->getPid());
2594             ev->setLastError(err_internal, "Error handling breakpoints before control authority transfer\n");
2595             return ret_error;
2596          }
2597       }
2598       iev->handled_bps = true;
2599    }
2600
2601    pthrd_printf("Checking if breakpoint %s has completed for %d in control release handler\n",
2602                 action_str, proc->getPid());
2603    for (set<response::ptr>::iterator i = async_responses.begin(); i != async_responses.end(); i++) {
2604       if ((*i)->hasError()) {
2605          perr_printf("Error while %s breakpoint\n", action_str);
2606          ev->setLastError(err_internal, "Error handling breakpoints during control authority transfer\n");
2607          return ret_error;
2608       }
2609       if (!(*i)->isReady()) {
2610          pthrd_printf("Suspending control authority handler due to async in breakpoint %s.\n", action_str);
2611          proc->handlerPool()->notifyOfPendingAsyncs(async_responses, ev);
2612          return ret_async;
2613       }
2614    }
2615
2616    //TODO: When HW breakpoints are supported on BGQ, handle those too.
2617
2618    if (!gained) {
2619       //This will cause the post-controlauthority handler to run when the process is next continued.
2620       bgproc->pending_control_authority = ca;
2621    }
2622    else {
2623       pthrd_printf("Marking ourselves as having CA\n");
2624       bgproc->hasControlAuthority = true;
2625    }
2626
2627    return ret_success;
2628 }
2629
2630 HandlePostControlAuthority::HandlePostControlAuthority() :
2631    Handler("BGQ Post-ControlAuthority")
2632 {
2633 }
2634
2635 HandlePostControlAuthority::~HandlePostControlAuthority()
2636 {
2637 }
2638
2639 void HandlePostControlAuthority::getEventTypesHandled(vector<EventType> &etypes)
2640 {
2641    etypes.push_back(EventType(EventType::Post, EventType::ControlAuthority));
2642 }
2643
2644 Handler::handler_ret_t HandlePostControlAuthority::handleEvent(Event::ptr ev)
2645 {
2646    //This triggers when the user continues the process after we're notified
2647    // of a control change.  Just send the ReleaseControl message
2648    EventControlAuthority::ptr ca = ev->getEventControlAuthority();
2649    int_process *proc = ca->getProcess()->llproc();
2650    bgq_process *bgproc = dynamic_cast<bgq_process *>(proc);
2651    pthrd_printf("Handling PostControlAuthority for %d\n", proc->getPid());
2652
2653    int_thread *thr = ca->getThread()->llthrd();
2654    thr->getControlAuthorityState().restoreStateProc();
2655
2656    bgproc->hasControlAuthority = false;
2657    bgproc->pending_control_authority = EventControlAuthority::ptr();
2658
2659    pthrd_printf("Sending continue command to %d for control authority release\n", proc->getPid());
2660    SetContinuationSignalCmd cont_signal_cmd;
2661    cont_signal_cmd.threadID = 0;
2662    cont_signal_cmd.signum = 0;
2663    bool result = bgproc->sendCommand(cont_signal_cmd, SetContinuationSignal);
2664    if (!result) {
2665       pthrd_printf("Error sending continue command\n");
2666       return ret_error;
2667    }
2668
2669    for (int_threadPool::iterator i = bgproc->threadPool()->begin(); i != bgproc->threadPool()->end(); i++) {
2670       int_thread *thr = *i;
2671       if (thr->isSuspended()) {
2672          ReleaseThreadCmd release_thrd;
2673          release_thrd.threadID = thr->getLWP();
2674          bool result = bgproc->sendCommand(release_thrd, ReleaseThread);
2675          if (!result) {
2676             pthrd_printf("Error sending ReleaseThread command\n");
2677             return ret_error;
2678          }
2679       }
2680    }
2681
2682    ContinueProcessCmd cont_process;
2683    cont_process.threadID = 0;
2684    bgproc->sendCommand(cont_process, ContinueProcess);
2685
2686    pthrd_printf("Sending control authority release command to %d\n", proc->getPid());
2687    ReleaseControlCmd release;
2688    release.threadID = 0;
2689    release.notify = ReleaseControlNotify_Active;
2690    result = bgproc->sendCommand(release, ReleaseControl);
2691    if (!result) {
2692       perr_printf("Error sending release control command to %d\n", proc->getPid());
2693       return ret_error;
2694    }
2695
2696    for (int_threadPool::iterator i = proc->threadPool()->begin(); i != proc->threadPool()->end(); i++) {
2697       int_thread *thrd = *i;
2698       thrd->getUserState().setState(int_thread::running);
2699       thrd->getHandlerState().setState(int_thread::running);
2700       thrd->getGeneratorState().setState(int_thread::running);
2701    }
2702    ProcPool()->condvar()->lock();
2703    ProcPool()->condvar()->broadcast();
2704    ProcPool()->condvar()->unlock();
2705    return ret_success;
2706 }
2707
2708 const char *bgq_process::bgqErrorMessage(uint32_t rc, bool long_form)
2709 {
2710    if ((int) rc < 0) {
2711       //Likely got an error in errorCode rather then returnCode, treat as errno
2712       return strerror((int) rc);
2713    }
2714    //Error Descriptions are taken from comments in IBM's MessageHeader.h
2715 #undef STR_CASE
2716 #define STR_CASE(X, Y) case X: return long_form ? #X  ": " #Y : #X
2717    switch ((ReturnCode) rc) {
2718       STR_CASE(Success, "Success (no error).");
2719       STR_CASE(WrongService, "Service value in message header is not valid.");
2720       STR_CASE(UnsupportedType, "Type value in message header is not supported.");
2721       STR_CASE(JobIdError, "Job id value is not valid.");
2722       STR_CASE(ProcessIdError, "Rank value is not valid.");
2723       STR_CASE(RequestFailed, "Requested operation failed.   ");
2724       STR_CASE(SubBlockJobError, "Sub-block job specifications are not valid.  ");
2725       STR_CASE(SendError, "Sending a message failed.");
2726       STR_CASE(RecvError, "Receiving a message failed.");
2727       STR_CASE(VersionMismatch, "Protocol versions do not match.");
2728       STR_CASE(NodeNotReady, "Compute node is not ready for requested operation.");
2729       STR_CASE(SecondaryGroupIdError, "Setting secondary group id failed.");
2730       STR_CASE(PrimaryGroupIdError, "Setting primary group id failed.");
2731       STR_CASE(UserIdError, "Setting user id failed.");
2732       STR_CASE(WorkingDirError, "Changing to working directory failed.");
2733       STR_CASE(AppOpenError, "Opening application executable failed.");
2734       STR_CASE(AppAuthorityError, "No authority to application executable.");
2735       STR_CASE(AppReadError, "Reading data from application executable failed.");
2736       STR_CASE(AppElfHeaderSize, "Application executable ELF header is wrong size.");
2737       STR_CASE(AppElfHeaderError, "Application executable ELF header contains invalid value.");
2738       STR_CASE(AppNoCodeSection, "Application executable contains no code sections.");
2739       STR_CASE(AppCodeSectionSize, "Application executable code section is too big.");
2740       STR_CASE(AppSegmentAlignment, "Application executable segment has wrong alignment.");
2741       STR_CASE(AppTooManySegments, "Application executable has too many segments.");
2742       STR_CASE(AppStaticTLBError, "Generating static TLB map for application failed.");
2743       STR_CASE(AppMemoryError, "Initializing memory for process failed.");
2744       STR_CASE(ArgumentListSize, "Argument list has too many items.");
2745       STR_CASE(ToolStartError, "Starting tool process failed.");
2746       STR_CASE(ToolAuthorityError, "No authority to tool executable.");
2747       STR_CASE(ToolIdError, "Tool id is not valid.");
2748       STR_CASE(ToolTimeoutExpired, "Timeout expired ending a tool.");
2749       STR_CASE(ToolPriorityConflict, "Tool priority conflict.");
2750       STR_CASE(ToolMaxAttachedExceeded, "Tool maximum number of tools exceeded.");
2751       STR_CASE(ToolIdConflict, "Tool id conflict.");
2752       STR_CASE(JobsDirError, "Creating /jobs directory failed.");
2753       STR_CASE(JobsObjectError, "Creating object in /jobs directory failed.");
2754       STR_CASE(ToolPriorityError, "Tool priority level is not valid.");
2755       STR_CASE(ToolRankNotFound, "Tool request could not find requested target process.");
2756       STR_CASE(CornerCoreError, "Corner core number is not valid.");
2757       STR_CASE(NumCoresInProcessError, "Number of cores allocated to a process is not valid.");
2758       STR_CASE(ProcessActive, "Process is currently active on a hardware thread.");
2759       STR_CASE(NumProcessesError, "Number of processes on node is not valid.");
2760       STR_CASE(RanksInJobError, "Number of active ranks in job is not valid.");
2761       STR_CASE(ClassRouteDataError, "Class route data is not valid.");
2762       STR_CASE(ToolNumberOfCmdsExceeded, "Tool number of commands is not valid.");
2763       STR_CASE(RequestIncomplete, "Requested operation was partially successful.");
2764       STR_CASE(PrologPgmStartError, "Starting job prolog program process failed.");
2765       STR_CASE(PrologPgmError, "Job prolog program failed. ");
2766       STR_CASE(EpilogPgmStartError, "Starting job epilog program process failed.");
2767       STR_CASE(EpilogPgmError, "Job epilog program failed. ");
2768       STR_CASE(ReturnCodeReserved1, "Formerly request in progress.");
2769       STR_CASE(ToolControlConflict, "Control authority conflict with another tool.");
2770       STR_CASE(NodesInJobError, "No compute nodes matched job specifications.");
2771       STR_CASE(ToolConflictingCmds, "An invalid combination of commands was specifed in the command list.");
2772       STR_CASE(ToolControlRequired, "Tool control authority is required.");
2773       STR_CASE(ToolControlReleaseRequired, "Tool release of control authority is required.");
2774       STR_CASE(AppInvalidorMissingMapfile, "Map file is missing or contains invalid values.");
2775       STR_CASE(ToolProcessExiting, "Tool message not handled because target process is exiting.");
2776       STR_CASE(ReturnCodeListEnd, "End of the return code enumerations.");
2777    }
2778    return "Unknown Error Code";   
2779 }
2780
2781 GeneratorBGQ::GeneratorBGQ() :
2782    GeneratorMT(std::string("BGQ Generator"))
2783 {
2784    if (dyninst_debug_proccontrol) {
2785       pthrd_printf("Enabling debug thread\n");
2786       DebugThread::getDebugThread();
2787    }
2788    int result = pipe(kick_pipe);
2789    if (result == -1) {
2790       int error = errno;
2791       perr_printf("Error creating kick pipe: %s\n", strerror(error));
2792       globalSetLastError(err_internal, "Could not create internal file descriptors\n");
2793       kick_pipe[0] = kick_pipe[1] = -1;
2794    }
2795    decoders.insert(new DecoderBlueGeneQ());
2796 }
2797
2798 GeneratorBGQ::~GeneratorBGQ()
2799 {
2800    kick();
2801 }
2802
2803 bool GeneratorBGQ::initialize()
2804 {
2805    if (kick_pipe[0] == -1 || kick_pipe[1] == -1) {
2806       pthrd_printf("Failed to initialize kick pipe ealier\n");
2807       return false;
2808    }
2809    return true;
2810 }
2811
2812 bool GeneratorBGQ::canFastHandle()
2813 {
2814    return false;
2815 }
2816
2817 ArchEvent *GeneratorBGQ::getEvent(bool)
2818 {
2819    assert(0); //BGQ uses multi-event interface
2820    return NULL;
2821 }
2822
2823 bool GeneratorBGQ::getMultiEvent(bool block, vector<ArchEvent *> &events)
2824 {
2825 #if defined(USE_THREADED_IO)
2826    return readMessage(events, block);
2827 #else
2828    bool have_fd = false;
2829    int max_fd = kick_pipe[0];
2830
2831    fd_set read_set;
2832    FD_ZERO(&read_set);
2833    
2834    const set<ComputeNode *> &nodes = ComputeNode::allNodes();
2835    std::string fd_list_str;
2836    for (set<ComputeNode *>::const_iterator i = nodes.begin(); i != nodes.end(); i++) {
2837       int fd = (*i)->getFD();
2838       if (fd > max_fd)
2839          max_fd = fd;
2840       FD_SET(fd, &read_set);
2841       have_fd  = true;
2842       if (dyninst_debug_proccontrol) {
2843          char buffer[32];
2844          if (!fd_list_str.empty())
2845             fd_list_str += ", ";
2846          snprintf(buffer, 32, "%d", fd);
2847          fd_list_str += buffer;
2848       }
2849    }
2850    assert(have_fd);
2851    FD_SET(kick_pipe[0], &read_set);
2852
2853    struct timeval timeout;
2854    timeout.tv_sec = 0;
2855    timeout.tv_usec = 0;
2856    struct timeval *timeoutp = block ? NULL : &timeout;
2857
2858    pthrd_printf("BGQ Generator is blocking on file descriptors: %s\n", fd_list_str.c_str());
2859    int result;
2860    do {
2861       result = select(max_fd+1, &read_set, NULL, NULL, timeoutp);
2862    } while (result == -1 && errno == EINTR);
2863
2864    if (result == 0) {
2865       if (!block) {
2866          pthrd_printf("Return with no events after polling BGQ pipes\n");
2867          return true;
2868       }
2869       perr_printf("Error. Blocking select returned early with no FDs.\n");
2870       return false;
2871    }
2872    if (result == -1) {
2873       int error = errno;
2874       perr_printf("Select returned unexpected error: %s", strerror(error));
2875       return false;
2876    }
2877
2878    if (FD_ISSET(kick_pipe[0], &read_set)) {
2879       int i;
2880       result = read(kick_pipe[0], &i, sizeof(int));
2881       if (result != -1) {
2882          assert(i == kick_val);
2883       }
2884       return false;
2885    }
2886
2887    for (set<ComputeNode *>::const_iterator i = nodes.begin(); i != nodes.end(); i++) {
2888       int fd = (*i)->getFD();
2889       if (!FD_ISSET(fd, &read_set)) {
2890          continue;
2891       }
2892       
2893       bool bresult = readMessage(fd, events);
2894       if (!bresult) {
2895          perr_printf("Could not read messages from ComputeNode %d\n", (*i)->getID());
2896          continue;
2897       }
2898    }
2899
2900    return true;
2901 #endif
2902 }
2903
2904 bool GeneratorBGQ::reliableRead(int fd, void *buffer, size_t buffer_size, int timeout_s)
2905 {
2906    size_t bytes_read = 0;
2907    while (bytes_read < buffer_size) {
2908       if (timeout_s > 0) {
2909          fd_set readfds;
2910          struct timeval timeout;
2911          FD_ZERO(&readfds);
2912          FD_SET(fd, &readfds);
2913          int nfds = fd+1;
2914          timeout.tv_sec = timeout_s;
2915          timeout.tv_usec = 0;
2916          int result = select(nfds, &readfds, NULL, NULL, &timeout);
2917          if (result == 0) {
2918             pthrd_printf("Timed out in reliableRead\n");
2919             return false;
2920          }
2921       }
2922
2923       int result = read(fd, ((char *) buffer) + bytes_read, buffer_size - bytes_read);
2924
2925       if (result == -1 && errno == EINTR) {
2926          continue;
2927       }
2928       else if (result == -1) {
2929          int error = errno;
2930          perr_printf("Failed to read from FD %d: %s\n", fd, strerror(error));
2931          globalSetLastError(err_internal, "Failed to read from CDTI file descriptor");
2932          return false;
2933       }
2934       else if (result == 0) {
2935          pthrd_printf("EOF on FD %d\n", fd);
2936          return false;
2937       }
2938       else {
2939          bytes_read += result;
2940       }
2941    }
2942    return true;
2943 }
2944
2945 bool GeneratorBGQ::readMessage(vector<ArchEvent *> &events, bool block)
2946 {
2947    for (;;) {
2948       buffer_t buf = ReaderThread::get()->readNextElement(block);
2949       if (buf.buffer == NULL && block) {
2950          pthrd_printf("Failed to read from ReaderThread\n");
2951          return false;
2952       }
2953       if (buf.buffer == NULL) {
2954          return true;
2955       }
2956       ToolMessage *tm = (ToolMessage *) buf.buffer;
2957       printMessage(tm, "Read");
2958       ArchEventBGQ *newArchEvent = new ArchEventBGQ(tm);
2959       assert(newArchEvent);
2960       events.push_back(newArchEvent);
2961       block = false;
2962    }
2963 }
2964
2965 bool GeneratorBGQ::readMessage(int fd, vector<ArchEvent *> &events)
2966 {
2967    int msgs_read = 0;
2968
2969    for (;;) {
2970       //Read a message from the fd
2971       MessageHeader hdr;
2972       bool result = reliableRead(fd, &hdr, sizeof(MessageHeader));
2973       if (!result) {
2974          pthrd_printf("Could not read header from file descriptor\n");
2975          return false;
2976       }
2977
2978       assert(hdr.length <= SmallMessageDataSize);
2979       char *message = (char *) malloc(hdr.length);
2980       memcpy(message, &hdr, sizeof(MessageHeader));
2981
2982       result = reliableRead(fd, message + sizeof(MessageHeader), hdr.length - sizeof(MessageHeader));
2983       if (result == -1) {
2984          pthrd_printf("Could not read message from file descriptor\n");
2985          return false;
2986       }
2987       msgs_read++;
2988
2989       printMessage((ToolMessage *) message, "Read");
2990       //Create and save a new ArchEvent from this message
2991       ArchEventBGQ *newArchEvent = new ArchEventBGQ((ToolMessage *) message);
2992       assert(newArchEvent);
2993       events.push_back(newArchEvent);
2994
2995       if (!read_multiple_msgs) {
2996          break;
2997       }
2998
2999       //Poll to see if there are any more messages
3000       fd_set read_set;
3001       FD_ZERO(&read_set);
3002       FD_SET(fd, &read_set);
3003       struct timeval timeout;
3004       timeout.tv_sec = 0;
3005       timeout.tv_usec = 0;
3006
3007       int iresult = select(fd+1, &read_set, NULL, NULL, &timeout);
3008       if (iresult == -1) {
3009          int error = errno;
3010          perr_printf("Non-fatal error polling FD %d for new messages: %s\n", fd, strerror(error));
3011          break;
3012       }
3013       if (iresult == 0) {
3014          //No more messages are available
3015          break;
3016       }
3017    }
3018    
3019    pthrd_printf("Read %d messages from fd %d\n", msgs_read, fd);
3020    return (msgs_read > 0);
3021 }
3022
3023 bool GeneratorBGQ::plat_skipGeneratorBlock()
3024 {
3025    bool result = getResponses().hasAsyncPending(false);
3026    if (result) {
3027       pthrd_printf("Async events pending, skipping generator block\n");
3028    }
3029    return result;
3030 }
3031
3032 void GeneratorBGQ::kick()
3033 {
3034    int result;
3035    int kval = kick_val;
3036    do {
3037       result = write(kick_pipe[1], &kval, sizeof(int));
3038    } while (result == -1 && errno == EINTR);
3039 }
3040
3041 extern void GeneratorInternalJoin(GeneratorMTInternals *);
3042 void GeneratorBGQ::shutdown()
3043 {
3044    setState(Generator::exiting);
3045    kick();
3046
3047    bool result = ProcPool()->condvar()->trylock();
3048    if (result) {
3049       ProcPool()->condvar()->signal();
3050       ProcPool()->condvar()->unlock();
3051    } 
3052    sleep(1);
3053 }
3054
3055 static GeneratorBGQ *gen = NULL;
3056 Generator *Generator::getDefaultGenerator()
3057 {
3058    if (!gen) {
3059       gen = new GeneratorBGQ();
3060       assert(gen);
3061       gen->launch();
3062    }
3063    return static_cast<Generator *>(gen);
3064 }
3065
3066 ArchEventBGQ::ArchEventBGQ(ToolMessage *m) :
3067    msg(m),
3068    free_msg(true)
3069 {
3070 }
3071
3072 ArchEventBGQ::~ArchEventBGQ()
3073 {
3074    if (msg && free_msg) {
3075       free(msg);
3076    }
3077    msg = NULL;
3078 }
3079
3080 ToolMessage *ArchEventBGQ::getMsg() const
3081 {
3082    return msg;
3083 }
3084
3085 void ArchEventBGQ::dontFreeMsg()
3086 {
3087    free_msg = false;
3088 }
3089
3090 DecoderBlueGeneQ::DecoderBlueGeneQ()
3091 {
3092 }
3093
3094 DecoderBlueGeneQ::~DecoderBlueGeneQ()
3095 {
3096 }
3097
3098 unsigned DecoderBlueGeneQ::getPriority() const 
3099 {
3100    return Decoder::default_priority;
3101 }
3102
3103 Event::ptr DecoderBlueGeneQ::decodeCompletedResponse(response::ptr resp, int_process *proc, int_thread *thrd,
3104                                                      map<Event::ptr, EventAsync::ptr> &async_evs)
3105 {
3106    if (resp->isMultiResponse() && !resp->isMultiResponseComplete())
3107       return Event::ptr();
3108
3109    Event::ptr ev = resp->getEvent();
3110    if (!ev) {
3111       pthrd_printf("Marking response %s/%d ready\n", resp->name().c_str(), resp->getID());
3112       resp->markReady();
3113
3114       int_eventAsyncIO *ioev = resp->getAsyncIOEvent();
3115       if (!ioev) {
3116          return Event::ptr();
3117       }
3118
3119       pthrd_printf("Decoded to User-level AsyncIO event.  Creating associated Event with ioev %p\n", ioev);
3120       EventAsyncIO::ptr newev;
3121       switch (ioev->iot) {
3122          case int_eventAsyncIO::memread:
3123             newev = EventAsyncRead::ptr(new EventAsyncRead(ioev));
3124             break;
3125          case int_eventAsyncIO::memwrite:
3126             newev = EventAsyncWrite::ptr(new EventAsyncWrite(ioev));
3127             break;
3128          case int_eventAsyncIO::regallread:
3129             newev = EventAsyncReadAllRegs::ptr(new EventAsyncReadAllRegs(ioev));
3130             break;
3131          case int_eventAsyncIO::regallwrite:
3132             newev = EventAsyncSetAllRegs::ptr(new EventAsyncSetAllRegs(ioev));
3133             break;
3134       }
3135       assert(newev);
3136       newev->setSyncType(Event::async);
3137       newev->setProcess(proc->proc());
3138       newev->setThread(thrd ? thrd->thread() : Thread::ptr());
3139       return newev;
3140    }
3141
3142    pthrd_printf("Creating new EventAsync over %s for response %s/%d\n",
3143                 ev->name().c_str(), resp->name().c_str(), resp->getID());
3144
3145    EventAsync::ptr async_ev;
3146    map<Event::ptr, EventAsync::ptr>::iterator i = async_evs.find(ev);
3147    if (i == async_evs.end()) {
3148       //Create a new EventAsync for this event.
3149       int_eventAsync *internal = new int_eventAsync(resp);
3150       async_ev = EventAsync::ptr(new EventAsync(internal));
3151       async_ev->setProcess(ev->getProcess());
3152       async_ev->setThread(ev->getThread());
3153       async_ev->setSyncType(Event::async);
3154       async_ev->addSubservientEvent(ev);
3155       async_evs[ev] = async_ev;
3156       return async_ev;
3157    }
3158    else {
3159       //Optimization - this event already has an EventAsync.  Just add it to the existing one.
3160       async_ev = i->second;
3161       int_eventAsync *internal = async_ev->getInternal();
3162       internal->addResp(resp);
3163       return Event::ptr();
3164    }
3165 }
3166
3167 bool DecoderBlueGeneQ::decodeStartupEvent(ArchEventBGQ *ae, bgq_process *proc, void *data,
3168                                           Event::SyncType stype, vector<Event::ptr> &events)
3169 {
3170    Event::ptr new_ev = EventIntBootstrap::ptr(new EventIntBootstrap(data));
3171    new_ev->setProcess(proc->proc());
3172    new_ev->setThread(Thread::ptr());
3173    new_ev->setSyncType(stype);
3174    ae->dontFreeMsg();
3175    events.push_back(new_ev);
3176    return true;
3177 }
3178
3179 bool DecoderBlueGeneQ::decodeLWPRefresh(ArchEventBGQ *, bgq_process *proc, ToolCommand *cmd, 
3180                                         vector<Event::ptr> &)
3181 {
3182    proc->lwp_tracking_resp = result_response::ptr();
3183    if (!proc->get_thread_list)
3184       proc->get_thread_list = new GetThreadListAckCmd();
3185    *proc->get_thread_list = *((GetThreadListAckCmd *) cmd);
3186    return true;
3187 }
3188
3189 bool DecoderBlueGeneQ::decodeFileContents(ArchEventBGQ *ev, bgq_process *proc, ToolCommand *cmd, 
3190                                           int rc, unsigned int resp_id, bool owns_msg,
3191                                           std::vector<Event::ptr> &events)
3192 {
3193    bool is_complete;
3194    Resp_ptr r = proc->recvResp(resp_id, is_complete);
3195    assert(r && is_complete);
3196    
3197    FileReadResp_t *resp = static_cast<FileReadResp_t *>(r);
3198    int_eventAsyncFileRead *iev = resp->get();
3199    iev->resp = resp;
3200
3201    GetFileContentsAckCmd *file_cmd_ack = static_cast<GetFileContentsAckCmd *>(cmd);
3202    iev->data = file_cmd_ack->data;
3203    iev->size = file_cmd_ack->numbytes;
3204
3205    if (owns_msg) {
3206       ev->dontFreeMsg();
3207       iev->to_free = ev->getMsg();
3208    }
3209
3210 #warning Fill in iev->errorcode with rc
3211
3212    EventAsyncFileRead::ptr newev = EventAsyncFileRead::ptr(new EventAsyncFileRead(iev));
3213    newev->setProcess(proc->proc());
3214    newev->setThread(proc->threadPool()->initialThread()->thread());
3215    newev->setSyncType(Event::async);
3216    events.push_back(newev);
3217
3218    resp->done();
3219
3220    return true;
3221 }
3222
3223 bool DecoderBlueGeneQ::decodeGetFilenames(ArchEventBGQ *, bgq_process *proc, ToolCommand *cmd, int rc, int id)
3224 {
3225    bool is_complete;
3226    Resp_ptr r = proc->recvResp(id, is_complete);
3227    assert(r && is_complete);
3228    FileSetResp_t *fset_resp = static_cast<FileSetResp_t *>(r);
3229    FileSet *fset = fset_resp->get();
3230    
3231    GetFilenamesAckCmd *filelist = static_cast<GetFilenamesAckCmd *>(cmd);
3232    Process::ptr ui_proc = proc->proc();
3233
3234 #warning TODO: Set errors based on rc
3235    
3236    for (uint32_t i = 0; i < filelist->numFiles; i++) {
3237       fset->insert(make_pair(ui_proc, FileInfo(string(filelist->pathname[i]))));
3238    }
3239
3240    fset_resp->done();
3241    return true;
3242 }
3243
3244 bool DecoderBlueGeneQ::decodeFileStat(ToolCommand *cmd, bgq_process *proc, unsigned int resp_id, int rc)
3245 {
3246    bool is_complete;
3247    Resp_ptr r = proc->recvResp(resp_id, is_complete);
3248    assert(r && is_complete);
3249    StatResp_t *resp = static_cast<StatResp_t *>(r);
3250    GetFileStatDataAckCmd *statack = static_cast<GetFileStatDataAckCmd *>(cmd);
3251       
3252    stat64_ptr *statp = resp->get();
3253    if (rc != 0) {
3254       *statp = stat64_ptr();
3255 #warning TODO: Set errors based on rc
3256    }
3257    else {
3258       *statp = stat64_ptr(new stat64_ret_t);
3259       memcpy(statp->get(), &statack->stat, sizeof(stat64_ret_t));
3260    }
3261
3262    resp->done();
3263
3264    return true;
3265 }
3266
3267 Event::ptr DecoderBlueGeneQ::createEventDetach(bgq_process *proc, bool err)
3268 {
3269    EventDetach::ptr new_ev = EventDetach::ptr(new EventDetach());
3270    new_ev->setProcess(proc->proc());
3271    new_ev->setThread(Thread::ptr());
3272    new_ev->setSyncType(Event::async);
3273    new_ev->getInternal()->temporary_detach = proc->is_doing_temp_detach;
3274    new_ev->getInternal()->removed_bps = true;
3275    new_ev->getInternal()->done = false;
3276    new_ev->getInternal()->had_error = err;
3277    return new_ev;
3278 }
3279
3280 bool DecoderBlueGeneQ::decodeControlAck(ArchEventBGQ *ev, bgq_process *proc, vector<Event::ptr> &events)
3281 {
3282    if (proc->startup_state == bgq_process::waitfor_control_request_ack) {
3283       //Control ACKs during startup are handled by the start-up handler.
3284       pthrd_printf("Decoded ControlAck to startup event\n");
3285       return decodeStartupEvent(ev, proc, ev->getMsg(), Event::async, events);
3286    }
3287
3288    pthrd_printf("Decoding ControlACK message response for %d\n", proc->getPid());
3289    ControlAckMessage *msg = static_cast<ControlAckMessage *>(ev->getMsg());
3290    ev->dontFreeMsg();
3291
3292    // These ControlAck message always come in a response set of size 1, since they
3293    // don't pair with other messages.
3294    uint32_t seq_id = msg->header.sequenceId;
3295    ResponseSet *resp_set = ResponseSet::getResponseSetByID(seq_id);
3296    assert(resp_set);
3297    
3298    map<Event::ptr, EventAsync::ptr> async_ev_map;
3299    getResponses().lock();
3300    bool found = false;
3301    unsigned int id = resp_set->getIDByIndex(0, found);
3302    assert(found);
3303    response::ptr resp = getResponses().rmResponse(id);
3304    data_response::ptr dresp = resp->getDataResponse();
3305    dresp->postResponse((void *) msg);
3306    Event::ptr new_ev = decodeCompletedResponse(dresp, proc, NULL, async_ev_map);
3307    assert(new_ev);
3308    events.push_back(new_ev);
3309    getResponses().signal();
3310    getResponses().unlock();
3311
3312    delete resp_set;
3313
3314    return true;
3315 }
3316
3317 bool DecoderBlueGeneQ::decodeReleaseControlAck(ArchEventBGQ *, bgq_process *proc, 
3318                                                int err_code, std::vector<Event::ptr> &events)
3319 {
3320    if (proc->detach_state == bgq_process::control_release_sent) {
3321       pthrd_printf("This ControlReleaseAck is part of a detach\n");
3322       Event::ptr new_ev = createEventDetach(proc, err_code != 0);
3323       events.push_back(new_ev);
3324       return true;
3325    }
3326    
3327    return false;
3328 }
3329
3330 bool DecoderBlueGeneQ::decodeUpdateOrQueryAck(ArchEventBGQ *archevent, bgq_process *proc,
3331                                               int num_commands, CommandDescriptor *cmd_list, 
3332                                               vector<Event::ptr> &events)
3333 {
3334    map<Event::ptr, EventAsync::ptr> async_ev_map;
3335    ToolMessage *msg = archevent->getMsg();
3336    uint32_t seq_id = msg->header.sequenceId;
3337    bool resp_lock_held = false;
3338    bool owns_message = true;
3339
3340    ResponseSet *resp_set = NULL;
3341    if (seq_id) {
3342       resp_set = ResponseSet::getResponseSetByID(seq_id);
3343       if (resp_set)
3344          pthrd_printf("Associated ACK with response set %d\n", seq_id);
3345    }
3346
3347    for (int i=0; i<num_commands; i++) 
3348    {
3349       CommandDescriptor *desc = cmd_list+i;
3350       ToolCommand *base_cmd = (ToolCommand *) (((char *) msg) + desc->offset);
3351
3352       BG_ThreadID_t threadID = base_cmd->threadID;
3353       int_thread *thr = proc->threadPool()->findThreadByLWP(threadID);
3354
3355       response::ptr cur_resp = response::ptr();
3356       unsigned int id = 0;
3357       if (resp_set) {
3358          if (!usesResp(desc->type)) {
3359             getResponses().lock();
3360             resp_lock_held = true;
3361             bool found = false;
3362             id = resp_set->getIDByIndex(i, found);
3363             if (found) {
3364                pthrd_printf("Old resp, associated ACK %u and index %u with internal id %u\n", seq_id, i, id);
3365                cur_resp = getResponses().rmResponse(id);
3366             }
3367             if (!cur_resp) {
3368                resp_lock_held = false;
3369                getResponses().unlock();
3370             }
3371          }
3372          else
3373          {
3374             bool found = false;
3375             id = resp_set->getIDByIndex(i, found);
3376             if (found) {
3377                pthrd_printf("New resp, associated ACK %u and index %u with internal id %u\n", seq_id, i, id);
3378             }
3379          }
3380       }
3381   
3382       switch (desc->type) {
3383          case GetSpecialRegsAck: 
3384          case GetGeneralRegsAck: {
3385             allreg_response::ptr allreg = cur_resp->getAllRegResponse();
3386             assert(allreg);
3387             int_registerPool *regpool = allreg->getRegPool();
3388             assert(allreg);
3389             assert(regpool);
3390             if (desc->type == GetSpecialRegsAck) {
3391                pthrd_printf("Decoding GetSpecialRegsAck on %d/%d\n", 
3392                             proc->getPid(), thr->getLWP());
3393                GetSpecialRegsAckCmd *cmd = static_cast<GetSpecialRegsAckCmd *>(base_cmd);
3394                bgq_thread::regBufferToPool(NULL, &cmd->sregs, *regpool);
3395             }
3396             else {
3397                pthrd_printf("Decoding GetGeneralRegsAck on %d/%d\n", 
3398                             proc->getPid(), thr->getLWP());
3399                GetGeneralRegsAckCmd *cmd = static_cast<GetGeneralRegsAckCmd *>(base_cmd);
3400                bgq_thread::regBufferToPool(cmd->gpr, NULL, *regpool);
3401             }
3402             allreg->postResponse();
3403             if (desc->returnCode)
3404                allreg->markError(desc->returnCode);
3405             
3406             Event::ptr new_ev = decodeCompletedResponse(allreg, proc, thr, async_ev_map);
3407             if (new_ev)
3408                events.push_back(new_ev);
3409
3410             //BG/Q doesn't have an individual register access mechanism.
3411             // Thus we turn requests for one register into requests for all registers.
3412             // Here we check if this request is in response to a single register query
3413             // and fill out the reg_response if so.
3414             reg_response::ptr indiv_reg = allreg->getIndividualAcc();
3415             if (indiv_reg && !indiv_reg->isReady()) {
3416                if (allreg->hasError()) {
3417                   allreg->markError(desc->returnCode);
3418                }
3419                else {
3420                   MachRegister reg = allreg->getIndividualReg();
3421                   int_registerPool::reg_map_t::iterator i = regpool->regs.find(reg);
3422                   if (i != regpool->regs.end()) {
3423                      indiv_reg->postResponse(i->second);
3424                      new_ev = decodeCompletedResponse(indiv_reg, proc, thr, async_ev_map);
3425                      if (new_ev)
3426                         events.push_back(new_ev);
3427                   }
3428                }
3429             }
3430
3431             resp_lock_held = false;
3432             getResponses().signal();
3433             getResponses().unlock();
3434             break;
3435          }
3436          case GetFloatRegsAck:
3437          case GetDebugRegsAck:
3438             assert(0); //Currently unused, but eventually needed
3439             break;
3440          case GetMemoryAck: {
3441             mem_response::ptr memresp = cur_resp->getMemResponse();
3442             GetMemoryAckCmd *cmd = static_cast<GetMemoryAckCmd *>(base_cmd);
3443             assert(memresp);
3444             assert(cmd);
3445             pthrd_printf("Decoding GetMemoryAck of length %u on %d. Contents: %u %u %u %u...\n",
3446                          cmd->length, proc->getPid(),
3447                          cmd->length > 0 ? (unsigned int) cmd->data[0] : 0, 
3448                          cmd->length > 1 ? (unsigned int) cmd->data[1] : 0, 
3449                          cmd->length > 2 ? (unsigned int) cmd->data[2] : 0, 
3450                          cmd->length > 3 ? (unsigned int) cmd->data[3] : 0);
3451             memresp->postResponse((char *) cmd->data, cmd->length, cmd->addr);
3452             if (desc->returnCode)
3453                memresp->markError(desc->returnCode);
3454
3455             Event::ptr new_ev = decodeCompletedResponse(memresp, proc, thr, async_ev_map);
3456             if (new_ev)
3457                events.push_back(new_ev);
3458
3459             resp_lock_held = false;
3460             getResponses().signal();
3461             getResponses().unlock();
3462             break;
3463          }
3464          case GetThreadDataAck: {
3465             pthrd_printf("Decoded new event on %d to GetThreadDataAck message\n", proc->getPid());
3466             if (proc->startup_state < bgq_process::startup_done) {
3467                pthrd_printf("GetThreadDataAck is startup event\n");
3468                break;
3469             }
3470             stack_response::ptr stkresp = cur_resp->getStackResponse();
3471             GetThreadDataAckCmd *cmd = static_cast<GetThreadDataAckCmd *>(base_cmd);
3472             assert(stkresp);
3473             assert(cmd);
3474             archevent->dontFreeMsg();
3475             bgq_process::held_msgs.insert(msg);
3476             stkresp->postResponse((void *) cmd);
3477             if (desc->returnCode) 
3478                stkresp->markError(desc->returnCode);
3479             
3480             Event::ptr new_ev = decodeCompletedResponse(stkresp, proc, thr, async_ev_map);
3481             if (new_ev)
3482                events.push_back(new_ev);
3483             
3484             resp_lock_held = false;
3485             getResponses().signal();
3486             getResponses().unlock();
3487             break;
3488          }
3489          case GetThreadListAck:
3490             if (proc->lwp_tracking_resp) {
3491                pthrd_printf("Decoded GetThreadList as LWP refresh on %d\n", proc->getPid());
3492                decodeLWPRefresh(archevent, proc, base_cmd, events);
3493                result_response::ptr result_resp = cur_resp->getResultResponse();
3494                result_resp->postResponse(true);
3495                Event::ptr new_ev = decodeCompletedResponse(result_resp, proc, thr, async_ev_map);
3496                if (new_ev)
3497                   events.push_back(new_ev);
3498                resp_lock_held = false;
3499                getResponses().signal();
3500                getResponses().unlock();
3501                break;
3502             }
3503             else if (proc->startup_state == bgq_process::reissue_data_collection) {
3504                pthrd_printf("Decoded to lwp refresh during startup on %d\n", proc->getPid());
3505                return decodeStartupEvent(archevent, proc, archevent->getMsg(), Event::async, events);
3506             }
3507             else {
3508                pthrd_printf("Decoded GetThreadListAck on %d/%d. Dropping\n",
3509                             proc ? proc->getPid() : -1, thr ? thr->getLWP() : -1);
3510             }
3511             break;
3512          case GetAuxVectorsAck:
3513             pthrd_printf("Decoded GetAuxVectorsAck on %d/%d. Dropping\n", 
3514                          proc ? proc->getPid() : -1, thr ? thr->getLWP() : -1);
3515             break;
3516          case GetProcessDataAck:
3517             pthrd_printf("Decoded new event on %d to GetProcessData message\n", proc->getPid());
3518             decodeStartupEvent(archevent, proc, msg, Event::async, events);
3519             break;
3520          case GetFilenamesAck:
3521             pthrd_printf("Decoded event on %d to GetFilenamesAck\n", proc->getPid());
3522             decodeGetFilenames(archevent, proc, base_cmd, desc->returnCode, id);
3523          case GetPreferencesAck:
3524             assert(0); //Currently unused
3525             break;
3526          case GetFileStatDataAck:
3527             pthrd_printf("Decoded new event on %d to GetFileStatDataAck message\n", proc->getPid());
3528             decodeFileStat(base_cmd, proc, id, desc->returnCode);
3529             break;
3530          case GetFileContentsAck:
3531             pthrd_printf("Decoding GetFileContentsAck on %d\n", proc->getPid());
3532             decodeFileContents(archevent, proc, base_cmd, desc->returnCode, id, owns_message, events);
3533             owns_message = false;
3534             break;
3535          case SetBreakpointAck:
3536             pthrd_printf("Decoding SetBreakpointAck on %d\n", proc->getPid());
3537             goto HandleResResponse;
3538          case ResetBreakpointAck:
3539             pthrd_printf("Decoding ResetBreakpointAck on %d\n", proc->getPid());
3540             goto HandleResResponse;
3541          case SetGeneralRegAck:
3542             pthrd_printf("Decoding SetGeneralRegAck on %d/%d\n", proc->getPid(), thr->getLWP());
3543             goto HandleResResponse;
3544          case SetGeneralRegsAck:
3545             pthrd_printf("Decoding SetGeneralRegsAck on %d/%d\n", proc->getPid(), thr->getLWP());
3546             goto HandleResResponse;
3547          case SetSpecialRegAck:
3548             pthrd_printf("Decoding SetSpecialRegAck on %d/%d\n", proc->getPid(), thr->getLWP());
3549             goto HandleResResponse;
3550          case SetSpecialRegsAck:
3551             pthrd_printf("Decoding SetSpecialRegsAck on %d/%d\n", proc->getPid(), thr->getLWP());
3552             goto HandleResResponse;
3553          case SetMemoryAck: 
3554             pthrd_printf("Decoding SetMemoryAck on %d\n", proc->getPid());
3555          HandleResResponse: {                  
3556                result_response::ptr result_resp = cur_resp->getResultResponse();
3557                assert(result_resp);
3558                bool has_error = (desc->returnCode != 0);
3559                if (has_error) 
3560                   result_resp->markError(desc->returnCode);
3561                result_resp->postResponse(!has_error);
3562                Event::ptr new_ev = decodeCompletedResponse(result_resp, proc, thr, async_ev_map);
3563                if (new_ev)
3564                   events.push_back(new_ev);
3565
3566                resp_lock_held = false;
3567                getResponses().signal();
3568                getResponses().unlock();
3569                break;
3570             }
3571          case SetFloatRegAck:
3572          case SetDebugRegAck:
3573             assert(0); //Currently unused
3574             break;
3575          case HoldThreadAck:
3576             pthrd_printf("Decoded HoldThreadAck on %d/%d. Dropping\n", proc->getPid(), thr->getLWP());
3577             break;
3578          case ReleaseThreadAck:
3579             pthrd_printf("Decoded ReleaseThreadAck on %d/%d. Dropping\n", proc->getPid(), thr->getLWP());
3580             break;
3581          case InstallTrapHandlerAck:
3582          case AllocateMemoryAck:
3583             assert(0); //Currently unused
3584             break;                  
3585          case SendSignalAck:
3586             pthrd_printf("Decoded SendSignalAck on %d/%d. Dropping\n", 
3587                          proc ? proc->getPid() : -1, thr ? thr->getLWP() : -1);
3588             break;
3589          case ContinueProcessAck:
3590             pthrd_printf("Decoded ContinueProcessAck on %d/%d. Dropping\n", proc->getPid(), thr->getLWP());
3591             break;
3592          case StepThreadAck:
3593             pthrd_printf("Decoded StepThreadAck on %d/%d. Dropping\n",
3594                          proc ? proc->getPid() : -1, thr ? thr->getLWP() : -1);
3595             break;
3596          case SetWatchpointAck:
3597          case ResetWatchpointAck:
3598          case RemoveTrapHandlerAck:
3599          case SetPreferencesAck:
3600          case FreeMemoryAck:
3601          case SetFloatRegsAck:
3602          case SetDebugRegsAck:
3603             assert(0); //Currently unused
3604             break;
3605          case ReleaseControlAck:
3606             pthrd_printf("Decoded ReleaseControlAck on %d\n", proc->getPid());
3607             decodeReleaseControlAck(archevent, proc, desc->returnCode, events);
3608             break;
3609          case SetContinuationSignalAck:
3610             pthrd_printf("Decoded SetContinuationSignalAck on %d/%d. Dropping\n", proc->getPid(), thr->getLWP());
3611             break;
3612          default:
3613             break;
3614       }
3615       assert(!resp_lock_held);
3616    }
3617
3618    delete archevent;
3619
3620    if (resp_set)
3621       delete resp_set;
3622
3623    return true;
3624 }
3625
3626 bool DecoderBlueGeneQ::decodeGenericSignal(ArchEventBGQ *, bgq_process *proc, int_thread *thr,
3627                                            int signum, vector<Event::ptr> &events)
3628 {
3629    Event::ptr new_ev = EventSignal::ptr(new EventSignal(signum));
3630    new_ev->setProcess(proc->proc());
3631    new_ev->setThread(thr->thread());
3632    new_ev->setSyncType(Event::sync_process);
3633    events.push_back(new_ev);
3634    return true;
3635 }
3636
3637 bool DecoderBlueGeneQ::decodeBreakpoint(ArchEventBGQ *archevent, bgq_process *proc, int_thread *thr,
3638                                         Address addr, vector<Event::ptr> &events)
3639 {
3640    if (rpcMgr()->isRPCTrap(thr, addr)) {
3641       pthrd_printf("Decoded event to rpc completion on %d/%d at %lx\n", proc->getPid(), thr->getLWP(), addr);
3642       Event::ptr rpc_event = EventRPC::ptr(new EventRPC(thr->runningRPC()->getWrapperForDecode()));
3643       rpc_event->setProcess(proc->proc());
3644       rpc_event->setThread(thr->thread());
3645       rpc_event->setSyncType(Event::sync_process);
3646       events.push_back(rpc_event);
3647       return true;
3648    }
3649    sw_breakpoint *ibp = proc->getBreakpoint(addr);
3650    if (ibp) {
3651       pthrd_printf("Decoded breakpoint on %d/%d at %lx\n", proc->getPid(), thr->getLWP(), addr);
3652       
3653       EventBreakpoint::ptr bp_event = EventBreakpoint::ptr(new EventBreakpoint(new int_eventBreakpoint(addr, ibp, thr)));
3654       bp_event->setProcess(proc->proc());
3655       bp_event->setThread(thr->thread());
3656       bp_event->setSyncType(Event::sync_process);