xref: /titanic_52/usr/src/uts/common/fs/dev/sdev_vtops.c (revision b0f673c4626e4cb1db7785287eaeed2731dfefe8)
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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*
26  * vnode ops for the /dev/vt directory
27  */
28 
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/sysmacros.h>
32 #include <sys/sunndi.h>
33 #include <fs/fs_subr.h>
34 #include <sys/fs/dv_node.h>
35 #include <sys/fs/sdev_impl.h>
36 #include <sys/policy.h>
37 #include <sys/stat.h>
38 #include <sys/vfs_opreg.h>
39 #include <sys/tty.h>
40 #include <sys/vt_impl.h>
41 #include <sys/note.h>
42 
43 /* warlock in this file only cares about variables shared by vt and devfs */
44 _NOTE(SCHEME_PROTECTS_DATA("Do not care", sdev_node vattr vnode))
45 
46 #define	DEVVT_UID_DEFAULT	SDEV_UID_DEFAULT
47 #define	DEVVT_GID_DEFAULT	(0)
48 #define	DEVVT_DEVMODE_DEFAULT	(0600)
49 #define	DEVVT_ACTIVE_NAME	"active"
50 #define	DEVVT_CONSUSER_NAME	"console_user"
51 
52 #define	isdigit(ch)	((ch) >= '0' && (ch) <= '9')
53 
54 /* attributes for VT nodes */
55 static vattr_t devvt_vattr = {
56 	AT_TYPE|AT_MODE|AT_UID|AT_GID,		/* va_mask */
57 	VCHR,					/* va_type */
58 	S_IFCHR | DEVVT_DEVMODE_DEFAULT,	/* va_mode */
59 	DEVVT_UID_DEFAULT,			/* va_uid */
60 	DEVVT_GID_DEFAULT,			/* va_gid */
61 	0					/* 0 hereafter */
62 };
63 
64 struct vnodeops		*devvt_vnodeops;
65 
66 struct vnodeops *
67 devvt_getvnodeops(void)
68 {
69 	return (devvt_vnodeops);
70 }
71 
72 static int
73 devvt_str2minor(const char *nm, minor_t *mp)
74 {
75 	long uminor = 0;
76 	char *endptr = NULL;
77 
78 	if (nm == NULL || !isdigit(*nm))
79 		return (EINVAL);
80 
81 	*mp = 0;
82 	if (ddi_strtol(nm, &endptr, 10, &uminor) != 0 ||
83 	    *endptr != '\0' || uminor < 0) {
84 		return (EINVAL);
85 	}
86 
87 	*mp = (minor_t)uminor;
88 	return (0);
89 }
90 
91 /*
92  * Validate that a node is up-to-date and correct.
93  * A validator may not update the node state or
94  * contents as a read lock permits entry by
95  * multiple threads.
96  */
97 int
98 devvt_validate(struct sdev_node *dv)
99 {
100 	minor_t min;
101 	char *nm = dv->sdev_name;
102 	int rval;
103 
104 	ASSERT(dv->sdev_state == SDEV_READY);
105 	ASSERT(RW_LOCK_HELD(&(dv->sdev_dotdot)->sdev_contents));
106 
107 	/* validate only READY nodes */
108 	if (dv->sdev_state != SDEV_READY) {
109 		sdcmn_err(("dev fs: skipping: node not ready %s(%p)",
110 		    nm, (void *)dv));
111 		return (SDEV_VTOR_SKIP);
112 	}
113 
114 	if (vt_wc_attached() == (major_t)-1)
115 		return (SDEV_VTOR_INVALID);
116 
117 	if (strcmp(nm, DEVVT_ACTIVE_NAME) == 0) {
118 		char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
119 		(void) vt_getactive(link, MAXPATHLEN);
120 		rval = (strcmp(link, dv->sdev_symlink) == 0) ?
121 		    SDEV_VTOR_VALID : SDEV_VTOR_STALE;
122 		kmem_free(link, MAXPATHLEN);
123 		return (rval);
124 	}
125 
126 	if (strcmp(nm, DEVVT_CONSUSER_NAME) == 0) {
127 		char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
128 		(void) vt_getconsuser(link, MAXPATHLEN);
129 		rval = (strcmp(link, dv->sdev_symlink) == 0) ?
130 		    SDEV_VTOR_VALID : SDEV_VTOR_STALE;
131 		kmem_free(link, MAXPATHLEN);
132 		return (rval);
133 	}
134 
135 	if (devvt_str2minor(nm, &min) != 0) {
136 		return (SDEV_VTOR_INVALID);
137 	}
138 
139 	if (vt_minor_valid(min) == B_FALSE)
140 		return (SDEV_VTOR_INVALID);
141 
142 	return (SDEV_VTOR_VALID);
143 }
144 
145 /*
146  * This callback is invoked from devname_lookup_func() to create
147  * a entry when the node is not found in the cache.
148  */
149 /*ARGSUSED*/
150 static int
151 devvt_create_rvp(struct sdev_node *ddv, char *nm,
152     void **arg, cred_t *cred, void *whatever, char *whichever)
153 {
154 	minor_t min;
155 	major_t maj;
156 	struct vattr *vap = (struct vattr *)arg;
157 
158 	if ((maj = vt_wc_attached()) == (major_t)-1)
159 		return (SDEV_VTOR_INVALID);
160 
161 	if (strcmp(nm, DEVVT_ACTIVE_NAME) == 0) {
162 		(void) vt_getactive((char *)*arg, MAXPATHLEN);
163 		return (0);
164 	}
165 
166 	if (strcmp(nm, DEVVT_CONSUSER_NAME) == 0) {
167 		(void) vt_getconsuser((char *)*arg, MAXPATHLEN);
168 		return (0);
169 	}
170 	if (devvt_str2minor(nm, &min) != 0)
171 		return (-1);
172 
173 	if (vt_minor_valid(min) == B_FALSE)
174 		return (-1);
175 
176 	*vap = devvt_vattr;
177 	vap->va_rdev = makedevice(maj, min);
178 
179 	return (0);
180 }
181 
182 /*ARGSUSED3*/
183 static int
184 devvt_lookup(struct vnode *dvp, char *nm, struct vnode **vpp,
185     struct pathname *pnp, int flags, struct vnode *rdir, struct cred *cred,
186     caller_context_t *ct, int *direntflags, pathname_t *realpnp)
187 {
188 	struct sdev_node *sdvp = VTOSDEV(dvp);
189 	struct sdev_node *dv;
190 	struct vnode *rvp = NULL;
191 	int type, error;
192 
193 	if ((strcmp(nm, DEVVT_ACTIVE_NAME) == 0) ||
194 	    (strcmp(nm, DEVVT_CONSUSER_NAME) == 0)) {
195 		type = SDEV_VLINK;
196 	} else {
197 		type = SDEV_VATTR;
198 	}
199 
200 /* Give warlock a more clear call graph */
201 #ifndef __lock_lint
202 	error = devname_lookup_func(sdvp, nm, vpp, cred,
203 	    devvt_create_rvp, type);
204 #else
205 	devvt_create_rvp(0, 0, 0, 0, 0, 0);
206 #endif
207 
208 	if (error == 0) {
209 		switch ((*vpp)->v_type) {
210 		case VCHR:
211 			dv = VTOSDEV(VTOS(*vpp)->s_realvp);
212 			ASSERT(VOP_REALVP(SDEVTOV(dv), &rvp, NULL) == ENOSYS);
213 			break;
214 		case VDIR:
215 		case VLNK:
216 			dv = VTOSDEV(*vpp);
217 			break;
218 		default:
219 			cmn_err(CE_PANIC, "devvt_lookup: Unsupported node "
220 			    "type: %p: %d", (void *)(*vpp), (*vpp)->v_type);
221 			break;
222 		}
223 		ASSERT(SDEV_HELD(dv));
224 	}
225 
226 	return (error);
227 }
228 
229 static void
230 devvt_create_snode(struct sdev_node *ddv, char *nm, struct cred *cred, int type)
231 {
232 	int error;
233 	struct sdev_node *sdv = NULL;
234 	struct vattr vattr;
235 	struct vattr *vap = &vattr;
236 	major_t maj;
237 	minor_t min;
238 
239 	ASSERT(RW_WRITE_HELD(&ddv->sdev_contents));
240 
241 	if ((maj = vt_wc_attached()) == (major_t)-1)
242 		return;
243 
244 	if (strcmp(nm, DEVVT_ACTIVE_NAME) != 0 &&
245 	    strcmp(nm, DEVVT_CONSUSER_NAME) != 0 &&
246 	    devvt_str2minor(nm, &min) != 0)
247 		return;
248 
249 	error = sdev_mknode(ddv, nm, &sdv, NULL, NULL, NULL, cred, SDEV_INIT);
250 	if (error || !sdv) {
251 		return;
252 	}
253 
254 	mutex_enter(&sdv->sdev_lookup_lock);
255 	SDEV_BLOCK_OTHERS(sdv, SDEV_LOOKUP);
256 	mutex_exit(&sdv->sdev_lookup_lock);
257 
258 	if (type & SDEV_VATTR) {
259 		*vap = devvt_vattr;
260 		vap->va_rdev = makedevice(maj, min);
261 		error = sdev_mknode(ddv, nm, &sdv, vap, NULL,
262 		    NULL, cred, SDEV_READY);
263 	} else if (type & SDEV_VLINK) {
264 		char *link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
265 
266 		(void) vt_getactive(link, MAXPATHLEN);
267 		*vap = sdev_vattr_lnk;
268 		vap->va_size = strlen(link);
269 		error = sdev_mknode(ddv, nm, &sdv, vap, NULL,
270 		    (void *)link, cred, SDEV_READY);
271 
272 		kmem_free(link, MAXPATHLEN);
273 	}
274 
275 	if (error != 0) {
276 		SDEV_RELE(sdv);
277 		return;
278 	}
279 
280 	mutex_enter(&sdv->sdev_lookup_lock);
281 	SDEV_UNBLOCK_OTHERS(sdv, SDEV_LOOKUP);
282 	mutex_exit(&sdv->sdev_lookup_lock);
283 
284 }
285 
286 static void
287 devvt_rebuild_stale_link(struct sdev_node *ddv, struct sdev_node *dv)
288 {
289 	char *link;
290 
291 	ASSERT(RW_WRITE_HELD(&ddv->sdev_contents));
292 
293 	ASSERT((strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == 0) ||
294 	    (strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == 0));
295 
296 	link = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
297 	if (strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == 0) {
298 		(void) vt_getactive(link, MAXPATHLEN);
299 	} else if (strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == 0) {
300 		(void) vt_getconsuser(link, MAXPATHLEN);
301 	}
302 
303 	if (strcmp(link, dv->sdev_symlink) != 0) {
304 		strfree(dv->sdev_symlink);
305 		dv->sdev_symlink = strdup(link);
306 		dv->sdev_attr->va_size = strlen(link);
307 	}
308 	kmem_free(link, MAXPATHLEN);
309 }
310 
311 /*
312  * First step in refreshing directory contents.
313  * Remove each invalid entry and rebuild the link
314  * reference for each stale entry.
315  */
316 static void
317 devvt_prunedir(struct sdev_node *ddv)
318 {
319 	struct vnode *vp;
320 	struct sdev_node *dv, *next = NULL;
321 	int (*vtor)(struct sdev_node *) = NULL;
322 
323 	ASSERT(ddv->sdev_flags & SDEV_VTOR);
324 
325 	vtor = (int (*)(struct sdev_node *))sdev_get_vtor(ddv);
326 	ASSERT(vtor);
327 
328 	for (dv = SDEV_FIRST_ENTRY(ddv); dv; dv = next) {
329 		next = SDEV_NEXT_ENTRY(ddv, dv);
330 
331 		switch (vtor(dv)) {
332 		case SDEV_VTOR_VALID:
333 			break;
334 		case SDEV_VTOR_SKIP:
335 			break;
336 		case SDEV_VTOR_INVALID:
337 			vp = SDEVTOV(dv);
338 			if (vp->v_count != 0)
339 				break;
340 			/* remove the cached node */
341 			SDEV_HOLD(dv);
342 			(void) sdev_cache_update(ddv, &dv,
343 			    dv->sdev_name, SDEV_CACHE_DELETE);
344 			SDEV_RELE(dv);
345 			break;
346 		case SDEV_VTOR_STALE:
347 			devvt_rebuild_stale_link(ddv, dv);
348 			break;
349 		}
350 	}
351 }
352 
353 static void
354 devvt_cleandir(struct vnode *dvp, struct cred *cred)
355 {
356 	struct sdev_node *sdvp = VTOSDEV(dvp);
357 	struct sdev_node *dv, *next = NULL;
358 	int min, cnt;
359 	char found = 0;
360 
361 	mutex_enter(&vc_lock);
362 	cnt = VC_INSTANCES_COUNT;
363 	mutex_exit(&vc_lock);
364 
365 /* We have to fool warlock this way, otherwise it will complain */
366 #ifndef	__lock_lint
367 	if (rw_tryupgrade(&sdvp->sdev_contents) == NULL) {
368 		rw_exit(&sdvp->sdev_contents);
369 		rw_enter(&sdvp->sdev_contents, RW_WRITER);
370 	}
371 #else
372 	rw_enter(&sdvp->sdev_contents, RW_WRITER);
373 #endif
374 
375 	/* 1.  prune invalid nodes and rebuild stale symlinks */
376 	devvt_prunedir(sdvp);
377 
378 	/* 2. create missing nodes */
379 	for (min = 0; min < cnt; min++) {
380 		char nm[16];
381 
382 		if (vt_minor_valid(min) == B_FALSE)
383 			continue;
384 
385 		(void) snprintf(nm, sizeof (nm), "%d", min);
386 		found = 0;
387 		for (dv = SDEV_FIRST_ENTRY(sdvp); dv; dv = next) {
388 			next = SDEV_NEXT_ENTRY(sdvp, dv);
389 
390 			/* validate only ready nodes */
391 			if (dv->sdev_state != SDEV_READY)
392 				continue;
393 			if (strcmp(nm, dv->sdev_name) == 0) {
394 				found = 1;
395 				break;
396 			}
397 		}
398 		if (!found) {
399 			devvt_create_snode(sdvp, nm, cred, SDEV_VATTR);
400 		}
401 	}
402 
403 	/* 3. create active link node and console user link node */
404 	found = 0;
405 	for (dv = SDEV_FIRST_ENTRY(sdvp); dv; dv = next) {
406 		next = SDEV_NEXT_ENTRY(sdvp, dv);
407 
408 		/* validate only ready nodes */
409 		if (dv->sdev_state != SDEV_READY)
410 			continue;
411 		if ((strcmp(dv->sdev_name, DEVVT_ACTIVE_NAME) == NULL))
412 			found |= 0x01;
413 		if ((strcmp(dv->sdev_name, DEVVT_CONSUSER_NAME) == NULL))
414 			found |= 0x02;
415 
416 		if ((found & 0x01) && (found & 0x02))
417 			break;
418 	}
419 	if (!(found & 0x01))
420 		devvt_create_snode(sdvp, DEVVT_ACTIVE_NAME, cred, SDEV_VLINK);
421 	if (!(found & 0x02))
422 		devvt_create_snode(sdvp, DEVVT_CONSUSER_NAME, cred, SDEV_VLINK);
423 
424 #ifndef	__lock_lint
425 	rw_downgrade(&sdvp->sdev_contents);
426 #else
427 	rw_exit(&sdvp->sdev_contents);
428 #endif
429 }
430 
431 /*ARGSUSED4*/
432 static int
433 devvt_readdir(struct vnode *dvp, struct uio *uiop, struct cred *cred,
434     int *eofp, caller_context_t *ct, int flags)
435 {
436 	if (uiop->uio_offset == 0) {
437 		devvt_cleandir(dvp, cred);
438 	}
439 
440 	return (devname_readdir_func(dvp, uiop, cred, eofp, 0));
441 }
442 
443 /*
444  * We allow create to find existing nodes
445  *	- if the node doesn't exist - EROFS
446  *	- creating an existing dir read-only succeeds, otherwise EISDIR
447  *	- exclusive creates fail - EEXIST
448  */
449 /*ARGSUSED2*/
450 static int
451 devvt_create(struct vnode *dvp, char *nm, struct vattr *vap, vcexcl_t excl,
452     int mode, struct vnode **vpp, struct cred *cred, int flag,
453     caller_context_t *ct, vsecattr_t *vsecp)
454 {
455 	int error;
456 	struct vnode *vp;
457 
458 	*vpp = NULL;
459 
460 	if ((error = devvt_lookup(dvp, nm, &vp, NULL, 0, NULL, cred, ct, NULL,
461 	    NULL)) != 0) {
462 		if (error == ENOENT)
463 			error = EROFS;
464 		return (error);
465 	}
466 
467 	if (excl == EXCL)
468 		error = EEXIST;
469 	else if (vp->v_type == VDIR && (mode & VWRITE))
470 		error = EISDIR;
471 	else
472 		error = VOP_ACCESS(vp, mode, 0, cred, ct);
473 
474 	if (error) {
475 		VN_RELE(vp);
476 	} else
477 		*vpp = vp;
478 
479 	return (error);
480 }
481 
482 const fs_operation_def_t devvt_vnodeops_tbl[] = {
483 	VOPNAME_READDIR,	{ .vop_readdir = devvt_readdir },
484 	VOPNAME_LOOKUP,		{ .vop_lookup = devvt_lookup },
485 	VOPNAME_CREATE,		{ .vop_create = devvt_create },
486 	VOPNAME_REMOVE,		{ .error = fs_nosys },
487 	VOPNAME_MKDIR,		{ .error = fs_nosys },
488 	VOPNAME_RMDIR,		{ .error = fs_nosys },
489 	VOPNAME_SYMLINK,	{ .error = fs_nosys },
490 	VOPNAME_SETSECATTR,	{ .error = fs_nosys },
491 	NULL,			NULL
492 };
493