xref: /titanic_44/usr/src/uts/common/io/clone.c (revision 2d6b5ea734bb47d251c82670646fde46af15fd69)
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 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
22 /*	  All Rights Reserved  	*/
23 
24 
25 /*
26  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 
31 /*
32  * Clone Driver.
33  */
34 
35 #include <sys/types.h>
36 #include <sys/param.h>
37 #include <sys/errno.h>
38 #include <sys/signal.h>
39 #include <sys/vfs.h>
40 #include <sys/vnode.h>
41 #include <sys/pcb.h>
42 #include <sys/user.h>
43 #include <sys/stropts.h>
44 #include <sys/stream.h>
45 #include <sys/errno.h>
46 #include <sys/sysinfo.h>
47 #include <sys/systm.h>
48 #include <sys/conf.h>
49 #include <sys/debug.h>
50 #include <sys/cred.h>
51 #include <sys/mkdev.h>
52 #include <sys/open.h>
53 #include <sys/strsubr.h>
54 #include <sys/ddi.h>
55 #include <sys/sunddi.h>
56 #include <sys/modctl.h>
57 #include <sys/policy.h>
58 
59 int clnopen(queue_t *rq, dev_t *devp, int flag, int sflag, cred_t *crp);
60 
61 static struct module_info clnm_info = { 0, "CLONE", 0, 0, 0, 0 };
62 static struct qinit clnrinit = { NULL, NULL, clnopen, NULL, NULL, &clnm_info,
63     NULL };
64 static struct qinit clnwinit = { NULL, NULL, NULL, NULL, NULL, &clnm_info,
65     NULL };
66 struct streamtab clninfo = { &clnrinit, &clnwinit };
67 
68 static int cln_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
69 static int cln_attach(dev_info_t *, ddi_attach_cmd_t);
70 static dev_info_t *cln_dip;		/* private copy of devinfo pointer */
71 
72 #define	CLONE_CONF_FLAG		(D_NEW|D_MP)
73 
74 DDI_DEFINE_STREAM_OPS(clone_ops, nulldev, nulldev, cln_attach, nodev, nodev, \
75     cln_info, CLONE_CONF_FLAG, &clninfo, ddi_quiesce_not_needed);
76 
77 /*
78  * Module linkage information for the kernel.
79  */
80 
81 static struct modldrv modldrv = {
82 	&mod_driverops, /* Type of module.  This one is a pseudo driver */
83 	"Clone Pseudodriver 'clone'",
84 	&clone_ops,	/* driver ops */
85 };
86 
87 static struct modlinkage modlinkage = {
88 	MODREV_1,
89 	(void *)&modldrv,
90 	NULL
91 };
92 
93 
94 int
95 _init(void)
96 {
97 	return (mod_install(&modlinkage));
98 }
99 
100 int
101 _fini(void)
102 {
103 	/*
104 	 * Since the clone driver's reference count is unreliable,
105 	 * make sure we are never unloaded.
106 	 */
107 	return (EBUSY);
108 }
109 
110 int
111 _info(struct modinfo *modinfop)
112 {
113 	return (mod_info(&modlinkage, modinfop));
114 }
115 
116 /* ARGSUSED */
117 static int
118 cln_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
119 {
120 	cln_dip = devi;
121 	return (DDI_SUCCESS);
122 }
123 
124 /* ARGSUSED */
125 static int
126 cln_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
127 	void **result)
128 {
129 	int error;
130 
131 	switch (infocmd) {
132 	case DDI_INFO_DEVT2DEVINFO:
133 		if (cln_dip == NULL) {
134 			error = DDI_FAILURE;
135 		} else {
136 			*result = (void *)cln_dip;
137 			error = DDI_SUCCESS;
138 		}
139 		break;
140 	case DDI_INFO_DEVT2INSTANCE:
141 		*result = (void *)0;
142 		error = DDI_SUCCESS;
143 		break;
144 	default:
145 		error = DDI_FAILURE;
146 	}
147 	return (error);
148 }
149 
150 /*
151  * Clone open.  Maj is the major device number of the streams
152  * device to open.  Look up the device in the cdevsw[].  Attach
153  * its qinit structures to the read and write queues and call its
154  * open with the sflag set to CLONEOPEN.  Swap in a new vnode with
155  * the real device number constructed from either
156  *	a) for old-style drivers:
157  *		maj and the minor returned by the device open, or
158  *	b) for new-style drivers:
159  *		the whole dev passed back as a reference parameter
160  *		from the device open.
161  */
162 int
163 clnopen(queue_t *rq, dev_t *devp, int flag, int sflag, cred_t *crp)
164 {
165 	struct streamtab *str;
166 	dev_t newdev;
167 	int error = 0;
168 	major_t maj;
169 	minor_t emaj;
170 	struct qinit *rinit, *winit;
171 	cdevsw_impl_t *dp;
172 	uint32_t qflag;
173 	uint32_t sqtype;
174 	perdm_t *dmp;
175 	vnode_t *vp;
176 
177 	if (sflag)
178 		return (ENXIO);
179 
180 	/*
181 	 * Get the device to open.
182 	 */
183 	emaj = getminor(*devp); /* minor is major for a cloned driver */
184 	maj = etoimajor(emaj);	/* get internal major of cloned driver */
185 
186 	if (maj >= devcnt)
187 		return (ENXIO);
188 
189 	/*
190 	 * NOTE We call ddi_hold_installed_driver() here to attach
191 	 *	all instances of the driver, since we do not know
192 	 *	a priori which instance the Stream is associated with.
193 	 *
194 	 *	For Style-2 network drivers, we know that the association
195 	 *	happens at DL_ATTACH time. For other types of drivers,
196 	 *	open probably requires attaching instance 0 (pseudo dip).
197 	 *
198 	 *	To eliminate ddi_hold_installed_driver(), the following
199 	 *	should happen:
200 	 *
201 	 *	- GLD be modified to include gld_init(). The driver will
202 	 *	  register information for gld_open() to succeed. It will
203 	 *	  also inform framework if driver assigns instance=PPA.
204 	 *	- ddi_hold_devi_by_instance() be modified to actively
205 	 *	  attach the instance via top-down enumeration.
206 	 */
207 	if (ddi_hold_installed_driver(maj) == NULL)
208 		return (ENXIO);
209 
210 	if ((str = STREAMSTAB(maj)) == NULL) {
211 		ddi_rele_driver(maj);
212 		return (ENXIO);
213 	}
214 
215 	newdev = makedevice(emaj, 0);	/* create new style device number  */
216 
217 	/*
218 	 * Check for security here. For DLPI style 2 network
219 	 * drivers, we need to apply the default network policy.
220 	 * Clone is weird in that the network driver isn't loaded
221 	 * and attached at spec_open() time, we need to load the
222 	 * driver to see if it is a network driver. Hence, we
223 	 * check security here (after ddi_hold_installed_driver
224 	 * call above).
225 	 */
226 	vp = makespecvp(newdev, VCHR);
227 	error = secpolicy_spec_open(crp, vp, flag);
228 	VN_RELE(vp);
229 	if (error) {
230 		ddi_rele_driver(maj);
231 		return (error);
232 	}
233 
234 	/*
235 	 * Save so that we can restore the q on failure.
236 	 */
237 	rinit = rq->q_qinfo;
238 	winit = WR(rq)->q_qinfo;
239 	ASSERT(rq->q_syncq->sq_type == (SQ_CI|SQ_CO));
240 	ASSERT((rq->q_flag & QMT_TYPEMASK) == QMTSAFE);
241 
242 	dp = &devimpl[maj];
243 	ASSERT(str == dp->d_str);
244 
245 	qflag = dp->d_qflag;
246 	sqtype = dp->d_sqtype;
247 
248 	/* create perdm_t if needed */
249 	if (NEED_DM(dp->d_dmp, qflag))
250 		dp->d_dmp = hold_dm(str, qflag, sqtype);
251 
252 	dmp = dp->d_dmp;
253 
254 	/*
255 	 * Set the syncq state what qattach started off with. This is safe
256 	 * since no other thread can access this queue at this point
257 	 * (stream open, close, push, and pop are single threaded
258 	 * by the framework.)
259 	 */
260 	leavesq(rq->q_syncq, SQ_OPENCLOSE);
261 
262 	/*
263 	 * Substitute the real qinit values for the current ones.
264 	 */
265 	/* setq might sleep in kmem_alloc - avoid holding locks. */
266 	setq(rq, str->st_rdinit, str->st_wrinit, dmp, qflag, sqtype, B_FALSE);
267 
268 	/*
269 	 * Open the attached module or driver.
270 	 *
271 	 * If there is an outer perimeter get exclusive access during
272 	 * the open procedure.
273 	 * Bump up the reference count on the queue.
274 	 */
275 	entersq(rq->q_syncq, SQ_OPENCLOSE);
276 
277 	/*
278 	 * Call the device open with the stream flag CLONEOPEN.  The device
279 	 * will either fail this or return the device number.
280 	 */
281 	error = (*rq->q_qinfo->qi_qopen)(rq, &newdev, flag, CLONEOPEN, crp);
282 	if (error != 0)
283 		goto failed;
284 
285 	*devp = newdev;
286 	if (getmajor(newdev) != emaj)
287 		goto bad_major;
288 
289 	return (0);
290 
291 bad_major:
292 	/*
293 	 * Close the device
294 	 */
295 	(*rq->q_qinfo->qi_qclose)(rq, flag, crp);
296 
297 #ifdef DEBUG
298 	cmn_err(CE_NOTE, "cannot clone major number %d(%s)->%d", emaj,
299 	    ddi_major_to_name(emaj), getmajor(newdev));
300 #endif
301 	error = ENXIO;
302 
303 failed:
304 	/*
305 	 * open failed; pretty up to look like original
306 	 * queue.
307 	 */
308 	if (backq(WR(rq)) && backq(WR(rq))->q_next == WR(rq))
309 		qprocsoff(rq);
310 	leavesq(rq->q_syncq, SQ_OPENCLOSE);
311 	rq->q_next = WR(rq)->q_next = NULL;
312 	ASSERT(flush_syncq(rq->q_syncq, rq) == 0);
313 	ASSERT(flush_syncq(WR(rq)->q_syncq, WR(rq)) == 0);
314 	rq->q_ptr = WR(rq)->q_ptr = NULL;
315 	/* setq might sleep in kmem_alloc - avoid holding locks. */
316 	setq(rq, rinit, winit, NULL, QMTSAFE, SQ_CI|SQ_CO,
317 	    B_FALSE);
318 
319 	/* Restore back to what qattach will expect */
320 	entersq(rq->q_syncq, SQ_OPENCLOSE);
321 
322 	ddi_rele_driver(maj);
323 	return (error);
324 }
325