xserver

xserver with xephyr scale patch
git clone https://git.neptards.moe/u3shit/xserver.git
Log | Files | Refs | README | LICENSE

misyncshm.c (5296B)

      1 /*
      2  * Copyright © 2013 Keith Packard
      3  *
      4  * Permission to use, copy, modify, distribute, and sell this software and its
      5  * documentation for any purpose is hereby granted without fee, provided that
      6  * the above copyright notice appear in all copies and that both that copyright
      7  * notice and this permission notice appear in supporting documentation, and
      8  * that the name of the copyright holders not be used in advertising or
      9  * publicity pertaining to distribution of the software without specific,
     10  * written prior permission.  The copyright holders make no representations
     11  * about the suitability of this software for any purpose.  It is provided "as
     12  * is" without express or implied warranty.
     13  *
     14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
     15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
     16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
     17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
     18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
     19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
     20  * OF THIS SOFTWARE.
     21  */
     22 
     23 #ifdef HAVE_DIX_CONFIG_H
     24 #include <dix-config.h>
     25 #endif
     26 
     27 #include "scrnintstr.h"
     28 #include "misync.h"
     29 #include "misyncstr.h"
     30 #include "misyncshm.h"
     31 #include "misyncfd.h"
     32 #include "pixmapstr.h"
     33 #include <sys/mman.h>
     34 #include <unistd.h>
     35 #include <fcntl.h>
     36 #include <X11/xshmfence.h>
     37 
     38 static DevPrivateKeyRec syncShmFencePrivateKey;
     39 
     40 typedef struct _SyncShmFencePrivate {
     41     struct xshmfence    *fence;
     42     int                 fd;
     43 } SyncShmFencePrivateRec, *SyncShmFencePrivatePtr;
     44 
     45 #define SYNC_FENCE_PRIV(pFence) \
     46     (SyncShmFencePrivatePtr) dixLookupPrivate(&pFence->devPrivates, &syncShmFencePrivateKey)
     47 
     48 static void
     49 miSyncShmFenceSetTriggered(SyncFence * pFence)
     50 {
     51     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
     52 
     53     if (pPriv->fence)
     54         xshmfence_trigger(pPriv->fence);
     55     miSyncFenceSetTriggered(pFence);
     56 }
     57 
     58 static void
     59 miSyncShmFenceReset(SyncFence * pFence)
     60 {
     61     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
     62 
     63     if (pPriv->fence)
     64         xshmfence_reset(pPriv->fence);
     65     miSyncFenceReset(pFence);
     66 }
     67 
     68 static Bool
     69 miSyncShmFenceCheckTriggered(SyncFence * pFence)
     70 {
     71     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
     72 
     73     if (pPriv->fence)
     74         return xshmfence_query(pPriv->fence);
     75     else
     76         return miSyncFenceCheckTriggered(pFence);
     77 }
     78 
     79 static void
     80 miSyncShmFenceAddTrigger(SyncTrigger * pTrigger)
     81 {
     82     miSyncFenceAddTrigger(pTrigger);
     83 }
     84 
     85 static void
     86 miSyncShmFenceDeleteTrigger(SyncTrigger * pTrigger)
     87 {
     88     miSyncFenceDeleteTrigger(pTrigger);
     89 }
     90 
     91 static const SyncFenceFuncsRec miSyncShmFenceFuncs = {
     92     &miSyncShmFenceSetTriggered,
     93     &miSyncShmFenceReset,
     94     &miSyncShmFenceCheckTriggered,
     95     &miSyncShmFenceAddTrigger,
     96     &miSyncShmFenceDeleteTrigger
     97 };
     98 
     99 static void
    100 miSyncShmScreenCreateFence(ScreenPtr pScreen, SyncFence * pFence,
    101                         Bool initially_triggered)
    102 {
    103     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
    104 
    105     pPriv->fence = NULL;
    106     miSyncScreenCreateFence(pScreen, pFence, initially_triggered);
    107     pFence->funcs = miSyncShmFenceFuncs;
    108 }
    109 
    110 static void
    111 miSyncShmScreenDestroyFence(ScreenPtr pScreen, SyncFence * pFence)
    112 {
    113     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
    114 
    115     if (pPriv->fence) {
    116         xshmfence_trigger(pPriv->fence);
    117         xshmfence_unmap_shm(pPriv->fence);
    118         close(pPriv->fd);
    119     }
    120     miSyncScreenDestroyFence(pScreen, pFence);
    121 }
    122 
    123 static int
    124 miSyncShmCreateFenceFromFd(ScreenPtr pScreen, SyncFence *pFence, int fd, Bool initially_triggered)
    125 {
    126     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
    127 
    128     miSyncInitFence(pScreen, pFence, initially_triggered);
    129 
    130     fd = os_move_fd(fd);
    131     pPriv->fence = xshmfence_map_shm(fd);
    132     if (pPriv->fence) {
    133         pPriv->fd = fd;
    134         return Success;
    135     }
    136     else
    137         close(fd);
    138     return BadValue;
    139 }
    140 
    141 static int
    142 miSyncShmGetFenceFd(ScreenPtr pScreen, SyncFence *pFence)
    143 {
    144     SyncShmFencePrivatePtr      pPriv = SYNC_FENCE_PRIV(pFence);
    145 
    146     if (!pPriv->fence) {
    147         pPriv->fd = xshmfence_alloc_shm();
    148         if (pPriv->fd < 0)
    149             return -1;
    150         pPriv->fd = os_move_fd(pPriv->fd);
    151         pPriv->fence = xshmfence_map_shm(pPriv->fd);
    152         if (!pPriv->fence) {
    153             close (pPriv->fd);
    154             return -1;
    155         }
    156     }
    157     return pPriv->fd;
    158 }
    159 
    160 static const SyncFdScreenFuncsRec miSyncShmScreenFuncs = {
    161     .version = SYNC_FD_SCREEN_FUNCS_VERSION,
    162     .CreateFenceFromFd = miSyncShmCreateFenceFromFd,
    163     .GetFenceFd = miSyncShmGetFenceFd
    164 };
    165 
    166 _X_EXPORT Bool miSyncShmScreenInit(ScreenPtr pScreen)
    167 {
    168     SyncScreenFuncsPtr  funcs;
    169 
    170     if (!miSyncFdScreenInit(pScreen, &miSyncShmScreenFuncs))
    171         return FALSE;
    172 
    173     if (!dixPrivateKeyRegistered(&syncShmFencePrivateKey)) {
    174         if (!dixRegisterPrivateKey(&syncShmFencePrivateKey, PRIVATE_SYNC_FENCE,
    175                                    sizeof(SyncShmFencePrivateRec)))
    176             return FALSE;
    177     }
    178 
    179     funcs = miSyncGetScreenFuncs(pScreen);
    180 
    181     funcs->CreateFence = miSyncShmScreenCreateFence;
    182     funcs->DestroyFence = miSyncShmScreenDestroyFence;
    183 
    184     return TRUE;
    185 }
    186