2006-09-21 07:43:05 +02:00
|
|
|
/*
|
|
|
|
* Copyright © 2006 Keith Packard
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "randrstr.h"
|
|
|
|
#include "propertyst.h"
|
|
|
|
#include "swaprep.h"
|
2018-02-12 22:51:54 +01:00
|
|
|
#include <X11/Xatom.h>
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2008-10-06 18:21:20 +02:00
|
|
|
static int
|
|
|
|
DeliverPropertyEvent(WindowPtr pWin, void *value)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
2008-10-06 18:21:20 +02:00
|
|
|
xRROutputPropertyNotifyEvent *event = value;
|
|
|
|
RREventPtr *pHead, pRREvent;
|
|
|
|
|
2013-12-15 10:05:51 +01:00
|
|
|
dixLookupResourceByType((void **) &pHead, pWin->drawable.id,
|
2012-03-21 20:55:09 +01:00
|
|
|
RREventType, serverClient, DixReadAccess);
|
2008-10-06 18:21:20 +02:00
|
|
|
if (!pHead)
|
2012-03-21 20:55:09 +01:00
|
|
|
return WT_WALKCHILDREN;
|
2008-10-06 18:21:20 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) {
|
|
|
|
if (!(pRREvent->mask & RROutputPropertyNotifyMask))
|
|
|
|
continue;
|
2008-10-06 18:21:20 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
event->window = pRREvent->window->drawable.id;
|
|
|
|
WriteEventsToClient(pRREvent->client, 1, (xEvent *) event);
|
2008-10-06 18:21:20 +02:00
|
|
|
}
|
2007-03-24 07:41:36 +01:00
|
|
|
|
2008-10-06 18:21:20 +02:00
|
|
|
return WT_WALKCHILDREN;
|
|
|
|
}
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
static void
|
|
|
|
RRDeliverPropertyEvent(ScreenPtr pScreen, xEvent *event)
|
2008-10-06 18:21:20 +02:00
|
|
|
{
|
2008-12-01 17:36:06 +01:00
|
|
|
if (!(dispatchException & (DE_RESET | DE_TERMINATE)))
|
2012-03-21 20:55:09 +01:00
|
|
|
WalkTree(pScreen, DeliverPropertyEvent, event);
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
2010-06-06 15:37:07 +02:00
|
|
|
static void
|
2012-03-21 20:55:09 +01:00
|
|
|
RRDestroyOutputProperty(RRPropertyPtr prop)
|
2010-06-06 15:37:07 +02:00
|
|
|
{
|
|
|
|
free(prop->valid_values);
|
|
|
|
free(prop->current.data);
|
|
|
|
free(prop->pending.data);
|
|
|
|
free(prop);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-03-21 20:55:09 +01:00
|
|
|
RRDeleteProperty(RROutputRec * output, RRPropertyRec * prop)
|
2010-06-06 15:37:07 +02:00
|
|
|
{
|
2012-07-10 04:12:44 +02:00
|
|
|
xRROutputPropertyNotifyEvent event = {
|
|
|
|
.type = RREventBase + RRNotify,
|
|
|
|
.subCode = RRNotify_OutputProperty,
|
|
|
|
.output = output->id,
|
|
|
|
.state = PropertyDelete,
|
|
|
|
.atom = prop->propertyName,
|
|
|
|
.timestamp = currentTime.milliseconds
|
|
|
|
};
|
2010-06-06 15:37:07 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
RRDeliverPropertyEvent(output->pScreen, (xEvent *) &event);
|
2010-06-06 15:37:07 +02:00
|
|
|
|
|
|
|
RRDestroyOutputProperty(prop);
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
void
|
2010-06-06 15:37:07 +02:00
|
|
|
RRDeleteAllOutputProperties(RROutputPtr output)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
2006-11-21 10:15:26 +01:00
|
|
|
RRPropertyPtr prop, next;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2010-06-06 15:37:07 +02:00
|
|
|
for (prop = output->properties; prop; prop = next) {
|
2012-03-21 20:55:09 +01:00
|
|
|
next = prop->next;
|
2010-06-06 15:37:07 +02:00
|
|
|
RRDeleteProperty(output, prop);
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
static void
|
2012-03-21 20:55:09 +01:00
|
|
|
RRInitOutputPropertyValue(RRPropertyValuePtr property_value)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
|
|
|
property_value->type = None;
|
|
|
|
property_value->format = 0;
|
|
|
|
property_value->size = 0;
|
|
|
|
property_value->data = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static RRPropertyPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
RRCreateOutputProperty(Atom property)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyPtr prop;
|
2007-03-24 07:41:36 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
prop = (RRPropertyPtr) malloc(sizeof(RRPropertyRec));
|
2006-11-21 10:15:26 +01:00
|
|
|
if (!prop)
|
2012-03-21 20:55:09 +01:00
|
|
|
return NULL;
|
2006-11-22 01:52:28 +01:00
|
|
|
prop->next = NULL;
|
2006-11-21 10:15:26 +01:00
|
|
|
prop->propertyName = property;
|
|
|
|
prop->is_pending = FALSE;
|
|
|
|
prop->range = FALSE;
|
|
|
|
prop->immutable = FALSE;
|
|
|
|
prop->num_valid = 0;
|
|
|
|
prop->valid_values = NULL;
|
2012-03-21 20:55:09 +01:00
|
|
|
RRInitOutputPropertyValue(&prop->current);
|
|
|
|
RRInitOutputPropertyValue(&prop->pending);
|
2006-11-21 10:15:26 +01:00
|
|
|
return prop;
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
void
|
2010-06-06 15:37:07 +02:00
|
|
|
RRDeleteOutputProperty(RROutputPtr output, Atom property)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
2010-06-06 15:37:07 +02:00
|
|
|
RRPropertyRec *prop, **prev;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
|
|
|
for (prev = &output->properties; (prop = *prev); prev = &(prop->next))
|
2012-03-21 20:55:09 +01:00
|
|
|
if (prop->propertyName == property) {
|
2010-06-06 15:37:07 +02:00
|
|
|
*prev = prop->next;
|
|
|
|
RRDeleteProperty(output, prop);
|
|
|
|
return;
|
|
|
|
}
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
2018-02-12 22:51:54 +01:00
|
|
|
static void
|
|
|
|
RRNoticePropertyChange(RROutputPtr output, Atom property, RRPropertyValuePtr value)
|
|
|
|
{
|
|
|
|
const char *non_desktop_str = RR_PROPERTY_NON_DESKTOP;
|
|
|
|
Atom non_desktop_prop = MakeAtom(non_desktop_str, strlen(non_desktop_str), FALSE);
|
|
|
|
|
|
|
|
if (property == non_desktop_prop) {
|
|
|
|
if (value->type == XA_INTEGER && value->format == 32 && value->size >= 1) {
|
|
|
|
uint32_t nonDesktopData;
|
|
|
|
Bool nonDesktop;
|
|
|
|
|
|
|
|
memcpy(&nonDesktopData, value->data, sizeof (nonDesktopData));
|
|
|
|
nonDesktop = nonDesktopData != 0;
|
|
|
|
|
|
|
|
if (nonDesktop != output->nonDesktop) {
|
|
|
|
output->nonDesktop = nonDesktop;
|
|
|
|
RROutputChanged(output, 0);
|
|
|
|
RRTellChanged(output->pScreen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type,
|
|
|
|
int format, int mode, unsigned long len,
|
2017-12-22 03:54:37 +01:00
|
|
|
const void *value, Bool sendevent, Bool pending)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyPtr prop;
|
|
|
|
rrScrPrivPtr pScrPriv = rrGetScrPriv(output->pScreen);
|
|
|
|
int size_in_bytes;
|
|
|
|
unsigned long total_len;
|
|
|
|
RRPropertyValuePtr prop_value;
|
|
|
|
RRPropertyValueRec new_value;
|
|
|
|
Bool add = FALSE;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2007-03-23 09:05:55 +01:00
|
|
|
size_in_bytes = format >> 3;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
|
|
|
/* first see if property already exists */
|
2012-03-21 20:55:09 +01:00
|
|
|
prop = RRQueryOutputProperty(output, property);
|
|
|
|
if (!prop) { /* just add to list */
|
|
|
|
prop = RRCreateOutputProperty(property);
|
|
|
|
if (!prop)
|
|
|
|
return BadAlloc;
|
|
|
|
add = TRUE;
|
|
|
|
mode = PropModeReplace;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2007-03-23 09:05:55 +01:00
|
|
|
if (pending && prop->is_pending)
|
2012-03-21 20:55:09 +01:00
|
|
|
prop_value = &prop->pending;
|
2006-09-21 07:43:05 +02:00
|
|
|
else
|
2012-03-21 20:55:09 +01:00
|
|
|
prop_value = &prop->current;
|
2007-03-24 07:41:36 +01:00
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
/* To append or prepend to a property the request format and type
|
2012-03-21 20:55:09 +01:00
|
|
|
must match those of the already defined property. The
|
|
|
|
existing format and type are irrelevant when using the mode
|
|
|
|
"PropModeReplace" since they will be written over. */
|
2006-11-21 10:15:26 +01:00
|
|
|
|
|
|
|
if ((format != prop_value->format) && (mode != PropModeReplace))
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadMatch;
|
2006-11-21 10:15:26 +01:00
|
|
|
if ((prop_value->type != type) && (mode != PropModeReplace))
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadMatch;
|
2007-03-23 09:05:55 +01:00
|
|
|
new_value = *prop_value;
|
2006-11-21 10:15:26 +01:00
|
|
|
if (mode == PropModeReplace)
|
2012-03-21 20:55:09 +01:00
|
|
|
total_len = len;
|
2007-03-23 09:05:55 +01:00
|
|
|
else
|
2012-03-21 20:55:09 +01:00
|
|
|
total_len = prop_value->size + len;
|
|
|
|
|
|
|
|
if (mode == PropModeReplace || len > 0) {
|
2013-12-15 10:05:51 +01:00
|
|
|
void *new_data = NULL, *old_data = NULL;
|
2012-03-21 20:55:09 +01:00
|
|
|
|
2015-03-21 21:42:12 +01:00
|
|
|
new_value.data = xallocarray(total_len, size_in_bytes);
|
|
|
|
if (!new_value.data && total_len && size_in_bytes) {
|
2012-03-21 20:55:09 +01:00
|
|
|
if (add)
|
|
|
|
RRDestroyOutputProperty(prop);
|
|
|
|
return BadAlloc;
|
|
|
|
}
|
|
|
|
new_value.size = len;
|
|
|
|
new_value.type = type;
|
|
|
|
new_value.format = format;
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case PropModeReplace:
|
|
|
|
new_data = new_value.data;
|
|
|
|
old_data = NULL;
|
|
|
|
break;
|
|
|
|
case PropModeAppend:
|
2013-12-15 10:05:51 +01:00
|
|
|
new_data = (void *) (((char *) new_value.data) +
|
2012-03-21 20:55:09 +01:00
|
|
|
(prop_value->size * size_in_bytes));
|
|
|
|
old_data = new_value.data;
|
|
|
|
break;
|
|
|
|
case PropModePrepend:
|
|
|
|
new_data = new_value.data;
|
2013-12-15 10:05:51 +01:00
|
|
|
old_data = (void *) (((char *) new_value.data) +
|
2012-03-21 20:55:09 +01:00
|
|
|
(prop_value->size * size_in_bytes));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (new_data)
|
|
|
|
memcpy((char *) new_data, (char *) value, len * size_in_bytes);
|
|
|
|
if (old_data)
|
|
|
|
memcpy((char *) old_data, (char *) prop_value->data,
|
|
|
|
prop_value->size * size_in_bytes);
|
|
|
|
|
|
|
|
if (pending && pScrPriv->rrOutputSetProperty &&
|
|
|
|
!pScrPriv->rrOutputSetProperty(output->pScreen, output,
|
|
|
|
prop->propertyName, &new_value)) {
|
|
|
|
free(new_value.data);
|
2012-07-14 18:29:52 +02:00
|
|
|
if (add)
|
|
|
|
RRDestroyOutputProperty(prop);
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
free(prop_value->data);
|
|
|
|
*prop_value = new_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (len == 0) {
|
|
|
|
/* do nothing */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (add) {
|
|
|
|
prop->next = output->properties;
|
|
|
|
output->properties = prop;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2007-01-16 22:01:03 +01:00
|
|
|
|
2007-03-24 07:41:36 +01:00
|
|
|
if (pending && prop->is_pending)
|
2012-03-21 20:55:09 +01:00
|
|
|
output->pendingProperties = TRUE;
|
|
|
|
|
2018-02-12 22:51:54 +01:00
|
|
|
if (!(pending && prop->is_pending))
|
|
|
|
RRNoticePropertyChange(output, prop->propertyName, prop_value);
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (sendevent) {
|
2012-07-10 04:12:44 +02:00
|
|
|
xRROutputPropertyNotifyEvent event = {
|
|
|
|
.type = RREventBase + RRNotify,
|
|
|
|
.subCode = RRNotify_OutputProperty,
|
|
|
|
.output = output->id,
|
|
|
|
.state = PropertyNewValue,
|
|
|
|
.atom = prop->propertyName,
|
|
|
|
.timestamp = currentTime.milliseconds
|
|
|
|
};
|
2012-03-21 20:55:09 +01:00
|
|
|
RRDeliverPropertyEvent(output->pScreen, (xEvent *) &event);
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2010-06-06 16:18:40 +02:00
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
Bool
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPostPendingProperties(RROutputPtr output)
|
2007-03-23 09:05:55 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyValuePtr pending_value;
|
|
|
|
RRPropertyValuePtr current_value;
|
|
|
|
RRPropertyPtr property;
|
|
|
|
Bool ret = TRUE;
|
2007-03-23 09:05:55 +01:00
|
|
|
|
2007-03-24 07:41:36 +01:00
|
|
|
if (!output->pendingProperties)
|
2012-03-21 20:55:09 +01:00
|
|
|
return TRUE;
|
|
|
|
|
2007-03-24 07:41:36 +01:00
|
|
|
output->pendingProperties = FALSE;
|
2012-03-21 20:55:09 +01:00
|
|
|
for (property = output->properties; property; property = property->next) {
|
|
|
|
/* Skip non-pending properties */
|
|
|
|
if (!property->is_pending)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
pending_value = &property->pending;
|
|
|
|
current_value = &property->current;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the pending and current values are equal, don't mark it
|
|
|
|
* as changed (which would deliver an event)
|
|
|
|
*/
|
|
|
|
if (pending_value->type == current_value->type &&
|
|
|
|
pending_value->format == current_value->format &&
|
|
|
|
pending_value->size == current_value->size &&
|
|
|
|
!memcmp(pending_value->data, current_value->data,
|
|
|
|
pending_value->size * (pending_value->format / 8)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (RRChangeOutputProperty(output, property->propertyName,
|
|
|
|
pending_value->type, pending_value->format,
|
|
|
|
PropModeReplace, pending_value->size,
|
|
|
|
pending_value->data, TRUE, FALSE) != Success)
|
|
|
|
ret = FALSE;
|
2007-03-24 07:41:36 +01:00
|
|
|
}
|
|
|
|
return ret;
|
2007-03-23 09:05:55 +01:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
RRPropertyPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
RRQueryOutputProperty(RROutputPtr output, Atom property)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyPtr prop;
|
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
for (prop = output->properties; prop; prop = prop->next)
|
2012-03-21 20:55:09 +01:00
|
|
|
if (prop->propertyName == property)
|
|
|
|
return prop;
|
2006-11-21 10:15:26 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-03-21 20:55:09 +01:00
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
RRPropertyValuePtr
|
2012-03-21 20:55:09 +01:00
|
|
|
RRGetOutputProperty(RROutputPtr output, Atom property, Bool pending)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyPtr prop = RRQueryOutputProperty(output, property);
|
|
|
|
rrScrPrivPtr pScrPriv = rrGetScrPriv(output->pScreen);
|
2006-11-21 10:15:26 +01:00
|
|
|
|
|
|
|
if (!prop)
|
2012-03-21 20:55:09 +01:00
|
|
|
return NULL;
|
2006-11-21 10:15:26 +01:00
|
|
|
if (pending && prop->is_pending)
|
2012-03-21 20:55:09 +01:00
|
|
|
return &prop->pending;
|
2008-03-06 22:47:44 +01:00
|
|
|
else {
|
|
|
|
#if RANDR_13_INTERFACE
|
2012-03-21 20:55:09 +01:00
|
|
|
/* If we can, try to update the property value first */
|
|
|
|
if (pScrPriv->rrOutputGetProperty)
|
|
|
|
pScrPriv->rrOutputGetProperty(output->pScreen, output,
|
|
|
|
prop->propertyName);
|
2008-03-06 22:47:44 +01:00
|
|
|
#endif
|
2012-03-21 20:55:09 +01:00
|
|
|
return &prop->current;
|
2008-03-06 22:47:44 +01:00
|
|
|
}
|
2006-11-21 10:15:26 +01:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
RRConfigureOutputProperty(RROutputPtr output, Atom property,
|
|
|
|
Bool pending, Bool range, Bool immutable,
|
2017-12-22 03:54:37 +01:00
|
|
|
int num_values, const INT32 *values)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyPtr prop = RRQueryOutputProperty(output, property);
|
|
|
|
Bool add = FALSE;
|
|
|
|
INT32 *new_values;
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
prop = RRCreateOutputProperty(property);
|
|
|
|
if (!prop)
|
|
|
|
return BadAlloc;
|
|
|
|
add = TRUE;
|
|
|
|
}
|
|
|
|
else if (prop->immutable && !immutable)
|
|
|
|
return BadAccess;
|
2006-11-21 10:15:26 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ranges must have even number of values
|
|
|
|
*/
|
2012-07-14 18:29:52 +02:00
|
|
|
if (range && (num_values & 1)) {
|
|
|
|
if (add)
|
|
|
|
RRDestroyOutputProperty(prop);
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadMatch;
|
2012-07-14 18:29:52 +02:00
|
|
|
}
|
2006-11-21 10:15:26 +01:00
|
|
|
|
2015-03-21 21:42:12 +01:00
|
|
|
new_values = xallocarray(num_values, sizeof(INT32));
|
2012-07-14 18:29:52 +02:00
|
|
|
if (!new_values && num_values) {
|
|
|
|
if (add)
|
|
|
|
RRDestroyOutputProperty(prop);
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadAlloc;
|
2012-07-14 18:29:52 +02:00
|
|
|
}
|
2006-11-21 10:15:26 +01:00
|
|
|
if (num_values)
|
2012-03-21 20:55:09 +01:00
|
|
|
memcpy(new_values, values, num_values * sizeof(INT32));
|
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
/*
|
|
|
|
* Property moving from pending to non-pending
|
|
|
|
* loses any pending values
|
|
|
|
*/
|
2012-03-21 20:55:09 +01:00
|
|
|
if (prop->is_pending && !pending) {
|
|
|
|
free(prop->pending.data);
|
|
|
|
RRInitOutputPropertyValue(&prop->pending);
|
2006-11-21 10:15:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
prop->is_pending = pending;
|
|
|
|
prop->range = range;
|
|
|
|
prop->immutable = immutable;
|
|
|
|
prop->num_valid = num_values;
|
2010-06-06 10:28:30 +02:00
|
|
|
free(prop->valid_values);
|
2006-11-21 10:15:26 +01:00
|
|
|
prop->valid_values = new_values;
|
2007-01-16 21:59:34 +01:00
|
|
|
|
|
|
|
if (add) {
|
2012-03-21 20:55:09 +01:00
|
|
|
prop->next = output->properties;
|
|
|
|
output->properties = prop;
|
2007-01-16 21:59:34 +01:00
|
|
|
}
|
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
return Success;
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
ProcRRListOutputProperties(ClientPtr client)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
|
|
|
REQUEST(xRRListOutputPropertiesReq);
|
2012-07-10 04:12:42 +02:00
|
|
|
Atom *pAtoms = NULL;
|
2012-03-21 20:55:09 +01:00
|
|
|
xRRListOutputPropertiesReply rep;
|
|
|
|
int numProps = 0;
|
|
|
|
RROutputPtr output;
|
|
|
|
RRPropertyPtr prop;
|
|
|
|
|
2006-09-21 07:43:05 +02:00
|
|
|
REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
|
|
|
|
|
2009-04-29 07:04:37 +02:00
|
|
|
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
|
2006-09-21 07:43:05 +02:00
|
|
|
|
|
|
|
for (prop = output->properties; prop; prop = prop->next)
|
2012-03-21 20:55:09 +01:00
|
|
|
numProps++;
|
2006-09-21 07:43:05 +02:00
|
|
|
if (numProps)
|
2015-03-21 21:42:12 +01:00
|
|
|
if (!(pAtoms = xallocarray(numProps, sizeof(Atom))))
|
2010-06-06 16:18:40 +02:00
|
|
|
return BadAlloc;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2012-07-10 04:12:43 +02:00
|
|
|
rep = (xRRListOutputPropertiesReply) {
|
|
|
|
.type = X_Reply,
|
|
|
|
.sequenceNumber = client->sequence,
|
|
|
|
.length = bytes_to_int32(numProps * sizeof(Atom)),
|
|
|
|
.nAtoms = numProps
|
|
|
|
};
|
2012-03-21 20:55:09 +01:00
|
|
|
if (client->swapped) {
|
|
|
|
swaps(&rep.sequenceNumber);
|
|
|
|
swapl(&rep.length);
|
|
|
|
swaps(&rep.nAtoms);
|
2006-11-21 10:15:26 +01:00
|
|
|
}
|
2012-05-13 09:03:35 +02:00
|
|
|
WriteToClient(client, sizeof(xRRListOutputPropertiesReply), &rep);
|
2012-07-10 04:12:42 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (numProps) {
|
2012-07-10 04:12:42 +02:00
|
|
|
/* Copy property name atoms to reply buffer */
|
|
|
|
Atom *temppAtoms = pAtoms;
|
|
|
|
for (prop = output->properties; prop; prop = prop->next)
|
|
|
|
*temppAtoms++ = prop->propertyName;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
|
2006-09-21 07:43:05 +02:00
|
|
|
WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms);
|
2010-05-05 20:44:06 +02:00
|
|
|
free(pAtoms);
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2010-05-11 05:22:05 +02:00
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
ProcRRQueryOutputProperty(ClientPtr client)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
|
|
|
REQUEST(xRRQueryOutputPropertyReq);
|
2012-03-21 20:55:09 +01:00
|
|
|
xRRQueryOutputPropertyReply rep;
|
|
|
|
RROutputPtr output;
|
|
|
|
RRPropertyPtr prop;
|
2008-11-24 22:08:48 +01:00
|
|
|
char *extra = NULL;
|
2012-03-21 20:55:09 +01:00
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
|
|
|
|
|
2009-04-29 07:04:37 +02:00
|
|
|
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
|
2012-03-21 20:55:09 +01:00
|
|
|
|
|
|
|
prop = RRQueryOutputProperty(output, stuff->property);
|
2006-11-21 10:15:26 +01:00
|
|
|
if (!prop)
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadName;
|
|
|
|
|
2008-08-21 01:32:03 +02:00
|
|
|
if (prop->num_valid) {
|
2015-03-21 21:42:12 +01:00
|
|
|
extra = xallocarray(prop->num_valid, sizeof(INT32));
|
2012-03-21 20:55:09 +01:00
|
|
|
if (!extra)
|
|
|
|
return BadAlloc;
|
2008-08-21 01:32:03 +02:00
|
|
|
}
|
2012-07-10 04:12:43 +02:00
|
|
|
|
|
|
|
rep = (xRRQueryOutputPropertyReply) {
|
|
|
|
.type = X_Reply,
|
|
|
|
.sequenceNumber = client->sequence,
|
|
|
|
.length = prop->num_valid,
|
|
|
|
.pending = prop->is_pending,
|
|
|
|
.range = prop->range,
|
|
|
|
.immutable = prop->immutable
|
|
|
|
};
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (client->swapped) {
|
|
|
|
swaps(&rep.sequenceNumber);
|
|
|
|
swapl(&rep.length);
|
|
|
|
}
|
2012-05-13 09:03:35 +02:00
|
|
|
WriteToClient(client, sizeof(xRRQueryOutputPropertyReply), &rep);
|
2012-03-21 20:55:09 +01:00
|
|
|
if (prop->num_valid) {
|
2008-08-21 01:32:03 +02:00
|
|
|
memcpy(extra, prop->valid_values, prop->num_valid * sizeof(INT32));
|
2012-03-21 20:55:09 +01:00
|
|
|
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
|
2006-11-21 10:15:26 +01:00
|
|
|
WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32),
|
2012-03-21 20:55:09 +01:00
|
|
|
extra);
|
2010-05-05 20:44:06 +02:00
|
|
|
free(extra);
|
2006-11-21 10:15:26 +01:00
|
|
|
}
|
2010-05-11 05:22:05 +02:00
|
|
|
return Success;
|
2006-11-21 10:15:26 +01:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
ProcRRConfigureOutputProperty(ClientPtr client)
|
2006-11-21 10:15:26 +01:00
|
|
|
{
|
|
|
|
REQUEST(xRRConfigureOutputPropertyReq);
|
2012-03-21 20:55:09 +01:00
|
|
|
RROutputPtr output;
|
|
|
|
int num_valid;
|
|
|
|
|
2007-02-16 07:23:16 +01:00
|
|
|
REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
|
2006-11-21 10:15:26 +01:00
|
|
|
|
2009-04-29 07:04:37 +02:00
|
|
|
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
|
2012-03-21 20:55:09 +01:00
|
|
|
|
Add RandR leases with modesetting driver support [v6]
This adds support for RandR CRTC/Output leases through the modesetting
driver, creating a lease using new kernel infrastructure and returning
that to a client through an fd which will have access to only those
resources.
v2: Restore CRTC mode when leases terminate
When a lease terminates for a crtc we have saved data for, go
ahead and restore the saved mode.
v3: Report RR_Rotate_0 rotations for leased crtcs.
Ignore leased CRTCs when selecting screen size.
Stop leasing encoders, the kernel doesn't do that anymore.
Turn off crtc->enabled while leased so that modesetting
ignores them.
Check lease status before calling any driver mode functions
When starting a lease, mark leased CRTCs as disabled and hide
their cursors. Also, check to see if there are other
non-leased CRTCs which are driving leased Outputs and mark
them as disabled as well. Sometimes an application will lease
an idle crtc instead of the one already associated with the
leased output.
When terminating a lease, reset any CRTCs which are driving
outputs that are no longer leased so that they start working
again.
This required splitting the DIX level lease termination code
into two pieces, one to remove the lease from the system
(RRLeaseTerminated) and a new function that frees the lease
data structure (RRLeaseFree).
v4: Report RR_Rotate_0 rotation for leased crtcs.
v5: Terminate all leases on server reset.
Leases hang around after the associated client exits so that
the client doesn't need to occupy an X server client slot and
consume a file descriptor once it has gotten the output
resources necessary.
Any leases still hanging around when the X server resets or
shuts down need to be cleaned up by calling the kernel to
terminate the lease and freeing any DIX structures.
Note that we cannot simply use the existing
drmmode_terminate_lease function on each lease as that wants
to also reset the video mode, and during server shut down that
modesetting: Validate leases on VT enter
The kernel doesn't allow any master ioctls to run when another
VT is active, including simple things like listing the active
leases. To deal with that, we check the list of leases
whenever the X server VT is activated.
xfree86: hide disabled cursors when resetting after lease termination
The lessee may well have played with cursors and left one
active on our screen. Just tell the kernel to turn it off.
v6: Add meson build infrastructure
[Also bumped libdrm requirement - ajax]
Signed-off-by: Keith Packard <keithp@keithp.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-02-12 22:51:56 +01:00
|
|
|
if (RROutputIsLeased(output))
|
|
|
|
return BadAccess;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
num_valid =
|
|
|
|
stuff->length - bytes_to_int32(sizeof(xRRConfigureOutputPropertyReq));
|
|
|
|
return RRConfigureOutputProperty(output, stuff->property, stuff->pending,
|
|
|
|
stuff->range, FALSE, num_valid,
|
|
|
|
(INT32 *) (stuff + 1));
|
2006-11-21 10:15:26 +01:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
ProcRRChangeOutputProperty(ClientPtr client)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
|
|
|
REQUEST(xRRChangeOutputPropertyReq);
|
2012-03-21 20:55:09 +01:00
|
|
|
RROutputPtr output;
|
|
|
|
char format, mode;
|
|
|
|
unsigned long len;
|
|
|
|
int sizeInBytes;
|
|
|
|
int totalSize;
|
|
|
|
int err;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
|
|
|
REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
|
|
|
|
UpdateCurrentTime();
|
|
|
|
format = stuff->format;
|
|
|
|
mode = stuff->mode;
|
|
|
|
if ((mode != PropModeReplace) && (mode != PropModeAppend) &&
|
2012-03-21 20:55:09 +01:00
|
|
|
(mode != PropModePrepend)) {
|
|
|
|
client->errorValue = mode;
|
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
if ((format != 8) && (format != 16) && (format != 32)) {
|
|
|
|
client->errorValue = format;
|
2006-09-21 07:43:05 +02:00
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
len = stuff->nUnits;
|
2009-07-06 04:24:27 +02:00
|
|
|
if (len > bytes_to_int32((0xffffffff - sizeof(xChangePropertyReq))))
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadLength;
|
|
|
|
sizeInBytes = format >> 3;
|
2006-09-21 07:43:05 +02:00
|
|
|
totalSize = len * sizeInBytes;
|
|
|
|
REQUEST_FIXED_SIZE(xRRChangeOutputPropertyReq, totalSize);
|
|
|
|
|
2009-04-29 07:04:37 +02:00
|
|
|
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
|
2012-03-21 20:55:09 +01:00
|
|
|
|
|
|
|
if (!ValidAtom(stuff->property)) {
|
|
|
|
client->errorValue = stuff->property;
|
|
|
|
return BadAtom;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2012-03-21 20:55:09 +01:00
|
|
|
if (!ValidAtom(stuff->type)) {
|
|
|
|
client->errorValue = stuff->type;
|
|
|
|
return BadAtom;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
err = RRChangeOutputProperty(output, stuff->property,
|
2012-03-21 20:55:09 +01:00
|
|
|
stuff->type, (int) format,
|
2013-12-15 10:05:51 +01:00
|
|
|
(int) mode, len, (void *) &stuff[1], TRUE,
|
2012-03-21 20:55:09 +01:00
|
|
|
TRUE);
|
2006-09-21 07:43:05 +02:00
|
|
|
if (err != Success)
|
2012-03-21 20:55:09 +01:00
|
|
|
return err;
|
2006-09-21 07:43:05 +02:00
|
|
|
else
|
2012-03-21 20:55:09 +01:00
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
ProcRRDeleteOutputProperty(ClientPtr client)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
|
|
|
REQUEST(xRRDeleteOutputPropertyReq);
|
2012-03-21 20:55:09 +01:00
|
|
|
RROutputPtr output;
|
|
|
|
RRPropertyPtr prop;
|
2011-08-24 00:19:59 +02:00
|
|
|
|
2006-09-21 07:43:05 +02:00
|
|
|
REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
|
|
|
|
UpdateCurrentTime();
|
2009-04-29 07:04:37 +02:00
|
|
|
VERIFY_RR_OUTPUT(stuff->output, output, DixReadAccess);
|
2011-08-24 00:19:59 +02:00
|
|
|
|
Add RandR leases with modesetting driver support [v6]
This adds support for RandR CRTC/Output leases through the modesetting
driver, creating a lease using new kernel infrastructure and returning
that to a client through an fd which will have access to only those
resources.
v2: Restore CRTC mode when leases terminate
When a lease terminates for a crtc we have saved data for, go
ahead and restore the saved mode.
v3: Report RR_Rotate_0 rotations for leased crtcs.
Ignore leased CRTCs when selecting screen size.
Stop leasing encoders, the kernel doesn't do that anymore.
Turn off crtc->enabled while leased so that modesetting
ignores them.
Check lease status before calling any driver mode functions
When starting a lease, mark leased CRTCs as disabled and hide
their cursors. Also, check to see if there are other
non-leased CRTCs which are driving leased Outputs and mark
them as disabled as well. Sometimes an application will lease
an idle crtc instead of the one already associated with the
leased output.
When terminating a lease, reset any CRTCs which are driving
outputs that are no longer leased so that they start working
again.
This required splitting the DIX level lease termination code
into two pieces, one to remove the lease from the system
(RRLeaseTerminated) and a new function that frees the lease
data structure (RRLeaseFree).
v4: Report RR_Rotate_0 rotation for leased crtcs.
v5: Terminate all leases on server reset.
Leases hang around after the associated client exits so that
the client doesn't need to occupy an X server client slot and
consume a file descriptor once it has gotten the output
resources necessary.
Any leases still hanging around when the X server resets or
shuts down need to be cleaned up by calling the kernel to
terminate the lease and freeing any DIX structures.
Note that we cannot simply use the existing
drmmode_terminate_lease function on each lease as that wants
to also reset the video mode, and during server shut down that
modesetting: Validate leases on VT enter
The kernel doesn't allow any master ioctls to run when another
VT is active, including simple things like listing the active
leases. To deal with that, we check the list of leases
whenever the X server VT is activated.
xfree86: hide disabled cursors when resetting after lease termination
The lessee may well have played with cursors and left one
active on our screen. Just tell the kernel to turn it off.
v6: Add meson build infrastructure
[Also bumped libdrm requirement - ajax]
Signed-off-by: Keith Packard <keithp@keithp.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2018-02-12 22:51:56 +01:00
|
|
|
if (RROutputIsLeased(output))
|
|
|
|
return BadAccess;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (!ValidAtom(stuff->property)) {
|
|
|
|
client->errorValue = stuff->property;
|
|
|
|
return BadAtom;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
2011-08-24 00:19:59 +02:00
|
|
|
prop = RRQueryOutputProperty(output, stuff->property);
|
2012-03-21 20:55:09 +01:00
|
|
|
if (!prop) {
|
|
|
|
client->errorValue = stuff->property;
|
|
|
|
return BadName;
|
2011-08-24 00:19:59 +02:00
|
|
|
}
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (prop->immutable) {
|
|
|
|
client->errorValue = stuff->property;
|
|
|
|
return BadAccess;
|
2011-08-24 00:19:59 +02:00
|
|
|
}
|
2006-09-21 07:43:05 +02:00
|
|
|
|
|
|
|
RRDeleteOutputProperty(output, stuff->property);
|
2010-05-11 05:22:05 +02:00
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int
|
2012-03-21 20:55:09 +01:00
|
|
|
ProcRRGetOutputProperty(ClientPtr client)
|
2006-09-21 07:43:05 +02:00
|
|
|
{
|
|
|
|
REQUEST(xRRGetOutputPropertyReq);
|
2012-03-21 20:55:09 +01:00
|
|
|
RRPropertyPtr prop, *prev;
|
|
|
|
RRPropertyValuePtr prop_value;
|
|
|
|
unsigned long n, len, ind;
|
|
|
|
RROutputPtr output;
|
|
|
|
xRRGetOutputPropertyReply reply;
|
|
|
|
char *extra = NULL;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
|
|
|
|
if (stuff->delete)
|
2012-03-21 20:55:09 +01:00
|
|
|
UpdateCurrentTime();
|
2009-04-29 07:04:37 +02:00
|
|
|
VERIFY_RR_OUTPUT(stuff->output, output,
|
2012-03-21 20:55:09 +01:00
|
|
|
stuff->delete ? DixWriteAccess : DixReadAccess);
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (!ValidAtom(stuff->property)) {
|
|
|
|
client->errorValue = stuff->property;
|
|
|
|
return BadAtom;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2012-03-21 20:55:09 +01:00
|
|
|
if ((stuff->delete != xTrue) && (stuff->delete != xFalse)) {
|
|
|
|
client->errorValue = stuff->delete;
|
|
|
|
return BadValue;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2012-03-21 20:55:09 +01:00
|
|
|
if ((stuff->type != AnyPropertyType) && !ValidAtom(stuff->type)) {
|
|
|
|
client->errorValue = stuff->type;
|
|
|
|
return BadAtom;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (prev = &output->properties; (prop = *prev); prev = &prop->next)
|
2012-03-21 20:55:09 +01:00
|
|
|
if (prop->propertyName == stuff->property)
|
|
|
|
break;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2012-07-10 04:12:43 +02:00
|
|
|
reply = (xRRGetOutputPropertyReply) {
|
|
|
|
.type = X_Reply,
|
|
|
|
.sequenceNumber = client->sequence
|
|
|
|
};
|
2012-03-21 20:55:09 +01:00
|
|
|
if (!prop) {
|
|
|
|
reply.nItems = 0;
|
|
|
|
reply.length = 0;
|
|
|
|
reply.bytesAfter = 0;
|
|
|
|
reply.propertyType = None;
|
|
|
|
reply.format = 0;
|
|
|
|
if (client->swapped) {
|
|
|
|
swaps(&reply.sequenceNumber);
|
|
|
|
swapl(&reply.length);
|
|
|
|
swapl(&reply.propertyType);
|
|
|
|
swapl(&reply.bytesAfter);
|
|
|
|
swapl(&reply.nItems);
|
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
|
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
2006-11-21 10:15:26 +01:00
|
|
|
if (prop->immutable && stuff->delete)
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadAccess;
|
2006-11-21 10:15:26 +01:00
|
|
|
|
2008-03-06 22:47:44 +01:00
|
|
|
prop_value = RRGetOutputProperty(output, stuff->property, stuff->pending);
|
|
|
|
if (!prop_value)
|
2012-03-21 20:55:09 +01:00
|
|
|
return BadAtom;
|
2008-03-06 22:47:44 +01:00
|
|
|
|
2006-09-21 07:43:05 +02:00
|
|
|
/* If the request type and actual type don't match. Return the
|
2012-03-21 20:55:09 +01:00
|
|
|
property information, but not the data. */
|
|
|
|
|
|
|
|
if (((stuff->type != prop_value->type) && (stuff->type != AnyPropertyType))
|
|
|
|
) {
|
|
|
|
reply.bytesAfter = prop_value->size;
|
|
|
|
reply.format = prop_value->format;
|
|
|
|
reply.length = 0;
|
|
|
|
reply.nItems = 0;
|
|
|
|
reply.propertyType = prop_value->type;
|
|
|
|
if (client->swapped) {
|
|
|
|
swaps(&reply.sequenceNumber);
|
|
|
|
swapl(&reply.length);
|
|
|
|
swapl(&reply.propertyType);
|
|
|
|
swapl(&reply.bytesAfter);
|
|
|
|
swapl(&reply.nItems);
|
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
|
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return type, format, value to client
|
|
|
|
*/
|
2012-03-21 20:55:09 +01:00
|
|
|
n = (prop_value->format / 8) * prop_value->size; /* size (bytes) of prop */
|
|
|
|
ind = stuff->longOffset << 2;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
/* If longOffset is invalid such that it causes "len" to
|
|
|
|
be negative, it's a value error. */
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (n < ind) {
|
|
|
|
client->errorValue = stuff->longOffset;
|
|
|
|
return BadValue;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
len = min(n - ind, 4 * stuff->longLength);
|
|
|
|
|
2008-08-21 01:32:03 +02:00
|
|
|
if (len) {
|
2012-03-21 20:55:09 +01:00
|
|
|
extra = malloc(len);
|
|
|
|
if (!extra)
|
|
|
|
return BadAlloc;
|
2008-08-21 01:32:03 +02:00
|
|
|
}
|
2006-09-21 07:43:05 +02:00
|
|
|
reply.bytesAfter = n - (ind + len);
|
2006-11-21 10:15:26 +01:00
|
|
|
reply.format = prop_value->format;
|
2009-07-06 04:24:27 +02:00
|
|
|
reply.length = bytes_to_int32(len);
|
2007-03-23 09:05:55 +01:00
|
|
|
if (prop_value->format)
|
2012-03-21 20:55:09 +01:00
|
|
|
reply.nItems = len / (prop_value->format / 8);
|
2007-03-23 09:05:55 +01:00
|
|
|
else
|
2012-03-21 20:55:09 +01:00
|
|
|
reply.nItems = 0;
|
2006-11-21 10:15:26 +01:00
|
|
|
reply.propertyType = prop_value->type;
|
2006-09-21 07:43:05 +02:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (stuff->delete && (reply.bytesAfter == 0)) {
|
2012-07-10 04:12:44 +02:00
|
|
|
xRROutputPropertyNotifyEvent event = {
|
|
|
|
.type = RREventBase + RRNotify,
|
|
|
|
.subCode = RRNotify_OutputProperty,
|
|
|
|
.output = output->id,
|
|
|
|
.state = PropertyDelete,
|
|
|
|
.atom = prop->propertyName,
|
|
|
|
.timestamp = currentTime.milliseconds
|
|
|
|
};
|
2012-03-21 20:55:09 +01:00
|
|
|
RRDeliverPropertyEvent(output->pScreen, (xEvent *) &event);
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
|
|
|
|
2008-08-21 01:32:03 +02:00
|
|
|
if (client->swapped) {
|
2012-03-21 20:55:09 +01:00
|
|
|
swaps(&reply.sequenceNumber);
|
|
|
|
swapl(&reply.length);
|
|
|
|
swapl(&reply.propertyType);
|
|
|
|
swapl(&reply.bytesAfter);
|
|
|
|
swapl(&reply.nItems);
|
2008-08-21 01:32:03 +02:00
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xGenericReply), &reply);
|
2012-03-21 20:55:09 +01:00
|
|
|
if (len) {
|
|
|
|
memcpy(extra, (char *) prop_value->data + ind, len);
|
|
|
|
switch (reply.format) {
|
|
|
|
case 32:
|
|
|
|
client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write;
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
client->pSwapReplyFunc = (ReplySwapPtr) CopySwap16Write;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
client->pSwapReplyFunc = (ReplySwapPtr) WriteToClient;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
WriteSwappedDataToClient(client, len, extra);
|
|
|
|
free(extra);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (stuff->delete && (reply.bytesAfter == 0)) { /* delete the Property */
|
|
|
|
*prev = prop->next;
|
|
|
|
RRDestroyOutputProperty(prop);
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|
2010-05-11 05:22:05 +02:00
|
|
|
return Success;
|
2006-09-21 07:43:05 +02:00
|
|
|
}
|