D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
usr
/
share
/
doc
/
xorgproto
/
Filename :
resproto.txt
back
Copy
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. ❧❧❧❧❧❧❧❧❧❧❧