自学教程：C++ DRM_COPY_FROM_USER_IOCTL函数代码示例

static int mga_dma_clear(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_mga_private_t *dev_priv = dev->dev_private;	drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;	drm_mga_clear_t clear;	LOCK_TEST_WITH_RETURN(dev, filp);	DRM_COPY_FROM_USER_IOCTL(clear, (drm_mga_clear_t __user *) data,				 sizeof(clear));	if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)		sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;	WRAP_TEST_WITH_RETURN(dev_priv);	mga_dma_dispatch_clear(dev, &clear);	/* Make sure we restore the 3D state next time.	 */	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CONTEXT;	return 0;}

int i915_mem_destroy_heap( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_i915_private_t *dev_priv = dev->dev_private;	drm_i915_mem_destroy_heap_t destroyheap;	struct mem_block **heap;	if ( !dev_priv ) {		DRM_ERROR( "%s called with no initialization/n", __FUNCTION__ );		return DRM_ERR(EINVAL);	}	DRM_COPY_FROM_USER_IOCTL( destroyheap, (drm_i915_mem_destroy_heap_t *)data,				  sizeof(destroyheap) );	heap = get_heap( dev_priv, destroyheap.region );	if (!heap) {		DRM_ERROR("get_heap failed");		return DRM_ERR(EFAULT);	}		if (!*heap) {		DRM_ERROR("heap not initialized?");		return DRM_ERR(EFAULT);	}	i915_mem_takedown( heap );	return 0;}

/* Needs the lock as it touches the ring. */int i915_irq_emit(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_i915_private_t *dev_priv = dev->dev_private;	drm_i915_irq_emit_t emit;	int result;	LOCK_TEST_WITH_RETURN(dev, filp);	if (!dev_priv) {		DRM_ERROR("%s called with no initialization/n", __FUNCTION__);		return DRM_ERR(EINVAL);	}	DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,				 sizeof(emit));	result = i915_emit_irq(dev);	if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {		DRM_ERROR("copy_to_user/n");		return DRM_ERR(EFAULT);	}	return 0;}

int sis_ioctl_agp_alloc( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_sis_private_t *dev_priv = dev->dev_private;	drm_sis_mem_t agp;	PMemBlock block;	int retval = 0;   	if (dev_priv == NULL || dev_priv->AGPHeap == NULL)		return DRM_ERR(EINVAL);  	DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_mem_t *)data, sizeof(agp));  	block = mmAllocMem(dev_priv->AGPHeap, agp.size, 0, 0);	if (block) {		/* TODO */		agp.offset = block->ofs;		agp.free = (unsigned long)block;		if (!add_alloc_set(agp.context, AGP_TYPE, agp.free)) {			DRM_DEBUG("adding to allocation set fails/n");			mmFreeMem((PMemBlock)agp.free);			retval = -1;		}	} else {  		agp.offset = 0;		agp.size = 0;		agp.free = 0;	}	DRM_COPY_TO_USER_IOCTL((drm_sis_mem_t *)data, agp, sizeof(agp));	DRM_DEBUG("alloc agp, size = %d, offset = %d/n", agp.size, agp.offset);	return retval;}

int sis_ioctl_agp_init( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_sis_private_t *dev_priv = dev->dev_private;	drm_sis_agp_t agp;	if (dev_priv == NULL) {		dev->dev_private = DRM(calloc)(1, sizeof(drm_sis_private_t),		    DRM_MEM_DRIVER);		dev_priv = dev->dev_private;		if (dev_priv == NULL)			return ENOMEM;	}	if (dev_priv->AGPHeap != NULL)		return DRM_ERR(EINVAL);	DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_agp_t *)data, sizeof(agp));	dev_priv->AGPHeap = mmInit(agp.offset, agp.size);	DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);  	return 0;}

int sis_fb_alloc( DRM_IOCTL_ARGS ){	drm_sis_mem_t fb;	struct sis_memreq req;	int retval = 0;	DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t *)data, sizeof(fb));	req.size = fb.size;	sis_malloc(&req);	if (req.offset) {		/* TODO */		fb.offset = req.offset;		fb.free = req.offset;		if (!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)) {			DRM_DEBUG("adding to allocation set fails/n");			sis_free(req.offset);			retval = DRM_ERR(EINVAL);		}	} else {  		fb.offset = 0;		fb.size = 0;		fb.free = 0;	}	DRM_COPY_TO_USER_IOCTL((drm_sis_mem_t *)data, fb, sizeof(fb));	DRM_DEBUG("alloc fb, size = %d, offset = %ld/n", fb.size, req.offset);	return retval;}

int radeon_mem_free( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_radeon_private_t *dev_priv = dev->dev_private;	drm_radeon_mem_free_t memfree;	struct mem_block *block, **heap;	if ( !dev_priv ) {		DRM_ERROR( "%s called with no initialization/n", __FUNCTION__ );		return DRM_ERR(EINVAL);	}	DRM_COPY_FROM_USER_IOCTL( memfree, (drm_radeon_mem_free_t *)data,				  sizeof(memfree) );	heap = get_heap( dev_priv, memfree.region );	if (!heap || !*heap)		return DRM_ERR(EFAULT);		block = find_block( *heap, memfree.region_offset );	if (!block)		return DRM_ERR(EFAULT);	if (block->pid != DRM_CURRENTPID)		return DRM_ERR(EPERM);	free_block( block );		return 0;}

int via_decoder_futex(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_via_futex_t fx;	volatile int *lock;	drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;	drm_via_sarea_t *sAPriv = dev_priv->sarea_priv;	int ret = 0;	DRM_DEBUG("%s/n", __FUNCTION__);	DRM_COPY_FROM_USER_IOCTL(fx, (drm_via_futex_t __user *) data,				 sizeof(fx));	if (fx.lock > VIA_NR_XVMC_LOCKS)		return -EFAULT;	lock = (int *)XVMCLOCKPTR(sAPriv, fx.lock);	switch (fx.func) {	case VIA_FUTEX_WAIT:		DRM_WAIT_ON(ret, dev_priv->decoder_queue[fx.lock],			    (fx.ms / 10) * (DRM_HZ / 100), *lock != fx.val);		return ret;	case VIA_FUTEX_WAKE:		DRM_WAKEUP(&(dev_priv->decoder_queue[fx.lock]));		return 0;	}	return 0;}

static int savage_bci_event_wait(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_savage_private_t *dev_priv = dev->dev_private;	drm_savage_event_wait_t event;	unsigned int event_e, hw_e;	unsigned int event_w, hw_w;	DRM_DEBUG("/n");	DRM_COPY_FROM_USER_IOCTL(event, (drm_savage_event_wait_t __user *)data,				 sizeof(event));	UPDATE_EVENT_COUNTER();	if (dev_priv->status_ptr)		hw_e = dev_priv->status_ptr[1] & 0xffff;	else		hw_e = SAVAGE_READ(SAVAGE_STATUS_WORD1) & 0xffff;	hw_w = dev_priv->event_wrap;	if (hw_e > dev_priv->event_counter)		hw_w--; /* hardware hasn't passed the last wrap yet */	event_e = event.count & 0xffff;	event_w = event.count >> 16;	/* Don't need to wait if	 * - event counter wrapped since the event was emitted or	 * - the hardware has advanced up to or over the event to wait for.	 */	if (event_w < hw_w || (event_w == hw_w && event_e <= hw_e) )		return 0;	else		return dev_priv->wait_evnt(dev_priv, event_e);}

int mga_dma_flush( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;	drm_lock_t lock;	LOCK_TEST_WITH_RETURN( dev, filp );	DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );	DRM_DEBUG( "%s%s%s/n",		   (lock.flags & _DRM_LOCK_FLUSH) ?	"flush, " : "",		   (lock.flags & _DRM_LOCK_FLUSH_ALL) ?	"flush all, " : "",		   (lock.flags & _DRM_LOCK_QUIESCENT) ?	"idle, " : "" );	WRAP_WAIT_WITH_RETURN( dev_priv );	if ( lock.flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL) ) {		mga_do_dma_flush( dev_priv );	}	if ( lock.flags & _DRM_LOCK_QUIESCENT ) {#if MGA_DMA_DEBUG		int ret = mga_do_wait_for_idle( dev_priv );		if ( ret < 0 )			DRM_INFO( "%s: -EBUSY/n", __FUNCTION__ );		return ret;#else		return mga_do_wait_for_idle( dev_priv );#endif	} else {		return 0;	}}

int radeon_mem_init_heap( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_radeon_private_t *dev_priv = dev->dev_private;	drm_radeon_mem_init_heap_t initheap;	struct mem_block **heap;	if ( !dev_priv ) {		DRM_ERROR( "%s called with no initialization/n", __FUNCTION__ );		return DRM_ERR(EINVAL);	}	DRM_COPY_FROM_USER_IOCTL( initheap, (drm_radeon_mem_init_heap_t *)data,				  sizeof(initheap) );	heap = get_heap( dev_priv, initheap.region );	if (!heap) 		return DRM_ERR(EFAULT);		if (*heap) {		DRM_ERROR("heap already initialized?");		return DRM_ERR(EFAULT);	}			return init_heap( heap, initheap.start, initheap.size );}

/* Called by the X Server to initialize the FB heap.  Allocations will fail * unless this is called.  Offset is the beginning of the heap from the * framebuffer offset (MaxXFBMem in XFree86). * * Memory layout according to Thomas Winischofer: * |------------------|DDDDDDDDDDDDDDDDDDDDDDDDDDDDD|HHHH|CCCCCCCCCCC| * *    X driver/sisfb                                  HW-   Command- *  framebuffer memory           DRI heap           Cursor   queue */int sis_fb_init( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_sis_private_t *dev_priv = dev->dev_private;	drm_sis_fb_t fb;	DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_fb_t *)data, sizeof(fb));	if (dev_priv == NULL) {		dev->dev_private = DRM(calloc)(1, sizeof(drm_sis_private_t),		    DRM_MEM_DRIVER);		dev_priv = dev->dev_private;		if (dev_priv == NULL)			return ENOMEM;	}	if (dev_priv->FBHeap != NULL)		return DRM_ERR(EINVAL);	dev_priv->FBHeap = mmInit(fb.offset, fb.size);	DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);	return 0;}

int via_fb_init(DRM_IOCTL_ARGS){	drm_via_fb_t fb;	DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t *) data, sizeof(fb));	FBHeap = via_mmInit(fb.offset, fb.size);	DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)fb.offset, (unsigned long)fb.size);	return 0;}

int via_agp_init(DRM_IOCTL_ARGS){	drm_via_agp_t agp;	DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t *) data, sizeof(agp));	AgpHeap = via_mmInit(agp.offset, agp.size);	DRM_DEBUG("offset = %lu, size = %lu", (unsigned long)agp.offset, (unsigned long)agp.size);	return 0;}

int via_dma_blit( DRM_IOCTL_ARGS ){	drm_via_dmablit_t xfer;	int err;	DRM_DEVICE;	DRM_COPY_FROM_USER_IOCTL(xfer, (drm_via_dmablit_t __user *)data, sizeof(xfer));	err = via_dmablit(dev, &xfer);	DRM_COPY_TO_USER_IOCTL((void __user *)data, xfer, sizeof(xfer));	return err;}

/* Doesn't need the hardware lock. */int i915_irq_wait(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_i915_private_t *dev_priv = dev->dev_private;	drm_i915_irq_wait_t irqwait;	if (!dev_priv) {		DRM_ERROR("%s called with no initialization/n", __FUNCTION__);		return DRM_ERR(EINVAL);	}	DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,				 sizeof(irqwait));	return i915_wait_irq(dev, irqwait.irq_seq);}

/* Set the vblank monitor pipe */int i915_vblank_pipe_set(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_i915_private_t *dev_priv = dev->dev_private;	drm_i915_vblank_pipe_t pipe;	if (!dev_priv) {		DRM_ERROR("%s called with no initialization/n", __FUNCTION__);		return DRM_ERR(EINVAL);	}	DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,				 sizeof(pipe));	dev_priv->vblank_pipe = pipe.pipe;	return i915_enable_interrupt (dev);}

int drm_authmagic(DRM_IOCTL_ARGS){	drm_auth_t	   auth;	drm_file_t	   *file;	DRM_DEVICE;	DRM_COPY_FROM_USER_IOCTL(auth, (drm_auth_t *)data, sizeof(auth));	DRM_DEBUG("%u/n", auth.magic);	if ((file = drm_find_file(dev, auth.magic))) {		file->authenticated = 1;		drm_remove_magic(dev, auth.magic);		return 0;	}	return DRM_ERR(EINVAL);}

int sis_fb_free( DRM_IOCTL_ARGS ){	drm_sis_mem_t fb;	int retval = 0;	DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_mem_t *)data, sizeof(fb));	if (!fb.free)		return DRM_ERR(EINVAL);	if (!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))		retval = DRM_ERR(EINVAL);	sis_free(fb.free);	DRM_DEBUG("free fb, offset = %lu/n", fb.free);	return retval;}

int mga_dma_init( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_mga_init_t init;	LOCK_TEST_WITH_RETURN( dev, filp );	DRM_COPY_FROM_USER_IOCTL( init, (drm_mga_init_t *)data, sizeof(init) );	switch ( init.func ) {	case MGA_INIT_DMA:		return mga_do_init_dma( dev, &init );	case MGA_CLEANUP_DMA:		return mga_do_cleanup_dma( dev );	}	return DRM_ERR(EINVAL);}

int via_map_init(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_via_init_t init;	DRM_DEBUG("%s/n", __FUNCTION__);	DRM_COPY_FROM_USER_IOCTL(init, (drm_via_init_t *) data, sizeof(init));	switch (init.func) {	case VIA_INIT_MAP:		return via_do_init_map(dev, &init);	case VIA_CLEANUP_MAP:		return via_do_cleanup_map(dev);	}	return -EINVAL;}

static int mga_dma_iload(DRM_IOCTL_ARGS){	DRM_DEVICE;	struct drm_device_dma *dma = dev->dma;	drm_mga_private_t *dev_priv = dev->dev_private;	struct drm_buf *buf;	drm_mga_buf_priv_t *buf_priv;	drm_mga_iload_t iload;	DRM_DEBUG("/n");	LOCK_TEST_WITH_RETURN(dev, filp);	DRM_COPY_FROM_USER_IOCTL(iload, (drm_mga_iload_t __user *) data,				 sizeof(iload));#if 0	if (mga_do_wait_for_idle(dev_priv) < 0) {		if (MGA_DMA_DEBUG)			DRM_INFO("%s: -EBUSY/n", __FUNCTION__);		return DRM_ERR(EBUSY);	}#endif	if (iload.idx < 0 || iload.idx > dma->buf_count)		return DRM_ERR(EINVAL);	buf = dma->buflist[iload.idx];	buf_priv = buf->dev_private;	if (mga_verify_iload(dev_priv, iload.dstorg, iload.length)) {		mga_freelist_put(dev, buf);		return DRM_ERR(EINVAL);	}	WRAP_TEST_WITH_RETURN(dev_priv);	mga_dma_dispatch_iload(dev, buf, iload.dstorg, iload.length);	/* Make sure we restore the 3D state next time.	 */	dev_priv->sarea_priv->dirty |= MGA_UPLOAD_CONTEXT;	return 0;}

static int savage_bci_init(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_savage_init_t init;	LOCK_TEST_WITH_RETURN(dev, filp);	DRM_COPY_FROM_USER_IOCTL(init, (drm_savage_init_t __user *)data,				 sizeof(init));	switch (init.func) {	case SAVAGE_INIT_BCI:		return savage_do_init_bci(dev, &init);	case SAVAGE_CLEANUP_BCI:		return savage_do_cleanup_bci(dev);	}	return DRM_ERR(EINVAL);}

intvia_dma_blit_sync( DRM_IOCTL_ARGS ){	drm_via_blitsync_t sync;	int err;	DRM_DEVICE;	DRM_COPY_FROM_USER_IOCTL(sync, (drm_via_blitsync_t *)data, sizeof(sync));		if (sync.engine >= VIA_NUM_BLIT_ENGINES) 		return DRM_ERR(EINVAL);	err = via_dmablit_sync(dev, sync.sync_handle, sync.engine);	if (DRM_ERR(EINTR) == err)		err = DRM_ERR(EAGAIN);	return err;}

static int savage_bci_event_emit(DRM_IOCTL_ARGS){	DRM_DEVICE;	drm_savage_private_t *dev_priv = dev->dev_private;	drm_savage_event_emit_t event;	DRM_DEBUG("/n");	LOCK_TEST_WITH_RETURN(dev, filp);	DRM_COPY_FROM_USER_IOCTL(event, (drm_savage_event_emit_t __user *)data,				 sizeof(event));	event.count = savage_bci_emit_event(dev_priv, event.flags);	event.count |= dev_priv->event_wrap << 16;	DRM_COPY_TO_USER_IOCTL(&((drm_savage_event_emit_t __user *)data)->count,			       event.count, sizeof(event.count));	return 0;}

int via_mem_free(DRM_IOCTL_ARGS){	drm_via_mem_t mem;	DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t *) data, sizeof(mem));	switch (mem.type) {	case VIDEO:		if (via_fb_free(&mem) == 0)			return 0;		break;	case AGP:		if (via_agp_free(&mem) == 0)			return 0;		break;	}	return -EFAULT;}

int mga_dma_buffers( DRM_IOCTL_ARGS ){	DRM_DEVICE;	drm_device_dma_t *dma = dev->dma;	drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;	drm_dma_t d;	int ret = 0;	LOCK_TEST_WITH_RETURN( dev, filp );	DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *)data, sizeof(d) );	/* Please don't send us buffers.	 */	if ( d.send_count != 0 ) {		DRM_ERROR( "Process %d trying to send %d buffers via drmDMA/n",			   DRM_CURRENTPID, d.send_count );		return DRM_ERR(EINVAL);	}	/* We'll send you buffers.	 */	if ( d.request_count < 0 || d.request_count > dma->buf_count ) {		DRM_ERROR( "Process %d trying to get %d buffers (of %d max)/n",			   DRM_CURRENTPID, d.request_count, dma->buf_count );		return DRM_ERR(EINVAL);	}	WRAP_TEST_WITH_RETURN( dev_priv );	d.granted_count = 0;	if ( d.request_count ) {		ret = mga_dma_get_buffers( filp, dev, &d );	}	DRM_COPY_TO_USER_IOCTL( (drm_dma_t *)data, d, sizeof(d) );	return ret;}