Package ghidra.trace.database.target

Class DBTraceObjectManager

java.lang.Object

ghidra.trace.database.target.DBTraceObjectManager

All Implemented Interfaces:

ErrorHandler, DBTraceManager, TraceObjectManager

public class DBTraceObjectManager
extends Object
implements TraceObjectManager, DBTraceManager

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	DBTraceObjectManager.DBTraceObjectSchemaDBFieldCodec
protected static final class	DBTraceObjectManager.DBTraceObjectSchemaEntry

Field Summary

Fields

Modifier and Type	Field	Description
protected final ReadWriteLock	lock
protected final DBCachedObjectIndex<KeyPath,DBTraceObject>	objectsByPath
protected final Map<ghidra.trace.database.target.DBTraceObjectManager.ObjectsContainingKey,Collection<?>>	objectsContainingCache
protected final DBCachedObjectStore<DBTraceObject>	objectStore
protected final Collection<TraceObject>	objectsView
protected TraceObjectSchema	rootSchema
protected final Map<Class<? extends TraceObjectInterface>,Set<TraceObjectSchema>>	schemasByInterface
protected final DBCachedObjectStore<DBTraceObjectManager.DBTraceObjectSchemaEntry>	schemaStore
protected final DBTrace	trace
protected final DBTraceObjectValueRStarTree.DBTraceObjectValueMap	valueMap
protected final DBTraceObjectValueRStarTree	valueTree
protected final ghidra.trace.database.target.DBTraceObjectValueWriteBehindCache	valueWbCache

Constructor Summary

Constructors

Constructor	Description
DBTraceObjectManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace)

Method Summary

Modifier and Type	Method	Description
TraceBreakpointLocation	addBreakpoint(String path, Lifespan lifespan, AddressRange range, Collection<TraceThread> threads, Collection<TraceBreakpointKind> kinds, boolean enabled, String comment)
TraceMemoryRegion	addMemoryRegion(String path, Lifespan lifespan, AddressRange range, Collection<TraceMemoryFlag> flags)
TraceModule	addModule(String path, String name, Lifespan lifespan, AddressRange range)
TraceSection	addSection(String path, String name, Lifespan lifespan, AddressRange range)
TraceStack	addStack(KeyPath path, long snap)
TraceStackFrame	addStackFrame(KeyPath path, long snap)
TraceThread	addThread(String path, String display, Lifespan lifespan)
protected DBTraceObject	assertIsMine(TraceObject object)
TraceThread	assertMyThread(TraceThread thread)
protected void	checkDuplicateThread(String path, Lifespan lifespan)
protected boolean	checkMyObject(DBTraceObject object)
void	clear()	Delete the entire object model, including the schema
protected Set<TraceObjectSchema>	collectSchemasForInterface(Class<? extends TraceObjectInterface> iface)
DBTraceObject	createObject(KeyPath path)	Create (or get) an object with the given canonical path
DBTraceObjectValue	createRootObject(TraceObjectSchema schema)	Creates the root object of the model, fixing its schema
void	cullDisconnectedObjects()	For maintenance, remove all disconnected objects
void	dbError(IOException e)	Notification that an IO exception occurred.
protected <I extends TraceObjectInterface> I	doAddWithInterface(KeyPath path, Class<I> iface)
protected <I extends TraceObjectInterface> I	doAddWithInterface(String path, Class<I> iface)
protected DBTraceObject	doCreateObject(KeyPath path)
protected DBTraceObjectValue	doCreateValue(Lifespan lifespan, DBTraceObject parent, String key, Object value)
protected DBTraceObjectValueData	doCreateValueData(Lifespan lifespan, DBTraceObject parent, String key, Object value)
protected void	doDeleteCachedValue(DBTraceObjectValueBehind value)
protected void	doDeleteObject(DBTraceObject object)
protected void	doDeleteValue(DBTraceObjectValueData value)
protected DBTraceObject	doGetObject(KeyPath path)
protected Collection<? extends TraceObjectInterface>	doGetObjectsContaining(ghidra.trace.database.target.DBTraceObjectManager.ObjectsContainingKey key)
protected void	emitValueCreated(DBTraceObject parent, DBTraceObjectValue entry)
void	flushWbCaches()
Stream<DBTraceObject>	getAllObjects()	Get all the objects in the database
<I extends TraceObjectInterface> Collection<I>	getAllObjects(Class<I> iface)
Stream<DBTraceObjectValue>	getAllValues()	Get all the values (edges) in the database
<I extends TraceObjectInterface> I	getLatestSuccessor(TraceObject seed, KeyPath path, long snap, Class<I> iface)
DBTraceObject	getObjectByCanonicalPath(KeyPath path)	Get objects in the database having the given canonical path
DBTraceObject	getObjectById(long key)	Get the object with the given database key, if it exists
<I extends TraceObjectInterface> I	getObjectByPath(long snap, String path, Class<I> iface)
<I extends TraceObjectInterface> I	getObjectContaining(long snap, Address address, String key, Class<I> iface)
int	getObjectCount()	Get the number of objects in the database
<I extends TraceObjectInterface> AddressSetView	getObjectsAddressSet(long snap, String key, Class<I> ifaceCls, Predicate<? super I> predicate)
<I extends TraceObjectInterface> Collection<I>	getObjectsAtSnap(long snap, Class<I> iface)
Stream<? extends DBTraceObject>	getObjectsByPath(Lifespan span, KeyPath path)	Get objects in the database having the given path intersecting the given span
<I extends TraceObjectInterface> Collection<I>	getObjectsByPath(String path, Class<I> iface)
<I extends TraceObjectInterface> Collection<I>	getObjectsContaining(long snap, Address address, String key, Class<I> iface)
<I extends TraceObjectInterface> Collection<I>	getObjectsIntersecting(Lifespan lifespan, AddressRange range, String key, Class<I> iface)
DBTraceObject	getRootObject()	Get the root object, if it has been created
TraceObjectSchema	getRootSchema()	Get the schema of the root object
DBTraceObjectValue	getRootValue()
<I extends TraceObjectInterface> I	getSuccessor(TraceObject seed, PathFilter filter, long snap, Class<I> iface)
Trace	getTrace()	Get the trace to which the object manager belongs
Stream<? extends TraceObjectValPath>	getValuePaths(Lifespan span, PathFilter filter)	Get value entries in the database matching the given predicates intersecting the given span
Collection<? extends TraceObjectValue>	getValuesAt(long snap, Address address, String entryKey)
Collection<? extends TraceObjectValue>	getValuesIntersecting(Lifespan span, AddressRange range, String entryKey)	Get all address-ranged values intersecting the given span and address range
void	invalidateCache(boolean all)	Invalidate this manager's caches
protected void	invalidateObjectsContainingCache()
protected void	loadRootSchema()
<I extends TraceObjectInterface> Stream<I>	queryAllInterface(Lifespan span, Class<I> iface)	Get all interfaces of the given type in the database
TraceObjectSchema	requireRootSchema()	Get the schema of the root object, failing if no root object exists
protected void	setSchema(TraceObjectSchema schema)
protected Stream<DBTraceObjectValueBehind>	streamValuesAtBehind(long snap, Address address, String entryKey)
protected Stream<DBTraceObjectValueData>	streamValuesAtData(long snap, Address address, String entryKey)
protected Stream<DBTraceObjectValueBehind>	streamValuesIntersectingBehind(Lifespan span, AddressRange range, String entryKey)
protected Stream<DBTraceObjectValueData>	streamValuesIntersectingData(Lifespan span, AddressRange range, String entryKey)
protected Object	validatePrimitive(Object value)
protected Object	validateValue(Object value)
void	waitWbWorkers()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface ghidra.trace.model.target.TraceObjectManager

getValuesIntersecting

Field Details

lock

protected final ReadWriteLock lock

trace

protected final DBTrace trace

schemaStore

protected final DBCachedObjectStore<DBTraceObjectManager.DBTraceObjectSchemaEntry> schemaStore

objectStore

protected final DBCachedObjectStore<DBTraceObject> objectStore

valueTree

protected final DBTraceObjectValueRStarTree valueTree

valueMap

protected final DBTraceObjectValueRStarTree.DBTraceObjectValueMap valueMap

valueWbCache

protected final ghidra.trace.database.target.DBTraceObjectValueWriteBehindCache valueWbCache

objectsByPath

protected final DBCachedObjectIndex<KeyPath,DBTraceObject> objectsByPath

objectsView

protected final Collection<TraceObject> objectsView

rootSchema

protected TraceObjectSchema rootSchema

objectsContainingCache

protected final Map<ghidra.trace.database.target.DBTraceObjectManager.ObjectsContainingKey,Collection<?>> objectsContainingCache

schemasByInterface

protected final Map<Class<? extends TraceObjectInterface>,Set<TraceObjectSchema>> schemasByInterface

Constructor Details

DBTraceObjectManager

public DBTraceObjectManager(DBHandle dbh,
 OpenMode openMode,
 ReadWriteLock lock,
 TaskMonitor monitor,
 Language baseLanguage,
 DBTrace trace)
                     throws IOException,
VersionException

Throws:

IOException

VersionException

Method Details

loadRootSchema

protected void loadRootSchema()

dbError

public void dbError(IOException e)

Description copied from interface: ErrorHandler

Notification that an IO exception occurred.

Specified by:

dbError in interface ErrorHandler

Parameters:

e - IOException which was cause of error

invalidateCache

public void invalidateCache(boolean all)

Description copied from interface: DBTraceManager

Invalidate this manager's caches

Specified by:

invalidateCache in interface DBTraceManager

Parameters:

all - probably nothing. Check out implementations of ManagerDB.invalidateCache(boolean).

checkMyObject

protected boolean checkMyObject(DBTraceObject object)

assertIsMine

protected DBTraceObject assertIsMine(TraceObject object)

validatePrimitive

protected Object validatePrimitive(Object value)

validateValue

protected Object validateValue(Object value)

getTrace

public Trace getTrace()

Description copied from interface: TraceObjectManager

Get the trace to which the object manager belongs

Specified by:

getTrace in interface TraceObjectManager

Returns:

the trace

setSchema

protected void setSchema(TraceObjectSchema schema)

emitValueCreated

protected void emitValueCreated(DBTraceObject parent,
 DBTraceObjectValue entry)

doCreateValueData

protected DBTraceObjectValueData doCreateValueData(Lifespan lifespan,
 DBTraceObject parent,
 String key,
 Object value)

doCreateValue

protected DBTraceObjectValue doCreateValue(Lifespan lifespan,
 DBTraceObject parent,
 String key,
 Object value)

doCreateObject

protected DBTraceObject doCreateObject(KeyPath path)

doGetObject

protected DBTraceObject doGetObject(KeyPath path)

createObject

public DBTraceObject createObject(KeyPath path)

Description copied from interface: TraceObjectManager

Create (or get) an object with the given canonical path

Specified by:

createObject in interface TraceObjectManager

Parameters:

path - the object's canonical path

Returns:

the new object

createRootObject

public DBTraceObjectValue createRootObject(TraceObjectSchema schema)

Description copied from interface: TraceObjectManager

Creates the root object of the model, fixing its schema

Note the schema cannot be changed once the root object is created. The only means to "change" the schema is to delete the root object (and thus the entire tree) then re-create the root object with the new schema.

Specified by:

createRootObject in interface TraceObjectManager

Parameters:

schema - the schema

Returns:

the new object

getRootSchema

public TraceObjectSchema getRootSchema()

Description copied from interface: TraceObjectManager

Get the schema of the root object

Specified by:

getRootSchema in interface TraceObjectManager

Returns:

the schema or null

getRootValue

public DBTraceObjectValue getRootValue()

getRootObject

public DBTraceObject getRootObject()

Description copied from interface: TraceObjectManager

Get the root object, if it has been created

Specified by:

getRootObject in interface TraceObjectManager

Returns:

the root object, or null

getObjectById

public DBTraceObject getObjectById(long key)

Description copied from interface: TraceObjectManager

Get the object with the given database key, if it exists

Specified by:

getObjectById in interface TraceObjectManager

Parameters:

key - the desired object's key

Returns:

the object, or null

getObjectByCanonicalPath

public DBTraceObject getObjectByCanonicalPath(KeyPath path)

Description copied from interface: TraceObjectManager

Get objects in the database having the given canonical path

Specified by:

getObjectByCanonicalPath in interface TraceObjectManager

Parameters:

path - the canonical path of the desired objects

Returns:

the collection of objects

getObjectsByPath

public Stream<? extends DBTraceObject> getObjectsByPath(Lifespan span,
 KeyPath path)

Description copied from interface: TraceObjectManager

Get objects in the database having the given path intersecting the given span

Specified by:

getObjectsByPath in interface TraceObjectManager

Parameters:

span - the span that desired objects' lifespans must intersect

path - the path of the desired objects

Returns:

the iterable of objects

getValuePaths

public Stream<? extends TraceObjectValPath> getValuePaths(Lifespan span,
 PathFilter filter)

Description copied from interface: TraceObjectManager

Get value entries in the database matching the given predicates intersecting the given span

While the manager does not maintain integrity wrt. child lifespans and that of their parents, nor even the connectivity of objects to their canonical parents, this search depends on that consistency. An object may not be discovered unless it is properly connected to the root object. Furthermore, it will not be discovered unless it and its ancestors' lifespans all intersect the given span.

Specified by:

getValuePaths in interface TraceObjectManager

Parameters:

span - the span that desired objects' lifespans must intersect

filter - predicates to match the desired objects

Returns:

an iterator over the matching objects

getAllObjects

public Stream<DBTraceObject> getAllObjects()

Description copied from interface: TraceObjectManager

Get all the objects in the database

Specified by:

getAllObjects in interface TraceObjectManager

Returns:

the stream of all objects

getObjectCount

public int getObjectCount()

Description copied from interface: TraceObjectManager

Get the number of objects in the database

Specified by:

getObjectCount in interface TraceObjectManager

Returns:

the number of objects

getAllValues

public Stream<DBTraceObjectValue> getAllValues()

Description copied from interface: TraceObjectManager

Get all the values (edges) in the database

Specified by:

getAllValues in interface TraceObjectManager

Returns:

the stream of all values

streamValuesIntersectingData

protected Stream<DBTraceObjectValueData> streamValuesIntersectingData(Lifespan span,
 AddressRange range,
 String entryKey)

streamValuesIntersectingBehind

protected Stream<DBTraceObjectValueBehind> streamValuesIntersectingBehind(Lifespan span,
 AddressRange range,
 String entryKey)

getValuesIntersecting

public Collection<? extends TraceObjectValue> getValuesIntersecting(Lifespan span,
 AddressRange range,
 String entryKey)

Description copied from interface: TraceObjectManager

Get all address-ranged values intersecting the given span and address range

Specified by:

getValuesIntersecting in interface TraceObjectManager

Parameters:

span - the span that desired values lifespans must intersect

range - the range that desired address-ranged values must intersect

entryKey - the entry key if a single one should be matched, or null for any

Returns:

the collection of values

streamValuesAtData

protected Stream<DBTraceObjectValueData> streamValuesAtData(long snap,
 Address address,
 String entryKey)

streamValuesAtBehind

protected Stream<DBTraceObjectValueBehind> streamValuesAtBehind(long snap,
 Address address,
 String entryKey)

getValuesAt

public Collection<? extends TraceObjectValue> getValuesAt(long snap,
 Address address,
 String entryKey)

queryAllInterface

public <I extends TraceObjectInterface> Stream<I> queryAllInterface(Lifespan span,
 Class<I> iface)

Description copied from interface: TraceObjectManager

Get all interfaces of the given type in the database

Specified by:

queryAllInterface in interface TraceObjectManager

Type Parameters:

I - the type of the desired interface

Parameters:

span - the span that desired objects must intersect

iface - the class of the desired interface

Returns:

the collection of all instances of the given interface

cullDisconnectedObjects

public void cullDisconnectedObjects()

Description copied from interface: TraceObjectManager

For maintenance, remove all disconnected objects

An object is disconnected if it is neither the child nor parent of any value for any span. In other words, it's unused.

Specified by:

cullDisconnectedObjects in interface TraceObjectManager

clear

public void clear()

Description copied from interface: TraceObjectManager

Delete the entire object model, including the schema

This is the only mechanism to modify the schema. This should almost never be necessary, because a connector should provide its immutable schema immediately. Nevertheless, the database permits schema modification, but requires that the entire model be replaced.

Specified by:

clear in interface TraceObjectManager

doDeleteObject

protected void doDeleteObject(DBTraceObject object)

doDeleteValue

protected void doDeleteValue(DBTraceObjectValueData value)

doDeleteCachedValue

protected void doDeleteCachedValue(DBTraceObjectValueBehind value)

requireRootSchema

public TraceObjectSchema requireRootSchema()

Description copied from interface: TraceObjectManager

Get the schema of the root object, failing if no root object exists

Specified by:

requireRootSchema in interface TraceObjectManager

Returns:

the schema

doAddWithInterface

protected <I extends TraceObjectInterface> I doAddWithInterface(KeyPath path,
 Class<I> iface)

doAddWithInterface

protected <I extends TraceObjectInterface> I doAddWithInterface(String path,
 Class<I> iface)

getAllObjects

public <I extends TraceObjectInterface>
Collection<I> getAllObjects(Class<I> iface)

getObjectsByPath

public <I extends TraceObjectInterface>
Collection<I> getObjectsByPath(String path,
 Class<I> iface)

getObjectByPath

public <I extends TraceObjectInterface> I getObjectByPath(long snap,
 String path,
 Class<I> iface)

invalidateObjectsContainingCache

protected void invalidateObjectsContainingCache()

doGetObjectsContaining

protected Collection<? extends TraceObjectInterface> doGetObjectsContaining(ghidra.trace.database.target.DBTraceObjectManager.ObjectsContainingKey key)

getObjectsContaining

public <I extends TraceObjectInterface>
Collection<I> getObjectsContaining(long snap,
 Address address,
 String key,
 Class<I> iface)

getObjectContaining

public <I extends TraceObjectInterface> I getObjectContaining(long snap,
 Address address,
 String key,
 Class<I> iface)

collectSchemasForInterface

protected Set<TraceObjectSchema> collectSchemasForInterface(Class<? extends TraceObjectInterface> iface)

getObjectsIntersecting

public <I extends TraceObjectInterface>
Collection<I> getObjectsIntersecting(Lifespan lifespan,
 AddressRange range,
 String key,
 Class<I> iface)

getObjectsAtSnap

public <I extends TraceObjectInterface>
Collection<I> getObjectsAtSnap(long snap,
 Class<I> iface)

getObjectsAddressSet

public <I extends TraceObjectInterface>
AddressSetView getObjectsAddressSet(long snap,
 String key,
 Class<I> ifaceCls,
 Predicate<? super I> predicate)

getSuccessor

public <I extends TraceObjectInterface> I getSuccessor(TraceObject seed,
 PathFilter filter,
 long snap,
 Class<I> iface)

getLatestSuccessor

public <I extends TraceObjectInterface> I getLatestSuccessor(TraceObject seed,
 KeyPath path,
 long snap,
 Class<I> iface)

addBreakpoint

public TraceBreakpointLocation addBreakpoint(String path,
 Lifespan lifespan,
 AddressRange range,
 Collection<TraceThread> threads,
 Collection<TraceBreakpointKind> kinds,
 boolean enabled,
 String comment)
                                      throws DuplicateNameException

Throws:

DuplicateNameException

addMemoryRegion

public TraceMemoryRegion addMemoryRegion(String path,
 Lifespan lifespan,
 AddressRange range,
 Collection<TraceMemoryFlag> flags)
                                  throws TraceOverlappedRegionException

Throws:

TraceOverlappedRegionException

addModule

public TraceModule addModule(String path,
 String name,
 Lifespan lifespan,
 AddressRange range)
                      throws DuplicateNameException

Throws:

DuplicateNameException

addSection

public TraceSection addSection(String path,
 String name,
 Lifespan lifespan,
 AddressRange range)
                        throws DuplicateNameException

Throws:

DuplicateNameException

addStack

public TraceStack addStack(KeyPath path,
 long snap)

addStackFrame

public TraceStackFrame addStackFrame(KeyPath path,
 long snap)

checkDuplicateThread

protected void checkDuplicateThread(String path,
 Lifespan lifespan)
                             throws DuplicateNameException

Throws:

DuplicateNameException

addThread

public TraceThread addThread(String path,
 String display,
 Lifespan lifespan)
                      throws DuplicateNameException

Throws:

DuplicateNameException

assertMyThread

public TraceThread assertMyThread(TraceThread thread)

flushWbCaches

public void flushWbCaches()

waitWbWorkers

public void waitWbWorkers()