dd8c833e3a3655f81c00becd37f270b27a07a96e
[dragonfly.git] / 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  * $FreeBSD: src/sys/dev/drm2/drm_auth.c,v 1.1 2012/05/22 11:07:44 kib Exp $
30  */
31
32 /** @file drm_auth.c
33  * Implementation of the get/authmagic ioctls implementing the authentication
34  * scheme between the master and clients.
35  */
36
37 #include <drm/drmP.h>
38
39 static int drm_hash_magic(drm_magic_t magic)
40 {
41         return magic & (DRM_HASH_SIZE-1);
42 }
43
44 /**
45  * Returns the file private associated with the given magic number.
46  */
47 static struct drm_file *drm_find_file(struct drm_device *dev, drm_magic_t magic)
48 {
49         drm_magic_entry_t *pt;
50         int hash = drm_hash_magic(magic);
51
52         DRM_LOCK_ASSERT(dev);
53
54         for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
55                 if (pt->magic == magic) {
56                         return pt->priv;
57                 }
58         }
59
60         return NULL;
61 }
62
63 /**
64  * Inserts the given magic number into the hash table of used magic number
65  * lists.
66  */
67 static int drm_add_magic(struct drm_device *dev, struct drm_file *priv,
68                          drm_magic_t magic)
69 {
70         int               hash;
71         drm_magic_entry_t *entry;
72
73         DRM_DEBUG("%d\n", magic);
74
75         DRM_LOCK_ASSERT(dev);
76
77         hash = drm_hash_magic(magic);
78         entry = kmalloc(sizeof(*entry), M_DRM, M_ZERO | M_WAITOK | M_NULLOK);
79         if (!entry)
80                 return ENOMEM;
81         entry->magic = magic;
82         entry->priv  = priv;
83         entry->next  = NULL;
84
85         if (dev->magiclist[hash].tail) {
86                 dev->magiclist[hash].tail->next = entry;
87                 dev->magiclist[hash].tail       = entry;
88         } else {
89                 dev->magiclist[hash].head       = entry;
90                 dev->magiclist[hash].tail       = entry;
91         }
92
93         return 0;
94 }
95
96 /**
97  * Removes the given magic number from the hash table of used magic number
98  * lists.
99  */
100 static int drm_remove_magic(struct drm_device *dev, drm_magic_t magic)
101 {
102         drm_magic_entry_t *prev = NULL;
103         drm_magic_entry_t *pt;
104         int               hash;
105
106         DRM_LOCK_ASSERT(dev);
107
108         DRM_DEBUG("%d\n", magic);
109         hash = drm_hash_magic(magic);
110
111         for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
112                 if (pt->magic == magic) {
113                         if (dev->magiclist[hash].head == pt) {
114                                 dev->magiclist[hash].head = pt->next;
115                         }
116                         if (dev->magiclist[hash].tail == pt) {
117                                 dev->magiclist[hash].tail = prev;
118                         }
119                         if (prev) {
120                                 prev->next = pt->next;
121                         }
122                         drm_free(pt, M_DRM);
123                         return 0;
124                 }
125         }
126
127         return EINVAL;
128 }
129
130 /**
131  * Called by the client, this returns a unique magic number to be authorized
132  * by the master.
133  *
134  * The master may use its own knowledge of the client (such as the X
135  * connection that the magic is passed over) to determine if the magic number
136  * should be authenticated.
137  */
138 int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
139 {
140         static drm_magic_t sequence = 0;
141         struct drm_auth *auth = data;
142
143         /* Find unique magic */
144         if (file_priv->magic) {
145                 auth->magic = file_priv->magic;
146         } else {
147                 DRM_LOCK(dev);
148                 do {
149                         int old = sequence;
150
151                         auth->magic = old+1;
152
153                         if (!atomic_cmpset_int(&sequence, old, auth->magic))
154                                 continue;
155                 } while (drm_find_file(dev, auth->magic));
156                 file_priv->magic = auth->magic;
157                 drm_add_magic(dev, file_priv, auth->magic);
158                 DRM_UNLOCK(dev);
159         }
160
161         DRM_DEBUG("%u\n", auth->magic);
162
163         return 0;
164 }
165
166 /**
167  * Marks the client associated with the given magic number as authenticated.
168  */
169 int drm_authmagic(struct drm_device *dev, void *data,
170                   struct drm_file *file_priv)
171 {
172         struct drm_auth *auth = data;
173         struct drm_file *priv;
174
175         DRM_DEBUG("%u\n", auth->magic);
176
177         DRM_LOCK(dev);
178         priv = drm_find_file(dev, auth->magic);
179         if (priv != NULL) {
180                 priv->authenticated = 1;
181                 drm_remove_magic(dev, auth->magic);
182                 DRM_UNLOCK(dev);
183                 return 0;
184         } else {
185                 DRM_UNLOCK(dev);
186                 return EINVAL;
187         }
188 }