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; }