privates.c 22 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/*

Copyright 1993, 1998  The Open Group

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.

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall
not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization
from The Open Group.

*/
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
/*
 * Copyright © 2010, Keith Packard
 * Copyright © 2010, Jamey Sharp
 *
 * 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.
 */
50

51 52 53 54
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif

55
#include <stddef.h>
56 57
#include "windowstr.h"
#include "resource.h"
58
#include "privates.h"
59
#include "gcstruct.h"
60
#include "cursorstr.h"
61
#include "colormapst.h"
62
#include "inputstr.h"
63 64
#include "scrnintstr.h"
#include "extnsionst.h"
65
#include "inputstr.h"
66

67
static DevPrivateSetRec global_keys[PRIVATE_LAST];
68 69

static const Bool xselinux_private[PRIVATE_LAST] = {
70
    [PRIVATE_SCREEN] = TRUE,
71 72 73 74 75 76 77 78 79 80 81 82
    [PRIVATE_CLIENT] = TRUE,
    [PRIVATE_WINDOW] = TRUE,
    [PRIVATE_PIXMAP] = TRUE,
    [PRIVATE_GC] = TRUE,
    [PRIVATE_CURSOR] = TRUE,
    [PRIVATE_COLORMAP] = TRUE,
    [PRIVATE_DEVICE] = TRUE,
    [PRIVATE_EXTENSION] = TRUE,
    [PRIVATE_SELECTION] = TRUE,
    [PRIVATE_PROPERTY] = TRUE,
    [PRIVATE_PICTURE] = TRUE,
    [PRIVATE_GLYPHSET] = TRUE,
83 84
};

85 86 87 88 89 90 91 92 93 94
static const char *key_names[PRIVATE_LAST] = {
    /* XSELinux uses the same private keys for numerous objects */
    [PRIVATE_XSELINUX] = "XSELINUX",

    /* Otherwise, you get a private in just the requested structure
     */
    /* These can have objects created before all of the keys are registered */
    [PRIVATE_SCREEN] = "SCREEN",
    [PRIVATE_EXTENSION] = "EXTENSION",
    [PRIVATE_COLORMAP] = "COLORMAP",
95
    [PRIVATE_DEVICE] = "DEVICE",
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130

    /* These cannot have any objects before all relevant keys are registered */
    [PRIVATE_CLIENT] = "CLIENT",
    [PRIVATE_PROPERTY] = "PROPERTY",
    [PRIVATE_SELECTION] = "SELECTION",
    [PRIVATE_WINDOW] = "WINDOW",
    [PRIVATE_PIXMAP] = "PIXMAP",
    [PRIVATE_GC] = "GC",
    [PRIVATE_CURSOR] = "CURSOR",
    [PRIVATE_CURSOR_BITS] = "CURSOR_BITS",

    /* extension privates */
    [PRIVATE_DAMAGE] = "DAMAGE",
    [PRIVATE_GLYPH] = "GLYPH",
    [PRIVATE_GLYPHSET] = "GLYPHSET",
    [PRIVATE_PICTURE] = "PICTURE",
    [PRIVATE_SYNC_FENCE] = "SYNC_FENCE",
};

static const Bool screen_specific_private[PRIVATE_LAST] = {
    [PRIVATE_SCREEN] = FALSE,
    [PRIVATE_CLIENT] = FALSE,
    [PRIVATE_WINDOW] = TRUE,
    [PRIVATE_PIXMAP] = TRUE,
    [PRIVATE_GC] = TRUE,
    [PRIVATE_CURSOR] = FALSE,
    [PRIVATE_COLORMAP] = FALSE,
    [PRIVATE_DEVICE] = FALSE,
    [PRIVATE_EXTENSION] = FALSE,
    [PRIVATE_SELECTION] = FALSE,
    [PRIVATE_PROPERTY] = FALSE,
    [PRIVATE_PICTURE] = TRUE,
    [PRIVATE_GLYPHSET] = FALSE,
};

131
typedef Bool (*FixupFunc) (PrivatePtr *privates, int offset, unsigned bytes);
132

133 134
typedef enum { FixupMove, FixupRealloc } FixupType;

135 136 137
static Bool
dixReallocPrivates(PrivatePtr *privates, int old_offset, unsigned bytes)
{
138
    void *new_privates;
139

140 141
    new_privates = realloc(*privates, old_offset + bytes);
    if (!new_privates)
142
        return FALSE;
143 144 145 146
    memset((char *) new_privates + old_offset, '\0', bytes);
    *privates = new_privates;
    return TRUE;
}
147

148 149
static Bool
dixMovePrivates(PrivatePtr *privates, int new_offset, unsigned bytes)
150
{
151 152 153 154
    memmove((char *) *privates + bytes, *privates, new_offset - bytes);
    memset(*privates, '\0', bytes);
    return TRUE;
}
155

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
static Bool
fixupOneScreen(ScreenPtr pScreen, FixupFunc fixup, unsigned bytes)
{
    intptr_t        dist;
    char            *old;
    char            *new;
    DevPrivateKey   *keyp, key;
    DevPrivateType  type;
    int             size;

    old = (char *) pScreen->devPrivates;
    size = global_keys[PRIVATE_SCREEN].offset;
    if (!fixup (&pScreen->devPrivates, size, bytes))
        return FALSE;

    /* Screen privates can contain screen-specific private keys
     * for other types. When they move, the linked list we use to
     * track them gets scrambled. Fix that by computing the change
     * in the location of each private adjusting our linked list
     * pointers to match
     */

    new = (char *) pScreen->devPrivates;

    /* Moving means everyone shifts up in the privates by 'bytes' amount,
     * realloc means the base pointer moves
     */
    if (fixup == dixMovePrivates)
        new += bytes;

    dist = new - old;

    if (dist) {
        for (type = PRIVATE_XSELINUX; type < PRIVATE_LAST; type++)

            /* Walk the privates list, being careful as the
             * pointers are scrambled before we patch them.
             */
            for (keyp = &pScreen->screenSpecificPrivates[type].key;
                 (key = *keyp) != NULL;
                 keyp = &key->next)
            {

                /* Only mangle things if the private structure
                 * is contained within the allocation. Privates
                 * stored elsewhere will be left alone
                 */
                if (old <= (char *) key && (char *) key < old + size)
                {
                    /* Compute new location of key */
                    key = (DevPrivateKey) ((char *) key + dist);

                    /* Patch the list */
                    *keyp = key;
                }
            }
    }
    return TRUE;
}

216 217 218 219
static Bool
fixupScreens(FixupFunc fixup, unsigned bytes)
{
    int s;
220

221
    for (s = 0; s < screenInfo.numScreens; s++)
222
        if (!fixupOneScreen (screenInfo.screens[s], fixup, bytes))
223
            return FALSE;
224 225 226 227

    for (s = 0; s < screenInfo.numGPUScreens; s++)
        if (!fixupOneScreen (screenInfo.gpuscreens[s], fixup, bytes))
            return FALSE;
228 229
    return TRUE;
}
230

231 232 233 234
static Bool
fixupServerClient(FixupFunc fixup, unsigned bytes)
{
    if (serverClient)
235
        return fixup(&serverClient->devPrivates, global_keys[PRIVATE_CLIENT].offset,
236
                     bytes);
237
    return TRUE;
238 239
}

240 241
static Bool
fixupExtensions(FixupFunc fixup, unsigned bytes)
242
{
243 244 245 246 247 248
    unsigned char major;
    ExtensionEntry *extension;

    for (major = EXTENSION_BASE; (extension = GetExtensionEntry(major));
         major++)
        if (!fixup
249
            (&extension->devPrivates, global_keys[PRIVATE_EXTENSION].offset, bytes))
250
            return FALSE;
251
    return TRUE;
252 253
}

254 255
static Bool
fixupDefaultColormaps(FixupFunc fixup, unsigned bytes)
256
{
257
    int s;
258

259
    for (s = 0; s < screenInfo.numScreens; s++) {
260 261 262 263 264 265
        ColormapPtr cmap;

        dixLookupResourceByType((pointer *) &cmap,
                                screenInfo.screens[s]->defColormap, RT_COLORMAP,
                                serverClient, DixCreateAccess);
        if (cmap &&
266
            !fixup(&cmap->devPrivates, screenInfo.screens[s]->screenSpecificPrivates[PRIVATE_COLORMAP].offset, bytes))
267
            return FALSE;
268
    }
269 270
    return TRUE;
}
271

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
static Bool
fixupDeviceList(DeviceIntPtr device, FixupFunc fixup, unsigned bytes)
{
    while (device) {
        if (!fixup(&device->devPrivates, global_keys[PRIVATE_DEVICE].offset, bytes))
            return FALSE;
        device = device->next;
    }
    return TRUE;
}

static Bool
fixupDevices(FixupFunc fixup, unsigned bytes)
{
    return (fixupDeviceList(inputInfo.devices, fixup, bytes) &&
            fixupDeviceList(inputInfo.off_devices, fixup, bytes));
}

290
static Bool (*const allocated_early[PRIVATE_LAST]) (FixupFunc, unsigned) = {
291 292 293 294
    [PRIVATE_SCREEN] = fixupScreens,
    [PRIVATE_CLIENT] = fixupServerClient,
    [PRIVATE_EXTENSION] = fixupExtensions,
    [PRIVATE_COLORMAP] = fixupDefaultColormaps,
295
    [PRIVATE_DEVICE] = fixupDevices,
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
};

static void
grow_private_set(DevPrivateSetPtr set, unsigned bytes)
{
    DevPrivateKey       k;

    for (k = set->key; k; k = k->next)
        k->offset += bytes;
    set->offset += bytes;
}

static void
grow_screen_specific_set(DevPrivateType type, unsigned bytes)
{
    int s;

    /* Update offsets for all screen-specific keys */
    for (s = 0; s < screenInfo.numScreens; s++) {
        ScreenPtr       pScreen = screenInfo.screens[s];

317 318 319 320 321
        grow_private_set(&pScreen->screenSpecificPrivates[type], bytes);
    }
    for (s = 0; s < screenInfo.numGPUScreens; s++) {
        ScreenPtr       pScreen = screenInfo.gpuscreens[s];

322 323 324
        grow_private_set(&pScreen->screenSpecificPrivates[type], bytes);
    }
}
325

326
/*
327 328 329 330 331 332
 * Register a private key. This takes the type of object the key will
 * be used with, which may be PRIVATE_ALL indicating that this key
 * will be used with all of the private objects. If 'size' is
 * non-zero, then the specified amount of space will be allocated in
 * the private storage. Otherwise, space for a single pointer will
 * be allocated which can be set with dixSetPrivate
333
 */
334 335
Bool
dixRegisterPrivateKey(DevPrivateKey key, DevPrivateType type, unsigned size)
336
{
337 338 339
    DevPrivateType t;
    int offset;
    unsigned bytes;
340

341
    if (key->initialized) {
342 343
        assert(size == key->size);
        return TRUE;
344 345
    }

346 347 348
    /* Compute required space */
    bytes = size;
    if (size == 0)
349
        bytes = sizeof(void *);
350 351

    /* align to void * size */
352
    bytes = (bytes + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
353 354 355

    /* Update offsets for all affected keys */
    if (type == PRIVATE_XSELINUX) {
356 357 358 359 360 361

        /* Resize if we can, or make sure nothing's allocated if we can't
         */
        for (t = PRIVATE_XSELINUX; t < PRIVATE_LAST; t++)
            if (xselinux_private[t]) {
                if (!allocated_early[t])
362
                    assert(!global_keys[t].created);
363 364 365 366 367 368 369 370 371
                else if (!allocated_early[t] (dixReallocPrivates, bytes))
                    return FALSE;
            }

        /* Move all existing keys up in the privates space to make
         * room for this new global key
         */
        for (t = PRIVATE_XSELINUX; t < PRIVATE_LAST; t++) {
            if (xselinux_private[t]) {
372 373
                grow_private_set(&global_keys[t], bytes);
                grow_screen_specific_set(t, bytes);
374 375 376
                if (allocated_early[t])
                    allocated_early[t] (dixMovePrivates, bytes);
            }
377

378 379 380 381 382 383 384
        }

        offset = 0;
    }
    else {
        /* Resize if we can, or make sure nothing's allocated if we can't */
        if (!allocated_early[type])
385
            assert(!global_keys[type].created);
386 387
        else if (!allocated_early[type] (dixReallocPrivates, bytes))
            return FALSE;
388 389 390
        offset = global_keys[type].offset;
        global_keys[type].offset += bytes;
        grow_screen_specific_set(type, bytes);
391
    }
392

393 394 395 396 397
    /* Setup this key */
    key->offset = offset;
    key->size = size;
    key->initialized = TRUE;
    key->type = type;
398
    key->allocated = FALSE;
399 400
    key->next = global_keys[type].key;
    global_keys[type].key = key;
401 402

    return TRUE;
403 404
}

405
Bool
406 407
dixRegisterScreenPrivateKey(DevScreenPrivateKey screenKey, ScreenPtr pScreen,
                            DevPrivateType type, unsigned size)
408
{
409
    DevPrivateKey key;
410

411
    if (!dixRegisterPrivateKey(&screenKey->screenKey, PRIVATE_SCREEN, 0))
412
        return FALSE;
413 414
    key = dixGetPrivate(&pScreen->devPrivates, &screenKey->screenKey);
    if (key != NULL) {
415 416 417
        assert(key->size == size);
        assert(key->type == type);
        return TRUE;
418
    }
419
    key = calloc(sizeof(DevPrivateKeyRec), 1);
420
    if (!key)
421
        return FALSE;
422
    if (!dixRegisterPrivateKey(key, type, size)) {
423 424
        free(key);
        return FALSE;
425 426
    }
    key->allocated = TRUE;
427 428 429 430 431 432 433 434
    dixSetPrivate(&pScreen->devPrivates, &screenKey->screenKey, key);
    return TRUE;
}

DevPrivateKey
_dixGetScreenPrivateKey(const DevScreenPrivateKey key, ScreenPtr pScreen)
{
    return dixGetPrivate(&pScreen->devPrivates, &key->screenKey);
435 436
}

437
/*
438
 * Initialize privates by zeroing them
439
 */
440 441
void
_dixInitPrivates(PrivatePtr *privates, void *addr, DevPrivateType type)
442
{
443 444 445
    assert (!screen_specific_private[type]);

    global_keys[type].created++;
446
    if (xselinux_private[type])
447 448
        global_keys[PRIVATE_XSELINUX].created++;
    if (global_keys[type].offset == 0)
449
        addr = 0;
450
    *privates = addr;
451
    memset(addr, '\0', global_keys[type].offset);
452
}
453

454 455 456 457 458 459
/*
 * Clean up privates
 */
void
_dixFiniPrivates(PrivatePtr privates, DevPrivateType type)
{
460
    global_keys[type].created--;
461
    if (xselinux_private[type])
462
        global_keys[PRIVATE_XSELINUX].created--;
463 464 465
}

/*
466 467 468 469
 * Allocate new object with privates.
 *
 * This is expected to be invoked from the
 * dixAllocateObjectWithPrivates macro
470
 */
471
void *
472 473
_dixAllocateObjectWithPrivates(unsigned baseSize, unsigned clear,
                               unsigned offset, DevPrivateType type)
474
{
475 476 477 478
    unsigned totalSize;
    void *object;
    PrivatePtr privates;
    PrivatePtr *devPrivates;
479

480
    assert(type > PRIVATE_SCREEN && type < PRIVATE_LAST);
481
    assert(!screen_specific_private[type]);
482 483

    /* round up so that void * is aligned */
484
    baseSize = (baseSize + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
485
    totalSize = baseSize + global_keys[type].offset;
486 487
    object = malloc(totalSize);
    if (!object)
488
        return NULL;
489

490 491 492
    memset(object, '\0', clear);
    privates = (PrivatePtr) (((char *) object) + baseSize);
    devPrivates = (PrivatePtr *) ((char *) object + offset);
493

494 495 496
    _dixInitPrivates(devPrivates, privates, type);

    return object;
497 498 499
}

/*
500 501
 * Allocate privates separately from containing object.
 * Used for clients and screens.
502
 */
503 504
Bool
dixAllocatePrivates(PrivatePtr *privates, DevPrivateType type)
505
{
506 507
    unsigned size;
    PrivatePtr p;
508

509
    assert(type > PRIVATE_XSELINUX && type < PRIVATE_LAST);
510
    assert(!screen_specific_private[type]);
511

512
    size = global_keys[type].offset;
513
    if (!size) {
514 515 516 517 518
        p = NULL;
    }
    else {
        if (!(p = malloc(size)))
            return FALSE;
519 520
    }

521
    _dixInitPrivates(privates, p, type);
522
    ++global_keys[type].allocated;
523 524

    return TRUE;
525 526
}

527
/*
528 529 530 531
 * Free an object that has privates
 *
 * This is expected to be invoked from the
 * dixFreeObjectWithPrivates macro
532
 */
533
void
534 535
_dixFreeObjectWithPrivates(void *object, PrivatePtr privates,
                           DevPrivateType type)
536
{
537 538 539
    _dixFiniPrivates(privates, type);
    free(object);
}
540

541 542 543 544 545 546 547
/*
 * Called to free screen or client privates
 */
void
dixFreePrivates(PrivatePtr privates, DevPrivateType type)
{
    _dixFiniPrivates(privates, type);
548
    --global_keys[type].allocated;
549
    free(privates);
550 551
}

552 553 554 555 556 557
/*
 * Return size of privates for the specified type
 */
extern _X_EXPORT int
dixPrivatesSize(DevPrivateType type)
{
558
    assert(type >= PRIVATE_SCREEN && type < PRIVATE_LAST);
559
    assert (!screen_specific_private[type]);
560

561
    return global_keys[type].offset;
562 563
}

564
/* Table of devPrivates offsets */
565
static const int offsets[] = {
566 567 568 569 570 571 572
    -1,                         /* RT_NONE */
    offsetof(WindowRec, devPrivates),   /* RT_WINDOW */
    offsetof(PixmapRec, devPrivates),   /* RT_PIXMAP */
    offsetof(GC, devPrivates),  /* RT_GC */
    -1,                         /* RT_FONT */
    offsetof(CursorRec, devPrivates),   /* RT_CURSOR */
    offsetof(ColormapRec, devPrivates), /* RT_COLORMAP */
573
};
574

575
#define NUM_OFFSETS	(sizeof (offsets) / sizeof (offsets[0]))
576

577
int
578
dixLookupPrivateOffset(RESTYPE type)
579
{
580 581 582 583 584
    /*
     * Special kludge for DBE which registers a new resource type that
     * points at pixmaps (thanks, DBE)
     */
    if (type & RC_DRAWABLE) {
585 586 587 588
        if (type == RT_WINDOW)
            return offsets[RT_WINDOW & TypeMask];
        else
            return offsets[RT_PIXMAP & TypeMask];
589
    }
590
    type = type & TypeMask;
591
    if (type < NUM_OFFSETS)
592
        return offsets[type];
593
    return -1;
594
}
595

596 597 598
/*
 * Screen-specific privates
 */
599

600 601 602 603 604 605
extern _X_EXPORT Bool
dixRegisterScreenSpecificPrivateKey(ScreenPtr pScreen, DevPrivateKey key,
                                    DevPrivateType type, unsigned size)
{
    int offset;
    unsigned bytes;
606

607 608 609
    if (!screen_specific_private[type])
        FatalError("Attempt to allocate screen-specific private storage for type %s\n",
                   key_names[type]);
610

611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
    if (key->initialized) {
        assert(size == key->size);
        return TRUE;
    }

    /* Compute required space */
    bytes = size;
    if (size == 0)
        bytes = sizeof(void *);

    /* align to void * size */
    bytes = (bytes + sizeof(void *) - 1) & ~(sizeof(void *) - 1);

    assert (!allocated_early[type]);
    assert (!pScreen->screenSpecificPrivates[type].created);
    offset = pScreen->screenSpecificPrivates[type].offset;
    pScreen->screenSpecificPrivates[type].offset += bytes;

    /* Setup this key */
    key->offset = offset;
    key->size = size;
    key->initialized = TRUE;
    key->type = type;
    key->allocated = FALSE;
    key->next = pScreen->screenSpecificPrivates[type].key;
    pScreen->screenSpecificPrivates[type].key = key;

    return TRUE;
}

/* Clean up screen-specific privates before CloseScreen */
void
dixFreeScreenSpecificPrivates(ScreenPtr pScreen)
{
}

/* Initialize screen-specific privates in AddScreen */
void
dixInitScreenSpecificPrivates(ScreenPtr pScreen)
{
    DevPrivateType      t;

    for (t = PRIVATE_XSELINUX; t < PRIVATE_LAST; t++)
        pScreen->screenSpecificPrivates[t].offset = global_keys[t].offset;
}

/* Initialize screen-specific privates in AddScreen */
void
_dixInitScreenPrivates(ScreenPtr pScreen, PrivatePtr *privates, void *addr, DevPrivateType type)
{
    int privates_size;
    assert (screen_specific_private[type]);

    if (pScreen) {
        privates_size = pScreen->screenSpecificPrivates[type].offset;
        pScreen->screenSpecificPrivates[type].created++;
    }
    else
        privates_size = global_keys[type].offset;

    global_keys[type].created++;
    if (xselinux_private[type])
        global_keys[PRIVATE_XSELINUX].created++;
    if (privates_size == 0)
        addr = 0;
    *privates = addr;
    memset(addr, '\0', privates_size);
}

void *
_dixAllocateScreenObjectWithPrivates(ScreenPtr pScreen,
                                     unsigned baseSize,
                                     unsigned clear,
                                     unsigned offset,
                                     DevPrivateType type)
{
    unsigned totalSize;
    void *object;
    PrivatePtr privates;
    PrivatePtr *devPrivates;
    int privates_size;

    assert(type > PRIVATE_SCREEN && type < PRIVATE_LAST);
    assert (screen_specific_private[type]);

    if (pScreen)
        privates_size = pScreen->screenSpecificPrivates[type].offset;
    else
        privates_size = global_keys[type].offset;
    /* round up so that void * is aligned */
    baseSize = (baseSize + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
    totalSize = baseSize + privates_size;
    object = malloc(totalSize);
    if (!object)
        return NULL;

    memset(object, '\0', clear);
    privates = (PrivatePtr) (((char *) object) + baseSize);
    devPrivates = (PrivatePtr *) ((char *) object + offset);

    _dixInitScreenPrivates(pScreen, devPrivates, privates, type);

    return object;
}

int
dixScreenSpecificPrivatesSize(ScreenPtr pScreen, DevPrivateType type)
{
    assert(type >= PRIVATE_SCREEN && type < PRIVATE_LAST);

    if (screen_specific_private[type])
        return pScreen->screenSpecificPrivates[type].offset;
    else
        return global_keys[type].offset;
}
726

727 728 729
void
dixPrivateUsage(void)
{
730
    int objects = 0;
731
    int bytes = 0;
732 733 734 735
    int alloc = 0;
    DevPrivateType t;

    for (t = PRIVATE_XSELINUX + 1; t < PRIVATE_LAST; t++) {
736
        if (global_keys[t].offset) {
737 738
            ErrorF
                ("%s: %d objects of %d bytes = %d total bytes %d private allocs\n",
739 740 741 742 743
                 key_names[t], global_keys[t].created, global_keys[t].offset,
                 global_keys[t].created * global_keys[t].offset, global_keys[t].allocated);
            bytes += global_keys[t].created * global_keys[t].offset;
            objects += global_keys[t].created;
            alloc += global_keys[t].allocated;
744
        }
745
    }
746
    ErrorF("TOTAL: %d objects, %d bytes, %d allocs\n", objects, bytes, alloc);
747 748 749
}

void
750
dixResetPrivates(void)
751
{
752
    DevPrivateType t;
753 754

    for (t = PRIVATE_XSELINUX; t < PRIVATE_LAST; t++) {
755 756
        DevPrivateKey key, next;

757
        for (key = global_keys[t].key; key; key = next) {
758 759 760 761 762 763 764 765
            next = key->next;
            key->offset = 0;
            key->initialized = FALSE;
            key->size = 0;
            key->type = 0;
            if (key->allocated)
                free(key);
        }
766
        if (global_keys[t].created) {
767
            ErrorF("%d %ss still allocated at reset\n",
768
                   global_keys[t].created, key_names[t]);
769 770
            dixPrivateUsage();
        }
771 772 773 774
        global_keys[t].key = NULL;
        global_keys[t].offset = 0;
        global_keys[t].created = 0;
        global_keys[t].allocated = 0;
775 776
    }
}