sys/dev/drm/drm_auth.c

   1 /*-
   2  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
   3  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rickard E. (Rik) Faith <faith@valinux.com>
  27  *    Gareth Hughes <gareth@valinux.com>
  28  *
  29  */
  30
  31 /** @file drm_auth.c
  32  * Implementation of the get/authmagic ioctls implementing the authentication
  33  * scheme between the master and clients.
  34  */
  35
  36 #include "dev/drm/drmP.h"
  37
  38 static int drm_hash_magic(drm_magic_t magic)
  39 {
  40         return magic & (DRM_HASH_SIZE-1);
  41 }
  42
  43 /**
  44  * Returns the file private associated with the given magic number.
  45  */
  46 static struct drm_file *drm_find_file(struct drm_device *dev, drm_magic_t magic)
  47 {
  48         drm_magic_entry_t *pt;
  49         int hash = drm_hash_magic(magic);
  50
  51         DRM_SPINLOCK_ASSERT(&dev->dev_lock);
  52
  53         for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
  54                 if (pt->magic == magic) {
  55                         return pt->priv;
  56                 }
  57         }
  58
  59         return NULL;
  60 }
  61
  62 /**
  63  * Inserts the given magic number into the hash table of used magic number
  64  * lists.
  65  */
  66 static int drm_add_magic(struct drm_device *dev, struct drm_file *priv,
  67                          drm_magic_t magic)
  68 {
  69         int               hash;
  70         drm_magic_entry_t *entry;
  71
  72         DRM_DEBUG("%d\n", magic);
  73
  74         DRM_SPINLOCK_ASSERT(&dev->dev_lock);
  75
  76         hash = drm_hash_magic(magic);
  77         entry = malloc(sizeof(*entry), DRM_MEM_MAGIC, M_ZERO | M_NOWAIT);
  78         if (!entry)
  79                 return ENOMEM;
  80         entry->magic = magic;
  81         entry->priv  = priv;
  82         entry->next  = NULL;
  83
  84         if (dev->magiclist[hash].tail) {
  85                 dev->magiclist[hash].tail->next = entry;
  86                 dev->magiclist[hash].tail       = entry;
  87         } else {
  88                 dev->magiclist[hash].head       = entry;
  89                 dev->magiclist[hash].tail       = entry;
  90         }
  91
  92         return 0;
  93 }
  94
  95 /**
  96  * Removes the given magic number from the hash table of used magic number
  97  * lists.
  98  */
  99 static int drm_remove_magic(struct drm_device *dev, drm_magic_t magic)
 100 {
 101         drm_magic_entry_t *prev = NULL;
 102         drm_magic_entry_t *pt;
 103         int               hash;
 104
 105         DRM_SPINLOCK_ASSERT(&dev->dev_lock);
 106
 107         DRM_DEBUG("%d\n", magic);
 108         hash = drm_hash_magic(magic);
 109
 110         for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
 111                 if (pt->magic == magic) {
 112                         if (dev->magiclist[hash].head == pt) {
 113                                 dev->magiclist[hash].head = pt->next;
 114                         }
 115                         if (dev->magiclist[hash].tail == pt) {
 116                                 dev->magiclist[hash].tail = prev;
 117                         }
 118                         if (prev) {
 119                                 prev->next = pt->next;
 120                         }
 121                         free(pt, DRM_MEM_MAGIC);
 122                         return 0;
 123                 }
 124         }
 125
 126         return EINVAL;
 127 }
 128
 129 /**
 130  * Called by the client, this returns a unique magic number to be authorized
 131  * by the master.
 132  *
 133  * The master may use its own knowledge of the client (such as the X
 134  * connection that the magic is passed over) to determine if the magic number
 135  * should be authenticated.
 136  */
 137 int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
 138 {
 139         static drm_magic_t sequence = 0;
 140         struct drm_auth *auth = data;
 141
 142         /* Find unique magic */
 143         if (file_priv->magic) {
 144                 auth->magic = file_priv->magic;
 145         } else {
 146                 DRM_LOCK();
 147                 do {
 148                         int old = sequence;
 149
 150                         auth->magic = old+1;
 151
 152                         if (!atomic_cmpset_int(&sequence, old, auth->magic))
 153                                 continue;
 154                 } while (drm_find_file(dev, auth->magic));
 155                 file_priv->magic = auth->magic;
 156                 drm_add_magic(dev, file_priv, auth->magic);
 157                 DRM_UNLOCK();
 158         }
 159
 160         DRM_DEBUG("%u\n", auth->magic);
 161
 162         return 0;
 163 }
 164
 165 /**
 166  * Marks the client associated with the given magic number as authenticated.
 167  */
 168 int drm_authmagic(struct drm_device *dev, void *data,
 169                   struct drm_file *file_priv)
 170 {
 171         struct drm_auth *auth = data;
 172         struct drm_file *priv;
 173
 174         DRM_DEBUG("%u\n", auth->magic);
 175
 176         DRM_LOCK();
 177         priv = drm_find_file(dev, auth->magic);
 178         if (priv != NULL) {
 179                 priv->authenticated = 1;
 180                 drm_remove_magic(dev, auth->magic);
 181                 DRM_UNLOCK();
 182                 return 0;
 183         } else {
 184                 DRM_UNLOCK();
 185                 return EINVAL;
 186         }
 187 }