xserver/output: rename some badly named variables/APIs.

This is an API and ABI break
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>

dix/dispatch.c

@@ -3860,7 +3860,7 @@ static int init_screen(ScreenPtr pScreen, int i, Bool gpu)
     pScreen->CreateScreenResources = 0;
 
     xorg_list_init(&pScreen->pixmap_dirty_list);
-    xorg_list_init(&pScreen->slave_list);
+    xorg_list_init(&pScreen->secondary_list);
 
     /*
      * This loop gets run once for every Screen that gets added,
@@ -4028,54 +4028,54 @@ void
 AttachUnboundGPU(ScreenPtr pScreen, ScreenPtr new)
 {
     assert(new->isGPU);
-    assert(!new->current_master);
-    xorg_list_add(&new->slave_head, &pScreen->slave_list);
-    new->current_master = pScreen;
+    assert(!new->current_primary);
+    xorg_list_add(&new->secondary_head, &pScreen->secondary_list);
+    new->current_primary = pScreen;
 }
 
 void
-DetachUnboundGPU(ScreenPtr slave)
+DetachUnboundGPU(ScreenPtr secondary)
 {
-    assert(slave->isGPU);
-    assert(!slave->is_output_slave);
-    assert(!slave->is_offload_slave);
-    xorg_list_del(&slave->slave_head);
-    slave->current_master = NULL;
+    assert(secondary->isGPU);
+    assert(!secondary->is_output_secondary);
+    assert(!secondary->is_offload_secondary);
+    xorg_list_del(&secondary->secondary_head);
+    secondary->current_primary = NULL;
 }
 
 void
 AttachOutputGPU(ScreenPtr pScreen, ScreenPtr new)
 {
     assert(new->isGPU);
-    assert(!new->is_output_slave);
-    assert(new->current_master == pScreen);
-    new->is_output_slave = TRUE;
-    new->current_master->output_slaves++;
+    assert(!new->is_output_secondary);
+    assert(new->current_primary == pScreen);
+    new->is_output_secondary = TRUE;
+    new->current_primary->output_secondarys++;
 }
 
 void
-DetachOutputGPU(ScreenPtr slave)
+DetachOutputGPU(ScreenPtr secondary)
 {
-    assert(slave->isGPU);
-    assert(slave->is_output_slave);
-    slave->current_master->output_slaves--;
-    slave->is_output_slave = FALSE;
+    assert(secondary->isGPU);
+    assert(secondary->is_output_secondary);
+    secondary->current_primary->output_secondarys--;
+    secondary->is_output_secondary = FALSE;
 }
 
 void
 AttachOffloadGPU(ScreenPtr pScreen, ScreenPtr new)
 {
     assert(new->isGPU);
-    assert(!new->is_offload_slave);
-    assert(new->current_master == pScreen);
-    new->is_offload_slave = TRUE;
+    assert(!new->is_offload_secondary);
+    assert(new->current_primary == pScreen);
+    new->is_offload_secondary = TRUE;
 }
 
 void
-DetachOffloadGPU(ScreenPtr slave)
+DetachOffloadGPU(ScreenPtr secondary)
 {
-    assert(slave->isGPU);
-    assert(slave->is_offload_slave);
-    slave->is_offload_slave = FALSE;
+    assert(secondary->isGPU);
+    assert(secondary->is_offload_secondary);
+    secondary->is_offload_secondary = FALSE;
 }
 

dix/pixmap.c

@@ -132,40 +132,40 @@ FreePixmap(PixmapPtr pPixmap)
     free(pPixmap);
 }
 
-void PixmapUnshareSlavePixmap(PixmapPtr slave_pixmap)
+void PixmapUnshareSecondaryPixmap(PixmapPtr secondary_pixmap)
 {
      int ihandle = -1;
-     ScreenPtr pScreen = slave_pixmap->drawable.pScreen;
-     pScreen->SetSharedPixmapBacking(slave_pixmap, ((void *)(long)ihandle));
+     ScreenPtr pScreen = secondary_pixmap->drawable.pScreen;
+     pScreen->SetSharedPixmapBacking(secondary_pixmap, ((void *)(long)ihandle));
 }
 
-PixmapPtr PixmapShareToSlave(PixmapPtr pixmap, ScreenPtr slave)
+PixmapPtr PixmapShareToSecondary(PixmapPtr pixmap, ScreenPtr secondary)
 {
     PixmapPtr spix;
     int ret;
     void *handle;
-    ScreenPtr master = pixmap->drawable.pScreen;
+    ScreenPtr primary = pixmap->drawable.pScreen;
     int depth = pixmap->drawable.depth;
 
-    ret = master->SharePixmapBacking(pixmap, slave, &handle);
+    ret = primary->SharePixmapBacking(pixmap, secondary, &handle);
     if (ret == FALSE)
         return NULL;
 
-    spix = slave->CreatePixmap(slave, 0, 0, depth,
+    spix = secondary->CreatePixmap(secondary, 0, 0, depth,
                                CREATE_PIXMAP_USAGE_SHARED);
-    slave->ModifyPixmapHeader(spix, pixmap->drawable.width,
-                              pixmap->drawable.height, depth, 0,
-                              pixmap->devKind, NULL);
+    secondary->ModifyPixmapHeader(spix, pixmap->drawable.width,
+                                  pixmap->drawable.height, depth, 0,
+                                  pixmap->devKind, NULL);
 
-    /* have the slave pixmap take a reference on the master pixmap
+    /* have the secondary pixmap take a reference on the primary pixmap
        later we destroy them both at the same time */
     pixmap->refcnt++;
 
-    spix->master_pixmap = pixmap;
+    spix->primary_pixmap = pixmap;
 
-    ret = slave->SetSharedPixmapBacking(spix, handle);
+    ret = secondary->SetSharedPixmapBacking(spix, handle);
     if (ret == FALSE) {
-        slave->DestroyPixmap(spix);
+        secondary->DestroyPixmap(spix);
         return NULL;
     }
 
@@ -182,7 +182,7 @@ PixmapDirtyDamageDestroy(DamagePtr damage, void *closure)
 
 Bool
 PixmapStartDirtyTracking(DrawablePtr src,
-                         PixmapPtr slave_dst,
+                         PixmapPtr secondary_dst,
                          int x, int y, int dst_x, int dst_y,
                          Rotation rotation)
 {
@@ -197,7 +197,7 @@ PixmapStartDirtyTracking(DrawablePtr src,
         return FALSE;
 
     dirty_update->src = src;
-    dirty_update->slave_dst = slave_dst;
+    dirty_update->secondary_dst = secondary_dst;
     dirty_update->x = x;
     dirty_update->y = y;
     dirty_update->dst_x = dst_x;
@@ -209,8 +209,8 @@ PixmapStartDirtyTracking(DrawablePtr src,
 
     if (rotation != RR_Rotate_0) {
         RRTransformCompute(x, y,
-                           slave_dst->drawable.width,
-                           slave_dst->drawable.height,
+                           secondary_dst->drawable.width,
+                           secondary_dst->drawable.height,
                            rotation,
                            NULL,
                            &dirty_update->transform,
@@ -229,11 +229,11 @@ PixmapStartDirtyTracking(DrawablePtr src,
     box.y1 = dirty_update->y;
     if (dirty_update->rotation == RR_Rotate_90 ||
         dirty_update->rotation == RR_Rotate_270) {
-        box.x2 = dirty_update->x + slave_dst->drawable.height;
-        box.y2 = dirty_update->y + slave_dst->drawable.width;
+        box.x2 = dirty_update->x + secondary_dst->drawable.height;
+        box.y2 = dirty_update->y + secondary_dst->drawable.width;
     } else {
-        box.x2 = dirty_update->x + slave_dst->drawable.width;
-        box.y2 = dirty_update->y + slave_dst->drawable.height;
+        box.x2 = dirty_update->x + secondary_dst->drawable.width;
+        box.y2 = dirty_update->y + secondary_dst->drawable.height;
     }
     RegionInit(&dstregion, &box, 1);
     damageregion = DamageRegion(dirty_update->damage);
@@ -246,13 +246,13 @@ PixmapStartDirtyTracking(DrawablePtr src,
 }
 
 Bool
-PixmapStopDirtyTracking(DrawablePtr src, PixmapPtr slave_dst)
+PixmapStopDirtyTracking(DrawablePtr src, PixmapPtr secondary_dst)
 {
     ScreenPtr screen = src->pScreen;
     PixmapDirtyUpdatePtr ent, safe;
 
     xorg_list_for_each_entry_safe(ent, safe, &screen->pixmap_dirty_list, ent) {
-        if (ent->src == src && ent->slave_dst == slave_dst) {
+        if (ent->src == src && ent->secondary_dst == secondary_dst) {
             if (ent->damage)
                 DamageDestroy(ent->damage);
             xorg_list_del(&ent->ent);
@@ -372,9 +372,9 @@ Bool PixmapSyncDirtyHelper(PixmapDirtyUpdatePtr dirty)
     RegionRec pixregion;
     BoxRec box;
 
-    dst = dirty->slave_dst->master_pixmap;
+    dst = dirty->secondary_dst->primary_pixmap;
     if (!dst)
-        dst = dirty->slave_dst;
+        dst = dirty->secondary_dst;
 
     box.x1 = 0;
     box.y1 = 0;

fb/fbpixmap.c

@@ -68,7 +68,7 @@ fbCreatePixmap(ScreenPtr pScreen, int width, int height, int depth,
     pPixmap->devKind = paddedWidth;
     pPixmap->refcnt = 1;
     pPixmap->devPrivate.ptr = (void *) ((char *) pPixmap + base + adjust);
-    pPixmap->master_pixmap = NULL;
+    pPixmap->primary_pixmap = NULL;
 
 #ifdef FB_DEBUG
     pPixmap->devPrivate.ptr =

hw/xfree86/dri2/dri2.c

@@ -98,7 +98,7 @@ typedef struct _DRI2Drawable {
     unsigned blocked[3];
     Bool needInvalidate;
     int prime_id;
-    PixmapPtr prime_slave_pixmap;
+    PixmapPtr prime_secondary_pixmap;
     PixmapPtr redirectpixmap;
 } DRI2DrawableRec, *DRI2DrawablePtr;
 
@@ -181,33 +181,33 @@ DRI2GetScreen(ScreenPtr pScreen)
 }
 
 static ScreenPtr
-GetScreenPrime(ScreenPtr master, int prime_id)
+GetScreenPrime(ScreenPtr primary, int prime_id)
 {
-    ScreenPtr slave;
+    ScreenPtr secondary;
     if (prime_id == 0) {
-        return master;
+        return primary;
     }
-    xorg_list_for_each_entry(slave, &master->slave_list, slave_head) {
+    xorg_list_for_each_entry(secondary, &primary->secondary_list, secondary_head) {
         DRI2ScreenPtr ds;
 
-        if (!slave->is_offload_slave)
+        if (!secondary->is_offload_secondary)
             continue;
 
-        ds = DRI2GetScreen(slave);
+        ds = DRI2GetScreen(secondary);
         if (ds == NULL)
             continue;
 
         if (ds->prime_id == prime_id)
-            return slave;
+            return secondary;
     }
-    return master;
+    return primary;
 }
 
 static DRI2ScreenPtr
-DRI2GetScreenPrime(ScreenPtr master, int prime_id)
+DRI2GetScreenPrime(ScreenPtr primary, int prime_id)
 {
-    ScreenPtr slave = GetScreenPrime(master, prime_id);
-    return DRI2GetScreen(slave);
+    ScreenPtr secondary = GetScreenPrime(primary, prime_id);
+    return DRI2GetScreen(secondary);
 }
 
 static DRI2DrawablePtr
@@ -262,7 +262,7 @@ DRI2AllocateDrawable(DrawablePtr pDraw)
     xorg_list_init(&pPriv->reference_list);
     pPriv->needInvalidate = FALSE;
     pPriv->redirectpixmap = NULL;
-    pPriv->prime_slave_pixmap = NULL;
+    pPriv->prime_secondary_pixmap = NULL;
     if (pDraw->type == DRAWABLE_WINDOW) {
         pWin = (WindowPtr) pDraw;
         dixSetPrivate(&pWin->devPrivates, dri2WindowPrivateKey, pPriv);
@@ -427,9 +427,9 @@ DRI2DrawableGone(void *p, XID id)
         dixSetPrivate(&pPixmap->devPrivates, dri2PixmapPrivateKey, NULL);
     }
 
-    if (pPriv->prime_slave_pixmap) {
-        (*pPriv->prime_slave_pixmap->master_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_slave_pixmap->master_pixmap);
-        (*pPriv->prime_slave_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_slave_pixmap);
+    if (pPriv->prime_secondary_pixmap) {
+        (*pPriv->prime_secondary_pixmap->primary_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_secondary_pixmap->primary_pixmap);
+        (*pPriv->prime_secondary_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_secondary_pixmap);
     }
 
     if (pPriv->buffers != NULL) {
@@ -815,10 +815,10 @@ DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
     DRI2DrawablePtr pPriv = DRI2GetDrawable(pDraw);
     PixmapPtr spix;
     PixmapPtr mpix = GetDrawablePixmap(pDraw);
-    ScreenPtr master, slave;
+    ScreenPtr primary, secondary;
     Bool ret;
 
-    master = mpix->drawable.pScreen;
+    primary = mpix->drawable.pScreen;
 
     if (pDraw->type == DRAWABLE_WINDOW) {
         WindowPtr pWin = (WindowPtr)pDraw;
@@ -831,15 +831,15 @@ DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
                 pPriv->redirectpixmap->drawable.depth == pDraw->depth) {
                 mpix = pPriv->redirectpixmap;
             } else {
-                if (master->ReplaceScanoutPixmap) {
-                    mpix = (*master->CreatePixmap)(master, pDraw->width, pDraw->height,
+                if (primary->ReplaceScanoutPixmap) {
+                    mpix = (*primary->CreatePixmap)(primary, pDraw->width, pDraw->height,
                                                    pDraw->depth, CREATE_PIXMAP_USAGE_SHARED);
                     if (!mpix)
                         return NULL;
 
-                    ret = (*master->ReplaceScanoutPixmap)(pDraw, mpix, TRUE);
+                    ret = (*primary->ReplaceScanoutPixmap)(pDraw, mpix, TRUE);
                     if (ret == FALSE) {
-                        (*master->DestroyPixmap)(mpix);
+                        (*primary->DestroyPixmap)(mpix);
                         return NULL;
                     }
                     pPriv->redirectpixmap = mpix;
@@ -847,31 +847,31 @@ DrawablePtr DRI2UpdatePrime(DrawablePtr pDraw, DRI2BufferPtr pDest)
                     return NULL;
             }
         } else if (pPriv->redirectpixmap) {
-            (*master->ReplaceScanoutPixmap)(pDraw, pPriv->redirectpixmap, FALSE);
-            (*master->DestroyPixmap)(pPriv->redirectpixmap);
+            (*primary->ReplaceScanoutPixmap)(pDraw, pPriv->redirectpixmap, FALSE);
+            (*primary->DestroyPixmap)(pPriv->redirectpixmap);
             pPriv->redirectpixmap = NULL;
         }
     }
 
-    slave = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
+    secondary = GetScreenPrime(pDraw->pScreen, pPriv->prime_id);
 
     /* check if the pixmap is still fine */
-    if (pPriv->prime_slave_pixmap) {
-        if (pPriv->prime_slave_pixmap->master_pixmap == mpix)
-            return &pPriv->prime_slave_pixmap->drawable;
+    if (pPriv->prime_secondary_pixmap) {
+        if (pPriv->prime_secondary_pixmap->primary_pixmap == mpix)
+            return &pPriv->prime_secondary_pixmap->drawable;
         else {
-            PixmapUnshareSlavePixmap(pPriv->prime_slave_pixmap);
-            (*pPriv->prime_slave_pixmap->master_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_slave_pixmap->master_pixmap);
-            (*slave->DestroyPixmap)(pPriv->prime_slave_pixmap);
-            pPriv->prime_slave_pixmap = NULL;
+            PixmapUnshareSecondaryPixmap(pPriv->prime_secondary_pixmap);
+            (*pPriv->prime_secondary_pixmap->primary_pixmap->drawable.pScreen->DestroyPixmap)(pPriv->prime_secondary_pixmap->primary_pixmap);
+            (*secondary->DestroyPixmap)(pPriv->prime_secondary_pixmap);
+            pPriv->prime_secondary_pixmap = NULL;
         }
     }
 
-    spix = PixmapShareToSlave(mpix, slave);
+    spix = PixmapShareToSecondary(mpix, secondary);
     if (!spix)
         return NULL;
 
-    pPriv->prime_slave_pixmap = spix;
+    pPriv->prime_secondary_pixmap = spix;
 #ifdef COMPOSITE
     spix->screen_x = mpix->screen_x;
     spix->screen_y = mpix->screen_y;

hw/xfree86/drivers/modesetting/driver.c

@@ -569,14 +569,14 @@ dispatch_dirty_pixmap(ScrnInfoPtr scrn, xf86CrtcPtr crtc, PixmapPtr ppix)
 {
     modesettingPtr ms = modesettingPTR(scrn);
     msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, ppix);
-    DamagePtr damage = ppriv->slave_damage;
+    DamagePtr damage = ppriv->secondary_damage;
     int fb_id = ppriv->fb_id;
 
     dispatch_dirty_region(scrn, ppix, damage, fb_id);
 }
 
 static void
-dispatch_slave_dirty(ScreenPtr pScreen)
+dispatch_secondary_dirty(ScreenPtr pScreen)
 {
     ScrnInfoPtr scrn = xf86ScreenToScrn(pScreen);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
@@ -601,28 +601,28 @@ redisplay_dirty(ScreenPtr screen, PixmapDirtyUpdatePtr dirty, int *timeout)
 {
     RegionRec pixregion;
 
-    PixmapRegionInit(&pixregion, dirty->slave_dst);
-    DamageRegionAppend(&dirty->slave_dst->drawable, &pixregion);
+    PixmapRegionInit(&pixregion, dirty->secondary_dst);
+    DamageRegionAppend(&dirty->secondary_dst->drawable, &pixregion);
     PixmapSyncDirtyHelper(dirty);
 
     if (!screen->isGPU) {
 #ifdef GLAMOR_HAS_GBM
         modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(screen));
         /*
-         * When copying from the master framebuffer to the shared pixmap,
-         * we must ensure the copy is complete before the slave starts a
-         * copy to its own framebuffer (some slaves scanout directly from
+         * When copying from the primary framebuffer to the shared pixmap,
+         * we must ensure the copy is complete before the secondary starts a
+         * copy to its own framebuffer (some secondarys scanout directly from
          * the shared pixmap, but not all).
          */
         if (ms->drmmode.glamor)
             ms->glamor.finish(screen);
 #endif
-        /* Ensure the slave processes the damage immediately */
+        /* Ensure the secondary processes the damage immediately */
         if (timeout)
             *timeout = 0;
     }
 
-    DamageRegionProcessPending(&dirty->slave_dst->drawable);
+    DamageRegionProcessPending(&dirty->secondary_dst->drawable);
     RegionUninit(&pixregion);
 }
 
@@ -642,13 +642,13 @@ ms_dirty_update(ScreenPtr screen, int *timeout)
         if (RegionNotEmpty(region)) {
             if (!screen->isGPU) {
                    msPixmapPrivPtr ppriv =
-                    msGetPixmapPriv(&ms->drmmode, ent->slave_dst->master_pixmap);
+                    msGetPixmapPriv(&ms->drmmode, ent->secondary_dst->primary_pixmap);
 
                 if (ppriv->notify_on_damage) {
                     ppriv->notify_on_damage = FALSE;
 
-                    ent->slave_dst->drawable.pScreen->
-                        SharedPixmapNotifyDamage(ent->slave_dst);
+                    ent->secondary_dst->drawable.pScreen->
+                        SharedPixmapNotifyDamage(ent->secondary_dst);
                 }
 
                 /* Requested manual updating */
@@ -663,7 +663,7 @@ ms_dirty_update(ScreenPtr screen, int *timeout)
 }
 
 static PixmapDirtyUpdatePtr
-ms_dirty_get_ent(ScreenPtr screen, PixmapPtr slave_dst)
+ms_dirty_get_ent(ScreenPtr screen, PixmapPtr secondary_dst)
 {
     PixmapDirtyUpdatePtr ent;
 
@@ -671,7 +671,7 @@ ms_dirty_get_ent(ScreenPtr screen, PixmapPtr slave_dst)
         return NULL;
 
     xorg_list_for_each_entry(ent, &screen->pixmap_dirty_list, ent) {
-        if (ent->slave_dst == slave_dst)
+        if (ent->secondary_dst == secondary_dst)
             return ent;
     }
 
@@ -688,7 +688,7 @@ msBlockHandler(ScreenPtr pScreen, void *timeout)
     ms->BlockHandler = pScreen->BlockHandler;
     pScreen->BlockHandler = msBlockHandler;
     if (pScreen->isGPU && !ms->drmmode.reverse_prime_offload_mode)
-        dispatch_slave_dirty(pScreen);
+        dispatch_secondary_dirty(pScreen);
     else if (ms->dirty_enabled)
         dispatch_dirty(pScreen);
 
@@ -1291,32 +1291,32 @@ msDisableSharedPixmapFlipping(RRCrtcPtr crtc)
 
 static Bool
 msStartFlippingPixmapTracking(RRCrtcPtr crtc, DrawablePtr src,
-                              PixmapPtr slave_dst1, PixmapPtr slave_dst2,
+                              PixmapPtr secondary_dst1, PixmapPtr secondary_dst2,
                               int x, int y, int dst_x, int dst_y,
                               Rotation rotation)
 {
     ScreenPtr pScreen = src->pScreen;
     modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
 
-    msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, slave_dst1->master_pixmap),
-                    ppriv2 = msGetPixmapPriv(&ms->drmmode, slave_dst2->master_pixmap);
+    msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, secondary_dst1->primary_pixmap),
+                    ppriv2 = msGetPixmapPriv(&ms->drmmode, secondary_dst2->primary_pixmap);
 
-    if (!PixmapStartDirtyTracking(src, slave_dst1, x, y,
+    if (!PixmapStartDirtyTracking(src, secondary_dst1, x, y,
                                   dst_x, dst_y, rotation)) {
         return FALSE;
     }
 
-    if (!PixmapStartDirtyTracking(src, slave_dst2, x, y,
+    if (!PixmapStartDirtyTracking(src, secondary_dst2, x, y,
                                   dst_x, dst_y, rotation)) {
-        PixmapStopDirtyTracking(src, slave_dst1);
+        PixmapStopDirtyTracking(src, secondary_dst1);
         return FALSE;
     }
 
-    ppriv1->slave_src = src;
-    ppriv2->slave_src = src;
+    ppriv1->secondary_src = src;
+    ppriv2->secondary_src = src;
 
-    ppriv1->dirty = ms_dirty_get_ent(pScreen, slave_dst1);
-    ppriv2->dirty = ms_dirty_get_ent(pScreen, slave_dst2);
+    ppriv1->dirty = ms_dirty_get_ent(pScreen, secondary_dst1);
+    ppriv2->dirty = ms_dirty_get_ent(pScreen, secondary_dst2);
 
     ppriv1->defer_dirty_update = TRUE;
     ppriv2->defer_dirty_update = TRUE;
@@ -1325,17 +1325,17 @@ msStartFlippingPixmapTracking(RRCrtcPtr crtc, DrawablePtr src,
 }
 
 static Bool
-msPresentSharedPixmap(PixmapPtr slave_dst)
+msPresentSharedPixmap(PixmapPtr secondary_dst)
 {
-    ScreenPtr pScreen = slave_dst->master_pixmap->drawable.pScreen;
+    ScreenPtr pScreen = secondary_dst->primary_pixmap->drawable.pScreen;
     modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
 
-    msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, slave_dst->master_pixmap);
+    msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, secondary_dst->primary_pixmap);
 
     RegionPtr region = DamageRegion(ppriv->dirty->damage);
 
     if (RegionNotEmpty(region)) {
-        redisplay_dirty(ppriv->slave_src->pScreen, ppriv->dirty, NULL);
+        redisplay_dirty(ppriv->secondary_src->pScreen, ppriv->dirty, NULL);
         DamageEmpty(ppriv->dirty->damage);
 
         return TRUE;
@@ -1346,22 +1346,22 @@ msPresentSharedPixmap(PixmapPtr slave_dst)
 
 static Bool
 msStopFlippingPixmapTracking(DrawablePtr src,
-                             PixmapPtr slave_dst1, PixmapPtr slave_dst2)
+                             PixmapPtr secondary_dst1, PixmapPtr secondary_dst2)
 {
     ScreenPtr pScreen = src->pScreen;
     modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
 
-    msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, slave_dst1->master_pixmap),
-                    ppriv2 = msGetPixmapPriv(&ms->drmmode, slave_dst2->master_pixmap);
+    msPixmapPrivPtr ppriv1 = msGetPixmapPriv(&ms->drmmode, secondary_dst1->primary_pixmap),
+                    ppriv2 = msGetPixmapPriv(&ms->drmmode, secondary_dst2->primary_pixmap);
 
     Bool ret = TRUE;
 
-    ret &= PixmapStopDirtyTracking(src, slave_dst1);
-    ret &= PixmapStopDirtyTracking(src, slave_dst2);
+    ret &= PixmapStopDirtyTracking(src, secondary_dst1);
+    ret &= PixmapStopDirtyTracking(src, secondary_dst2);
 
     if (ret) {
-        ppriv1->slave_src = NULL;
-        ppriv2->slave_src = NULL;
+        ppriv1->secondary_src = NULL;
+        ppriv2->secondary_src = NULL;
 
         ppriv1->dirty = NULL;
         ppriv2->dirty = NULL;
@@ -1455,7 +1455,7 @@ CreateScreenResources(ScreenPtr pScreen)
 }
 
 static Bool
-msSharePixmapBacking(PixmapPtr ppix, ScreenPtr slave, void **handle)
+msSharePixmapBacking(PixmapPtr ppix, ScreenPtr secondary, void **handle)
 {
 #ifdef GLAMOR_HAS_GBM
     modesettingPtr ms =
@@ -1515,7 +1515,7 @@ msRequestSharedPixmapNotifyDamage(PixmapPtr ppix)
     ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
     modesettingPtr ms = modesettingPTR(scrn);
 
-    msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, ppix->master_pixmap);
+    msPixmapPrivPtr ppriv = msGetPixmapPriv(&ms->drmmode, ppix->primary_pixmap);
 
     ppriv->notify_on_damage = TRUE;
 
@@ -1548,7 +1548,7 @@ msSharedPixmapNotifyDamage(PixmapPtr ppix)
         if (!(drmmode_crtc->prime_pixmap && drmmode_crtc->prime_pixmap_back))
             continue;
 
-        // Received damage on master screen pixmap, schedule present on vblank
+        // Received damage on primary screen pixmap, schedule present on vblank
         ret |= drmmode_SharedPixmapPresentOnVBlank(ppix, crtc, &ms->drmmode);
     }
 

hw/xfree86/drivers/modesetting/drmmode_display.c

@@ -1089,9 +1089,9 @@ static Bool
 drmmode_SharedPixmapPresent(PixmapPtr ppix, xf86CrtcPtr crtc,
                             drmmode_ptr drmmode)
 {
-    ScreenPtr master = crtc->randr_crtc->pScreen->current_master;
+    ScreenPtr primary = crtc->randr_crtc->pScreen->current_primary;