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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
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
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
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
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
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
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
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
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
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
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
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
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 }