This change contains changes that were made on a separate copy of this code,...

src/trusted/gdb_rsp/target.h

 /*
  * Copyright 2010 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can
  * be found in the LICENSE file.
  */
 
 
 // This module provides interfaces for accessing the debugging state of
 // the target.  The target can use either the thread that took the
 // exception or run in it's own thread.  To respond to the host, the
 // application must call the run function with a valid Transport
 // which will then be polled for commands.  The target will return
 // from Run when the host disconnects, or requests a continue.
 //
 // The object is protected by a mutex, so that it is legal to track or
 // ignore threads as an exception takes place.
 //
 // The Run function expects that all threads of interest are stopped
 // with the Step flag cleared before Run is called.  It is expected that
 // and that all threads are updated with thier modified contexts and
 // restarted when the target returns from Run.
 
-#ifndef NATIVE_CLIENT_GDB_RSP_TARGET_H_
-#define NATIVE_CLIENT_GDB_RSP_TARGET_H_ 1
+#ifndef SRC_TRUSTED_GDB_RSP_TARGET_H_
+#define SRC_TRUSTED_GDB_RSP_TARGET_H_ 1
 
 #include <map>
 #include <string>
 
 #include "native_client/src/trusted/gdb_rsp/util.h"
 
 #include "native_client/src/trusted/port/event.h"
 #include "native_client/src/trusted/port/platform.h"
 #include "native_client/src/trusted/port/mutex.h"
 #include "native_client/src/trusted/port/thread.h"
 
 namespace gdb_rsp {
 
 class Abi;
 class Packet;
 class Session;
 
 class Target {
  public:
   enum ErrDef {
     NONE = 0,
     BAD_FORMAT = 1,
     BAD_ARGS = 2,
     FAILED = 3
   };
 
-  enum State {
-    UNINIT = 0,
-    RUNNING = 1,
-    STOPPED = 2
+  enum ConState {
+    DETACHED = 0,
+    ATTACHED = 1,
+    DETACHING= 2
   };
 
   typedef ErrDef (*QFunc_t)(Target *, stringvec&, std::string);
   typedef std::map<uint32_t, port::IThread*> ThreadMap_t;
   typedef std::map<std::string, std::string> PropertyMap_t;
   typedef std::map<uint64_t, uint8_t*> BreakMap_t;
 
  public:
   // Contruct a Target object.  By default use the native ABI.
   explicit Target(const Abi *abi = NULL);
   ~Target();
 
   // Init must be the first function called to correctlty
   // build the Target internal structures.
   bool Init();
 
+  // Set/Get locally cached properties
+  bool SetProperty(const std::string &name, const std::string& val);
+  bool GetProperty(const std::string &name, std::string* val) const;
+
+  // MatchQuery does a longest prefix match against the locally cased
+  // properties, and returns the length of the match, as well as the
+  // requested value.
+  size_t MatchQuery(const std::string& match, std::string* val) const;
+
   // Add and remove temporary breakpoints.  These breakpoints
   // must be added just before we start running, and removed
   // just before we stop running to prevent the debugger from
   // seeing the modified memory.
   bool AddTemporaryBreakpoint(uint64_t address);
   bool RemoveTemporaryBreakpoints();
 
   // This function should be called by a tracked thread when it takes
   // an exception.  It takes sig_start_ to prevent other exceptions
   // from signalling thread.  If wait is true, it will then  block on
   // sig_done_ until a continue is issued by the host.
   void Signal(uint32_t id, int8_t sig, bool wait);
 
   // This function will spin on a session, until it closes.  If an
   // exception is caught, it will signal the exception thread by
   // setting sig_done_.
   void Run(Session *ses);
 
   // This function causes the target to track the state
   // of the specified thread and make it availible to
   // a connected host.
   void TrackThread(port::IThread *thread);
 
   // This function causes the target to stop tracking the
   // state of the specified thread, which will no longer
   // be visible to the host.
   void IgnoreThread(port::IThread *thread);
 
  protected:
+  // Protected member functions, should only be called by the stub thread
+  // from within "Run", at which point stateMutex_ is already held, so
+  // it is always safe for a protected function to access the signal
+  // state or thread map.
+
+  // Called whenever the target transitions from running to stopped to
+  // update information about the current state.
+  void Update();
+
+  // Called to stop and start all debug threads
+  void Pause();
+  void Resume();
+
   // This function always succeedes, since all errors
   // are reported as an error string of "E<##>" where
   // the two digit number.  The error codes are not
   // not documented, so this implementation uses
   // ErrDef as errors codes.  This function returns
   // true a request to continue (or step) is processed.
   bool ProcessPacket(Packet *pktIn, Packet *pktOut);
 
   void Destroy();
   void Detach();
 
   bool GetFirstThreadId(uint32_t *id);
   bool GetNextThreadId(uint32_t *id);
 
   uint32_t GetRegThreadId() const;
   uint32_t GetRunThreadId() const;
-  port::IThread *GetThread(uint32_t id);
+  port::IThread *GetThread(uint32_t id) const;

[noelallen_use_chromium, 2010/12/07 23:04:44]

Good catch.

 
- public:
+ private:
+  // Current Target state
+  ConState conState_;
+
   const Abi *abi_;
 
-  // This mutex protects debugging state (threads_, cur_signal, sig_thread_)
-  port::IMutex *mutex_;
+  // This mutex protects debugging state (threads_, cur_signal, sig_thread_).
+  // This mutex is held by the stub thread, while in a broken state.
+  port::IMutex *stateMutex_;
+
+  // This mutex protects the public data (breakpoint, property), and is only
+  // held temporarily as needed.
+  port::IMutex *publicMutex_;
 
   // This event is signalled when the target is really to process an
   // exception.  It ensures only one exception is processed at a time.
   port::IEvent *sig_start_;
 
   // This event is signalled when the target done processing an exception.
   port::IEvent *sig_done_;
 
   // This value is set if the exception cather is requesting a continue signal
   bool send_done_;
 
   ThreadMap_t threads_;
   ThreadMap_t::const_iterator threadItr_;
   BreakMap_t breakMap_;
 
-
+  // A map of generic properties for the target.
   PropertyMap_t properties_;
 
-  uint8_t *ctx_;         // Context Scratchpad
+  // Context Scratchpad
+  uint8_t *ctx_;
 
   // The current signal and signaling thread data is protected by
   // the mutex, and can only be owned by one thread at a time.
   // These values should only be written via the "Signal" member,
   // which will ensure that a new signal does not overwrite a
   // previous signal.
   volatile int8_t cur_signal_;
   volatile uint32_t sig_thread_;
 
-  uint32_t run_thread_;   // Which thread to issue step commands on
-  uint32_t reg_thread_;   // Which thread to issue context (reg) commands on
+  // The debugger tracks two thread ids for its operations, one for
+  // getting and setting registers, the other for step and continue.
+  // The value can be 0 for any, -1 for all, or a specific ID for
+  // a specific thread.   The "_req_" variable stores the requested
+  // id, while the "_last_" value stores the last value returned.
+  uint32_t run_req_;   // Requested thread for run operations.

[mmortensen, 2010/12/07 22:53:58]

If run_req and run_reg can bo -1, why are the declared as unsigned int?

Are we utilizing the fact the -1 has the 2's complement value of 0xFFFFFFFF when
we assign -1 to ii?  In target.cc we do in fact assign -1 to these values.

[mlinck, 2010/12/10 21:10:27]

Excellent question.  I'm not sure what the best approach here is.  I'm thinking
I want to go with int64_t for each pair so that one can be set to -1 and one to
0(like now) but we don't get overflow problems.  Not sure if that's valid for 32
bit platforms though.  Any thoughts (Cliff or Noel)?

[noelallen_use_chromium, 2010/12/13 19:28:10]

I set this to 32b so you would get that behavior.  Linux returns (0 > pid <
65535).  So if you want you can make this an int32 and be fine.  For Windows, 0
and -1 are also special.  In the case of windows, the thread ID is 32b.

[mlinck, 2010/12/14 17:23:24]

Changed to int32_t

+  uint32_t reg_req_;   // Requested thread for reg operations.
+  mutable uint32_t run_last_;  // Last result from a run thread query.
+  mutable uint32_t reg_last_;  // Last result from a reg thread query.
 };
 
 
 }  // namespace gdb_rsp
 
-#endif  // NATIVE_CLIENT_GDB_RSP_TARGET_H_
+#endif  // SRC_TRUSTED_GDB_RSP_TARGET_H_