1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * ksyms driver - exports a single symbol/string table for the kernel
29 * by concatenating all the module symbol/string tables.
30 */
31
32 #include <sys/types.h>
33 #include <sys/sysmacros.h>
34 #include <sys/cmn_err.h>
35 #include <sys/uio.h>
36 #include <sys/kmem.h>
37 #include <sys/cred.h>
38 #include <sys/mman.h>
39 #include <sys/errno.h>
40 #include <sys/stat.h>
41 #include <sys/conf.h>
42 #include <sys/debug.h>
43 #include <sys/kobj.h>
44 #include <sys/ksyms.h>
45 #include <sys/vmsystm.h>
46 #include <vm/seg_vn.h>
47 #include <sys/atomic.h>
48 #include <sys/compress.h>
49 #include <sys/ddi.h>
50 #include <sys/sunddi.h>
51 #include <sys/list.h>
52
53 typedef struct ksyms_image {
54 caddr_t ksyms_base; /* base address of image */
55 size_t ksyms_size; /* size of image */
56 } ksyms_image_t;
57
58 typedef struct ksyms_buflist {
59 list_node_t buflist_node;
60 char buf[1];
61 } ksyms_buflist_t;
62
63 typedef struct ksyms_buflist_hdr {
64 list_t blist;
65 int nchunks;
66 ksyms_buflist_t *cur;
67 size_t curbuf_off;
68 } ksyms_buflist_hdr_t;
69
70 #define BUF_SIZE (PAGESIZE - (size_t)offsetof(ksyms_buflist_t, buf))
71
72 int nksyms_clones; /* tunable: max clones of this device */
73
74 static ksyms_image_t *ksyms_clones; /* clone device array */
75 static dev_info_t *ksyms_devi;
76
77 static void
78 ksyms_bcopy(const void *srcptr, void *ptr, size_t rsize)
79 {
80
81 size_t sz;
82 const char *src = (const char *)srcptr;
83 ksyms_buflist_hdr_t *hptr = (ksyms_buflist_hdr_t *)ptr;
84
85 if (hptr->cur == NULL)
86 return;
87
88 while (rsize) {
89 sz = MIN(rsize, (BUF_SIZE - hptr->curbuf_off));
90 bcopy(src, (hptr->cur->buf + hptr->curbuf_off), sz);
91
92 hptr->curbuf_off += sz;
93 if (hptr->curbuf_off == BUF_SIZE) {
94 hptr->curbuf_off = 0;
95 hptr->cur = list_next(&hptr->blist, hptr->cur);
96 if (hptr->cur == NULL)
97 break;
98 }
99 src += sz;
100 rsize -= sz;
101 }
102 }
103
104 static void
105 ksyms_buflist_free(ksyms_buflist_hdr_t *hdr)
106 {
107 ksyms_buflist_t *list;
108
109 while (list = list_head(&hdr->blist)) {
110 list_remove(&hdr->blist, list);
111 kmem_free(list, PAGESIZE);
112 }
113 list_destroy(&hdr->blist);
114 hdr->cur = NULL;
115 }
116
117
118 /*
119 * Allocate 'size'(rounded to BUF_SIZE) bytes in chunks of BUF_SIZE, and
120 * add it to the buf list.
121 * Returns the total size rounded to BUF_SIZE.
122 */
123 static size_t
124 ksyms_buflist_alloc(ksyms_buflist_hdr_t *hdr, size_t size)
125 {
126 int chunks, i;
127 ksyms_buflist_t *list;
128
129 chunks = howmany(size, BUF_SIZE);
130
131 if (hdr->nchunks >= chunks)
132 return (hdr->nchunks * BUF_SIZE);
133
134 /*
135 * Allocate chunks - hdr->nchunks buffers and add them to
136 * the list.
137 */
138 for (i = chunks - hdr->nchunks; i > 0; i--) {
139
140 if ((list = kmem_alloc(PAGESIZE, KM_NOSLEEP)) == NULL)
141 break;
142
143 list_insert_tail(&hdr->blist, list);
144 }
145
146 /*
147 * If we are running short of memory, free memory allocated till now
148 * and return.
149 */
150 if (i > 0) {
151 ksyms_buflist_free(hdr);
152 return (0);
153 }
154
155 hdr->nchunks = chunks;
156 hdr->cur = list_head(&hdr->blist);
157 hdr->curbuf_off = 0;
158
159 return (chunks * BUF_SIZE);
160 }
161
162 /*
163 * rlen is in multiples of PAGESIZE
164 */
165 static char *
166 ksyms_asmap(struct as *as, size_t rlen)
167 {
168 char *addr = NULL;
169
170 as_rangelock(as);
171 map_addr(&addr, rlen, 0, 1, 0);
172 if (addr == NULL || as_map(as, addr, rlen, segvn_create, zfod_argsp)) {
173 as_rangeunlock(as);
174 return (NULL);
175 }
176 as_rangeunlock(as);
177 return (addr);
178 }
179
180 static char *
181 ksyms_mapin(ksyms_buflist_hdr_t *hdr, size_t size)
182 {
183 size_t sz, rlen = roundup(size, PAGESIZE);
184 struct as *as = curproc->p_as;
185 char *addr, *raddr;
186 ksyms_buflist_t *list = list_head(&hdr->blist);
187
188 if ((addr = ksyms_asmap(as, rlen)) == NULL)
189 return (NULL);
190
191 raddr = addr;
192 while (size > 0 && list != NULL) {
193 sz = MIN(size, BUF_SIZE);
194
195 if (copyout(list->buf, raddr, sz)) {
196 (void) as_unmap(as, addr, rlen);
197 return (NULL);
198 }
199 list = list_next(&hdr->blist, list);
200 raddr += sz;
201 size -= sz;
202 }
203 return (addr);
204 }
205
206 /*
207 * Copy a snapshot of the kernel symbol table into the user's address space.
208 * The symbol table is copied in fragments so that we do not have to
209 * do a large kmem_alloc() which could fail/block if the kernel memory is
210 * fragmented.
211 */
212 /* ARGSUSED */
213 static int
214 ksyms_open(dev_t *devp, int flag, int otyp, struct cred *cred)
215 {
216 minor_t clone;
217 size_t size = 0;
218 size_t realsize;
219 char *addr;
220 void *hptr = NULL;
221 ksyms_buflist_hdr_t hdr;
222 bzero(&hdr, sizeof (struct ksyms_buflist_hdr));
223 list_create(&hdr.blist, PAGESIZE,
224 offsetof(ksyms_buflist_t, buflist_node));
225
226 if (getminor(*devp) != 0)
227 return (ENXIO);
228
229 for (;;) {
230 realsize = ksyms_snapshot(ksyms_bcopy, hptr, size);
231 if (realsize <= size)
232 break;
233 size = realsize;
234 size = ksyms_buflist_alloc(&hdr, size);
235 if (size == 0)
236 return (ENOMEM);
237 hptr = (void *)&hdr;
238 }
239
240 addr = ksyms_mapin(&hdr, realsize);
241 ksyms_buflist_free(&hdr);
242 if (addr == NULL)
243 return (EOVERFLOW);
244
245 /*
246 * Reserve a clone entry. Note that we don't use clone 0
247 * since that's the "real" minor number.
248 */
249 for (clone = 1; clone < nksyms_clones; clone++) {
250 if (atomic_cas_ptr(&ksyms_clones[clone].ksyms_base, 0, addr) ==
251 0) {
252 ksyms_clones[clone].ksyms_size = realsize;
253 *devp = makedevice(getemajor(*devp), clone);
254 (void) ddi_prop_update_int(*devp, ksyms_devi,
255 "size", realsize);
256 modunload_disable();
257 return (0);
258 }
259 }
260 cmn_err(CE_NOTE, "ksyms: too many open references");
261 (void) as_unmap(curproc->p_as, addr, roundup(realsize, PAGESIZE));
262 return (ENXIO);
263 }
264
265 /* ARGSUSED */
266 static int
267 ksyms_close(dev_t dev, int flag, int otyp, struct cred *cred)
268 {
269 minor_t clone = getminor(dev);
270
271 (void) as_unmap(curproc->p_as, ksyms_clones[clone].ksyms_base,
272 roundup(ksyms_clones[clone].ksyms_size, PAGESIZE));
273 ksyms_clones[clone].ksyms_base = 0;
274 modunload_enable();
275 (void) ddi_prop_remove(dev, ksyms_devi, "size");
276 return (0);
277 }
278
279 static int
280 ksyms_symtbl_copy(ksyms_image_t *kip, struct uio *uio, size_t len)
281 {
282 char *buf;
283 int error = 0;
284 caddr_t base;
285 off_t off = uio->uio_offset;
286 size_t size;
287
288 /*
289 * The symbol table is stored in the user address space,
290 * so we have to copy it into the kernel first,
291 * then copy it back out to the specified user address.
292 */
293 buf = kmem_alloc(PAGESIZE, KM_SLEEP);
294 base = kip->ksyms_base + off;
295 while (len) {
296 size = MIN(PAGESIZE, len);
297 if (copyin(base, buf, size))
298 error = EFAULT;
299 else
300 error = uiomove(buf, size, UIO_READ, uio);
301
302 if (error)
303 break;
304
305 len -= size;
306 base += size;
307 }
308 kmem_free(buf, PAGESIZE);
309 return (error);
310 }
311
312 /* ARGSUSED */
313 static int
314 ksyms_read(dev_t dev, struct uio *uio, struct cred *cred)
315 {
316 ksyms_image_t *kip = &ksyms_clones[getminor(dev)];
317 off_t off = uio->uio_offset;
318 size_t len = uio->uio_resid;
319
320 if (off < 0 || off > kip->ksyms_size)
321 return (EFAULT);
322
323 if (len > kip->ksyms_size - off)
324 len = kip->ksyms_size - off;
325
326 if (len == 0)
327 return (0);
328
329 return (ksyms_symtbl_copy(kip, uio, len));
330 }
331
332 /* ARGSUSED */
333 static int
334 ksyms_segmap(dev_t dev, off_t off, struct as *as, caddr_t *addrp, off_t len,
335 uint_t prot, uint_t maxprot, uint_t flags, struct cred *cred)
336 {
337 ksyms_image_t *kip = &ksyms_clones[getminor(dev)];
338 int error = 0;
339 char *addr = NULL;
340 size_t rlen = 0;
341 struct iovec aiov;
342 struct uio auio;
343
344 if (flags & MAP_FIXED)
345 return (ENOTSUP);
346
347 if (off < 0 || len <= 0 || off > kip->ksyms_size ||
348 len > kip->ksyms_size - off)
349 return (EINVAL);
350
351 rlen = roundup(len, PAGESIZE);
352 if ((addr = ksyms_asmap(as, rlen)) == NULL)
353 return (EOVERFLOW);
354
355 aiov.iov_base = addr;
356 aiov.iov_len = len;
357 auio.uio_offset = off;
358 auio.uio_iov = &aiov;
359 auio.uio_iovcnt = 1;
360 auio.uio_resid = len;
361 auio.uio_segflg = UIO_USERSPACE;
362 auio.uio_llimit = MAXOFFSET_T;
363 auio.uio_fmode = FREAD;
364 auio.uio_extflg = UIO_COPY_CACHED;
365
366 error = ksyms_symtbl_copy(kip, &auio, len);
367
368 if (error)
369 (void) as_unmap(as, addr, rlen);
370 else
371 *addrp = addr;
372 return (error);
373 }
374
375 /* ARGSUSED */
376 static int
377 ksyms_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
378 {
379 switch (infocmd) {
380 case DDI_INFO_DEVT2DEVINFO:
381 *result = ksyms_devi;
382 return (DDI_SUCCESS);
383 case DDI_INFO_DEVT2INSTANCE:
384 *result = 0;
385 return (DDI_SUCCESS);
386 }
387 return (DDI_FAILURE);
388 }
389
390 static int
391 ksyms_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
392 {
393 if (cmd != DDI_ATTACH)
394 return (DDI_FAILURE);
395 if (ddi_create_minor_node(devi, "ksyms", S_IFCHR, 0, DDI_PSEUDO, NULL)
396 == DDI_FAILURE) {
397 ddi_remove_minor_node(devi, NULL);
398 return (DDI_FAILURE);
399 }
400 ksyms_devi = devi;
401 return (DDI_SUCCESS);
402 }
403
404 static int
405 ksyms_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
406 {
407 if (cmd != DDI_DETACH)
408 return (DDI_FAILURE);
409 ddi_remove_minor_node(devi, NULL);
410 return (DDI_SUCCESS);
411 }
412
413 static struct cb_ops ksyms_cb_ops = {
414 ksyms_open, /* open */
415 ksyms_close, /* close */
416 nodev, /* strategy */
417 nodev, /* print */
418 nodev, /* dump */
419 ksyms_read, /* read */
420 nodev, /* write */
421 nodev, /* ioctl */
422 nodev, /* devmap */
423 nodev, /* mmap */
424 ksyms_segmap, /* segmap */
425 nochpoll, /* poll */
426 ddi_prop_op, /* prop_op */
427 0, /* streamtab */
428 D_NEW | D_MP /* Driver compatibility flag */
429 };
430
431 static struct dev_ops ksyms_ops = {
432 DEVO_REV, /* devo_rev, */
433 0, /* refcnt */
434 ksyms_info, /* info */
435 nulldev, /* identify */
436 nulldev, /* probe */
437 ksyms_attach, /* attach */
438 ksyms_detach, /* detach */
439 nodev, /* reset */
440 &ksyms_cb_ops, /* driver operations */
441 (struct bus_ops *)0, /* no bus operations */
442 NULL, /* power */
443 ddi_quiesce_not_needed, /* quiesce */
444 };
445
446 static struct modldrv modldrv = {
447 &mod_driverops, "kernel symbols driver", &ksyms_ops,
448 };
449
450 static struct modlinkage modlinkage = {
451 MODREV_1, { (void *)&modldrv }
452 };
453
454 int
455 _init(void)
456 {
457 int error;
458
459 if (nksyms_clones == 0)
460 nksyms_clones = maxusers + 50;
461
462 ksyms_clones = kmem_zalloc(nksyms_clones *
463 sizeof (ksyms_image_t), KM_SLEEP);
464
465 if ((error = mod_install(&modlinkage)) != 0)
466 kmem_free(ksyms_clones, nksyms_clones * sizeof (ksyms_image_t));
467
468 return (error);
469 }
470
471 int
472 _fini(void)
473 {
474 int error;
475
476 if ((error = mod_remove(&modlinkage)) == 0)
477 kmem_free(ksyms_clones, nksyms_clones * sizeof (ksyms_image_t));
478 return (error);
479 }
480
481 int
482 _info(struct modinfo *modinfop)
483 {
484 return (mod_info(&modlinkage, modinfop));
485 }