VFS messaging/interfacing work stage 8a/99: Sync other filesystems to 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.18 2004/10/07 01:13:10 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         vput(vp);
273         vput(vpd);
274
275         /*
276          * Re-resolve the ncp to match the fact that the file has been
277          * deleted from the namespace.  If an error occured leave the ncp
278          * unresolved (meaning that we have no idea what the correct state
279          * is).
280          */
281         cache_setunresolved(ncfile);
282         if (error == 0)
283                 cache_setvp(ncfile, NULL);
284         return (error);
285 }
286
287 #endif
288
289
290 static int
291 vop_nolookup(ap)
292         struct vop_lookup_args /* {
293                 struct vnode *a_dvp;
294                 struct vnode **a_vpp;
295                 struct componentname *a_cnp;
296         } */ *ap;
297 {
298
299         *ap->a_vpp = NULL;
300         return (ENOTDIR);
301 }
302
303 /*
304  *      vop_nostrategy:
305  *
306  *      Strategy routine for VFS devices that have none.
307  *
308  *      B_ERROR and B_INVAL must be cleared prior to calling any strategy
309  *      routine.  Typically this is done for a B_READ strategy call.  Typically
310  *      B_INVAL is assumed to already be clear prior to a write and should not
311  *      be cleared manually unless you just made the buffer invalid.  B_ERROR
312  *      should be cleared either way.
313  */
314
315 static int
316 vop_nostrategy (struct vop_strategy_args *ap)
317 {
318         printf("No strategy for buffer at %p\n", ap->a_bp);
319         vprint("", ap->a_vp);
320         vprint("", ap->a_bp->b_vp);
321         ap->a_bp->b_flags |= B_ERROR;
322         ap->a_bp->b_error = EOPNOTSUPP;
323         biodone(ap->a_bp);
324         return (EOPNOTSUPP);
325 }
326
327 int
328 vop_stdpathconf(ap)
329         struct vop_pathconf_args /* {
330         struct vnode *a_vp;
331         int a_name;
332         int *a_retval;
333         } */ *ap;
334 {
335
336         switch (ap->a_name) {
337                 case _PC_LINK_MAX:
338                         *ap->a_retval = LINK_MAX;
339                         return (0);
340                 case _PC_MAX_CANON:
341                         *ap->a_retval = MAX_CANON;
342                         return (0);
343                 case _PC_MAX_INPUT:
344                         *ap->a_retval = MAX_INPUT;
345                         return (0);
346                 case _PC_PIPE_BUF:
347                         *ap->a_retval = PIPE_BUF;
348                         return (0);
349                 case _PC_CHOWN_RESTRICTED:
350                         *ap->a_retval = 1;
351                         return (0);
352                 case _PC_VDISABLE:
353                         *ap->a_retval = _POSIX_VDISABLE;
354                         return (0);
355                 default:
356                         return (EINVAL);
357         }
358         /* NOTREACHED */
359 }
360
361 /*
362  * Standard lock.  The lock is recursive-capable only if the lock was
363  * initialized with LK_CANRECURSE or that flag is passed in a_flags.
364  */
365 int
366 vop_stdlock(ap)
367         struct vop_lock_args /* {
368                 struct vnode *a_vp;
369                 lwkt_tokref_t a_vlock;
370                 int a_flags;
371                 struct proc *a_p;
372         } */ *ap;
373 {               
374         int error;
375
376 #ifndef DEBUG_LOCKS
377         error = lockmgr(&ap->a_vp->v_lock, ap->a_flags,
378                         ap->a_vlock, ap->a_td);
379 #else
380         error = debuglockmgr(&ap->a_vp->v_lock, ap->a_flags,
381                         ap->a_vlock, ap->a_td,
382                         "vop_stdlock", ap->a_vp->filename, ap->a_vp->line);
383 #endif
384         return(error);
385 }
386
387 int
388 vop_stdunlock(ap)
389         struct vop_unlock_args /* {
390                 struct vnode *a_vp;
391                 lwkt_tokref_t a_vlock;
392                 int a_flags;
393                 struct thread *a_td;
394         } */ *ap;
395 {
396         int error;
397
398         error = lockmgr(&ap->a_vp->v_lock, ap->a_flags | LK_RELEASE,
399                         ap->a_vlock, ap->a_td);
400         return(error);
401 }
402
403 int
404 vop_stdislocked(ap)
405         struct vop_islocked_args /* {
406                 struct vnode *a_vp;
407                 struct thread *a_td;
408         } */ *ap;
409 {
410         return (lockstatus(&ap->a_vp->v_lock, ap->a_td));
411 }
412
413 /*
414  * Return true for select/poll.
415  */
416 int
417 vop_nopoll(ap)
418         struct vop_poll_args /* {
419                 struct vnode *a_vp;
420                 int  a_events;
421                 struct ucred *a_cred;
422                 struct proc *a_p;
423         } */ *ap;
424 {
425         /*
426          * Return true for read/write.  If the user asked for something
427          * special, return POLLNVAL, so that clients have a way of
428          * determining reliably whether or not the extended
429          * functionality is present without hard-coding knowledge
430          * of specific filesystem implementations.
431          */
432         if (ap->a_events & ~POLLSTANDARD)
433                 return (POLLNVAL);
434
435         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
436 }
437
438 /*
439  * Implement poll for local filesystems that support it.
440  */
441 int
442 vop_stdpoll(ap)
443         struct vop_poll_args /* {
444                 struct vnode *a_vp;
445                 int  a_events;
446                 struct ucred *a_cred;
447                 struct thread *a_td;
448         } */ *ap;
449 {
450         if (ap->a_events & ~POLLSTANDARD)
451                 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
452         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
453 }
454
455 int
456 vop_stdbwrite(ap)
457         struct vop_bwrite_args *ap;
458 {
459         return (bwrite(ap->a_bp));
460 }
461
462 int
463 vop_stdcreatevobject(ap)
464         struct vop_createvobject_args /* {
465                 struct vnode *a_vp;
466                 struct proc *a_td;
467         } */ *ap;
468 {
469         struct vnode *vp = ap->a_vp;
470         struct thread *td = ap->a_td;
471         struct vattr vat;
472         vm_object_t object;
473         int error = 0;
474
475         if (!vn_isdisk(vp, NULL) && vn_canvmio(vp) == FALSE)
476                 return (0);
477
478 retry:
479         if ((object = vp->v_object) == NULL) {
480                 if (vp->v_type == VREG || vp->v_type == VDIR) {
481                         if ((error = VOP_GETATTR(vp, &vat, td)) != 0)
482                                 goto retn;
483                         object = vnode_pager_alloc(vp, vat.va_size, 0, 0);
484                 } else if (vp->v_rdev && dev_is_good(vp->v_rdev)) {
485                         /*
486                          * XXX v_rdev uses NULL/non-NULL instead of NODEV
487                          *
488                          * This simply allocates the biggest object possible
489                          * for a disk vnode.  This should be fixed, but doesn't
490                          * cause any problems (yet).
491                          */
492                         object = vnode_pager_alloc(vp, IDX_TO_OFF(INT_MAX), 0, 0);
493                 } else {
494                         goto retn;
495                 }
496                 /*
497                  * Dereference the reference we just created.  This assumes
498                  * that the object is associated with the vp.
499                  */
500                 object->ref_count--;
501                 vp->v_usecount--;
502         } else {
503                 if (object->flags & OBJ_DEAD) {
504                         VOP_UNLOCK(vp, NULL, 0, td);
505                         tsleep(object, 0, "vodead", 0);
506                         vn_lock(vp, NULL, LK_EXCLUSIVE | LK_RETRY, td);
507                         goto retry;
508                 }
509         }
510
511         KASSERT(vp->v_object != NULL, ("vfs_object_create: NULL object"));
512         vp->v_flag |= VOBJBUF;
513
514 retn:
515         return (error);
516 }
517
518 int
519 vop_stddestroyvobject(ap)
520         struct vop_destroyvobject_args /* {
521                 struct vnode *vp;
522         } */ *ap;
523 {
524         struct vnode *vp = ap->a_vp;
525         vm_object_t obj = vp->v_object;
526
527         if (vp->v_object == NULL)
528                 return (0);
529
530         if (obj->ref_count == 0) {
531                 /*
532                  * vclean() may be called twice. The first time
533                  * removes the primary reference to the object,
534                  * the second time goes one further and is a
535                  * special-case to terminate the object.
536                  *
537                  * don't double-terminate the object.
538                  */
539                 if ((obj->flags & OBJ_DEAD) == 0)
540                         vm_object_terminate(obj);
541         } else {
542                 /*
543                  * Woe to the process that tries to page now :-).
544                  */
545                 vm_pager_deallocate(obj);
546         }
547         return (0);
548 }
549
550 /*
551  * Return the underlying VM object.  This routine may be called with or
552  * without the vnode interlock held.  If called without, the returned
553  * object is not guarenteed to be valid.  The syncer typically gets the
554  * object without holding the interlock in order to quickly test whether
555  * it might be dirty before going heavy-weight.  vm_object's use zalloc
556  * and thus stable-storage, so this is safe.
557  */
558 int
559 vop_stdgetvobject(ap)
560         struct vop_getvobject_args /* {
561                 struct vnode *vp;
562                 struct vm_object **objpp;
563         } */ *ap;
564 {
565         struct vnode *vp = ap->a_vp;
566         struct vm_object **objpp = ap->a_objpp;
567
568         if (objpp)
569                 *objpp = vp->v_object;
570         return (vp->v_object ? 0 : EINVAL);
571 }
572
573 /* 
574  * vfs default ops
575  * used to fill the vfs fucntion table to get reasonable default return values.
576  */
577 int 
578 vfs_stdmount(struct mount *mp, char *path, caddr_t data,
579         struct nameidata *ndp, struct thread *td)
580 {
581         return (0);
582 }
583
584 int     
585 vfs_stdunmount(struct mount *mp, int mntflags, struct thread *td)
586 {
587         return (0);
588 }
589
590 int     
591 vfs_stdroot(struct mount *mp, struct vnode **vpp)
592 {
593         return (EOPNOTSUPP);
594 }
595
596 int     
597 vfs_stdstatfs(struct mount *mp, struct statfs *sbp, struct thread *td)
598 {
599         return (EOPNOTSUPP);
600 }
601
602 int
603 vfs_stdvptofh(struct vnode *vp, struct fid *fhp)
604 {
605         return (EOPNOTSUPP);
606 }
607
608 int     
609 vfs_stdstart(struct mount *mp, int flags, struct thread *td)
610 {
611         return (0);
612 }
613
614 int     
615 vfs_stdquotactl(struct mount *mp, int cmds, uid_t uid,
616         caddr_t arg, struct thread *td)
617 {
618         return (EOPNOTSUPP);
619 }
620
621 int     
622 vfs_stdsync(struct mount *mp, int waitfor, struct thread *td)
623 {
624         return (0);
625 }
626
627 int     
628 vfs_stdvget(struct mount *mp, ino_t ino, struct vnode **vpp)
629 {
630         return (EOPNOTSUPP);
631 }
632
633 int     
634 vfs_stdfhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
635 {
636         return (EOPNOTSUPP);
637 }
638
639 int 
640 vfs_stdcheckexp(struct mount *mp, struct sockaddr *nam, int *extflagsp,
641         struct ucred **credanonp)
642 {
643         return (EOPNOTSUPP);
644 }
645
646 int
647 vfs_stdinit(struct vfsconf *vfsp)
648 {
649         return (0);
650 }
651
652 int
653 vfs_stduninit(struct vfsconf *vfsp)
654 {
655         return(0);
656 }
657
658 int
659 vfs_stdextattrctl(struct mount *mp, int cmd, const char *attrname,
660         caddr_t arg, struct thread *td)
661 {
662         return(EOPNOTSUPP);
663 }
664
665 /* end of vfs default ops */