Attachment #648986 for bug #732298





struct intel_device {
	int idx;
	char *primary_node;
	char *render_node;
	int fd;
	int device_id;
	int open_count;
	int primary_count;
};

static int intel_device_key = -1;

	return fd;
}

static char *find_primary_node(int fd)
{
	struct stat st, primary;
	char buf[128];

	if (fstat(fd, &st))

		return NULL;

	sprintf(buf, "/dev/dri/card%d", (int)(st.st_rdev & 0x7f));
	if (stat(buf, &primary) == 0 &&
	    S_ISCHR(primary.st_mode) &&
	    (st.st_rdev & 0x7f) == primary.st_rdev)
		return strdup(buf);

	/* Fallback to iterating over the usual suspects */


static char *find_render_node(int fd)
{
	struct stat primary, render;
	char buf[128];
	int i;

	/* Are we a render-node ourselves? */
	if (is_render_node(fd, &primary))
		return NULL;

	sprintf(buf, "/dev/dri/renderD%d", (int)((primary.st_rdev | 0x80) & 0xbf));
	if (stat(buf, &render) == 0 &&
	    S_ISCHR(render.st_mode) &&
	    render.st_rdev == (primary.st_rdev | 0x80))
		return strdup(buf);

	/* Misaligned card <-> renderD, do a full search */

		sprintf(buf, "/dev/dri/renderD%d", i + 128);
		if (stat(buf, &render) == 0 &&
		    S_ISCHR(render.st_mode) &&
		    render.st_rdev == (primary.st_rdev | 0x80))
			return strdup(buf);
	}


}
#endif

static int is_primary(int fd)
{
	drmSetVersion sv;


{
	struct intel_device *dev;
	char *path;
	int fd, primary_count;

	if (intel_device_key == -1)
		intel_device_key = xf86AllocateEntityPrivateIndex();


	path = get_path(platform);

	primary_count = 1; /* DRM_MASTER is managed by Xserver */
	fd = get_fd(platform);
	if (fd == -1) {
		fd = __intel_open_device(pci, path);
		if (fd == -1)
			goto err_path;

		primary_count = 0;
	}

	if (path == NULL) {
		path = find_primary_node(fd);
		if (path == NULL)
			goto err_close;
	}

	if (dev == NULL)
		goto err_close;

	/* If hosted under a system compositor, just pretend to be primary */
	if (hosted())
		primary_count++;

	/* Non-root user holding MASTER, don't let go */
	if (geteuid() && is_primary(fd))
		primary_count++;

	if (pci)
		dev->device_id = pci->device_id;


	dev->idx = entity_num;
	dev->fd = fd;
	dev->open_count = primary_count;
	dev->primary_count = primary_count;
	dev->primary_node = path;
	dev->render_node = find_render_node(fd);
	if (dev->render_node == NULL)
		dev->render_node = dev->primary_node;

	xf86GetEntityPrivate(entity_num, intel_device_key)->ptr = dev;

	return fd;

err_close:
	if (primary_count == 0) /* Don't close server-fds */
		close(fd);
err_path:
	free(path);

	if (!dev)
		return;

	if (dev->primary_count == 0) /* Don't close server-fds */
		close(dev->fd);

	if (dev->render_node != dev->primary_node)
		free(dev->render_node);
	free(dev->primary_node);
	free(dev);
}



		assert(!hosted());

		/* Check that what we opened was a primary or a
		 * primary-capable FD, by setting the version of the
		 * interface we'll use to talk to it.
		 */
		do {

	return dev;
}

const char *intel_get_primary_name(struct intel_device *dev)
{
	assert(dev && dev->primary_node);
	return dev->primary_node;
}

const char *intel_get_client_name(struct intel_device *dev)

	return dev->device_id;
}

int intel_get_primary(struct intel_device *dev)
{
	int ret;

	assert(dev && dev->fd != -1);

	ret = 0;
	if (dev->primary_count++ == 0) {
		int retry = 2000;

		assert(!hosted());

	return ret;
}

int intel_put_primary(struct intel_device *dev)
{
	int ret;

	assert(dev && dev->fd != -1);

	ret = 0;
	assert(dev->primary_count);
	if (--dev->primary_count == 0) {
		assert(!hosted());
		assert(drmSetMaster(dev->fd) == 0);
		ret = drmDropMaster(dev->fd);

	xf86GetEntityPrivate(dev->idx, intel_device_key)->ptr = NULL;

	drmClose(dev->fd);
	if (dev->render_node != dev->primary_node)
		free(dev->render_node);
	free(dev->primary_node);
	free(dev);
}




int __intel_peek_fd(ScrnInfoPtr scrn);
struct intel_device *intel_get_device(ScrnInfoPtr scrn, int *fd);
int intel_has_render_node(struct intel_device *dev);
const char *intel_get_primary_name(struct intel_device *dev);
const char *intel_get_client_name(struct intel_device *dev);
int intel_get_client_fd(struct intel_device *dev);
int intel_get_device_id(struct intel_device *dev);
int intel_get_primary(struct intel_device *dev);
int intel_put_primary(struct intel_device *dev);
void intel_put_device(struct intel_device *dev);

void intel_detect_chipset(ScrnInfoPtr scrn, struct intel_device *dev);

Lines 816-822 Link Here

(-)a/src/intel_module.c (-1 / +1 lines)
816	if (intel_open_device(entity_num, dev->pdev, dev) == -1)	816	if (intel_open_device(entity_num, dev->pdev, dev) == -1)
817	return FALSE;	817	return FALSE;
818		818
819	/* Allow ourselves to act as a slaved output if not primary */	819	/* Allow ourselves to act as a secondaryd output if not primary */
820	if (flags & PLATFORM_PROBE_GPU_SCREEN) {	820	if (flags & PLATFORM_PROBE_GPU_SCREEN) {
821	flags &= ~PLATFORM_PROBE_GPU_SCREEN;	821	flags &= ~PLATFORM_PROBE_GPU_SCREEN;
822	scrn_flags \|= XF86_ALLOCATE_GPU_SCREEN;	822	scrn_flags \|= XF86_ALLOCATE_GPU_SCREEN;





#ifdef CREATE_PIXMAP_USAGE_SHARED
static Bool
sna_share_pixmap_backing(PixmapPtr pixmap, ScreenPtr secondary, void **fd_handle)
{
	struct sna *sna = to_sna_from_pixmap(pixmap);
	struct sna_pixmap *priv;

	sna->timer_active &= ~(1<<id);
}

static bool has_offload_secondarys(struct sna *sna)
{
#if HAS_PIXMAP_SHARING
	ScreenPtr screen = to_screen_from_sna(sna);

{
	struct sna_pixmap *scanout;

	if (has_offload_secondarys(sna)) {
		DBG(("%s: has offload secondarys\n", __FUNCTION__));
		return true;
	}



static bool stop_flush(struct sna *sna, struct sna_pixmap *scanout)
{
	DBG(("%s: scanout=%d shadow?=%d, secondarys?=%d, (cpu?=%d || gpu?=%d))\n",
	     __FUNCTION__,
	     scanout && scanout->gpu_bo ? scanout->gpu_bo->handle : 0,
	     has_shadow(sna), has_offload_secondarys(sna),
	     scanout && scanout->cpu_damage != NULL,
	     scanout && scanout->gpu_bo && scanout->gpu_bo->rq != NULL));

	if (has_offload_secondarys(sna))
		return true;

	if (has_shadow(sna))

#else
		src = dirty->src;
#endif
		dst = dirty->secondary_dst->primary_pixmap;

		region.extents.x1 = dirty->x;
		region.extents.x2 = dirty->x + dst->drawable.width;

		region.extents.y2 = dirty->y + dst->drawable.height;
		region.data = NULL;

		DBG(("%s: pushing damage ((%d, %d), (%d, %d))x%d to secondary pixmap=%d, ((%d, %d), (%d, %d))\n", __FUNCTION__,
		     damage->extents.x1, damage->extents.y1,
		     damage->extents.x2, damage->extents.y2,
		     region_num_rects(damage),

		dy += dirty->dst_y;
#endif
		RegionTranslate(&region, dx, dy);
		DamageRegionAppend(&dirty->secondary_dst->drawable, &region);

		DBG(("%s: secondary:  ((%d, %d), (%d, %d))x%d\n", __FUNCTION__,
		     region.extents.x1, region.extents.y1,
		     region.extents.x2, region.extents.y2,
		     region_num_rects(&region)));

						    box, n, COPY_LAST))
				goto fallback;

			/* Before signalling the secondary via ProcessPending,
			 * ensure not only the batch is submitted as the
			 * secondary may be using the Damage callback to perform
			 * its copy, but also that the memory must be coherent
			 * - we need to treat it as uncached for the PCI secondary
			 * will bypass LLC.
			 */
			kgem_bo_sync__gtt(&sna->kgem, __sna_pixmap_get_bo(dst));
		}

		DamageRegionProcessPending(&dirty->secondary_dst->drawable);
skip:
		RegionUninit(&region);
		DamageEmpty(dirty->damage);




	uint32_t id;
	xf86CrtcPtr base;
	struct drm_mode_modeinfo kmode;
	PixmapPtr secondary_pixmap;
	DamagePtr secondary_damage;
	struct kgem_bo *bo, *shadow_bo, *client_bo, *cache_bo;
	struct sna_cursor *cursor;
	unsigned int last_cursor_size;


	assert(bo->tiling != I915_TILING_Y || sna->kgem.can_scanout_y);
	assert((bo->pitch & 63) == 0);
	assert(scrn->vtSema); /* must be primary */

	VG_CLEAR(arg);
	arg.width = width;

	VG_CLEAR(arg);
	arg.crtc_id = __sna_crtc_id(sna_crtc);
	arg.fb_id = fb_id(sna_crtc->bo);
	if (sna_crtc->transform || sna_crtc->secondary_pixmap) {
		arg.x = 0;
		arg.y = 0;
		sna_crtc->offset = 0;

	sna->mode.shadow_dirty = false;
}

static void sna_crtc_secondary_damage(DamagePtr damage, RegionPtr region, void *closure)
{
	struct sna_crtc *crtc = closure;
	struct sna *sna = to_sna(crtc->base->scrn);

	     region_num_rects(region),
	     __sna_crtc_pipe(crtc), crtc->base->x, crtc->base->y));

	assert(crtc->secondary_damage == damage);
	assert(sna->mode.shadow_damage);

	RegionTranslate(region, crtc->base->x, crtc->base->y);

		assert(sna->mode.shadow == NULL);
	}

	if (crtc->secondary_pixmap) {
		assert(crtc->secondary_damage == NULL);

		DBG(("%s: enabling PRIME secondary tracking on CRTC %d [pipe=%d], pixmap=%ld\n",
		     __FUNCTION__, __sna_crtc_id(crtc), __sna_crtc_pipe(crtc), crtc->secondary_pixmap->drawable.serialNumber));
		crtc->secondary_damage = DamageCreate(sna_crtc_secondary_damage, NULL,
						  DamageReportRawRegion, TRUE,
						  to_screen_from_sna(sna),
						  crtc);
		if (crtc->secondary_damage == NULL) {
			if (!--sna->mode.shadow_active)
				sna_mode_disable_shadow(sna);
			return false;
		}

		DamageRegister(&crtc->secondary_pixmap->drawable, crtc->secondary_damage);
	}

	crtc->shadow = true;

	DBG(("%s: disabling for crtc %d\n", __FUNCTION__, __sna_crtc_id(crtc)));
	assert(sna->mode.shadow_active > 0);

	if (crtc->secondary_damage) {
		assert(crtc->secondary_pixmap);
		DamageUnregister(&crtc->secondary_pixmap->drawable, crtc->secondary_damage);
		DamageDestroy(crtc->secondary_damage);
		crtc->secondary_damage = NULL;
	}

	sna_crtc_disable_override(sna, crtc);

		return true;
	}

	if (sna->flags & SNA_TEAR_FREE && to_sna_crtc(crtc)->secondary_pixmap) {
		DBG(("%s: TearFree shadow required\n", __FUNCTION__));
		return true;
	}

			return NULL;
		}

		front = sna_crtc->secondary_pixmap ?: sna->front;
		if (__sna_pixmap_get_bo(front) && !rr_active(crtc)) {
			BoxRec b;


			sna_crtc->shadow_bo = NULL;
		}

		if (sna_crtc->secondary_pixmap) {
			DBG(("%s: attaching to scanout pixmap\n", __FUNCTION__));
			bo = get_scanout_bo(sna, sna_crtc->secondary_pixmap);
			if (bo == NULL) {
				DBG(("%s: failed to pin crtc scanout\n", __FUNCTION__));
				sna_crtc->fallback_shadow = true;

			}

			if (!get_fb(sna, bo,
				    sna_crtc->secondary_pixmap->drawable.width,
				    sna_crtc->secondary_pixmap->drawable.height)) {
				DBG(("%s: failed to bind fb for crtc scanout\n", __FUNCTION__));
				sna_crtc->fallback_shadow = true;
				goto force_shadow;

		if (sna->flags & SNA_TEAR_FREE) {
			RegionRec region;

			assert(sna_crtc->secondary_pixmap == NULL);

			DBG(("%s: enabling TearFree shadow\n", __FUNCTION__));
			region.extents.x1 = 0;

	if (sna_crtc == NULL)
		return FALSE;

	if (pixmap == sna_crtc->secondary_pixmap)
		return TRUE;

	DBG(("%s: CRTC:%d, pipe=%d setting scanout pixmap=%ld\n",

	/* Disable first so that we can unregister the damage tracking */
	sna_crtc_disable_shadow(to_sna(crtc->scrn), sna_crtc);

	sna_crtc->secondary_pixmap = pixmap;

	return TRUE;
}

		if (crtc->bo == NULL)
			continue;
		assert(!crtc->transform);
		assert(!crtc->secondary_pixmap);
		assert(crtc->bo->active_scanout);
		assert(crtc->bo->refcnt >= crtc->bo->active_scanout);
		assert(crtc->flip_bo == NULL);

inline static DrawablePtr crtc_source(xf86CrtcPtr crtc, int16_t *sx, int16_t *sy)
{
	struct sna_crtc *sna_crtc = to_sna_crtc(crtc);
	if (sna_crtc->secondary_pixmap) {
		DBG(("%s: using secondary pixmap=%ld, offset (%d, %d)\n",
		     __FUNCTION__,
		     sna_crtc->secondary_pixmap->drawable.serialNumber,
		 -crtc->x, -crtc->y));
		*sx = -crtc->x;
		*sy = -crtc->y;
		return &sna_crtc->secondary_pixmap->drawable;
	} else {
		DBG(("%s: using Screen pixmap=%ld\n",
		     __FUNCTION__,

		if (crtc->bo == NULL)
			continue;

		if (crtc->secondary_pixmap)
			continue;

		if (crtc->client_bo)

			}
			RegionUninit(&damage);

			if (sna_crtc->secondary_damage)
				DamageEmpty(sna_crtc->secondary_damage);
		}

		RegionEmpty(region);

		RegionUninit(&damage);
		sigio_unblock(sigio);

		if (sna_crtc->secondary_damage)
			DamageEmpty(sna_crtc->secondary_damage);
	}

	if (sna->mode.shadow) {

Lines 3741-3747 Link Here

(-)a/src/sna/sna_dri2.c (-1 / +1 lines)
3741	memset(&info, '\0', sizeof(info));	3741	memset(&info, '\0', sizeof(info));
3742	info.fd = sna->kgem.fd;	3742	info.fd = sna->kgem.fd;
3743	info.driverName = dri_driver_name(sna);	3743	info.driverName = dri_driver_name(sna);
3744	info.deviceName = intel_get_master_name(sna->dev);	3744	info.deviceName = intel_get_primary_name(sna->dev);
3745		3745
3746	DBG(("%s: loading dri driver '%s' [gen=%d] for device '%s'\n",	3746	DBG(("%s: loading dri driver '%s' [gen=%d] for device '%s'\n",
3747	__FUNCTION__, info.driverName, sna->kgem.gen, info.deviceName));	3747	__FUNCTION__, info.driverName, sna->kgem.gen, info.deviceName));





	sna_mode_set_primary(sna);

	/* Try to become primary and copy the current fbcon before the
	 * actual VT switch. If we fail here, we will try to reset the
	 * mode in the eventual VT switch. This can fail if systemd has
	 * already revoked our KMS privileges, so just carry on regardless,
	 * and hope that everything is sorted after the VT switch.
	 */
	if (intel_get_primary(sna->dev) == 0) {
		/* Only preserve the fbcon, not any subsequent server regens */
		if (serverGeneration == 1 && (sna->flags & SNA_IS_HOSTED) == 0)
			sna_copy_fbcon(sna);

	sna_mode_reset(sna);
	sna_accel_leave(sna);

	if (scrn->vtSema && intel_put_primary(sna->dev))
		xf86DrvMsg(scrn->scrnIndex, X_WARNING,
			   "drmDropMaster failed: %s\n", strerror(errno));


	}

	if (scrn->vtSema) {
		intel_put_primary(sna->dev);
		scrn->vtSema = FALSE;
	}


	struct sna *sna = to_sna(scrn);

	DBG(("%s(vtSema=%d)\n", __FUNCTION__, scrn->vtSema));
	if (intel_get_primary(sna->dev))
		return FALSE;

	scrn->vtSema = TRUE;

Lines 58-64 Link Here

(-)a/src/sna/sna_threads.c (-1 / +1 lines)
58	struct thread *t = arg;	58	struct thread *t = arg;
59	sigset_t signals;	59	sigset_t signals;
60		60
61	/* Disable all signals in the slave threads as X uses them for IO */	61	/* Disable all signals in the secondary threads as X uses them for IO */
62	sigfillset(&signals);	62	sigfillset(&signals);
63	sigdelset(&signals, SIGBUS);	63	sigdelset(&signals, SIGBUS);
64	sigdelset(&signals, SIGSEGV);	64	sigdelset(&signals, SIGSEGV);




	}
}

static Bool intel_open_drm_primary(ScrnInfoPtr scrn)
{
	intel_screen_private *intel = intel_get_screen_private(scrn);
	intel->dev = intel_get_device(scrn, &intel->drmSubFD);


	scrn->displayWidth = 640;	/* default it */

	if (!intel_open_drm_primary(scrn)) {
		xf86DrvMsg(scrn->scrnIndex, X_ERROR,
			   "Failed to become DRM primary.\n");
		return FALSE;
	}


	RegionRec pixregion;
	int was_blocked;

	PixmapRegionInit(&pixregion, dirty->secondary_dst->primary_pixmap);
	RegionTranslate(&pixregion, dirty->x, dirty->y);
	RegionIntersect(&pixregion, &pixregion, DamageRegion(dirty->damage));
	RegionTranslate(&pixregion, -dirty->x, -dirty->y);
	was_blocked = RegionNil(&pixregion);
	DamageRegionAppend(&dirty->secondary_dst->drawable, &pixregion);
	RegionUninit(&pixregion);
	if (was_blocked)
		return;

	PixmapRegionInit(&pixregion, dirty->secondary_dst->primary_pixmap);
	PixmapSyncDirtyHelper(dirty, &pixregion);
	RegionUninit(&pixregion);

        intel_flush(intel);
	if (!intel->has_prime_vmap_flush) {
		drm_intel_bo *bo = intel_uxa_get_pixmap_bo(dirty->secondary_dst->primary_pixmap);
		was_blocked = xf86BlockSIGIO();
		drm_intel_bo_map(bo, FALSE);
		drm_intel_bo_unmap(bo);
		xf86UnblockSIGIO(was_blocked);
	}

	DamageRegionProcessPending(&dirty->secondary_dst->drawable);
	return;
}



	xf86_hide_cursors(scrn);

	if (intel_put_primary(intel->dev))
		xf86DrvMsg(scrn->scrnIndex, X_WARNING,
			   "drmDropMaster failed: %s\n", strerror(errno));
}

	SCRN_INFO_PTR(arg);
	intel_screen_private *intel = intel_get_screen_private(scrn);

	if (intel_get_primary(intel->dev)) {
		xf86DrvMsg(scrn->scrnIndex, X_WARNING,
			   "drmSetMaster failed: %s\n",
			   strerror(errno));

Lines 1136-1142 Link Here

(-)a/src/uxa/intel_uxa.c (-1 / +1 lines)
1136		1136
1137	#ifdef CREATE_PIXMAP_USAGE_SHARED	1137	#ifdef CREATE_PIXMAP_USAGE_SHARED
1138	static Bool	1138	static Bool
1139	intel_uxa_share_pixmap_backing(PixmapPtr ppix, ScreenPtr slave, void **fd_handle)	1139	intel_uxa_share_pixmap_backing(PixmapPtr ppix, ScreenPtr secondary, void **fd_handle)
1140	{	1140	{
1141	ScrnInfoPtr scrn = xf86ScreenToScrn(ppix->drawable.pScreen);	1141	ScrnInfoPtr scrn = xf86ScreenToScrn(ppix->drawable.pScreen);
1142	intel_screen_private *intel = intel_get_screen_private(scrn);	1142	intel_screen_private *intel = intel_get_screen_private(scrn);

Return to bug 732298

Lines 1108-1114 Link Here

(-)a/src/sna/sna_accel.c (-15 / +15 lines)
1108		1108
1109	#ifdef CREATE_PIXMAP_USAGE_SHARED	1109	#ifdef CREATE_PIXMAP_USAGE_SHARED
1110	static Bool	1110	static Bool
1111	sna_share_pixmap_backing(PixmapPtr pixmap, ScreenPtr slave, void **fd_handle)	1111	sna_share_pixmap_backing(PixmapPtr pixmap, ScreenPtr secondary, void **fd_handle)
1112	{	1112	{
1113	struct sna *sna = to_sna_from_pixmap(pixmap);	1113	struct sna *sna = to_sna_from_pixmap(pixmap);
1114	struct sna_pixmap *priv;	1114	struct sna_pixmap *priv;
Lines 17519-17525 Link Here
17519	sna->timer_active &= ~(1<<id);	17519	sna->timer_active &= ~(1<<id);
17520	}	17520	}
17521		17521
17522	static bool has_offload_slaves(struct sna *sna)	17522	static bool has_offload_secondarys(struct sna *sna)
17523	{	17523	{
17524	#if HAS_PIXMAP_SHARING	17524	#if HAS_PIXMAP_SHARING
17525	ScreenPtr screen = to_screen_from_sna(sna);	17525	ScreenPtr screen = to_screen_from_sna(sna);
Lines 17560-17567 Link Here
17560	{	17560	{
17561	struct sna_pixmap *scanout;	17561	struct sna_pixmap *scanout;
17562		17562
17563	if (has_offload_slaves(sna)) {	17563	if (has_offload_secondarys(sna)) {
17564	DBG(("%s: has offload slaves\n", __FUNCTION__));	17564	DBG(("%s: has offload secondarys\n", __FUNCTION__));
17565	return true;	17565	return true;
17566	}	17566	}
17567		17567
Lines 17588-17601 Link Here
17588		17588
17589	static bool stop_flush(struct sna sna, struct sna_pixmap scanout)	17589	static bool stop_flush(struct sna sna, struct sna_pixmap scanout)
17590	{	17590	{
17591	DBG(("%s: scanout=%d shadow?=%d, slaves?=%d, (cpu?=%d \|\| gpu?=%d))\n",	17591	DBG(("%s: scanout=%d shadow?=%d, secondarys?=%d, (cpu?=%d \|\| gpu?=%d))\n",
17592	__FUNCTION__,	17592	__FUNCTION__,
17593	scanout && scanout->gpu_bo ? scanout->gpu_bo->handle : 0,	17593	scanout && scanout->gpu_bo ? scanout->gpu_bo->handle : 0,
17594	has_shadow(sna), has_offload_slaves(sna),	17594	has_shadow(sna), has_offload_secondarys(sna),
17595	scanout && scanout->cpu_damage != NULL,	17595	scanout && scanout->cpu_damage != NULL,
17596	scanout && scanout->gpu_bo && scanout->gpu_bo->rq != NULL));	17596	scanout && scanout->gpu_bo && scanout->gpu_bo->rq != NULL));
17597		17597
17598	if (has_offload_slaves(sna))	17598	if (has_offload_secondarys(sna))
17599	return true;	17599	return true;
17600		17600
17601	if (has_shadow(sna))	17601	if (has_shadow(sna))
Lines 17696-17702 Link Here
17696	#else	17696	#else
17697	src = dirty->src;	17697	src = dirty->src;
17698	#endif	17698	#endif
17699	dst = dirty->slave_dst->master_pixmap;	17699	dst = dirty->secondary_dst->primary_pixmap;
17700		17700
17701	region.extents.x1 = dirty->x;	17701	region.extents.x1 = dirty->x;
17702	region.extents.x2 = dirty->x + dst->drawable.width;	17702	region.extents.x2 = dirty->x + dst->drawable.width;
Lines 17704-17710 Link Here
17704	region.extents.y2 = dirty->y + dst->drawable.height;	17704	region.extents.y2 = dirty->y + dst->drawable.height;
17705	region.data = NULL;	17705	region.data = NULL;
17706		17706
17707	DBG(("%s: pushing damage ((%d, %d), (%d, %d))x%d to slave pixmap=%d, ((%d, %d), (%d, %d))\n", __FUNCTION__,	17707	DBG(("%s: pushing damage ((%d, %d), (%d, %d))x%d to secondary pixmap=%d, ((%d, %d), (%d, %d))\n", __FUNCTION__,
17708	damage->extents.x1, damage->extents.y1,	17708	damage->extents.x1, damage->extents.y1,
17709	damage->extents.x2, damage->extents.y2,	17709	damage->extents.x2, damage->extents.y2,
17710	region_num_rects(damage),	17710	region_num_rects(damage),
Lines 17723-17731 Link Here
17723	dy += dirty->dst_y;	17723	dy += dirty->dst_y;
17724	#endif	17724	#endif
17725	RegionTranslate(&region, dx, dy);	17725	RegionTranslate(&region, dx, dy);
17726	DamageRegionAppend(&dirty->slave_dst->drawable, &region);	17726	DamageRegionAppend(&dirty->secondary_dst->drawable, &region);
17727		17727
17728	DBG(("%s: slave: ((%d, %d), (%d, %d))x%d\n", __FUNCTION__,	17728	DBG(("%s: secondary: ((%d, %d), (%d, %d))x%d\n", __FUNCTION__,
17729	region.extents.x1, region.extents.y1,	17729	region.extents.x1, region.extents.y1,
17730	region.extents.x2, region.extents.y2,	17730	region.extents.x2, region.extents.y2,
17731	region_num_rects(&region)));	17731	region_num_rects(&region)));
Lines 17790-17806 Link Here
17790	box, n, COPY_LAST))	17790	box, n, COPY_LAST))
17791	goto fallback;	17791	goto fallback;
17792		17792
17793	/* Before signalling the slave via ProcessPending,	17793	/* Before signalling the secondary via ProcessPending,
17794	* ensure not only the batch is submitted as the	17794	* ensure not only the batch is submitted as the
17795	* slave may be using the Damage callback to perform	17795	* secondary may be using the Damage callback to perform
17796	* its copy, but also that the memory must be coherent	17796	* its copy, but also that the memory must be coherent
17797	* - we need to treat it as uncached for the PCI slave	17797	* - we need to treat it as uncached for the PCI secondary
17798	* will bypass LLC.	17798	* will bypass LLC.
17799	*/	17799	*/
17800	kgem_bo_sync__gtt(&sna->kgem, __sna_pixmap_get_bo(dst));	17800	kgem_bo_sync__gtt(&sna->kgem, __sna_pixmap_get_bo(dst));
17801	}	17801	}
17802		17802
17803	DamageRegionProcessPending(&dirty->slave_dst->drawable);	17803	DamageRegionProcessPending(&dirty->secondary_dst->drawable);
17804	skip:	17804	skip:
17805	RegionUninit(&region);	17805	RegionUninit(&region);
17806	DamageEmpty(dirty->damage);	17806	DamageEmpty(dirty->damage);

Lines 195-202 Link Here

(-)a/src/sna/sna_display.c (-37 / +37 lines)
195	uint32_t id;	195	uint32_t id;
196	xf86CrtcPtr base;	196	xf86CrtcPtr base;
197	struct drm_mode_modeinfo kmode;	197	struct drm_mode_modeinfo kmode;
198	PixmapPtr slave_pixmap;	198	PixmapPtr secondary_pixmap;
199	DamagePtr slave_damage;	199	DamagePtr secondary_damage;
200	struct kgem_bo bo, shadow_bo, client_bo, cache_bo;	200	struct kgem_bo bo, shadow_bo, client_bo, cache_bo;
201	struct sna_cursor *cursor;	201	struct sna_cursor *cursor;
202	unsigned int last_cursor_size;	202	unsigned int last_cursor_size;
Lines 617-623 Link Here
617		617
618	assert(bo->tiling != I915_TILING_Y \|\| sna->kgem.can_scanout_y);	618	assert(bo->tiling != I915_TILING_Y \|\| sna->kgem.can_scanout_y);
619	assert((bo->pitch & 63) == 0);	619	assert((bo->pitch & 63) == 0);
620	assert(scrn->vtSema); /* must be master */	620	assert(scrn->vtSema); /* must be primary */
621		621
622	VG_CLEAR(arg);	622	VG_CLEAR(arg);
623	arg.width = width;	623	arg.width = width;
Lines 1604-1610 Link Here
1604	VG_CLEAR(arg);	1604	VG_CLEAR(arg);
1605	arg.crtc_id = __sna_crtc_id(sna_crtc);	1605	arg.crtc_id = __sna_crtc_id(sna_crtc);
1606	arg.fb_id = fb_id(sna_crtc->bo);	1606	arg.fb_id = fb_id(sna_crtc->bo);
1607	if (sna_crtc->transform \|\| sna_crtc->slave_pixmap) {	1607	if (sna_crtc->transform \|\| sna_crtc->secondary_pixmap) {
1608	arg.x = 0;	1608	arg.x = 0;
1609	arg.y = 0;	1609	arg.y = 0;
1610	sna_crtc->offset = 0;	1610	sna_crtc->offset = 0;
Lines 2021-2027 Link Here
2021	sna->mode.shadow_dirty = false;	2021	sna->mode.shadow_dirty = false;
2022	}	2022	}
2023		2023
2024	static void sna_crtc_slave_damage(DamagePtr damage, RegionPtr region, void *closure)	2024	static void sna_crtc_secondary_damage(DamagePtr damage, RegionPtr region, void *closure)
2025	{	2025	{
2026	struct sna_crtc *crtc = closure;	2026	struct sna_crtc *crtc = closure;
2027	struct sna *sna = to_sna(crtc->base->scrn);	2027	struct sna *sna = to_sna(crtc->base->scrn);
Lines 2033-2039 Link Here
2033	region_num_rects(region),	2033	region_num_rects(region),
2034	__sna_crtc_pipe(crtc), crtc->base->x, crtc->base->y));	2034	__sna_crtc_pipe(crtc), crtc->base->x, crtc->base->y));
2035		2035
2036	assert(crtc->slave_damage == damage);	2036	assert(crtc->secondary_damage == damage);
2037	assert(sna->mode.shadow_damage);	2037	assert(sna->mode.shadow_damage);
2038		2038
2039	RegionTranslate(region, crtc->base->x, crtc->base->y);	2039	RegionTranslate(region, crtc->base->x, crtc->base->y);
Lines 2058-2079 Link Here
2058	assert(sna->mode.shadow == NULL);	2058	assert(sna->mode.shadow == NULL);
2059	}	2059	}
2060		2060
2061	if (crtc->slave_pixmap) {	2061	if (crtc->secondary_pixmap) {
2062	assert(crtc->slave_damage == NULL);	2062	assert(crtc->secondary_damage == NULL);
2063		2063
2064	DBG(("%s: enabling PRIME slave tracking on CRTC %d [pipe=%d], pixmap=%ld\n",	2064	DBG(("%s: enabling PRIME secondary tracking on CRTC %d [pipe=%d], pixmap=%ld\n",
2065	__FUNCTION__, __sna_crtc_id(crtc), __sna_crtc_pipe(crtc), crtc->slave_pixmap->drawable.serialNumber));	2065	__FUNCTION__, __sna_crtc_id(crtc), __sna_crtc_pipe(crtc), crtc->secondary_pixmap->drawable.serialNumber));
2066	crtc->slave_damage = DamageCreate(sna_crtc_slave_damage, NULL,	2066	crtc->secondary_damage = DamageCreate(sna_crtc_secondary_damage, NULL,
2067	DamageReportRawRegion, TRUE,	2067	DamageReportRawRegion, TRUE,
2068	to_screen_from_sna(sna),	2068	to_screen_from_sna(sna),
2069	crtc);	2069	crtc);
2070	if (crtc->slave_damage == NULL) {	2070	if (crtc->secondary_damage == NULL) {
2071	if (!--sna->mode.shadow_active)	2071	if (!--sna->mode.shadow_active)
2072	sna_mode_disable_shadow(sna);	2072	sna_mode_disable_shadow(sna);
2073	return false;	2073	return false;
2074	}	2074	}
2075		2075
2076	DamageRegister(&crtc->slave_pixmap->drawable, crtc->slave_damage);	2076	DamageRegister(&crtc->secondary_pixmap->drawable, crtc->secondary_damage);
2077	}	2077	}
2078		2078
2079	crtc->shadow = true;	2079	crtc->shadow = true;
Lines 2116-2126 Link Here
2116	DBG(("%s: disabling for crtc %d\n", __FUNCTION__, __sna_crtc_id(crtc)));	2116	DBG(("%s: disabling for crtc %d\n", __FUNCTION__, __sna_crtc_id(crtc)));
2117	assert(sna->mode.shadow_active > 0);	2117	assert(sna->mode.shadow_active > 0);
2118		2118
2119	if (crtc->slave_damage) {	2119	if (crtc->secondary_damage) {
2120	assert(crtc->slave_pixmap);	2120	assert(crtc->secondary_pixmap);
2121	DamageUnregister(&crtc->slave_pixmap->drawable, crtc->slave_damage);	2121	DamageUnregister(&crtc->secondary_pixmap->drawable, crtc->secondary_damage);
2122	DamageDestroy(crtc->slave_damage);	2122	DamageDestroy(crtc->secondary_damage);
2123	crtc->slave_damage = NULL;	2123	crtc->secondary_damage = NULL;
2124	}	2124	}
2125		2125
2126	sna_crtc_disable_override(sna, crtc);	2126	sna_crtc_disable_override(sna, crtc);
Lines 2392-2398 Link Here
2392	return true;	2392	return true;
2393	}	2393	}
2394		2394
2395	if (sna->flags & SNA_TEAR_FREE && to_sna_crtc(crtc)->slave_pixmap) {	2395	if (sna->flags & SNA_TEAR_FREE && to_sna_crtc(crtc)->secondary_pixmap) {
2396	DBG(("%s: TearFree shadow required\n", __FUNCTION__));	2396	DBG(("%s: TearFree shadow required\n", __FUNCTION__));
2397	return true;	2397	return true;
2398	}	2398	}
Lines 2659-2665 Link Here
2659	return NULL;	2659	return NULL;
2660	}	2660	}
2661		2661
2662	front = sna_crtc->slave_pixmap ?: sna->front;	2662	front = sna_crtc->secondary_pixmap ?: sna->front;
2663	if (__sna_pixmap_get_bo(front) && !rr_active(crtc)) {	2663	if (__sna_pixmap_get_bo(front) && !rr_active(crtc)) {
2664	BoxRec b;	2664	BoxRec b;
2665		2665
Lines 2717-2725 Link Here
2717	sna_crtc->shadow_bo = NULL;	2717	sna_crtc->shadow_bo = NULL;
2718	}	2718	}
2719		2719
2720	if (sna_crtc->slave_pixmap) {	2720	if (sna_crtc->secondary_pixmap) {
2721	DBG(("%s: attaching to scanout pixmap\n", __FUNCTION__));	2721	DBG(("%s: attaching to scanout pixmap\n", __FUNCTION__));
2722	bo = get_scanout_bo(sna, sna_crtc->slave_pixmap);	2722	bo = get_scanout_bo(sna, sna_crtc->secondary_pixmap);
2723	if (bo == NULL) {	2723	if (bo == NULL) {
2724	DBG(("%s: failed to pin crtc scanout\n", __FUNCTION__));	2724	DBG(("%s: failed to pin crtc scanout\n", __FUNCTION__));
2725	sna_crtc->fallback_shadow = true;	2725	sna_crtc->fallback_shadow = true;
Lines 2727-2734 Link Here
2727	}	2727	}
2728		2728
2729	if (!get_fb(sna, bo,	2729	if (!get_fb(sna, bo,
2730	sna_crtc->slave_pixmap->drawable.width,	2730	sna_crtc->secondary_pixmap->drawable.width,
2731	sna_crtc->slave_pixmap->drawable.height)) {	2731	sna_crtc->secondary_pixmap->drawable.height)) {
2732	DBG(("%s: failed to bind fb for crtc scanout\n", __FUNCTION__));	2732	DBG(("%s: failed to bind fb for crtc scanout\n", __FUNCTION__));
2733	sna_crtc->fallback_shadow = true;	2733	sna_crtc->fallback_shadow = true;
2734	goto force_shadow;	2734	goto force_shadow;
Lines 2752-2758 Link Here
2752	if (sna->flags & SNA_TEAR_FREE) {	2752	if (sna->flags & SNA_TEAR_FREE) {
2753	RegionRec region;	2753	RegionRec region;
2754		2754
2755	assert(sna_crtc->slave_pixmap == NULL);	2755	assert(sna_crtc->secondary_pixmap == NULL);
2756		2756
2757	DBG(("%s: enabling TearFree shadow\n", __FUNCTION__));	2757	DBG(("%s: enabling TearFree shadow\n", __FUNCTION__));
2758	region.extents.x1 = 0;	2758	region.extents.x1 = 0;
Lines 3286-3292 Link Here
3286	if (sna_crtc == NULL)	3286	if (sna_crtc == NULL)
3287	return FALSE;	3287	return FALSE;
3288		3288
3289	if (pixmap == sna_crtc->slave_pixmap)	3289	if (pixmap == sna_crtc->secondary_pixmap)
3290	return TRUE;	3290	return TRUE;
3291		3291
3292	DBG(("%s: CRTC:%d, pipe=%d setting scanout pixmap=%ld\n",	3292	DBG(("%s: CRTC:%d, pipe=%d setting scanout pixmap=%ld\n",
Lines 3296-3302 Link Here
3296	/* Disable first so that we can unregister the damage tracking */	3296	/* Disable first so that we can unregister the damage tracking */
3297	sna_crtc_disable_shadow(to_sna(crtc->scrn), sna_crtc);	3297	sna_crtc_disable_shadow(to_sna(crtc->scrn), sna_crtc);
3298		3298
3299	sna_crtc->slave_pixmap = pixmap;	3299	sna_crtc->secondary_pixmap = pixmap;
3300		3300
3301	return TRUE;	3301	return TRUE;
3302	}	3302	}
Lines 7180-7186 Link Here
7180	if (crtc->bo == NULL)	7180	if (crtc->bo == NULL)
7181	continue;	7181	continue;
7182	assert(!crtc->transform);	7182	assert(!crtc->transform);
7183	assert(!crtc->slave_pixmap);	7183	assert(!crtc->secondary_pixmap);
7184	assert(crtc->bo->active_scanout);	7184	assert(crtc->bo->active_scanout);
7185	assert(crtc->bo->refcnt >= crtc->bo->active_scanout);	7185	assert(crtc->bo->refcnt >= crtc->bo->active_scanout);
7186	assert(crtc->flip_bo == NULL);	7186	assert(crtc->flip_bo == NULL);
Lines 8825-8838 Link Here
8825	inline static DrawablePtr crtc_source(xf86CrtcPtr crtc, int16_t sx, int16_t sy)	8825	inline static DrawablePtr crtc_source(xf86CrtcPtr crtc, int16_t sx, int16_t sy)
8826	{	8826	{
8827	struct sna_crtc *sna_crtc = to_sna_crtc(crtc);	8827	struct sna_crtc *sna_crtc = to_sna_crtc(crtc);
8828	if (sna_crtc->slave_pixmap) {	8828	if (sna_crtc->secondary_pixmap) {
8829	DBG(("%s: using slave pixmap=%ld, offset (%d, %d)\n",	8829	DBG(("%s: using secondary pixmap=%ld, offset (%d, %d)\n",
8830	__FUNCTION__,	8830	__FUNCTION__,
8831	sna_crtc->slave_pixmap->drawable.serialNumber,	8831	sna_crtc->secondary_pixmap->drawable.serialNumber,
8832	-crtc->x, -crtc->y));	8832	-crtc->x, -crtc->y));
8833	*sx = -crtc->x;	8833	*sx = -crtc->x;
8834	*sy = -crtc->y;	8834	*sy = -crtc->y;
8835	return &sna_crtc->slave_pixmap->drawable;	8835	return &sna_crtc->secondary_pixmap->drawable;
8836	} else {	8836	} else {
8837	DBG(("%s: using Screen pixmap=%ld\n",	8837	DBG(("%s: using Screen pixmap=%ld\n",
8838	__FUNCTION__,	8838	__FUNCTION__,
Lines 9263-9269 Link Here
9263	if (crtc->bo == NULL)	9263	if (crtc->bo == NULL)
9264	continue;	9264	continue;
9265		9265
9266	if (crtc->slave_pixmap)	9266	if (crtc->secondary_pixmap)
9267	continue;	9267	continue;
9268		9268
9269	if (crtc->client_bo)	9269	if (crtc->client_bo)
Lines 9358-9365 Link Here
9358	}	9358	}
9359	RegionUninit(&damage);	9359	RegionUninit(&damage);
9360		9360
9361	if (sna_crtc->slave_damage)	9361	if (sna_crtc->secondary_damage)
9362	DamageEmpty(sna_crtc->slave_damage);	9362	DamageEmpty(sna_crtc->secondary_damage);
9363	}	9363	}
9364		9364
9365	RegionEmpty(region);	9365	RegionEmpty(region);
Lines 9529-9536 Link Here
9529	RegionUninit(&damage);	9529	RegionUninit(&damage);
9530	sigio_unblock(sigio);	9530	sigio_unblock(sigio);
9531		9531
9532	if (sna_crtc->slave_damage)	9532	if (sna_crtc->secondary_damage)
9533	DamageEmpty(sna_crtc->slave_damage);	9533	DamageEmpty(sna_crtc->secondary_damage);
9534	}	9534	}
9535		9535
9536	if (sna->mode.shadow) {	9536	if (sna->mode.shadow) {

Lines 270-282 Link Here

(-)a/src/sna/sna_driver.c (-5 / +5 lines)
270		270
271	sna_mode_set_primary(sna);	271	sna_mode_set_primary(sna);
272		272
273	/* Try to become master and copy the current fbcon before the	273	/* Try to become primary and copy the current fbcon before the
274	* actual VT switch. If we fail here, we will try to reset the	274	* actual VT switch. If we fail here, we will try to reset the
275	* mode in the eventual VT switch. This can fail if systemd has	275	* mode in the eventual VT switch. This can fail if systemd has
276	* already revoked our KMS privileges, so just carry on regardless,	276	* already revoked our KMS privileges, so just carry on regardless,
277	* and hope that everything is sorted after the VT switch.	277	* and hope that everything is sorted after the VT switch.
278	*/	278	*/
279	if (intel_get_master(sna->dev) == 0) {	279	if (intel_get_primary(sna->dev) == 0) {
280	/* Only preserve the fbcon, not any subsequent server regens */	280	/* Only preserve the fbcon, not any subsequent server regens */
281	if (serverGeneration == 1 && (sna->flags & SNA_IS_HOSTED) == 0)	281	if (serverGeneration == 1 && (sna->flags & SNA_IS_HOSTED) == 0)
282	sna_copy_fbcon(sna);	282	sna_copy_fbcon(sna);
Lines 963-969 Link Here
963	sna_mode_reset(sna);	963	sna_mode_reset(sna);
964	sna_accel_leave(sna);	964	sna_accel_leave(sna);
965		965
966	if (scrn->vtSema && intel_put_master(sna->dev))	966	if (scrn->vtSema && intel_put_primary(sna->dev))
967	xf86DrvMsg(scrn->scrnIndex, X_WARNING,	967	xf86DrvMsg(scrn->scrnIndex, X_WARNING,
968	"drmDropMaster failed: %s\n", strerror(errno));	968	"drmDropMaster failed: %s\n", strerror(errno));
969		969
Lines 1009-1015 Link Here
1009	}	1009	}
1010		1010
1011	if (scrn->vtSema) {	1011	if (scrn->vtSema) {
1012	intel_put_master(sna->dev);	1012	intel_put_primary(sna->dev);
1013	scrn->vtSema = FALSE;	1013	scrn->vtSema = FALSE;
1014	}	1014	}
1015		1015
Lines 1294-1300 Link Here
1294	struct sna *sna = to_sna(scrn);	1294	struct sna *sna = to_sna(scrn);
1295		1295
1296	DBG(("%s(vtSema=%d)\n", __FUNCTION__, scrn->vtSema));	1296	DBG(("%s(vtSema=%d)\n", __FUNCTION__, scrn->vtSema));
1297	if (intel_get_master(sna->dev))	1297	if (intel_get_primary(sna->dev))
1298	return FALSE;	1298	return FALSE;
1299		1299
1300	scrn->vtSema = TRUE;	1300	scrn->vtSema = TRUE;

Lines 257-263 Link Here

(-)a/src/uxa/intel_driver.c (-10 / +10 lines)
257	}	257	}
258	}	258	}
259		259
260	static Bool intel_open_drm_master(ScrnInfoPtr scrn)	260	static Bool intel_open_drm_primary(ScrnInfoPtr scrn)
261	{	261	{
262	intel_screen_private *intel = intel_get_screen_private(scrn);	262	intel_screen_private *intel = intel_get_screen_private(scrn);
263	intel->dev = intel_get_device(scrn, &intel->drmSubFD);	263	intel->dev = intel_get_device(scrn, &intel->drmSubFD);
Lines 473-481 Link Here
473		473
474	scrn->displayWidth = 640; /* default it */	474	scrn->displayWidth = 640; /* default it */
475		475
476	if (!intel_open_drm_master(scrn)) {	476	if (!intel_open_drm_primary(scrn)) {
477	xf86DrvMsg(scrn->scrnIndex, X_ERROR,	477	xf86DrvMsg(scrn->scrnIndex, X_ERROR,
478	"Failed to become DRM master.\n");	478	"Failed to become DRM primary.\n");
479	return FALSE;	479	return FALSE;
480	}	480	}
481		481
Lines 624-653 Link Here
624	RegionRec pixregion;	624	RegionRec pixregion;
625	int was_blocked;	625	int was_blocked;
626		626
627	PixmapRegionInit(&pixregion, dirty->slave_dst->master_pixmap);	627	PixmapRegionInit(&pixregion, dirty->secondary_dst->primary_pixmap);
628	RegionTranslate(&pixregion, dirty->x, dirty->y);	628	RegionTranslate(&pixregion, dirty->x, dirty->y);
629	RegionIntersect(&pixregion, &pixregion, DamageRegion(dirty->damage));	629	RegionIntersect(&pixregion, &pixregion, DamageRegion(dirty->damage));
630	RegionTranslate(&pixregion, -dirty->x, -dirty->y);	630	RegionTranslate(&pixregion, -dirty->x, -dirty->y);
631	was_blocked = RegionNil(&pixregion);	631	was_blocked = RegionNil(&pixregion);
632	DamageRegionAppend(&dirty->slave_dst->drawable, &pixregion);	632	DamageRegionAppend(&dirty->secondary_dst->drawable, &pixregion);
633	RegionUninit(&pixregion);	633	RegionUninit(&pixregion);
634	if (was_blocked)	634	if (was_blocked)
635	return;	635	return;
636		636
637	PixmapRegionInit(&pixregion, dirty->slave_dst->master_pixmap);	637	PixmapRegionInit(&pixregion, dirty->secondary_dst->primary_pixmap);
638	PixmapSyncDirtyHelper(dirty, &pixregion);	638	PixmapSyncDirtyHelper(dirty, &pixregion);
639	RegionUninit(&pixregion);	639	RegionUninit(&pixregion);
640		640
641	intel_flush(intel);	641	intel_flush(intel);
642	if (!intel->has_prime_vmap_flush) {	642	if (!intel->has_prime_vmap_flush) {
643	drm_intel_bo *bo = intel_uxa_get_pixmap_bo(dirty->slave_dst->master_pixmap);	643	drm_intel_bo *bo = intel_uxa_get_pixmap_bo(dirty->secondary_dst->primary_pixmap);
644	was_blocked = xf86BlockSIGIO();	644	was_blocked = xf86BlockSIGIO();
645	drm_intel_bo_map(bo, FALSE);	645	drm_intel_bo_map(bo, FALSE);
646	drm_intel_bo_unmap(bo);	646	drm_intel_bo_unmap(bo);
647	xf86UnblockSIGIO(was_blocked);	647	xf86UnblockSIGIO(was_blocked);
648	}	648	}
649		649
650	DamageRegionProcessPending(&dirty->slave_dst->drawable);	650	DamageRegionProcessPending(&dirty->secondary_dst->drawable);
651	return;	651	return;
652	}	652	}
653		653
Lines 1102-1108 Link Here
1102		1102
1103	xf86_hide_cursors(scrn);	1103	xf86_hide_cursors(scrn);
1104		1104
1105	if (intel_put_master(intel->dev))	1105	if (intel_put_primary(intel->dev))
1106	xf86DrvMsg(scrn->scrnIndex, X_WARNING,	1106	xf86DrvMsg(scrn->scrnIndex, X_WARNING,
1107	"drmDropMaster failed: %s\n", strerror(errno));	1107	"drmDropMaster failed: %s\n", strerror(errno));
1108	}	1108	}
Lines 1115-1121 Link Here
1115	SCRN_INFO_PTR(arg);	1115	SCRN_INFO_PTR(arg);
1116	intel_screen_private *intel = intel_get_screen_private(scrn);	1116	intel_screen_private *intel = intel_get_screen_private(scrn);
1117		1117
1118	if (intel_get_master(intel->dev)) {	1118	if (intel_get_primary(intel->dev)) {
1119	xf86DrvMsg(scrn->scrnIndex, X_WARNING,	1119	xf86DrvMsg(scrn->scrnIndex, X_WARNING,
1120	"drmSetMaster failed: %s\n",	1120	"drmSetMaster failed: %s\n",
1121	strerror(errno));	1121	strerror(errno));

Lines 72-83 Link Here

(-)a/src/intel_device.c (-41 / +41 lines)
72		72
73	struct intel_device {	73	struct intel_device {
74	int idx;	74	int idx;
75	char *master_node;	75	char *primary_node;
76	char *render_node;	76	char *render_node;
77	int fd;	77	int fd;
78	int device_id;	78	int device_id;
79	int open_count;	79	int open_count;
80	int master_count;	80	int primary_count;
81	};	81	};
82		82
83	static int intel_device_key = -1;	83	static int intel_device_key = -1;
Lines 454-462 Link Here
454	return fd;	454	return fd;
455	}	455	}
456		456
457	static char *find_master_node(int fd)	457	static char *find_primary_node(int fd)
458	{	458	{
459	struct stat st, master;	459	struct stat st, primary;
460	char buf[128];	460	char buf[128];
461		461
462	if (fstat(fd, &st))	462	if (fstat(fd, &st))
Lines 466-474 Link Here
466	return NULL;	466	return NULL;
467		467
468	sprintf(buf, "/dev/dri/card%d", (int)(st.st_rdev & 0x7f));	468	sprintf(buf, "/dev/dri/card%d", (int)(st.st_rdev & 0x7f));
469	if (stat(buf, &master) == 0 &&	469	if (stat(buf, &primary) == 0 &&
470	S_ISCHR(master.st_mode) &&	470	S_ISCHR(primary.st_mode) &&
471	(st.st_rdev & 0x7f) == master.st_rdev)	471	(st.st_rdev & 0x7f) == primary.st_rdev)
472	return strdup(buf);	472	return strdup(buf);
473		473
474	/* Fallback to iterating over the usual suspects */	474	/* Fallback to iterating over the usual suspects */
Lines 488-505 Link Here
488		488
489	static char *find_render_node(int fd)	489	static char *find_render_node(int fd)
490	{	490	{
491	struct stat master, render;	491	struct stat primary, render;
492	char buf[128];	492	char buf[128];
493	int i;	493	int i;
494		494
495	/* Are we a render-node ourselves? */	495	/* Are we a render-node ourselves? */
496	if (is_render_node(fd, &master))	496	if (is_render_node(fd, &primary))
497	return NULL;	497	return NULL;
498		498
499	sprintf(buf, "/dev/dri/renderD%d", (int)((master.st_rdev \| 0x80) & 0xbf));	499	sprintf(buf, "/dev/dri/renderD%d", (int)((primary.st_rdev \| 0x80) & 0xbf));
500	if (stat(buf, &render) == 0 &&	500	if (stat(buf, &render) == 0 &&
501	S_ISCHR(render.st_mode) &&	501	S_ISCHR(render.st_mode) &&
502	render.st_rdev == (master.st_rdev \| 0x80))	502	render.st_rdev == (primary.st_rdev \| 0x80))
503	return strdup(buf);	503	return strdup(buf);
504		504
505	/* Misaligned card <-> renderD, do a full search */	505	/* Misaligned card <-> renderD, do a full search */
Lines 507-513 Link Here
507	sprintf(buf, "/dev/dri/renderD%d", i + 128);	507	sprintf(buf, "/dev/dri/renderD%d", i + 128);
508	if (stat(buf, &render) == 0 &&	508	if (stat(buf, &render) == 0 &&
509	S_ISCHR(render.st_mode) &&	509	S_ISCHR(render.st_mode) &&
510	render.st_rdev == (master.st_rdev \| 0x80))	510	render.st_rdev == (primary.st_rdev \| 0x80))
511	return strdup(buf);	511	return strdup(buf);
512	}	512	}
513		513
Lines 555-561 Link Here
555	}	555	}
556	#endif	556	#endif
557		557
558	static int is_master(int fd)	558	static int is_primary(int fd)
559	{	559	{
560	drmSetVersion sv;	560	drmSetVersion sv;
561		561
Lines 573-579 Link Here
573	{	573	{
574	struct intel_device *dev;	574	struct intel_device *dev;
575	char *path;	575	char *path;
576	int fd, master_count;	576	int fd, primary_count;
577		577
578	if (intel_device_key == -1)	578	if (intel_device_key == -1)
579	intel_device_key = xf86AllocateEntityPrivateIndex();	579	intel_device_key = xf86AllocateEntityPrivateIndex();
Lines 586-603 Link Here
586		586
587	path = get_path(platform);	587	path = get_path(platform);
588		588
589	master_count = 1; /* DRM_MASTER is managed by Xserver */	589	primary_count = 1; /* DRM_MASTER is managed by Xserver */
590	fd = get_fd(platform);	590	fd = get_fd(platform);
591	if (fd == -1) {	591	if (fd == -1) {
592	fd = __intel_open_device(pci, path);	592	fd = __intel_open_device(pci, path);
593	if (fd == -1)	593	if (fd == -1)
594	goto err_path;	594	goto err_path;
595		595
596	master_count = 0;	596	primary_count = 0;
597	}	597	}
598		598
599	if (path == NULL) {	599	if (path == NULL) {
600	path = find_master_node(fd);	600	path = find_primary_node(fd);
601	if (path == NULL)	601	if (path == NULL)
602	goto err_close;	602	goto err_close;
603	}	603	}
Lines 609-621 Link Here
609	if (dev == NULL)	609	if (dev == NULL)
610	goto err_close;	610	goto err_close;
611		611
612	/* If hosted under a system compositor, just pretend to be master */	612	/* If hosted under a system compositor, just pretend to be primary */
613	if (hosted())	613	if (hosted())
614	master_count++;	614	primary_count++;
615		615
616	/* Non-root user holding MASTER, don't let go */	616	/* Non-root user holding MASTER, don't let go */
617	if (geteuid() && is_master(fd))	617	if (geteuid() && is_primary(fd))
618	master_count++;	618	primary_count++;
619		619
620	if (pci)	620	if (pci)
621	dev->device_id = pci->device_id;	621	dev->device_id = pci->device_id;
Lines 624-642 Link Here
624		624
625	dev->idx = entity_num;	625	dev->idx = entity_num;
626	dev->fd = fd;	626	dev->fd = fd;
627	dev->open_count = master_count;	627	dev->open_count = primary_count;
628	dev->master_count = master_count;	628	dev->primary_count = primary_count;
629	dev->master_node = path;	629	dev->primary_node = path;
630	dev->render_node = find_render_node(fd);	630	dev->render_node = find_render_node(fd);
631	if (dev->render_node == NULL)	631	if (dev->render_node == NULL)
632	dev->render_node = dev->master_node;	632	dev->render_node = dev->primary_node;
633		633
634	xf86GetEntityPrivate(entity_num, intel_device_key)->ptr = dev;	634	xf86GetEntityPrivate(entity_num, intel_device_key)->ptr = dev;
635		635
636	return fd;	636	return fd;
637		637
638	err_close:	638	err_close:
639	if (master_count == 0) /* Don't close server-fds */	639	if (primary_count == 0) /* Don't close server-fds */
640	close(fd);	640	close(fd);
641	err_path:	641	err_path:
642	free(path);	642	free(path);
Lines 655-666 Link Here
655	if (!dev)	655	if (!dev)
656	return;	656	return;
657		657
658	if (dev->master_count == 0) /* Don't close server-fds */	658	if (dev->primary_count == 0) /* Don't close server-fds */
659	close(dev->fd);	659	close(dev->fd);
660		660
661	if (dev->render_node != dev->master_node)	661	if (dev->render_node != dev->primary_node)
662	free(dev->render_node);	662	free(dev->render_node);
663	free(dev->master_node);	663	free(dev->primary_node);
664	free(dev);	664	free(dev);
665	}	665	}
666		666
Lines 699-706 Link Here
699		699
700	assert(!hosted());	700	assert(!hosted());
701		701
702	/* Check that what we opened was a master or a	702	/* Check that what we opened was a primary or a
703	* master-capable FD, by setting the version of the	703	* primary-capable FD, by setting the version of the
704	* interface we'll use to talk to it.	704	* interface we'll use to talk to it.
705	*/	705	*/
706	do {	706	do {
Lines 728-737 Link Here
728	return dev;	728	return dev;
729	}	729	}
730		730
731	const char intel_get_master_name(struct intel_device dev)	731	const char intel_get_primary_name(struct intel_device dev)
732	{	732	{
733	assert(dev && dev->master_node);	733	assert(dev && dev->primary_node);
734	return dev->master_node;	734	return dev->primary_node;
735	}	735	}
736		736
737	const char intel_get_client_name(struct intel_device dev)	737	const char intel_get_client_name(struct intel_device dev)
Lines 782-795 Link Here
782	return dev->device_id;	782	return dev->device_id;
783	}	783	}
784		784
785	int intel_get_master(struct intel_device *dev)	785	int intel_get_primary(struct intel_device *dev)
786	{	786	{
787	int ret;	787	int ret;
788		788
789	assert(dev && dev->fd != -1);	789	assert(dev && dev->fd != -1);
790		790
791	ret = 0;	791	ret = 0;
792	if (dev->master_count++ == 0) {	792	if (dev->primary_count++ == 0) {
793	int retry = 2000;	793	int retry = 2000;
794		794
795	assert(!hosted());	795	assert(!hosted());
Lines 804-818 Link Here
804	return ret;	804	return ret;
805	}	805	}
806		806
807	int intel_put_master(struct intel_device *dev)	807	int intel_put_primary(struct intel_device *dev)
808	{	808	{
809	int ret;	809	int ret;
810		810
811	assert(dev && dev->fd != -1);	811	assert(dev && dev->fd != -1);
812		812
813	ret = 0;	813	ret = 0;
814	assert(dev->master_count);	814	assert(dev->primary_count);
815	if (--dev->master_count == 0) {	815	if (--dev->primary_count == 0) {
816	assert(!hosted());	816	assert(!hosted());
817	assert(drmSetMaster(dev->fd) == 0);	817	assert(drmSetMaster(dev->fd) == 0);
818	ret = drmDropMaster(dev->fd);	818	ret = drmDropMaster(dev->fd);
Lines 833-840 Link Here
833	xf86GetEntityPrivate(dev->idx, intel_device_key)->ptr = NULL;	833	xf86GetEntityPrivate(dev->idx, intel_device_key)->ptr = NULL;
834		834
835	drmClose(dev->fd);	835	drmClose(dev->fd);
836	if (dev->render_node != dev->master_node)	836	if (dev->render_node != dev->primary_node)
837	free(dev->render_node);	837	free(dev->render_node);
838	free(dev->master_node);	838	free(dev->primary_node);
839	free(dev);	839	free(dev);
840	}	840	}

Lines 128-139 Link Here

(-)a/src/intel_driver.h (-3 / +3 lines)
128	int __intel_peek_fd(ScrnInfoPtr scrn);	128	int __intel_peek_fd(ScrnInfoPtr scrn);
129	struct intel_device intel_get_device(ScrnInfoPtr scrn, int fd);	129	struct intel_device intel_get_device(ScrnInfoPtr scrn, int fd);
130	int intel_has_render_node(struct intel_device *dev);	130	int intel_has_render_node(struct intel_device *dev);
131	const char intel_get_master_name(struct intel_device dev);	131	const char intel_get_primary_name(struct intel_device dev);
132	const char intel_get_client_name(struct intel_device dev);	132	const char intel_get_client_name(struct intel_device dev);
133	int intel_get_client_fd(struct intel_device *dev);	133	int intel_get_client_fd(struct intel_device *dev);
134	int intel_get_device_id(struct intel_device *dev);	134	int intel_get_device_id(struct intel_device *dev);
135	int intel_get_master(struct intel_device *dev);	135	int intel_get_primary(struct intel_device *dev);
136	int intel_put_master(struct intel_device *dev);	136	int intel_put_primary(struct intel_device *dev);
137	void intel_put_device(struct intel_device *dev);	137	void intel_put_device(struct intel_device *dev);
138		138
139	void intel_detect_chipset(ScrnInfoPtr scrn, struct intel_device *dev);	139	void intel_detect_chipset(ScrnInfoPtr scrn, struct intel_device *dev);