static struct target_info * target_select_tool(FILE *f)
{
struct target_info * target;
unsigned int i;
unsigned int x;
char s[64];
int n = 0;
fprintf(f, "Target configuration utility\n\n");
if ((target = get_target_info()) != NULL) {
strcpy(s, target->name);
}
target = target_first();
fprintf(f, " | target: | arch name: | cpu family: "
"| cpu vendor: |\n");
fprintf(f, " ----+-----------------+-----------------+-------------"
"+-------------+\n");
for (i = 0; target != NULL; i++) {
if (strcmp(target->name, s) == 0) {
fprintf(f, "-> ");
n = i;
} else {
fprintf(f, " ");
}
fprintf(f, "%2d | %-15s | %15s | %11s | %11s |\n", i,
target->name, target->arch->name,
target->arch->cpu->family, target->arch->cpu->vendor);
target = target_next(target);
}
fprintf(f, " ----+-----------------+-----------------+-------------"
"+-------------+\n");
fprintf(f, "Target(%d): ", n);
fgets(s, 4, f);
x = strtoul(s, NULL, 0);
if ((s[0] == '\0') || (s[0] == '\n') || (x == n) || (x > i)) {
fprintf(f, "\nKeeping current configuration.\n");
return get_target_info();
}
target = target_first();
for (i = 0; (target != NULL); i++) {
if (x == i) {
fprintf(f, " New target: '%s'\n", target->name);
setenv("TARGET", target->name, 1);
break;
}
target = target_next(target);
}
return target;
}
static HRESULT compile_shader(const char *preproc_shader, const char *target, const char *entrypoint,
ID3DBlob **shader_blob, ID3DBlob **error_messages)
{
struct bwriter_shader *shader;
char *messages = NULL;
HRESULT hr;
DWORD *res, size, major, minor;
ID3DBlob *buffer;
char *pos;
enum shader_type shader_type;
const struct target_info *info;
TRACE("Preprocessed shader source: %s\n", debugstr_a(preproc_shader));
TRACE("Checking compilation target %s\n", debugstr_a(target));
info = get_target_info(target);
if (!info)
{
FIXME("Unknown compilation target %s\n", debugstr_a(target));
return D3DERR_INVALIDCALL;
}
else
{
if (!info->support)
{
FIXME("Compilation target %s not yet supported\n", debugstr_a(target));
return D3DERR_INVALIDCALL;
}
else
{
shader_type = info->type;
major = info->sm_major;
minor = info->sm_minor;
}
}
shader = parse_hlsl_shader(preproc_shader, shader_type, major, minor, entrypoint, &messages);
if (messages)
{
TRACE("Compiler messages:\n");
TRACE("%s\n", debugstr_a(messages));
TRACE("Shader source:\n");
TRACE("%s\n", debugstr_a(preproc_shader));
if (error_messages)
{
const char *preproc_messages = *error_messages ? ID3D10Blob_GetBufferPointer(*error_messages) : NULL;
size = strlen(messages) + (preproc_messages ? strlen(preproc_messages) : 0) + 1;
hr = D3DCreateBlob(size, &buffer);
if (FAILED(hr))
{
HeapFree(GetProcessHeap(), 0, messages);
if (shader) SlDeleteShader(shader);
return hr;
}
pos = ID3D10Blob_GetBufferPointer(buffer);
if (preproc_messages)
{
memcpy(pos, preproc_messages, strlen(preproc_messages) + 1);
pos += strlen(preproc_messages);
}
memcpy(pos, messages, strlen(messages) + 1);
if (*error_messages) ID3D10Blob_Release(*error_messages);
*error_messages = buffer;
}
HeapFree(GetProcessHeap(), 0, messages);
}
if (!shader)
{
ERR("HLSL shader parsing failed.\n");
return D3DXERR_INVALIDDATA;
}
hr = SlWriteBytecode(shader, 9, &res, &size);
SlDeleteShader(shader);
if (FAILED(hr))
{
ERR("SlWriteBytecode failed with error 0x%08x.\n", hr);
return D3DXERR_INVALIDDATA;
}
if (shader_blob)
{
hr = D3DCreateBlob(size, &buffer);
if (FAILED(hr))
{
HeapFree(GetProcessHeap(), 0, res);
return hr;
}
memcpy(ID3D10Blob_GetBufferPointer(buffer), res, size);
*shader_blob = buffer;
}
HeapFree(GetProcessHeap(), 0, res);
return S_OK;
}
static void
process_message(iscsid_request_t *req, iscsid_response_t **prsp, int *prsp_temp)
{
iscsid_response_t *rsp;
void *p = req->parameter;
*prsp_temp = FALSE;
*prsp = rsp = (iscsid_response_t *)(void *)rsp_buf;
rsp->parameter_length = 0;
rsp->status = ISCSID_STATUS_SUCCESS;
switch (req->request) {
case ISCSID_ADD_TARGET:
if (req->parameter_length < sizeof(iscsid_add_target_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_target((iscsid_add_target_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_ADD_PORTAL:
if (req->parameter_length != sizeof(iscsid_add_portal_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_portal((iscsid_add_portal_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_SET_TARGET_OPTIONS:
if (req->parameter_length != sizeof(iscsid_get_set_target_options_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = set_target_options((iscsid_get_set_target_options_t *)p);
break;
case ISCSID_GET_TARGET_OPTIONS:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = ISCSID_STATUS_NOTIMPL;
break;
case ISCSID_SET_TARGET_AUTHENTICATION:
if (req->parameter_length !=
sizeof(iscsid_set_target_authentication_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = set_target_auth((iscsid_set_target_authentication_req_t *)p);
break;
case ISCSID_SLP_FIND_TARGETS:
rsp->status = ISCSID_STATUS_NOTIMPL;
break;
case ISCSID_REFRESH_TARGETS:
if (req->parameter_length < sizeof(iscsid_refresh_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = refresh_targets((iscsid_refresh_req_t *)p);
break;
case ISCSID_REMOVE_TARGET:
if (req->parameter_length != sizeof(iscsid_list_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_target((iscsid_list_id_t *)p);
break;
case ISCSID_SEARCH_LIST:
if (req->parameter_length != sizeof(iscsid_search_list_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
search_list((iscsid_search_list_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_LIST:
if (req->parameter_length != sizeof(iscsid_get_list_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_list((iscsid_get_list_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_TARGET_INFO:
if (req->parameter_length != sizeof(iscsid_list_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_target_info((iscsid_list_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_PORTAL_INFO:
if (req->parameter_length != sizeof(iscsid_list_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_portal_info((iscsid_list_id_t *)p, prsp, prsp_temp);
break;
#ifndef ISCSI_MINIMAL
case ISCSID_ADD_ISNS_SERVER:
if (req->parameter_length != sizeof(iscsid_add_isns_server_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_isns_server((iscsid_add_isns_server_req_t *)p,
prsp, prsp_temp);
break;
case ISCSID_GET_ISNS_SERVER:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_isns_server((iscsid_sym_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_SLP_FIND_ISNS_SERVERS:
rsp->status = ISCSID_STATUS_NOTIMPL;
break;
case ISCSID_REMOVE_ISNS_SERVER:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_isns_server((iscsid_sym_id_t *)p);
break;
#endif
case ISCSID_ADD_INITIATOR_PORTAL:
if (req->parameter_length != sizeof(iscsid_add_initiator_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_initiator_portal((iscsid_add_initiator_req_t *)p,
prsp, prsp_temp);
break;
case ISCSID_GET_INITIATOR_PORTAL:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_initiator_portal((iscsid_sym_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_REMOVE_INITIATOR_PORTAL:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_initiator_portal((iscsid_sym_id_t *)p);
break;
case ISCSID_LOGIN:
if (req->parameter_length != sizeof(iscsid_login_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
login((iscsid_login_req_t *)p, rsp);
break;
case ISCSID_ADD_CONNECTION:
if (req->parameter_length != sizeof(iscsid_login_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_connection((iscsid_login_req_t *)p, rsp);
break;
case ISCSID_LOGOUT:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = logout((iscsid_sym_id_t *)p);
break;
case ISCSID_REMOVE_CONNECTION:
if (req->parameter_length != sizeof(iscsid_remove_connection_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_connection((iscsid_remove_connection_req_t *)p);
break;
case ISCSID_GET_SESSION_LIST:
get_session_list(prsp, prsp_temp);
break;
case ISCSID_GET_CONNECTION_LIST:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_connection_list((iscsid_sym_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_CONNECTION_INFO:
if (req->parameter_length != sizeof(iscsid_get_connection_info_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_connection_info((iscsid_get_connection_info_req_t *)p,
prsp, prsp_temp);
break;
case ISCSID_SET_NODE_NAME:
if (req->parameter_length != sizeof(iscsid_set_node_name_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = set_node_name((iscsid_set_node_name_req_t *)p);
break;
case ISCSID_GET_VERSION:
get_version(prsp, prsp_temp);
break;
default:
rsp->status = ISCSID_STATUS_INVALID_REQUEST;
break;
}
}
static long px_tp_d_ioctl( struct file *fp,
unsigned int cmd,
unsigned long arg)
#endif
{
switch (cmd)
{
case PX_TP_CMD_START_MODULE_TRACKING:
return start_module_tracking();
case PX_TP_CMD_START_SAMPLING:
return start_sampling((bool *)arg);
case PX_TP_CMD_STOP_PROFILING:
return stop_profiling();
case PX_TP_CMD_PAUSE_PROFILING:
return pause_profiling();
case PX_TP_CMD_RESUME_PROFILING:
return resume_profiling();
case PX_TP_CMD_ALLOC_EVENT_BUFFER:
return allocate_event_buffer((unsigned int *)arg);
case PX_TP_CMD_ALLOC_MODULE_BUFFER:
return allocate_module_buffer((unsigned int *)arg);
case PX_TP_CMD_FREE_EVENT_BUFFER:
return free_event_buffer();
case PX_TP_CMD_FREE_MODULE_BUFFER:
return free_module_buffer();
case PX_TP_CMD_SET_AUTO_LAUNCH_APP_PID:
return set_auto_launch_app_pid((pid_t *)arg);
case PX_TP_CMD_SET_WAIT_IMAGE_LOAD_NAME:
return set_wait_image_load_name((char *)arg);
case PX_TP_CMD_QUERY_REQUEST:
return query_request((struct query_request_data *)arg);
case PX_TP_CMD_GET_CPU_ID:
return get_cpu_id((unsigned long *)arg);
case PX_TP_CMD_GET_TARGET_RAW_DATA_LENGTH:
return get_target_raw_data_length((unsigned long *)arg);
case PX_TP_CMD_GET_TARGET_INFO:
return get_target_info((unsigned long *)arg);
case PX_TP_CMD_GET_CPU_FREQ:
return get_cpu_freq((unsigned int *)arg);
case PX_TP_CMD_GET_TIMESTAMP_FREQ:
return get_timestamp_frequency((unsigned long *)arg);
case PX_TP_CMD_GET_TIMESTAMP:
return get_time_stamp((unsigned long long *)arg);
case PX_TP_CMD_ADD_MODULE_RECORD:
return add_module_record((struct add_module_data *)arg);
#if 0
case PX_TP_CMD_RESET_EVENT_BUFFER_FULL:
return reset_event_buffer_full((bool *)arg);
case PX_TP_CMD_RESET_MODULE_BUFFER_FULL:
return reset_module_buffer_full((bool *)arg);
#endif
// case PX_TP_CMD_SET_KERNEL_FUNC_ADDR:
// return set_kernel_func_addr((struct tp_kernel_func_addr *)arg);
// case PX_TP_CMD_HOOK_ADDRESS:
// return hook_address((struct tp_hook_address *)arg);
case PX_TP_CMD_READ_EVENT_BUFFER:
return read_event_buffer((struct read_buffer_data *)arg);
case PX_TP_CMD_READ_MODULE_BUFFER:
return read_module_buffer((struct read_buffer_data *)arg);
case PX_TP_CMD_GET_POSSIBLE_CPU_NUM:
return get_possible_cpu_number((unsigned int *)arg);
case PX_TP_CMD_GET_ONLINE_CPU_NUM:
return get_online_cpu_number((unsigned int *)arg);
default:
return -EINVAL;
}
}
static long px_hotspot_d_ioctl(struct file *fp,
unsigned int cmd,
unsigned long arg)
#endif
{
int ret;
if ((ret = check_ioctl(fp, cmd, arg)) != 0)
return ret;
switch (cmd)
{
case PX_HS_CMD_START_MODULE_TRACKING:
return start_module_tracking_hs();
case PX_HS_CMD_START_SAMPLING:
return start_sampling((bool *)arg);
case PX_HS_CMD_STOP_PROFILING:
return stop_profiling();
case PX_HS_CMD_PAUSE_PROFILING:
return pause_profiling();
case PX_HS_CMD_RESUME_PROFILING:
return resume_profiling();
case PX_HS_CMD_ALLOC_SAMPLE_BUFFER:
return allocate_all_sample_buffers((unsigned int *)arg);
case PX_HS_CMD_ALLOC_MODULE_BUFFER:
return allocate_module_buffer((unsigned int *)arg);
case PX_HS_CMD_FREE_SAMPLE_BUFFER:
return free_all_sample_buffers();
case PX_HS_CMD_FREE_MODULE_BUFFER:
return free_module_buffer();
case PX_HS_CMD_SET_AUTO_LAUNCH_APP_PID:
return set_auto_launch_app_pid((pid_t *)arg);
case PX_HS_CMD_SET_WAIT_IMAGE_LOAD_NAME:
return set_wait_image_load_name((char *)arg);
case PX_HS_CMD_SET_TBS_SETTINGS:
return set_tbs_settings((struct HSTimerSettings *)arg);
case PX_HS_CMD_SET_EBS_SETTINGS:
return set_ebs_settings((struct HSEventSettings *)arg);
case PX_HS_CMD_SET_CALIBRATION_MODE:
return set_calibration_mode((bool *)arg);
case PX_HS_CMD_QUERY_REQUEST:
return query_request((struct query_request_data *)arg);
case PX_HS_CMD_GET_CALIBRATION_RESULT:
return get_calibration_result((struct calibration_result *)arg);
case PX_HS_CMD_GET_CPU_ID:
return get_cpu_id((unsigned long *)arg);
case PX_HS_CMD_GET_TARGET_RAW_DATA_LENGTH:
return get_target_raw_data_length((unsigned long *)arg);
case PX_HS_CMD_GET_TARGET_INFO:
return get_target_info((unsigned long *)arg);
case PX_HS_CMD_GET_CPU_FREQ:
return get_cpu_freq((unsigned int *)arg);
case PX_HS_CMD_GET_TIMESTAMP_FREQ:
return get_timestamp_frequency((unsigned long *)arg);
case PX_HS_CMD_GET_TIMESTAMP:
return get_time_stamp((unsigned long long *)arg);
case PX_HS_CMD_ADD_MODULE_RECORD:
return add_module_record_hs((struct add_module_data *)arg);
case PX_HS_CMD_READ_SAMPLE_BUFFER:
return read_sample_buffer((struct read_buffer_data *)arg);
case PX_HS_CMD_READ_MODULE_BUFFER:
return read_module_buffer((struct read_buffer_data *)arg);
case PX_HS_CMD_READ_TOTAL_SAMPLE_COUNT:
return read_total_sample_count((unsigned long long *)arg);
case PX_HS_CMD_GET_POSSIBLE_CPU_NUM:
return get_possible_cpu_number((unsigned int *)arg);
case PX_HS_CMD_GET_ONLINE_CPU_NUM:
return get_online_cpu_number((unsigned int *)arg);
default:
return -EINVAL;
}
}
