| Current Path : /proc/2/root/proc/self/root/proc/self/root/usr/share/doc/xorg-x11-proto-devel-7.7/ |
| Current File : //proc/2/root/proc/self/root/proc/self/root/usr/share/doc/xorg-x11-proto-devel-7.7/resproto.txt |
DRAFT FOR REVIEW
The X Resource Extension
Version 1.2
Rami Ylimäki
rami.ylimaki@vincit.fi
❧❧❧❧❧❧❧❧❧❧❧
1. Introduction
The protocol description of X Resource Extension version 1.1 has been
either lost or has never been written. This specification documents
version 1.0 based on reverse engineered library and server
code. Version 1.1 has been accidentally released from the version
control and while it doesn't have differences to version 1.0, this
version is labeled 1.2 in order to remove the risk of confusion. In
addition to the 1.0 description, this document introduces a new 1.2
version of the extension.
Version 1.2 is a minor release and therefore the changes are
compatible with the previous version. Main enhancements over version
1.0 are:
- Client identification is now possible. For example, servers
supporting version 1.2 may report PID of local clients.
- Size of any resource can be queried from the server. Servers may not
necessarily support size calculation for every resource. However,
clients have now at least the chance to let the server do resource
size estimation for them.
❧❧❧❧❧❧❧❧❧❧❧
2. Notations used in this document
Notation for data types and requests follows the guidelines set in
sections 2-4 of X Window System Protocol standard.
❧❧❧❧❧❧❧❧❧❧❧
3. Interoperability between version 1.1 and 1.2
Version 1.2 only introduces two new requests. However, these requests
could be seen as generalized versions of existing requests. Even
though we aren't deprecating any old requests, libraries could
implement some old requests using the new ones.
The new XResQueryClientIds request could be used instead of
XResQueryClients.
The new XResQueryResourceBytes request could be used instead of
XResQueryClientPixmapBytes.
Using the old requests is still acceptable because we don't want to
change the semantics of existing requests between version 1.1 and 1.2.
❧❧❧❧❧❧❧❧❧❧❧
4. Data types
4.1 Types in version 1.0
CLIENTXIDRANGE [ resource_base: CARD32
resource_mask: CARD32 ]
This type is used for reply of XResQueryClients in version 1.1. It
represents the range of resource allocated for a client and can be
also used for client identification.
resource_base
First resource ID reserved for a client. Used also to identify the
clients themselves.
resource_mask
Mask that can be used to identify a client from some resource
ID. Just zero the bits indicated by this mask from any resource ID
to identify the client that owns the resource.
CLIENTXID [ client: XID ]
This type identifies a single client by a resource owned by that
client or by the first resource ID allocated for the client
(resource_base of CLIENTXIDRANGE). Whenever a resource ID is used, it
is masked by resource_mask of CLIENTXIDRANGE to find out the client
that owns the resource.
CLIENTRESOURCETYPECOUNT [ resource_type: ATOM
count: CARD32 ]
This type is used for reply of XResQueryClientResources in version
1.1. It represents the number of certain type of resources that are
owned by some client.
resource_type
Atom specifying the type of a resource.
count
Number of resources of the given type owned by a client.
4.2 Types in version 1.2
4.2.1 Types used by XResQueryClientIds
CLIENTIDMASK { ClientXid = 0x1, LocalClientPid = 0x2 }
A bitmask specifying a client identification method. Currently only
the PID of local clients is supported in the form of
LocalClientPid. ClientXid is provided for backward compatibility with
version 1.0 so that the new 1.2 requests (XResQueryClientIds) can be
used in place of the older ones (XResQueryClients).
CLIENTIDSPEC [ client: CLIENTXID or None
mask: SETofCLIENTIDMASK or None ]
A data structure for selecting client IDs.
client
ID of a resource allocated for some client. Only the part
identifying a client is actually used. The resource_base of
CLIENTXIDRANGE can be used if the client doesn't own any
resources. However, any resource ID is accepted because that makes
identifying the owners of existing resources easy. The null
resource None can be used to select all clients.
mask
Collection of identification methods that should be applied on the
client. The special value None can be used to apply all supported
identification methods.
CLIENTIDVALUE [ spec: CLIENTIDSPEC
length: CARD32
value: LISTofCARD32 ]
A data structure specifying a single client ID.
spec
A unique identifier for a specific ID of some client. Wildcards
such as None and bitmask unions aren't allowed. The data structure
must always identify a single client and single ID type. However,
the client doesn't have to be specified as the resource_base of
CLIENTXIDRANGE and can be any resource owned by the client.
length
Specifies the length of an ID in units of CARD32. The length
depends on the ID type. In version 1.2 the lengths are 0 for
ClientXid and 4 for LocalClientPid. The length of ClientXid is 0
because that is already stored in the spec field.
value
Actual ID data. In version 1.2 this is missing for ClientXid and
consists of a single CARD32 for LocalClientPid.
4.2.2 Types used by XResQueryResourceBytes
To better understand how resources are related to each other, it's
useful to introduce the concepts of main resource and cross
reference. By main resource we just mean a normal resource that has a
valid XID. By cross reference we mean a resource that is used by some
other resource.
The same resource may have both of these roles depending on the
context. For example, there could be an ordinary pixmap resource. When
we talk about this resource in isolation the term main resource is
used. We call the exact same resource a cross reference when we are
concentrating on some higher level resource, such as window or
graphics context, that is using the lower level resource. Cross
references may also be internal server resources that don't have a
valid XID.
RESOURCEIDSPEC [ resource: XID or None
type: ATOM or None/AnyPropertyType ]
A data structure for selecting or identifying resources. The
interpretation of fields changes depending on the context. The
differences in interpretation are described below.
resource
An XID of a resource. The null resource None can be used to select
all resources matching some type if the data structure is used in
XResQueryResourceBytes request. The null resource None can be used
to mark private server resources if the data structure is used in
a cross reference of XResQueryResourceBytes reply.
type
An atom identifying the resource type. The null atom
None/AnyPropertyType can be used to select all resource types
matching some resource ID if the data structure is used in
XResQueryResourceBytes request.
RESOURCESIZESPEC [ spec: RESOURCEIDSPEC
bytes: CARD32
ref_count: CARD32
use_count: CARD32 ]
A data structure specifying the size of a single resource.
spec
Uniquely identifies a single resource. Wildcards such as None and
AnyPropertyType aren't allowed for main resources. In cross
references, None is used to mark internal server resources.
bytes
Number of bytes allocated for the resource. The size of a resource
is never divided by a reference count. This is the number of bytes
released in server when there are no more references left to the
resource.
ref_count
Number of total users of the resource. Typically the reference
count is 1 but for pixmaps and other resources used from different
contexts the count may be larger.
use_count
Number of times the resource is used by some other resource. For
main resources this is typically 1, because a resource doesn't
usually use itself recursively. For cross references this is the
number of times the resource is used and is also 1 usually.
RESOURCESIZEVALUE [ size: RESOURCESIZESPEC
num_cross_references: CARD32
cross_references: LISTofRESOURCESIZESPEC ]
A data structure specifying sizes of cross references to other
resources in addition to the main resource size.
size
Size of a main resource.
num_cross_references
Number of cross references to other resources from the main
resource. Currently resources can only have pixmaps as cross
references but this can be extended to other types in the
future. For simple resources this field is therefore 0 and the
cross_references list is missing.
cross_references:
Size specifications for cross references. Note that cross
references may contain resources that don't have a valid XID. For
example, a DRI2 drawable might have a cross reference to a private
pixmap that is used internally in the server only. These private
cross references are contained in this list also. This makes it
possible to emulate XResGetClientPixmapBytes with
XResGetResourceBytes.
❧❧❧❧❧❧❧❧❧❧❧
5. Requests
5.1 Requests in version 1.0
┌───
XResQueryVersion
client_major: CARD8
client_minor: CARD8
▶
server_major: CARD16
server_minor: CARD16
└───
The client sends the highest supported version to the server and the
server sends the highest version it supports, but no higher than the
requested version. Major version changes can introduce
incompatibilities in existing functionality, minor version changes
introduce only backward compatible changes. It is the client's
responsibility to ensure that the server supports a version which is
compatible with its expectations.
client_major
Major X Resource Extension version supported by client.
client_minor
Minor X Resource Extension version supported by client.
server_major
Highest version supported by server that is compatible with
client.
server_minor
Highest version supported by server that is compatible with
client.
┌───
XResQueryClients
▶
num_clients: CARD32
clients: LISTofCLIENTXIDRANGE
└───
The request asks X server to return the list of all currently
connected clients.
num_clients
Number of currently connected clients.
clients
List of XID ranges allocated for the connected clients.
┌───
XResQueryClientResources
client: CLIENTXID
▶
num_types: CARD32
types: LISTofCLIENTRESOURCETYPECOUNT
Errors: Value
└───
This request can be used to ask the number of resources owned by a
client. The server will return the counts of each type of resource.
client
An XID in the resource range of a client. This identifies the
client and not some specific resource.
num_types
Number of different resource types owned by the client.
types
A list of counts for each resource type.
A value error is generated if invalid resource or client XID is given
in the request.
┌───
XResQueryClientPixmapBytes
client: CLIENTXID
▶
bytes: CARD32
bytes_overflow: CARD32
Errors: Value
└───
This request is used to get the pixmap usage of some client. The
returned number is a sum of memory usage of each pixmap that can be
attributed to the given client. Ideally the server goes through all
pixmaps and divides each pixmap size by the pixmap reference count to
get a pixmap reference size. The reference size is then added to the
returned sum if the client happens to be referencing that pixmap. In
practice some pixmap references may be missed, because it would be too
difficult to keep track of all pixmap references. However, the server
will check the most important client resources that are using pixmaps
and tries to estimate the pixmap usage as well as is possible. In
other words, the server need only make a best-effort attempt to
calculate resource source, so actual resource size may differ from
that reported in practice.
client
Identifies a client by an ID in its resource ID range.
bytes:
Number of bytes attributed to pixmap references from the client
resources.
bytes_overflow:
Higher order word for the bytes field in case the sum of pixmap
reference sizes doesn't fit in CARD32.
A value error is generated if invalid resource or client XID is given
in the request.
5.2 Requests in version 1.2
┌───
XResQueryClientIds
num_specs: CARD32
client_specs: LISTofCLIENTIDSPEC
▶
num_ids: CARD32
client_ids: LISTofCLIENTIDVALUE
Errors: Value
└───
XResQueryClientIds can be used to identify a given set of clients with
some identification method. The request sends a list of specifiers
that select clients and identification methods to server. The server
then tries to identify the chosen clients using the identification
methods specified for each client. The server returns IDs for those
clients that were successfully identified. It's not an error condition
if some identification method couldn't be applied to a client. If the
server is unable to identify some clients, they simply aren't included
in the returned list.
The request supports wildcards in the client specifications so that in
the most general case all IDs of all clients can be queried with a
single CLIENTIDSPEC.
The CLIENTIDSPEC of request and CLIENTIDSPEC of CLIENTIDVALUE in reply
usually match each other. For example, if a request selected a client
by a resource ID owned by the client, then the client is identified by
the same resource ID in the reply. This has been done so that it would
be easy to identify an owner of some resource.
However, the CLIENTIDSPEC of returned CLIENTIDVALUE never contains any
wildcards. If the request used a wildcard to specify all clients in a
single CLIENTIDSPEC, then the reply has expanded the wildcard and
returns separate CLIENTIDVALUE records for each client. In this case
wildcarded clients are identified by resource_base of CLIENTXIDRANGE.
The LocalClientPid type of IDs are included in the reply list only if
the client executing the request asked for it and was also a local
client itself. It doesn't make sense for remote clients to ask PIDs of
local clients.
num_specs
Number of client ID specifications.
client_specs
A list specifying identification methods for clients. Supports
multiple identification methods and clients in a single
specification. See CLIENTIDSPEC for details.
num_ids
Number of IDs that were successfully determined. Can be different
from num_specs or even zero if the server didn't support any
identification methods for the given clients.
client_ids
A list specifying ID information for successfully identified
clients. If wildcards were used in a single CLIENTIDSPEC of
client_specs, then multiple CLIENTIDVALUE records may be returned
for that CLIENTIDSPEC. See CLIENTIDVALUE for details.
A Value error is returned if the request specifies an invalid client
XID or invalid identification method type.
┌───
XResQueryResourceBytes
client: CLIENTXID or None
num_specs: CARD32
resource_specs: LISTofRESOURCEIDSPEC
▶
num_sizes: CARD32
sizes: LISTofRESOURCESIZEVALUE
Errors: Atom, Value
└───
XResQueryResourceBytes can be used to ask the sizes of resources from
X server. The request sends a list of specifiers that selects
resources for size calculation. The server tries to calculate the
sizes of chosen resources and returns an estimate for a resource only
if the size could be determined. It's not an error condition if a size
couldn't be calculated. In that case the resources simply aren't
included in the returned list.
The request supports wildcards so that in the most general case sizes
of all resources of all clients can be queried with a single
RESOURCEIDSPEC. However, the reply has all wildcards expanded and
reports a size of a single resource in each RESOURCESIZEVALUE.
client
An ID of a client can be given to limit the query to resources of
that client. Just like in CLIENTIDSPEC, any resource ID can be
given to identify a client and None can be used if the query
shouldn't be limited to a specific client. Note that in some cases
this field is redundant because resource_specs already fully
determines which resources are selected. If the client ID doesn't
match the owner of any resource in resource_specs, no sizes are
returned and no error is generated.
num_specs
Number of resource specifications.
resource_specs
A list of resource specifications. Each specification can either
uniquely identify a single resource or multiple resources if
wildcarding is used. See RESOURCEIDSPEC for details.
num_sizes
Number of resources whose size could be determined. Can be
different from num_specs or even zero if the server didn't support
size calculation for the given resources.
sizes
A list of resource sizes. Each resource size is linked to a unique
resource. Wildcards are never used in the returned size
records. For example, it's not possible to receive a single
RESOURCESIZEVALUE that would specify the size of all pixmaps if
the sizes of pixmap type resources were asked. Instead, a single
RESOURCESIZEVALUE would be returned for each pixmap in that case.
An Atom error is returned if the request specifies an invalid resource
type. A Value error is returned if the request specifies an invalid
XID for a client or a resource.
❧❧❧❧❧❧❧❧❧❧❧
Copyright 2K16 - 2K18 Indonesian Hacker Rulez
;?>)