8f4640bdb9
So in the cold plug server shutdown case, we reap the resources before we call CloseScreen handlers, so the config->randr_provider is a dangling pointer when the xf86CrtcCloseScreen handler is called, however in the hot screen unplug case, we can't rely on automatically reaped resources, so we need to clean up the provider in the xf86CrtcCloseScreen case. This patch provides a cleanup callback from the randr provider removal into the DDX so it can cleanup properly, this then gets called by the automatic code for cold plug, or if hot unplug it gets called explicitly. Fixes a number of random server crashes on shutdown Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=58174 Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=891140 Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net> Signed-off-by: Dave Airlie <airlied@redhat.com>
419 lines
12 KiB
C
419 lines
12 KiB
C
/*
|
|
* Copyright © 2012 Red Hat Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
* that the name of the copyright holders not be used in advertising or
|
|
* publicity pertaining to distribution of the software without specific,
|
|
* written prior permission. The copyright holders make no representations
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
* is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
* OF THIS SOFTWARE.
|
|
*
|
|
* Authors: Dave Airlie
|
|
*/
|
|
|
|
#include "randrstr.h"
|
|
#include "swaprep.h"
|
|
|
|
RESTYPE RRProviderType;
|
|
|
|
/*
|
|
* Initialize provider type error value
|
|
*/
|
|
void
|
|
RRProviderInitErrorValue(void)
|
|
{
|
|
SetResourceTypeErrorValue(RRProviderType, RRErrorBase + BadRRProvider);
|
|
}
|
|
|
|
#define ADD_PROVIDER(_pScreen) do { \
|
|
pScrPriv = rrGetScrPriv((_pScreen)); \
|
|
if (pScrPriv->provider) { \
|
|
providers[count_providers] = pScrPriv->provider->id; \
|
|
if (client->swapped) \
|
|
swapl(&providers[count_providers]); \
|
|
count_providers++; \
|
|
} \
|
|
} while(0)
|
|
|
|
int
|
|
ProcRRGetProviders (ClientPtr client)
|
|
{
|
|
REQUEST(xRRGetProvidersReq);
|
|
xRRGetProvidersReply rep;
|
|
WindowPtr pWin;
|
|
ScreenPtr pScreen;
|
|
rrScrPrivPtr pScrPriv;
|
|
int rc;
|
|
CARD8 *extra;
|
|
unsigned int extraLen;
|
|
RRProvider *providers;
|
|
int total_providers = 0, count_providers = 0;
|
|
ScreenPtr iter;
|
|
|
|
REQUEST_SIZE_MATCH(xRRGetProvidersReq);
|
|
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
|
|
if (rc != Success)
|
|
return rc;
|
|
|
|
pScreen = pWin->drawable.pScreen;
|
|
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
|
|
if (pScrPriv->provider)
|
|
total_providers++;
|
|
xorg_list_for_each_entry(iter, &pScreen->output_slave_list, output_head) {
|
|
pScrPriv = rrGetScrPriv(iter);
|
|
total_providers += pScrPriv->provider ? 1 : 0;
|
|
}
|
|
xorg_list_for_each_entry(iter, &pScreen->offload_slave_list, offload_head) {
|
|
pScrPriv = rrGetScrPriv(iter);
|
|
total_providers += pScrPriv->provider ? 1 : 0;
|
|
}
|
|
xorg_list_for_each_entry(iter, &pScreen->unattached_list, unattached_head) {
|
|
pScrPriv = rrGetScrPriv(iter);
|
|
total_providers += pScrPriv->provider ? 1 : 0;
|
|
}
|
|
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
|
|
if (!pScrPriv)
|
|
{
|
|
rep = (xRRGetProvidersReply) {
|
|
.type = X_Reply,
|
|
.sequenceNumber = client->sequence,
|
|
.length = 0,
|
|
.timestamp = currentTime.milliseconds,
|
|
.nProviders = 0
|
|
};
|
|
extra = NULL;
|
|
extraLen = 0;
|
|
} else {
|
|
rep = (xRRGetProvidersReply) {
|
|
.type = X_Reply,
|
|
.sequenceNumber = client->sequence,
|
|
.timestamp = pScrPriv->lastSetTime.milliseconds,
|
|
.nProviders = total_providers,
|
|
.length = total_providers
|
|
};
|
|
extraLen = rep.length << 2;
|
|
if (extraLen) {
|
|
extra = malloc(extraLen);
|
|
if (!extra)
|
|
return BadAlloc;
|
|
} else
|
|
extra = NULL;
|
|
|
|
providers = (RRProvider *)extra;
|
|
ADD_PROVIDER(pScreen);
|
|
xorg_list_for_each_entry(iter, &pScreen->output_slave_list, output_head) {
|
|
ADD_PROVIDER(iter);
|
|
}
|
|
xorg_list_for_each_entry(iter, &pScreen->offload_slave_list, offload_head) {
|
|
ADD_PROVIDER(iter);
|
|
}
|
|
xorg_list_for_each_entry(iter, &pScreen->unattached_list, unattached_head) {
|
|
ADD_PROVIDER(iter);
|
|
}
|
|
}
|
|
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swapl(&rep.timestamp);
|
|
swaps(&rep.nProviders);
|
|
}
|
|
WriteToClient(client, sizeof(xRRGetProvidersReply), (char *)&rep);
|
|
if (extraLen)
|
|
{
|
|
WriteToClient (client, extraLen, (char *) extra);
|
|
free(extra);
|
|
}
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
ProcRRGetProviderInfo (ClientPtr client)
|
|
{
|
|
REQUEST(xRRGetProviderInfoReq);
|
|
xRRGetProviderInfoReply rep;
|
|
rrScrPrivPtr pScrPriv, pScrProvPriv;
|
|
RRProviderPtr provider;
|
|
ScreenPtr pScreen;
|
|
CARD8 *extra;
|
|
unsigned int extraLen = 0;
|
|
RRCrtc *crtcs;
|
|
RROutput *outputs;
|
|
int i;
|
|
char *name;
|
|
ScreenPtr provscreen;
|
|
RRProvider *providers;
|
|
uint32_t *prov_cap;
|
|
|
|
REQUEST_SIZE_MATCH(xRRGetProviderInfoReq);
|
|
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
|
|
|
|
pScreen = provider->pScreen;
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
|
|
rep = (xRRGetProviderInfoReply) {
|
|
.type = X_Reply,
|
|
.status = RRSetConfigSuccess,
|
|
.sequenceNumber = client->sequence,
|
|
.length = 0,
|
|
.capabilities = provider->capabilities,
|
|
.nameLength = provider->nameLength,
|
|
.timestamp = pScrPriv->lastSetTime.milliseconds,
|
|
.nCrtcs = pScrPriv->numCrtcs,
|
|
.nOutputs = pScrPriv->numOutputs,
|
|
.nAssociatedProviders = 0
|
|
};
|
|
|
|
/* count associated providers */
|
|
if (provider->offload_sink)
|
|
rep.nAssociatedProviders++;
|
|
if (provider->output_source)
|
|
rep.nAssociatedProviders++;
|
|
xorg_list_for_each_entry(provscreen, &pScreen->output_slave_list, output_head)
|
|
rep.nAssociatedProviders++;
|
|
xorg_list_for_each_entry(provscreen, &pScreen->offload_slave_list, offload_head)
|
|
rep.nAssociatedProviders++;
|
|
|
|
rep.length = (pScrPriv->numCrtcs + pScrPriv->numOutputs +
|
|
(rep.nAssociatedProviders * 2) + bytes_to_int32(rep.nameLength));
|
|
|
|
extraLen = rep.length << 2;
|
|
if (extraLen) {
|
|
extra = malloc(extraLen);
|
|
if (!extra)
|
|
return BadAlloc;
|
|
}
|
|
else
|
|
extra = NULL;
|
|
|
|
crtcs = (RRCrtc *)extra;
|
|
outputs = (RROutput *)(crtcs + rep.nCrtcs);
|
|
providers = (RRProvider *)(outputs + rep.nOutputs);
|
|
prov_cap = (unsigned int *)(providers + rep.nAssociatedProviders);
|
|
name = (char *)(prov_cap + rep.nAssociatedProviders);
|
|
|
|
for (i = 0; i < pScrPriv->numCrtcs; i++) {
|
|
crtcs[i] = pScrPriv->crtcs[i]->id;
|
|
if (client->swapped)
|
|
swapl(&crtcs[i]);
|
|
}
|
|
|
|
for (i = 0; i < pScrPriv->numOutputs; i++) {
|
|
outputs[i] = pScrPriv->outputs[i]->id;
|
|
if (client->swapped)
|
|
swapl(&outputs[i]);
|
|
}
|
|
|
|
i = 0;
|
|
if (provider->offload_sink) {
|
|
providers[i] = provider->offload_sink->id;
|
|
if (client->swapped)
|
|
swapl(&providers[i]);
|
|
prov_cap[i] = RR_Capability_SinkOffload;
|
|
if (client->swapped)
|
|
swapl(&prov_cap[i]);
|
|
i++;
|
|
}
|
|
if (provider->output_source) {
|
|
providers[i] = provider->output_source->id;
|
|
if (client->swapped)
|
|
swapl(&providers[i]);
|
|
prov_cap[i] = RR_Capability_SourceOutput;
|
|
swapl(&prov_cap[i]);
|
|
i++;
|
|
}
|
|
xorg_list_for_each_entry(provscreen, &pScreen->output_slave_list, output_head) {
|
|
pScrProvPriv = rrGetScrPriv(provscreen);
|
|
providers[i] = pScrProvPriv->provider->id;
|
|
if (client->swapped)
|
|
swapl(&providers[i]);
|
|
prov_cap[i] = RR_Capability_SinkOutput;
|
|
if (client->swapped)
|
|
swapl(&prov_cap[i]);
|
|
i++;
|
|
}
|
|
xorg_list_for_each_entry(provscreen, &pScreen->offload_slave_list, offload_head) {
|
|
pScrProvPriv = rrGetScrPriv(provscreen);
|
|
providers[i] = pScrProvPriv->provider->id;
|
|
if (client->swapped)
|
|
swapl(&providers[i]);
|
|
prov_cap[i] = RR_Capability_SourceOffload;
|
|
if (client->swapped)
|
|
swapl(&prov_cap[i]);
|
|
i++;
|
|
}
|
|
|
|
|
|
memcpy(name, provider->name, rep.nameLength);
|
|
if (client->swapped) {
|
|
swaps(&rep.sequenceNumber);
|
|
swapl(&rep.length);
|
|
swapl(&rep.capabilities);
|
|
swaps(&rep.nCrtcs);
|
|
swaps(&rep.nOutputs);
|
|
swaps(&rep.nameLength);
|
|
}
|
|
WriteToClient(client, sizeof(xRRGetProviderInfoReply), (char *)&rep);
|
|
if (extraLen)
|
|
{
|
|
WriteToClient (client, extraLen, (char *) extra);
|
|
free(extra);
|
|
}
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
ProcRRSetProviderOutputSource(ClientPtr client)
|
|
{
|
|
REQUEST(xRRSetProviderOutputSourceReq);
|
|
rrScrPrivPtr pScrPriv;
|
|
RRProviderPtr provider, source_provider = NULL;
|
|
ScreenPtr pScreen;
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRRSetProviderOutputSourceReq);
|
|
|
|
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
|
|
|
|
if (!(provider->capabilities & RR_Capability_SinkOutput))
|
|
return BadValue;
|
|
|
|
if (stuff->source_provider) {
|
|
VERIFY_RR_PROVIDER(stuff->source_provider, source_provider, DixReadAccess);
|
|
|
|
if (!(source_provider->capabilities & RR_Capability_SourceOutput))
|
|
return BadValue;
|
|
}
|
|
|
|
pScreen = provider->pScreen;
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
|
|
pScrPriv->rrProviderSetOutputSource(pScreen, provider, source_provider);
|
|
|
|
RRTellChanged (pScreen);
|
|
|
|
return Success;
|
|
}
|
|
|
|
int
|
|
ProcRRSetProviderOffloadSink(ClientPtr client)
|
|
{
|
|
REQUEST(xRRSetProviderOffloadSinkReq);
|
|
rrScrPrivPtr pScrPriv;
|
|
RRProviderPtr provider, sink_provider = NULL;
|
|
ScreenPtr pScreen;
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRRSetProviderOffloadSinkReq);
|
|
|
|
VERIFY_RR_PROVIDER(stuff->provider, provider, DixReadAccess);
|
|
if (!(provider->capabilities & RR_Capability_SourceOffload))
|
|
return BadValue;
|
|
|
|
if (stuff->sink_provider) {
|
|
VERIFY_RR_PROVIDER(stuff->sink_provider, sink_provider, DixReadAccess);
|
|
if (!(sink_provider->capabilities & RR_Capability_SinkOffload))
|
|
return BadValue;
|
|
}
|
|
pScreen = provider->pScreen;
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
|
|
pScrPriv->rrProviderSetOffloadSink(pScreen, provider, sink_provider);
|
|
|
|
RRTellChanged (pScreen);
|
|
|
|
return Success;
|
|
}
|
|
|
|
RRProviderPtr
|
|
RRProviderCreate(ScreenPtr pScreen, const char *name,
|
|
int nameLength)
|
|
{
|
|
RRProviderPtr provider;
|
|
rrScrPrivPtr pScrPriv;
|
|
|
|
pScrPriv = rrGetScrPriv(pScreen);
|
|
|
|
provider = calloc(1, sizeof(RRProviderRec) + nameLength + 1);
|
|
if (!provider)
|
|
return NULL;
|
|
|
|
provider->id = FakeClientID(0);
|
|
provider->pScreen = pScreen;
|
|
provider->name = (char *) (provider + 1);
|
|
provider->nameLength = nameLength;
|
|
memcpy(provider->name, name, nameLength);
|
|
provider->name[nameLength] = '\0';
|
|
|
|
if (!AddResource (provider->id, RRProviderType, (pointer) provider))
|
|
return NULL;
|
|
pScrPriv->provider = provider;
|
|
return provider;
|
|
}
|
|
|
|
/*
|
|
* Destroy a provider at shutdown
|
|
*/
|
|
void
|
|
RRProviderDestroy (RRProviderPtr provider)
|
|
{
|
|
FreeResource (provider->id, 0);
|
|
}
|
|
|
|
void
|
|
RRProviderSetCapabilities(RRProviderPtr provider, uint32_t capabilities)
|
|
{
|
|
provider->capabilities = capabilities;
|
|
}
|
|
|
|
static int
|
|
RRProviderDestroyResource (pointer value, XID pid)
|
|
{
|
|
RRProviderPtr provider = (RRProviderPtr)value;
|
|
ScreenPtr pScreen = provider->pScreen;
|
|
|
|
if (pScreen)
|
|
{
|
|
rrScrPriv(pScreen);
|
|
|
|
if (pScrPriv->rrProviderDestroy)
|
|
(*pScrPriv->rrProviderDestroy)(pScreen, provider);
|
|
pScrPriv->provider = NULL;
|
|
}
|
|
free(provider);
|
|
return 1;
|
|
}
|
|
|
|
Bool
|
|
RRProviderInit(void)
|
|
{
|
|
RRProviderType = CreateNewResourceType(RRProviderDestroyResource, "Provider");
|
|
if (!RRProviderType)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
extern _X_EXPORT Bool
|
|
RRProviderLookup(XID id, RRProviderPtr *provider_p)
|
|
{
|
|
int rc = dixLookupResourceByType((void **)provider_p, id,
|
|
RRProviderType, NullClient, DixReadAccess);
|
|
if (rc == Success)
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|