int profiling_stop_wrapper(struct mali_session_data *session_data, _mali_uk_profiling_stop_s __user *uargs)
{
_mali_uk_profiling_stop_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
kargs.ctx = session_data;
err = _mali_ukk_profiling_stop(&kargs);
if (_MALI_OSK_ERR_OK != err)
{
return map_errcode(err);
}
if (0 != put_user(kargs.count, &uargs->count))
{
return -EFAULT;
}
return 0;
}
int get_api_version_wrapper(struct mali_session_data *session_data, _mali_uk_get_api_version_s __user *uargs)
{
_mali_uk_get_api_version_s kargs;
_mali_osk_errcode_t err;
u32 mem = _mali_ukk_report_memory_usage();
printk("Mali: mem_usage before %d : %u\n", _mali_osk_get_pid(), mem);
MALI_CHECK_NON_NULL(uargs, -EINVAL);
if (0 != get_user(kargs.version, &uargs->version)) return -EFAULT;
kargs.ctx = session_data;
err = _mali_ukk_get_api_version(&kargs);
if (_MALI_OSK_ERR_OK != err) return map_errcode(err);
if (0 != put_user(kargs.version, &uargs->version)) return -EFAULT;
if (0 != put_user(kargs.compatible, &uargs->compatible)) return -EFAULT;
return 0;
}
int profiling_memory_usage_get_wrapper(struct mali_session_data *session_data, _mali_uk_profiling_memory_usage_get_s __user *uargs)
{
_mali_osk_errcode_t err;
_mali_uk_profiling_memory_usage_get_s kargs;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
MALI_CHECK_NON_NULL(session_data, -EINVAL);
kargs.ctx = (uintptr_t)session_data;
err = _mali_ukk_profiling_memory_usage_get(&kargs);
if (_MALI_OSK_ERR_OK != err) {
return map_errcode(err);
}
kargs.ctx = (uintptr_t)NULL; /* prevent kernel address to be returned to user space */
if (0 != copy_to_user(uargs, &kargs, sizeof(_mali_uk_profiling_memory_usage_get_s))) {
return -EFAULT;
}
return 0;
}
int mem_free_big_block_wrapper(struct mali_session_data *session_data, _mali_uk_free_big_block_s __user * argument)
{
_mali_uk_free_big_block_s uk_args;
_mali_osk_errcode_t err_code;
/* validate input */
/* the session_data pointer was validated by caller */
MALI_CHECK_NON_NULL( argument, -EINVAL );
/* get call arguments from user space. get_user returns 0 on success */
if ( 0 != get_user(uk_args.cookie, &argument->cookie) )
{
return -EFAULT;
}
uk_args.ctx = session_data;
err_code = _mali_ukk_free_big_block( &uk_args );
/* Return the error that _mali_ukk_free_big_block produced */
return map_errcode(err_code);
}
int mem_release_ump_wrapper(struct mali_session_data *session_data, _mali_uk_release_ump_mem_s __user * argument)
{
_mali_uk_release_ump_mem_s uk_args;
_mali_osk_errcode_t err_code;
MALI_CHECK_NON_NULL( argument, -EINVAL);
if ( 0 != copy_from_user(&uk_args, (void __user *)argument, sizeof(_mali_uk_release_ump_mem_s)) )
{
return -EFAULT;
}
uk_args.ctx = session_data;
err_code = _mali_ukk_release_ump_mem( &uk_args );
return map_errcode(err_code);
}
int mem_release_ump_wrapper(struct mali_session_data *session_data, _mali_uk_release_ump_mem_s __user * argument)
{
_mali_uk_release_ump_mem_s uk_args;
_mali_osk_errcode_t err_code;
/* validate input */
/* the session_data pointer was validated by caller */
MALI_CHECK_NON_NULL( argument, -EINVAL);
/* get call arguments from user space. copy_from_user returns how many bytes which where NOT copied */
if ( 0 != copy_from_user(&uk_args, (void __user *)argument, sizeof(_mali_uk_release_ump_mem_s)) )
{
return -EFAULT;
}
uk_args.ctx = session_data;
err_code = _mali_ukk_release_ump_mem( &uk_args );
/* Return the error that _mali_ukk_free_big_block produced */
return map_errcode(err_code);
}
int vsync_event_report_wrapper(struct mali_session_data *session_data, _mali_uk_vsync_event_report_s __user *uargs)
{
_mali_uk_vsync_event_report_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
if (0 != copy_from_user(&kargs, uargs, sizeof(_mali_uk_vsync_event_report_s)))
{
return -EFAULT;
}
kargs.ctx = session_data;
err = _mali_ukk_vsync_event_report(&kargs);
if (_MALI_OSK_ERR_OK != err)
{
return map_errcode(err);
}
return 0;
}
static OM_uint32
val_store_cred_args(
OM_uint32 *minor_status,
const gss_cred_id_t input_cred_handle,
gss_cred_usage_t cred_usage,
const gss_OID desired_mech,
OM_uint32 overwrite_cred,
OM_uint32 default_cred,
gss_OID_set *elements_stored,
gss_cred_usage_t *cred_usage_stored)
{
/* Initialize outputs. */
if (minor_status != NULL)
*minor_status = 0;
if (elements_stored != NULL)
*elements_stored = GSS_C_NULL_OID_SET;
/* Validate arguments. */
if (minor_status == NULL)
return (GSS_S_CALL_INACCESSIBLE_WRITE);
if (input_cred_handle == GSS_C_NO_CREDENTIAL)
return (GSS_S_CALL_INACCESSIBLE_READ | GSS_S_NO_CRED);
if (cred_usage != GSS_C_ACCEPT
&& cred_usage != GSS_C_INITIATE
&& cred_usage != GSS_C_BOTH) {
if (minor_status) {
*minor_status = EINVAL;
map_errcode(minor_status);
}
return GSS_S_FAILURE;
}
return (GSS_S_COMPLETE);
}
int mem_map_ext_wrapper(struct mali_session_data *session_data, _mali_uk_map_external_mem_s __user * argument)
{
_mali_uk_map_external_mem_s uk_args;
_mali_osk_errcode_t err_code;
MALI_CHECK_NON_NULL( argument, -EINVAL);
if ( 0 != copy_from_user(&uk_args, (void __user *)argument, sizeof(_mali_uk_map_external_mem_s)) )
{
return -EFAULT;
}
uk_args.ctx = session_data;
err_code = _mali_ukk_map_external_mem( &uk_args );
if (0 != put_user(uk_args.cookie, &argument->cookie))
{
if (_MALI_OSK_ERR_OK == err_code)
{
_mali_uk_unmap_external_mem_s uk_args_unmap;
uk_args_unmap.ctx = session_data;
uk_args_unmap.cookie = uk_args.cookie;
err_code = _mali_ukk_unmap_external_mem( &uk_args_unmap );
if (_MALI_OSK_ERR_OK != err_code)
{
MALI_DEBUG_PRINT(4, ("reverting _mali_ukk_unmap_external_mem, as a result of failing put_user(), failed\n"));
}
}
return -EFAULT;
}
return map_errcode(err_code);
}
int mem_attach_ump_wrapper(struct mali_session_data *session_data, _mali_uk_attach_ump_mem_s __user * argument)
{
_mali_uk_attach_ump_mem_s uk_args;
_mali_osk_errcode_t err_code;
/* validate input */
/* the session_data pointer was validated by caller */
MALI_CHECK_NON_NULL( argument, -EINVAL);
/* get call arguments from user space. copy_from_user returns how many bytes which where NOT copied */
if ( 0 != copy_from_user(&uk_args, (void __user *)argument, sizeof(_mali_uk_attach_ump_mem_s)) )
{
return -EFAULT;
}
uk_args.ctx = session_data;
err_code = _mali_ukk_attach_ump_mem( &uk_args );
if (0 != put_user(uk_args.cookie, &argument->cookie))
{
if (_MALI_OSK_ERR_OK == err_code)
{
/* Rollback */
_mali_uk_release_ump_mem_s uk_args_unmap;
uk_args_unmap.ctx = session_data;
uk_args_unmap.cookie = uk_args.cookie;
err_code = _mali_ukk_release_ump_mem( &uk_args_unmap );
if (_MALI_OSK_ERR_OK != err_code)
{
MALI_DEBUG_PRINT(4, ("reverting _mali_ukk_attach_mem, as a result of failing put_user(), failed\n"));
}
}
return -EFAULT;
}
/* Return the error that _mali_ukk_map_external_ump_mem produced */
return map_errcode(err_code);
}
int post_notification_wrapper(struct mali_session_data *session_data, _mali_uk_post_notification_s __user *uargs)
{
_mali_uk_post_notification_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
kargs.ctx = session_data;
if (0 != get_user(kargs.type, &uargs->type))
{
return -EFAULT;
}
err = _mali_ukk_post_notification(&kargs);
if (_MALI_OSK_ERR_OK != err)
{
return map_errcode(err);
}
return 0;
}
int stream_create_wrapper(struct mali_session_data *session_data, _mali_uk_stream_create_s __user *uargs)
{
_mali_uk_stream_create_s kargs;
_mali_osk_errcode_t err;
char name[32];
MALI_CHECK_NON_NULL(uargs, -EINVAL);
snprintf(name, 32, "mali-%u", _mali_osk_get_pid());
kargs.ctx = session_data;
err = mali_stream_create(name, &kargs.fd);
if (_MALI_OSK_ERR_OK != err)
{
return map_errcode(err);
}
kargs.ctx = NULL; /* prevent kernel address to be returned to user space */
if (0 != copy_to_user(uargs, &kargs, sizeof(_mali_uk_stream_create_s))) return -EFAULT;
return 0;
}
/*
* IOCTL operation; Negotiate version of IOCTL API
*/
int ump_get_api_version_wrapper(u32 __user * argument, struct ump_session_data * session_data)
{
_ump_uk_api_version_s version_info;
_mali_osk_errcode_t err;
/* Sanity check input parameters */
if (NULL == argument || NULL == session_data)
{
MSG_ERR(("NULL parameter in ump_ioctl_get_api_version()\n"));
return -ENOTTY;
}
/* Copy the user space memory to kernel space (so we safely can read it) */
if (0 != copy_from_user(&version_info, argument, sizeof(version_info)))
{
MSG_ERR(("copy_from_user() in ump_ioctl_get_api_version()\n"));
return -EFAULT;
}
version_info.ctx = (void*) session_data;
err = _ump_uku_get_api_version( &version_info );
if( _MALI_OSK_ERR_OK != err )
{
MSG_ERR(("_ump_uku_get_api_version() failed in ump_ioctl_get_api_version()\n"));
return map_errcode(err);
}
version_info.ctx = NULL;
/* Copy ouput data back to user space */
if (0 != copy_to_user(argument, &version_info, sizeof(version_info)))
{
MSG_ERR(("copy_to_user() failed in ump_ioctl_get_api_version()\n"));
return -EFAULT;
}
return 0; /* success */
}
int wait_for_notification_wrapper(struct mali_session_data *session_data, _mali_uk_wait_for_notification_s __user *uargs)
{
_mali_uk_wait_for_notification_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
kargs.ctx = session_data;
err = _mali_ukk_wait_for_notification(&kargs);
if (_MALI_OSK_ERR_OK != err) return map_errcode(err);
if(_MALI_NOTIFICATION_CORE_SHUTDOWN_IN_PROGRESS != kargs.type)
{
kargs.ctx = NULL; /* prevent kernel address to be returned to user space */
if (0 != copy_to_user(uargs, &kargs, sizeof(_mali_uk_wait_for_notification_s))) return -EFAULT;
}
else
{
if (0 != put_user(kargs.type, &uargs->type)) return -EFAULT;
}
return 0;
}
int profiling_get_stream_fd_wrapper(struct mali_session_data *session_data, _mali_uk_profiling_stream_fd_get_s __user *uargs)
{
_mali_uk_profiling_stream_fd_get_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
if (0 != copy_from_user(&kargs, uargs, sizeof(_mali_uk_profiling_stream_fd_get_s))) {
return -EFAULT;
}
kargs.ctx = (uintptr_t)session_data;
err = _mali_ukk_profiling_stream_fd_get(&kargs);
if (_MALI_OSK_ERR_OK != err) {
return map_errcode(err);
}
if (0 != copy_to_user(uargs, &kargs, sizeof(_mali_uk_profiling_stream_fd_get_s))) {
return -EFAULT;
}
return 0;
}
int gp_start_job_wrapper(struct mali_session_data *session_data, _mali_uk_gp_start_job_s __user *uargs)
{
_mali_uk_gp_start_job_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
MALI_CHECK_NON_NULL(session_data, -EINVAL);
if (!access_ok(VERIFY_WRITE, uargs, sizeof(_mali_uk_gp_start_job_s)))
{
return -EFAULT;
}
if (0 != copy_from_user(&kargs, uargs, sizeof(_mali_uk_gp_start_job_s))) return -EFAULT;
kargs.ctx = session_data;
err = _mali_ukk_gp_start_job(&kargs);
if (_MALI_OSK_ERR_OK != err) return map_errcode(err);
kargs.ctx = NULL; /* prevent kernel address to be returned to user space */
if (0 != copy_to_user(uargs, &kargs, sizeof(_mali_uk_gp_start_job_s)))
{
/*
* If this happens, then user space will not know that the job was actually started,
* and if we return a queued job, then user space will still think that one is still queued.
* This will typically lead to a deadlock in user space.
* This could however only happen if user space deliberately passes a user buffer which
* passes the access_ok(VERIFY_WRITE) check, but isn't fully writable at the time of copy_to_user().
* The official Mali driver will never attempt to do that, and kernel space should not be affected.
* That is why we do not bother to do a complex rollback in this very very very rare case.
*/
return -EFAULT;
}
return 0;
}
int mem_write_safe_wrapper(struct mali_session_data *session_data, _mali_uk_mem_write_safe_s __user * uargs)
{
_mali_uk_mem_write_safe_s kargs;
_mali_osk_errcode_t err;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
MALI_CHECK_NON_NULL(session_data, -EINVAL);
if (0 != copy_from_user(&kargs, uargs, sizeof(_mali_uk_mem_write_safe_s))) {
return -EFAULT;
}
kargs.ctx = session_data;
/* Check if we can access the buffers */
if (!access_ok(VERIFY_WRITE, kargs.dest, kargs.size)
|| !access_ok(VERIFY_READ, kargs.src, kargs.size)) {
return -EINVAL;
}
/* Check if size wraps */
if ((kargs.size + kargs.dest) <= kargs.dest
|| (kargs.size + kargs.src) <= kargs.src) {
return -EINVAL;
}
err = _mali_ukk_mem_write_safe(&kargs);
if (_MALI_OSK_ERR_OK != err) {
return map_errcode(err);
}
if (0 != put_user(kargs.size, &uargs->size)) {
return -EFAULT;
}
return 0;
}
/*
* IOCTL operation; Return size for specified UMP memory.
*/
int ump_size_get_wrapper(u32 __user * argument, struct ump_session_data * session_data)
{
_ump_uk_size_get_s user_interaction;
_mali_osk_errcode_t err;
/* Sanity check input parameters */
if (NULL == argument || NULL == session_data)
{
MSG_ERR(("NULL parameter in ump_ioctl_size_get()\n"));
return -ENOTTY;
}
if (0 != copy_from_user(&user_interaction, argument, sizeof(user_interaction)))
{
MSG_ERR(("copy_from_user() in ump_ioctl_size_get()\n"));
return -EFAULT;
}
user_interaction.ctx = (void *) session_data;
err = _ump_ukk_size_get( &user_interaction );
if( _MALI_OSK_ERR_OK != err )
{
MSG_ERR(("_ump_ukk_size_get() failed in ump_ioctl_size_get()\n"));
return map_errcode(err);
}
user_interaction.ctx = NULL;
if (0 != copy_to_user(argument, &user_interaction, sizeof(user_interaction)))
{
MSG_ERR(("copy_to_user() failed in ump_ioctl_size_get()\n"));
return -EFAULT;
}
return 0; /* success */
}
static int mali_open(struct inode *inode, struct file *filp)
{
struct mali_session_data * session_data;
_mali_osk_errcode_t err;
/* input validation */
if (mali_miscdevice.minor != iminor(inode))
{
MALI_PRINT_ERROR(("mali_open() Minor does not match\n"));
return -ENODEV;
}
/* allocated struct to track this session */
err = _mali_ukk_open((void **)&session_data);
if (_MALI_OSK_ERR_OK != err) return map_errcode(err);
/* initialize file pointer */
filp->f_pos = 0;
/* link in our session data */
filp->private_data = (void*)session_data;
return 0;
}
int mali_driver_init(void)
{
int ret = 0;
MALI_DEBUG_PRINT(2, ("\n"));
MALI_DEBUG_PRINT(2, ("Inserting Mali v%d device driver. \n",_MALI_API_VERSION));
MALI_DEBUG_PRINT(2, ("Compiled: %s, time: %s.\n", __DATE__, __TIME__));
MALI_DEBUG_PRINT(2, ("Driver revision: %s\n", SVN_REV_STRING));
ret = _mali_dev_platform_register();
if (0 != ret) goto platform_register_failed;
ret = map_errcode(initialize_kernel_device());
if (0 != ret) goto initialize_kernel_device_failed;
ret = map_errcode(mali_platform_init());
if (0 != ret) goto platform_init_failed;
mali_osk_low_level_mem_init();
ret = map_errcode(mali_initialize_subsystems());
if (0 != ret) goto initialize_subsystems_failed;
#if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED
ret = _mali_internal_profiling_init(mali_boot_profiling ? MALI_TRUE : MALI_FALSE);
if (0 != ret)
{
/* No biggie if we wheren't able to initialize the profiling */
MALI_PRINT_ERROR(("Failed to initialize profiling, feature will be unavailable\n"));
}
#endif
ret = initialize_sysfs();
if (0 != ret) goto initialize_sysfs_failed;
#if MALI_LICENSE_IS_GPL && defined(CONFIG_MALI_UMP_R3P1_DEBUG_MEM_USAGE_FOR_OOM)
ret = register_oom_notifier(&mali_oom_notifier);
if (0 != ret) goto initialize_oom_nofifier_failed;
#endif
MALI_PRINT(("Mali device driver loaded\n"));
return 0; /* Success */
/* Error handling */
#if MALI_LICENSE_IS_GPL && defined(CONFIG_MALI_UMP_R3P1_DEBUG_MEM_USAGE_FOR_OOM)
initialize_oom_nofifier_failed:
/* No need to terminate sysfs, this will be done automatically
* along with device termination */
#endif
initialize_sysfs_failed:
#if MALI_INTERNAL_TIMELINE_PROFILING_ENABLED
_mali_internal_profiling_term();
#endif
mali_terminate_subsystems();
initialize_subsystems_failed:
mali_osk_low_level_mem_term();
mali_platform_deinit();
platform_init_failed:
terminate_kernel_device();
initialize_kernel_device_failed:
_mali_dev_platform_unregister();
platform_register_failed:
return ret;
}
int profiling_control_set_wrapper(struct mali_session_data *session_data, _mali_uk_profiling_control_set_s __user *uargs)
{
_mali_uk_profiling_control_set_s kargs;
_mali_osk_errcode_t err;
u8 *kernel_control_data = NULL;
u8 *kernel_response_data = NULL;
MALI_CHECK_NON_NULL(uargs, -EINVAL);
if (0 != get_user(kargs.control_packet_size, &uargs->control_packet_size)) return -EFAULT;
if (0 != get_user(kargs.response_packet_size, &uargs->response_packet_size)) return -EFAULT;
kargs.ctx = (uintptr_t)session_data;
if (0 != kargs.control_packet_size) {
kernel_control_data = _mali_osk_calloc(1, kargs.control_packet_size);
if (NULL == kernel_control_data) {
return -ENOMEM;
}
MALI_DEBUG_ASSERT(0 != kargs.response_packet_size);
kernel_response_data = _mali_osk_calloc(1, kargs.response_packet_size);
if (NULL == kernel_response_data) {
_mali_osk_free(kernel_control_data);
return -ENOMEM;
}
kargs.control_packet_data = (uintptr_t)kernel_control_data;
kargs.response_packet_data = (uintptr_t)kernel_response_data;
if (0 != copy_from_user((void *)(uintptr_t)kernel_control_data, (void *)(uintptr_t)uargs->control_packet_data, kargs.control_packet_size)) {
_mali_osk_free(kernel_control_data);
_mali_osk_free(kernel_response_data);
return -EFAULT;
}
err = _mali_ukk_profiling_control_set(&kargs);
if (_MALI_OSK_ERR_OK != err) {
_mali_osk_free(kernel_control_data);
_mali_osk_free(kernel_response_data);
return map_errcode(err);
}
if (0 != kargs.response_packet_size && 0 != copy_to_user(((void *)(uintptr_t)uargs->response_packet_data), ((void *)(uintptr_t)kargs.response_packet_data), kargs.response_packet_size)) {
_mali_osk_free(kernel_control_data);
_mali_osk_free(kernel_response_data);
return -EFAULT;
}
if (0 != put_user(kargs.response_packet_size, &uargs->response_packet_size)) {
_mali_osk_free(kernel_control_data);
_mali_osk_free(kernel_response_data);
return -EFAULT;
}
_mali_osk_free(kernel_control_data);
_mali_osk_free(kernel_response_data);
} else {
err = _mali_ukk_profiling_control_set(&kargs);
if (_MALI_OSK_ERR_OK != err) {
return map_errcode(err);
}
}
return 0;
}
