Sanitizer Patching API


Typedefs

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackBarrier )(void *userdata, uint64_t pc, uint32_t barIndex)
 Function type for a barrier callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackBlockEnter )(void *userdata)
 Function type for a CUDA block enter callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackBlockExit )(void *userdata, uint64_t pc)
 Function type for a CUDA block exit callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackCall )(void *userdata, uint64_t pc, uint64_t targetPc)
 Function type for a function call callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackDeviceSideFree )(void *userdata, uint64_t pc, void *ptr)
 Function type for a device-side free call.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackDeviceSideMalloc )(void *userdata, uint64_t pc, void *allocatedPtr, uint64_t allocatedSize)
 Function type for a device-side malloc call.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackMemoryAccess )(void *userdata, uint64_t pc, void *ptr, uint32_t accessSize, uint32_t flags)
 Function type for a memory access callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackRet )(void *userdata, uint64_t pc)
 Function type for a function return callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackShfl )(void *userdata, uint64_t pc)
 Function type for a shfl callback.
typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackSyncwarp )(void *userdata, uint64_t pc, uint32_t mask)
 Function type for a syncwarp callback.

Enumerations

enum  Sanitizer_DeviceMemoryFlags {
  SANITIZER_MEMORY_DEVICE_FLAG_NONE = 0,
  SANITIZER_MEMORY_DEVICE_FLAG_READ = 0x1,
  SANITIZER_MEMORY_DEVICE_FLAG_WRITE = 0x2,
  SANITIZER_MEMORY_DEVICE_FLAG_ATOMSYS = 0x4,
  SANITIZER_MEMORY_DEVICE_FLAG_LOCAL = 0x8,
  SANITIZER_MEMORY_DEVICE_FLAG_SHARED = 0x10
}
 Flags describing a memory access. More...
enum  Sanitizer_InstructionId {
  SANITIZER_INSTRUCTION_INVALID = 0,
  SANITIZER_INSTRUCTION_BLOCK_ENTER = 1,
  SANITIZER_INSTRUCTION_BLOCK_EXIT = 2,
  SANITIZER_INSTRUCTION_MEMORY_ACCESS = 3,
  SANITIZER_INSTRUCTION_BARRIER = 4,
  SANITIZER_INSTRUCTION_SYNCWARP = 5,
  SANITIZER_INSTRUCTION_SHFL = 6,
  SANITIZER_INSTRUCTION_CALL = 7,
  SANITIZER_INSTRUCTION_RET = 8,
  SANITIZER_INSTRUCTION_DEVICE_SIDE_MALLOC = 9,
  SANITIZER_INSTRUCTION_DEVICE_SIDE_FREE = 10
}
 Instrumentation. More...
enum  SanitizerPatchResult {
  SANITIZER_PATCH_SUCCESS = 0,
  SANITIZER_PATCH_INVALID_MEMORY_ACCESS = 1,
  SANITIZER_PATCH_INVALID_SYNCHRONIZATION = 2
}
 Sanitizer patch result codes. More...

Functions

SanitizerResult SANITIZERAPI sanitizerAddPatches (const void *image, CUcontext ctx)
 Load a module containing patches that can be used by the patching API.
SanitizerResult SANITIZERAPI sanitizerAddPatchesFromFile (const char *filename, CUcontext ctx)
 Load a module containing patches that can be used by the patching API.
SanitizerResult SANITIZERAPI sanitizerPatchInstructions (const Sanitizer_InstructionId instructionId, CUmodule module, const char *deviceCallbackName)
 Set instrumentation points and patches to be applied in a module.
SanitizerResult SANITIZERAPI sanitizerPatchModule (CUmodule module)
 Perform the actual instrumentation of a module.
SanitizerResult SANITIZERAPI sanitizerSetCallbackData (CUstream stream, const void *userdata)
 Specifies the user data pointer for callbacks.
SanitizerResult SANITIZERAPI sanitizerUnpatchModule (CUmodule module)
 Remove existing instrumentation of a module.

Detailed Description

Functions, types, and enums that implement the Sanitizer Patching API.

Typedef Documentation

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackBarrier)(void *userdata, uint64_t pc, uint32_t barIndex)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction barIndex is the barrier index.

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackBlockEnter)(void *userdata)

userdata is a pointer to user data. See sanitizerPatchModule

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackBlockExit)(void *userdata, uint64_t pc)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackCall)(void *userdata, uint64_t pc, uint64_t targetPc)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction targetPc is the PC where the called function is located.

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackDeviceSideFree)(void *userdata, uint64_t pc, void *ptr)

Note:
This is called prior to the actual call.
userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction ptr is the pointer passed to device-side free.

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackDeviceSideMalloc)(void *userdata, uint64_t pc, void *allocatedPtr, uint64_t allocatedSize)

Note:
This is called after the call has completed.
userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction allocatedPtr is the pointer returned by device-side malloc allocatedSize is the size requested by the user to device-side malloc.

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackMemoryAccess)(void *userdata, uint64_t pc, void *ptr, uint32_t accessSize, uint32_t flags)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction ptr is the address of the memory being accessed accessSize is the size of the access in bytes. Valid values are 1, 2, 4, 8, and 16. flags contains information about the type of access. See Sanitizer_DeviceMemoryFlags to interpret this value.

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackRet)(void *userdata, uint64_t pc)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackShfl)(void *userdata, uint64_t pc)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction

typedef SanitizerPatchResult(SANITIZERAPI * SanitizerCallbackSyncwarp)(void *userdata, uint64_t pc, uint32_t mask)

userdata is a pointer to user data. See sanitizerPatchModule pc is the program counter of the patched instruction mask is the thread mask passed to __syncwarp().


Enumeration Type Documentation

Flags describing a memory access. These values are to be used in order to interpret the value of flags for a SanitizerCallbackMemoryAccess callback.

If neither LOCAL or SHARED flag is set, the access is made to global memory.

Enumerator:
SANITIZER_MEMORY_DEVICE_FLAG_NONE  Empty flag.
SANITIZER_MEMORY_DEVICE_FLAG_READ  Specifies that the access is a read.
SANITIZER_MEMORY_DEVICE_FLAG_WRITE  Specifies that the access is a write.
SANITIZER_MEMORY_DEVICE_FLAG_ATOMSYS  Specifies that the access is a system-scoped atomic.
SANITIZER_MEMORY_DEVICE_FLAG_LOCAL  Specifies that the memory accessed is local memory.
SANITIZER_MEMORY_DEVICE_FLAG_SHARED  Specifies that the memory accessed is shared memory.

Instrumentation. Every entry represent an instruction type or a function call where a callback patch can be inserted.

Enumerator:
SANITIZER_INSTRUCTION_INVALID  Invalid instruction ID.
SANITIZER_INSTRUCTION_BLOCK_ENTER  CUDA block enter. This is called prior to any user code. The type of the callback must be SanitizerCallbackBlockEnter.
SANITIZER_INSTRUCTION_BLOCK_EXIT  CUDA block exit. This is called after all user code has executed. The type of the callback must be SanitizerCallbackBlockExit.
SANITIZER_INSTRUCTION_MEMORY_ACCESS  Memory Access. This can be a store, load or atomic operation. The type of the callback must be SanitizerCallbackMemoryAccess.
SANITIZER_INSTRUCTION_BARRIER  Barrier. The type of the callback must be SanitizerCallbackBarrier.
SANITIZER_INSTRUCTION_SYNCWARP  Syncwarp. The type of the callback must be SanitizerCallbackSyncwarp.
SANITIZER_INSTRUCTION_SHFL  Shfl. The type of the callback must be SanitizerCallbackShfl.
SANITIZER_INSTRUCTION_CALL  Function call. The type of the callback must be SanitizerCallbackCall.
SANITIZER_INSTRUCTION_RET  Function return. The type of the callback must be SanitizerCallbackRet.
SANITIZER_INSTRUCTION_DEVICE_SIDE_MALLOC  Device-side malloc. The type of the callback must be SanitizerCallbackDeviceSideMalloc.
SANITIZER_INSTRUCTION_DEVICE_SIDE_FREE  Device-side free. The type of the callback must be SanitizerCallbackDeviceSideFree.

Error and result codes returned by Sanitizer patches. If a patch returns with an error code different than SANITIZER_PATCH_SUCCESS, the thread will be exited.

Enumerator:
SANITIZER_PATCH_SUCCESS  No error.
SANITIZER_PATCH_INVALID_MEMORY_ACCESS  An invalid memory access was performed.
SANITIZER_PATCH_INVALID_SYNCHRONIZATION  An invalid synchronization operation was performed.


Function Documentation

SanitizerResult SANITIZERAPI sanitizerAddPatches ( const void *  image,
CUcontext  ctx 
)

Note:
Thread-safety: an API user must serialize access to sanitizerAddPatchesFromFile, sanitizerAddPatches, sanitizerPatchInstructions, and sanitizerPatchModule. For example if sanitizerAddPatches(image) and sanitizerPatchInstruction(*, *, cbName) are called concurrently and cbName is intended to be found in the loaded image, the results are undefined.

The patches loaded are only valid for the specified CUDA context.

Parameters:
image Pointer to module data to load. This API supports the same module formats as the cuModuleLoadData and cuModuleLoadFatBinary functions from the CUDA driver API.
ctx CUDA context in which to load the patches. If ctx is NULL, the current context will be used.
Return values:
SANITIZER_SUCCESS on success
SANITIZER_ERROR_NOT_INITIALIZED if unable to initialize the sanitizer
SANITIZER_ERROR_INVALID_PARAMETER if image does not point to a valid CUDA module.

SanitizerResult SANITIZERAPI sanitizerAddPatchesFromFile ( const char *  filename,
CUcontext  ctx 
)

Note:
Thread-safety: an API user must serialize access to sanitizerAddPatchesFromFile, sanitizerAddPatches, sanitizerPatchInstructions, and sanitizerPatchModule. For example if sanitizerAddPatchesFromFile(filename) and sanitizerPatchInstruction(*, *, cbName) are called concurrently and cbName is intended to be found in the loaded module, the results are undefined.

The patches loaded are only valid for the specified CUDA context.

Parameters:
filename Path to the module file. This API supports the same module formats as the cuModuleLoad function from the CUDA driver API.
ctx CUDA context in which to load the patches. If ctx is NULL, the current context will be used.
Return values:
SANITIZER_SUCCESS on success
SANITIZER_ERROR_NOT_INITIALIZED if unable to initialize the sanitizer
SANITIZER_ERROR_INVALID_PARAMETER if filename is not a path to a valid CUDA module.

SanitizerResult SANITIZERAPI sanitizerPatchInstructions ( const Sanitizer_InstructionId  instructionId,
CUmodule  module,
const char *  deviceCallbackName 
)

Mark that all instrumentation points matching instructionId are to be patched in order to call the device function identified by deviceCallbackName. It is up to the API client to ensure that this device callback exists and match the correct callback format for this instrumentation point.

Note:
Thread-safety: an API user must serialize access to sanitizerAddPatchesFromFile, sanitizerAddPatches, sanitizerPatchInstructions, and sanitizerPatchModule. For example if sanitizerAddPatches(fileName) and sanitizerPatchInstruction(*, *, cbName) are called concurrently and cbName is intended to be found in the loaded module, the results are undefined.
Parameters:
instructionId Instrumentation point for which to insert patches
module CUDA module to instrument
deviceCallbackName Name of the device function callback that the inserted patch will call at the instrumented points. This function is expected to be found in code previously loaded by sanitizerAddPatchesFromFile or sanitizerAddPatches.
Return values:
SANITIZER_SUCCESS on success
SANITIZER_ERROR_NOT_INITIALIZED if unable to initialize the sanitizer
SANITIZER_ERROR_INVALID_PARAMETER if module is not a CUDA module or if deviceCallbackName function cannot be located.

SanitizerResult SANITIZERAPI sanitizerPatchModule ( CUmodule  module  ) 

Perform the instrumentation of a CUDA module based on previous calls to sanitizerPatchInstructions. This function also specifies the device memory buffer to be passed in as userdata to all callback functions.

Note:
Thread-safety: an API user must serialize access to sanitizerAddPatchesFromFile, sanitizerAddPatches, sanitizerPatchInstructions, and sanitizerPatchModule. For example if sanitizerPatchModule(mod, *) and sanitizerPatchInstruction(*, mod, *) are called concurrently, the results are undefined.
Parameters:
module CUDA module to instrument
Return values:
SANITIZER_SUCCESS on success
SANITIZER_ERROR_INVALID_PARAMETER if module is not a CUDA module

SanitizerResult SANITIZERAPI sanitizerSetCallbackData ( CUstream  stream,
const void *  userdata 
)

Mark all subsequent launches on stream to use userdata pointer as the device memory buffer to pass in to callback functions.

Note:
Thread-safety: an API user must serialize access to sanitizerSetCallbackData and kernel launches on the same stream.
Parameters:
stream CUDA stream to link to user data. Callbacks in subsequent launches on this stream will use userdata as callback data. Can be 0 to specify the NULL stream.
userdata Device memory buffer. This data will be passed to callback functions via the userdata parameter.
Return values:
SANITIZER_SUCCESS on success
SANITIZER_ERROR_INVALID_PARAMETER if stream is not a CUDA stream

SanitizerResult SANITIZERAPI sanitizerUnpatchModule ( CUmodule  module  ) 

Remove any instrumentation of a CUDA module performed by previous calls to sanitizerPatchModule.

Note:
Thread-safety: an API user must serialize access to sanitizerPatchModule and sanitizerUnpatchModule on the same module. For example, if sanitizerPatchModule(mod) and sanitizerUnpatchModule(mod) are called concurrently, the results are undefined.
Parameters:
module CUDA module on which to remove instrumentation
Return values:
SANITIZER_SUCCESS on success


Generated on Wed Apr 24 10:01:09 2019 for SanitizerApi by  doxygen 1.5.8