xref: /titanic_41/usr/src/uts/common/fs/specfs/specvnops.c (revision 2bf00e07043e19042e1e812204a767057b8d3001)
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 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
25  */
26 
27 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 /*
31  * University Copyright- Copyright (c) 1982, 1986, 1988
32  * The Regents of the University of California
33  * All Rights Reserved
34  *
35  * University Acknowledgment- Portions of this document are derived from
36  * software developed by the University of California, Berkeley, and its
37  * contributors.
38  */
39 
40 #include <sys/types.h>
41 #include <sys/thread.h>
42 #include <sys/t_lock.h>
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/bitmap.h>
46 #include <sys/buf.h>
47 #include <sys/cmn_err.h>
48 #include <sys/conf.h>
49 #include <sys/ddi.h>
50 #include <sys/debug.h>
51 #include <sys/dkio.h>
52 #include <sys/errno.h>
53 #include <sys/time.h>
54 #include <sys/fcntl.h>
55 #include <sys/flock.h>
56 #include <sys/file.h>
57 #include <sys/kmem.h>
58 #include <sys/mman.h>
59 #include <sys/open.h>
60 #include <sys/swap.h>
61 #include <sys/sysmacros.h>
62 #include <sys/uio.h>
63 #include <sys/vfs.h>
64 #include <sys/vfs_opreg.h>
65 #include <sys/vnode.h>
66 #include <sys/stat.h>
67 #include <sys/poll.h>
68 #include <sys/stream.h>
69 #include <sys/strsubr.h>
70 #include <sys/policy.h>
71 #include <sys/devpolicy.h>
72 
73 #include <sys/proc.h>
74 #include <sys/user.h>
75 #include <sys/session.h>
76 #include <sys/vmsystm.h>
77 #include <sys/vtrace.h>
78 #include <sys/pathname.h>
79 
80 #include <sys/fs/snode.h>
81 
82 #include <vm/seg.h>
83 #include <vm/seg_map.h>
84 #include <vm/page.h>
85 #include <vm/pvn.h>
86 #include <vm/seg_dev.h>
87 #include <vm/seg_vn.h>
88 
89 #include <fs/fs_subr.h>
90 
91 #include <sys/esunddi.h>
92 #include <sys/autoconf.h>
93 #include <sys/sunndi.h>
94 #include <sys/contract/device_impl.h>
95 
96 
97 static int spec_open(struct vnode **, int, struct cred *, caller_context_t *);
98 static int spec_close(struct vnode *, int, int, offset_t, struct cred *,
99 	caller_context_t *);
100 static int spec_read(struct vnode *, struct uio *, int, struct cred *,
101 	caller_context_t *);
102 static int spec_write(struct vnode *, struct uio *, int, struct cred *,
103 	caller_context_t *);
104 static int spec_ioctl(struct vnode *, int, intptr_t, int, struct cred *, int *,
105 	caller_context_t *);
106 static int spec_getattr(struct vnode *, struct vattr *, int, struct cred *,
107 	caller_context_t *);
108 static int spec_setattr(struct vnode *, struct vattr *, int, struct cred *,
109 	caller_context_t *);
110 static int spec_access(struct vnode *, int, int, struct cred *,
111 	caller_context_t *);
112 static int spec_create(struct vnode *, char *, vattr_t *, enum vcexcl, int,
113 	struct vnode **, struct cred *, int, caller_context_t *, vsecattr_t *);
114 static int spec_fsync(struct vnode *, int, struct cred *, caller_context_t *);
115 static void spec_inactive(struct vnode *, struct cred *, caller_context_t *);
116 static int spec_fid(struct vnode *, struct fid *, caller_context_t *);
117 static int spec_seek(struct vnode *, offset_t, offset_t *, caller_context_t *);
118 static int spec_frlock(struct vnode *, int, struct flock64 *, int, offset_t,
119 	struct flk_callback *, struct cred *, caller_context_t *);
120 static int spec_realvp(struct vnode *, struct vnode **, caller_context_t *);
121 
122 static int spec_getpage(struct vnode *, offset_t, size_t, uint_t *, page_t **,
123 	size_t, struct seg *, caddr_t, enum seg_rw, struct cred *,
124 	caller_context_t *);
125 static int spec_putapage(struct vnode *, page_t *, u_offset_t *, size_t *, int,
126 	struct cred *);
127 static struct buf *spec_startio(struct vnode *, page_t *, u_offset_t, size_t,
128 	int);
129 static int spec_getapage(struct vnode *, u_offset_t, size_t, uint_t *,
130 	page_t **, size_t, struct seg *, caddr_t, enum seg_rw, struct cred *);
131 static int spec_map(struct vnode *, offset_t, struct as *, caddr_t *, size_t,
132 	uchar_t, uchar_t, uint_t, struct cred *, caller_context_t *);
133 static int spec_addmap(struct vnode *, offset_t, struct as *, caddr_t, size_t,
134 	uchar_t, uchar_t, uint_t, struct cred *, caller_context_t *);
135 static int spec_delmap(struct vnode *, offset_t, struct as *, caddr_t, size_t,
136 	uint_t, uint_t, uint_t, struct cred *, caller_context_t *);
137 
138 static int spec_poll(struct vnode *, short, int, short *, struct pollhead **,
139 	caller_context_t *);
140 static int spec_dump(struct vnode *, caddr_t, offset_t, offset_t,
141     caller_context_t *);
142 static int spec_pageio(struct vnode *, page_t *, u_offset_t, size_t, int,
143     cred_t *, caller_context_t *);
144 
145 static int spec_getsecattr(struct vnode *, vsecattr_t *, int, struct cred *,
146 	caller_context_t *);
147 static int spec_setsecattr(struct vnode *, vsecattr_t *, int, struct cred *,
148 	caller_context_t *);
149 static int spec_pathconf(struct	vnode *, int, ulong_t *, struct cred *,
150 	caller_context_t *);
151 
152 #define	SN_HOLD(csp)	{ \
153 	mutex_enter(&csp->s_lock); \
154 	csp->s_count++; \
155 	mutex_exit(&csp->s_lock); \
156 }
157 
158 #define	SN_RELE(csp)	{ \
159 	mutex_enter(&csp->s_lock); \
160 	csp->s_count--; \
161 	ASSERT((csp->s_count > 0) || (csp->s_vnode->v_stream == NULL)); \
162 	mutex_exit(&csp->s_lock); \
163 }
164 
165 #define	S_ISFENCED(sp)	((VTOS((sp)->s_commonvp))->s_flag & SFENCED)
166 
167 struct vnodeops *spec_vnodeops;
168 
169 /*
170  * *PLEASE NOTE*: If you add new entry points to specfs, do
171  * not forget to add support for fencing. A fenced snode
172  * is indicated by the SFENCED flag in the common snode.
173  * If a snode is fenced, determine if your entry point is
174  * a configuration operation (Example: open), a detection
175  * operation (Example: gettattr), an I/O operation (Example: ioctl())
176  * or an unconfiguration operation (Example: close). If it is
177  * a configuration or detection operation, fail the operation
178  * for a fenced snode with an ENXIO or EIO as appropriate. If
179  * it is any other operation, let it through.
180  */
181 
182 const fs_operation_def_t spec_vnodeops_template[] = {
183 	VOPNAME_OPEN,		{ .vop_open = spec_open },
184 	VOPNAME_CLOSE,		{ .vop_close = spec_close },
185 	VOPNAME_READ,		{ .vop_read = spec_read },
186 	VOPNAME_WRITE,		{ .vop_write = spec_write },
187 	VOPNAME_IOCTL,		{ .vop_ioctl = spec_ioctl },
188 	VOPNAME_GETATTR,	{ .vop_getattr = spec_getattr },
189 	VOPNAME_SETATTR,	{ .vop_setattr = spec_setattr },
190 	VOPNAME_ACCESS,		{ .vop_access = spec_access },
191 	VOPNAME_CREATE,		{ .vop_create = spec_create },
192 	VOPNAME_FSYNC,		{ .vop_fsync = spec_fsync },
193 	VOPNAME_INACTIVE,	{ .vop_inactive = spec_inactive },
194 	VOPNAME_FID,		{ .vop_fid = spec_fid },
195 	VOPNAME_SEEK,		{ .vop_seek = spec_seek },
196 	VOPNAME_PATHCONF,	{ .vop_pathconf = spec_pathconf },
197 	VOPNAME_FRLOCK,		{ .vop_frlock = spec_frlock },
198 	VOPNAME_REALVP,		{ .vop_realvp = spec_realvp },
199 	VOPNAME_GETPAGE,	{ .vop_getpage = spec_getpage },
200 	VOPNAME_PUTPAGE,	{ .vop_putpage = spec_putpage },
201 	VOPNAME_MAP,		{ .vop_map = spec_map },
202 	VOPNAME_ADDMAP,		{ .vop_addmap = spec_addmap },
203 	VOPNAME_DELMAP,		{ .vop_delmap = spec_delmap },
204 	VOPNAME_POLL,		{ .vop_poll = spec_poll },
205 	VOPNAME_DUMP,		{ .vop_dump = spec_dump },
206 	VOPNAME_PAGEIO,		{ .vop_pageio = spec_pageio },
207 	VOPNAME_SETSECATTR,	{ .vop_setsecattr = spec_setsecattr },
208 	VOPNAME_GETSECATTR,	{ .vop_getsecattr = spec_getsecattr },
209 	NULL,			NULL
210 };
211 
212 /*
213  * Return address of spec_vnodeops
214  */
215 struct vnodeops *
spec_getvnodeops(void)216 spec_getvnodeops(void)
217 {
218 	return (spec_vnodeops);
219 }
220 
221 extern vnode_t *rconsvp;
222 
223 /*
224  * Acquire the serial lock on the common snode.
225  */
226 #define	LOCK_CSP(csp)			(void) spec_lockcsp(csp, 0, 1, 0)
227 #define	LOCKHOLD_CSP_SIG(csp)		spec_lockcsp(csp, 1, 1, 1)
228 #define	SYNCHOLD_CSP_SIG(csp, intr)	spec_lockcsp(csp, intr, 0, 1)
229 
230 typedef enum {
231 	LOOP,
232 	INTR,
233 	SUCCESS
234 } slock_ret_t;
235 
236 /*
237  * Synchronize with active SLOCKED snode, optionally checking for a signal and
238  * optionally returning with SLOCKED set and SN_HOLD done.  The 'intr'
239  * argument determines if the thread is interruptible by a signal while
240  * waiting, the function returns INTR if interrupted while there is another
241  * thread closing this snonde and LOOP if interrupted otherwise.
242  * When SUCCESS is returned the 'hold' argument determines if the open
243  * count (SN_HOLD) has been incremented and the 'setlock' argument
244  * determines if the function returns with SLOCKED set.
245  */
246 static slock_ret_t
spec_lockcsp(struct snode * csp,int intr,int setlock,int hold)247 spec_lockcsp(struct snode *csp, int intr, int setlock, int hold)
248 {
249 	slock_ret_t ret = SUCCESS;
250 	mutex_enter(&csp->s_lock);
251 	while (csp->s_flag & SLOCKED) {
252 		csp->s_flag |= SWANT;
253 		if (intr) {
254 			if (!cv_wait_sig(&csp->s_cv, &csp->s_lock)) {
255 				if (csp->s_flag & SCLOSING)
256 					ret = INTR;
257 				else
258 					ret = LOOP;
259 				mutex_exit(&csp->s_lock);
260 				return (ret);		/* interrupted */
261 			}
262 		} else {
263 			cv_wait(&csp->s_cv, &csp->s_lock);
264 		}
265 	}
266 	if (setlock)
267 		csp->s_flag |= SLOCKED;
268 	if (hold)
269 		csp->s_count++;		/* one more open reference : SN_HOLD */
270 	mutex_exit(&csp->s_lock);
271 	return (ret);			/* serialized/locked */
272 }
273 
274 /*
275  * Unlock the serial lock on the common snode
276  */
277 #define	UNLOCK_CSP_LOCK_HELD(csp)			\
278 	ASSERT(mutex_owned(&csp->s_lock));		\
279 	if (csp->s_flag & SWANT)			\
280 		cv_broadcast(&csp->s_cv);		\
281 	csp->s_flag &= ~(SWANT|SLOCKED);
282 
283 #define	UNLOCK_CSP(csp)					\
284 	mutex_enter(&csp->s_lock);			\
285 	UNLOCK_CSP_LOCK_HELD(csp);			\
286 	mutex_exit(&csp->s_lock);
287 
288 /*
289  * compute/return the size of the device
290  */
291 #define	SPEC_SIZE(csp)	\
292 	(((csp)->s_flag & SSIZEVALID) ? (csp)->s_size : spec_size(csp))
293 
294 /*
295  * Compute and return the size.  If the size in the common snode is valid then
296  * return it.  If not valid then get the size from the driver and set size in
297  * the common snode.  If the device has not been attached then we don't ask for
298  * an update from the driver- for non-streams SSIZEVALID stays unset until the
299  * device is attached. A stat of a mknod outside /devices (non-devfs) may
300  * report UNKNOWN_SIZE because the device may not be attached yet (SDIPSET not
301  * established in mknod until open time). An stat in /devices will report the
302  * size correctly.  Specfs should always call SPEC_SIZE instead of referring
303  * directly to s_size to initialize/retrieve the size of a device.
304  *
305  * XXX There is an inconsistency between block and raw - "unknown" is
306  * UNKNOWN_SIZE for VBLK and 0 for VCHR(raw).
307  */
308 static u_offset_t
spec_size(struct snode * csp)309 spec_size(struct snode *csp)
310 {
311 	struct vnode	*cvp = STOV(csp);
312 	u_offset_t	size;
313 	int		plen;
314 	uint32_t	size32;
315 	dev_t		dev;
316 	dev_info_t	*devi;
317 	major_t		maj;
318 	uint_t		blksize;
319 	int		blkshift;
320 
321 	ASSERT((csp)->s_commonvp == cvp);	/* must be common node */
322 
323 	/* return cached value */
324 	mutex_enter(&csp->s_lock);
325 	if (csp->s_flag & SSIZEVALID) {
326 		mutex_exit(&csp->s_lock);
327 		return (csp->s_size);
328 	}
329 
330 	/* VOP_GETATTR of mknod has not had devcnt restriction applied */
331 	dev = cvp->v_rdev;
332 	maj = getmajor(dev);
333 	if (maj >= devcnt) {
334 		/* return non-cached UNKNOWN_SIZE */
335 		mutex_exit(&csp->s_lock);
336 		return ((cvp->v_type == VCHR) ? 0 : UNKNOWN_SIZE);
337 	}
338 
339 	/* establish cached zero size for streams */
340 	if (STREAMSTAB(maj)) {
341 		csp->s_size = 0;
342 		csp->s_flag |= SSIZEVALID;
343 		mutex_exit(&csp->s_lock);
344 		return (0);
345 	}
346 
347 	/*
348 	 * Return non-cached UNKNOWN_SIZE if not open.
349 	 *
350 	 * NB: This check is bogus, calling prop_op(9E) should be gated by
351 	 * attach, not open. Not having this check however opens up a new
352 	 * context under which a driver's prop_op(9E) could be called. Calling
353 	 * prop_op(9E) in this new context has been shown to expose latent
354 	 * driver bugs (insufficient NULL pointer checks that lead to panic).
355 	 * We are keeping this open check for now to avoid these panics.
356 	 */
357 	if (csp->s_count == 0) {
358 		mutex_exit(&csp->s_lock);
359 		return ((cvp->v_type == VCHR) ? 0 : UNKNOWN_SIZE);
360 	}
361 
362 	/* Return non-cached UNKNOWN_SIZE if not attached. */
363 	if (((csp->s_flag & SDIPSET) == 0) || (csp->s_dip == NULL) ||
364 	    !i_ddi_devi_attached(csp->s_dip)) {
365 		mutex_exit(&csp->s_lock);
366 		return ((cvp->v_type == VCHR) ? 0 : UNKNOWN_SIZE);
367 	}
368 
369 	devi = csp->s_dip;
370 
371 	/*
372 	 * Established cached size obtained from the attached driver. Since we
373 	 * know the devinfo node, for efficiency we use cdev_prop_op directly
374 	 * instead of [cb]dev_[Ss]size.
375 	 */
376 	if (cvp->v_type == VCHR) {
377 		size = 0;
378 		plen = sizeof (size);
379 		if (cdev_prop_op(dev, devi, PROP_LEN_AND_VAL_BUF,
380 		    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS |
381 		    DDI_PROP_CONSUMER_TYPED, "Size", (caddr_t)&size,
382 		    &plen) != DDI_PROP_SUCCESS) {
383 			plen = sizeof (size32);
384 			if (cdev_prop_op(dev, devi, PROP_LEN_AND_VAL_BUF,
385 			    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
386 			    "size", (caddr_t)&size32, &plen) ==
387 			    DDI_PROP_SUCCESS)
388 				size = size32;
389 		}
390 	} else {
391 		size = UNKNOWN_SIZE;
392 		plen = sizeof (size);
393 		if (cdev_prop_op(dev, devi, PROP_LEN_AND_VAL_BUF,
394 		    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS |
395 		    DDI_PROP_CONSUMER_TYPED, "Nblocks", (caddr_t)&size,
396 		    &plen) != DDI_PROP_SUCCESS) {
397 			plen = sizeof (size32);
398 			if (cdev_prop_op(dev, devi, PROP_LEN_AND_VAL_BUF,
399 			    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
400 			    "nblocks", (caddr_t)&size32, &plen) ==
401 			    DDI_PROP_SUCCESS)
402 				size = size32;
403 		}
404 
405 		if (size != UNKNOWN_SIZE) {
406 			blksize = DEV_BSIZE;		/* default */
407 			plen = sizeof (blksize);
408 
409 			/* try to get dev_t specific "blksize" */
410 			if (cdev_prop_op(dev, devi, PROP_LEN_AND_VAL_BUF,
411 			    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
412 			    "blksize", (caddr_t)&blksize, &plen) !=
413 			    DDI_PROP_SUCCESS) {
414 				/*
415 				 * Try for dev_info node "device-blksize".
416 				 * If this fails then blksize will still be
417 				 * DEV_BSIZE default value.
418 				 */
419 				(void) cdev_prop_op(DDI_DEV_T_ANY, devi,
420 				    PROP_LEN_AND_VAL_BUF,
421 				    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
422 				    "device-blksize", (caddr_t)&blksize, &plen);
423 			}
424 
425 			/* blksize must be a power of two */
426 			ASSERT(BIT_ONLYONESET(blksize));
427 			blkshift = highbit(blksize) - 1;
428 
429 			/* convert from block size to byte size */
430 			if (size < (MAXOFFSET_T >> blkshift))
431 				size = size << blkshift;
432 			else
433 				size = UNKNOWN_SIZE;
434 		}
435 	}
436 
437 	csp->s_size = size;
438 	csp->s_flag |= SSIZEVALID;
439 
440 	mutex_exit(&csp->s_lock);
441 	return (size);
442 }
443 
444 /*
445  * This function deal with vnode substitution in the case of
446  * device cloning.
447  */
448 static int
spec_clone(struct vnode ** vpp,dev_t newdev,int vtype,struct stdata * stp)449 spec_clone(struct vnode **vpp, dev_t newdev, int vtype, struct stdata *stp)
450 {
451 	dev_t		dev = (*vpp)->v_rdev;
452 	major_t		maj = getmajor(dev);
453 	major_t 	newmaj = getmajor(newdev);
454 	int		sysclone = (maj == clone_major);
455 	int		qassociate_used = 0;
456 	struct snode	*oldsp, *oldcsp;
457 	struct snode	*newsp, *newcsp;
458 	struct vnode	*newvp, *newcvp;
459 	dev_info_t	*dip;
460 	queue_t		*dq;
461 
462 	ASSERT(dev != newdev);
463 
464 	/*
465 	 * Check for cloning across different drivers.
466 	 * We only support this under the system provided clone driver
467 	 */
468 	if ((maj != newmaj) && !sysclone) {
469 		cmn_err(CE_NOTE,
470 		    "unsupported clone open maj = %u, newmaj = %u",
471 		    maj, newmaj);
472 		return (ENXIO);
473 	}
474 
475 	/* old */
476 	oldsp = VTOS(*vpp);
477 	oldcsp = VTOS(oldsp->s_commonvp);
478 
479 	/* new */
480 	newvp = makespecvp(newdev, vtype);
481 	ASSERT(newvp != NULL);
482 	newsp = VTOS(newvp);
483 	newcvp = newsp->s_commonvp;
484 	newcsp = VTOS(newcvp);
485 
486 	/*
487 	 * Clones inherit fsid, realvp, and dip.
488 	 * XXX realvp inherit is not occurring, does fstat of clone work?
489 	 */
490 	newsp->s_fsid = oldsp->s_fsid;
491 	if (sysclone) {
492 		newsp->s_flag |= SCLONE;
493 		dip = NULL;
494 	} else {
495 		newsp->s_flag |= SSELFCLONE;
496 		dip = oldcsp->s_dip;
497 	}
498 
499 	/*
500 	 * If we cloned to an opened newdev that already has called
501 	 * spec_assoc_vp_with_devi (SDIPSET set) then the association is
502 	 * already established.
503 	 */
504 	if (!(newcsp->s_flag & SDIPSET)) {
505 		/*
506 		 * Establish s_dip association for newdev.
507 		 *
508 		 * If we trusted the getinfo(9E) DDI_INFO_DEVT2INSTANCE
509 		 * implementation of all cloning drivers  (SCLONE and SELFCLONE)
510 		 * we would always use e_ddi_hold_devi_by_dev().  We know that
511 		 * many drivers have had (still have?) problems with
512 		 * DDI_INFO_DEVT2INSTANCE, so we try to minimize reliance by
513 		 * detecting drivers that use QASSOCIATE (by looking down the
514 		 * stream) and setting their s_dip association to NULL.
515 		 */
516 		qassociate_used = 0;
517 		if (stp) {
518 			for (dq = stp->sd_wrq; dq; dq = dq->q_next) {
519 				if (_RD(dq)->q_flag & _QASSOCIATED) {
520 					qassociate_used = 1;
521 					dip = NULL;
522 					break;
523 				}
524 			}
525 		}
526 
527 		if (dip || qassociate_used) {
528 			spec_assoc_vp_with_devi(newvp, dip);
529 		} else {
530 			/* derive association from newdev */
531 			dip = e_ddi_hold_devi_by_dev(newdev, 0);
532 			spec_assoc_vp_with_devi(newvp, dip);
533 			if (dip)
534 				ddi_release_devi(dip);
535 		}
536 	}
537 
538 	SN_HOLD(newcsp);
539 
540 	/* deal with stream stuff */
541 	if (stp != NULL) {
542 		LOCK_CSP(newcsp);	/* synchronize stream open/close */
543 		mutex_enter(&newcsp->s_lock);
544 		newcvp->v_stream = newvp->v_stream = stp;
545 		stp->sd_vnode = newcvp;
546 		stp->sd_strtab = STREAMSTAB(newmaj);
547 		mutex_exit(&newcsp->s_lock);
548 		UNLOCK_CSP(newcsp);
549 	}
550 
551 	/* substitute the vnode */
552 	SN_RELE(oldcsp);
553 	VN_RELE(*vpp);
554 	*vpp = newvp;
555 
556 	return (0);
557 }
558 
559 static int
spec_open(struct vnode ** vpp,int flag,struct cred * cr,caller_context_t * cc)560 spec_open(struct vnode **vpp, int flag, struct cred *cr, caller_context_t *cc)
561 {
562 	major_t maj;
563 	dev_t dev, newdev;
564 	struct vnode *vp, *cvp;
565 	struct snode *sp, *csp;
566 	struct stdata *stp;
567 	dev_info_t *dip;
568 	int error, type;
569 	contract_t *ct = NULL;
570 	int open_returns_eintr;
571 	slock_ret_t spec_locksp_ret;
572 
573 
574 	flag &= ~FCREAT;		/* paranoia */
575 
576 	vp = *vpp;
577 	sp = VTOS(vp);
578 	ASSERT((vp->v_type == VCHR) || (vp->v_type == VBLK));
579 	if ((vp->v_type != VCHR) && (vp->v_type != VBLK))
580 		return (ENXIO);
581 
582 	/*
583 	 * If the VFS_NODEVICES bit was set for the mount,
584 	 * do not allow opens of special devices.
585 	 */
586 	if (sp->s_realvp && (sp->s_realvp->v_vfsp->vfs_flag & VFS_NODEVICES))
587 		return (ENXIO);
588 
589 	newdev = dev = vp->v_rdev;
590 
591 	/*
592 	 * If we are opening a node that has not had spec_assoc_vp_with_devi
593 	 * called against it (mknod outside /devices or a non-dacf makespecvp
594 	 * node) then SDIPSET will not be set. In this case we call an
595 	 * interface which will reconstruct the path and lookup (drive attach)
596 	 * through devfs (e_ddi_hold_devi_by_dev -> e_ddi_hold_devi_by_path ->
597 	 * devfs_lookupname).  For support of broken drivers that don't call
598 	 * ddi_create_minor_node for all minor nodes in their instance space,
599 	 * we call interfaces that operates at the directory/devinfo
600 	 * (major/instance) level instead of to the leaf/minor node level.
601 	 * After finding and attaching the dip we associate it with the
602 	 * common specfs vnode (s_dip), which sets SDIPSET.  A DL_DETACH_REQ
603 	 * to style-2 stream driver may set s_dip to NULL with SDIPSET set.
604 	 *
605 	 * NOTE: Although e_ddi_hold_devi_by_dev takes a dev_t argument, its
606 	 * implementation operates at the major/instance level since it only
607 	 * need to return a dip.
608 	 */
609 	cvp = sp->s_commonvp;
610 	csp = VTOS(cvp);
611 	if (!(csp->s_flag & SDIPSET)) {
612 		/* try to attach, return error if we fail */
613 		if ((dip = e_ddi_hold_devi_by_dev(dev, 0)) == NULL)
614 			return (ENXIO);
615 
616 		/* associate dip with the common snode s_dip */
617 		spec_assoc_vp_with_devi(vp, dip);
618 		ddi_release_devi(dip);	/* from e_ddi_hold_devi_by_dev */
619 	}
620 
621 	/* check if device fenced off */
622 	if (S_ISFENCED(sp))
623 		return (ENXIO);
624 
625 #ifdef  DEBUG
626 	/* verify attach/open exclusion guarantee */
627 	dip = csp->s_dip;
628 	ASSERT((dip == NULL) || i_ddi_devi_attached(dip));
629 #endif  /* DEBUG */
630 
631 	if ((error = secpolicy_spec_open(cr, vp, flag)) != 0)
632 		return (error);
633 
634 	/* Verify existance of open(9E) implementation. */
635 	maj = getmajor(dev);
636 	if ((maj >= devcnt) ||
637 	    (devopsp[maj]->devo_cb_ops == NULL) ||
638 	    (devopsp[maj]->devo_cb_ops->cb_open == NULL))
639 		return (ENXIO);
640 
641 	/*
642 	 * split STREAMS vs. non-STREAMS
643 	 *
644 	 * If the device is a dual-personality device, then we might want
645 	 * to allow for a regular OTYP_BLK open.  If however it's strictly
646 	 * a pure STREAMS device, the cb_open entry point will be
647 	 * nodev() which returns ENXIO.  This does make this failure path
648 	 * somewhat longer, but such attempts to use OTYP_BLK with STREAMS
649 	 * devices should be exceedingly rare.  (Most of the time they will
650 	 * be due to programmer error.)
651 	 */
652 	if ((vp->v_type == VCHR) && (STREAMSTAB(maj)))
653 		goto streams_open;
654 
655 not_streams:
656 	/*
657 	 * Wait for in progress last close to complete. This guarantees
658 	 * to the driver writer that we will never be in the drivers
659 	 * open and close on the same (dev_t, otype) at the same time.
660 	 * Open count already incremented (SN_HOLD) on non-zero return.
661 	 * The wait is interruptible by a signal if the driver sets the
662 	 * D_OPEN_RETURNS_EINTR cb_ops(9S) cb_flag or sets the
663 	 * ddi-open-returns-eintr(9P) property in its driver.conf.
664 	 */
665 	if ((devopsp[maj]->devo_cb_ops->cb_flag & D_OPEN_RETURNS_EINTR) ||
666 	    (devnamesp[maj].dn_flags & DN_OPEN_RETURNS_EINTR))
667 		open_returns_eintr = 1;
668 	else
669 		open_returns_eintr = 0;
670 	while ((spec_locksp_ret = SYNCHOLD_CSP_SIG(csp, open_returns_eintr)) !=
671 	    SUCCESS) {
672 		if (spec_locksp_ret == INTR)
673 			return (EINTR);
674 	}
675 
676 	/* non streams open */
677 	type = (vp->v_type == VBLK ? OTYP_BLK : OTYP_CHR);
678 	error = dev_open(&newdev, flag, type, cr);
679 
680 	/* deal with clone case */
681 	if (error == 0 && dev != newdev) {
682 		error = spec_clone(vpp, newdev, vp->v_type, NULL);
683 		/*
684 		 * bail on clone failure, further processing
685 		 * results in undefined behaviors.
686 		 */
687 		if (error != 0)
688 			return (error);
689 		sp = VTOS(*vpp);
690 		csp = VTOS(sp->s_commonvp);
691 	}
692 
693 	/*
694 	 * create contracts only for userland opens
695 	 * Successful open and cloning is done at this point.
696 	 */
697 	if (error == 0 && !(flag & FKLYR)) {
698 		int spec_type;
699 		spec_type = (STOV(csp)->v_type == VCHR) ? S_IFCHR : S_IFBLK;
700 		if (contract_device_open(newdev, spec_type, NULL) != 0) {
701 			error = EIO;
702 		}
703 	}
704 
705 	if (error == 0) {
706 		sp->s_size = SPEC_SIZE(csp);
707 
708 		if ((csp->s_flag & SNEEDCLOSE) == 0) {
709 			int nmaj = getmajor(newdev);
710 			mutex_enter(&csp->s_lock);
711 			/* successful open needs a close later */
712 			csp->s_flag |= SNEEDCLOSE;
713 
714 			/*
715 			 * Invalidate possible cached "unknown" size
716 			 * established by a VOP_GETATTR while open was in
717 			 * progress, and the driver might fail prop_op(9E).
718 			 */
719 			if (((cvp->v_type == VCHR) && (csp->s_size == 0)) ||
720 			    ((cvp->v_type == VBLK) &&
721 			    (csp->s_size == UNKNOWN_SIZE)))
722 				csp->s_flag &= ~SSIZEVALID;
723 
724 			if (devopsp[nmaj]->devo_cb_ops->cb_flag & D_64BIT)
725 				csp->s_flag |= SLOFFSET;
726 			if (devopsp[nmaj]->devo_cb_ops->cb_flag & D_U64BIT)
727 				csp->s_flag |= SLOFFSET | SANYOFFSET;
728 			mutex_exit(&csp->s_lock);
729 		}
730 		return (0);
731 	}
732 
733 	/*
734 	 * Open failed. If we missed a close operation because
735 	 * we were trying to get the device open and it is the
736 	 * last in progress open that is failing then call close.
737 	 *
738 	 * NOTE: Only non-streams open has this race condition.
739 	 */
740 	mutex_enter(&csp->s_lock);
741 	csp->s_count--;			/* decrement open count : SN_RELE */
742 	if ((csp->s_count == 0) &&	/* no outstanding open */
743 	    (csp->s_mapcnt == 0) &&	/* no mapping */
744 	    (csp->s_flag & SNEEDCLOSE)) { /* need a close */
745 		csp->s_flag &= ~(SNEEDCLOSE | SSIZEVALID);
746 
747 		/* See comment in spec_close() */
748 		if (csp->s_flag & (SCLONE | SSELFCLONE))
749 			csp->s_flag &= ~SDIPSET;
750 
751 		csp->s_flag |= SCLOSING;
752 		mutex_exit(&csp->s_lock);
753 
754 		ASSERT(*vpp != NULL);
755 		(void) device_close(*vpp, flag, cr);
756 
757 		mutex_enter(&csp->s_lock);
758 		csp->s_flag &= ~SCLOSING;
759 		mutex_exit(&csp->s_lock);
760 	} else {
761 		mutex_exit(&csp->s_lock);
762 	}
763 	return (error);
764 
765 streams_open:
766 	/*
767 	 * Lock common snode to prevent any new clone opens on this
768 	 * stream while one is in progress. This is necessary since
769 	 * the stream currently associated with the clone device will
770 	 * not be part of it after the clone open completes. Unfortunately
771 	 * we don't know in advance if this is a clone
772 	 * device so we have to lock all opens.
773 	 *
774 	 * If we fail, it's because of an interrupt - EINTR return is an
775 	 * expected aspect of opening a stream so we don't need to check
776 	 * D_OPEN_RETURNS_EINTR. Open count already incremented (SN_HOLD)
777 	 * on non-zero return.
778 	 */
779 	if (LOCKHOLD_CSP_SIG(csp) != SUCCESS)
780 		return (EINTR);
781 
782 	error = stropen(cvp, &newdev, flag, cr);
783 	stp = cvp->v_stream;
784 
785 	/* deal with the clone case */
786 	if ((error == 0) && (dev != newdev)) {
787 		vp->v_stream = cvp->v_stream = NULL;
788 		UNLOCK_CSP(csp);
789 		error = spec_clone(vpp, newdev, vp->v_type, stp);
790 		/*
791 		 * bail on clone failure, further processing
792 		 * results in undefined behaviors.
793 		 */
794 		if (error != 0)
795 			return (error);
796 		sp = VTOS(*vpp);
797 		csp = VTOS(sp->s_commonvp);
798 	} else if (error == 0) {
799 		vp->v_stream = stp;
800 		UNLOCK_CSP(csp);
801 	}
802 
803 	/*
804 	 * create contracts only for userland opens
805 	 * Successful open and cloning is done at this point.
806 	 */
807 	if (error == 0 && !(flag & FKLYR)) {
808 		/* STREAM is of type S_IFCHR */
809 		if (contract_device_open(newdev, S_IFCHR, &ct) != 0) {
810 			UNLOCK_CSP(csp);
811 			(void) spec_close(vp, flag, 1, 0, cr, cc);
812 			return (EIO);
813 		}
814 	}
815 
816 	if (error == 0) {
817 		/* STREAMS devices don't have a size */
818 		sp->s_size = csp->s_size = 0;
819 
820 		if (!(stp->sd_flag & STRISTTY) || (flag & FNOCTTY))
821 			return (0);
822 
823 		/* try to allocate it as a controlling terminal */
824 		if (strctty(stp) != EINTR)
825 			return (0);
826 
827 		/* strctty() was interrupted by a signal */
828 		if (ct) {
829 			/* we only create contracts for userland opens */
830 			ASSERT(ttoproc(curthread));
831 			(void) contract_abandon(ct, ttoproc(curthread), 0);
832 		}
833 		(void) spec_close(vp, flag, 1, 0, cr, cc);
834 		return (EINTR);
835 	}
836 
837 	/*
838 	 * Deal with stropen failure.
839 	 *
840 	 * sd_flag in the stream head cannot change since the
841 	 * common snode is locked before the call to stropen().
842 	 */
843 	if ((stp != NULL) && (stp->sd_flag & STREOPENFAIL)) {
844 		/*
845 		 * Open failed part way through.
846 		 */
847 		mutex_enter(&stp->sd_lock);
848 		stp->sd_flag &= ~STREOPENFAIL;
849 		mutex_exit(&stp->sd_lock);
850 
851 		UNLOCK_CSP(csp);
852 		(void) spec_close(vp, flag, 1, 0, cr, cc);
853 	} else {
854 		UNLOCK_CSP(csp);
855 		SN_RELE(csp);
856 	}
857 
858 	/*
859 	 * Resolution for STREAMS vs. regular character device: If the
860 	 * STREAMS open(9e) returns ENOSTR, then try an ordinary device
861 	 * open instead.
862 	 */
863 	if (error == ENOSTR) {
864 		goto not_streams;
865 	}
866 	return (error);
867 }
868 
869 /*ARGSUSED2*/
870 static int
spec_close(struct vnode * vp,int flag,int count,offset_t offset,struct cred * cr,caller_context_t * ct)871 spec_close(
872 	struct vnode	*vp,
873 	int		flag,
874 	int		count,
875 	offset_t	offset,
876 	struct cred	*cr,
877 	caller_context_t *ct)
878 {
879 	struct vnode *cvp;
880 	struct snode *sp, *csp;
881 	enum vtype type;
882 	dev_t dev;
883 	int error = 0;
884 	int sysclone;
885 
886 	if (!(flag & FKLYR)) {
887 		/* this only applies to closes of devices from userland */
888 		cleanlocks(vp, ttoproc(curthread)->p_pid, 0);
889 		cleanshares(vp, ttoproc(curthread)->p_pid);
890 		if (vp->v_stream)
891 			strclean(vp);
892 	}
893 	if (count > 1)
894 		return (0);
895 
896 	/* we allow close to succeed even if device is fenced off */
897 	sp = VTOS(vp);
898 	cvp = sp->s_commonvp;
899 
900 	dev = sp->s_dev;
901 	type = vp->v_type;
902 
903 	ASSERT(type == VCHR || type == VBLK);
904 
905 	/*
906 	 * Prevent close/close and close/open races by serializing closes
907 	 * on this common snode. Clone opens are held up until after
908 	 * we have closed this device so the streams linkage is maintained
909 	 */
910 	csp = VTOS(cvp);
911 
912 	LOCK_CSP(csp);
913 	mutex_enter(&csp->s_lock);
914 
915 	csp->s_count--;			/* one fewer open reference : SN_RELE */
916 	sysclone = sp->s_flag & SCLONE;
917 
918 	/*
919 	 * Invalidate size on each close.
920 	 *
921 	 * XXX We do this on each close because we don't have interfaces that
922 	 * allow a driver to invalidate the size.  Since clearing this on each
923 	 * close this causes property overhead we skip /dev/null and
924 	 * /dev/zero to avoid degrading kenbus performance.
925 	 */
926 	if (getmajor(dev) != mm_major)
927 		csp->s_flag &= ~SSIZEVALID;
928 
929 	/*
930 	 * Only call the close routine when the last open reference through
931 	 * any [s, v]node goes away.  This can be checked by looking at
932 	 * s_count on the common vnode.
933 	 */
934 	if ((csp->s_count == 0) && (csp->s_mapcnt == 0)) {
935 		/* we don't need a close */
936 		csp->s_flag &= ~(SNEEDCLOSE | SSIZEVALID);
937 
938 		/*
939 		 * A cloning driver may open-clone to the same dev_t that we
940 		 * are closing before spec_inactive destroys the common snode.
941 		 * If this occurs the s_dip association needs to be reevaluated.
942 		 * We clear SDIPSET to force reevaluation in this case.  When
943 		 * reevaluation occurs (by spec_clone after open), if the
944 		 * devinfo association has changed then the old association
945 		 * will be released as the new association is established by
946 		 * spec_assoc_vp_with_devi().
947 		 */
948 		if (csp->s_flag & (SCLONE | SSELFCLONE))
949 			csp->s_flag &= ~SDIPSET;
950 
951 		csp->s_flag |= SCLOSING;
952 		mutex_exit(&csp->s_lock);
953 		error = device_close(vp, flag, cr);
954 
955 		/*
956 		 * Decrement the devops held in clnopen()
957 		 */
958 		if (sysclone) {
959 			ddi_rele_driver(getmajor(dev));
960 		}
961 		mutex_enter(&csp->s_lock);
962 		csp->s_flag &= ~SCLOSING;
963 	}
964 
965 	UNLOCK_CSP_LOCK_HELD(csp);
966 	mutex_exit(&csp->s_lock);
967 
968 	return (error);
969 }
970 
971 /*ARGSUSED2*/
972 static int
spec_read(struct vnode * vp,struct uio * uiop,int ioflag,struct cred * cr,caller_context_t * ct)973 spec_read(
974 	struct vnode	*vp,
975 	struct uio	*uiop,
976 	int		ioflag,
977 	struct cred	*cr,
978 	caller_context_t *ct)
979 {
980 	int error;
981 	struct snode *sp = VTOS(vp);
982 	dev_t dev = sp->s_dev;
983 	size_t n;
984 	ulong_t on;
985 	u_offset_t bdevsize;
986 	offset_t maxoff;
987 	offset_t off;
988 	struct vnode *blkvp;
989 
990 	ASSERT(vp->v_type == VCHR || vp->v_type == VBLK);
991 
992 	if (vp->v_stream) {
993 		ASSERT(vp->v_type == VCHR);
994 		smark(sp, SACC);
995 		return (strread(vp, uiop, cr));
996 	}
997 
998 	if (uiop->uio_resid == 0)
999 		return (0);
1000 
1001 	/*
1002 	 * Plain old character devices that set D_U64BIT can have
1003 	 * unrestricted offsets.
1004 	 */
1005 	maxoff = spec_maxoffset(vp);
1006 	ASSERT(maxoff != -1 || vp->v_type == VCHR);
1007 
1008 	if (maxoff != -1 && (uiop->uio_loffset < 0 ||
1009 	    uiop->uio_loffset + uiop->uio_resid > maxoff))
1010 		return (EINVAL);
1011 
1012 	if (vp->v_type == VCHR) {
1013 		smark(sp, SACC);
1014 		ASSERT(vp->v_stream == NULL);
1015 		return (cdev_read(dev, uiop, cr));
1016 	}
1017 
1018 	/*
1019 	 * Block device.
1020 	 */
1021 	error = 0;
1022 	blkvp = sp->s_commonvp;
1023 	bdevsize = SPEC_SIZE(VTOS(blkvp));
1024 
1025 	do {
1026 		caddr_t base;
1027 		offset_t diff;
1028 
1029 		off = uiop->uio_loffset & (offset_t)MAXBMASK;
1030 		on = (size_t)(uiop->uio_loffset & MAXBOFFSET);
1031 		n = (size_t)MIN(MAXBSIZE - on, uiop->uio_resid);
1032 		diff = bdevsize - uiop->uio_loffset;
1033 
1034 		if (diff <= 0)
1035 			break;
1036 		if (diff < n)
1037 			n = (size_t)diff;
1038 
1039 		if (vpm_enable) {
1040 			error = vpm_data_copy(blkvp, (u_offset_t)(off + on),
1041 			    n, uiop, 1, NULL, 0, S_READ);
1042 		} else {
1043 			base = segmap_getmapflt(segkmap, blkvp,
1044 			    (u_offset_t)(off + on), n, 1, S_READ);
1045 
1046 			error = uiomove(base + on, n, UIO_READ, uiop);
1047 		}
1048 		if (!error) {
1049 			int flags = 0;
1050 			/*
1051 			 * If we read a whole block, we won't need this
1052 			 * buffer again soon.
1053 			 */
1054 			if (n + on == MAXBSIZE)
1055 				flags = SM_DONTNEED | SM_FREE;
1056 			if (vpm_enable) {
1057 				error = vpm_sync_pages(blkvp, off, n, flags);
1058 			} else {
1059 				error = segmap_release(segkmap, base, flags);
1060 			}
1061 		} else {
1062 			if (vpm_enable) {
1063 				(void) vpm_sync_pages(blkvp, off, n, 0);
1064 			} else {
1065 				(void) segmap_release(segkmap, base, 0);
1066 			}
1067 			if (bdevsize == UNKNOWN_SIZE) {
1068 				error = 0;
1069 				break;
1070 			}
1071 		}
1072 	} while (error == 0 && uiop->uio_resid > 0 && n != 0);
1073 
1074 	return (error);
1075 }
1076 
1077 /*ARGSUSED*/
1078 static int
spec_write(struct vnode * vp,struct uio * uiop,int ioflag,struct cred * cr,caller_context_t * ct)1079 spec_write(
1080 	struct vnode *vp,
1081 	struct uio *uiop,
1082 	int ioflag,
1083 	struct cred *cr,
1084 	caller_context_t *ct)
1085 {
1086 	int error;
1087 	struct snode *sp = VTOS(vp);
1088 	dev_t dev = sp->s_dev;
1089 	size_t n;
1090 	ulong_t on;
1091 	u_offset_t bdevsize;
1092 	offset_t maxoff;
1093 	offset_t off;
1094 	struct vnode *blkvp;
1095 
1096 	ASSERT(vp->v_type == VCHR || vp->v_type == VBLK);
1097 
1098 	if (vp->v_stream) {
1099 		ASSERT(vp->v_type == VCHR);
1100 		smark(sp, SUPD);
1101 		return (strwrite(vp, uiop, cr));
1102 	}
1103 
1104 	/*
1105 	 * Plain old character devices that set D_U64BIT can have
1106 	 * unrestricted offsets.
1107 	 */
1108 	maxoff = spec_maxoffset(vp);
1109 	ASSERT(maxoff != -1 || vp->v_type == VCHR);
1110 
1111 	if (maxoff != -1 && (uiop->uio_loffset < 0 ||
1112 	    uiop->uio_loffset + uiop->uio_resid > maxoff))
1113 		return (EINVAL);
1114 
1115 	if (vp->v_type == VCHR) {
1116 		smark(sp, SUPD);
1117 		ASSERT(vp->v_stream == NULL);
1118 		return (cdev_write(dev, uiop, cr));
1119 	}
1120 
1121 	if (uiop->uio_resid == 0)
1122 		return (0);
1123 
1124 	error = 0;
1125 	blkvp = sp->s_commonvp;
1126 	bdevsize = SPEC_SIZE(VTOS(blkvp));
1127 
1128 	do {
1129 		int pagecreate;
1130 		int newpage;
1131 		caddr_t base;
1132 		offset_t diff;
1133 
1134 		off = uiop->uio_loffset & (offset_t)MAXBMASK;
1135 		on = (ulong_t)(uiop->uio_loffset & MAXBOFFSET);
1136 		n = (size_t)MIN(MAXBSIZE - on, uiop->uio_resid);
1137 		pagecreate = 0;
1138 
1139 		diff = bdevsize - uiop->uio_loffset;
1140 		if (diff <= 0) {
1141 			error = ENXIO;
1142 			break;
1143 		}
1144 		if (diff < n)
1145 			n = (size_t)diff;
1146 
1147 		/*
1148 		 * Check to see if we can skip reading in the page
1149 		 * and just allocate the memory.  We can do this
1150 		 * if we are going to rewrite the entire mapping
1151 		 * or if we are going to write to end of the device
1152 		 * from the beginning of the mapping.
1153 		 */
1154 		if (n == MAXBSIZE || (on == 0 && (off + n) == bdevsize))
1155 			pagecreate = 1;
1156 
1157 		newpage = 0;
1158 
1159 		/*
1160 		 * Touch the page and fault it in if it is not in core
1161 		 * before segmap_getmapflt or vpm_data_copy can lock it.
1162 		 * This is to avoid the deadlock if the buffer is mapped
1163 		 * to the same file through mmap which we want to write.
1164 		 */
1165 		uio_prefaultpages((long)n, uiop);
1166 
1167 		if (vpm_enable) {
1168 			error = vpm_data_copy(blkvp, (u_offset_t)(off + on),
1169 			    n, uiop, !pagecreate, NULL, 0, S_WRITE);
1170 		} else {
1171 			base = segmap_getmapflt(segkmap, blkvp,
1172 			    (u_offset_t)(off + on), n, !pagecreate, S_WRITE);
1173 
1174 			/*
1175 			 * segmap_pagecreate() returns 1 if it calls
1176 			 * page_create_va() to allocate any pages.
1177 			 */
1178 
1179 			if (pagecreate)
1180 				newpage = segmap_pagecreate(segkmap, base + on,
1181 				    n, 0);
1182 
1183 			error = uiomove(base + on, n, UIO_WRITE, uiop);
1184 		}
1185 
1186 		if (!vpm_enable && pagecreate &&
1187 		    uiop->uio_loffset <
1188 		    P2ROUNDUP_TYPED(off + on + n, PAGESIZE, offset_t)) {
1189 			/*
1190 			 * We created pages w/o initializing them completely,
1191 			 * thus we need to zero the part that wasn't set up.
1192 			 * This can happen if we write to the end of the device
1193 			 * or if we had some sort of error during the uiomove.
1194 			 */
1195 			long nzero;
1196 			offset_t nmoved;
1197 
1198 			nmoved = (uiop->uio_loffset - (off + on));
1199 			if (nmoved < 0 || nmoved > n) {
1200 				panic("spec_write: nmoved bogus");
1201 				/*NOTREACHED*/
1202 			}
1203 			nzero = (long)P2ROUNDUP(on + n, PAGESIZE) -
1204 			    (on + nmoved);
1205 			if (nzero < 0 || (on + nmoved + nzero > MAXBSIZE)) {
1206 				panic("spec_write: nzero bogus");
1207 				/*NOTREACHED*/
1208 			}
1209 			(void) kzero(base + on + nmoved, (size_t)nzero);
1210 		}
1211 
1212 		/*
1213 		 * Unlock the pages which have been allocated by
1214 		 * page_create_va() in segmap_pagecreate().
1215 		 */
1216 		if (!vpm_enable && newpage)
1217 			segmap_pageunlock(segkmap, base + on,
1218 			    (size_t)n, S_WRITE);
1219 
1220 		if (error == 0) {
1221 			int flags = 0;
1222 
1223 			/*
1224 			 * Force write back for synchronous write cases.
1225 			 */
1226 			if (ioflag & (FSYNC|FDSYNC))
1227 				flags = SM_WRITE;
1228 			else if (n + on == MAXBSIZE || IS_SWAPVP(vp)) {
1229 				/*
1230 				 * Have written a whole block.
1231 				 * Start an asynchronous write and
1232 				 * mark the buffer to indicate that
1233 				 * it won't be needed again soon.
1234 				 * Push swap files here, since it
1235 				 * won't happen anywhere else.
1236 				 */
1237 				flags = SM_WRITE | SM_ASYNC | SM_DONTNEED;
1238 			}
1239 			smark(sp, SUPD|SCHG);
1240 			if (vpm_enable) {
1241 				error = vpm_sync_pages(blkvp, off, n, flags);
1242 			} else {
1243 				error = segmap_release(segkmap, base, flags);
1244 			}
1245 		} else {
1246 			if (vpm_enable) {
1247 				(void) vpm_sync_pages(blkvp, off, n, SM_INVAL);
1248 			} else {
1249 				(void) segmap_release(segkmap, base, SM_INVAL);
1250 			}
1251 		}
1252 
1253 	} while (error == 0 && uiop->uio_resid > 0 && n != 0);
1254 
1255 	return (error);
1256 }
1257 
1258 /*ARGSUSED6*/
1259 static int
spec_ioctl(struct vnode * vp,int cmd,intptr_t arg,int mode,struct cred * cr,int * rvalp,caller_context_t * ct)1260 spec_ioctl(struct vnode *vp, int cmd, intptr_t arg, int mode, struct cred *cr,
1261     int *rvalp, caller_context_t *ct)
1262 {
1263 	struct snode *sp;
1264 	dev_t dev;
1265 	int error;
1266 
1267 	if (vp->v_type != VCHR)
1268 		return (ENOTTY);
1269 
1270 	/*
1271 	 * allow ioctls() to go through even for fenced snodes, as they
1272 	 * may include unconfiguration operation - for example popping of
1273 	 * streams modules.
1274 	 */
1275 
1276 	sp = VTOS(vp);
1277 	dev = sp->s_dev;
1278 	if (vp->v_stream) {
1279 		error = strioctl(vp, cmd, arg, mode, U_TO_K, cr, rvalp);
1280 	} else {
1281 		error = cdev_ioctl(dev, cmd, arg, mode, cr, rvalp);
1282 	}
1283 	return (error);
1284 }
1285 
1286 static int
spec_getattr(struct vnode * vp,struct vattr * vap,int flags,struct cred * cr,caller_context_t * ct)1287 spec_getattr(
1288 	struct vnode *vp,
1289 	struct vattr *vap,
1290 	int flags,
1291 	struct cred *cr,
1292 	caller_context_t *ct)
1293 {
1294 	int error;
1295 	struct snode *sp;
1296 	struct vnode *realvp;
1297 
1298 	/* With ATTR_COMM we will not get attributes from realvp */
1299 	if (flags & ATTR_COMM) {
1300 		sp = VTOS(vp);
1301 		vp = sp->s_commonvp;
1302 	}
1303 	sp = VTOS(vp);
1304 
1305 	/* we want stat() to fail with ENXIO if the device is fenced off */
1306 	if (S_ISFENCED(sp))
1307 		return (ENXIO);
1308 
1309 	realvp = sp->s_realvp;
1310 
1311 	if (realvp == NULL) {
1312 		static int snode_shift	= 0;
1313 
1314 		/*
1315 		 * Calculate the amount of bitshift to a snode pointer which
1316 		 * will still keep it unique.  See below.
1317 		 */
1318 		if (snode_shift == 0)
1319 			snode_shift = highbit(sizeof (struct snode));
1320 		ASSERT(snode_shift > 0);
1321 
1322 		/*
1323 		 * No real vnode behind this one.  Fill in the fields
1324 		 * from the snode.
1325 		 *
1326 		 * This code should be refined to return only the
1327 		 * attributes asked for instead of all of them.
1328 		 */
1329 		vap->va_type = vp->v_type;
1330 		vap->va_mode = 0;
1331 		vap->va_uid = vap->va_gid = 0;
1332 		vap->va_fsid = sp->s_fsid;
1333 
1334 		/*
1335 		 * If the va_nodeid is > MAX_USHORT, then i386 stats might
1336 		 * fail. So we shift down the snode pointer to try and get
1337 		 * the most uniqueness into 16-bits.
1338 		 */
1339 		vap->va_nodeid = ((ino64_t)(uintptr_t)sp >> snode_shift) &
1340 		    0xFFFF;
1341 		vap->va_nlink = 0;
1342 		vap->va_rdev = sp->s_dev;
1343 
1344 		/*
1345 		 * va_nblocks is the number of 512 byte blocks used to store
1346 		 * the mknod for the device, not the number of blocks on the
1347 		 * device itself.  This is typically zero since the mknod is
1348 		 * represented directly in the inode itself.
1349 		 */
1350 		vap->va_nblocks = 0;
1351 	} else {
1352 		error = VOP_GETATTR(realvp, vap, flags, cr, ct);
1353 		if (error != 0)
1354 			return (error);
1355 	}
1356 
1357 	/* set the size from the snode */
1358 	vap->va_size = SPEC_SIZE(VTOS(sp->s_commonvp));
1359 	vap->va_blksize = MAXBSIZE;
1360 
1361 	mutex_enter(&sp->s_lock);
1362 	vap->va_atime.tv_sec = sp->s_atime;
1363 	vap->va_mtime.tv_sec = sp->s_mtime;
1364 	vap->va_ctime.tv_sec = sp->s_ctime;
1365 	mutex_exit(&sp->s_lock);
1366 
1367 	vap->va_atime.tv_nsec = 0;
1368 	vap->va_mtime.tv_nsec = 0;
1369 	vap->va_ctime.tv_nsec = 0;
1370 	vap->va_seq = 0;
1371 
1372 	return (0);
1373 }
1374 
1375 static int
spec_setattr(struct vnode * vp,struct vattr * vap,int flags,struct cred * cr,caller_context_t * ct)1376 spec_setattr(
1377 	struct vnode *vp,
1378 	struct vattr *vap,
1379 	int flags,
1380 	struct cred *cr,
1381 	caller_context_t *ct)
1382 {
1383 	struct snode *sp = VTOS(vp);
1384 	struct vnode *realvp;
1385 	int error;
1386 
1387 	/* fail with ENXIO if the device is fenced off */
1388 	if (S_ISFENCED(sp))
1389 		return (ENXIO);
1390 
1391 	if (vp->v_type == VCHR && vp->v_stream && (vap->va_mask & AT_SIZE)) {
1392 		/*
1393 		 * 1135080:	O_TRUNC should have no effect on
1394 		 *		named pipes and terminal devices.
1395 		 */
1396 		ASSERT(vap->va_mask == AT_SIZE);
1397 		return (0);
1398 	}
1399 
1400 	if ((realvp = sp->s_realvp) == NULL)
1401 		error = 0;	/* no real vnode to update */
1402 	else
1403 		error = VOP_SETATTR(realvp, vap, flags, cr, ct);
1404 	if (error == 0) {
1405 		/*
1406 		 * If times were changed, update snode.
1407 		 */
1408 		mutex_enter(&sp->s_lock);
1409 		if (vap->va_mask & AT_ATIME)
1410 			sp->s_atime = vap->va_atime.tv_sec;
1411 		if (vap->va_mask & AT_MTIME) {
1412 			sp->s_mtime = vap->va_mtime.tv_sec;
1413 			sp->s_ctime = gethrestime_sec();
1414 		}
1415 		mutex_exit(&sp->s_lock);
1416 	}
1417 	return (error);
1418 }
1419 
1420 static int
spec_access(struct vnode * vp,int mode,int flags,struct cred * cr,caller_context_t * ct)1421 spec_access(
1422 	struct vnode *vp,
1423 	int mode,
1424 	int flags,
1425 	struct cred *cr,
1426 	caller_context_t *ct)
1427 {
1428 	struct vnode *realvp;
1429 	struct snode *sp = VTOS(vp);
1430 
1431 	/* fail with ENXIO if the device is fenced off */
1432 	if (S_ISFENCED(sp))
1433 		return (ENXIO);
1434 
1435 	if ((realvp = sp->s_realvp) != NULL)
1436 		return (VOP_ACCESS(realvp, mode, flags, cr, ct));
1437 	else
1438 		return (0);	/* Allow all access. */
1439 }
1440 
1441 /*
1442  * This can be called if creat or an open with O_CREAT is done on the root
1443  * of a lofs mount where the mounted entity is a special file.
1444  */
1445 /*ARGSUSED*/
1446 static int
spec_create(struct vnode * dvp,char * name,vattr_t * vap,enum vcexcl excl,int mode,struct vnode ** vpp,struct cred * cr,int flag,caller_context_t * ct,vsecattr_t * vsecp)1447 spec_create(
1448 	struct vnode *dvp,
1449 	char *name,
1450 	vattr_t *vap,
1451 	enum vcexcl excl,
1452 	int mode,
1453 	struct vnode **vpp,
1454 	struct cred *cr,
1455 	int flag,
1456 	caller_context_t *ct,
1457 	vsecattr_t *vsecp)
1458 {
1459 	int error;
1460 	struct snode *sp = VTOS(dvp);
1461 
1462 	/* fail with ENXIO if the device is fenced off */
1463 	if (S_ISFENCED(sp))
1464 		return (ENXIO);
1465 
1466 	ASSERT(dvp && (dvp->v_flag & VROOT) && *name == '\0');
1467 	if (excl == NONEXCL) {
1468 		if (mode && (error = spec_access(dvp, mode, 0, cr, ct)))
1469 			return (error);
1470 		VN_HOLD(dvp);
1471 		return (0);
1472 	}
1473 	return (EEXIST);
1474 }
1475 
1476 /*
1477  * In order to sync out the snode times without multi-client problems,
1478  * make sure the times written out are never earlier than the times
1479  * already set in the vnode.
1480  */
1481 static int
spec_fsync(struct vnode * vp,int syncflag,struct cred * cr,caller_context_t * ct)1482 spec_fsync(
1483 	struct vnode *vp,
1484 	int syncflag,
1485 	struct cred *cr,
1486 	caller_context_t *ct)
1487 {
1488 	struct snode *sp = VTOS(vp);
1489 	struct vnode *realvp;
1490 	struct vnode *cvp;
1491 	struct vattr va, vatmp;
1492 
1493 	/* allow syncing even if device is fenced off */
1494 
1495 	/* If times didn't change, don't flush anything. */
1496 	mutex_enter(&sp->s_lock);
1497 	if ((sp->s_flag & (SACC|SUPD|SCHG)) == 0 && vp->v_type != VBLK) {
1498 		mutex_exit(&sp->s_lock);
1499 		return (0);
1500 	}
1501 	sp->s_flag &= ~(SACC|SUPD|SCHG);
1502 	mutex_exit(&sp->s_lock);
1503 	cvp = sp->s_commonvp;
1504 	realvp = sp->s_realvp;
1505 
1506 	if (vp->v_type == VBLK && cvp != vp && vn_has_cached_data(cvp) &&
1507 	    (cvp->v_flag & VISSWAP) == 0)
1508 		(void) VOP_PUTPAGE(cvp, (offset_t)0, 0, 0, cr, ct);
1509 
1510 	/*
1511 	 * For devices that support it, force write cache to stable storage.
1512 	 * We don't need the lock to check s_flags since we can treat
1513 	 * SNOFLUSH as a hint.
1514 	 */
1515 	if ((vp->v_type == VBLK || vp->v_type == VCHR) &&
1516 	    !(sp->s_flag & SNOFLUSH)) {
1517 		int rval, rc;
1518 		struct dk_callback spec_callback;
1519 
1520 		spec_callback.dkc_flag = FLUSH_VOLATILE;
1521 		spec_callback.dkc_callback = NULL;
1522 
1523 		/* synchronous flush on volatile cache */
1524 		rc = cdev_ioctl(vp->v_rdev, DKIOCFLUSHWRITECACHE,
1525 		    (intptr_t)&spec_callback, FNATIVE|FKIOCTL, cr, &rval);
1526 
1527 		if (rc == ENOTSUP || rc == ENOTTY) {
1528 			mutex_enter(&sp->s_lock);
1529 			sp->s_flag |= SNOFLUSH;
1530 			mutex_exit(&sp->s_lock);
1531 		}
1532 	}
1533 
1534 	/*
1535 	 * If no real vnode to update, don't flush anything.
1536 	 */
1537 	if (realvp == NULL)
1538 		return (0);
1539 
1540 	vatmp.va_mask = AT_ATIME|AT_MTIME;
1541 	if (VOP_GETATTR(realvp, &vatmp, 0, cr, ct) == 0) {
1542 
1543 		mutex_enter(&sp->s_lock);
1544 		if (vatmp.va_atime.tv_sec > sp->s_atime)
1545 			va.va_atime = vatmp.va_atime;
1546 		else {
1547 			va.va_atime.tv_sec = sp->s_atime;
1548 			va.va_atime.tv_nsec = 0;
1549 		}
1550 		if (vatmp.va_mtime.tv_sec > sp->s_mtime)
1551 			va.va_mtime = vatmp.va_mtime;
1552 		else {
1553 			va.va_mtime.tv_sec = sp->s_mtime;
1554 			va.va_mtime.tv_nsec = 0;
1555 		}
1556 		mutex_exit(&sp->s_lock);
1557 
1558 		va.va_mask = AT_ATIME|AT_MTIME;
1559 		(void) VOP_SETATTR(realvp, &va, 0, cr, ct);
1560 	}
1561 	(void) VOP_FSYNC(realvp, syncflag, cr, ct);
1562 	return (0);
1563 }
1564 
1565 /*ARGSUSED*/
1566 static void
spec_inactive(struct vnode * vp,struct cred * cr,caller_context_t * ct)1567 spec_inactive(struct vnode *vp, struct cred *cr, caller_context_t *ct)
1568 {
1569 	struct snode *sp = VTOS(vp);
1570 	struct vnode *cvp;
1571 	struct vnode *rvp;
1572 
1573 	/*
1574 	 * If no one has reclaimed the vnode, remove from the
1575 	 * cache now.
1576 	 */
1577 	if (vp->v_count < 1) {
1578 		panic("spec_inactive: Bad v_count");
1579 		/*NOTREACHED*/
1580 	}
1581 	mutex_enter(&stable_lock);
1582 
1583 	mutex_enter(&vp->v_lock);
1584 	/*
1585 	 * Drop the temporary hold by vn_rele now
1586 	 */
1587 	if (--vp->v_count != 0) {
1588 		mutex_exit(&vp->v_lock);
1589 		mutex_exit(&stable_lock);
1590 		return;
1591 	}
1592 	mutex_exit(&vp->v_lock);
1593 
1594 	sdelete(sp);
1595 	mutex_exit(&stable_lock);
1596 
1597 	/* We are the sole owner of sp now */
1598 	cvp = sp->s_commonvp;
1599 	rvp = sp->s_realvp;
1600 
1601 	if (rvp) {
1602 		/*
1603 		 * If the snode times changed, then update the times
1604 		 * associated with the "realvp".
1605 		 */
1606 		if ((sp->s_flag & (SACC|SUPD|SCHG)) != 0) {
1607 
1608 			struct vattr va, vatmp;
1609 
1610 			mutex_enter(&sp->s_lock);
1611 			sp->s_flag &= ~(SACC|SUPD|SCHG);
1612 			mutex_exit(&sp->s_lock);
1613 			vatmp.va_mask = AT_ATIME|AT_MTIME;
1614 			/*
1615 			 * The user may not own the device, but we
1616 			 * want to update the attributes anyway.
1617 			 */
1618 			if (VOP_GETATTR(rvp, &vatmp, 0, kcred, ct) == 0) {
1619 				if (vatmp.va_atime.tv_sec > sp->s_atime)
1620 					va.va_atime = vatmp.va_atime;
1621 				else {
1622 					va.va_atime.tv_sec = sp->s_atime;
1623 					va.va_atime.tv_nsec = 0;
1624 				}
1625 				if (vatmp.va_mtime.tv_sec > sp->s_mtime)
1626 					va.va_mtime = vatmp.va_mtime;
1627 				else {
1628 					va.va_mtime.tv_sec = sp->s_mtime;
1629 					va.va_mtime.tv_nsec = 0;
1630 				}
1631 
1632 				va.va_mask = AT_ATIME|AT_MTIME;
1633 				(void) VOP_SETATTR(rvp, &va, 0, kcred, ct);
1634 			}
1635 		}
1636 	}
1637 	ASSERT(!vn_has_cached_data(vp));
1638 	vn_invalid(vp);
1639 
1640 	/* if we are sharing another file systems vfs, release it */
1641 	if (vp->v_vfsp && (vp->v_vfsp != &spec_vfs))
1642 		VFS_RELE(vp->v_vfsp);
1643 
1644 	/* if we have a realvp, release the realvp */
1645 	if (rvp)
1646 		VN_RELE(rvp);
1647 
1648 	/* if we have a common, release the common */
1649 	if (cvp && (cvp != vp)) {
1650 		VN_RELE(cvp);
1651 #ifdef DEBUG
1652 	} else if (cvp) {
1653 		/*
1654 		 * if this is the last reference to a common vnode, any
1655 		 * associated stream had better have been closed
1656 		 */
1657 		ASSERT(cvp == vp);
1658 		ASSERT(cvp->v_stream == NULL);
1659 #endif /* DEBUG */
1660 	}
1661 
1662 	/*
1663 	 * if we have a hold on a devinfo node (established by
1664 	 * spec_assoc_vp_with_devi), release the hold
1665 	 */
1666 	if (sp->s_dip)
1667 		ddi_release_devi(sp->s_dip);
1668 
1669 	/*
1670 	 * If we have an associated device policy, release it.
1671 	 */
1672 	if (sp->s_plcy != NULL)
1673 		dpfree(sp->s_plcy);
1674 
1675 	/*
1676 	 * If all holds on the devinfo node are through specfs/devfs
1677 	 * and we just destroyed the last specfs node associated with the
1678 	 * device, then the devinfo node reference count should now be
1679 	 * zero.  We can't check this because there may be other holds
1680 	 * on the node from non file system sources: ddi_hold_devi_by_instance
1681 	 * for example.
1682 	 */
1683 	kmem_cache_free(snode_cache, sp);
1684 }
1685 
1686 static int
spec_fid(struct vnode * vp,struct fid * fidp,caller_context_t * ct)1687 spec_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct)
1688 {
1689 	struct vnode *realvp;
1690 	struct snode *sp = VTOS(vp);
1691 
1692 	if ((realvp = sp->s_realvp) != NULL)
1693 		return (VOP_FID(realvp, fidp, ct));
1694 	else
1695 		return (EINVAL);
1696 }
1697 
1698 /*ARGSUSED1*/
1699 static int
spec_seek(struct vnode * vp,offset_t ooff,offset_t * noffp,caller_context_t * ct)1700 spec_seek(
1701 	struct vnode *vp,
1702 	offset_t ooff,
1703 	offset_t *noffp,
1704 	caller_context_t *ct)
1705 {
1706 	offset_t maxoff = spec_maxoffset(vp);
1707 
1708 	if (maxoff == -1 || *noffp <= maxoff)
1709 		return (0);
1710 	else
1711 		return (EINVAL);
1712 }
1713 
1714 static int
spec_frlock(struct vnode * vp,int cmd,struct flock64 * bfp,int flag,offset_t offset,struct flk_callback * flk_cbp,struct cred * cr,caller_context_t * ct)1715 spec_frlock(
1716 	struct vnode *vp,
1717 	int		cmd,
1718 	struct flock64	*bfp,
1719 	int		flag,
1720 	offset_t	offset,
1721 	struct flk_callback *flk_cbp,
1722 	struct cred	*cr,
1723 	caller_context_t *ct)
1724 {
1725 	struct snode *sp = VTOS(vp);
1726 	struct snode *csp;
1727 
1728 	csp = VTOS(sp->s_commonvp);
1729 	/*
1730 	 * If file is being mapped, disallow frlock.
1731 	 */
1732 	if (csp->s_mapcnt > 0)
1733 		return (EAGAIN);
1734 
1735 	return (fs_frlock(vp, cmd, bfp, flag, offset, flk_cbp, cr, ct));
1736 }
1737 
1738 static int
spec_realvp(struct vnode * vp,struct vnode ** vpp,caller_context_t * ct)1739 spec_realvp(struct vnode *vp, struct vnode **vpp, caller_context_t *ct)
1740 {
1741 	struct vnode *rvp;
1742 
1743 	if ((rvp = VTOS(vp)->s_realvp) != NULL) {
1744 		vp = rvp;
1745 		if (VOP_REALVP(vp, &rvp, ct) == 0)
1746 			vp = rvp;
1747 	}
1748 
1749 	*vpp = vp;
1750 	return (0);
1751 }
1752 
1753 /*
1754  * Return all the pages from [off..off + len] in block
1755  * or character device.
1756  */
1757 /*ARGSUSED*/
1758 static int
spec_getpage(struct vnode * vp,offset_t off,size_t len,uint_t * protp,page_t * pl[],size_t plsz,struct seg * seg,caddr_t addr,enum seg_rw rw,struct cred * cr,caller_context_t * ct)1759 spec_getpage(
1760 	struct vnode	*vp,
1761 	offset_t	off,
1762 	size_t		len,
1763 	uint_t		*protp,
1764 	page_t		*pl[],
1765 	size_t		plsz,
1766 	struct seg	*seg,
1767 	caddr_t		addr,
1768 	enum seg_rw	rw,
1769 	struct cred	*cr,
1770 	caller_context_t *ct)
1771 {
1772 	struct snode *sp = VTOS(vp);
1773 	int err;
1774 
1775 	ASSERT(sp->s_commonvp == vp);
1776 
1777 	/*
1778 	 * XXX	Given the above assertion, this might not do
1779 	 *	what is wanted here.
1780 	 */
1781 	if (vp->v_flag & VNOMAP)
1782 		return (ENOSYS);
1783 	TRACE_4(TR_FAC_SPECFS, TR_SPECFS_GETPAGE,
1784 	    "specfs getpage:vp %p off %llx len %ld snode %p",
1785 	    vp, off, len, sp);
1786 
1787 	switch (vp->v_type) {
1788 	case VBLK:
1789 		if (protp != NULL)
1790 			*protp = PROT_ALL;
1791 
1792 		if (((u_offset_t)off + len) > (SPEC_SIZE(sp) + PAGEOFFSET))
1793 			return (EFAULT);	/* beyond EOF */
1794 
1795 		err = pvn_getpages(spec_getapage, vp, (u_offset_t)off, len,
1796 		    protp, pl, plsz, seg, addr, rw, cr);
1797 		break;
1798 
1799 	case VCHR:
1800 		cmn_err(CE_NOTE, "spec_getpage called for character device. "
1801 		    "Check any non-ON consolidation drivers");
1802 		err = 0;
1803 		pl[0] = (page_t *)0;
1804 		break;
1805 
1806 	default:
1807 		panic("spec_getpage: bad v_type 0x%x", vp->v_type);
1808 		/*NOTREACHED*/
1809 	}
1810 
1811 	return (err);
1812 }
1813 
1814 extern int klustsize;	/* set in machdep.c */
1815 
1816 int spec_ra = 1;
1817 int spec_lostpage;	/* number of times we lost original page */
1818 
1819 /*ARGSUSED2*/
1820 static int
spec_getapage(struct vnode * vp,u_offset_t off,size_t len,uint_t * protp,page_t * pl[],size_t plsz,struct seg * seg,caddr_t addr,enum seg_rw rw,struct cred * cr)1821 spec_getapage(
1822 	struct vnode *vp,
1823 	u_offset_t	off,
1824 	size_t		len,
1825 	uint_t		*protp,
1826 	page_t		*pl[],
1827 	size_t		plsz,
1828 	struct seg	*seg,
1829 	caddr_t		addr,
1830 	enum seg_rw	rw,
1831 	struct cred	*cr)
1832 {
1833 	struct snode *sp;
1834 	struct buf *bp;
1835 	page_t *pp, *pp2;
1836 	u_offset_t io_off1, io_off2;
1837 	size_t io_len1;
1838 	size_t io_len2;
1839 	size_t blksz;
1840 	u_offset_t blkoff;
1841 	int dora, err;
1842 	page_t *pagefound;
1843 	uint_t xlen;
1844 	size_t adj_klustsize;
1845 	u_offset_t size;
1846 	u_offset_t tmpoff;
1847 
1848 	sp = VTOS(vp);
1849 	TRACE_3(TR_FAC_SPECFS, TR_SPECFS_GETAPAGE,
1850 	    "specfs getapage:vp %p off %llx snode %p", vp, off, sp);
1851 reread:
1852 
1853 	err = 0;
1854 	bp = NULL;
1855 	pp = NULL;
1856 	pp2 = NULL;
1857 
1858 	if (pl != NULL)
1859 		pl[0] = NULL;
1860 
1861 	size = SPEC_SIZE(VTOS(sp->s_commonvp));
1862 
1863 	if (spec_ra && sp->s_nextr == off)
1864 		dora = 1;
1865 	else
1866 		dora = 0;
1867 
1868 	if (size == UNKNOWN_SIZE) {
1869 		dora = 0;
1870 		adj_klustsize = PAGESIZE;
1871 	} else {
1872 		adj_klustsize = dora ? klustsize : PAGESIZE;
1873 	}
1874 
1875 again:
1876 	if ((pagefound = page_exists(vp, off)) == NULL) {
1877 		if (rw == S_CREATE) {
1878 			/*
1879 			 * We're allocating a swap slot and it's
1880 			 * associated page was not found, so allocate
1881 			 * and return it.
1882 			 */
1883 			if ((pp = page_create_va(vp, off,
1884 			    PAGESIZE, PG_WAIT, seg, addr)) == NULL) {
1885 				panic("spec_getapage: page_create");
1886 				/*NOTREACHED*/
1887 			}
1888 			io_len1 = PAGESIZE;
1889 			sp->s_nextr = off + PAGESIZE;
1890 		} else {
1891 			/*
1892 			 * Need to really do disk I/O to get the page(s).
1893 			 */
1894 			blkoff = (off / adj_klustsize) * adj_klustsize;
1895 			if (size == UNKNOWN_SIZE) {
1896 				blksz = PAGESIZE;
1897 			} else {
1898 				if (blkoff + adj_klustsize <= size)
1899 					blksz = adj_klustsize;
1900 				else
1901 					blksz =
1902 					    MIN(size - blkoff, adj_klustsize);
1903 			}
1904 
1905 			pp = pvn_read_kluster(vp, off, seg, addr, &tmpoff,
1906 			    &io_len1, blkoff, blksz, 0);
1907 			io_off1 = tmpoff;
1908 			/*
1909 			 * Make sure the page didn't sneek into the
1910 			 * cache while we blocked in pvn_read_kluster.
1911 			 */
1912 			if (pp == NULL)
1913 				goto again;
1914 
1915 			/*
1916 			 * Zero part of page which we are not
1917 			 * going to be reading from disk now.
1918 			 */
1919 			xlen = (uint_t)(io_len1 & PAGEOFFSET);
1920 			if (xlen != 0)
1921 				pagezero(pp->p_prev, xlen, PAGESIZE - xlen);
1922 
1923 			bp = spec_startio(vp, pp, io_off1, io_len1,
1924 			    pl == NULL ? (B_ASYNC | B_READ) : B_READ);
1925 			sp->s_nextr = io_off1 + io_len1;
1926 		}
1927 	}
1928 
1929 	if (dora && rw != S_CREATE) {
1930 		u_offset_t off2;
1931 		caddr_t addr2;
1932 
1933 		off2 = ((off / adj_klustsize) + 1) * adj_klustsize;
1934 		addr2 = addr + (off2 - off);
1935 
1936 		pp2 = NULL;
1937 		/*
1938 		 * If we are past EOF then don't bother trying
1939 		 * with read-ahead.
1940 		 */
1941 		if (off2 >= size)
1942 			pp2 = NULL;
1943 		else {
1944 			if (off2 + adj_klustsize <= size)
1945 				blksz = adj_klustsize;
1946 			else
1947 				blksz = MIN(size - off2, adj_klustsize);
1948 
1949 			pp2 = pvn_read_kluster(vp, off2, seg, addr2, &tmpoff,
1950 			    &io_len2, off2, blksz, 1);
1951 			io_off2 = tmpoff;
1952 		}
1953 
1954 		if (pp2 != NULL) {
1955 			/*
1956 			 * Zero part of page which we are not
1957 			 * going to be reading from disk now.
1958 			 */
1959 			xlen = (uint_t)(io_len2 & PAGEOFFSET);
1960 			if (xlen != 0)
1961 				pagezero(pp2->p_prev, xlen, PAGESIZE - xlen);
1962 
1963 			(void) spec_startio(vp, pp2, io_off2, io_len2,
1964 			    B_READ | B_ASYNC);
1965 		}
1966 	}
1967 
1968 	if (pl == NULL)
1969 		return (err);
1970 
1971 	if (bp != NULL) {
1972 		err = biowait(bp);
1973 		pageio_done(bp);
1974 
1975 		if (err) {
1976 			if (pp != NULL)
1977 				pvn_read_done(pp, B_ERROR);
1978 			return (err);
1979 		}
1980 	}
1981 
1982 	if (pagefound) {
1983 		se_t se = (rw == S_CREATE ? SE_EXCL : SE_SHARED);
1984 		/*
1985 		 * Page exists in the cache, acquire the appropriate
1986 		 * lock.  If this fails, start all over again.
1987 		 */
1988 
1989 		if ((pp = page_lookup(vp, off, se)) == NULL) {
1990 			spec_lostpage++;
1991 			goto reread;
1992 		}
1993 		pl[0] = pp;
1994 		pl[1] = NULL;
1995 
1996 		sp->s_nextr = off + PAGESIZE;
1997 		return (0);
1998 	}
1999 
2000 	if (pp != NULL)
2001 		pvn_plist_init(pp, pl, plsz, off, io_len1, rw);
2002 	return (0);
2003 }
2004 
2005 /*
2006  * Flags are composed of {B_INVAL, B_DIRTY B_FREE, B_DONTNEED, B_FORCE}.
2007  * If len == 0, do from off to EOF.
2008  *
2009  * The normal cases should be len == 0 & off == 0 (entire vp list),
2010  * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE
2011  * (from pageout).
2012  */
2013 /*ARGSUSED5*/
2014 int
spec_putpage(struct vnode * vp,offset_t off,size_t len,int flags,struct cred * cr,caller_context_t * ct)2015 spec_putpage(
2016 	struct vnode *vp,
2017 	offset_t	off,
2018 	size_t		len,
2019 	int		flags,
2020 	struct cred	*cr,
2021 	caller_context_t *ct)
2022 {
2023 	struct snode *sp = VTOS(vp);
2024 	struct vnode *cvp;
2025 	page_t *pp;
2026 	u_offset_t io_off;
2027 	size_t io_len = 0;	/* for lint */
2028 	int err = 0;
2029 	u_offset_t size;
2030 	u_offset_t tmpoff;
2031 
2032 	ASSERT(vp->v_count != 0);
2033 
2034 	if (vp->v_flag & VNOMAP)
2035 		return (ENOSYS);
2036 
2037 	cvp = sp->s_commonvp;
2038 	size = SPEC_SIZE(VTOS(cvp));
2039 
2040 	if (!vn_has_cached_data(vp) || off >= size)
2041 		return (0);
2042 
2043 	ASSERT(vp->v_type == VBLK && cvp == vp);
2044 	TRACE_4(TR_FAC_SPECFS, TR_SPECFS_PUTPAGE,
2045 	    "specfs putpage:vp %p off %llx len %ld snode %p",
2046 	    vp, off, len, sp);
2047 
2048 	if (len == 0) {
2049 		/*
2050 		 * Search the entire vp list for pages >= off.
2051 		 */
2052 		err = pvn_vplist_dirty(vp, off, spec_putapage,
2053 		    flags, cr);
2054 	} else {
2055 		u_offset_t eoff;
2056 
2057 		/*
2058 		 * Loop over all offsets in the range [off...off + len]
2059 		 * looking for pages to deal with.  We set limits so
2060 		 * that we kluster to klustsize boundaries.
2061 		 */
2062 		eoff = off + len;
2063 		for (io_off = off; io_off < eoff && io_off < size;
2064 		    io_off += io_len) {
2065 			/*
2066 			 * If we are not invalidating, synchronously
2067 			 * freeing or writing pages use the routine
2068 			 * page_lookup_nowait() to prevent reclaiming
2069 			 * them from the free list.
2070 			 */
2071 			if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
2072 				pp = page_lookup(vp, io_off,
2073 				    (flags & (B_INVAL | B_FREE)) ?
2074 				    SE_EXCL : SE_SHARED);
2075 			} else {
2076 				pp = page_lookup_nowait(vp, io_off,
2077 				    (flags & B_FREE) ? SE_EXCL : SE_SHARED);
2078 			}
2079 
2080 			if (pp == NULL || pvn_getdirty(pp, flags) == 0)
2081 				io_len = PAGESIZE;
2082 			else {
2083 				err = spec_putapage(vp, pp, &tmpoff, &io_len,
2084 				    flags, cr);
2085 				io_off = tmpoff;
2086 				if (err != 0)
2087 					break;
2088 				/*
2089 				 * "io_off" and "io_len" are returned as
2090 				 * the range of pages we actually wrote.
2091 				 * This allows us to skip ahead more quickly
2092 				 * since several pages may've been dealt
2093 				 * with by this iteration of the loop.
2094 				 */
2095 			}
2096 		}
2097 	}
2098 	return (err);
2099 }
2100 
2101 
2102 /*
2103  * Write out a single page, possibly klustering adjacent
2104  * dirty pages.
2105  */
2106 /*ARGSUSED5*/
2107 static int
spec_putapage(struct vnode * vp,page_t * pp,u_offset_t * offp,size_t * lenp,int flags,struct cred * cr)2108 spec_putapage(
2109 	struct vnode	*vp,
2110 	page_t		*pp,
2111 	u_offset_t	*offp,		/* return value */
2112 	size_t		*lenp,		/* return value */
2113 	int		flags,
2114 	struct cred	*cr)
2115 {
2116 	struct snode *sp = VTOS(vp);
2117 	u_offset_t io_off;
2118 	size_t io_len;
2119 	size_t blksz;
2120 	u_offset_t blkoff;
2121 	int err = 0;
2122 	struct buf *bp;
2123 	u_offset_t size;
2124 	size_t adj_klustsize;
2125 	u_offset_t tmpoff;
2126 
2127 	/*
2128 	 * Destroy read ahead value since we are really going to write.
2129 	 */
2130 	sp->s_nextr = 0;
2131 	size = SPEC_SIZE(VTOS(sp->s_commonvp));
2132 
2133 	adj_klustsize = klustsize;
2134 
2135 	blkoff = (pp->p_offset / adj_klustsize) * adj_klustsize;
2136 
2137 	if (blkoff + adj_klustsize <= size)
2138 		blksz = adj_klustsize;
2139 	else
2140 		blksz = size - blkoff;
2141 
2142 	/*
2143 	 * Find a kluster that fits in one contiguous chunk.
2144 	 */
2145 	pp = pvn_write_kluster(vp, pp, &tmpoff, &io_len, blkoff,
2146 	    blksz, flags);
2147 	io_off = tmpoff;
2148 
2149 	/*
2150 	 * Check for page length rounding problems
2151 	 * XXX - Is this necessary?
2152 	 */
2153 	if (io_off + io_len > size) {
2154 		ASSERT((io_off + io_len) - size < PAGESIZE);
2155 		io_len = size - io_off;
2156 	}
2157 
2158 	bp = spec_startio(vp, pp, io_off, io_len, B_WRITE | flags);
2159 
2160 	/*
2161 	 * Wait for i/o to complete if the request is not B_ASYNC.
2162 	 */
2163 	if ((flags & B_ASYNC) == 0) {
2164 		err = biowait(bp);
2165 		pageio_done(bp);
2166 		pvn_write_done(pp, ((err) ? B_ERROR : 0) | B_WRITE | flags);
2167 	}
2168 
2169 	if (offp)
2170 		*offp = io_off;
2171 	if (lenp)
2172 		*lenp = io_len;
2173 	TRACE_4(TR_FAC_SPECFS, TR_SPECFS_PUTAPAGE,
2174 	    "specfs putapage:vp %p offp %p snode %p err %d",
2175 	    vp, offp, sp, err);
2176 	return (err);
2177 }
2178 
2179 /*
2180  * Flags are composed of {B_ASYNC, B_INVAL, B_FREE, B_DONTNEED}
2181  */
2182 static struct buf *
spec_startio(struct vnode * vp,page_t * pp,u_offset_t io_off,size_t io_len,int flags)2183 spec_startio(
2184 	struct vnode *vp,
2185 	page_t		*pp,
2186 	u_offset_t	io_off,
2187 	size_t		io_len,
2188 	int		flags)
2189 {
2190 	struct buf *bp;
2191 
2192 	bp = pageio_setup(pp, io_len, vp, flags);
2193 
2194 	bp->b_edev = vp->v_rdev;
2195 	bp->b_dev = cmpdev(vp->v_rdev);
2196 	bp->b_blkno = btodt(io_off);
2197 	bp->b_un.b_addr = (caddr_t)0;
2198 
2199 	(void) bdev_strategy(bp);
2200 
2201 	if (flags & B_READ)
2202 		lwp_stat_update(LWP_STAT_INBLK, 1);
2203 	else
2204 		lwp_stat_update(LWP_STAT_OUBLK, 1);
2205 
2206 	return (bp);
2207 }
2208 
2209 static int
spec_poll(struct vnode * vp,short events,int anyyet,short * reventsp,struct pollhead ** phpp,caller_context_t * ct)2210 spec_poll(
2211 	struct vnode	*vp,
2212 	short		events,
2213 	int		anyyet,
2214 	short		*reventsp,
2215 	struct pollhead **phpp,
2216 	caller_context_t *ct)
2217 {
2218 	dev_t dev;
2219 	int error;
2220 
2221 	if (vp->v_type == VBLK)
2222 		error = fs_poll(vp, events, anyyet, reventsp, phpp, ct);
2223 	else {
2224 		ASSERT(vp->v_type == VCHR);
2225 		dev = vp->v_rdev;
2226 		if (vp->v_stream) {
2227 			ASSERT(vp->v_stream != NULL);
2228 			error = strpoll(vp->v_stream, events, anyyet,
2229 			    reventsp, phpp);
2230 		} else if (devopsp[getmajor(dev)]->devo_cb_ops->cb_chpoll) {
2231 			error = cdev_poll(dev, events, anyyet, reventsp, phpp);
2232 		} else {
2233 			error = fs_poll(vp, events, anyyet, reventsp, phpp, ct);
2234 		}
2235 	}
2236 	return (error);
2237 }
2238 
2239 /*
2240  * This routine is called through the cdevsw[] table to handle
2241  * traditional mmap'able devices that support a d_mmap function.
2242  */
2243 /*ARGSUSED8*/
2244 int
spec_segmap(dev_t dev,off_t off,struct as * as,caddr_t * addrp,off_t len,uint_t prot,uint_t maxprot,uint_t flags,struct cred * cred)2245 spec_segmap(
2246 	dev_t dev,
2247 	off_t off,
2248 	struct as *as,
2249 	caddr_t *addrp,
2250 	off_t len,
2251 	uint_t prot,
2252 	uint_t maxprot,
2253 	uint_t flags,
2254 	struct cred *cred)
2255 {
2256 	struct segdev_crargs dev_a;
2257 	int (*mapfunc)(dev_t dev, off_t off, int prot);
2258 	size_t i;
2259 	int	error;
2260 
2261 	if ((mapfunc = devopsp[getmajor(dev)]->devo_cb_ops->cb_mmap) == nodev)
2262 		return (ENODEV);
2263 	TRACE_4(TR_FAC_SPECFS, TR_SPECFS_SEGMAP,
2264 	    "specfs segmap:dev %x as %p len %lx prot %x",
2265 	    dev, as, len, prot);
2266 
2267 	/*
2268 	 * Character devices that support the d_mmap
2269 	 * interface can only be mmap'ed shared.
2270 	 */
2271 	if ((flags & MAP_TYPE) != MAP_SHARED)
2272 		return (EINVAL);
2273 
2274 	/*
2275 	 * Check to ensure that the entire range is
2276 	 * legal and we are not trying to map in
2277 	 * more than the device will let us.
2278 	 */
2279 	for (i = 0; i < len; i += PAGESIZE) {
2280 		if (cdev_mmap(mapfunc, dev, off + i, maxprot) == -1)
2281 			return (ENXIO);
2282 	}
2283 
2284 	as_rangelock(as);
2285 	/* Pick an address w/o worrying about any vac alignment constraints. */
2286 	error = choose_addr(as, addrp, len, off, ADDR_NOVACALIGN, flags);
2287 	if (error != 0) {
2288 		as_rangeunlock(as);
2289 		return (error);
2290 	}
2291 
2292 	dev_a.mapfunc = mapfunc;
2293 	dev_a.dev = dev;
2294 	dev_a.offset = off;
2295 	dev_a.prot = (uchar_t)prot;
2296 	dev_a.maxprot = (uchar_t)maxprot;
2297 	dev_a.hat_flags = 0;
2298 	dev_a.hat_attr = 0;
2299 	dev_a.devmap_data = NULL;
2300 
2301 	error = as_map(as, *addrp, len, segdev_create, &dev_a);
2302 	as_rangeunlock(as);
2303 	return (error);
2304 }
2305 
2306 int
spec_char_map(dev_t dev,offset_t off,struct as * as,caddr_t * addrp,size_t len,uchar_t prot,uchar_t maxprot,uint_t flags,struct cred * cred)2307 spec_char_map(
2308 	dev_t dev,
2309 	offset_t off,
2310 	struct as *as,
2311 	caddr_t *addrp,
2312 	size_t len,
2313 	uchar_t prot,
2314 	uchar_t maxprot,
2315 	uint_t flags,
2316 	struct cred *cred)
2317 {
2318 	int error = 0;
2319 	major_t maj = getmajor(dev);
2320 	int map_flag;
2321 	int (*segmap)(dev_t, off_t, struct as *,
2322 	    caddr_t *, off_t, uint_t, uint_t, uint_t, cred_t *);
2323 	int (*devmap)(dev_t, devmap_cookie_t, offset_t,
2324 	    size_t, size_t *, uint_t);
2325 	int (*mmap)(dev_t dev, off_t off, int prot);
2326 
2327 	/*
2328 	 * Character device: let the device driver
2329 	 * pick the appropriate segment driver.
2330 	 *
2331 	 * 4.x compat.: allow 'NULL' cb_segmap => spec_segmap
2332 	 * Kindness: allow 'nulldev' cb_segmap => spec_segmap
2333 	 */
2334 	segmap = devopsp[maj]->devo_cb_ops->cb_segmap;
2335 	if (segmap == NULL || segmap == nulldev || segmap == nodev) {
2336 		mmap = devopsp[maj]->devo_cb_ops->cb_mmap;
2337 		map_flag = devopsp[maj]->devo_cb_ops->cb_flag;
2338 
2339 		/*
2340 		 * Use old mmap framework if the driver has both mmap
2341 		 * and devmap entry points.  This is to prevent the
2342 		 * system from calling invalid devmap entry point
2343 		 * for some drivers that might have put garbage in the
2344 		 * devmap entry point.
2345 		 */
2346 		if ((map_flag & D_DEVMAP) || mmap == NULL ||
2347 		    mmap == nulldev || mmap == nodev) {
2348 			devmap = devopsp[maj]->devo_cb_ops->cb_devmap;
2349 
2350 			/*
2351 			 * If driver provides devmap entry point in
2352 			 * cb_ops but not xx_segmap(9E), call
2353 			 * devmap_setup with default settings
2354 			 * (NULL) for callback_ops and driver
2355 			 * callback private data
2356 			 */
2357 			if (devmap == nodev || devmap == NULL ||
2358 			    devmap == nulldev)
2359 				return (ENODEV);
2360 
2361 			error = devmap_setup(dev, off, as, addrp,
2362 			    len, prot, maxprot, flags, cred);
2363 
2364 			return (error);
2365 		} else
2366 			segmap = spec_segmap;
2367 	} else
2368 		segmap = cdev_segmap;
2369 
2370 	return ((*segmap)(dev, (off_t)off, as, addrp, len, prot,
2371 	    maxprot, flags, cred));
2372 }
2373 
2374 /*ARGSUSED9*/
2375 static int
spec_map(struct vnode * vp,offset_t off,struct as * as,caddr_t * addrp,size_t len,uchar_t prot,uchar_t maxprot,uint_t flags,struct cred * cred,caller_context_t * ct)2376 spec_map(
2377 	struct vnode *vp,
2378 	offset_t off,
2379 	struct as *as,
2380 	caddr_t *addrp,
2381 	size_t len,
2382 	uchar_t prot,
2383 	uchar_t maxprot,
2384 	uint_t flags,
2385 	struct cred *cred,
2386 	caller_context_t *ct)
2387 {
2388 	int error = 0;
2389 	struct snode *sp = VTOS(vp);
2390 
2391 	if (vp->v_flag & VNOMAP)
2392 		return (ENOSYS);
2393 
2394 	/* fail map with ENXIO if the device is fenced off */
2395 	if (S_ISFENCED(sp))
2396 		return (ENXIO);
2397 
2398 	/*
2399 	 * If file is locked, fail mapping attempt.
2400 	 */
2401 	if (vn_has_flocks(vp))
2402 		return (EAGAIN);
2403 
2404 	if (vp->v_type == VCHR) {
2405 		return (spec_char_map(vp->v_rdev, off, as, addrp, len, prot,
2406 		    maxprot, flags, cred));
2407 	} else if (vp->v_type == VBLK) {
2408 		struct segvn_crargs vn_a;
2409 		struct vnode *cvp;
2410 		struct snode *sp;
2411 
2412 		/*
2413 		 * Block device, use segvn mapping to the underlying commonvp
2414 		 * for pages.
2415 		 */
2416 		if (off > spec_maxoffset(vp))
2417 			return (ENXIO);
2418 
2419 		sp = VTOS(vp);
2420 		cvp = sp->s_commonvp;
2421 		ASSERT(cvp != NULL);
2422 
2423 		if (off < 0 || ((offset_t)(off + len) < 0))
2424 			return (ENXIO);
2425 
2426 		as_rangelock(as);
2427 		error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags);
2428 		if (error != 0) {
2429 			as_rangeunlock(as);
2430 			return (error);
2431 		}
2432 
2433 		vn_a.vp = cvp;
2434 		vn_a.offset = off;
2435 		vn_a.type = flags & MAP_TYPE;
2436 		vn_a.prot = (uchar_t)prot;
2437 		vn_a.maxprot = (uchar_t)maxprot;
2438 		vn_a.flags = flags & ~MAP_TYPE;
2439 		vn_a.cred = cred;
2440 		vn_a.amp = NULL;
2441 		vn_a.szc = 0;
2442 		vn_a.lgrp_mem_policy_flags = 0;
2443 
2444 		error = as_map(as, *addrp, len, segvn_create, &vn_a);
2445 		as_rangeunlock(as);
2446 	} else
2447 		return (ENODEV);
2448 
2449 	return (error);
2450 }
2451 
2452 /*ARGSUSED1*/
2453 static int
spec_addmap(struct vnode * vp,offset_t off,struct as * as,caddr_t addr,size_t len,uchar_t prot,uchar_t maxprot,uint_t flags,struct cred * cred,caller_context_t * ct)2454 spec_addmap(
2455 	struct vnode *vp,	/* the common vnode */
2456 	offset_t off,
2457 	struct as *as,
2458 	caddr_t addr,
2459 	size_t len,		/* how many bytes to add */
2460 	uchar_t prot,
2461 	uchar_t maxprot,
2462 	uint_t flags,
2463 	struct cred *cred,
2464 	caller_context_t *ct)
2465 {
2466 	int error = 0;
2467 	struct snode *csp = VTOS(vp);
2468 	ulong_t npages;
2469 
2470 	ASSERT(vp != NULL && VTOS(vp)->s_commonvp == vp);
2471 
2472 	/*
2473 	 * XXX	Given the above assertion, this might not
2474 	 *	be a particularly sensible thing to test.
2475 	 */
2476 	if (vp->v_flag & VNOMAP)
2477 		return (ENOSYS);
2478 
2479 	/* fail with EIO if the device is fenced off */
2480 	if (S_ISFENCED(csp))
2481 		return (EIO);
2482 
2483 	npages = btopr(len);
2484 	LOCK_CSP(csp);
2485 	csp->s_mapcnt += npages;
2486 
2487 	UNLOCK_CSP(csp);
2488 	return (error);
2489 }
2490 
2491 /*ARGSUSED1*/
2492 static int
spec_delmap(struct vnode * vp,offset_t off,struct as * as,caddr_t addr,size_t len,uint_t prot,uint_t maxprot,uint_t flags,struct cred * cred,caller_context_t * ct)2493 spec_delmap(
2494 	struct vnode *vp,	/* the common vnode */
2495 	offset_t off,
2496 	struct as *as,
2497 	caddr_t addr,
2498 	size_t len,		/* how many bytes to take away */
2499 	uint_t prot,
2500 	uint_t maxprot,
2501 	uint_t flags,
2502 	struct cred *cred,
2503 	caller_context_t *ct)
2504 {
2505 	struct snode *csp = VTOS(vp);
2506 	ulong_t npages;
2507 	long mcnt;
2508 
2509 	/* segdev passes us the common vp */
2510 
2511 	ASSERT(vp != NULL && VTOS(vp)->s_commonvp == vp);
2512 
2513 	/* allow delmap to succeed even if device fenced off */
2514 
2515 	/*
2516 	 * XXX	Given the above assertion, this might not
2517 	 *	be a particularly sensible thing to test..
2518 	 */
2519 	if (vp->v_flag & VNOMAP)
2520 		return (ENOSYS);
2521 
2522 	npages = btopr(len);
2523 
2524 	LOCK_CSP(csp);
2525 	mutex_enter(&csp->s_lock);
2526 	mcnt = (csp->s_mapcnt -= npages);
2527 
2528 	if (mcnt == 0) {
2529 		/*
2530 		 * Call the close routine when the last reference of any
2531 		 * kind through any [s, v]node goes away.  The s_dip hold
2532 		 * on the devinfo node is released when the vnode is
2533 		 * destroyed.
2534 		 */
2535 		if (csp->s_count == 0) {
2536 			csp->s_flag &= ~(SNEEDCLOSE | SSIZEVALID);
2537 
2538 			/* See comment in spec_close() */
2539 			if (csp->s_flag & (SCLONE | SSELFCLONE))
2540 				csp->s_flag &= ~SDIPSET;
2541 
2542 			mutex_exit(&csp->s_lock);
2543 
2544 			(void) device_close(vp, 0, cred);
2545 		} else
2546 			mutex_exit(&csp->s_lock);
2547 
2548 		mutex_enter(&csp->s_lock);
2549 	}
2550 	ASSERT(mcnt >= 0);
2551 
2552 	UNLOCK_CSP_LOCK_HELD(csp);
2553 	mutex_exit(&csp->s_lock);
2554 
2555 	return (0);
2556 }
2557 
2558 /*ARGSUSED4*/
2559 static int
spec_dump(struct vnode * vp,caddr_t addr,offset_t bn,offset_t count,caller_context_t * ct)2560 spec_dump(
2561 	struct vnode *vp,
2562 	caddr_t addr,
2563 	offset_t bn,
2564 	offset_t count,
2565 	caller_context_t *ct)
2566 {
2567 	/* allow dump to succeed even if device fenced off */
2568 
2569 	ASSERT(vp->v_type == VBLK);
2570 	return (bdev_dump(vp->v_rdev, addr, (daddr_t)bn, (int)count));
2571 }
2572 
2573 
2574 /*
2575  * Do i/o on the given page list from/to vp, io_off for io_len.
2576  * Flags are composed of:
2577  * 	{B_ASYNC, B_INVAL, B_FREE, B_DONTNEED, B_READ, B_WRITE}
2578  * If B_ASYNC is not set i/o is waited for.
2579  */
2580 /*ARGSUSED5*/
2581 static int
spec_pageio(struct vnode * vp,page_t * pp,u_offset_t io_off,size_t io_len,int flags,cred_t * cr,caller_context_t * ct)2582 spec_pageio(
2583 	struct vnode *vp,
2584 	page_t	*pp,
2585 	u_offset_t io_off,
2586 	size_t	io_len,
2587 	int	flags,
2588 	cred_t	*cr,
2589 	caller_context_t *ct)
2590 {
2591 	struct buf *bp = NULL;
2592 	int err = 0;
2593 
2594 	if (pp == NULL)
2595 		return (EINVAL);
2596 
2597 	bp = spec_startio(vp, pp, io_off, io_len, flags);
2598 
2599 	/*
2600 	 * Wait for i/o to complete if the request is not B_ASYNC.
2601 	 */
2602 	if ((flags & B_ASYNC) == 0) {
2603 		err = biowait(bp);
2604 		pageio_done(bp);
2605 	}
2606 	return (err);
2607 }
2608 
2609 /*
2610  * Set ACL on underlying vnode if one exists, or return ENOSYS otherwise.
2611  */
2612 int
spec_setsecattr(struct vnode * vp,vsecattr_t * vsap,int flag,struct cred * cr,caller_context_t * ct)2613 spec_setsecattr(
2614 	struct vnode *vp,
2615 	vsecattr_t *vsap,
2616 	int flag,
2617 	struct cred *cr,
2618 	caller_context_t *ct)
2619 {
2620 	struct vnode *realvp;
2621 	struct snode *sp = VTOS(vp);
2622 	int error;
2623 
2624 	/* fail with ENXIO if the device is fenced off */
2625 	if (S_ISFENCED(sp))
2626 		return (ENXIO);
2627 
2628 	/*
2629 	 * The acl(2) system calls VOP_RWLOCK on the file before setting an
2630 	 * ACL, but since specfs does not serialize reads and writes, this
2631 	 * VOP does not do anything.  However, some backing file systems may
2632 	 * expect the lock to be held before setting an ACL, so it is taken
2633 	 * here privately to avoid serializing specfs reads and writes.
2634 	 */
2635 	if ((realvp = sp->s_realvp) != NULL) {
2636 		(void) VOP_RWLOCK(realvp, V_WRITELOCK_TRUE, ct);
2637 		error = VOP_SETSECATTR(realvp, vsap, flag, cr, ct);
2638 		(void) VOP_RWUNLOCK(realvp, V_WRITELOCK_TRUE, ct);
2639 		return (error);
2640 	} else
2641 		return (fs_nosys());
2642 }
2643 
2644 /*
2645  * Get ACL from underlying vnode if one exists, or fabricate it from
2646  * the permissions returned by spec_getattr() otherwise.
2647  */
2648 int
spec_getsecattr(struct vnode * vp,vsecattr_t * vsap,int flag,struct cred * cr,caller_context_t * ct)2649 spec_getsecattr(
2650 	struct vnode *vp,
2651 	vsecattr_t *vsap,
2652 	int flag,
2653 	struct cred *cr,
2654 	caller_context_t *ct)
2655 {
2656 	struct vnode *realvp;
2657 	struct snode *sp = VTOS(vp);
2658 
2659 	/* fail with ENXIO if the device is fenced off */
2660 	if (S_ISFENCED(sp))
2661 		return (ENXIO);
2662 
2663 	if ((realvp = sp->s_realvp) != NULL)
2664 		return (VOP_GETSECATTR(realvp, vsap, flag, cr, ct));
2665 	else
2666 		return (fs_fab_acl(vp, vsap, flag, cr, ct));
2667 }
2668 
2669 int
spec_pathconf(vnode_t * vp,int cmd,ulong_t * valp,cred_t * cr,caller_context_t * ct)2670 spec_pathconf(
2671 	vnode_t *vp,
2672 	int cmd,
2673 	ulong_t *valp,
2674 	cred_t *cr,
2675 	caller_context_t *ct)
2676 {
2677 	vnode_t *realvp;
2678 	struct snode *sp = VTOS(vp);
2679 
2680 	/* fail with ENXIO if the device is fenced off */
2681 	if (S_ISFENCED(sp))
2682 		return (ENXIO);
2683 
2684 	if ((realvp = sp->s_realvp) != NULL)
2685 		return (VOP_PATHCONF(realvp, cmd, valp, cr, ct));
2686 	else
2687 		return (fs_pathconf(vp, cmd, valp, cr, ct));
2688 }
2689