VFS messaging/interfacing work stage 7f/99: More firming up of stage 7.
[dragonfly.git] / sys / kern / vfs_default.c
1 /*
2  * Copyright (c) 1989, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed
6  * to Berkeley by John Heidemann of the UCLA Ficus project.
7  *
8  * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *
39  * $FreeBSD: src/sys/kern/vfs_default.c,v 1.28.2.7 2003/01/10 18:23:26 bde Exp $
40  * $DragonFly: src/sys/kern/vfs_default.c,v 1.19 2004/10/07 04:20:26 dillon Exp $
41  */
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/buf.h>
46 #include <sys/conf.h>
47 #include <sys/kernel.h>
48 #include <sys/lock.h>
49 #include <sys/malloc.h>
50 #include <sys/mount.h>
51 #include <sys/unistd.h>
52 #include <sys/vnode.h>
53 #include <sys/namei.h>
54 #include <sys/poll.h>
55
56 #include <machine/limits.h>
57
58 #include <vm/vm.h>
59 #include <vm/vm_object.h>
60 #include <vm/vm_page.h>
61 #include <vm/vm_pager.h>
62 #include <vm/vnode_pager.h>
63
64 static int      vop_nolookup (struct vop_lookup_args *);
65 static int      vop_nostrategy (struct vop_strategy_args *);
66
67 /*
68  * This vnode table stores what we want to do if the filesystem doesn't
69  * implement a particular VOP.
70  *
71  * If there is no specific entry here, we will return EOPNOTSUPP.
72  */
73 struct vop_ops *default_vnode_vops;
74 static struct vnodeopv_entry_desc default_vnodeop_entries[] = {
75         { &vop_default_desc,            vop_eopnotsupp },
76         { &vop_advlock_desc,            vop_einval },
77         { &vop_bwrite_desc,             (void *) vop_stdbwrite },
78         { &vop_close_desc,              vop_null },
79         { &vop_createvobject_desc,      (void *) vop_stdcreatevobject },
80         { &vop_destroyvobject_desc,     (void *) vop_stddestroyvobject },
81         { &vop_fsync_desc,              vop_null },
82         { &vop_getvobject_desc,         (void *) vop_stdgetvobject },
83         { &vop_ioctl_desc,              vop_enotty },
84         { &vop_islocked_desc,           (void *) vop_stdislocked },
85         { &vop_lease_desc,              vop_null },
86         { &vop_lock_desc,               (void *) vop_stdlock },
87         { &vop_mmap_desc,               vop_einval },
88         { &vop_resolve_desc,            (void *) vop_noresolve },
89         { &vop_lookup_desc,             (void *) vop_nolookup },
90         { &vop_open_desc,               vop_null },
91         { &vop_pathconf_desc,           vop_einval },
92         { &vop_poll_desc,               (void *) vop_nopoll },
93         { &vop_readlink_desc,           vop_einval },
94         { &vop_reallocblks_desc,        vop_eopnotsupp },
95         { &vop_revoke_desc,             (void *) vop_stdrevoke },
96         { &vop_strategy_desc,           (void *) vop_nostrategy },
97         { &vop_unlock_desc,             (void *) vop_stdunlock },
98         { &vop_getacl_desc,             vop_eopnotsupp },
99         { &vop_setacl_desc,             vop_eopnotsupp },
100         { &vop_aclcheck_desc,           vop_eopnotsupp },
101         { &vop_getextattr_desc,         vop_eopnotsupp },
102         { &vop_setextattr_desc,         vop_eopnotsupp },
103         { NULL, NULL }
104 };
105
106 static struct vnodeopv_desc default_vnodeop_opv_desc =
107         { &default_vnode_vops, default_vnodeop_entries };
108
109 VNODEOP_SET(default_vnodeop_opv_desc);
110
111 int
112 vop_eopnotsupp(struct vop_generic_args *ap)
113 {
114         return (EOPNOTSUPP);
115 }
116
117 int
118 vop_ebadf(struct vop_generic_args *ap)
119 {
120         return (EBADF);
121 }
122
123 int
124 vop_enotty(struct vop_generic_args *ap)
125 {
126         return (ENOTTY);
127 }
128
129 int
130 vop_einval(struct vop_generic_args *ap)
131 {
132         return (EINVAL);
133 }
134
135 int
136 vop_null(struct vop_generic_args *ap)
137 {
138         return (0);
139 }
140
141 int
142 vop_defaultop(struct vop_generic_args *ap)
143 {
144         return (VOCALL(default_vnode_vops, ap));
145 }
146
147 int
148 vop_panic(struct vop_generic_args *ap)
149 {
150
151         panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
152 }
153
154 /*
155  * vop_noresolve { struct namecache *a_ncp }    XXX STOPGAP FUNCTION
156  *
157  * XXX OLD API ROUTINE!  WHEN ALL VFSs HAVE BEEN CLEANED UP THIS PROCEDURE
158  * WILL BE REMOVED.  This procedure exists for all VFSs which have not
159  * yet implemented vop_resolve().  It converts vop_resolve() into a 
160  * vop_lookup() and does appropriate translations.
161  *
162  * Resolve a ncp for VFSs which do not support the VOP.  Eventually all
163  * VFSs will support this VOP and this routine can be removed, since
164  * vop_resolve() is far less complex then the older LOOKUP/CACHEDLOOKUP
165  * API.
166  *
167  * A locked ncp is passed in to be resolved.  The NCP is resolved by
168  * figuring out the vnode (if any) and calling cache_setvp() to attach the
169  * vnode to the entry.  If the entry represents a non-existant node then
170  * cache_setvp() is called with a NULL vnode to resolve the entry into a
171  * negative cache entry.  No vnode locks are retained and the
172  * ncp is left locked on return.
173  *
174  * There is a potential directory and vnode interlock.   The lock order
175  * requirement is: namecache, governing directory, resolved vnode.
176  */
177 int
178 vop_noresolve(struct vop_resolve_args *ap)
179 {
180         int error;
181         struct vnode *dvp;
182         struct vnode *vp;
183         struct namecache *ncp;
184         struct componentname cnp;
185
186         ncp = ap->a_ncp;        /* locked namecache node */
187         if (ncp->nc_flag & NCF_MOUNTPT) /* can't cross a mount point! */
188                 return(EPERM);
189         if (ncp->nc_parent == NULL)
190                 return(EPERM);
191         if ((dvp = ncp->nc_parent->nc_vp) == NULL)
192                 return(EPERM);
193
194         vget(dvp, NULL, LK_EXCLUSIVE, curthread);
195
196         bzero(&cnp, sizeof(cnp));
197         cnp.cn_nameiop = NAMEI_LOOKUP;
198         cnp.cn_flags = CNP_ISLASTCN;
199         cnp.cn_nameptr = ncp->nc_name;
200         cnp.cn_namelen = ncp->nc_nlen;
201         cnp.cn_cred = ap->a_cred;
202         cnp.cn_td = curthread; /* XXX */
203
204         /*
205          * vop_lookup() always returns vp locked.  dvp may or may not be
206          * left locked depending on CNP_PDIRUNLOCK.
207          */
208         error = vop_lookup(ap->a_head.a_ops, dvp, &vp, &cnp);
209         if (error == 0)
210                 VOP_UNLOCK(vp, NULL, 0, curthread);
211         if ((cnp.cn_flags & CNP_PDIRUNLOCK) == 0)
212                 VOP_UNLOCK(dvp, NULL, 0, curthread);
213         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
214                 /* was resolved by another process while we were unlocked */
215                 if (error == 0)
216                         vrele(vp);
217         } else if (error == 0) {
218                 KKASSERT(vp != NULL);
219                 cache_setvp(ncp, vp);
220                 vrele(vp);
221         } else if (error == ENOENT) {
222                 KKASSERT(vp == NULL);
223                 if (cnp.cn_flags & CNP_ISWHITEOUT)
224                         ncp->nc_flag |= NCF_WHITEOUT;
225                 cache_setvp(ncp, NULL);
226         }
227         vrele(dvp);
228         return (error);
229 }
230
231 #if 0
232
233 /*
234  * vop_noremove { struct namecache *a_ncp }     XXX STOPGAP FUNCTION
235  *
236  * Remove the file/dir represented by a_ncp.
237  *
238  * XXX ultra difficult.  A number of existing filesystems, including UFS,
239  *     assume that the directory will remain locked and the lookup will
240  *     store the directory offset and other things in the directory inode
241  *     for the later VOP_REMOVE to use.  We have to move all that
242  *     functionality into e.g. UFS's VOP_REMOVE itself.
243  */
244 static int
245 vop_nonremove(struct vop_nremove_args *ap)
246 {
247         struct namecache *ncfile;
248         struct namecache *ncdir;
249         struct componentname cnd;
250         struct vnode *vp;
251         struct vnode *vpd;
252         thread_t td;
253         int error;
254
255         td = curthread;
256         ncfile = ap->a_ncp;
257         ncdir = ncfile->nc_parent;
258
259         if ((error = cache_vget(ncdir, ap->a_cred, LK_EXCLUSIVE, &vpd)) != 0)
260                 return (error);
261         if ((error = cache_vget(ncfile, ap->a_cred, LK_EXCLUSIVE, &vp)) != 0) {
262                 vput(vpd);
263                 return (error);
264         }
265         bzero(&cnd, sizeof(cnd));
266         cnd.cn_nameiop = NAMEI_DELETE;
267         cnd.cn_td = td;
268         cnd.cn_cred = ap->a_cred;
269         cnd.cn_nameptr = ncfile->nc_name;
270         cnd.cn_namelen = ncfile->nc_nlen;
271         error = VOP_REMOVE(vpd, NCPNULL, vp, &cnd);
272         if (error == 0)
273                 cache_purge(vp);
274         vput(vp);
275         vput(vpd);
276
277         /*
278          * Re-resolve the ncp to match the fact that the file has been
279          * deleted from the namespace.  If an error occured leave the ncp
280          * unresolved (meaning that we have no idea what the correct state
281          * is).
282          */
283         if (error == 0) {
284                 cache_setunresolved(ncfile);
285                 cache_setvp(ncfile, NULL);
286         }
287         return (error);
288 }
289
290 #endif
291
292
293 static int
294 vop_nolookup(ap)
295         struct vop_lookup_args /* {
296                 struct vnode *a_dvp;
297                 struct vnode **a_vpp;
298                 struct componentname *a_cnp;
299         } */ *ap;
300 {
301
302         *ap->a_vpp = NULL;
303         return (ENOTDIR);
304 }
305
306 /*
307  *      vop_nostrategy:
308  *
309  *      Strategy routine for VFS devices that have none.
310  *
311  *      B_ERROR and B_INVAL must be cleared prior to calling any strategy
312  *      routine.  Typically this is done for a B_READ strategy call.  Typically
313  *      B_INVAL is assumed to already be clear prior to a write and should not
314  *      be cleared manually unless you just made the buffer invalid.  B_ERROR
315  *      should be cleared either way.
316  */
317
318 static int
319 vop_nostrategy (struct vop_strategy_args *ap)
320 {
321         printf("No strategy for buffer at %p\n", ap->a_bp);
322         vprint("", ap->a_vp);
323         vprint("", ap->a_bp->b_vp);
324         ap->a_bp->b_flags |= B_ERROR;
325         ap->a_bp->b_error = EOPNOTSUPP;
326         biodone(ap->a_bp);
327         return (EOPNOTSUPP);
328 }
329
330 int
331 vop_stdpathconf(ap)
332         struct vop_pathconf_args /* {
333         struct vnode *a_vp;
334         int a_name;
335         int *a_retval;
336         } */ *ap;
337 {
338
339         switch (ap->a_name) {
340                 case _PC_LINK_MAX:
341                         *ap->a_retval = LINK_MAX;
342                         return (0);
343                 case _PC_MAX_CANON:
344                         *ap->a_retval = MAX_CANON;
345                         return (0);
346                 case _PC_MAX_INPUT:
347                         *ap->a_retval = MAX_INPUT;
348                         return (0);
349                 case _PC_PIPE_BUF:
350                         *ap->a_retval = PIPE_BUF;
351                         return (0);
352                 case _PC_CHOWN_RESTRICTED:
353                         *ap->a_retval = 1;
354                         return (0);
355                 case _PC_VDISABLE:
356                         *ap->a_retval = _POSIX_VDISABLE;
357                         return (0);
358                 default:
359                         return (EINVAL);
360         }
361         /* NOTREACHED */
362 }
363
364 /*
365  * Standard lock.  The lock is recursive-capable only if the lock was
366  * initialized with LK_CANRECURSE or that flag is passed in a_flags.
367  */
368 int
369 vop_stdlock(ap)
370         struct vop_lock_args /* {
371                 struct vnode *a_vp;
372                 lwkt_tokref_t a_vlock;
373                 int a_flags;
374                 struct proc *a_p;
375         } */ *ap;
376 {               
377         int error;
378
379 #ifndef DEBUG_LOCKS
380         error = lockmgr(&ap->a_vp->v_lock, ap->a_flags,
381                         ap->a_vlock, ap->a_td);
382 #else
383         error = debuglockmgr(&ap->a_vp->v_lock, ap->a_flags,
384                         ap->a_vlock, ap->a_td,
385                         "vop_stdlock", ap->a_vp->filename, ap->a_vp->line);
386 #endif
387         return(error);
388 }
389
390 int
391 vop_stdunlock(ap)
392         struct vop_unlock_args /* {
393                 struct vnode *a_vp;
394                 lwkt_tokref_t a_vlock;
395                 int a_flags;
396                 struct thread *a_td;
397         } */ *ap;
398 {
399         int error;
400
401         error = lockmgr(&ap->a_vp->v_lock, ap->a_flags | LK_RELEASE,
402                         ap->a_vlock, ap->a_td);
403         return(error);
404 }
405
406 int
407 vop_stdislocked(ap)
408         struct vop_islocked_args /* {
409                 struct vnode *a_vp;
410                 struct thread *a_td;
411         } */ *ap;
412 {
413         return (lockstatus(&ap->a_vp->v_lock, ap->a_td));
414 }
415
416 /*
417  * Return true for select/poll.
418  */
419 int
420 vop_nopoll(ap)
421         struct vop_poll_args /* {
422                 struct vnode *a_vp;
423                 int  a_events;
424                 struct ucred *a_cred;
425                 struct proc *a_p;
426         } */ *ap;
427 {
428         /*
429          * Return true for read/write.  If the user asked for something
430          * special, return POLLNVAL, so that clients have a way of
431          * determining reliably whether or not the extended
432          * functionality is present without hard-coding knowledge
433          * of specific filesystem implementations.
434          */
435         if (ap->a_events & ~POLLSTANDARD)
436                 return (POLLNVAL);
437
438         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
439 }
440
441 /*
442  * Implement poll for local filesystems that support it.
443  */
444 int
445 vop_stdpoll(ap)
446         struct vop_poll_args /* {
447                 struct vnode *a_vp;
448                 int  a_events;
449                 struct ucred *a_cred;
450                 struct thread *a_td;
451         } */ *ap;
452 {
453         if (ap->a_events & ~POLLSTANDARD)
454                 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
455         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
456 }
457
458 int
459 vop_stdbwrite(ap)
460         struct vop_bwrite_args *ap;
461 {
462         return (bwrite(ap->a_bp));
463 }
464
465 int
466 vop_stdcreatevobject(ap)
467         struct vop_createvobject_args /* {
468                 struct vnode *a_vp;
469                 struct proc *a_td;
470         } */ *ap;
471 {
472         struct vnode *vp = ap->a_vp;
473         struct thread *td = ap->a_td;
474         struct vattr vat;
475         vm_object_t object;
476         int error = 0;
477
478         if (!vn_isdisk(vp, NULL) && vn_canvmio(vp) == FALSE)
479                 return (0);
480
481 retry:
482         if ((object = vp->v_object) == NULL) {
483                 if (vp->v_type == VREG || vp->v_type == VDIR) {
484                         if ((error = VOP_GETATTR(vp, &vat, td)) != 0)
485                                 goto retn;
486                         object = vnode_pager_alloc(vp, vat.va_size, 0, 0);
487                 } else if (vp->v_rdev && dev_is_good(vp->v_rdev)) {
488                         /*
489                          * XXX v_rdev uses NULL/non-NULL instead of NODEV
490                          *
491                          * This simply allocates the biggest object possible
492                          * for a disk vnode.  This should be fixed, but doesn't
493                          * cause any problems (yet).
494                          */
495                         object = vnode_pager_alloc(vp, IDX_TO_OFF(INT_MAX), 0, 0);
496                 } else {
497                         goto retn;
498                 }
499                 /*
500                  * Dereference the reference we just created.  This assumes
501                  * that the object is associated with the vp.
502                  */
503                 object->ref_count--;
504                 vp->v_usecount--;
505         } else {
506                 if (object->flags & OBJ_DEAD) {
507                         VOP_UNLOCK(vp, NULL, 0, td);
508                         tsleep(object, 0, "vodead", 0);
509                         vn_lock(vp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
510                         goto retry;
511                 }
512         }
513
514         KASSERT(vp->v_object != NULL, ("vfs_object_create: NULL object"));
515         vp->v_flag |= VOBJBUF;
516
517 retn:
518         return (error);
519 }
520
521 int
522 vop_stddestroyvobject(ap)
523         struct vop_destroyvobject_args /* {
524                 struct vnode *vp;
525         } */ *ap;
526 {
527         struct vnode *vp = ap->a_vp;
528         vm_object_t obj = vp->v_object;
529
530         if (vp->v_object == NULL)
531                 return (0);
532
533         if (obj->ref_count == 0) {
534                 /*
535                  * vclean() may be called twice. The first time
536                  * removes the primary reference to the object,
537                  * the second time goes one further and is a
538                  * special-case to terminate the object.
539                  *
540                  * don't double-terminate the object.
541                  */
542                 if ((obj->flags & OBJ_DEAD) == 0)
543                         vm_object_terminate(obj);
544         } else {
545                 /*
546                  * Woe to the process that tries to page now :-).
547                  */
548                 vm_pager_deallocate(obj);
549         }
550         return (0);
551 }
552
553 /*
554  * Return the underlying VM object.  This routine may be called with or
555  * without the vnode interlock held.  If called without, the returned
556  * object is not guarenteed to be valid.  The syncer typically gets the
557  * object without holding the interlock in order to quickly test whether
558  * it might be dirty before going heavy-weight.  vm_object's use zalloc
559  * and thus stable-storage, so this is safe.
560  */
561 int
562 vop_stdgetvobject(ap)
563         struct vop_getvobject_args /* {
564                 struct vnode *vp;
565                 struct vm_object **objpp;
566         } */ *ap;
567 {
568         struct vnode *vp = ap->a_vp;
569         struct vm_object **objpp = ap->a_objpp;
570
571         if (objpp)
572                 *objpp = vp->v_object;
573         return (vp->v_object ? 0 : EINVAL);
574 }
575
576 /* 
577  * vfs default ops
578  * used to fill the vfs fucntion table to get reasonable default return values.
579  */
580 int 
581 vfs_stdmount(struct mount *mp, char *path, caddr_t data,
582         struct nameidata *ndp, struct thread *td)
583 {
584         return (0);
585 }
586
587 int     
588 vfs_stdunmount(struct mount *mp, int mntflags, struct thread *td)
589 {
590         return (0);
591 }
592
593 int     
594 vfs_stdroot(struct mount *mp, struct vnode **vpp)
595 {
596         return (EOPNOTSUPP);
597 }
598
599 int     
600 vfs_stdstatfs(struct mount *mp, struct statfs *sbp, struct thread *td)
601 {
602         return (EOPNOTSUPP);
603 }
604
605 int
606 vfs_stdvptofh(struct vnode *vp, struct fid *fhp)
607 {
608         return (EOPNOTSUPP);
609 }
610
611 int     
612 vfs_stdstart(struct mount *mp, int flags, struct thread *td)
613 {
614         return (0);
615 }
616
617 int     
618 vfs_stdquotactl(struct mount *mp, int cmds, uid_t uid,
619         caddr_t arg, struct thread *td)
620 {
621         return (EOPNOTSUPP);
622 }
623
624 int     
625 vfs_stdsync(struct mount *mp, int waitfor, struct thread *td)
626 {
627         return (0);
628 }
629
630 int     
631 vfs_stdvget(struct mount *mp, ino_t ino, struct vnode **vpp)
632 {
633         return (EOPNOTSUPP);
634 }
635
636 int     
637 vfs_stdfhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
638 {
639         return (EOPNOTSUPP);
640 }
641
642 int 
643 vfs_stdcheckexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
644         struct ucred **credanonp)
645 {
646         return (EOPNOTSUPP);
647 }
648
649 int
650 vfs_stdinit(struct vfsconf *vfsp)
651 {
652         return (0);
653 }
654
655 int
656 vfs_stduninit(struct vfsconf *vfsp)
657 {
658         return(0);
659 }
660
661 int
662 vfs_stdextattrctl(struct mount *mp, int cmd, const char *attrname,
663         caddr_t arg, struct thread *td)
664 {
665         return(EOPNOTSUPP);
666 }
667
668 /* end of vfs default ops */