1 | /* |
2 | * Copyright (c) 2000-2019 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ |
29 | /* |
30 | * Copyright (c) 1992, 1993 |
31 | * The Regents of the University of California. All rights reserved. |
32 | * |
33 | * This code is derived from software donated to Berkeley by |
34 | * Jan-Simon Pendry. |
35 | * |
36 | * Redistribution and use in source and binary forms, with or without |
37 | * modification, are permitted provided that the following conditions |
38 | * are met: |
39 | * 1. Redistributions of source code must retain the above copyright |
40 | * notice, this list of conditions and the following disclaimer. |
41 | * 2. Redistributions in binary form must reproduce the above copyright |
42 | * notice, this list of conditions and the following disclaimer in the |
43 | * documentation and/or other materials provided with the distribution. |
44 | * 3. All advertising materials mentioning features or use of this software |
45 | * must display the following acknowledgement: |
46 | * This product includes software developed by the University of |
47 | * California, Berkeley and its contributors. |
48 | * 4. Neither the name of the University nor the names of its contributors |
49 | * may be used to endorse or promote products derived from this software |
50 | * without specific prior written permission. |
51 | * |
52 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
53 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
54 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
55 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
56 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
57 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
58 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
59 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
60 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
61 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
62 | * SUCH DAMAGE. |
63 | * |
64 | * @(#)fdesc_vnops.c 8.17 (Berkeley) 5/22/95 |
65 | * |
66 | */ |
67 | |
68 | /* |
69 | * /dev/fd Filesystem |
70 | */ |
71 | |
72 | #include <sys/param.h> |
73 | #include <sys/systm.h> |
74 | #include <sys/types.h> |
75 | #include <sys/time.h> |
76 | #include <sys/proc_internal.h> |
77 | #include <sys/kernel.h> /* boottime */ |
78 | #include <sys/resourcevar.h> |
79 | #include <sys/filedesc.h> |
80 | #include <sys/kauth.h> |
81 | #include <sys/vnode_internal.h> |
82 | #include <sys/malloc.h> |
83 | #include <sys/file_internal.h> |
84 | #include <sys/stat.h> |
85 | #include <sys/mount_internal.h> |
86 | #include <sys/namei.h> |
87 | #include <sys/dirent.h> |
88 | #include <sys/ubc.h> |
89 | #include <sys/socketvar.h> |
90 | #include <sys/pipe.h> |
91 | #include <sys/uio_internal.h> |
92 | #include <vfs/vfs_support.h> |
93 | #include <pexpert/pexpert.h> |
94 | #include <miscfs/devfs/fdesc.h> |
95 | #include <miscfs/devfs/devfs.h> |
96 | #include <miscfs/devfs/devfsdefs.h> |
97 | |
98 | #define FDL_WANT 0x01 |
99 | #define FDL_LOCKED 0x02 |
100 | static int fdcache_lock; |
101 | |
102 | |
103 | #if (FD_STDIN != FD_STDOUT - 1) || (FD_STDOUT != FD_STDERR - 1) |
104 | FD_STDIN, FD_STDOUT, FD_STDERR must be a sequence n, n + 1, n + 2 |
105 | #endif |
106 | |
107 | #define NFDCACHE 3 |
108 | |
109 | #define FD_NHASH(ix) \ |
110 | (&fdhashtbl[(ix) & fdhash]) |
111 | LIST_HEAD(fdhashhead, fdescnode) * fdhashtbl; |
112 | u_long fdhash; |
113 | |
114 | static int fdesc_attr(int fd, struct vnode_attr *vap, vfs_context_t a_context); |
115 | |
116 | static LCK_GRP_DECLARE(fdesc_lckgrp, "fdesc" ); |
117 | static LCK_MTX_DECLARE(fdesc_mtx, &fdesc_lckgrp); |
118 | |
119 | static void |
120 | fdesc_lock(void) |
121 | { |
122 | lck_mtx_lock(lck: &fdesc_mtx); |
123 | } |
124 | |
125 | static void |
126 | fdesc_unlock(void) |
127 | { |
128 | lck_mtx_unlock(lck: &fdesc_mtx); |
129 | } |
130 | |
131 | |
132 | /* |
133 | * Initialise cache headers, create the devfs node |
134 | */ |
135 | int |
136 | devfs_fdesc_init() |
137 | { |
138 | int error = 0; |
139 | devnode_t *rootdir = dev_root->de_dnp; |
140 | devdirent_t *direntp; |
141 | |
142 | /* XXX Make sure you have the right path... */ |
143 | fdhashtbl = hashinit(NFDCACHE, M_CACHE, hashmask: &fdhash); |
144 | |
145 | DEVFS_LOCK(); |
146 | dev_add_entry(name: "fd" , parent: rootdir, type: DEV_DEVFD, NULL, NULL, NULL, nm_pp: &direntp); |
147 | devfs_fdesc_makelinks(); |
148 | DEVFS_UNLOCK(); |
149 | |
150 | return error; |
151 | } |
152 | |
153 | /* |
154 | * Called during early startup, no need to synchronize |
155 | */ |
156 | int |
157 | devfs_fdesc_makelinks() |
158 | { |
159 | int error = 0; |
160 | devdirent_t *stdin_ent = NULL, *stdout_ent = NULL, *stderr_ent = NULL; |
161 | devnode_t *root_devnode = dev_root->de_dnp; |
162 | |
163 | /* We do this ugliness to get around some "const" warnings */ |
164 | char in[] = "stdin" ; |
165 | char out[] = "stdout" ; |
166 | char err[] = "stderr" ; |
167 | char zero[] = "fd/0" ; |
168 | char one[] = "fd/1" ; |
169 | char two[] = "fd/2" ; |
170 | |
171 | if ((error = devfs_make_symlink(dir_p: root_devnode, name: in, mode: 0555, target: zero, newent: &stdin_ent))) { |
172 | printf("Couldn't make stdin, err %d.\n" , error); |
173 | goto bad; |
174 | } |
175 | |
176 | if ((error = devfs_make_symlink(dir_p: root_devnode, name: out, mode: 0555, target: one, newent: &stdout_ent))) { |
177 | printf("Couldn't make stdout, err %d.\n" , error); |
178 | goto bad; |
179 | } |
180 | |
181 | if ((error = devfs_make_symlink(dir_p: root_devnode, name: err, mode: 0555, target: two, newent: &stderr_ent))) { |
182 | printf("Couldn't make stderr, err %d.\n" , error); |
183 | goto bad; |
184 | } |
185 | |
186 | return 0; |
187 | |
188 | bad: |
189 | if (stdin_ent) { |
190 | dev_free_name(dirent_p: stdin_ent); |
191 | } |
192 | if (stdout_ent) { |
193 | dev_free_name(dirent_p: stdout_ent); |
194 | } |
195 | if (stderr_ent) { |
196 | dev_free_name(dirent_p: stderr_ent); |
197 | } |
198 | |
199 | return error; |
200 | } |
201 | |
202 | int |
203 | fdesc_allocvp(fdntype ftype, int ix, struct mount *mp, struct vnode **vpp, enum vtype vtype, int fdno) |
204 | { |
205 | struct fdhashhead *fc; |
206 | struct fdescnode *fd; |
207 | int error = 0; |
208 | int vid = 0; |
209 | struct vnode_fsparam vfsp; |
210 | struct vnode *vp; |
211 | |
212 | fdesc_lock(); |
213 | |
214 | fc = FD_NHASH(ix); |
215 | loop: |
216 | for (fd = fc->lh_first; fd != 0; fd = fd->fd_hash.le_next) { |
217 | if (fd->fd_ix == ix && vnode_mount(vp: fd->fd_vnode) == mp) { |
218 | vid = vnode_vid(vp: fd->fd_vnode); |
219 | vp = fd->fd_vnode; |
220 | vnode_hold(vp); |
221 | fdesc_unlock(); |
222 | |
223 | if (vnode_getwithvid(vp, vid)) { |
224 | vnode_drop(vp); |
225 | fdesc_lock(); |
226 | goto loop; |
227 | } |
228 | |
229 | vnode_drop(vp); |
230 | *vpp = vp; |
231 | (*vpp)->v_type = (uint16_t)vtype; |
232 | |
233 | return error; |
234 | } |
235 | } |
236 | |
237 | /* Only one thread can add to the hash at a time */ |
238 | if (fdcache_lock & FDL_LOCKED) { |
239 | fdcache_lock |= FDL_WANT; |
240 | msleep(chan: (caddr_t) &fdcache_lock, mtx: &fdesc_mtx, PINOD, wmesg: "fdesc_allocvp" , NULL); |
241 | goto loop; |
242 | } |
243 | |
244 | fdcache_lock |= FDL_LOCKED; |
245 | fdesc_unlock(); |
246 | |
247 | fd = kalloc_type(struct fdescnode, Z_WAITOK); |
248 | |
249 | vfsp.vnfs_mp = mp; |
250 | vfsp.vnfs_vtype = vtype; |
251 | vfsp.vnfs_str = "fdesc" ; |
252 | vfsp.vnfs_dvp = NULL; |
253 | vfsp.vnfs_fsnode = fd; |
254 | vfsp.vnfs_cnp = NULL; |
255 | vfsp.vnfs_vops = fdesc_vnodeop_p; |
256 | vfsp.vnfs_rdev = 0; |
257 | vfsp.vnfs_filesize = 0; |
258 | vfsp.vnfs_flags = VNFS_NOCACHE | VNFS_CANTCACHE; |
259 | vfsp.vnfs_marksystem = 0; |
260 | vfsp.vnfs_markroot = 0; |
261 | |
262 | error = vnode_create_ext(VNCREATE_FLAVOR, VCREATESIZE, data: &vfsp, vpp, |
263 | VNODE_CREATE_DEFAULT); |
264 | if (error) { |
265 | kfree_type(struct fdescnode, fd); |
266 | fdesc_lock(); |
267 | goto out; |
268 | } |
269 | |
270 | (*vpp)->v_tag = VT_FDESC; |
271 | fd->fd_vnode = *vpp; |
272 | fd->fd_type = ftype; |
273 | fd->fd_fd = fdno; |
274 | fd->fd_link = NULL; |
275 | fd->fd_ix = ix; |
276 | |
277 | fdesc_lock(); |
278 | |
279 | LIST_INSERT_HEAD(fc, fd, fd_hash); |
280 | out: |
281 | /* Hold the lock when we get here */ |
282 | fdcache_lock &= ~FDL_LOCKED; |
283 | |
284 | if (fdcache_lock & FDL_WANT) { |
285 | fdcache_lock &= ~FDL_WANT; |
286 | wakeup(chan: (caddr_t) &fdcache_lock); |
287 | } |
288 | |
289 | fdesc_unlock(); |
290 | |
291 | return error; |
292 | } |
293 | |
294 | /* |
295 | * vp is the current namei directory |
296 | * ndp is the name to locate in that directory... |
297 | * |
298 | * This vnop should only be called on the special directory /dev/fd. |
299 | */ |
300 | int |
301 | devfs_devfd_lookup(struct vnop_lookup_args *ap) |
302 | { |
303 | struct vnode **vpp = ap->a_vpp; |
304 | struct vnode *dvp = ap->a_dvp; |
305 | struct componentname *cnp = ap->a_cnp; |
306 | char *pname = cnp->cn_nameptr; |
307 | struct proc *p = vfs_context_proc(ctx: ap->a_context); |
308 | int numfiles = p->p_fd.fd_nfiles; |
309 | int fd; |
310 | int error; |
311 | struct vnode *fvp; |
312 | |
313 | if (cnp->cn_namelen == 1 && *pname == '.') { |
314 | *vpp = dvp; |
315 | |
316 | if ((error = vnode_get(dvp))) { |
317 | goto bad; |
318 | } |
319 | return 0; |
320 | } |
321 | |
322 | fd = 0; |
323 | while (*pname >= '0' && *pname <= '9') { |
324 | if (os_mul_and_add_overflow(fd, 10, *pname++ - '0', &fd)) { |
325 | break; |
326 | } |
327 | } |
328 | |
329 | if (*pname != '\0') { |
330 | error = ENOENT; |
331 | goto bad; |
332 | } |
333 | |
334 | if (fd < 0 || fd >= numfiles || |
335 | *fdfile(p, fd) == NULL || |
336 | (*fdflags(p, fd) & UF_RESERVED)) { |
337 | error = EBADF; |
338 | goto bad; |
339 | } |
340 | |
341 | /* |
342 | * For OP_SETATTR lookups, resolve the backing vnode now so we do |
343 | * MACF checks on the right thing. |
344 | * |
345 | * If there is no vnode (i.e. something else is open at that fd) then |
346 | * just return an fdescnode. |
347 | */ |
348 | if ((cnp->cn_ndp->ni_op == OP_SETATTR) && |
349 | (0 == vnode_getfromfd(ctx: ap->a_context, fd, vpp: &fvp))) { |
350 | cnp->cn_flags &= ~MAKEENTRY; |
351 | *vpp = fvp; |
352 | return 0; |
353 | } |
354 | |
355 | error = fdesc_allocvp(ftype: Fdesc, FD_DESC + fd, mp: dvp->v_mount, vpp: &fvp, vtype: VNON, fdno: fd); |
356 | if (error) { |
357 | goto bad; |
358 | } |
359 | *vpp = fvp; |
360 | return 0; |
361 | |
362 | bad: |
363 | *vpp = NULL; |
364 | return error; |
365 | } |
366 | |
367 | int |
368 | fdesc_open(struct vnop_open_args *ap) |
369 | { |
370 | struct vnode *vp = ap->a_vp; |
371 | thread_t thr = vfs_context_thread(ctx: ap->a_context); |
372 | uthread_t uu; |
373 | int error = 0; |
374 | |
375 | if (thr == NULL) { |
376 | return EINVAL; |
377 | } |
378 | |
379 | uu = get_bsdthread_info(thr); |
380 | |
381 | switch (VTOFDESC(vp)->fd_type) { |
382 | case Fdesc: |
383 | /* |
384 | * XXX Kludge: set uu->uu_dupfd to contain the value of the |
385 | * the file descriptor being sought for duplication. The error |
386 | * return ensures that the vnode for this device will be |
387 | * released by vn_open. Open will detect this special error and |
388 | * take the actions in dupfdopen. Other callers of vn_open or |
389 | * vnop_open will simply report the error. |
390 | */ |
391 | uu->uu_dupfd = VTOFDESC(vp)->fd_fd; /* XXX */ |
392 | error = ENODEV; |
393 | break; |
394 | default: |
395 | panic("Invalid type for fdesc node!" ); |
396 | break; |
397 | } |
398 | |
399 | return error; |
400 | } |
401 | |
402 | static int |
403 | fdesc_attr(int fd, struct vnode_attr *vap, vfs_context_t a_context) |
404 | { |
405 | struct fileproc *fp; |
406 | struct proc *p = vfs_context_proc(ctx: a_context); |
407 | struct stat stb; |
408 | int error; |
409 | |
410 | if ((error = fp_lookup(p, fd, resultfp: &fp, locked: 0))) { |
411 | return error; |
412 | } |
413 | switch (FILEGLOB_DTYPE(fp->fp_glob)) { |
414 | case DTYPE_VNODE: |
415 | if ((error = vnode_getwithref(vp: (struct vnode *)fp_get_data(fp))) != 0) { |
416 | break; |
417 | } |
418 | if ((error = vnode_authorize(vp: (struct vnode *)fp_get_data(fp), |
419 | NULL, |
420 | KAUTH_VNODE_READ_ATTRIBUTES | KAUTH_VNODE_READ_SECURITY, |
421 | ctx: a_context)) == 0) { |
422 | error = vnode_getattr(vp: (struct vnode *)fp_get_data(fp), vap, ctx: a_context); |
423 | } |
424 | if (error == 0 && vap->va_type == VDIR) { |
425 | /* |
426 | * directories can cause loops in the namespace, |
427 | * so turn off the 'x' bits to avoid trouble. |
428 | * |
429 | * XXX ACLs break this, of course |
430 | */ |
431 | vap->va_mode &= ~((VEXEC) | (VEXEC >> 3) | (VEXEC >> 6)); |
432 | } |
433 | (void)vnode_put(vp: (struct vnode *)fp_get_data(fp)); |
434 | break; |
435 | |
436 | case DTYPE_SOCKET: |
437 | case DTYPE_PIPE: |
438 | #if SOCKETS |
439 | if (FILEGLOB_DTYPE(fp->fp_glob) == DTYPE_SOCKET) { |
440 | error = soo_stat((struct socket *)fp_get_data(fp), (void *)&stb, 0); |
441 | } else |
442 | #endif /* SOCKETS */ |
443 | error = pipe_stat((struct pipe *)fp_get_data(fp), (void *)&stb, 0); |
444 | |
445 | if (error == 0) { |
446 | if (FILEGLOB_DTYPE(fp->fp_glob) == DTYPE_SOCKET) { |
447 | VATTR_RETURN(vap, va_type, VSOCK); |
448 | } else { |
449 | VATTR_RETURN(vap, va_type, VFIFO); |
450 | } |
451 | |
452 | VATTR_RETURN(vap, va_mode, stb.st_mode); |
453 | VATTR_RETURN(vap, va_nlink, stb.st_nlink); |
454 | VATTR_RETURN(vap, va_uid, stb.st_uid); |
455 | VATTR_RETURN(vap, va_gid, stb.st_gid); |
456 | VATTR_RETURN(vap, va_fsid, stb.st_dev); |
457 | VATTR_RETURN(vap, va_fileid, stb.st_ino); |
458 | VATTR_RETURN(vap, va_data_size, stb.st_size); |
459 | VATTR_RETURN(vap, va_access_time, stb.st_atimespec); |
460 | VATTR_RETURN(vap, va_modify_time, stb.st_mtimespec); |
461 | VATTR_RETURN(vap, va_change_time, stb.st_ctimespec); |
462 | VATTR_RETURN(vap, va_gen, stb.st_gen); |
463 | VATTR_RETURN(vap, va_flags, stb.st_flags); |
464 | VATTR_RETURN(vap, va_rdev, stb.st_rdev); |
465 | VATTR_RETURN(vap, va_total_alloc, stb.st_blocks * stb.st_blksize); |
466 | VATTR_RETURN(vap, va_acl, NULL); |
467 | } |
468 | break; |
469 | |
470 | default: |
471 | error = EBADF; |
472 | } |
473 | |
474 | fp_drop(p, fd, fp, locked: 0); |
475 | return error; |
476 | } |
477 | |
478 | int |
479 | fdesc_getattr(struct vnop_getattr_args *ap) |
480 | { |
481 | struct vnode *vp = ap->a_vp; |
482 | struct vnode_attr *vap = ap->a_vap; |
483 | unsigned fd; |
484 | int error = 0; |
485 | |
486 | switch (VTOFDESC(vp)->fd_type) { |
487 | case Fdesc: |
488 | fd = VTOFDESC(vp)->fd_fd; |
489 | error = fdesc_attr(fd, vap, a_context: ap->a_context); |
490 | break; |
491 | |
492 | default: |
493 | panic("Invalid type for an fdesc node!" ); |
494 | break; |
495 | } |
496 | |
497 | /* |
498 | * Yes, we do this without locking, but this value is always just |
499 | * a snapshot. |
500 | */ |
501 | if (error == 0) { |
502 | vp->v_type = (uint16_t)vap->va_type; |
503 | |
504 | /* We need an inactive to reset type to VNON */ |
505 | vnode_setneedinactive(vp); |
506 | } |
507 | |
508 | return error; |
509 | } |
510 | |
511 | int |
512 | fdesc_setattr(struct vnop_setattr_args *ap) |
513 | { |
514 | struct fileproc *fp; |
515 | unsigned fd; |
516 | int error; |
517 | struct proc * p = vfs_context_proc(ctx: ap->a_context); |
518 | |
519 | /* |
520 | * Can't mess with the root vnode |
521 | */ |
522 | switch (VTOFDESC(ap->a_vp)->fd_type) { |
523 | case Fdesc: |
524 | break; |
525 | default: |
526 | panic("Invalid type for an fdesc node!" ); |
527 | return EACCES; |
528 | } |
529 | |
530 | fd = VTOFDESC(ap->a_vp)->fd_fd; |
531 | if ((error = fp_lookup(p: vfs_context_proc(ctx: ap->a_context), fd, resultfp: &fp, locked: 0))) { |
532 | return error; |
533 | } |
534 | |
535 | switch (FILEGLOB_DTYPE(fp->fp_glob)) { |
536 | case DTYPE_VNODE: |
537 | /* |
538 | * We shouldn't get here unless we were raced with close/open. |
539 | * In that case, shenanigans are happening and it's unsafe to |
540 | * take action on the `setattr`; the MACF and UNIX permission |
541 | * checks are no longer valid (TOCTOU). |
542 | * |
543 | * Fall through to report success. |
544 | */ |
545 | case DTYPE_SOCKET: |
546 | case DTYPE_PIPE: |
547 | error = 0; |
548 | break; |
549 | |
550 | default: |
551 | error = EBADF; |
552 | break; |
553 | } |
554 | |
555 | fp_drop(p, fd, fp, locked: 0); |
556 | return error; |
557 | } |
558 | |
559 | #define UIO_MX 16 |
560 | |
561 | /* |
562 | * static struct dirtmp { |
563 | * u_int32_t d_fileno; |
564 | * u_short d_reclen; |
565 | * u_short d_namlen; |
566 | * char d_name[8]; |
567 | * } rootent[] = { |
568 | * { FD_DEVFD, UIO_MX, 2, "fd" }, |
569 | * { FD_STDIN, UIO_MX, 5, "stdin" }, |
570 | * { FD_STDOUT, UIO_MX, 6, "stdout" }, |
571 | * { FD_STDERR, UIO_MX, 6, "stderr" }, |
572 | * { 0, 0, 0, "" } |
573 | * }; |
574 | */ |
575 | |
576 | /* Only called on /dev/fd */ |
577 | int |
578 | devfs_devfd_readdir(struct vnop_readdir_args *ap) |
579 | { |
580 | struct uio *uio = ap->a_uio; |
581 | struct proc *p = current_proc(); |
582 | off_t i; |
583 | int error; |
584 | |
585 | /* |
586 | * We don't allow exporting fdesc mounts, and currently local |
587 | * requests do not need cookies. |
588 | */ |
589 | if (ap->a_flags & (VNODE_READDIR_EXTENDED | VNODE_READDIR_REQSEEKOFF)) { |
590 | return EINVAL; |
591 | } |
592 | |
593 | /* |
594 | * There needs to be space for at least one entry. |
595 | */ |
596 | if (uio_resid(a_uio: uio) < UIO_MX) { |
597 | return EINVAL; |
598 | } |
599 | |
600 | i = uio->uio_offset / UIO_MX; |
601 | error = 0; |
602 | while (uio_resid(a_uio: uio) >= UIO_MX) { |
603 | if (i >= p->p_fd.fd_nfiles || i < 0) { |
604 | break; |
605 | } |
606 | |
607 | if (*fdfile(p, i) != NULL && !(*fdflags(p, i) & UF_RESERVED)) { |
608 | struct dirent d; |
609 | struct dirent *dp = &d; |
610 | |
611 | bzero(s: (caddr_t) dp, UIO_MX); |
612 | |
613 | dp->d_namlen = (__uint8_t)scnprintf(dp->d_name, count: sizeof(dp->d_name), |
614 | "%lld" , i); |
615 | dp->d_reclen = UIO_MX; |
616 | dp->d_type = DT_UNKNOWN; |
617 | dp->d_fileno = (ino_t)i + FD_STDIN; |
618 | /* |
619 | * And ship to userland |
620 | */ |
621 | error = uiomove(cp: (caddr_t) dp, UIO_MX, uio); |
622 | if (error) { |
623 | break; |
624 | } |
625 | } |
626 | i++; |
627 | } |
628 | |
629 | uio->uio_offset = i * UIO_MX; |
630 | return error; |
631 | } |
632 | |
633 | int |
634 | fdesc_read(__unused struct vnop_read_args *ap) |
635 | { |
636 | return ENOTSUP; |
637 | } |
638 | |
639 | int |
640 | fdesc_write(__unused struct vnop_write_args *ap) |
641 | { |
642 | return ENOTSUP; |
643 | } |
644 | |
645 | int |
646 | fdesc_ioctl(__unused struct vnop_ioctl_args *ap) |
647 | { |
648 | return ENOTSUP; |
649 | } |
650 | |
651 | int |
652 | fdesc_select(__unused struct vnop_select_args *ap) |
653 | { |
654 | return ENOTSUP; |
655 | } |
656 | |
657 | int |
658 | fdesc_inactive(struct vnop_inactive_args *ap) |
659 | { |
660 | struct vnode *vp = ap->a_vp; |
661 | |
662 | /* |
663 | * Clear out the v_type field to avoid |
664 | * nasty things happening in vgone(). |
665 | */ |
666 | vp->v_type = VNON; |
667 | |
668 | return 0; |
669 | } |
670 | |
671 | int |
672 | fdesc_reclaim(struct vnop_reclaim_args *ap) |
673 | { |
674 | struct vnode *vp = ap->a_vp; |
675 | struct fdescnode *fd = VTOFDESC(vp); |
676 | |
677 | fdesc_lock(); |
678 | |
679 | LIST_REMOVE(fd, fd_hash); |
680 | kfree_type(struct fdescnode, vp->v_data); |
681 | |
682 | fdesc_unlock(); |
683 | |
684 | return 0; |
685 | } |
686 | |
687 | /* |
688 | * Return POSIX pathconf information applicable to special devices. |
689 | */ |
690 | int |
691 | fdesc_pathconf(struct vnop_pathconf_args *ap) |
692 | { |
693 | switch (ap->a_name) { |
694 | case _PC_LINK_MAX: |
695 | *ap->a_retval = LINK_MAX; |
696 | return 0; |
697 | case _PC_MAX_CANON: |
698 | *ap->a_retval = MAX_CANON; |
699 | return 0; |
700 | case _PC_MAX_INPUT: |
701 | *ap->a_retval = MAX_INPUT; |
702 | return 0; |
703 | case _PC_PIPE_BUF: |
704 | *ap->a_retval = PIPE_BUF; |
705 | return 0; |
706 | case _PC_CHOWN_RESTRICTED: |
707 | *ap->a_retval = 200112; /* _POSIX_CHOWN_RESTRICTED */ |
708 | return 0; |
709 | case _PC_VDISABLE: |
710 | *ap->a_retval = _POSIX_VDISABLE; |
711 | return 0; |
712 | default: |
713 | return EINVAL; |
714 | } |
715 | /* NOTREACHED */ |
716 | } |
717 | |
718 | /* |
719 | * /dev/fd "should never get here" operation |
720 | */ |
721 | int |
722 | fdesc_badop(void) |
723 | { |
724 | return ENOTSUP; |
725 | /* NOTREACHED */ |
726 | } |
727 | |
728 | #define VOPFUNC int (*)(void *) |
729 | |
730 | #define fdesc_revoke nop_revoke |
731 | #define fdesc_strategy (void (*)(void))fdesc_badop |
732 | |
733 | #define fdesc_nullop (void (*)(void ))nullop |
734 | #define fdesc_error (void (*)(void ))vn_default_error |
735 | #define fdesc_notsupp (void (*)(void ))eopnotsupp |
736 | |
737 | int(**fdesc_vnodeop_p)(void *); |
738 | const struct vnodeopv_entry_desc devfs_fdesc_vnodeop_entries[] = { |
739 | { .opve_op = &vnop_default_desc, .opve_impl = (VOPFUNC)fdesc_error }, |
740 | { .opve_op = &vnop_lookup_desc, .opve_impl = (VOPFUNC)fdesc_error}, /* lookup */ |
741 | { .opve_op = &vnop_create_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* create */ |
742 | { .opve_op = &vnop_mknod_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* mknod */ |
743 | { .opve_op = &vnop_open_desc, .opve_impl = (VOPFUNC)fdesc_open }, /* open */ |
744 | { .opve_op = &vnop_close_desc, .opve_impl = (VOPFUNC)fdesc_nullop }, /* close */ |
745 | { .opve_op = &vnop_access_desc, .opve_impl = (VOPFUNC)fdesc_nullop }, /* access */ |
746 | { .opve_op = &vnop_getattr_desc, .opve_impl = (VOPFUNC)fdesc_getattr }, /* getattr */ |
747 | { .opve_op = &vnop_setattr_desc, .opve_impl = (VOPFUNC)fdesc_setattr }, /* setattr */ |
748 | { .opve_op = &vnop_read_desc, .opve_impl = (VOPFUNC)fdesc_read }, /* read */ |
749 | { .opve_op = &vnop_write_desc, .opve_impl = (VOPFUNC)fdesc_write }, /* write */ |
750 | { .opve_op = &vnop_ioctl_desc, .opve_impl = (VOPFUNC)fdesc_ioctl }, /* ioctl */ |
751 | { .opve_op = &vnop_select_desc, .opve_impl = (VOPFUNC)fdesc_select }, /* select */ |
752 | { .opve_op = &vnop_revoke_desc, .opve_impl = (VOPFUNC)fdesc_revoke }, /* revoke */ |
753 | { .opve_op = &vnop_mmap_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* mmap */ |
754 | { .opve_op = &vnop_fsync_desc, .opve_impl = (VOPFUNC)fdesc_nullop }, /* fsync */ |
755 | { .opve_op = &vnop_remove_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* remove */ |
756 | { .opve_op = &vnop_link_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* link */ |
757 | { .opve_op = &vnop_rename_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* rename */ |
758 | { .opve_op = &vnop_mkdir_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* mkdir */ |
759 | { .opve_op = &vnop_rmdir_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* rmdir */ |
760 | { .opve_op = &vnop_symlink_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* symlink */ |
761 | { .opve_op = &vnop_readdir_desc, .opve_impl = (VOPFUNC)fdesc_error},/* readdir */ |
762 | { .opve_op = &vnop_readlink_desc, .opve_impl = (VOPFUNC)err_readlink}, /* readlink */ |
763 | { .opve_op = &vnop_inactive_desc, .opve_impl = (VOPFUNC)fdesc_inactive },/* inactive */ |
764 | { .opve_op = &vnop_reclaim_desc, .opve_impl = (VOPFUNC)fdesc_reclaim }, /* reclaim */ |
765 | { .opve_op = &vnop_strategy_desc, .opve_impl = (VOPFUNC)fdesc_strategy }, /* strategy */ |
766 | { .opve_op = &vnop_pathconf_desc, .opve_impl = (VOPFUNC)fdesc_pathconf }, /* pathconf */ |
767 | { .opve_op = &vnop_advlock_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* advlock */ |
768 | { .opve_op = &vnop_bwrite_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* bwrite */ |
769 | { .opve_op = &vnop_pagein_desc, .opve_impl = (VOPFUNC)err_pagein }, /* pagein */ |
770 | { .opve_op = &vnop_pageout_desc, .opve_impl = (VOPFUNC)err_pageout }, /* pageout */ |
771 | { .opve_op = &vnop_copyfile_desc, .opve_impl = (VOPFUNC)err_copyfile }, /* Copyfile */ |
772 | { .opve_op = &vnop_blktooff_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* blktooff */ |
773 | { .opve_op = &vnop_blktooff_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* offtoblk */ |
774 | { .opve_op = &vnop_blockmap_desc, .opve_impl = (VOPFUNC)fdesc_notsupp }, /* blockmap */ |
775 | { .opve_op = (struct vnodeop_desc*)NULL, .opve_impl = (VOPFUNC)NULL } |
776 | }; |
777 | |
778 | const struct vnodeopv_desc devfs_fdesc_vnodeop_opv_desc = |
779 | { .opv_desc_vector_p = &fdesc_vnodeop_p, .opv_desc_ops = devfs_fdesc_vnodeop_entries }; |
780 | |