[SCM] master: swagiaal: Reimplemented ProcRunUtil with rich client notification.

[SCM] master: swagiaal: Reimplemented ProcRunUtil with rich client notification.

[swagiaal]

The branch, master has been updated
       via  3b36d485999bed1d4e1b6fa7d4922332d8adfe74 (commit)
      from  dec89fbcd4c87a499c7801dfad629a998e3623e5 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email.

- Log -----------------------------------------------------------------
commit 3b36d485999bed1d4e1b6fa7d4922332d8adfe74
Author: Sami Wagiaalla <swagiaal@redhat.com>
Date:   Thu Mar 20 16:25:15 2008 -0400

    swagiaal: Reimplemented ProcRunUtil with rich client notification.
    
    frysk-core/frysk/bindir/ChangeLog
    +2008-03-20  Sami Wagiaalla  <swagiaal@redhat.com>
    +
    +	* fstep.java: Use ProcRunUtil.
    +
    
    frysk-core/frysk/util/ChangeLog
    +2008-03-20  Sami Wagiaalla  <swagiaal@redhat.com>
    +
    +	* ProcRunUtil.java: Reimplemented with rich client notification.
    +

-----------------------------------------------------------------------

Summary of changes:
 frysk-core/frysk/bindir/ChangeLog                  |    6 +-
 frysk-core/frysk/bindir/fstep.java                 |  150 ++++++++++--------
 frysk-core/frysk/util/ChangeLog                    |    4 +
 .../util/{ProcFollowUtil.java => ProcRunUtil.java} |  169 ++++++-------------
 4 files changed, 150 insertions(+), 179 deletions(-)
 copy frysk-core/frysk/util/{ProcFollowUtil.java => ProcRunUtil.java} (57%)

First 500 lines of diff:
diff --git a/frysk-core/frysk/bindir/ChangeLog b/frysk-core/frysk/bindir/ChangeLog
index 6f27c50..abbd05e 100644
--- a/frysk-core/frysk/bindir/ChangeLog
+++ b/frysk-core/frysk/bindir/ChangeLog
@@ -1,8 +1,12 @@
+2008-03-20  Sami Wagiaalla  <swagiaal@redhat.com> 
+
+	* fstep.java: Use ProcRunUtil.
+	
 2008-03-20  Sami Wagiaalla  <swagiaal@redhat.com>
 
 	Renamed ProcRunUtil to ProcFollowUtil.
 	* ferror.java: Updated.
-	* fstep.java: Updated.
+	* fstep.java: Updated.	
 
 2008-03-20  Andrew Cagney  <cagney@redhat.com>
 
diff --git a/frysk-core/frysk/bindir/fstep.java b/frysk-core/frysk/bindir/fstep.java
index 87dedf5..d509347 100644
--- a/frysk-core/frysk/bindir/fstep.java
+++ b/frysk-core/frysk/bindir/fstep.java
@@ -51,16 +51,15 @@ import frysk.isa.signals.Signal;
 import frysk.proc.Action;
 import frysk.proc.Auxv;
 import frysk.proc.Manager;
-import frysk.proc.Proc;
 import frysk.proc.Task;
 import frysk.proc.TaskObserver;
-import frysk.util.CommandlineParser;
-import frysk.util.ProcFollowUtil;
+import frysk.util.ProcRunUtil;
+import frysk.util.ProcRunUtil.ProcRunObserver;
 import gnu.classpath.tools.getopt.Option;
 import gnu.classpath.tools.getopt.OptionGroup;
 import gnu.classpath.tools.getopt.OptionException;
 
-public class fstep implements ProcFollowUtil.NewTaskObserver,
+public class fstep implements ProcRunObserver,
   TaskObserver.Code,
   TaskObserver.Instruction,
   TaskObserver.Terminated
@@ -77,13 +76,9 @@ public class fstep implements ProcFollowUtil.NewTaskObserver,
   // Defaults to 1.
   private static int instrs;
 
-  // The command to execute
-//  static String[] command;
-
   // The process id to trace
   static int pid;
 
-  private static String[] command;
 
   // Tasks being observed mapped to the total number of steps.
   private static final HashMap tasks = new HashMap();
@@ -135,32 +130,35 @@ public class fstep implements ProcFollowUtil.NewTaskObserver,
 	return new OptionGroup[] { group };
     }
 
-    public static void main(String[] args) {
-	sample = 0;
-	instrs = 1;
-	
-	// XXX: parser is only needed because fstep uses fstep.command
-	// to figure out wether the loaded code should be skipped or
-	// not.
-	final CommandlineParser parser = new CommandlineParser("fstep") {
-		//XXX: this is needed so parser doesnt thin that pids
-		//are not supported
-		public void parsePids(Proc[] procs) {
-		}
-		public void parseCommand(Proc command) {
-		    fstep.command = command.getCmdLine();
-		}
-	    };
-	parser.parse(args);
-	
-	final fstep step = new fstep();
-	
-	ProcFollowUtil procRunUtil = new ProcFollowUtil("fstep",
-						  "fstep <PID|EXEC> [OPTIONS]",
-						  args, step, options(),
-						  ProcFollowUtil.DEFAULT);
-	procRunUtil.start();
-    }
+    Option instructionsOption = new Option("instructions", 'i',
+			  "how many instructions to print at each step/sample",
+			  "instructions")
+      {
+	public void parsed(String argument) throws OptionException
+	{
+	  try
+	    {
+	      instrs = Integer.parseInt(argument);
+	    }
+	  catch (NumberFormatException nfe)
+	    {
+	      OptionException ex;
+	      ex = new OptionException("instructions must be a number");
+	      ex.initCause(nfe);
+	      throw ex;
+	    }
+	}
+      };
+
+  public static void main(String[] args) {
+    sample = 0;
+    instrs = 1;
+    
+    final fstep step = new fstep();
+    
+    ProcRunUtil procRunUtil = new ProcRunUtil("fstep", "fstep <PID|EXEC> [OPTIONS]", args, step , options(), ProcRunUtil.DEFAULT);
+    procRunUtil.start();
+  }
 
   /**
    * Disassembler to use when real disassembler isn't available.
@@ -194,54 +192,51 @@ public class fstep implements ProcFollowUtil.NewTaskObserver,
     }
   }
 
-  public void notifyNewTask(Task task)
+  public Action updateAttached(Task task)
   {
-    // We only need one disassembler since all Tasks share their memory.
-    if (disassembler == null)
-      {
-	if (Disassembler.available())
-	  disassembler = new Disassembler(task.getMemory());
-	else
-	  disassembler = new DummyDisassembler(task.getMemory());
-      }
-
-    tasks.put(task, Long.valueOf(0));
-
     // If this is an attach for a command given on the command line
     // then we want to start stepping at the actual start of the
     // process (and not inside the dynamic linker).
     long startAddress = 0;
-    if (command != null && command.length != 0)
-      {
-	Auxv[] auxv = task.getProc().getAuxv ();
-	for (int i = 0; i < auxv.length; i++)
-	  {
-	    if (auxv[i].type == inua.elf.AT.ENTRY)
-	      {
+	Auxv[] auxv = task.getProc().getAuxv();
+	for (int i = 0; i < auxv.length; i++) {
+	    if (auxv[i].type == inua.elf.AT.ENTRY) {
 		startAddress = auxv[i].val;
 		break;
-	      }
-	  }
-      }
-    
-//    System.out.println("fstep.updateAttached() startAddress 0x" + Long.toHexString(startAddress));
+	    }
+	}
 
     if (startAddress == 0)
       {
 	// Immediately start tracing steps.
-	task.requestAddInstructionObserver(this);
-	task.requestAddTerminatedObserver(this);
+	this.startTracingTask(task);
       }
     else
       task.requestAddCodeObserver(this, startAddress);
     
+    return Action.CONTINUE;
   }
 
+  private void startTracingTask(Task task){
+      if (!tasks.containsKey(task)) {
+	  tasks.put(task, Long.valueOf(0));
+	  // We only need one disassembler since all Tasks share their memory.
+	  if (disassembler == null)
+	  {
+	      if (Disassembler.available())
+		  disassembler = new Disassembler(task.getMemory());
+	      else
+		  disassembler = new DummyDisassembler(task.getMemory());
+	  }
+	    task.requestAddInstructionObserver(this);
+	    task.requestAddTerminatedObserver(this);
+	}
+  }
+  
   // TaskObserver.Code interface
   public Action updateHit(Task task, long address)
   {
-    task.requestAddInstructionObserver(this);
-    task.requestAddTerminatedObserver(this);
+      startTracingTask(task);
     task.requestDeleteCodeObserver(this, address);
     return Action.BLOCK;
   }
@@ -268,7 +263,7 @@ public class fstep implements ProcFollowUtil.NewTaskObserver,
     long steps = ((Long) tasks.get(task)).longValue();
     steps++;
     tasks.put(task, Long.valueOf(steps));
-
+    
     if (sample == 0 || steps % sample == 0) {
 	int tid = task.getTid();
 	long pc = task.getPC();
@@ -300,4 +295,33 @@ public class fstep implements ProcFollowUtil.NewTaskObserver,
   {
     // Unused
   }
+
+  public Action updateForkedOffspring(Task parent, Task offspring) {
+      this.startTracingTask(offspring);
+      offspring.requestUnblock(this);
+      return Action.BLOCK;
+  }
+
+    public Action updateExeced(Task task) {
+	// XXX: skip dynamic linker code again
+	//      a la updateAttached ?
+	return Action.CONTINUE;
+    }
+
+    public Action updateClonedOffspring(Task parent, Task offspring) {
+	this.startTracingTask(offspring);
+	offspring.requestUnblock(this);
+	return Action.BLOCK;
+    }
+    
+    public void taskAdded(Task task) {/* use updateClonedOffspring instead*/}
+    
+    public void existingTask(Task task) {
+	this.startTracingTask(task);
+    }
+
+    public void taskRemoved(Task task) {}
+    public Action updateForkedParent(Task parent, Task offspring) {return Action.CONTINUE;}
+    public Action updateClonedParent(Task task, Task clone) {return Action.CONTINUE;}
+
 }
diff --git a/frysk-core/frysk/util/ChangeLog b/frysk-core/frysk/util/ChangeLog
index b013423..9074d17 100644
--- a/frysk-core/frysk/util/ChangeLog
+++ b/frysk-core/frysk/util/ChangeLog
@@ -1,3 +1,7 @@
+2008-03-20  Sami Wagiaalla  <swagiaal@redhat.com> 
+
+	* ProcRunUtil.java: Reimplemented with rich client notification.
+
 2008-03-20  Sami Wagiaalla  <swagiaal@redhat.com>
 
 	* ProcFollowUtil.java: Renamed ProcRunUtil to ProcFollowUtil
diff --git a/frysk-core/frysk/util/ProcFollowUtil.java b/frysk-core/frysk/util/ProcRunUtil.java
similarity index 57%
copy from frysk-core/frysk/util/ProcFollowUtil.java
copy to frysk-core/frysk/util/ProcRunUtil.java
index f2888df..0163b4b 100644
--- a/frysk-core/frysk/util/ProcFollowUtil.java
+++ b/frysk-core/frysk/util/ProcRunUtil.java
@@ -40,7 +40,6 @@
 package frysk.util;
 
 import java.util.HashSet;
-import java.util.Set;
 
 import frysk.proc.Action;
 import frysk.proc.Manager;
@@ -50,14 +49,6 @@ import frysk.proc.ProcTasksObserver;
 import frysk.proc.Task;
 import frysk.proc.TaskAttachedObserverXXX;
 import frysk.proc.TaskObserver;
-import frysk.proc.TaskObserver.Cloned;
-import frysk.proc.TaskObserver.Execed;
-import frysk.proc.TaskObserver.Forked;
-import frysk.proc.TaskObserver.Instruction;
-import frysk.proc.TaskObserver.Signaled;
-import frysk.proc.TaskObserver.Syscalls;
-import frysk.proc.TaskObserver.Terminated;
-import frysk.proc.TaskObserver.Terminating;
 import gnu.classpath.tools.getopt.OptionGroup;
 
 /**
@@ -66,77 +57,71 @@ import gnu.classpath.tools.getopt.OptionGroup;
  * 
  * Utilities must define a event.ProcEvent to execute.
  */
-public class ProcFollowUtil {
+public class ProcRunUtil {
 
     private final HashSet knownTasks = new HashSet();
     
     ForkedObserver forkedObserver = new ForkedObserver();
-
     AttachedObserver attachedObserver = new AttachedObserver();
 
-    private RunningUtilOptions options;
-    private TaskObserver[] observers;
-
-    private NewTaskObserver newTaskObserver;
+    private RunUtilOptions options;
 
-    public static interface NewTaskObserver{
-	void notifyNewTask(Task task);
-    }
+    public static interface ProcRunObserver extends
+    TaskAttachedObserverXXX, // this is only notified if the process is newly created by the util
+    TaskObserver.Forked,
+    TaskObserver.Execed,
+    ProcTasksObserver, // this is only notified if the util attaches to an existing process 
+    TaskObserver.Cloned,
+    TaskObserver.Terminated
+    {}
     
-    public static class RunningUtilOptions {
+    private final ProcRunObserver procRunObserver;
+    
+    public static class RunUtilOptions {
 	boolean followForks = true;
     }
     
-    public static final RunningUtilOptions DEFAULT = new RunningUtilOptions();
+    public static final RunUtilOptions DEFAULT = new RunUtilOptions();
 
-    public ProcFollowUtil(String utilName, String usage, String[] args,
-		       NewTaskObserver newTaskObserver,
-		       OptionGroup[] customOptions,
-		       RunningUtilOptions options) {
-	this(utilName, usage, args, new TaskObserver[]{}, customOptions,
-	     options);
-	this.newTaskObserver = newTaskObserver;
-    }
-    
-    public ProcFollowUtil(String utilName, String usage, String[] args,
-		       TaskObserver[] observers, OptionGroup[] customOptions,
-		       RunningUtilOptions options) {
+    public ProcRunUtil(String utilName, String usage, String[] args,
+	    final ProcRunObserver procRunObserver, OptionGroup[] customOptions,
+	    RunUtilOptions options) {
+	
+	this.procRunObserver = procRunObserver;
 	this.options = options;
-	this.observers = observers;
-
-	//Set up commandline parser
-	CommandlineParser parser = new CommandlineParser(utilName,
-							 customOptions) {
-		// @Override
-		public void parsePids(Proc[] procs) {
-		    for (int i = 0; i < procs.length; i++) {
-			addObservers(procs[i]);
-		    }
-		}
-		// @Override
-		public void parseCommand(Proc command) {
-		    Manager.host.requestCreateAttachedProc(command, attachedObserver);
+	
+	CommandlineParser parser = new CommandlineParser(utilName, customOptions) {
+	    // @Override
+	    public void parsePids(Proc[] procs) {
+		for (int i = 0; i < procs.length; i++) {
+		    addObservers(procs[i]);
+		    new ProcTasksAction(procs[i], procRunObserver);
 		}
-	    };
+	    }
+	    
+	    // @Override
+	    public void parseCommand(Proc command) {
+		Manager.host.requestCreateAttachedProc(command, attachedObserver);
+	    }
+	};
+	
 	parser.parse(args);
+	
     }
-
+    
     private void addObservers(Proc proc) {
 	new ProcTasksAction(proc, tasksObserver);
     }
     
     private void addObservers(Task task) {
 	if (knownTasks.add(task)) {
-	    
-	    if(newTaskObserver != null){
-		newTaskObserver.notifyNewTask(task);
-	    }
-	    
-	    for (int i = 0; i < observers.length; i++) {
-		this.addTaskObserver(observers[i], task);
-	    }
-	    if (options.followForks) {
-		this.addTaskObserver(forkedObserver, task);
+	    task.requestAddClonedObserver(procRunObserver);
+	    task.requestAddExecedObserver(procRunObserver);
+	    task.requestAddForkedObserver(forkedObserver);
+	    task.requestAddTerminatedObserver(procRunObserver);
+
+	    if (this.options.followForks) {
+		task.requestAddForkedObserver(forkedObserver);
 	    }
 	}
     }
@@ -162,31 +147,33 @@ public class ProcFollowUtil {
     }
 
     class AttachedObserver implements TaskAttachedObserverXXX {
-	private Set procs = new HashSet();
-
+	
 	public synchronized Action updateAttached(Task task) {
-	    
+	
+	    procRunObserver.updateAttached(task);
 	    Proc proc = task.getProc();
-	    if (!procs.contains(proc)) {
-		procs.add(proc);
-		addObservers(proc);
-	    }
+	    addObservers(proc);
 	    
 	    return Action.BLOCK;
 	}
 
 	public void addedTo(Object observable) {
+	    procRunObserver.addedTo(observable);
 	}
 
 	public void deletedFrom(Object observable) {
+	    procRunObserver.deletedFrom(observable);
 	}
 
 	public void addFailed(Object observable, Throwable w) {
+	    procRunObserver.addFailed(observable, w);
 	    throw new RuntimeException("Failed to attach to created proc", w);
 	}
     }
     
-    private ProcTasksObserver tasksObserver = new ProcTasksObserver() {
+    ProcTasksObserver tasksObserver = new ProcTasksObserver()
+    {
+	
 	public void existingTask (Task task)
 	{
 	    addObservers(task);
@@ -219,55 +206,7 @@ public class ProcFollowUtil {
 	public void deletedFrom (Object observable) {}
     };
 
-    //XXX: this is to handle adding observers according to their types
-    //     since task does not provide overloaded functions for adding
-    //     observers.
-    private void addTaskObserver(TaskObserver observer, Task task){
-	boolean handled = false;
-	
-	if(observer instanceof TaskAttachedObserverXXX){
-	    task.requestAddAttachedObserver((TaskAttachedObserverXXX) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Cloned){
-	    task.requestAddClonedObserver((Cloned) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Forked){
-	    task.requestAddForkedObserver((Forked) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Execed){
-	    task.requestAddExecedObserver((Execed) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Terminating){
-	    task.requestAddTerminatingObserver((Terminating) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Terminated){
-	    task.requestAddTerminatedObserver((Terminated) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Syscalls){
-	    task.requestAddSyscallsObserver((Syscalls) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Signaled){
-	    task.requestAddSignaledObserver((Signaled) observer);
-	    handled = true;
-	}
-	if(observer instanceof TaskObserver.Instruction){
-	    task.requestAddInstructionObserver((Instruction) observer);
-	    handled = true;
-	}
-	
-	if(!handled){
-	    throw new RuntimeException("Observer type not handled");
-	}
-    }
-
     public void start() {
 	Manager.eventLoop.run();


hooks/post-receive
--
frysk system monitor/debugger