Attachment #261377 for bug #353514

View | Details | Raw Unified | Return to bug 353514
Collapse All | Expand All




			  &version->desc))
		return -EFAULT;

    err = psb_drm_ioctl(file, DRM_IOCTL_VERSION, (unsigned long)version);
			DRM_IOCTL_VERSION, (unsigned long)version);
	if (err)
		return err;


			  &u->unique))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
			DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
	if (err)
		return err;


			  &u->unique))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
			 DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
}

typedef struct drm_map32 {

	if (__put_user(idx, &map->offset))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_GET_MAP, (unsigned long)map);
			DRM_IOCTL_GET_MAP, (unsigned long)map);
	if (err)
		return err;


	    || __put_user(m32.flags, &map->flags))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_ADD_MAP, (unsigned long)map);
			DRM_IOCTL_ADD_MAP, (unsigned long)map);
	if (err)
		return err;


	if (__put_user((void *)(unsigned long)handle, &map->handle))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_RM_MAP, (unsigned long)map);
			 DRM_IOCTL_RM_MAP, (unsigned long)map);
}

typedef struct drm_client32 {

	if (__put_user(idx, &client->idx))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_GET_CLIENT, (unsigned long)client);
			DRM_IOCTL_GET_CLIENT, (unsigned long)client);
	if (err)
		return err;


	if (!access_ok(VERIFY_WRITE, stats, sizeof(*stats)))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_GET_STATS, (unsigned long)stats);
			DRM_IOCTL_GET_STATS, (unsigned long)stats);
	if (err)
		return err;


	    || __put_user(agp_start, &buf->agp_start))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
			DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
	if (err)
		return err;


	    || __put_user(b32.high_mark, &buf->high_mark))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
			 DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
}

typedef struct drm_buf_info32 {

	    || __put_user(list, &request->list))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_INFO_BUFS, (unsigned long)request);
			DRM_IOCTL_INFO_BUFS, (unsigned long)request);
	if (err)
		return err;


	    || __put_user(list, &request->list))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_MAP_BUFS, (unsigned long)request);
			DRM_IOCTL_MAP_BUFS, (unsigned long)request);
	if (err)
		return err;


			  &request->list))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_FREE_BUFS, (unsigned long)request);
			 DRM_IOCTL_FREE_BUFS, (unsigned long)request);
}

typedef struct drm_ctx_priv_map32 {

			  &request->handle))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
			 DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
}

static int compat_drm_getsareactx(struct file *file, unsigned int cmd,

	if (__put_user(ctx_id, &request->ctx_id))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
			DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
	if (err)
		return err;


			  &res->contexts))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_RES_CTX, (unsigned long)res);
			DRM_IOCTL_RES_CTX, (unsigned long)res);
	if (err)
		return err;


			  &d->request_sizes))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_DMA, (unsigned long)d);
			DRM_IOCTL_DMA, (unsigned long)d);
	if (err)
		return err;


	if (put_user(m32.mode, &mode->mode))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
			 DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
}

typedef struct drm_agp_info32 {

	if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_AGP_INFO, (unsigned long)info);
			DRM_IOCTL_AGP_INFO, (unsigned long)info);
	if (err)
		return err;


	    || __put_user(req32.type, &request->type))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
			DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
	if (err)
		return err;

	if (__get_user(req32.handle, &request->handle)
	    || __get_user(req32.physical, &request->physical)
	    || copy_to_user(argp, &req32, sizeof(req32))) {
		psb_drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
			  DRM_IOCTL_AGP_FREE, (unsigned long)request);
		return -EFAULT;
	}


	    || __put_user(handle, &request->handle))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
			 DRM_IOCTL_AGP_FREE, (unsigned long)request);
}

typedef struct drm_agp_binding32 {

	    || __put_user(req32.offset, &request->offset))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_AGP_BIND, (unsigned long)request);
			 DRM_IOCTL_AGP_BIND, (unsigned long)request);
}

static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,

	    || __put_user(handle, &request->handle))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
			 DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
}
#endif				/* __OS_HAS_AGP */


	    || __put_user(x, &request->size))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_SG_ALLOC, (unsigned long)request);
			DRM_IOCTL_SG_ALLOC, (unsigned long)request);
	if (err)
		return err;


	    || __put_user(x << PAGE_SHIFT, &request->handle))
		return -EFAULT;

	return psb_drm_ioctl(file, DRM_IOCTL_SG_FREE, (unsigned long)request);
			 DRM_IOCTL_SG_FREE, (unsigned long)request);
}

struct drm_wait_vblank_request32 {

	    || __put_user(req32.request.signal, &request->request.signal))
		return -EFAULT;

	err = psb_drm_ioctl(file, DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
			DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
	if (err)
		return err;


	 * than always failing.
	 */
	if (nr >= DRM_ARRAY_SIZE(drm_compat_ioctls))
		return psb_drm_ioctl(filp, cmd, arg);

	fn = drm_compat_ioctls[nr];


	if (fn != NULL)
		ret = (*fn)(filp, cmd, arg);
	else
		ret = psb_drm_ioctl(filp, cmd, arg);
	unlock_kernel();

	return ret;

Return to bug 353514

Lines 102-109 Link Here

(-)drm_ioc32.c (-56 / +29 lines)
102	&version->desc))	102	&version->desc))
103	return -EFAULT;	103	return -EFAULT;
104		104
105	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	105	err = psb_drm_ioctl(file, DRM_IOCTL_VERSION, (unsigned long)version);
106	DRM_IOCTL_VERSION, (unsigned long)version);
107	if (err)	106	if (err)
108	return err;	107	return err;
109		108
Lines 143-150 Link Here
143	&u->unique))	142	&u->unique))
144	return -EFAULT;	143	return -EFAULT;
145		144
146	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	145	err = psb_drm_ioctl(file, DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
147	DRM_IOCTL_GET_UNIQUE, (unsigned long)u);
148	if (err)	146	if (err)
149	return err;	147	return err;
150		148
Lines 172-179 Link Here
172	&u->unique))	170	&u->unique))
173	return -EFAULT;	171	return -EFAULT;
174		172
175	return psb_drm_ioctl(file->f_dentry->d_inode, file,	173	return psb_drm_ioctl(file, DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
176	DRM_IOCTL_SET_UNIQUE, (unsigned long)u);
177	}	174	}
178		175
179	typedef struct drm_map32 {	176	typedef struct drm_map32 {
Lines 203-210 Link Here
203	if (__put_user(idx, &map->offset))	200	if (__put_user(idx, &map->offset))
204	return -EFAULT;	201	return -EFAULT;
205		202
206	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	203	err = psb_drm_ioctl(file, DRM_IOCTL_GET_MAP, (unsigned long)map);
207	DRM_IOCTL_GET_MAP, (unsigned long)map);
208	if (err)	204	if (err)
209	return err;	205	return err;
210		206
Lines 244-251 Link Here
244	\|\| __put_user(m32.flags, &map->flags))	240	\|\| __put_user(m32.flags, &map->flags))
245	return -EFAULT;	241	return -EFAULT;
246		242
247	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	243	err = psb_drm_ioctl(file, DRM_IOCTL_ADD_MAP, (unsigned long)map);
248	DRM_IOCTL_ADD_MAP, (unsigned long)map);
249	if (err)	244	if (err)
250	return err;	245	return err;
251		246
Lines 282-289 Link Here
282	if (__put_user((void *)(unsigned long)handle, &map->handle))	277	if (__put_user((void *)(unsigned long)handle, &map->handle))
283	return -EFAULT;	278	return -EFAULT;
284		279
285	return psb_drm_ioctl(file->f_dentry->d_inode, file,	280	return psb_drm_ioctl(file, DRM_IOCTL_RM_MAP, (unsigned long)map);
286	DRM_IOCTL_RM_MAP, (unsigned long)map);
287	}	281	}
288		282
289	typedef struct drm_client32 {	283	typedef struct drm_client32 {
Lines 312-319 Link Here
312	if (__put_user(idx, &client->idx))	306	if (__put_user(idx, &client->idx))
313	return -EFAULT;	307	return -EFAULT;
314		308
315	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	309	err = psb_drm_ioctl(file, DRM_IOCTL_GET_CLIENT, (unsigned long)client);
316	DRM_IOCTL_GET_CLIENT, (unsigned long)client);
317	if (err)	310	if (err)
318	return err;	311	return err;
319		312
Lines 349-356 Link Here
349	if (!access_ok(VERIFY_WRITE, stats, sizeof(*stats)))	342	if (!access_ok(VERIFY_WRITE, stats, sizeof(*stats)))
350	return -EFAULT;	343	return -EFAULT;
351		344
352	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	345	err = psb_drm_ioctl(file, DRM_IOCTL_GET_STATS, (unsigned long)stats);
353	DRM_IOCTL_GET_STATS, (unsigned long)stats);
354	if (err)	346	if (err)
355	return err;	347	return err;
356		348
Lines 393-400 Link Here
393	\|\| __put_user(agp_start, &buf->agp_start))	385	\|\| __put_user(agp_start, &buf->agp_start))
394	return -EFAULT;	386	return -EFAULT;
395		387
396	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	388	err = psb_drm_ioctl(file, DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
397	DRM_IOCTL_ADD_BUFS, (unsigned long)buf);
398	if (err)	389	if (err)
399	return err;	390	return err;
400		391
Lines 425-432 Link Here
425	\|\| __put_user(b32.high_mark, &buf->high_mark))	416	\|\| __put_user(b32.high_mark, &buf->high_mark))
426	return -EFAULT;	417	return -EFAULT;
427		418
428	return psb_drm_ioctl(file->f_dentry->d_inode, file,	419	return psb_drm_ioctl(file, DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
429	DRM_IOCTL_MARK_BUFS, (unsigned long)buf);
430	}	420	}
431		421
432	typedef struct drm_buf_info32 {	422	typedef struct drm_buf_info32 {
Lines 467-474 Link Here
467	\|\| __put_user(list, &request->list))	457	\|\| __put_user(list, &request->list))
468	return -EFAULT;	458	return -EFAULT;
469		459
470	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	460	err = psb_drm_ioctl(file, DRM_IOCTL_INFO_BUFS, (unsigned long)request);
471	DRM_IOCTL_INFO_BUFS, (unsigned long)request);
472	if (err)	461	if (err)
473	return err;	462	return err;
474		463
Lines 529-536 Link Here
529	\|\| __put_user(list, &request->list))	518	\|\| __put_user(list, &request->list))
530	return -EFAULT;	519	return -EFAULT;
531		520
532	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	521	err = psb_drm_ioctl(file, DRM_IOCTL_MAP_BUFS, (unsigned long)request);
533	DRM_IOCTL_MAP_BUFS, (unsigned long)request);
534	if (err)	522	if (err)
535	return err;	523	return err;
536		524
Lines 576-583 Link Here
576	&request->list))	564	&request->list))
577	return -EFAULT;	565	return -EFAULT;
578		566
579	return psb_drm_ioctl(file->f_dentry->d_inode, file,	567	return psb_drm_ioctl(file, DRM_IOCTL_FREE_BUFS, (unsigned long)request);
580	DRM_IOCTL_FREE_BUFS, (unsigned long)request);
581	}	568	}
582		569
583	typedef struct drm_ctx_priv_map32 {	570	typedef struct drm_ctx_priv_map32 {
Lines 603-610 Link Here
603	&request->handle))	590	&request->handle))
604	return -EFAULT;	591	return -EFAULT;
605		592
606	return psb_drm_ioctl(file->f_dentry->d_inode, file,	593	return psb_drm_ioctl(file, DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
607	DRM_IOCTL_SET_SAREA_CTX, (unsigned long)request);
608	}	594	}
609		595
610	static int compat_drm_getsareactx(struct file *file, unsigned int cmd,	596	static int compat_drm_getsareactx(struct file *file, unsigned int cmd,
Lines 626-633 Link Here
626	if (__put_user(ctx_id, &request->ctx_id))	612	if (__put_user(ctx_id, &request->ctx_id))
627	return -EFAULT;	613	return -EFAULT;
628		614
629	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	615	err = psb_drm_ioctl(file, DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
630	DRM_IOCTL_GET_SAREA_CTX, (unsigned long)request);
631	if (err)	616	if (err)
632	return err;	617	return err;
633		618
Lines 662-669 Link Here
662	&res->contexts))	647	&res->contexts))
663	return -EFAULT;	648	return -EFAULT;
664		649
665	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	650	err = psb_drm_ioctl(file, DRM_IOCTL_RES_CTX, (unsigned long)res);
666	DRM_IOCTL_RES_CTX, (unsigned long)res);
667	if (err)	651	if (err)
668	return err;	652	return err;
669		653
Lines 716-723 Link Here
716	&d->request_sizes))	700	&d->request_sizes))
717	return -EFAULT;	701	return -EFAULT;
718		702
719	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	703	err = psb_drm_ioctl(file, DRM_IOCTL_DMA, (unsigned long)d);
720	DRM_IOCTL_DMA, (unsigned long)d);
721	if (err)	704	if (err)
722	return err;	705	return err;
723		706
Lines 749-756 Link Here
749	if (put_user(m32.mode, &mode->mode))	732	if (put_user(m32.mode, &mode->mode))
750	return -EFAULT;	733	return -EFAULT;
751		734
752	return psb_drm_ioctl(file->f_dentry->d_inode, file,	735	return psb_drm_ioctl(file, DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
753	DRM_IOCTL_AGP_ENABLE, (unsigned long)mode);
754	}	736	}
755		737
756	typedef struct drm_agp_info32 {	738	typedef struct drm_agp_info32 {
Lines 779-786 Link Here
779	if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))	761	if (!access_ok(VERIFY_WRITE, info, sizeof(*info)))
780	return -EFAULT;	762	return -EFAULT;
781		763
782	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	764	err = psb_drm_ioctl(file, DRM_IOCTL_AGP_INFO, (unsigned long)info);
783	DRM_IOCTL_AGP_INFO, (unsigned long)info);
784	if (err)	765	if (err)
785	return err;	766	return err;
786		767
Lines 825-840 Link Here
825	\|\| __put_user(req32.type, &request->type))	806	\|\| __put_user(req32.type, &request->type))
826	return -EFAULT;	807	return -EFAULT;
827		808
828	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	809	err = psb_drm_ioctl(file, DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
829	DRM_IOCTL_AGP_ALLOC, (unsigned long)request);
830	if (err)	810	if (err)
831	return err;	811	return err;
832		812
833	if (__get_user(req32.handle, &request->handle)	813	if (__get_user(req32.handle, &request->handle)
834	\|\| __get_user(req32.physical, &request->physical)	814	\|\| __get_user(req32.physical, &request->physical)
835	\|\| copy_to_user(argp, &req32, sizeof(req32))) {	815	\|\| copy_to_user(argp, &req32, sizeof(req32))) {
836	psb_drm_ioctl(file->f_dentry->d_inode, file,	816	psb_drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
837	DRM_IOCTL_AGP_FREE, (unsigned long)request);
838	return -EFAULT;	817	return -EFAULT;
839	}	818	}
840		819
Lines 854-861 Link Here
854	\|\| __put_user(handle, &request->handle))	833	\|\| __put_user(handle, &request->handle))
855	return -EFAULT;	834	return -EFAULT;
856		835
857	return psb_drm_ioctl(file->f_dentry->d_inode, file,	836	return psb_drm_ioctl(file, DRM_IOCTL_AGP_FREE, (unsigned long)request);
858	DRM_IOCTL_AGP_FREE, (unsigned long)request);
859	}	837	}
860		838
861	typedef struct drm_agp_binding32 {	839	typedef struct drm_agp_binding32 {
Lines 879-886 Link Here
879	\|\| __put_user(req32.offset, &request->offset))	857	\|\| __put_user(req32.offset, &request->offset))
880	return -EFAULT;	858	return -EFAULT;
881		859
882	return psb_drm_ioctl(file->f_dentry->d_inode, file,	860	return psb_drm_ioctl(file, DRM_IOCTL_AGP_BIND, (unsigned long)request);
883	DRM_IOCTL_AGP_BIND, (unsigned long)request);
884	}	861	}
885		862
886	static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,	863	static int compat_drm_agp_unbind(struct file *file, unsigned int cmd,
Lines 896-903 Link Here
896	\|\| __put_user(handle, &request->handle))	873	\|\| __put_user(handle, &request->handle))
897	return -EFAULT;	874	return -EFAULT;
898		875
899	return psb_drm_ioctl(file->f_dentry->d_inode, file,	876	return psb_drm_ioctl(file, DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
900	DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
901	}	877	}
902	#endif /* __OS_HAS_AGP */	878	#endif /* __OS_HAS_AGP */
903		879
Lines 921-928 Link Here
921	\|\| __put_user(x, &request->size))	897	\|\| __put_user(x, &request->size))
922	return -EFAULT;	898	return -EFAULT;
923		899
924	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	900	err = psb_drm_ioctl(file, DRM_IOCTL_SG_ALLOC, (unsigned long)request);
925	DRM_IOCTL_SG_ALLOC, (unsigned long)request);
926	if (err)	901	if (err)
927	return err;	902	return err;
928		903
Lines 948-955 Link Here
948	\|\| __put_user(x << PAGE_SHIFT, &request->handle))	923	\|\| __put_user(x << PAGE_SHIFT, &request->handle))
949	return -EFAULT;	924	return -EFAULT;
950		925
951	return psb_drm_ioctl(file->f_dentry->d_inode, file,	926	return psb_drm_ioctl(file, DRM_IOCTL_SG_FREE, (unsigned long)request);
952	DRM_IOCTL_SG_FREE, (unsigned long)request);
953	}	927	}
954		928
955	struct drm_wait_vblank_request32 {	929	struct drm_wait_vblank_request32 {
Lines 988-995 Link Here
988	\|\| __put_user(req32.request.signal, &request->request.signal))	962	\|\| __put_user(req32.request.signal, &request->request.signal))
989	return -EFAULT;	963	return -EFAULT;
990		964
991	err = psb_drm_ioctl(file->f_dentry->d_inode, file,	965	err = psb_drm_ioctl(file, DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
992	DRM_IOCTL_WAIT_VBLANK, (unsigned long)request);
993	if (err)	966	if (err)
994	return err;	967	return err;
995		968
Lines 1057-1063 Link Here
1057	* than always failing.	1030	* than always failing.
1058	*/	1031	*/
1059	if (nr >= DRM_ARRAY_SIZE(drm_compat_ioctls))	1032	if (nr >= DRM_ARRAY_SIZE(drm_compat_ioctls))
1060	return psb_drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);	1033	return psb_drm_ioctl(filp, cmd, arg);
1061		1034
1062	fn = drm_compat_ioctls[nr];	1035	fn = drm_compat_ioctls[nr];
1063		1036
Lines 1065-1071 Link Here
1065	if (fn != NULL)	1038	if (fn != NULL)
1066	ret = (*fn)(filp, cmd, arg);	1039	ret = (*fn)(filp, cmd, arg);
1067	else	1040	else
1068	ret = psb_drm_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);	1041	ret = psb_drm_ioctl(filp, cmd, arg);
1069	unlock_kernel();	1042	unlock_kernel();
1070		1043
1071	return ret;	1044	return ret;