?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel - Fix races created by a comedy of circumstansces (3)
[dragonfly.git] / sys / vfs / dirfs / dirfs_vnops.c
bloba9acfbb5c1139a1c5154781e18df573ebcfc434c
1 /*
2 * Copyright (c) 2013 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Antonio Huete Jimenez <tuxillo@quantumachine.net>
6 * by Matthew Dillon <dillon@dragonflybsd.org>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the
17 * distribution.
18 * 3. Neither the name of The DragonFly Project nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific, prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 */
36
37 #include <stdio.h>
38 #include <errno.h>
39 #include <strings.h>
40 #include <unistd.h>
41
42 #include <sys/vfsops.h>
43 #include <sys/vnode.h>
44 #include <sys/stat.h>
45 #include <sys/namecache.h>
46 #include <sys/queue.h>
47 #include <sys/systm.h>
48 #include <sys/dirent.h>
49 #include <sys/mount.h>
50 #include <sys/signalvar.h>
51 #include <sys/resource.h>
52 #include <sys/buf2.h>
53 #include <sys/kern_syscall.h>
54 #include <sys/ktr.h>
55
56 #include "dirfs.h"
57
58 /*
59 * Kernel tracing facilities
60 */
61 KTR_INFO_MASTER_EXTERN(dirfs);
62
63 KTR_INFO(KTR_DIRFS, dirfs, unsupported, 0,
64 "DIRFS(func=%s)",
65 const char *func);
66
67 KTR_INFO(KTR_DIRFS, dirfs, nresolve, 0,
68 "DIRFS(dnp=%p ncp_name=%s parent=%p pfd=%d error=%d)",
69 dirfs_node_t dnp, char *name, dirfs_node_t pdnp, int pfd, int error);
70
71 KTR_INFO(KTR_DIRFS, dirfs, ncreate, 1,
72 "DIRFS(dnp=%p ncp_name=%s parent=%p pfd=%d error=%d)",
73 dirfs_node_t dnp, char *name, dirfs_node_t pdnp, int pfd, int error);
74
75 KTR_INFO(KTR_DIRFS, dirfs, open, 2,
76 "DIRFS(dnp=%p dn_name=%s nfd=%d)",
77 dirfs_node_t dnp, char *name, int fd);
78
79 KTR_INFO(KTR_DIRFS, dirfs, close, 3,
80 "DIRFS(dnp=%p fd=%d opencount=%d writecount=%d vfsync error=%d)",
81 dirfs_node_t dnp, int fd, int oc, int wc, int error);
82
83 KTR_INFO(KTR_DIRFS, dirfs, readdir, 4,
84 "DIRFS(dnp=%p fd=%d startoff=%jd uio_offset=%jd)",
85 dirfs_node_t dnp, int fd, off_t startoff, off_t uoff);
86
87 KTR_INFO(KTR_DIRFS, dirfs, access, 5,
88 "DIRFS(dnp=%p error=%d)",
89 dirfs_node_t dnp, int error);
90
91 KTR_INFO(KTR_DIRFS, dirfs, getattr, 6,
92 "DIRFS(dnp=%p error=%d)",
93 dirfs_node_t dnp, int error);
94
95 KTR_INFO(KTR_DIRFS, dirfs, setattr, 7,
96 "DIRFS(dnp=%p action=%s error=%d)",
97 dirfs_node_t dnp, const char *action, int error);
98
99 KTR_INFO(KTR_DIRFS, dirfs, fsync, 8,
100 "DIRFS(dnp=%p error=%d)",
101 dirfs_node_t dnp, int error);
102
103 KTR_INFO(KTR_DIRFS, dirfs, read, 9,
104 "DIRFS(dnp=%p size=%jd error=%d)",
105 dirfs_node_t dnp, size_t size, int error);
106
107 KTR_INFO(KTR_DIRFS, dirfs, write, 10,
108 "DIRFS(dnp=%p size=%jd boff=%jd uio_resid=%jd error=%d)",
109 dirfs_node_t dnp, off_t boff, size_t resid, size_t size, int error);
110
111 KTR_INFO(KTR_DIRFS, dirfs, strategy, 11,
112 "DIRFS(dnp=%p dnp_size=%jd iosize=%jd b_cmd=%d b_error=%d "
113 "b_resid=%d bio_off=%jd error=%d)",
114 dirfs_node_t dnp, size_t size, size_t iosize, int cmd, int berror,
115 int bresid, off_t biooff, int error);
116
117 KTR_INFO(KTR_DIRFS, dirfs, nremove, 12,
118 "DIRFS(dnp=%p pdnp=%p error=%d)",
119 dirfs_node_t dnp, dirfs_node_t pdnp, int error);
120
121 KTR_INFO(KTR_DIRFS, dirfs, nmkdir, 13,
122 "DIRFS(pdnp=%p dnp=%p nc_name=%p error=%d)",
123 dirfs_node_t dnp, dirfs_node_t pdnp, char *n, int error);
124
125 KTR_INFO(KTR_DIRFS, dirfs, nrmdir, 13,
126 "DIRFS(pdnp=%p dnp=%p error=%d)",
127 dirfs_node_t dnp, dirfs_node_t pdnp, int error);
128
129 KTR_INFO(KTR_DIRFS, dirfs, nsymlink, 14,
130 "DIRFS(dnp=%p target=%s symlink=%s error=%d)",
131 dirfs_node_t dnp, char *tgt, char *lnk, int error);
132
133 /* Needed prototypes */
134 int dirfs_access(struct vop_access_args *);
135 int dirfs_getattr(struct vop_getattr_args *);
136 int dirfs_setattr(struct vop_setattr_args *);
137 int dirfs_reclaim(struct vop_reclaim_args *);
138
139 static __inline
140 void
141 dirfs_knote(struct vnode *vp, int flags)
142 {
143 if (flags)
144 KNOTE(&vp->v_pollinfo.vpi_kqinfo.ki_note, flags);
145 }
146
147 static int
148 dirfs_nresolve(struct vop_nresolve_args *ap)
149 {
150 dirfs_node_t pdnp, dnp, d1, d2;
151 dirfs_mount_t dmp;
152 struct namecache *ncp;
153 struct nchandle *nch;
154 struct vnode *dvp;
155 struct vnode *vp;
156 struct mount *mp;
157 int error;
158
159 dbg(3, "called\n");
160
161 error = 0;
162 nch = ap->a_nch;
163 ncp = nch->ncp;
164 mp = nch->mount;
165 dvp = ap->a_dvp;
166 vp = NULL;
167 dnp = d1 = d2 = NULL;
168 pdnp = VP_TO_NODE(dvp);
169 dmp = VFS_TO_DIRFS(mp);
170
171 dirfs_node_lock(pdnp);
172 TAILQ_FOREACH_MUTABLE(d1, &dmp->dm_fdlist, dn_fdentry, d2) {
173 if (d1->dn_parent == pdnp &&
174 (strcmp(d1->dn_name, ncp->nc_name) == 0)) {
175 dnp = d1;
176 dirfs_node_ref(dnp);
177 passive_fd_list_hits++;
178 break;
179 }
180 }
181 dirfs_node_unlock(pdnp);
182
183 if (dnp) {
184 dirfs_alloc_vp(mp, &vp, LK_CANRECURSE, dnp);
185 dirfs_node_drop(dmp, dnp);
186 } else {
187 passive_fd_list_miss++;
188 error = dirfs_alloc_file(dmp, &dnp, pdnp, ncp, &vp, NULL, 0);
189 }
190
191 if (vp) {
192 if (error && error == ENOENT) {
193 cache_setvp(nch, NULL);
194 } else {
195 vn_unlock(vp);
196 cache_setvp(nch, vp);
197 vrele(vp);
198 }
199 }
200
201 KTR_LOG(dirfs_nresolve, dnp, ncp->nc_name, pdnp, pdnp->dn_fd, error);
202
203 return error;
204 }
205
206 static int
207 dirfs_nlookupdotdot(struct vop_nlookupdotdot_args *ap)
208 {
209 dbg(3, "called\n");
210
211 KTR_LOG(dirfs_unsupported, __func__);
212
213 return EOPNOTSUPP;
214 }
215
216 static int
217 dirfs_ncreate(struct vop_ncreate_args *ap)
218 {
219 dirfs_node_t pdnp;
220 dirfs_node_t dnp;
221 dirfs_mount_t dmp;
222 struct namecache *ncp;
223 struct vnode *dvp;
224 struct vnode **vpp;
225 struct vattr *vap;
226 int perms = 0;
227 int error;
228
229 dbg(3, "called\n");
230
231 error = 0;
232 dnp = NULL;
233 dvp = ap->a_dvp;
234 pdnp = VP_TO_NODE(dvp);
235 dmp = VFS_TO_DIRFS(dvp->v_mount);
236 vap = ap->a_vap;
237 ncp = ap->a_nch->ncp;
238 vpp = ap->a_vpp;
239
240 dirfs_node_getperms(pdnp, &perms);
241 if ((perms & DIRFS_NODE_WR) == 0)
242 error = EPERM;
243
244 error = dirfs_alloc_file(dmp, &dnp, pdnp, ncp, vpp, vap,
245 (O_CREAT | O_RDWR));
246
247 if (error == 0) {
248 cache_setunresolved(ap->a_nch);
249 cache_setvp(ap->a_nch, *vpp);
250 dirfs_knote(dvp, NOTE_WRITE);
251 }
252
253 KTR_LOG(dirfs_ncreate, dnp, ncp->nc_name, pdnp, pdnp->dn_fd, error);
254
255 return error;
256 }
257
258 static int
259 dirfs_nmknod(struct vop_nmknod_args *v)
260 {
261 dbg(3, "called\n");
262
263 return EOPNOTSUPP;
264 }
265
266 static int
267 dirfs_open(struct vop_open_args *ap)
268 {
269 dirfs_node_t dnp;
270 dirfs_mount_t dmp;
271 struct vnode *vp;
272 int error;
273
274 dbg(3, "called\n");
275
276 vp = ap->a_vp;
277 dnp = VP_TO_NODE(vp);
278 dmp = VFS_TO_DIRFS(vp->v_mount);
279 error = 0;
280
281 /*
282 * Root inode has been allocated and opened in VFS_ROOT() so
283 * no reason to attempt to open it again.
284 */
285 if (dmp->dm_root != dnp && dnp->dn_fd == DIRFS_NOFD) {
286 error = dirfs_open_helper(dmp, dnp, DIRFS_NOFD, NULL);
287 if (error)
288 return error;
289 }
290
291 KTR_LOG(dirfs_open, dnp, dnp->dn_name, dnp->dn_fd);
292
293 return vop_stdopen(ap);
294 }
295
296 static int
297 dirfs_close(struct vop_close_args *ap)
298 {
299 struct vnode *vp;
300 dirfs_node_t dnp;
301 int error;
302
303 dbg(3, "called\n");
304
305 error = 0;
306 vp = ap->a_vp;
307 dnp = VP_TO_NODE(vp);
308
309 if (vp->v_type == VREG) {
310 error = vfsync(vp, 0, 1, NULL, NULL);
311 if (error)
312 dbg(9, "vfsync error=%d\n", error);
313 }
314 vop_stdclose(ap);
315
316 KTR_LOG(dirfs_close, dnp, dnp->dn_fd, vp->v_opencount,
317 vp->v_writecount, error);
318
319 return 0;
320 }
321
322 int
323 dirfs_access(struct vop_access_args *ap)
324 {
325 struct vnode *vp = ap->a_vp;
326 int error;
327 dirfs_node_t dnp;
328
329 dbg(3, "called\n");
330
331 dnp = VP_TO_NODE(vp);
332
333 switch (vp->v_type) {
334 case VDIR:
335 /* FALLTHROUGH */
336 case VLNK:
337 /* FALLTHROUGH */
338 case VREG:
339 if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
340 error = EROFS;
341 goto out;
342 }
343 break;
344 case VBLK:
345 /* FALLTHROUGH */
346 case VCHR:
347 /* FALLTHROUGH */
348 case VSOCK:
349 /* FALLTHROUGH */
350 case VFIFO:
351 break;
352
353 default:
354 error = EINVAL;
355 goto out;
356 }
357
358 error = vop_helper_access(ap, dnp->dn_uid,
359 dnp->dn_gid, dnp->dn_mode, 0);
360
361 out:
362 KTR_LOG(dirfs_access, dnp, error);
363
364 return error;
365 }
366
367 int
368 dirfs_getattr(struct vop_getattr_args *ap)
369 {
370 dirfs_mount_t dmp;
371 dirfs_node_t dnp;
372 dirfs_node_t pathnp;
373 struct vnode *vp;
374 struct vattr *vap;
375 char *tmp;
376 char *pathfree;
377 int error;
378
379 dbg(3, "called\n");
380
381 vp = ap->a_vp;
382 vap = ap->a_vap;
383 dnp = VP_TO_NODE(vp);
384 dmp = VFS_TO_DIRFS(vp->v_mount);
385
386 KKASSERT(dnp); /* This must not happen */
387
388 if (!dirfs_node_isroot(dnp)) {
389 pathnp = dirfs_findfd(dmp, dnp, &tmp, &pathfree);
390
391 KKASSERT(pathnp->dn_fd != DIRFS_NOFD);
392
393 error = dirfs_node_stat(pathnp->dn_fd, tmp, dnp);
394 dirfs_dropfd(dmp, pathnp, pathfree);
395 } else {
396 error = dirfs_node_stat(DIRFS_NOFD, dmp->dm_path, dnp);
397 }
398
399 if (error == 0) {
400 dirfs_node_lock(dnp);
401 vap->va_nlink = dnp->dn_links;
402 vap->va_type = dnp->dn_type;
403 vap->va_mode = dnp->dn_mode;
404 vap->va_uid = dnp->dn_uid;
405 vap->va_gid = dnp->dn_gid;
406 vap->va_fileid = dnp->dn_ino;
407 vap->va_size = dnp->dn_size;
408 vap->va_blocksize = dnp->dn_blocksize;
409 vap->va_atime.tv_sec = dnp->dn_atime;
410 vap->va_atime.tv_nsec = dnp->dn_atimensec;
411 vap->va_mtime.tv_sec = dnp->dn_mtime;
412 vap->va_mtime.tv_nsec = dnp->dn_mtimensec;
413 vap->va_ctime.tv_sec = dnp->dn_ctime;
414 vap->va_ctime.tv_nsec = dnp->dn_ctimensec;
415 vap->va_bytes = dnp->dn_size;
416 vap->va_gen = dnp->dn_gen;
417 vap->va_flags = dnp->dn_flags;
418 vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
419 dirfs_node_unlock(dnp);
420 }
421
422 KTR_LOG(dirfs_getattr, dnp, error);
423
424 return 0;
425 }
426
427 int
428 dirfs_setattr(struct vop_setattr_args *ap)
429 {
430 dirfs_mount_t dmp;
431 dirfs_node_t dnp;
432 struct vnode *vp;
433 struct vattr *vap;
434 struct ucred *cred;
435 int error;
436 int kflags = 0;
437 #ifdef KTR
438 const char *msg[6] = {
439 "invalid",
440 "chflags",
441 "chsize",
442 "chown",
443 "chmod",
444 "chtimes"
445 };
446 #endif
447 int msgno;
448
449 dbg(3, "called\n");
450
451 error = msgno = 0;
452 vp = ap->a_vp;
453 vap = ap->a_vap;
454 cred = ap->a_cred;
455 dnp = VP_TO_NODE(vp);
456 dmp = VFS_TO_DIRFS(vp->v_mount);
457
458 /*
459 * Check for unsettable attributes.
460 */
461 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
462 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
463 (vap->va_blocksize != VNOVAL) || (vap->va_rmajor != VNOVAL) ||
464 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
465 msgno = 0;
466 error = EINVAL;
467 goto out;
468 }
469
470 /*
471 * Change file flags
472 */
473 if (error == 0 && (vap->va_flags != VNOVAL)) {
474 if (vp->v_mount->mnt_flag & MNT_RDONLY) {
475 error = EROFS;
476 } else {
477 error = dirfs_node_chflags(dnp, vap->va_flags, cred);
478 kflags |= NOTE_ATTRIB;
479 }
480 msgno = 1;
481 goto out;
482 }
483
484 /*
485 * Extend or truncate a file
486 */
487 if (error == 0 && (vap->va_size != VNOVAL)) {
488 if (vp->v_mount->mnt_flag & MNT_RDONLY) {
489 error = EROFS;
490 } else {
491 if (vap->va_size > dnp->dn_size)
492 kflags |= NOTE_WRITE | NOTE_EXTEND;
493 else
494 kflags |= NOTE_WRITE;
495 error = dirfs_node_chsize(dnp, vap->va_size);
496 }
497 dbg(9, "dnp size=%jd vap size=%jd\n", dnp->dn_size, vap->va_size);
498 msgno = 2;
499 goto out;
500 }
501
502 /*
503 * Change file owner or group
504 */
505 if (error == 0 && (vap->va_uid != (uid_t)VNOVAL ||
506 vap->va_gid != (gid_t)VNOVAL)) {
507 if (vp->v_mount->mnt_flag & MNT_RDONLY) {
508 error = EROFS;
509 } else {
510 mode_t cur_mode = dnp->dn_mode;
511 uid_t cur_uid = dnp->dn_uid;
512 gid_t cur_gid = dnp->dn_gid;
513
514 error = vop_helper_chown(ap->a_vp, vap->va_uid,
515 vap->va_gid, ap->a_cred,
516 &cur_uid, &cur_gid, &cur_mode);
517 if (error == 0 &&
518 (cur_mode != dnp->dn_mode ||
519 cur_uid != dnp->dn_uid ||
520 cur_gid != dnp->dn_gid)) {
521 error = dirfs_node_chown(dmp, dnp, cur_uid,
522 cur_gid, cur_mode);
523 kflags |= NOTE_ATTRIB;
524 }
525 }
526 msgno = 3;
527 goto out;
528 }
529
530 /*
531 * Change file mode
532 */
533 if (error == 0 && (vap->va_mode != (mode_t)VNOVAL)) {
534 if (vp->v_mount->mnt_flag & MNT_RDONLY) {
535 error = EROFS;
536 } else {
537 mode_t cur_mode = dnp->dn_mode;
538 uid_t cur_uid = dnp->dn_uid;
539 gid_t cur_gid = dnp->dn_gid;
540
541 error = vop_helper_chmod(ap->a_vp, vap->va_mode,
542 ap->a_cred,
543 cur_uid, cur_gid, &cur_mode);
544 if (error == 0 && cur_mode != dnp->dn_mode) {
545 error = dirfs_node_chmod(dmp, dnp, cur_mode);
546 kflags |= NOTE_ATTRIB;
547 }
548 }
549 msgno = 4;
550 goto out;
551 }
552
553 /*
554 * Change file times
555 */
556 if (error == 0 && ((vap->va_atime.tv_sec != VNOVAL &&
557 vap->va_atime.tv_nsec != VNOVAL) ||
558 (vap->va_mtime.tv_sec != VNOVAL &&
559 vap->va_mtime.tv_nsec != VNOVAL) )) {
560 if (vp->v_mount->mnt_flag & MNT_RDONLY) {
561 error = EROFS;
562 } else {
563 error = dirfs_node_chtimes(dnp);
564 kflags |= NOTE_ATTRIB;
565 }
566 msgno = 5;
567 goto out;
568
569 }
570 out:
571 KTR_LOG(dirfs_setattr, dnp, msg[msgno], error);
572
573 dirfs_knote(vp, kflags);
574
575 return error;
576 }
577
578 static int
579 dirfs_fsync(struct vop_fsync_args *ap)
580 {
581 dirfs_node_t dnp = VP_TO_NODE(ap->a_vp);
582 int error = 0;
583
584 dbg(3, "called\n");
585
586 vfsync(ap->a_vp, ap->a_waitfor, 1, NULL, NULL);
587
588 if (dnp->dn_fd != DIRFS_NOFD) {
589 if (fsync(dnp->dn_fd) == -1)
590 error = fsync(dnp->dn_fd);
591 }
592
593 KTR_LOG(dirfs_fsync, dnp, error);
594
595 return 0;
596 }
597
598 static int
599 dirfs_read(struct vop_read_args *ap)
600 {
601 struct buf *bp;
602 struct vnode *vp = ap->a_vp;
603 struct uio *uio = ap->a_uio;
604 dirfs_node_t dnp;
605 off_t base_offset;
606 size_t offset;
607 size_t len;
608 int error;
609
610 dbg(3, "called\n");
611
612 error = 0;
613 if (uio->uio_resid == 0) {
614 dbg(9, "zero len uio->uio_resid\n");
615 return error;
616 }
617
618 dnp = VP_TO_NODE(vp);
619
620 if (uio->uio_offset < 0)
621 return (EINVAL);
622 if (vp->v_type != VREG)
623 return (EINVAL);
624
625 while (uio->uio_resid > 0 && uio->uio_offset < dnp->dn_size) {
626 /*
627 * Use buffer cache I/O (via dirfs_strategy)
628 */
629 offset = (size_t)uio->uio_offset & BMASK;
630 base_offset = (off_t)uio->uio_offset - offset;
631 bp = getcacheblk(vp, base_offset, BSIZE, 0);
632 if (bp == NULL) {
633 lwkt_gettoken(&vp->v_mount->mnt_token);
634 error = bread(vp, base_offset, BSIZE, &bp);
635 if (error) {
636 brelse(bp);
637 lwkt_reltoken(&vp->v_mount->mnt_token);
638 dbg(9, "dirfs_read bread error %d\n", error);
639 break;
640 }
641 lwkt_reltoken(&vp->v_mount->mnt_token);
642 }
643
644 /*
645 * Figure out how many bytes we can actually copy this loop.
646 */
647 len = BSIZE - offset;
648 if (len > uio->uio_resid)
649 len = uio->uio_resid;
650 if (len > dnp->dn_size - uio->uio_offset)
651 len = (size_t)(dnp->dn_size - uio->uio_offset);
652
653 error = uiomovebp(bp, (char *)bp->b_data + offset, len, uio);
654 bqrelse(bp);
655 if (error) {
656 dbg(9, "dirfs_read uiomove error %d\n", error);
657 break;
658 }
659 }
660
661 KTR_LOG(dirfs_read, dnp, dnp->dn_size, error);
662
663 return(error);
664 }
665
666 static int
667 dirfs_write (struct vop_write_args *ap)
668 {
669 dirfs_node_t dnp;
670 dirfs_mount_t dmp;
671 struct buf *bp;
672 struct vnode *vp = ap->a_vp;
673 struct uio *uio = ap->a_uio;
674 struct thread *td = uio->uio_td;
675 int error;
676 int kflags = 0;
677 off_t osize;
678 off_t nsize;
679 off_t base_offset;
680 size_t offset;
681 size_t len;
682 struct rlimit limit;
683
684 dbg(3, "called\n");
685
686 error = 0;
687 if (uio->uio_resid == 0) {
688 dbg(9, "zero-length uio->uio_resid\n");
689 return error;
690 }
691
692 dnp = VP_TO_NODE(vp);
693 dmp = VFS_TO_DIRFS(vp->v_mount);
694
695 if (vp->v_type != VREG)
696 return (EINVAL);
697
698 if (vp->v_type == VREG && td != NULL) {
699 error = kern_getrlimit(RLIMIT_FSIZE, &limit);
700 if (error != 0) {
701 dbg(9, "rlimit failure\n");
702 return error;
703 }
704 if (uio->uio_offset + uio->uio_resid > limit.rlim_cur) {
705 dbg(9, "file too big\n");
706 ksignal(td->td_proc, SIGXFSZ);
707 return (EFBIG);
708 }
709 }
710
711 if (ap->a_ioflag & IO_APPEND)
712 uio->uio_offset = dnp->dn_size;
713
714 /*
715 * buffer cache operations may be deferred, make sure
716 * the file is correctly sized right now.
717 */
718 osize = dnp->dn_size;
719 nsize = uio->uio_offset + uio->uio_resid;
720 if (nsize > osize && uio->uio_resid) {
721 KKASSERT(dnp->dn_fd >= 0);
722 dnp->dn_size = nsize;
723 ftruncate(dnp->dn_fd, nsize);
724 nvextendbuf(vp, osize, nsize,
725 BSIZE, BSIZE, -1, -1, 0);
726 kflags |= NOTE_EXTEND;
727 } /* else nsize = osize; NOT USED */
728
729 while (uio->uio_resid > 0) {
730 /*
731 * Use buffer cache I/O (via dirfs_strategy)
732 */
733 offset = (size_t)uio->uio_offset & BMASK;
734 base_offset = (off_t)uio->uio_offset - offset;
735 len = BSIZE - offset;
736
737 if (len > uio->uio_resid)
738 len = uio->uio_resid;
739
740 error = bread(vp, base_offset, BSIZE, &bp);
741 error = uiomovebp(bp, (char *)bp->b_data + offset, len, uio);
742 if (error) {
743 brelse(bp);
744 dbg(9, "WRITE uiomove failed\n");
745 break;
746 }
747 kflags |= NOTE_WRITE;
748
749 dbg(9, "WRITE dn_size=%jd uio_offset=%jd uio_resid=%jd base_offset=%jd\n",
750 dnp->dn_size, uio->uio_offset, uio->uio_resid, base_offset);
751
752 if (ap->a_ioflag & IO_SYNC)
753 bwrite(bp);
754 else
755 bdwrite(bp);
756 }
757
758 KTR_LOG(dirfs_write, dnp, base_offset, uio->uio_resid,
759 dnp->dn_size, error);
760
761 if (kflags)
762 dirfs_knote(vp, kflags);
763 return error;
764 }
765
766 static int
767 dirfs_advlock (struct vop_advlock_args *ap)
768 {
769 struct vnode *vp = ap->a_vp;
770 dirfs_node_t dnp = VP_TO_NODE(vp);
771
772 dbg(3, "called\n");
773
774 return (lf_advlock(ap, &dnp->dn_advlock, dnp->dn_size));
775 }
776
777 static int
778 dirfs_strategy(struct vop_strategy_args *ap)
779 {
780 dirfs_node_t dnp;
781 dirfs_mount_t dmp;
782 struct bio *bio = ap->a_bio;
783 struct buf *bp = bio->bio_buf;
784 struct vnode *vp = ap->a_vp;
785 int error;
786 size_t iosize;
787 char *tmp;
788 char *pathfree;
789
790 dbg(3, "called\n");
791
792 dnp = VP_TO_NODE(vp);
793 dmp = VFS_TO_DIRFS(vp->v_mount);
794
795 error = 0;
796
797 if (vp->v_type != VREG) {
798 dbg(9, "not VREG\n");
799 bp->b_resid = bp->b_bcount;
800 bp->b_flags |= B_ERROR | B_INVAL;
801 bp->b_error = EINVAL;
802 biodone(bio);
803 return(0);
804 }
805
806 if (dnp->dn_fd == DIRFS_NOFD) {
807 print_backtrace(-1);
808 panic("Meh, no fd to write to. dnp=%p\n", dnp);
809 }
810
811 if (bio->bio_offset + bp->b_bcount > dnp->dn_size)
812 iosize = dnp->dn_size - bio->bio_offset;
813 else
814 iosize = bp->b_bcount;
815 KKASSERT((ssize_t)iosize >= 0);
816
817 switch (bp->b_cmd) {
818 case BUF_CMD_WRITE:
819 error = pwrite(dnp->dn_fd, bp->b_data, iosize, bio->bio_offset);
820 break;
821 case BUF_CMD_READ:
822 error = pread(dnp->dn_fd, bp->b_data, iosize, bio->bio_offset);
823 break;
824 default:
825 bp->b_error = error = EINVAL;
826 bp->b_flags |= B_ERROR;
827 break;
828 }
829
830 if (error >= 0 && error < bp->b_bcount)
831 bzero(bp->b_data + error, bp->b_bcount - error);
832
833 if (error < 0 && errno != EINTR) {
834 dbg(9, "error=%d dnp=%p dnp->dn_fd=%d "
835 "bio->bio_offset=%ld bcount=%d resid=%d iosize=%zd\n",
836 errno, dnp, dnp->dn_fd, bio->bio_offset, bp->b_bcount,
837 bp->b_resid, iosize);
838 bp->b_error = errno;
839 bp->b_resid = bp->b_bcount;
840 bp->b_flags |= B_ERROR;
841 } else {
842 tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
843 dirfs_node_stat(DIRFS_NOFD, tmp, dnp);
844 dirfs_dropfd(dmp, NULL, pathfree);
845 }
846
847 KTR_LOG(dirfs_strategy, dnp, dnp->dn_size, iosize, bp->b_cmd,
848 bp->b_error, bp->b_resid, bio->bio_offset, error);
849
850 biodone(bio);
851
852 return 0;
853 }
854
855 static int
856 dirfs_bmap(struct vop_bmap_args *ap)
857 {
858 dbg(3, "called\n");
859
860 if (ap->a_doffsetp != NULL)
861 *ap->a_doffsetp = ap->a_loffset;
862 if (ap->a_runp != NULL)
863 *ap->a_runp = 0;
864 if (ap->a_runb != NULL)
865 *ap->a_runb = 0;
866
867 return 0;
868 }
869
870 static int
871 dirfs_nremove(struct vop_nremove_args *ap)
872 {
873 dirfs_node_t dnp, pdnp;
874 dirfs_node_t pathnp;
875 dirfs_mount_t dmp;
876 struct vnode *dvp;
877 struct nchandle *nch;
878 struct namecache *ncp;
879 struct mount *mp;
880 struct vnode *vp;
881 int error;
882 char *tmp;
883 char *pathfree;
884
885 dbg(3, "called\n");
886
887 error = 0;
888 tmp = NULL;
889 vp = NULL;
890 dvp = ap->a_dvp;
891 nch = ap->a_nch;
892 ncp = nch->ncp;
893
894 mp = dvp->v_mount;
895 dmp = VFS_TO_DIRFS(mp);
896
897 lwkt_gettoken(&mp->mnt_token);
898 cache_vget(nch, ap->a_cred, LK_SHARED, &vp);
899 vn_unlock(vp);
900
901 pdnp = VP_TO_NODE(dvp);
902 dnp = VP_TO_NODE(vp);
903
904 if (vp->v_type == VDIR) {
905 error = EISDIR;
906 } else {
907 pathnp = dirfs_findfd(dmp, dnp, &tmp, &pathfree);
908 dirfs_node_lock(pdnp);
909 error = unlinkat(pathnp->dn_fd, tmp, 0);
910 if (error == 0) {
911 cache_unlink(nch);
912 dirfs_knote(vp, NOTE_DELETE);
913 dirfs_node_setpassive(dmp, dnp, 0);
914 if (dnp->dn_parent) {
915 dirfs_node_drop(dmp, dnp->dn_parent);
916 dnp->dn_parent = NULL;
917 }
918 } else {
919 error = errno;
920 }
921 dirfs_node_unlock(pdnp);
922 dirfs_dropfd(dmp, pathnp, pathfree);
923 }
924 dirfs_knote(dvp, NOTE_WRITE);
925 vrele(vp);
926 lwkt_reltoken(&mp->mnt_token);
927
928 KTR_LOG(dirfs_nremove, dnp, pdnp, error);
929
930 return error;
931 }
932
933 static int
934 dirfs_nlink(struct vop_nlink_args *ap)
935 {
936 dbg(3, "called\n");
937
938 KTR_LOG(dirfs_unsupported, __func__);
939
940 return EOPNOTSUPP;
941 }
942
943 static int
944 dirfs_nrename(struct vop_nrename_args *ap)
945 {
946 dirfs_node_t dnp, fdnp, tdnp;
947 dirfs_mount_t dmp;
948 struct namecache *fncp, *tncp;
949 struct vnode *fdvp, *tdvp, *vp;
950 struct mount *mp;
951 char *fpath, *fpathfree;
952 char *tpath, *tpathfree;
953 int error;
954
955 dbg(3, "called\n");
956
957 error = 0;
958 fdvp = ap->a_fdvp;
959 tdvp = ap->a_tdvp;
960 fncp = ap->a_fnch->ncp;
961 tncp = ap->a_tnch->ncp;
962 mp = fdvp->v_mount;
963 dmp = VFS_TO_DIRFS(mp);
964 fdnp = VP_TO_NODE(fdvp);
965 tdnp = VP_TO_NODE(tdvp);
966
967 dbg(9, "fdnp=%p tdnp=%p from=%s to=%s\n", fdnp, tdnp, fncp->nc_name,
968 tncp->nc_name);
969
970 if (fdvp->v_mount != tdvp->v_mount)
971 return(EXDEV);
972 if (fdvp->v_mount != fncp->nc_vp->v_mount)
973 return(EXDEV);
974 if (fdvp->v_mount->mnt_flag & MNT_RDONLY)
975 return (EROFS);
976
977 tpath = dirfs_node_absolute_path_plus(dmp, tdnp,
978 tncp->nc_name, &tpathfree);
979 fpath = dirfs_node_absolute_path_plus(dmp, fdnp,
980 fncp->nc_name, &fpathfree);
981 error = rename(fpath, tpath);
982 if (error < 0)
983 error = errno;
984 if (error == 0) {
985 vp = fncp->nc_vp; /* file being renamed */
986 dnp = VP_TO_NODE(vp);
987 dirfs_node_setname(dnp, tncp->nc_name, tncp->nc_nlen);
988 dirfs_knote(fdvp, NOTE_RENAME);
989 /*
990 * We have to mark the target file that was replaced by
991 * the rename as having been unlinked.
992 */
993 vp = tncp->nc_vp;
994 if (vp) {
995 dbg(9, "RENAME2\n");
996 dnp = VP_TO_NODE(vp);
997 cache_unlink(ap->a_tnch);
998 dirfs_knote(vp, NOTE_DELETE);
999 dirfs_node_setpassive(dmp, dnp, 0);
1000 if (dnp->dn_parent) {
1001 dirfs_node_drop(dmp, dnp->dn_parent);
1002 dnp->dn_parent = NULL;
1003 }
1004
1005 /*
1006 * nlinks on directories can be a bit weird. Zero
1007 * it out.
1008 */
1009 dnp->dn_links = 0;
1010 cache_inval_vp(vp, CINV_DESTROY);
1011 }
1012 cache_rename(ap->a_fnch, ap->a_tnch);
1013 dirfs_knote(fdvp, NOTE_WRITE);
1014 dirfs_knote(tdvp, NOTE_WRITE);
1015
1016 }
1017 dirfs_dropfd(dmp, NULL, fpathfree);
1018 dirfs_dropfd(dmp, NULL, tpathfree);
1019
1020 return error;
1021 }
1022
1023 static int
1024 dirfs_nmkdir(struct vop_nmkdir_args *ap)
1025 {
1026 dirfs_mount_t dmp;
1027 dirfs_node_t dnp, pdnp, dnp1;
1028 struct namecache *ncp;
1029 struct vattr *vap;
1030 struct vnode *dvp;
1031 struct vnode **vpp;
1032 char *tmp, *pathfree;
1033 char *path;
1034 int pfd, error;
1035 int extrapath;
1036
1037 dbg(3, "called\n");
1038
1039 extrapath = error = 0;
1040 dvp = ap->a_dvp;
1041 vpp = ap->a_vpp;
1042 dmp = VFS_TO_DIRFS(dvp->v_mount);
1043 pdnp = VP_TO_NODE(dvp);
1044 ncp = ap->a_nch->ncp;
1045 vap = ap->a_vap;
1046 pathfree = tmp = path = NULL;
1047 dnp = NULL;
1048
1049 dirfs_node_lock(pdnp);
1050 if (pdnp->dn_fd != DIRFS_NOFD) {
1051 pfd = pdnp->dn_fd;
1052 path = ncp->nc_name;
1053 } else {
1054 dnp1 = dirfs_findfd(dmp, pdnp, &tmp, &pathfree);
1055 pfd = dnp1->dn_fd;
1056 /* XXX check there is room to copy the path */
1057 path = kmalloc(MAXPATHLEN, M_DIRFS_MISC, M_ZERO | M_WAITOK);
1058 ksnprintf(path, MAXPATHLEN, "%s/%s", tmp, ncp->nc_name);
1059 extrapath = 1;
1060 dirfs_dropfd(dmp, dnp1, pathfree);
1061 }
1062
1063 error = mkdirat(pfd, path, vap->va_mode);
1064 if (error) {
1065 error = errno;
1066 } else { /* Directory has been made */
1067 error = dirfs_alloc_file(dmp, &dnp, pdnp, ncp, vpp,
1068 vap, O_DIRECTORY);
1069 if (error)
1070 error = errno;
1071 cache_setunresolved(ap->a_nch);
1072 cache_setvp(ap->a_nch, *vpp);
1073 dirfs_knote(dvp, NOTE_WRITE | NOTE_LINK);
1074 }
1075 dirfs_node_unlock(pdnp);
1076
1077 if (extrapath)
1078 kfree(path, M_DIRFS_MISC);
1079
1080 KTR_LOG(dirfs_nmkdir, pdnp, dnp, ncp->nc_name, error);
1081
1082 return error;
1083 }
1084
1085 static int
1086 dirfs_nrmdir(struct vop_nrmdir_args *ap)
1087 {
1088 dirfs_node_t dnp, pdnp;
1089 dirfs_mount_t dmp;
1090 struct vnode *dvp;
1091 struct nchandle *nch;
1092 struct namecache *ncp;
1093 struct mount *mp;
1094 struct vnode *vp;
1095 int error;
1096 char *tmp;
1097 char *pathfree;
1098
1099 dbg(3, "called\n");
1100
1101 error = 0;
1102 tmp = NULL;
1103 vp = NULL;
1104 dvp = ap->a_dvp;
1105 nch = ap->a_nch;
1106 ncp = nch->ncp;
1107
1108 mp = dvp->v_mount;
1109 dmp = VFS_TO_DIRFS(mp);
1110
1111 lwkt_gettoken(&mp->mnt_token);
1112 cache_vget(nch, ap->a_cred, LK_SHARED, &vp);
1113 vn_unlock(vp);
1114
1115 pdnp = VP_TO_NODE(dvp);
1116 dnp = VP_TO_NODE(vp);
1117
1118 if (vp->v_type != VDIR) {
1119 error = ENOTDIR;
1120 } else {
1121 tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
1122 dirfs_node_lock(pdnp);
1123 error = rmdir(tmp);
1124 if (error == 0) {
1125 cache_unlink(nch);
1126 dirfs_knote(dvp, NOTE_WRITE | NOTE_LINK);
1127 dirfs_node_setpassive(dmp, dnp, 0);
1128 if (dnp->dn_parent) {
1129 dirfs_node_drop(dmp, dnp->dn_parent);
1130 dnp->dn_parent = NULL;
1131 }
1132
1133 /*
1134 * nlinks on directories can be a bit weird. Zero
1135 * it out.
1136 */
1137 dnp->dn_links = 0;
1138 cache_inval_vp(vp, CINV_DESTROY);
1139 } else {
1140 error = errno;
1141 }
1142 dirfs_node_unlock(pdnp);
1143 dirfs_dropfd(dmp, NULL, pathfree);
1144 }
1145 vrele(vp);
1146 lwkt_reltoken(&mp->mnt_token);
1147
1148 KTR_LOG(dirfs_nrmdir, dnp, pdnp, error);
1149
1150 return error;
1151 }
1152
1153 static int
1154 dirfs_nsymlink(struct vop_nsymlink_args *ap)
1155 {
1156 dirfs_mount_t dmp;
1157 dirfs_node_t dnp, pdnp;
1158 struct mount *mp;
1159 struct namecache *ncp;
1160 struct vattr *vap;
1161 struct vnode *dvp;
1162 struct vnode **vpp;
1163 char *tmp, *pathfree;
1164 char *path;
1165 int error;
1166
1167 dbg(3, "called\n");
1168
1169 error = 0;
1170 dvp = ap->a_dvp;
1171 vpp = ap->a_vpp;
1172 mp = dvp->v_mount;
1173 dmp = VFS_TO_DIRFS(dvp->v_mount);
1174 pdnp = VP_TO_NODE(dvp);
1175 ncp = ap->a_nch->ncp;
1176 vap = ap->a_vap;
1177 pathfree = tmp = path = NULL;
1178 dnp = NULL;
1179
1180 lwkt_gettoken(&mp->mnt_token);
1181 vap->va_type = VLNK;
1182
1183 /* Find out the whole path of our new symbolic link */
1184 tmp = dirfs_node_absolute_path(dmp, pdnp, &pathfree);
1185 /* XXX check there is room to copy the path */
1186 path = kmalloc(MAXPATHLEN, M_DIRFS_MISC, M_ZERO | M_WAITOK);
1187 ksnprintf(path, MAXPATHLEN, "%s/%s", tmp, ncp->nc_name);
1188 dirfs_dropfd(dmp, NULL, pathfree);
1189
1190 error = symlink(ap->a_target, path);
1191 if (error) {
1192 error = errno;
1193 } else { /* Symlink has been made */
1194 error = dirfs_alloc_file(dmp, &dnp, pdnp, ncp, vpp,
1195 NULL, 0);
1196 if (error)
1197 error = errno;
1198 cache_setunresolved(ap->a_nch);
1199 cache_setvp(ap->a_nch, *vpp);
1200 dirfs_knote(*vpp, NOTE_WRITE);
1201 }
1202 dbg(5, "path=%s a_target=%s\n", path, ap->a_target);
1203
1204 KTR_LOG(dirfs_nsymlink, dnp, ap->a_target, path, error);
1205 kfree(path, M_DIRFS_MISC);
1206 lwkt_reltoken(&mp->mnt_token);
1207
1208 return error;
1209
1210 }
1211
1212 static int
1213 dirfs_readdir(struct vop_readdir_args *ap)
1214 {
1215
1216 struct dirent *dp, *dpn;
1217 off_t __unused **cookies = ap->a_cookies;
1218 int *ncookies = ap->a_ncookies;
1219 int bytes;
1220 char *buf;
1221 long base;
1222 struct vnode *vp = ap->a_vp;
1223 struct uio *uio;
1224 dirfs_node_t dnp;
1225 off_t startoff;
1226 off_t cnt;
1227 int error, r;
1228 size_t bufsiz;
1229 off_t curoff;
1230
1231 dbg(3, "called\n");
1232
1233 if (ncookies)
1234 debug(1, "ncookies=%d\n", *ncookies);
1235
1236 dnp = VP_TO_NODE(vp);
1237 uio = ap->a_uio;
1238 startoff = uio->uio_offset;
1239 cnt = 0;
1240 error = 0;
1241 base = 0;
1242 bytes = 0;
1243
1244 if (vp->v_type != VDIR)
1245 return ENOTDIR;
1246 if (uio->uio_resid < 0)
1247 return EINVAL;
1248 if ((bufsiz = uio->uio_resid) > 4096)
1249 bufsiz = 4096;
1250 buf = kmalloc(bufsiz, M_DIRFS_MISC, M_WAITOK | M_ZERO);
1251
1252 /*
1253 * Generally speaking we have to be able to process ALL the
1254 * entries returned by getdirentries() in order for the seek
1255 * position to be correct. For now try to size the buffer
1256 * to make this happen. A smaller buffer always works. For
1257 * now just use an appropriate size.
1258 */
1259 dirfs_node_lock(dnp);
1260 lseek(dnp->dn_fd, startoff, SEEK_SET);
1261 bytes = getdirentries(dnp->dn_fd, buf, bufsiz, &base);
1262 dbg(9, "seek %016jx %016jx %016jx\n",
1263 (intmax_t)startoff, (intmax_t)base,
1264 (intmax_t)lseek(dnp->dn_fd, 0, SEEK_CUR));
1265 if (bytes < 0) {
1266 if (errno == EINVAL)
1267 panic("EINVAL on readdir\n");
1268 error = errno;
1269 curoff = startoff;
1270 goto out;
1271 } else if (bytes == 0) {
1272 *ap->a_eofflag = 1;
1273 curoff = startoff;
1274 goto out;
1275 }
1276
1277 for (dp = (struct dirent *)buf; bytes > 0 && uio->uio_resid > 0;
1278 bytes -= _DIRENT_DIRSIZ(dp), dp = dpn) {
1279 r = vop_write_dirent(&error, uio, dp->d_ino, dp->d_type,
1280 dp->d_namlen, dp->d_name);
1281 if (error || r)
1282 break;
1283 dpn = _DIRENT_NEXT(dp);
1284 dp = dpn;
1285 cnt++;
1286 }
1287 curoff = lseek(dnp->dn_fd, 0, SEEK_CUR);
1288
1289 out:
1290 kfree(buf, M_DIRFS_MISC);
1291 uio->uio_offset = curoff;
1292 dirfs_node_unlock(dnp);
1293
1294 KTR_LOG(dirfs_readdir, dnp, dnp->dn_fd, startoff, uio->uio_offset);
1295
1296 return error;
1297 }
1298
1299 static int
1300 dirfs_readlink(struct vop_readlink_args *ap)
1301 {
1302 dirfs_node_t dnp, pathnp;
1303 dirfs_mount_t dmp;
1304 struct vnode *vp;
1305 struct mount *mp;
1306 struct uio *uio;
1307 char *tmp, *pathfree, *buf;
1308 ssize_t nlen;
1309 int error;
1310
1311 dbg(3, "called\n");
1312
1313 vp = ap->a_vp;
1314
1315 KKASSERT(vp->v_type == VLNK);
1316
1317 error = 0;
1318 tmp = pathfree = NULL;
1319 uio = ap->a_uio;
1320 mp = vp->v_mount;
1321 dmp = VFS_TO_DIRFS(mp);
1322 dnp = VP_TO_NODE(vp);
1323
1324 lwkt_gettoken(&mp->mnt_token);
1325
1326 pathnp = dirfs_findfd(dmp, dnp, &tmp, &pathfree);
1327
1328 buf = kmalloc(uio->uio_resid, M_DIRFS_MISC, M_WAITOK | M_ZERO);
1329 nlen = readlinkat(pathnp->dn_fd, dnp->dn_name, buf, uio->uio_resid);
1330 if (nlen == -1 ) {
1331 error = errno;
1332 } else {
1333 error = uiomove(buf, nlen + 1, uio);
1334 buf[nlen] = '\0';
1335 if (error)
1336 error = errno;
1337 }
1338 dirfs_dropfd(dmp, pathnp, pathfree);
1339 kfree(buf, M_DIRFS_MISC);
1340
1341 lwkt_reltoken(&mp->mnt_token);
1342
1343 return error;
1344 }
1345
1346 /*
1347 * Main tasks to be performed.
1348 * 1) When inode is NULL recycle the vnode
1349 * 2) When the inode has 0 links:
1350 * - Check if in the TAILQ, if so remove.
1351 * - Destroy the inode.
1352 * - Recycle the vnode.
1353 * 3) If none of the above, add the node to the TAILQ
1354 * when it has a valid fd and there is room on the
1355 * queue.
1356 *
1357 */
1358 static int
1359 dirfs_inactive(struct vop_inactive_args *ap)
1360 {
1361 struct vnode *vp;
1362 dirfs_mount_t dmp;
1363 dirfs_node_t dnp;
1364
1365 dbg(3, "called\n");
1366
1367 vp = ap->a_vp;
1368 dmp = VFS_TO_DIRFS(vp->v_mount);
1369 dnp = VP_TO_NODE(vp);
1370
1371 /* Degenerate case */
1372 if (dnp == NULL) {
1373 dbg(5, "dnp was NULL\n");
1374 vrecycle(vp);
1375 return 0;
1376 }
1377
1378 /*
1379 * Deal with the case the inode has 0 links which means it was unlinked.
1380 */
1381 if (dnp->dn_links == 0) {
1382 vrecycle(vp);
1383 dbg(5, "recycled a vnode of an unlinked dnp\n");
1384
1385 goto out;
1386 }
1387
1388 /*
1389 * Try to retain the fd in our fd cache.
1390 */
1391 dirfs_node_setpassive(dmp, dnp, 1);
1392 out:
1393
1394 return 0;
1395
1396 }
1397
1398 int
1399 dirfs_reclaim(struct vop_reclaim_args *ap)
1400 {
1401 struct vnode *vp;
1402 dirfs_node_t dnp;
1403 dirfs_mount_t dmp;
1404
1405 dbg(3, "called\n");
1406
1407 vp = ap->a_vp;
1408 dnp = VP_TO_NODE(vp);
1409 dmp = VFS_TO_DIRFS(vp->v_mount);
1410
1411 dirfs_free_vp(dmp, dnp);
1412 /* dnp is now invalid, may have been destroyed */
1413
1414 return 0;
1415 }
1416
1417 static int
1418 dirfs_mountctl(struct vop_mountctl_args *ap)
1419 {
1420 dbg(3, "called\n");
1421
1422 KTR_LOG(dirfs_unsupported, __func__);
1423
1424 return EOPNOTSUPP;
1425 }
1426
1427 static int
1428 dirfs_print(struct vop_print_args *v)
1429 {
1430 dbg(3, "called\n");
1431
1432 KTR_LOG(dirfs_unsupported, __func__);
1433
1434 return EOPNOTSUPP;
1435 }
1436
1437 static int __unused
1438 dirfs_pathconf(struct vop_pathconf_args *v)
1439 {
1440 dbg(3, "called\n");
1441
1442 return EOPNOTSUPP;
1443 }
1444
1445 /************************************************************************
1446 * KQFILTER OPS *
1447 ************************************************************************/
1448
1449 static void filt_dirfsdetach(struct knote *kn);
1450 static int filt_dirfsread(struct knote *kn, long hint);
1451 static int filt_dirfswrite(struct knote *kn, long hint);
1452 static int filt_dirfsvnode(struct knote *kn, long hint);
1453
1454 static struct filterops dirfsread_filtops =
1455 { FILTEROP_ISFD | FILTEROP_MPSAFE,
1456 NULL, filt_dirfsdetach, filt_dirfsread };
1457 static struct filterops dirfswrite_filtops =
1458 { FILTEROP_ISFD | FILTEROP_MPSAFE,
1459 NULL, filt_dirfsdetach, filt_dirfswrite };
1460 static struct filterops dirfsvnode_filtops =
1461 { FILTEROP_ISFD | FILTEROP_MPSAFE,
1462 NULL, filt_dirfsdetach, filt_dirfsvnode };
1463
1464 static int
1465 dirfs_kqfilter (struct vop_kqfilter_args *ap)
1466 {
1467 struct vnode *vp = ap->a_vp;
1468 struct knote *kn = ap->a_kn;
1469
1470 switch (kn->kn_filter) {
1471 case EVFILT_READ:
1472 kn->kn_fop = &dirfsread_filtops;
1473 break;
1474 case EVFILT_WRITE:
1475 kn->kn_fop = &dirfswrite_filtops;
1476 break;
1477 case EVFILT_VNODE:
1478 kn->kn_fop = &dirfsvnode_filtops;
1479 break;
1480 default:
1481 return (EOPNOTSUPP);
1482 }
1483
1484 kn->kn_hook = (caddr_t)vp;
1485
1486 knote_insert(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
1487
1488 return(0);
1489 }
1490
1491 static void
1492 filt_dirfsdetach(struct knote *kn)
1493 {
1494 struct vnode *vp = (void *)kn->kn_hook;
1495
1496 knote_remove(&vp->v_pollinfo.vpi_kqinfo.ki_note, kn);
1497 }
1498
1499 static int
1500 filt_dirfsread(struct knote *kn, long hint)
1501 {
1502 struct vnode *vp = (void *)kn->kn_hook;
1503 dirfs_node_t dnp = VP_TO_NODE(vp);
1504 off_t off;
1505
1506 if (hint == NOTE_REVOKE) {
1507 kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
1508 return(1);
1509 }
1510
1511 /*
1512 * Interlock against MP races when performing this function.
1513 */
1514 dirfs_node_lock(dnp);
1515 off = dnp->dn_size - kn->kn_fp->f_offset;
1516 kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
1517 if (kn->kn_sfflags & NOTE_OLDAPI) {
1518 dirfs_node_unlock(dnp);
1519 return(1);
1520 }
1521 if (kn->kn_data == 0) {
1522 kn->kn_data = (off < INTPTR_MAX) ? off : INTPTR_MAX;
1523 }
1524 dirfs_node_unlock(dnp);
1525 return (kn->kn_data != 0);
1526 }
1527
1528 static int
1529 filt_dirfswrite(struct knote *kn, long hint)
1530 {
1531 if (hint == NOTE_REVOKE)
1532 kn->kn_flags |= (EV_EOF | EV_NODATA | EV_ONESHOT);
1533 kn->kn_data = 0;
1534 return (1);
1535 }
1536
1537 static int
1538 filt_dirfsvnode(struct knote *kn, long hint)
1539 {
1540 if (kn->kn_sfflags & hint)
1541 kn->kn_fflags |= hint;
1542 if (hint == NOTE_REVOKE) {
1543 kn->kn_flags |= (EV_EOF | EV_NODATA);
1544 return (1);
1545 }
1546 return (kn->kn_fflags != 0);
1547 }
1548
1549
1550 /* --------------------------------------------------------------------- */
1551
1552 struct vop_ops dirfs_vnode_vops = {
1553 .vop_default = vop_defaultop,
1554 .vop_nwhiteout = vop_compat_nwhiteout,
1555 .vop_ncreate = dirfs_ncreate,
1556 .vop_nresolve = dirfs_nresolve,
1557 .vop_markatime = vop_stdmarkatime,
1558 .vop_nlookupdotdot = dirfs_nlookupdotdot,
1559 .vop_nmknod = dirfs_nmknod,
1560 .vop_open = dirfs_open,
1561 .vop_close = dirfs_close,
1562 .vop_access = dirfs_access,
1563 .vop_getattr = dirfs_getattr,
1564 .vop_setattr = dirfs_setattr,
1565 .vop_read = dirfs_read,
1566 .vop_write = dirfs_write,
1567 .vop_fsync = dirfs_fsync,
1568 .vop_mountctl = dirfs_mountctl,
1569 .vop_nremove = dirfs_nremove,
1570 .vop_nlink = dirfs_nlink,
1571 .vop_nrename = dirfs_nrename,
1572 .vop_nmkdir = dirfs_nmkdir,
1573 .vop_nrmdir = dirfs_nrmdir,
1574 .vop_nsymlink = dirfs_nsymlink,
1575 .vop_readdir = dirfs_readdir,
1576 .vop_readlink = dirfs_readlink,
1577 .vop_inactive = dirfs_inactive,
1578 .vop_reclaim = dirfs_reclaim,
1579 .vop_print = dirfs_print,
1580 .vop_pathconf = vop_stdpathconf,
1581 .vop_bmap = dirfs_bmap,
1582 .vop_strategy = dirfs_strategy,
1583 .vop_advlock = dirfs_advlock,
1584 .vop_kqfilter = dirfs_kqfilter,
1585 .vop_getpages = vop_stdgetpages,
1586 .vop_putpages = vop_stdputpages
1587 };
DragonFly BSD