| Start/ | End/ | |||
| True | False | - | Line | Source |
| 1 | /** | |||
| 2 | * \file drm_auth.c | |||
| 3 | * IOCTLs for authentication | |||
| 4 | * | |||
| 5 | * \author Rickard E. (Rik) Faith <faith@valinux.com> | |||
| 6 | * \author Gareth Hughes <gareth@valinux.com> | |||
| 7 | */ | |||
| 8 | ||||
| 9 | /* | |||
| 10 | * Created: Tue Feb 2 08:37:54 1999 by faith@valinux.com | |||
| 11 | * | |||
| 12 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. | |||
| 13 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. | |||
| 14 | * All Rights Reserved. | |||
| 15 | * | |||
| 16 | * Permission is hereby granted, free of charge, to any person obtaining a | |||
| 17 | * copy of this software and associated documentation files (the "Software"), | |||
| 18 | * to deal in the Software without restriction, including without limitation | |||
| 19 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |||
| 20 | * and/or sell copies of the Software, and to permit persons to whom the | |||
| 21 | * Software is furnished to do so, subject to the following conditions: | |||
| 22 | * | |||
| 23 | * The above copyright notice and this permission notice (including the next | |||
| 24 | * paragraph) shall be included in all copies or substantial portions of the | |||
| 25 | * Software. | |||
| 26 | * | |||
| 27 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
| 28 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
| 29 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |||
| 30 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR | |||
| 31 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |||
| 32 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |||
| 33 | * OTHER DEALINGS IN THE SOFTWARE. | |||
| 34 | */ | |||
| 35 | ||||
| 36 | #include "drmP.h" | |||
| 37 | ||||
| 38 | /** | |||
| 39 | * Generate a hash key from a magic. | |||
| 40 | * | |||
| 41 | * \param magic magic. | |||
| 42 | * \return hash key. | |||
| 43 | * | |||
| 44 | * The key is the modulus of the hash table size, #DRM_HASH_SIZE, which must be | |||
| 45 | * a power of 2. | |||
| 46 | */ | |||
| 0 | 0 | - | 47 | static int drm_hash_magic(drm_magic_t magic) |
| 48 | { | |||
| 0 | - | 49 | return magic & (DRM_HASH_SIZE - 1); | |
| 50 | } | |||
| 51 | ||||
| 52 | /** | |||
| 53 | * Find the file with the given magic number. | |||
| 54 | * | |||
| 55 | * \param dev DRM device. | |||
| 56 | * \param magic magic number. | |||
| 57 | * | |||
| 58 | * Searches in drm_device::magiclist within all files with the same hash key | |||
| 59 | * the one with matching magic number, while holding the drm_device::struct_mutex | |||
| 60 | * lock. | |||
| 61 | */ | |||
| 0 | 0 | - | 62 | static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic) |
| 63 | { | |||
| 64 | drm_file_t *retval = NULL; | |||
| 65 | drm_magic_entry_t *pt; | |||
| 66 | int hash = drm_hash_magic(magic); | |||
| 67 | ||||
| 68 | mutex_lock(&dev->struct_mutex); | |||
| 0 | 0 | - | 69 | for (pt = dev->magiclist[hash].head; pt; pt = pt->next) { |
| 0 | 0 | - | 70 | if (pt->magic == magic) { |
| 71 | retval = pt->priv; | |||
| 0 | - | 72 | break; | |
| 73 | } | |||
| 74 | } | |||
| 75 | mutex_unlock(&dev->struct_mutex); | |||
| 0 | - | 76 | return retval; | |
| 77 | } | |||
| 78 | ||||
| 79 | /** | |||
| 80 | * Adds a magic number. | |||
| 81 | * | |||
| 82 | * \param dev DRM device. | |||
| 83 | * \param priv file private data. | |||
| 84 | * \param magic magic number. | |||
| 85 | * | |||
| 86 | * Creates a drm_magic_entry structure and appends to the linked list | |||
| 87 | * associated the magic number hash key in drm_device::magiclist, while holding | |||
| 88 | * the drm_device::struct_mutex lock. | |||
| 89 | */ | |||
| 0 | 0 | - | 90 | static int drm_add_magic(drm_device_t * dev, drm_file_t * priv, |
| 91 | drm_magic_t magic) | |||
| 92 | { | |||
| 93 | int hash; | |||
| 94 | drm_magic_entry_t *entry; | |||
| 95 | ||||
| 96 | DRM_DEBUG("%d\n", magic); | |||
| 0 | 0 | - | 96 | if (drm_debug) |
| 0 | 0 | - | 96 | do-while (0) |
| 97 | ||||
| 98 | hash = drm_hash_magic(magic); | |||
| 99 | entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC); | |||
| 0 | 0 | - | 100 | if (!entry) |
| 0 | - | 101 | return -ENOMEM; | |
| 102 | memset(entry, 0, sizeof(*entry)); | |||
| 103 | entry->magic = magic; | |||
| 104 | entry->priv = priv; | |||
| 105 | entry->next = NULL; | |||
| 106 | ||||
| 107 | mutex_lock(&dev->struct_mutex); | |||
| 0 | 0 | - | 108 | if (dev->magiclist[hash].tail) { |
| 109 | dev->magiclist[hash].tail->next = entry; | |||
| 110 | dev->magiclist[hash].tail = entry; | |||
| 111 | } else { | |||
| 112 | dev->magiclist[hash].head = entry; | |||
| 113 | dev->magiclist[hash].tail = entry; | |||
| 114 | } | |||
| 115 | mutex_unlock(&dev->struct_mutex); | |||
| 116 | ||||
| 0 | - | 117 | return 0; | |
| 118 | } | |||
| 119 | ||||
| 120 | /** | |||
| 121 | * Remove a magic number. | |||
| 122 | * | |||
| 123 | * \param dev DRM device. | |||
| 124 | * \param magic magic number. | |||
| 125 | * | |||
| 126 | * Searches and unlinks the entry in drm_device::magiclist with the magic | |||
| 127 | * number hash key, while holding the drm_device::struct_mutex lock. | |||
| 128 | */ | |||
| 0 | 0 | - | 129 | static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic) |
| 130 | { | |||
| 131 | drm_magic_entry_t *prev = NULL; | |||
| 132 | drm_magic_entry_t *pt; | |||
| 133 | int hash; | |||
| 134 | ||||
| 135 | DRM_DEBUG("%d\n", magic); | |||
| 0 | 0 | - | 135 | if (drm_debug) |
| 0 | 0 | - | 135 | do-while (0) |
| 136 | hash = drm_hash_magic(magic); | |||
| 137 | ||||
| 138 | mutex_lock(&dev->struct_mutex); | |||
| 0 | 0 | - | 139 | for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) { |
| 0 | 0 | - | 140 | if (pt->magic == magic) { |
| 0 | 0 | - | 141 | if (dev->magiclist[hash].head == pt) { |
| 142 | dev->magiclist[hash].head = pt->next; | |||
| 143 | } | |||
| 0 | 0 | - | 144 | if (dev->magiclist[hash].tail == pt) { |
| 145 | dev->magiclist[hash].tail = prev; | |||
| 146 | } | |||
| 0 | 0 | - | 147 | if (prev) { |
| 148 | prev->next = pt->next; | |||
| 149 | } | |||
| 150 | mutex_unlock(&dev->struct_mutex); | |||
| 0 | - | 151 | return 0; | |
| 152 | } | |||
| 153 | } | |||
| 154 | mutex_unlock(&dev->struct_mutex); | |||
| 155 | ||||
| 156 | drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC); | |||
| 157 | ||||
| 0 | - | 158 | return -EINVAL; | |
| 159 | } | |||
| 160 | ||||
| 161 | /** | |||
| 162 | * Get a unique magic number (ioctl). | |||
| 163 | * | |||
| 164 | * \param inode device inode. | |||
| 165 | * \param filp file pointer. | |||
| 166 | * \param cmd command. | |||
| 167 | * \param arg pointer to a resulting drm_auth structure. | |||
| 168 | * \return zero on success, or a negative number on failure. | |||
| 169 | * | |||
| 170 | * If there is a magic number in drm_file::magic then use it, otherwise | |||
| 171 | * searches an unique non-zero magic number and add it associating it with \p | |||
| 172 | * filp. | |||
| 173 | */ | |||
| 0 | 0 | - | 174 | int drm_getmagic(struct inode *inode, struct file *filp, |
| 175 | unsigned int cmd, unsigned long arg) | |||
| 176 | { | |||
| 177 | static drm_magic_t sequence = 0; | |||
| 178 | static DEFINE_SPINLOCK(lock); | |||
| 179 | drm_file_t *priv = filp->private_data; | |||
| 180 | drm_device_t *dev = priv->head->dev; | |||
| 181 | drm_auth_t auth; | |||
| 182 | ||||
| 183 | /* Find unique magic */ | |||
| 0 | 0 | - | 184 | if (priv->magic) { |
| 185 | auth.magic = priv->magic; | |||
| 186 | } else { | |||
| 187 | do { | |||
| 188 | spin_lock(&lock); | |||
| 188 | do | |||
| 0 | 0 | - | 188 | do-while (0) |
| 0 | 0 | - | 188 | do-while (0) |
| 0 | 0 | - | 189 | if (!sequence) |
| 190 | ++sequence; /* reserve 0 */ | |||
| 191 | auth.magic = sequence++; | |||
| 192 | spin_unlock(&lock); | |||
| 192 | do | |||
| 0 | 0 | - | 192 | do-while (0) |
| 0 | 0 | - | 192 | do-while (0) |
| 0 | 0 | - | 193 | } while (drm_find_file(dev, auth.magic)); |
| 194 | priv->magic = auth.magic; | |||
| 195 | drm_add_magic(dev, priv, auth.magic); | |||
| 196 | } | |||
| 197 | ||||
| 198 | DRM_DEBUG("%u\n", auth.magic); | |||
| 0 | 0 | - | 198 | if (drm_debug) |
| 0 | 0 | - | 198 | do-while (0) |
| 0 | 0 | - | 199 | if (copy_to_user((drm_auth_t __user *) arg, &auth, sizeof(auth))) |
| 0 | - | 200 | return -EFAULT; | |
| 0 | - | 201 | return 0; | |
| 202 | } | |||
| 203 | ||||
| 204 | /** | |||
| 205 | * Authenticate with a magic. | |||
| 206 | * | |||
| 207 | * \param inode device inode. | |||
| 208 | * \param filp file pointer. | |||
| 209 | * \param cmd command. | |||
| 210 | * \param arg pointer to a drm_auth structure. | |||
| 211 | * \return zero if authentication successed, or a negative number otherwise. | |||
| 212 | * | |||
| 213 | * Checks if \p filp is associated with the magic number passed in \arg. | |||
| 214 | */ | |||
| 0 | 0 | - | 215 | int drm_authmagic(struct inode *inode, struct file *filp, |
| 216 | unsigned int cmd, unsigned long arg) | |||
| 217 | { | |||
| 218 | drm_file_t *priv = filp->private_data; | |||
| 219 | drm_device_t *dev = priv->head->dev; | |||
| 220 | drm_auth_t auth; | |||
| 221 | drm_file_t *file; | |||
| 222 | ||||
| 0 | 0 | - | 223 | if (copy_from_user(&auth, (drm_auth_t __user *) arg, sizeof(auth))) |
| 0 | - | 224 | return -EFAULT; | |
| 225 | DRM_DEBUG("%u\n", auth.magic); | |||
| 0 | 0 | - | 225 | if (drm_debug) |
| 0 | 0 | - | 225 | do-while (0) |
| 0 | 0 | - | 226 | if ((file = drm_find_file(dev, auth.magic))) { |
| 227 | file->authenticated = 1; | |||
| 228 | drm_remove_magic(dev, auth.magic); | |||
| 0 | - | 229 | return 0; | |
| 230 | } | |||
| 0 | - | 231 | return -EINVAL; | |
| 232 | } | |||
| ***TER 0% (0/72) of SOURCE FILE drm_auth.c | ||||