1/*	$NetBSD: putter.c,v 1.31 2011/02/06 14:29:25 haad Exp $	*/
2
3/*
4 * Copyright (c) 2006, 2007  Antti Kantee.  All Rights Reserved.
5 *
6 * Development of this software was supported by the
7 * Ulla Tuominen Foundation and the Finnish Cultural Foundation and the
8 * Research Foundation of Helsinki University of Technology
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
20 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * Pass-to-Userspace TransporTER: generic kernel-user request-response
34 * transport interface.
35 */
36
37#include <sys/cdefs.h>
38__KERNEL_RCSID(0, "$NetBSD: putter.c,v 1.31 2011/02/06 14:29:25 haad Exp $");
39
40#include <sys/param.h>
41#include <sys/systm.h>
42#include <sys/conf.h>
43#include <sys/file.h>
44#include <sys/filedesc.h>
45#include <sys/kmem.h>
46#include <sys/poll.h>
47#include <sys/stat.h>
48#include <sys/socketvar.h>
49#include <sys/module.h>
50#include <sys/kauth.h>
51
52#include <dev/putter/putter_sys.h>
53
54/*
55 * Device routines.  These are for when /dev/putter is initially
56 * opened before it has been cloned.
57 */
58
59dev_type_open(puttercdopen);
60dev_type_close(puttercdclose);
61dev_type_ioctl(puttercdioctl);
62
63/* dev */
64const struct cdevsw putter_cdevsw = {
65	puttercdopen,	puttercdclose,	noread,		nowrite,
66	noioctl,	nostop,		notty,		nopoll,
67	nommap,		nokqfilter,	D_OTHER
68};
69
70/*
71 * Configuration data.
72 *
73 * This is static-size for now.  Will be redone for devfs.
74 */
75
76#define PUTTER_CONFSIZE 16
77
78static struct putter_config {
79	int	pc_minor;
80	int	(*pc_config)(int, int, int);
81} putterconf[PUTTER_CONFSIZE];
82
83static int
84putter_configure(dev_t dev, int flags, int fmt, int fd)
85{
86	struct putter_config *pc;
87
88	/* are we the catch-all node? */
89	if (minor(dev) == PUTTER_MINOR_WILDCARD
90	    || minor(dev) == PUTTER_MINOR_COMPAT)
91		return 0;
92
93	/* nopes?  try to configure us */
94	for (pc = putterconf; pc->pc_config; pc++)
95		if (minor(dev) == pc->pc_minor)
96			return pc->pc_config(fd, flags, fmt);
97	return ENXIO;
98}
99
100int
101putter_register(putter_config_fn pcfn, int minor)
102{
103	int i;
104
105	for (i = 0; i < PUTTER_CONFSIZE; i++)
106		if (putterconf[i].pc_config == NULL)
107			break;
108	if (i == PUTTER_CONFSIZE)
109		return EBUSY;
110
111	putterconf[i].pc_minor = minor;
112	putterconf[i].pc_config = pcfn;
113	return 0;
114}
115
116/*
117 * putter instance structures.  these are always allocated and freed
118 * from the context of the transport user.
119 */
120struct putter_instance {
121	pid_t			pi_pid;
122	int			pi_idx;
123	int			pi_fd;
124	struct selinfo		pi_sel;
125
126	void			*pi_private;
127	struct putter_ops	*pi_pop;
128
129	uint8_t			*pi_curput;
130	size_t			pi_curres;
131	void			*pi_curopaq;
132	struct timespec		pi_atime;
133	struct timespec		pi_mtime;
134	struct timespec		pi_btime;
135
136	TAILQ_ENTRY(putter_instance) pi_entries;
137};
138#define PUTTER_EMBRYO ((void *)-1)	/* before attach	*/
139#define PUTTER_DEAD ((void *)-2)	/* after detach		*/
140
141static TAILQ_HEAD(, putter_instance) putter_ilist
142    = TAILQ_HEAD_INITIALIZER(putter_ilist);
143
144static int get_pi_idx(struct putter_instance *);
145
146#ifdef DEBUG
147#ifndef PUTTERDEBUG
148#define PUTTERDEBUG
149#endif
150#endif
151
152#ifdef PUTTERDEBUG
153int putterdebug = 0;
154#define DPRINTF(x) if (putterdebug > 0) printf x
155#define DPRINTF_VERBOSE(x) if (putterdebug > 1) printf x
156#else
157#define DPRINTF(x)
158#define DPRINTF_VERBOSE(x)
159#endif
160
161/*
162 * public init / deinit
163 */
164
165/* protects both the list and the contents of the list elements */
166static kmutex_t pi_mtx;
167
168void putterattach(void);
169
170void
171putterattach(void)
172{
173
174	mutex_init(&pi_mtx, MUTEX_DEFAULT, IPL_NONE);
175}
176
177#if 0
178void
179putter_destroy(void)
180{
181
182	mutex_destroy(&pi_mtx);
183}
184#endif
185
186/*
187 * fd routines, for cloner
188 */
189static int putter_fop_read(file_t *, off_t *, struct uio *,
190			   kauth_cred_t, int);
191static int putter_fop_write(file_t *, off_t *, struct uio *,
192			    kauth_cred_t, int);
193static int putter_fop_ioctl(file_t*, u_long, void *);
194static int putter_fop_poll(file_t *, int);
195static int putter_fop_stat(file_t *, struct stat *);
196static int putter_fop_close(file_t *);
197static int putter_fop_kqfilter(file_t *, struct knote *);
198
199
200static const struct fileops putter_fileops = {
201	.fo_read = putter_fop_read,
202	.fo_write = putter_fop_write,
203	.fo_ioctl = putter_fop_ioctl,
204	.fo_fcntl = fnullop_fcntl,
205	.fo_poll = putter_fop_poll,
206	.fo_stat = putter_fop_stat,
207	.fo_close = putter_fop_close,
208	.fo_kqfilter = putter_fop_kqfilter,
209	.fo_restart = fnullop_restart,
210};
211
212static int
213putter_fop_read(file_t *fp, off_t *off, struct uio *uio,
214	kauth_cred_t cred, int flags)
215{
216	struct putter_instance *pi = fp->f_data;
217	size_t origres, moved;
218	int error;
219
220	KERNEL_LOCK(1, NULL);
221	getnanotime(&pi->pi_atime);
222
223	if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) {
224		printf("putter_fop_read: private %d not inited\n", pi->pi_idx);
225		KERNEL_UNLOCK_ONE(NULL);
226		return ENOENT;
227	}
228
229	if (pi->pi_curput == NULL) {
230		error = pi->pi_pop->pop_getout(pi->pi_private, uio->uio_resid,
231		    fp->f_flag & O_NONBLOCK, &pi->pi_curput,
232		    &pi->pi_curres, &pi->pi_curopaq);
233		if (error) {
234			KERNEL_UNLOCK_ONE(NULL);
235			return error;
236		}
237	}
238
239	origres = uio->uio_resid;
240	error = uiomove(pi->pi_curput, pi->pi_curres, uio);
241	moved = origres - uio->uio_resid;
242	DPRINTF(("putter_fop_read (%p): moved %zu bytes from %p, error %d\n",
243	    pi, moved, pi->pi_curput, error));
244
245	KASSERT(pi->pi_curres >= moved);
246	pi->pi_curres -= moved;
247	pi->pi_curput += moved;
248
249	if (pi->pi_curres == 0) {
250		pi->pi_pop->pop_releaseout(pi->pi_private,
251		    pi->pi_curopaq, error);
252		pi->pi_curput = NULL;
253	}
254
255	KERNEL_UNLOCK_ONE(NULL);
256	return error;
257}
258
259static int
260putter_fop_write(file_t *fp, off_t *off, struct uio *uio,
261	kauth_cred_t cred, int flags)
262{
263	struct putter_instance *pi = fp->f_data;
264	struct putter_hdr pth;
265	uint8_t *buf;
266	size_t frsize;
267	int error;
268
269	KERNEL_LOCK(1, NULL);
270	getnanotime(&pi->pi_mtime);
271
272	DPRINTF(("putter_fop_write (%p): writing response, resid %zu\n",
273	    pi->pi_private, uio->uio_resid));
274
275	if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) {
276		printf("putter_fop_write: putter %d not inited\n", pi->pi_idx);
277		KERNEL_UNLOCK_ONE(NULL);
278		return ENOENT;
279	}
280
281	error = uiomove(&pth, sizeof(struct putter_hdr), uio);
282	if (error) {
283		KERNEL_UNLOCK_ONE(NULL);
284		return error;
285	}
286
287	/* Sorry mate, the kernel doesn't buffer. */
288	frsize = pth.pth_framelen - sizeof(struct putter_hdr);
289	if (uio->uio_resid < frsize) {
290		KERNEL_UNLOCK_ONE(NULL);
291		return EINVAL;
292	}
293
294	buf = kmem_alloc(frsize + sizeof(struct putter_hdr), KM_SLEEP);
295	memcpy(buf, &pth, sizeof(pth));
296	error = uiomove(buf+sizeof(struct putter_hdr), frsize, uio);
297	if (error == 0) {
298		pi->pi_pop->pop_dispatch(pi->pi_private,
299		    (struct putter_hdr *)buf);
300	}
301	kmem_free(buf, frsize + sizeof(struct putter_hdr));
302
303	KERNEL_UNLOCK_ONE(NULL);
304	return error;
305}
306
307/*
308 * Poll query interface.  The question is only if an event
309 * can be read from us.
310 */
311#define PUTTERPOLL_EVSET (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)
312static int
313putter_fop_poll(file_t *fp, int events)
314{
315	struct putter_instance *pi = fp->f_data;
316	int revents;
317
318	KERNEL_LOCK(1, NULL);
319
320	if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) {
321		printf("putter_fop_ioctl: putter %d not inited\n", pi->pi_idx);
322		KERNEL_UNLOCK_ONE(NULL);
323		return ENOENT;
324	}
325
326	revents = events & (POLLOUT | POLLWRNORM | POLLWRBAND);
327	if ((events & PUTTERPOLL_EVSET) == 0) {
328		KERNEL_UNLOCK_ONE(NULL);
329		return revents;
330	}
331
332	/* check queue */
333	if (pi->pi_pop->pop_waitcount(pi->pi_private))
334		revents |= PUTTERPOLL_EVSET;
335	else
336		selrecord(curlwp, &pi->pi_sel);
337
338	KERNEL_UNLOCK_ONE(NULL);
339	return revents;
340}
341
342/*
343 * device close = forced unmount.
344 *
345 * unmounting is a frightfully complex operation to avoid races
346 */
347static int
348putter_fop_close(file_t *fp)
349{
350	struct putter_instance *pi = fp->f_data;
351	int rv;
352
353	DPRINTF(("putter_fop_close: device closed\n"));
354
355	KERNEL_LOCK(1, NULL);
356
357 restart:
358	mutex_enter(&pi_mtx);
359	/*
360	 * First check if the driver was never born.  In that case
361	 * remove the instance from the list.  If mount is attempted later,
362	 * it will simply fail.
363	 */
364	if (pi->pi_private == PUTTER_EMBRYO) {
365		TAILQ_REMOVE(&putter_ilist, pi, pi_entries);
366		mutex_exit(&pi_mtx);
367
368		DPRINTF(("putter_fop_close: data associated with fp %p was "
369		    "embryonic\n", fp));
370
371		goto out;
372	}
373
374	/*
375	 * Next, analyze if unmount was called and the instance is dead.
376	 * In this case we can just free the structure and go home, it
377	 * was removed from the list by putter_rmprivate().
378	 */
379	if (pi->pi_private == PUTTER_DEAD) {
380		mutex_exit(&pi_mtx);
381
382		DPRINTF(("putter_fop_close: putter associated with fp %p (%d) "
383		    "dead, freeing\n", fp, pi->pi_idx));
384
385		goto out;
386	}
387
388	/*
389	 * So we have a reference.  Proceed to unravel the
390	 * underlying driver.
391	 */
392	mutex_exit(&pi_mtx);
393
394	/* hmm?  suspicious locking? */
395	while ((rv = pi->pi_pop->pop_close(pi->pi_private)) == ERESTART)
396		goto restart;
397
398 out:
399	KERNEL_UNLOCK_ONE(NULL);
400	/*
401	 * Finally, release the instance information.  It was already
402	 * removed from the list by putter_rmprivate() and we know it's
403	 * dead, so no need to lock.
404	 */
405	kmem_free(pi, sizeof(struct putter_instance));
406
407	return 0;
408}
409
410static int
411putter_fop_stat(file_t *fp, struct stat *st)
412{
413	struct putter_instance *pi = fp->f_data;
414
415	(void)memset(st, 0, sizeof(*st));
416	KERNEL_LOCK(1, NULL);
417	st->st_dev = makedev(cdevsw_lookup_major(&putter_cdevsw), pi->pi_idx);
418	st->st_atimespec = pi->pi_atime;
419	st->st_mtimespec = pi->pi_mtime;
420	st->st_ctimespec = st->st_birthtimespec = pi->pi_btime;
421	st->st_uid = kauth_cred_geteuid(fp->f_cred);
422	st->st_gid = kauth_cred_getegid(fp->f_cred);
423	st->st_mode = S_IFCHR;
424	KERNEL_UNLOCK_ONE(NULL);
425	return 0;
426}
427
428static int
429putter_fop_ioctl(file_t *fp, u_long cmd, void *data)
430{
431
432	/*
433	 * work already done in sys_ioctl().  skip sanity checks to enable
434	 * setting non-blocking fd on an embryotic driver.
435	 */
436	if (cmd == FIONBIO)
437		return 0;
438
439	return EINVAL;
440}
441
442/* kqueue stuff */
443
444static void
445filt_putterdetach(struct knote *kn)
446{
447	struct putter_instance *pi = kn->kn_hook;
448
449	KERNEL_LOCK(1, NULL);
450	mutex_enter(&pi_mtx);
451	SLIST_REMOVE(&pi->pi_sel.sel_klist, kn, knote, kn_selnext);
452	mutex_exit(&pi_mtx);
453	KERNEL_UNLOCK_ONE(NULL);
454}
455
456static int
457filt_putter(struct knote *kn, long hint)
458{
459	struct putter_instance *pi = kn->kn_hook;
460	int error, rv;
461
462	KERNEL_LOCK(1, NULL);
463	error = 0;
464	mutex_enter(&pi_mtx);
465	if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD)
466		error = 1;
467	mutex_exit(&pi_mtx);
468	if (error) {
469		KERNEL_UNLOCK_ONE(NULL);
470		return 0;
471	}
472
473	kn->kn_data = pi->pi_pop->pop_waitcount(pi->pi_private);
474	rv = kn->kn_data != 0;
475	KERNEL_UNLOCK_ONE(NULL);
476	return rv;
477}
478
479static const struct filterops putter_filtops =
480	{ 1, NULL, filt_putterdetach, filt_putter };
481
482static int
483putter_fop_kqfilter(file_t *fp, struct knote *kn)
484{
485	struct putter_instance *pi = fp->f_data;
486	struct klist *klist;
487
488	KERNEL_LOCK(1, NULL);
489
490	switch (kn->kn_filter) {
491	case EVFILT_READ:
492		klist = &pi->pi_sel.sel_klist;
493		kn->kn_fop = &putter_filtops;
494		kn->kn_hook = pi;
495
496		mutex_enter(&pi_mtx);
497		SLIST_INSERT_HEAD(klist, kn, kn_selnext);
498		mutex_exit(&pi_mtx);
499
500		break;
501	case EVFILT_WRITE:
502		kn->kn_fop = &seltrue_filtops;
503		break;
504	default:
505		KERNEL_UNLOCK_ONE(NULL);
506		return EINVAL;
507	}
508
509	KERNEL_UNLOCK_ONE(NULL);
510	return 0;
511}
512
513int
514puttercdopen(dev_t dev, int flags, int fmt, struct lwp *l)
515{
516	struct putter_instance *pi;
517	file_t *fp;
518	int error, fd, idx;
519	proc_t *p;
520
521	p = curproc;
522	pi = kmem_alloc(sizeof(struct putter_instance), KM_SLEEP);
523	mutex_enter(&pi_mtx);
524	idx = get_pi_idx(pi);
525
526	pi->pi_pid = p->p_pid;
527	pi->pi_idx = idx;
528	pi->pi_curput = NULL;
529	pi->pi_curres = 0;
530	pi->pi_curopaq = NULL;
531	getnanotime(&pi->pi_btime);
532	pi->pi_atime = pi->pi_mtime = pi->pi_btime;
533	selinit(&pi->pi_sel);
534	mutex_exit(&pi_mtx);
535
536	if ((error = fd_allocfile(&fp, &fd)) != 0)
537		goto bad1;
538
539	if ((error = putter_configure(dev, flags, fmt, fd)) != 0)
540		goto bad2;
541
542	DPRINTF(("puttercdopen: registered embryonic pmp for pid: %d\n",
543	    pi->pi_pid));
544
545	error = fd_clone(fp, fd, FREAD|FWRITE, &putter_fileops, pi);
546	KASSERT(error == EMOVEFD);
547	return error;
548
549 bad2:
550 	fd_abort(p, fp, fd);
551 bad1:
552	putter_detach(pi);
553	kmem_free(pi, sizeof(struct putter_instance));
554	return error;
555}
556
557int
558puttercdclose(dev_t dev, int flags, int fmt, struct lwp *l)
559{
560
561	panic("puttercdclose impossible\n");
562
563	return 0;
564}
565
566
567/*
568 * Set the private structure for the file descriptor.  This is
569 * typically done immediately when the counterpart has knowledge
570 * about the private structure's address and the file descriptor
571 * (e.g. vfs mount routine).
572 *
573 * We only want to make sure that the caller had the right to open the
574 * device, we don't so much care about which context it gets in case
575 * the same process opened multiple (since they are equal at this point).
576 */
577struct putter_instance *
578putter_attach(pid_t pid, int fd, void *ppriv, struct putter_ops *pop)
579{
580	struct putter_instance *pi = NULL;
581
582	mutex_enter(&pi_mtx);
583	TAILQ_FOREACH(pi, &putter_ilist, pi_entries) {
584		if (pi->pi_pid == pid && pi->pi_private == PUTTER_EMBRYO) {
585			pi->pi_private = ppriv;
586			pi->pi_fd = fd;
587			pi->pi_pop = pop;
588			break;
589		    }
590	}
591	mutex_exit(&pi_mtx);
592
593	DPRINTF(("putter_setprivate: pi at %p (%d/%d)\n", pi,
594	    pi ? pi->pi_pid : 0, pi ? pi->pi_fd : 0));
595
596	return pi;
597}
598
599/*
600 * Remove fp <-> private mapping.
601 */
602void
603putter_detach(struct putter_instance *pi)
604{
605
606	mutex_enter(&pi_mtx);
607	TAILQ_REMOVE(&putter_ilist, pi, pi_entries);
608	pi->pi_private = PUTTER_DEAD;
609	mutex_exit(&pi_mtx);
610	seldestroy(&pi->pi_sel);
611
612	DPRINTF(("putter_nukebypmp: nuked %p\n", pi));
613}
614
615void
616putter_notify(struct putter_instance *pi)
617{
618
619	selnotify(&pi->pi_sel, 0, 0);
620}
621
622/* search sorted list of instances for free minor, sorted insert arg */
623static int
624get_pi_idx(struct putter_instance *pi_i)
625{
626	struct putter_instance *pi;
627	int i;
628
629	KASSERT(mutex_owned(&pi_mtx));
630
631	i = 0;
632	TAILQ_FOREACH(pi, &putter_ilist, pi_entries) {
633		if (i != pi->pi_idx)
634			break;
635		i++;
636	}
637
638	pi_i->pi_private = PUTTER_EMBRYO;
639
640	if (pi == NULL)
641		TAILQ_INSERT_TAIL(&putter_ilist, pi_i, pi_entries);
642	else
643		TAILQ_INSERT_BEFORE(pi, pi_i, pi_entries);
644
645	return i;
646}
647
648MODULE(MODULE_CLASS_DRIVER, putter, NULL);
649
650static int
651putter_modcmd(modcmd_t cmd, void *arg)
652{
653#ifdef _MODULE
654	devmajor_t bmajor = NODEVMAJOR, cmajor = NODEVMAJOR;
655
656	switch (cmd) {
657	case MODULE_CMD_INIT:
658		putterattach();
659		return devsw_attach("putter", NULL, &bmajor,
660		    &putter_cdevsw, &cmajor);
661	case MODULE_CMD_FINI:
662		return ENOTTY; /* XXX: putterdetach */
663	default:
664		return ENOTTY;
665	}
666#else
667	if (cmd == MODULE_CMD_INIT)
668		return 0;
669	return ENOTTY;
670#endif
671}
672