C++ copy_in_user函数代码示例

static int compat_cdrom_generic_command(struct block_device *bdev, fmode_t mode,
		unsigned int cmd, unsigned long arg)
{
	struct cdrom_generic_command __user *cgc;
	struct compat_cdrom_generic_command __user *cgc32;
	u32 data;
	unsigned char dir;
	int itmp;

	cgc = compat_alloc_user_space(sizeof(*cgc));
	cgc32 = compat_ptr(arg);

	if (copy_in_user(&cgc->cmd, &cgc32->cmd, sizeof(cgc->cmd)) ||
	    get_user(data, &cgc32->buffer) ||
	    put_user(compat_ptr(data), &cgc->buffer) ||
	    copy_in_user(&cgc->buflen, &cgc32->buflen,
			 (sizeof(unsigned int) + sizeof(int))) ||
	    get_user(data, &cgc32->sense) ||
	    put_user(compat_ptr(data), &cgc->sense) ||
	    get_user(dir, &cgc32->data_direction) ||
	    put_user(dir, &cgc->data_direction) ||
	    get_user(itmp, &cgc32->quiet) ||
	    put_user(itmp, &cgc->quiet) ||
	    get_user(itmp, &cgc32->timeout) ||
	    put_user(itmp, &cgc->timeout) ||
	    get_user(data, &cgc32->reserved[0]) ||
	    put_user(compat_ptr(data), &cgc->reserved[0]))
		return -EFAULT;

	return __blkdev_driver_ioctl(bdev, mode, cmd, (unsigned long)cgc);
}

long compat_put_v4l2_format_data(struct v4l2_format *kp, struct v4l2_format32 __user *up)
{
 	long ret = 0;

	ret = put_user(kp->type, &up->type);
 	switch (kp->type) {
	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
		ret |= copy_in_user(&up->fmt.pix, &kp->fmt.pix, sizeof(struct v4l2_pix_format));
		break;
	case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
		ret |= copy_in_user(&up->fmt.pix_mp, &kp->fmt.pix_mp, sizeof(struct v4l2_pix_format_mplane));
		break;
	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
		ret |= compat_put_v4l2_window(&kp->fmt.win, &up->fmt.win);
		break;
	case V4L2_BUF_TYPE_VBI_CAPTURE:
	case V4L2_BUF_TYPE_VBI_OUTPUT:
		ret |= copy_in_user(&up->fmt.vbi, &kp->fmt.vbi, sizeof(struct v4l2_vbi_format));
		break;
	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
		ret |= copy_in_user(&up->fmt.sliced, &kp->fmt.sliced, sizeof(struct v4l2_sliced_vbi_format));
		break;
	default:
		printk(KERN_INFO "compat_ioctl32: unexpected VIDIOC_FMT type %d\n",kp->type);
		ret = -EINVAL;
	}
	return ret;
}

static int get_v4l2_plane32(struct v4l2_plane *up, struct v4l2_plane32 *up32,
				enum v4l2_memory memory)
{
	void __user *up_pln;
	compat_long_t p;

	if (copy_in_user(up, up32, 2 * sizeof(__u32)) ||
		copy_in_user(&up->data_offset, &up32->data_offset,
				sizeof(__u32)))
		return -EFAULT;

	if (memory == V4L2_MEMORY_USERPTR) {
		if (get_user(p, &up32->m.userptr))
			return -EFAULT;
		up_pln = compat_ptr(p);
		if (put_user((unsigned long)up_pln, &up->m.userptr))
			return -EFAULT;
	} else {
		if (copy_in_user(&up->m.mem_offset, &up32->m.mem_offset,
					sizeof(__u32)))
			return -EFAULT;
	}

	return 0;
}

long compat_get_v4l2_event_data(struct v4l2_event __user *pdata, struct v4l2_event32 __user *pdata32)
{
	long ret = 0;
    compat_uint_t type;
    compat_uint_t pending;
    compat_uint_t sequence;
    struct timespec		timestamp;
    compat_uint_t id;

	if (!access_ok(VERIFY_READ, pdata32, sizeof(struct v4l2_event32)))
		return -EFAULT;


	ret  = get_user(type, &pdata32->type);
    ret |= put_user(type, &pdata->type);
	ret |= copy_in_user(&pdata->u, &pdata32->u, sizeof(pdata->u));
	ret |= get_user(pending, &pdata32->pending);
    ret |= put_user(pending, &pdata->pending);
	ret |= get_user(sequence, &pdata32->sequence);
    ret |= put_user(sequence, &pdata->sequence);
	ret |= get_compat_timespec(&timestamp, &pdata32->timestamp);
    /* ret |= put_compat_timespec(&timestamp, &pdata->timestamp); */
    ret |= copy_to_user(&pdata->timestamp, &timestamp, sizeof(timestamp));
	ret |= get_user(id, &pdata32->id);
    ret |= put_user(id, &pdata->id);
	ret |= copy_in_user(pdata->reserved, pdata32->reserved, 8 * sizeof(__u32));

	return ret;
}

long compat_put_v4l2_event_data(struct v4l2_event *kp, struct v4l2_event32 __user *up)
{
	long ret = 0;
	ret  = put_user(kp->type, &up->type);
	ret |= copy_in_user(&up->u, &kp->u, sizeof(kp->u));
	ret |= put_user(kp->pending, &up->pending);
	ret |= put_user(kp->sequence, &up->sequence);
	ret |= put_compat_timespec(&kp->timestamp, &up->timestamp);
	ret |= put_user(kp->id, &up->id);
	ret |= copy_in_user(up->reserved, kp->reserved, 8 * sizeof(__u32));
	return ret;
}

static int compat_cdrom_read_audio(struct block_device *bdev, fmode_t mode,
		unsigned int cmd, unsigned long arg)
{
	struct cdrom_read_audio __user *cdread_audio;
	struct compat_cdrom_read_audio __user *cdread_audio32;
	__u32 data;
	void __user *datap;

	cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio));
	cdread_audio32 = compat_ptr(arg);

	if (copy_in_user(&cdread_audio->addr,
			 &cdread_audio32->addr,
			 (sizeof(*cdread_audio32) -
			  sizeof(compat_caddr_t))))
		return -EFAULT;

	if (get_user(data, &cdread_audio32->buf))
		return -EFAULT;
	datap = compat_ptr(data);
	if (put_user(datap, &cdread_audio->buf))
		return -EFAULT;

	return __blkdev_driver_ioctl(bdev, mode, cmd,
			(unsigned long)cdread_audio);
}

static int compat_cdrom_read_audio(struct inode *inode, struct file *file,
		struct gendisk *disk, unsigned int cmd, unsigned long arg)
{
	struct cdrom_read_audio __user *cdread_audio;
	struct compat_cdrom_read_audio __user *cdread_audio32;
	__u32 data;
	void __user *datap;

	cdread_audio = compat_alloc_user_space(sizeof(*cdread_audio));
	cdread_audio32 = compat_ptr(arg);

	if (copy_in_user(&cdread_audio->addr,
			 &cdread_audio32->addr,
			 (sizeof(*cdread_audio32) -
			  sizeof(compat_caddr_t))))
		return -EFAULT;

	if (get_user(data, &cdread_audio32->buf))
		return -EFAULT;
	datap = compat_ptr(data);
	if (put_user(datap, &cdread_audio->buf))
		return -EFAULT;

	return blkdev_driver_ioctl(inode, file, disk, cmd,
			(unsigned long)cdread_audio);
}

long adf_compat_post_config(struct file *file,
		struct adf_post_config32 __user *arg)
{
	struct adf_post_config32 cfg32;
	struct adf_post_config __user *cfg;
	int ret;

	if (copy_from_user(&cfg32, arg, sizeof(cfg32)))
		return -EFAULT;

	cfg = compat_alloc_user_space(sizeof(*cfg));
	if (!access_ok(VERIFY_WRITE, cfg, sizeof(*cfg)))
		return -EFAULT;

	if (put_user(cfg32.n_interfaces, &cfg->n_interfaces) ||
			put_user(compat_ptr(cfg32.interfaces),
					&cfg->interfaces) ||
			put_user(cfg32.n_bufs, &cfg->n_bufs) ||
			put_user(compat_ptr(cfg32.bufs), &cfg->bufs) ||
			put_user(cfg32.custom_data_size,
					&cfg->custom_data_size) ||
			put_user(compat_ptr(cfg32.custom_data),
					&cfg->custom_data))
		return -EFAULT;

	ret = adf_file_ioctl(file, ADF_POST_CONFIG, (unsigned long)cfg);
	if (ret < 0)
		return ret;

	if (copy_in_user(&arg->complete_fence, &cfg->complete_fence,
			sizeof(cfg->complete_fence)))
		return -EFAULT;

	return 0;
}

static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
{
    if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) ||
        copy_from_user(&kp->w, &up->w, sizeof(up->w)) ||
        get_user(kp->field, &up->field) ||
        get_user(kp->chromakey, &up->chromakey) ||
        get_user(kp->clipcount, &up->clipcount))
            return -EFAULT;
    if (kp->clipcount > 2048)
        return -EINVAL;
    if (kp->clipcount) {
        struct v4l2_clip32 __user *uclips;
        struct v4l2_clip __user *kclips;
        int n = kp->clipcount;
        compat_caddr_t p;

        if (get_user(p, &up->clips))
            return -EFAULT;
        uclips = compat_ptr(p);
        kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
        kp->clips = kclips;
        while (--n >= 0) {
            if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
                return -EFAULT;
            if (put_user(n ? kclips + 1 : NULL, &kclips->next))
                return -EFAULT;
            uclips += 1;
            kclips += 1;
        }
    } else
        kp->clips = NULL;
    return 0;
}

static int compat_get_qseecom_update_key_userinfo_req(
		struct compat_qseecom_update_key_userinfo_req __user *data32,
		struct qseecom_update_key_userinfo_req __user *data)
{
	int err = 0;
	compat_uint_t usage;

	err = copy_in_user(data->current_hash32, data32->current_hash32,
				QSEECOM_HASH_SIZE);
	err |= copy_in_user(data->new_hash32, data32->new_hash32,
				QSEECOM_HASH_SIZE);
	err |= get_user(usage, &data32->usage);
	err |= put_user(usage, &data->usage);

	return err;
}

static int compat_get_qseecom_load_img_req(
		struct compat_qseecom_load_img_req __user *data32,
		struct qseecom_load_img_req __user *data)
{
	int err;
	compat_ulong_t mdt_len;
	compat_ulong_t img_len;
	compat_long_t ifd_data_fd;
	compat_ulong_t app_arch;
	compat_int_t app_id;

	err = get_user(mdt_len, &data32->mdt_len);
	err |= put_user(mdt_len, &data->mdt_len);
	err |= get_user(img_len, &data32->img_len);
	err |= put_user(img_len, &data->img_len);
	err |= get_user(ifd_data_fd, &data32->ifd_data_fd);
	err |= put_user(ifd_data_fd, &data->ifd_data_fd);
	err |= copy_in_user(data->img_name, data32->img_name,
				MAX_APP_NAME_SIZE);
	err |= get_user(app_arch, &data32->app_arch);
	err |= put_user(app_arch, &data->app_arch);
	err |= get_user(app_id, &data32->app_id);
	err |= put_user(app_id, &data->app_id);
	return err;
}

static int put_v4l2_plane32(struct v4l2_plane *up, struct v4l2_plane32 *up32,
				enum v4l2_memory memory)
{
	if (copy_in_user(up32, up, 2 * sizeof(__u32)) ||
		copy_in_user(&up32->data_offset, &up->data_offset,
				sizeof(__u32)))
		return -EFAULT;

	/* For MMAP, driver might've set up the offset, so copy it back.
	 * USERPTR stays the same (was userspace-provided), so no copying. */
	if (memory == V4L2_MEMORY_MMAP)
		if (copy_in_user(&up32->m.mem_offset, &up->m.mem_offset,
					sizeof(__u32)))
			return -EFAULT;

	return 0;
}

STATIC unsigned long xfs_ioctl32_geom_v1(unsigned long arg)
{
	compat_xfs_fsop_geom_v1_t __user *p32 = (void __user *)arg;
	xfs_fsop_geom_v1_t __user *p = compat_alloc_user_space(sizeof(*p));

	if (copy_in_user(p, p32, sizeof(*p32)))
		return -EFAULT;
	return (unsigned long)p;
}

static int compat_put_v4l2_window(struct v4l2_window *kp, struct v4l2_window32 __user *up)
{
	if (copy_in_user(&up->w, &kp->w, sizeof(kp->w)) ||
		put_user(kp->field, &up->field) ||
		put_user(kp->chromakey, &up->chromakey) ||
		put_user(kp->clipcount, &up->clipcount))
			return -EFAULT;
	return 0;
}

long adf_compat_get_device_data(struct file *file,
		struct adf_device_data32 __user *arg)
{
	struct adf_device_data32 data32;
	struct adf_device_data __user *data;
	int ret;

	if (copy_from_user(&data32, arg, sizeof(data32)))
		return -EFAULT;

	data = compat_alloc_user_space(sizeof(*data));
	if (!access_ok(VERIFY_WRITE, data, sizeof(*data)))
		return -EFAULT;

	if (put_user(data32.n_attachments, &data->n_attachments) ||
			put_user(compat_ptr(data32.attachments),
					&data->attachments) ||
			put_user(data32.n_allowed_attachments,
					&data->n_allowed_attachments) ||
			put_user(compat_ptr(data32.allowed_attachments),
					&data->allowed_attachments) ||
			put_user(data32.custom_data_size,
					&data->custom_data_size) ||
			put_user(compat_ptr(data32.custom_data),
					&data->custom_data))
		return -EFAULT;

	ret = adf_file_ioctl(file, ADF_GET_DEVICE_DATA32, (unsigned long)data);
	if (ret < 0)
		return ret;

	if (copy_in_user(arg->name, data->name, sizeof(arg->name)) ||
			copy_in_user(&arg->n_attachments, &data->n_attachments,
					sizeof(arg->n_attachments)) ||
			copy_in_user(&arg->n_allowed_attachments,
					&data->n_allowed_attachments,
					sizeof(arg->n_allowed_attachments)) ||
			copy_in_user(&arg->custom_data_size,
					&data->custom_data_size,
					sizeof(arg->custom_data_size)))
		return -EFAULT;

	return 0;
}