Per-CPU VFS Namecache Effectiveness Statistics:
[dragonfly.git] / sys / vfs / hpfs / hpfs_vnops.c
1 /*-
2  * Copyright (c) 1998, 1999 Semen Ustimenko (semenu@FreeBSD.org)
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/fs/hpfs/hpfs_vnops.c,v 1.2.2.2 2002/01/15 18:35:09 semenu Exp $
27  * $DragonFly: src/sys/vfs/hpfs/hpfs_vnops.c,v 1.12 2004/02/05 21:03:37 rob Exp $
28  */
29
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/proc.h>
34 #include <sys/time.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/vnode.h>
38 #include <sys/mount.h>
39 #include <sys/namei.h>
40 #include <sys/malloc.h>
41 #include <sys/buf.h>
42 #include <sys/dirent.h>
43
44 #include <vm/vm.h>
45 #include <vm/vm_param.h>
46 #if !defined(__DragonFly__)
47 #include <vm/vm_prot.h>
48 #endif
49 #include <vm/vm_page.h>
50 #include <vm/vm_object.h>
51 #include <vm/vm_pager.h>
52 #include <vm/vm_zone.h>
53 #if defined(__DragonFly__)
54 #include <vm/vnode_pager.h>
55 #endif
56 #include <vm/vm_extern.h>
57 #include <sys/buf2.h>
58
59 #if !defined(__DragonFly__)
60 #include <miscfs/specfs/specdev.h>
61 #include <miscfs/genfs/genfs.h>
62 #endif
63
64 #include <sys/unistd.h> /* for pathconf(2) constants */
65
66 #include "hpfs.h"
67 #include "hpfsmount.h"
68 #include "hpfs_subr.h"
69 #include "hpfs_ioctl.h"
70
71 static int      hpfs_de_uiomove (struct hpfsmount *, struct hpfsdirent *,
72                                      struct uio *);
73 static int      hpfs_ioctl (struct vop_ioctl_args *ap);
74 static int      hpfs_read (struct vop_read_args *);
75 static int      hpfs_write (struct vop_write_args *ap);
76 static int      hpfs_getattr (struct vop_getattr_args *ap);
77 static int      hpfs_setattr (struct vop_setattr_args *ap);
78 static int      hpfs_inactive (struct vop_inactive_args *ap);
79 static int      hpfs_print (struct vop_print_args *ap);
80 static int      hpfs_reclaim (struct vop_reclaim_args *ap);
81 static int      hpfs_strategy (struct vop_strategy_args *ap);
82 static int      hpfs_access (struct vop_access_args *ap);
83 static int      hpfs_open (struct vop_open_args *ap);
84 static int      hpfs_close (struct vop_close_args *ap);
85 static int      hpfs_readdir (struct vop_readdir_args *ap);
86 static int      hpfs_lookup (struct vop_lookup_args *ap);
87 static int      hpfs_create (struct vop_create_args *);
88 static int      hpfs_remove (struct vop_remove_args *);
89 static int      hpfs_bmap (struct vop_bmap_args *ap);
90 #if defined(__DragonFly__)
91 static int      hpfs_getpages (struct vop_getpages_args *ap);
92 static int      hpfs_putpages (struct vop_putpages_args *);
93 static int      hpfs_fsync (struct vop_fsync_args *ap);
94 #endif
95 static int      hpfs_pathconf (struct vop_pathconf_args *ap);
96
97 #if defined(__DragonFly__)
98 int
99 hpfs_getpages(ap)
100         struct vop_getpages_args *ap;
101 {
102         return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, ap->a_count,
103                 ap->a_reqpage);
104 }
105
106 int
107 hpfs_putpages(ap)
108         struct vop_putpages_args *ap;
109 {
110         return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
111                 ap->a_sync, ap->a_rtvals);
112 }
113
114 static int
115 hpfs_fsync(ap)
116         struct vop_fsync_args /* {
117                 struct vnode *a_vp;
118                 struct ucred *a_cred;
119                 int a_waitfor;
120                 struct proc *a_td;
121         } */ *ap;
122 {
123         struct vnode *vp = ap->a_vp;
124         int s;
125         struct buf *bp, *nbp;
126
127         /*
128          * Flush all dirty buffers associated with a vnode.
129          */
130 loop:
131         s = splbio();
132         for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
133                 nbp = TAILQ_NEXT(bp, b_vnbufs);
134                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT))
135                         continue;
136                 if ((bp->b_flags & B_DELWRI) == 0)
137                         panic("hpfs_fsync: not dirty");
138                 bremfree(bp);
139                 splx(s);
140                 (void) bwrite(bp);
141                 goto loop;
142         }
143         while (vp->v_numoutput) {
144                 vp->v_flag |= VBWAIT;
145                 (void) tsleep((caddr_t)&vp->v_numoutput, 0, "hpfsn", 0);
146         }
147 #ifdef DIAGNOSTIC
148         if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
149                 vprint("hpfs_fsync: dirty", vp);
150                 goto loop;
151         }
152 #endif
153         splx(s);
154
155         /*
156          * Write out the on-disc version of the vnode.
157          */
158         return hpfs_update(VTOHP(vp));
159 }
160
161 #endif
162
163 static int
164 hpfs_ioctl (
165         struct vop_ioctl_args /* {
166                 struct vnode *a_vp;
167                 u_long a_command;
168                 caddr_t a_data;
169                 int a_fflag;
170                 struct ucred *a_cred;
171                 struct proc *a_td;
172         } */ *ap)
173 {
174         struct vnode *vp = ap->a_vp;
175         struct hpfsnode *hp = VTOHP(vp);
176         int error;
177
178         printf("hpfs_ioctl(0x%x, 0x%lx, 0x%p, 0x%x): ",
179                 hp->h_no, ap->a_command, ap->a_data, ap->a_fflag);
180
181         switch (ap->a_command) {
182         case HPFSIOCGEANUM: {
183                 u_long eanum;
184                 u_long passed;
185                 struct ea *eap;
186
187                 eanum = 0;
188
189                 if (hp->h_fn.fn_ealen > 0) {
190                         eap = (struct ea *)&(hp->h_fn.fn_int);
191                         passed = 0;
192
193                         while (passed < hp->h_fn.fn_ealen) {
194
195                                 printf("EAname: %s\n", EA_NAME(eap));
196
197                                 eanum++;
198                                 passed += sizeof(struct ea) +
199                                           eap->ea_namelen + 1 + eap->ea_vallen;
200                                 eap = (struct ea *)((caddr_t)hp->h_fn.fn_int +
201                                                 passed);
202                         }
203                         error = 0;
204                 } else {
205                         error = ENOENT;
206                 }
207
208                 printf("%lu eas\n", eanum);
209
210                 *(u_long *)ap->a_data = eanum;
211
212                 break;
213         }
214         case HPFSIOCGEASZ: {
215                 u_long eanum;
216                 u_long passed;
217                 struct ea *eap;
218
219                 printf("EA%ld\n", *(u_long *)ap->a_data);
220
221                 eanum = 0;
222                 if (hp->h_fn.fn_ealen > 0) {
223                         eap = (struct ea *)&(hp->h_fn.fn_int);
224                         passed = 0;
225
226                         error = ENOENT;
227                         while (passed < hp->h_fn.fn_ealen) {
228                                 printf("EAname: %s\n", EA_NAME(eap));
229
230                                 if (eanum == *(u_long *)ap->a_data) {
231                                         *(u_long *)ap->a_data =
232                                                 eap->ea_namelen + 1 +
233                                                 eap->ea_vallen;
234
235                                         error = 0;
236                                         break;
237                                 }
238
239                                 eanum++;
240                                 passed += sizeof(struct ea) +
241                                           eap->ea_namelen + 1 + eap->ea_vallen;
242                                 eap = (struct ea *)((caddr_t)hp->h_fn.fn_int +
243                                                 passed);
244                         }
245                 } else {
246                         error = ENOENT;
247                 }
248
249                 break;
250         }
251         case HPFSIOCRDEA: {
252                 u_long eanum;
253                 u_long passed;
254                 struct hpfs_rdea *rdeap;
255                 struct ea *eap;
256
257                 rdeap = (struct hpfs_rdea *)ap->a_data;
258                 printf("EA%ld\n", rdeap->ea_no);
259
260                 eanum = 0;
261                 if (hp->h_fn.fn_ealen > 0) {
262                         eap = (struct ea *)&(hp->h_fn.fn_int);
263                         passed = 0;
264
265                         error = ENOENT;
266                         while (passed < hp->h_fn.fn_ealen) {
267                                 printf("EAname: %s\n", EA_NAME(eap));
268
269                                 if (eanum == rdeap->ea_no) {
270                                         rdeap->ea_sz = eap->ea_namelen + 1 +
271                                                         eap->ea_vallen;
272                                         copyout(EA_NAME(eap),rdeap->ea_data,
273                                                 rdeap->ea_sz);
274                                         error = 0;
275                                         break;
276                                 }
277
278                                 eanum++;
279                                 passed += sizeof(struct ea) +
280                                           eap->ea_namelen + 1 + eap->ea_vallen;
281                                 eap = (struct ea *)((caddr_t)hp->h_fn.fn_int +
282                                                 passed);
283                         }
284                 } else {
285                         error = ENOENT;
286                 }
287
288                 break;
289         }
290         default:
291                 error = EOPNOTSUPP;
292                 break;
293         }
294         return (error);
295 }
296
297 /*
298  * Map file offset to disk offset.
299  */
300 int
301 hpfs_bmap(ap)
302         struct vop_bmap_args /* {
303                 struct vnode *a_vp;
304                 daddr_t  a_bn;
305                 struct vnode **a_vpp;
306                 daddr_t *a_bnp;
307                 int *a_runp;
308                 int *a_runb;
309         } */ *ap;
310 {
311         struct hpfsnode *hp = VTOHP(ap->a_vp);
312         int error;
313
314         if (ap->a_vpp != NULL) 
315                 *ap->a_vpp = hp->h_devvp;
316 #if defined(__DragonFly__)
317         if (ap->a_runb != NULL)
318                 *ap->a_runb = 0;
319 #endif
320         if (ap->a_bnp == NULL)
321                 return (0);
322
323         dprintf(("hpfs_bmap(0x%x, 0x%x): ",hp->h_no, ap->a_bn));
324
325         error = hpfs_hpbmap (hp, ap->a_bn, ap->a_bnp, ap->a_runp);
326
327         return (error);
328 }
329
330 static int
331 hpfs_read(ap)
332         struct vop_read_args /* {
333                 struct vnode *a_vp;
334                 struct uio *a_uio;
335                 int a_ioflag;
336                 struct ucred *a_cred;
337         } */ *ap;
338 {
339         struct vnode *vp = ap->a_vp;
340         struct hpfsnode *hp = VTOHP(vp);
341         struct uio *uio = ap->a_uio;
342         struct buf *bp;
343         u_int xfersz, toread;
344         u_int off;
345         daddr_t lbn, bn;
346         int resid;
347         int runl;
348         int error = 0;
349
350         resid = min (uio->uio_resid, hp->h_fn.fn_size - uio->uio_offset);
351
352         dprintf(("hpfs_read(0x%x, off: %d resid: %d, segflg: %d): [resid: 0x%x]\n",hp->h_no,(u_int32_t)uio->uio_offset,uio->uio_resid,uio->uio_segflg, resid));
353
354         while (resid) {
355                 lbn = uio->uio_offset >> DEV_BSHIFT;
356                 off = uio->uio_offset & (DEV_BSIZE - 1);
357                 dprintf(("hpfs_read: resid: 0x%x lbn: 0x%x off: 0x%x\n",
358                         uio->uio_resid, lbn, off));
359                 error = hpfs_hpbmap(hp, lbn, &bn, &runl);
360                 if (error)
361                         return (error);
362
363                 toread = min(off + resid, min(DFLTPHYS, (runl+1)*DEV_BSIZE));
364                 xfersz = (toread + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
365                 dprintf(("hpfs_read: bn: 0x%x (0x%x) toread: 0x%x (0x%x)\n",
366                         bn, runl, toread, xfersz));
367
368                 if (toread == 0) 
369                         break;
370
371                 error = bread(hp->h_devvp, bn, xfersz, &bp);
372                 if (error) {
373                         brelse(bp);
374                         break;
375                 }
376
377                 error = uiomove(bp->b_data + off, toread - off, uio);
378                 if(error) {
379                         brelse(bp);
380                         break;
381                 }
382                 brelse(bp);
383                 resid -= toread;
384         }
385         dprintf(("hpfs_read: successful\n"));
386         return (error);
387 }
388
389 static int
390 hpfs_write(ap)
391         struct vop_write_args /* {
392                 struct vnode *a_vp;
393                 struct uio *a_uio;
394                 int  a_ioflag;
395                 struct ucred *a_cred;
396         } */ *ap;
397 {
398         struct vnode *vp = ap->a_vp;
399         struct hpfsnode *hp = VTOHP(vp);
400         struct uio *uio = ap->a_uio;
401         struct buf *bp;
402         u_int xfersz, towrite;
403         u_int off;
404         daddr_t lbn, bn;
405         int runl;
406         int error = 0;
407
408         dprintf(("hpfs_write(0x%x, off: %d resid: %d, segflg: %d):\n",hp->h_no,(u_int32_t)uio->uio_offset,uio->uio_resid,uio->uio_segflg));
409
410         if (ap->a_ioflag & IO_APPEND) {
411                 dprintf(("hpfs_write: APPEND mode\n"));
412                 uio->uio_offset = hp->h_fn.fn_size;
413         }
414         if (uio->uio_offset + uio->uio_resid > hp->h_fn.fn_size) {
415                 error = hpfs_extend (hp, uio->uio_offset + uio->uio_resid);
416                 if (error) {
417                         printf("hpfs_write: hpfs_extend FAILED %d\n", error);
418                         return (error);
419                 }
420         }
421
422         while (uio->uio_resid) {
423                 lbn = uio->uio_offset >> DEV_BSHIFT;
424                 off = uio->uio_offset & (DEV_BSIZE - 1);
425                 dprintf(("hpfs_write: resid: 0x%x lbn: 0x%x off: 0x%x\n",
426                         uio->uio_resid, lbn, off));
427                 error = hpfs_hpbmap(hp, lbn, &bn, &runl);
428                 if (error)
429                         return (error);
430
431                 towrite = min(off + uio->uio_resid, min(DFLTPHYS, (runl+1)*DEV_BSIZE));
432                 xfersz = (towrite + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
433                 dprintf(("hpfs_write: bn: 0x%x (0x%x) towrite: 0x%x (0x%x)\n",
434                         bn, runl, towrite, xfersz));
435
436                 if ((off == 0) && (towrite == xfersz)) {
437                         bp = getblk(hp->h_devvp, bn, xfersz, 0, 0);
438                         clrbuf(bp);
439                 } else {
440                         error = bread(hp->h_devvp, bn, xfersz, &bp);
441                         if (error) {
442                                 brelse(bp);
443                                 return (error);
444                         }
445                 }
446
447                 error = uiomove(bp->b_data + off, towrite - off, uio);
448                 if(error) {
449                         brelse(bp);
450                         return (error);
451                 }
452
453                 if (ap->a_ioflag & IO_SYNC)
454                         bwrite(bp);
455                 else
456                         bawrite(bp);
457         }
458
459         dprintf(("hpfs_write: successful\n"));
460         return (0);
461 }
462
463 /*
464  * XXXXX do we need hpfsnode locking inside?
465  */
466 static int
467 hpfs_getattr(ap)
468         struct vop_getattr_args /* {
469                 struct vnode *a_vp;
470                 struct vattr *a_vap;
471                 struct ucred *a_cred;
472                 struct proc *a_td;
473         } */ *ap;
474 {
475         struct vnode *vp = ap->a_vp;
476         struct hpfsnode *hp = VTOHP(vp);
477         struct vattr *vap = ap->a_vap;
478         int error;
479
480         dprintf(("hpfs_getattr(0x%x):\n", hp->h_no));
481
482 #if defined(__DragonFly__)
483         vap->va_fsid = dev2udev(hp->h_dev);
484 #else /* defined(__NetBSD__) */
485         vap->va_fsid = ip->i_dev;
486 #endif
487         vap->va_fileid = hp->h_no;
488         vap->va_mode = hp->h_mode;
489         vap->va_nlink = 1;
490         vap->va_uid = hp->h_uid;
491         vap->va_gid = hp->h_gid;
492         vap->va_rdev = 0;                               /* XXX UNODEV ? */
493         vap->va_size = hp->h_fn.fn_size;
494         vap->va_bytes = ((hp->h_fn.fn_size + DEV_BSIZE-1) & ~(DEV_BSIZE-1)) +
495                         DEV_BSIZE;
496
497         if (!(hp->h_flag & H_PARVALID)) {
498                 error = hpfs_validateparent(hp);
499                 if (error) 
500                         return (error);
501         }
502         vap->va_atime = hpfstimetounix(hp->h_atime);
503         vap->va_mtime = hpfstimetounix(hp->h_mtime);
504         vap->va_ctime = hpfstimetounix(hp->h_ctime);
505
506         vap->va_flags = 0;
507         vap->va_gen = 0;
508         vap->va_blocksize = DEV_BSIZE;
509         vap->va_type = vp->v_type;
510         vap->va_filerev = 0;
511
512         return (0);
513 }
514
515 /*
516  * XXXXX do we need hpfsnode locking inside?
517  */
518 static int
519 hpfs_setattr(ap)
520         struct vop_setattr_args /* {
521                 struct vnode *a_vp;
522                 struct vattr *a_vap;
523                 struct ucred *a_cred;
524                 struct thread *a_td;
525         } */ *ap;
526 {
527         struct vnode *vp = ap->a_vp;
528         struct hpfsnode *hp = VTOHP(vp);
529         struct vattr *vap = ap->a_vap;
530         struct ucred *cred = ap->a_cred;
531         struct thread *td = ap->a_td;
532         int error;
533
534         dprintf(("hpfs_setattr(0x%x):\n", hp->h_no));
535
536         /*
537          * Check for unsettable attributes.
538          */
539         if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
540             (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
541             (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
542             (vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
543                 dprintf(("hpfs_setattr: changing nonsettable attr\n"));
544                 return (EINVAL);
545         }
546
547         /* Can't change flags XXX Could be implemented */
548         if (vap->va_flags != VNOVAL) {
549                 printf("hpfs_setattr: FLAGS CANNOT BE SET\n");
550                 return (EINVAL);
551         }
552
553         /* Can't change uid/gid XXX Could be implemented */
554         if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
555                 printf("hpfs_setattr: UID/GID CANNOT BE SET\n");
556                 return (EINVAL);
557         }
558
559         /* Can't change mode XXX Could be implemented */
560         if (vap->va_mode != (mode_t)VNOVAL) {
561                 printf("hpfs_setattr: MODE CANNOT BE SET\n");
562                 return (EINVAL);
563         }
564
565         /* Update times */
566         if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
567                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
568                         return (EROFS);
569                 if (cred->cr_uid != hp->h_uid &&
570                     (error = suser_cred(cred, PRISON_ROOT)) &&
571                     ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
572                     (error = VOP_ACCESS(vp, VWRITE, cred, td))))
573                         return (error);
574                 if (vap->va_atime.tv_sec != VNOVAL)
575                         hp->h_atime = vap->va_atime.tv_sec;
576                 if (vap->va_mtime.tv_sec != VNOVAL)
577                         hp->h_mtime = vap->va_mtime.tv_sec;
578
579                 hp->h_flag |= H_PARCHANGE;
580         }
581
582         if (vap->va_size != VNOVAL) {
583                 switch (vp->v_type) {
584                 case VDIR:
585                         return (EISDIR);
586                 case VREG:
587                         if (vp->v_mount->mnt_flag & MNT_RDONLY)
588                                 return (EROFS);
589                         break;
590                 default:
591                         printf("hpfs_setattr: WRONG v_type\n");
592                         return (EINVAL);
593                 }
594
595                 if (vap->va_size < hp->h_fn.fn_size) {
596 #if defined(__DragonFly__)
597                         error = vtruncbuf(vp, td, vap->va_size, DEV_BSIZE);
598                         if (error)
599                                 return (error);
600 #else /* defined(__NetBSD__) */
601 #error Need alternation for vtruncbuf()
602 #endif
603                         error = hpfs_truncate(hp, vap->va_size);
604                         if (error)
605                                 return (error);
606
607                 } else if (vap->va_size > hp->h_fn.fn_size) {
608 #if defined(__DragonFly__)
609                         vnode_pager_setsize(vp, vap->va_size);
610 #endif
611                         error = hpfs_extend(hp, vap->va_size);
612                         if (error)
613                                 return (error);
614                 }
615         }
616
617         return (0);
618 }
619
620 /*
621  * Last reference to an node.  If necessary, write or delete it.
622  */
623 int
624 hpfs_inactive(ap)
625         struct vop_inactive_args /* {
626                 struct vnode *a_vp;
627         } */ *ap;
628 {
629         struct vnode *vp = ap->a_vp;
630         struct hpfsnode *hp = VTOHP(vp);
631         int error;
632
633         dprintf(("hpfs_inactive(0x%x): \n", hp->h_no));
634
635         if (hp->h_flag & H_CHANGE) {
636                 dprintf(("hpfs_inactive: node changed, update\n"));
637                 error = hpfs_update (hp);
638                 if (error)
639                         return (error);
640         }
641
642         if (hp->h_flag & H_PARCHANGE) {
643                 dprintf(("hpfs_inactive: parent node changed, update\n"));
644                 error = hpfs_updateparent (hp);
645                 if (error)
646                         return (error);
647         }
648
649         if (prtactive && vp->v_usecount != 0)
650                 vprint("hpfs_inactive: pushing active", vp);
651
652         if (hp->h_flag & H_INVAL) {
653                 VOP__UNLOCK(vp,0,ap->a_td);
654 #if defined(__DragonFly__)
655                 vrecycle(vp, NULL, ap->a_td);
656 #else /* defined(__NetBSD__) */
657                 vgone(vp);
658 #endif
659                 return (0);
660         }
661
662         VOP__UNLOCK(vp,0,ap->a_td);
663         return (0);
664 }
665
666 /*
667  * Reclaim an inode so that it can be used for other purposes.
668  */
669 int
670 hpfs_reclaim(ap)
671         struct vop_reclaim_args /* {
672                 struct vnode *a_vp;
673         } */ *ap;
674 {
675         struct vnode *vp = ap->a_vp;
676         struct hpfsnode *hp = VTOHP(vp);
677
678         dprintf(("hpfs_reclaim(0x%x0): \n", hp->h_no));
679
680         hpfs_hphashrem(hp);
681
682         /* Purge old data structures associated with the inode. */
683         cache_purge(vp);
684         if (hp->h_devvp) {
685                 vrele(hp->h_devvp);
686                 hp->h_devvp = NULL;
687         }
688
689         vp->v_data = NULL;
690
691         FREE(hp, M_HPFSNO);
692
693         return (0);
694 }
695
696 static int
697 hpfs_print(ap)
698         struct vop_print_args /* {
699                 struct vnode *a_vp;
700         } */ *ap;
701 {
702         struct vnode *vp = ap->a_vp;
703         struct hpfsnode *hp = VTOHP(vp);
704
705         printf("tag VT_HPFS, ino 0x%x",hp->h_no);
706         lockmgr_printinfo(&hp->h_lock);
707         printf("\n");
708         return (0);
709 }
710
711 /*
712  * Calculate the logical to physical mapping if not done already,
713  * then call the device strategy routine.
714  *
715  * In order to be able to swap to a file, the VOP_BMAP operation may not
716  * deadlock on memory.  See hpfs_bmap() for details. XXXXXXX (not impl)
717  */
718 int
719 hpfs_strategy(ap)
720         struct vop_strategy_args /* {
721                 struct buf *a_bp;
722         } */ *ap;
723 {
724         struct buf *bp = ap->a_bp;
725         struct vnode *vp = ap->a_vp;
726         struct vnode *nvp;
727         int error;
728
729         dprintf(("hpfs_strategy(): \n"));
730
731         if (vp->v_type == VBLK || vp->v_type == VCHR)
732                 panic("hpfs_strategy: spec");
733         if (bp->b_blkno == bp->b_lblkno) {
734                 error = VOP_BMAP(vp, bp->b_lblkno, &nvp, &bp->b_blkno, NULL, NULL);
735                 if (error) {
736                         printf("hpfs_strategy: VOP_BMAP FAILED %d\n", error);
737                         bp->b_error = error;
738                         bp->b_flags |= B_ERROR;
739                         biodone(bp);
740                         return (error);
741                 }
742                 if ((long)bp->b_blkno == -1)
743                         vfs_bio_clrbuf(bp);
744         }
745         if ((long)bp->b_blkno == -1) {
746                 biodone(bp);
747                 return (0);
748         }
749         bp->b_dev = nvp->v_rdev;
750         VOP_STRATEGY(nvp, bp);
751         return (0);
752 }
753
754 /*
755  * XXXXX do we need hpfsnode locking inside?
756  */
757 int
758 hpfs_access(ap)
759         struct vop_access_args /* {
760                 struct vnode *a_vp;
761                 int  a_mode;
762                 struct ucred *a_cred;
763                 struct proc *a_td;
764         } */ *ap;
765 {
766         struct vnode *vp = ap->a_vp;
767         struct hpfsnode *hp = VTOHP(vp);
768         struct ucred *cred = ap->a_cred;
769         mode_t mask, mode = ap->a_mode;
770         gid_t *gp;
771         int i;
772
773         dprintf(("hpfs_access(0x%x):\n", hp->h_no));
774
775         /*
776          * Disallow write attempts on read-only file systems;
777          * unless the file is a socket, fifo, or a block or
778          * character device resident on the file system.
779          */
780         if (mode & VWRITE) {
781                 switch ((int)vp->v_type) {
782                 case VDIR:
783                 case VLNK:
784                 case VREG:
785                         if (vp->v_mount->mnt_flag & MNT_RDONLY)
786                                 return (EROFS);
787                         break;
788                 }
789         }
790
791         /* Otherwise, user id 0 always gets access. */
792         if (cred->cr_uid == 0)
793                 return (0);
794
795         mask = 0;
796
797         /* Otherwise, check the owner. */
798         if (cred->cr_uid == hp->h_uid) {
799                 if (mode & VEXEC)
800                         mask |= S_IXUSR;
801                 if (mode & VREAD)
802                         mask |= S_IRUSR;
803                 if (mode & VWRITE)
804                         mask |= S_IWUSR;
805                 return ((hp->h_mode & mask) == mask ? 0 : EACCES);
806         }
807
808         /* Otherwise, check the groups. */
809         for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
810                 if (hp->h_gid == *gp) {
811                         if (mode & VEXEC)
812                                 mask |= S_IXGRP;
813                         if (mode & VREAD)
814                                 mask |= S_IRGRP;
815                         if (mode & VWRITE)
816                                 mask |= S_IWGRP;
817                         return ((hp->h_mode & mask) == mask ? 0 : EACCES);
818                 }
819
820         /* Otherwise, check everyone else. */
821         if (mode & VEXEC)
822                 mask |= S_IXOTH;
823         if (mode & VREAD)
824                 mask |= S_IROTH;
825         if (mode & VWRITE)
826                 mask |= S_IWOTH;
827         return ((hp->h_mode & mask) == mask ? 0 : EACCES);
828 }
829
830 /*
831  * Open called.
832  *
833  * Nothing to do.
834  */
835 /* ARGSUSED */
836 static int
837 hpfs_open(ap)
838         struct vop_open_args /* {
839                 struct vnode *a_vp;
840                 int  a_mode;
841                 struct ucred *a_cred;
842                 struct proc *a_td;
843         } */ *ap;
844 {
845 #if HPFS_DEBUG
846         struct vnode *vp = ap->a_vp;
847         struct hpfsnode *hp = VTOHP(vp);
848
849         printf("hpfs_open(0x%x):\n",hp->h_no);
850 #endif
851
852         /*
853          * Files marked append-only must be opened for appending.
854          */
855
856         return (0);
857 }
858
859 /*
860  * Close called.
861  *
862  * Update the times on the inode.
863  */
864 /* ARGSUSED */
865 static int
866 hpfs_close(ap)
867         struct vop_close_args /* {
868                 struct vnode *a_vp;
869                 int  a_fflag;
870                 struct ucred *a_cred;
871                 struct proc *a_td;
872         } */ *ap;
873 {
874 #if HPFS_DEBUG
875         struct vnode *vp = ap->a_vp;
876         struct hpfsnode *hp = VTOHP(vp);
877
878         printf("hpfs_close: %d\n",hp->h_no);
879 #endif
880
881         return (0);
882 }
883
884 static int
885 hpfs_de_uiomove (
886         struct hpfsmount *hpmp,
887         struct hpfsdirent *dep,
888         struct uio *uio)
889 {
890         struct dirent cde;
891         int i, error;
892
893         dprintf(("[no: 0x%x, size: %d, name: %2d:%.*s, flag: 0x%x] ",
894                 dep->de_fnode, dep->de_size, dep->de_namelen,
895                 dep->de_namelen, dep->de_name, dep->de_flag));
896
897         /*strncpy(cde.d_name, dep->de_name, dep->de_namelen);*/
898         for (i=0; i<dep->de_namelen; i++) 
899                 cde.d_name[i] = hpfs_d2u(hpmp, dep->de_name[i]);
900
901         cde.d_name[dep->de_namelen] = '\0';
902         cde.d_namlen = dep->de_namelen;
903         cde.d_fileno = dep->de_fnode;
904         cde.d_type = (dep->de_flag & DE_DIR) ? DT_DIR : DT_REG;
905         cde.d_reclen = sizeof(struct dirent);
906
907         error = uiomove((char *)&cde, sizeof(struct dirent), uio);
908         if (error)
909                 return (error);
910         
911         dprintf(("[0x%x] ", uio->uio_resid));
912         return (error);
913 }
914
915
916 static struct dirent hpfs_de_dot =
917         { 0, sizeof(struct dirent), DT_DIR, 1, "." };
918 static struct dirent hpfs_de_dotdot =
919         { 0, sizeof(struct dirent), DT_DIR, 2, ".." };
920 int
921 hpfs_readdir(ap)
922         struct vop_readdir_args /* {
923                 struct vnode *a_vp;
924                 struct uio *a_uio;
925                 struct ucred *a_cred;
926                 int *a_ncookies;
927                 u_int **cookies;
928         } */ *ap;
929 {
930         struct vnode *vp = ap->a_vp;
931         struct hpfsnode *hp = VTOHP(vp);
932         struct hpfsmount *hpmp = hp->h_hpmp;
933         struct uio *uio = ap->a_uio;
934         int ncookies = 0, i, num, cnum;
935         int error = 0;
936         off_t off;
937         struct buf *bp;
938         struct dirblk *dp;
939         struct hpfsdirent *dep;
940         lsn_t olsn;
941         lsn_t lsn;
942         int level;
943
944         dprintf(("hpfs_readdir(0x%x, 0x%x, 0x%x): ",hp->h_no,(u_int32_t)uio->uio_offset,uio->uio_resid));
945
946         off = uio->uio_offset;
947
948         if( uio->uio_offset < sizeof(struct dirent) ) {
949                 dprintf((". faked, "));
950                 hpfs_de_dot.d_fileno = hp->h_no;
951                 error = uiomove((char *)&hpfs_de_dot,sizeof(struct dirent),uio);
952                 if(error) {
953                         return (error);
954                 }
955
956                 ncookies ++;
957         }
958
959         if( uio->uio_offset < 2 * sizeof(struct dirent) ) {
960                 dprintf((".. faked, "));
961                 hpfs_de_dotdot.d_fileno = hp->h_fn.fn_parent;
962
963                 error = uiomove((char *)&hpfs_de_dotdot, sizeof(struct dirent),
964                                 uio);
965                 if(error) {
966                         return (error);
967                 }
968
969                 ncookies ++;
970         }
971
972         num = uio->uio_offset / sizeof(struct dirent) - 2;
973         cnum = 0;
974
975         lsn = ((alleaf_t *)hp->h_fn.fn_abd)->al_lsn;
976
977         olsn = 0;
978         level = 1;
979
980 dive:
981         dprintf(("[dive 0x%x] ", lsn));
982         error = bread(hp->h_devvp, lsn, D_BSIZE, &bp);
983         if (error) {
984                 brelse(bp);
985                 return (error);
986         }
987
988         dp = (struct dirblk *) bp->b_data;
989         if (dp->d_magic != D_MAGIC) {
990                 printf("hpfs_readdir: MAGIC DOESN'T MATCH\n");
991                 brelse(bp);
992                 return (EINVAL);
993         }
994
995         dep = D_DIRENT(dp);
996
997         if (olsn) {
998                 dprintf(("[restore 0x%x] ", olsn));
999
1000                 while(!(dep->de_flag & DE_END) ) {
1001                         if((dep->de_flag & DE_DOWN) &&
1002                            (olsn == DE_DOWNLSN(dep)))
1003                                          break;
1004                         dep = (hpfsdirent_t *)((caddr_t)dep + dep->de_reclen);
1005                 }
1006
1007                 if((dep->de_flag & DE_DOWN) && (olsn == DE_DOWNLSN(dep))) {
1008                         if (dep->de_flag & DE_END)
1009                                 goto blockdone;
1010
1011                         if (!(dep->de_flag & DE_SPECIAL)) {
1012                                 if (num <= cnum) {
1013                                         if (uio->uio_resid < sizeof(struct dirent)) {
1014                                                 brelse(bp);
1015                                                 dprintf(("[resid] "));
1016                                                 goto readdone;
1017                                         }
1018
1019                                         error = hpfs_de_uiomove(hpmp, dep, uio);
1020                                         if (error) {
1021                                                 brelse (bp);
1022                                                 return (error);
1023                                         }
1024                                         ncookies++;
1025
1026                                         if (uio->uio_resid < sizeof(struct dirent)) {
1027                                                 brelse(bp);
1028                                                 dprintf(("[resid] "));
1029                                                 goto readdone;
1030                                         }
1031                                 }
1032                                 cnum++;
1033                         }
1034
1035                         dep = (hpfsdirent_t *)((caddr_t)dep + dep->de_reclen);
1036                 } else {
1037                         printf("hpfs_readdir: ERROR! oLSN not found\n");
1038                         brelse(bp);
1039                         return (EINVAL);
1040                 }
1041         }
1042
1043         olsn = 0;
1044
1045         while(!(dep->de_flag & DE_END)) {
1046                 if(dep->de_flag & DE_DOWN) {
1047                         lsn = DE_DOWNLSN(dep);
1048                         brelse(bp);
1049                         level++;
1050                         goto dive;
1051                 }
1052
1053                 if (!(dep->de_flag & DE_SPECIAL)) {
1054                         if (num <= cnum) {
1055                                 if (uio->uio_resid < sizeof(struct dirent)) {
1056                                         brelse(bp);
1057                                         dprintf(("[resid] "));
1058                                         goto readdone;
1059                                 }
1060
1061                                 error = hpfs_de_uiomove(hpmp, dep, uio);
1062                                 if (error) {
1063                                         brelse (bp);
1064                                         return (error);
1065                                 }
1066                                 ncookies++;
1067                                 
1068                                 if (uio->uio_resid < sizeof(struct dirent)) {
1069                                         brelse(bp);
1070                                         dprintf(("[resid] "));
1071                                         goto readdone;
1072                                 }
1073                         }
1074                         cnum++;
1075                 }
1076
1077                 dep = (hpfsdirent_t *)((caddr_t)dep + dep->de_reclen);
1078         }
1079
1080         if(dep->de_flag & DE_DOWN) {
1081                 dprintf(("[enddive] "));
1082                 lsn = DE_DOWNLSN(dep);
1083                 brelse(bp);
1084                 level++;
1085                 goto dive;
1086         }
1087
1088 blockdone:
1089         dprintf(("[EOB] "));
1090         olsn = lsn;
1091         lsn = dp->d_parent;
1092         brelse(bp);
1093         level--;
1094
1095         dprintf(("[level %d] ", level));
1096
1097         if (level > 0)
1098                 goto dive;      /* undive really */
1099
1100         if (ap->a_eofflag) {
1101             dprintf(("[EOF] "));
1102             *ap->a_eofflag = 1;
1103         }
1104
1105 readdone:
1106         dprintf(("[readdone]\n"));
1107         if (!error && ap->a_ncookies != NULL) {
1108                 struct dirent* dpStart;
1109                 struct dirent* dp;
1110 #if defined(__DragonFly__)
1111                 u_long *cookies;
1112                 u_long *cookiep;
1113 #else /* defined(__NetBSD__) */
1114                 off_t *cookies;
1115                 off_t *cookiep;
1116 #endif
1117
1118                 dprintf(("%d cookies, ",ncookies));
1119                 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
1120                         panic("hpfs_readdir: unexpected uio from NFS server");
1121                 dpStart = (struct dirent *)
1122                      ((caddr_t)uio->uio_iov->iov_base -
1123                          (uio->uio_offset - off));
1124 #if defined(__DragonFly__)
1125                 MALLOC(cookies, u_long *, ncookies * sizeof(u_long),
1126                        M_TEMP, M_WAITOK);
1127 #else /* defined(__NetBSD__) */
1128                 MALLOC(cookies, off_t *, ncookies * sizeof(off_t),
1129                        M_TEMP, M_WAITOK);
1130 #endif
1131                 for (dp = dpStart, cookiep = cookies, i=0;
1132                      i < ncookies;
1133                      dp = (struct dirent *)((caddr_t) dp + dp->d_reclen), i++) {
1134                         off += dp->d_reclen;
1135                         *cookiep++ = (u_int) off;
1136                 }
1137                 *ap->a_ncookies = ncookies;
1138                 *ap->a_cookies = cookies;
1139         }
1140
1141         return (0);
1142 }
1143
1144 int
1145 hpfs_lookup(ap)
1146         struct vop_lookup_args /* {
1147                 struct vnode *a_dvp;
1148                 struct vnode **a_vpp;
1149                 struct componentname *a_cnp;
1150         } */ *ap;
1151 {
1152         struct vnode *dvp = ap->a_dvp;
1153         struct hpfsnode *dhp = VTOHP(dvp);
1154         struct hpfsmount *hpmp = dhp->h_hpmp;
1155         struct componentname *cnp = ap->a_cnp;
1156         struct ucred *cred = cnp->cn_cred;
1157         int error;
1158         int nameiop = cnp->cn_nameiop;
1159         int flags = cnp->cn_flags;
1160         int lockparent = flags & CNP_LOCKPARENT;
1161 #if HPFS_DEBUG
1162         int wantparent = flags & (CNP_LOCKPARENT | CNP_WANTPARENT);
1163 #endif
1164         dprintf(("hpfs_lookup(0x%x, %s, %ld, %d, %d): \n",
1165                 dhp->h_no, cnp->cn_nameptr, cnp->cn_namelen,
1166                 lockparent, wantparent));
1167
1168         if (nameiop != NAMEI_CREATE && nameiop != NAMEI_DELETE && nameiop != NAMEI_LOOKUP) {
1169                 printf("hpfs_lookup: LOOKUP, DELETE and CREATE are only supported\n");
1170                 return (EOPNOTSUPP);
1171         }
1172
1173         error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_td);
1174         if(error)
1175                 return (error);
1176
1177         if( (cnp->cn_namelen == 1) &&
1178             !strncmp(cnp->cn_nameptr,".",1) ) {
1179                 dprintf(("hpfs_lookup(0x%x,...): . faked\n",dhp->h_no));
1180
1181                 VREF(dvp);
1182                 *ap->a_vpp = dvp;
1183
1184                 return (0);
1185         } else if( (cnp->cn_namelen == 2) &&
1186             !strncmp(cnp->cn_nameptr,"..",2) && (flags & CNP_ISDOTDOT) ) {
1187                 dprintf(("hpfs_lookup(0x%x,...): .. faked (0x%x)\n",
1188                         dhp->h_no, dhp->h_fn.fn_parent));
1189
1190                 VOP__UNLOCK(dvp,0,cnp->cn_td);
1191
1192                 error = VFS_VGET(hpmp->hpm_mp,
1193                                  dhp->h_fn.fn_parent, ap->a_vpp); 
1194                 if(error) {
1195                         VOP__LOCK(dvp, 0, cnp->cn_td);
1196                         return(error);
1197                 }
1198
1199                 if( lockparent && (flags & CNP_ISLASTCN) && 
1200                     (error = VOP__LOCK(dvp, 0, cnp->cn_td)) ) {
1201                         vput( *(ap->a_vpp) );
1202                         return (error);
1203                 }
1204                 return (error);
1205         } else {
1206                 struct buf *bp;
1207                 struct hpfsdirent *dep;
1208                 struct hpfsnode *hp;
1209
1210                 error = hpfs_genlookupbyname(dhp,
1211                                 cnp->cn_nameptr, cnp->cn_namelen, &bp, &dep);
1212                 if (error) {
1213                         if ((error == ENOENT) && (flags & CNP_ISLASTCN) &&
1214                             (nameiop == NAMEI_CREATE || nameiop == NAMEI_RENAME)) {
1215                                 if(!lockparent)
1216                                         VOP__UNLOCK(dvp, 0, cnp->cn_td);
1217                                 cnp->cn_flags |= CNP_SAVENAME;
1218                                 return (EJUSTRETURN);
1219                         }
1220
1221                         return (error);
1222                 }
1223
1224                 dprintf(("hpfs_lookup: fnode: 0x%x, CPID: 0x%x\n",
1225                          dep->de_fnode, dep->de_cpid));
1226
1227                 if (nameiop == NAMEI_DELETE && (flags & CNP_ISLASTCN)) {
1228                         error = VOP_ACCESS(dvp, VWRITE, cred, cnp->cn_td);
1229                         if (error) {
1230                                 brelse(bp);
1231                                 return (error);
1232                         }
1233                 }
1234
1235                 if (dhp->h_no == dep->de_fnode) {
1236                         brelse(bp);
1237                         VREF(dvp);
1238                         *ap->a_vpp = dvp;
1239                         return (0);
1240                 }
1241
1242                 error = VFS_VGET(hpmp->hpm_mp, dep->de_fnode, ap->a_vpp);
1243                 if (error) {
1244                         printf("hpfs_lookup: VFS_VGET FAILED %d\n", error);
1245                         brelse(bp);
1246                         return(error);
1247                 }
1248
1249                 hp = VTOHP(*ap->a_vpp);
1250
1251                 hp->h_mtime = dep->de_mtime;
1252                 hp->h_ctime = dep->de_ctime;
1253                 hp->h_atime = dep->de_atime;
1254                 bcopy(dep->de_name, hp->h_name, dep->de_namelen);
1255                 hp->h_name[dep->de_namelen] = '\0';
1256                 hp->h_namelen = dep->de_namelen;
1257                 hp->h_flag |= H_PARVALID;
1258
1259                 brelse(bp);
1260
1261                 if(!lockparent || !(flags & CNP_ISLASTCN))
1262                         VOP__UNLOCK(dvp, 0, cnp->cn_td);
1263                 if ((flags & CNP_MAKEENTRY) &&
1264                     (!(flags & CNP_ISLASTCN) || 
1265                      (nameiop != NAMEI_DELETE && nameiop != NAMEI_CREATE)))
1266                         cache_enter(dvp, NCPNULL, *ap->a_vpp, cnp);
1267         }
1268         return (error);
1269 }
1270
1271 int
1272 hpfs_remove(ap)
1273         struct vop_remove_args /* {
1274                 struct vnode *a_dvp;
1275                 struct vnode *a_vp;
1276                 struct componentname *a_cnp;
1277         } */ *ap;
1278 {
1279         int error;
1280
1281         dprintf(("hpfs_remove(0x%x, %s, %ld): \n", VTOHP(ap->a_vp)->h_no,
1282                 ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen));
1283
1284         if (ap->a_vp->v_type == VDIR)
1285                 return (EPERM);
1286
1287         error = hpfs_removefnode (ap->a_dvp, ap->a_vp, ap->a_cnp);
1288         return (error);
1289 }
1290
1291 int
1292 hpfs_create(ap)
1293         struct vop_create_args /* {
1294                 struct vnode *a_dvp;
1295                 struct vnode **a_vpp;
1296                 struct componentname *a_cnp;
1297                 struct vattr *a_vap;
1298         } */ *ap;
1299 {
1300         int error;
1301
1302         dprintf(("hpfs_create(0x%x, %s, %ld): \n", VTOHP(ap->a_dvp)->h_no,
1303                 ap->a_cnp->cn_nameptr, ap->a_cnp->cn_namelen));
1304
1305         if (!(ap->a_cnp->cn_flags & CNP_HASBUF)) 
1306                 panic ("hpfs_create: no name\n");
1307
1308         error = hpfs_makefnode (ap->a_dvp, ap->a_vpp, ap->a_cnp, ap->a_vap);
1309
1310         return (error);
1311 }
1312
1313 /*
1314  * Return POSIX pathconf information applicable to NTFS filesystem
1315  */
1316 int
1317 hpfs_pathconf(ap)
1318         struct vop_pathconf_args /* {
1319                 struct vnode *a_vp;
1320                 int a_name;
1321                 t *a_retval;
1322         } */ *ap;
1323 {
1324         switch (ap->a_name) {
1325         case _PC_LINK_MAX:
1326                 *ap->a_retval = 1;
1327                 return (0);
1328         case _PC_NAME_MAX:
1329                 *ap->a_retval = HPFS_MAXFILENAME;
1330                 return (0);
1331         case _PC_PATH_MAX:
1332                 *ap->a_retval = PATH_MAX;
1333                 return (0);
1334         case _PC_CHOWN_RESTRICTED:
1335                 *ap->a_retval = 1;
1336                 return (0);
1337         case _PC_NO_TRUNC:
1338                 *ap->a_retval = 0;
1339                 return (0);
1340 #if defined(__NetBSD__)
1341         case _PC_SYNC_IO:
1342                 *ap->a_retval = 1;
1343                 return (0);
1344         case _PC_FILESIZEBITS:
1345                 *ap->a_retval = 32;
1346                 return (0);
1347 #endif
1348         default:
1349                 return (EINVAL);
1350         }
1351         /* NOTREACHED */
1352 }
1353
1354
1355 /*
1356  * Global vfs data structures
1357  */
1358 vop_t **hpfs_vnodeop_p;
1359 #if defined(__DragonFly__)
1360 struct vnodeopv_entry_desc hpfs_vnodeop_entries[] = {
1361         { &vop_default_desc, (vop_t *)vop_defaultop },
1362
1363         { &vop_getattr_desc, (vop_t *)hpfs_getattr },
1364         { &vop_setattr_desc, (vop_t *)hpfs_setattr },
1365         { &vop_inactive_desc, (vop_t *)hpfs_inactive },
1366         { &vop_reclaim_desc, (vop_t *)hpfs_reclaim },
1367         { &vop_print_desc, (vop_t *)hpfs_print },
1368         { &vop_create_desc, (vop_t *)hpfs_create },
1369         { &vop_remove_desc, (vop_t *)hpfs_remove },
1370         { &vop_islocked_desc, (vop_t *)vop_stdislocked },
1371         { &vop_unlock_desc, (vop_t *)vop_stdunlock },
1372         { &vop_lock_desc, (vop_t *)vop_stdlock },
1373         { &vop_cachedlookup_desc, (vop_t *)hpfs_lookup },
1374         { &vop_lookup_desc, (vop_t *)vfs_cache_lookup },
1375         { &vop_access_desc, (vop_t *)hpfs_access },
1376         { &vop_close_desc, (vop_t *)hpfs_close },
1377         { &vop_open_desc, (vop_t *)hpfs_open },
1378         { &vop_readdir_desc, (vop_t *)hpfs_readdir },
1379         { &vop_fsync_desc, (vop_t *)hpfs_fsync },
1380         { &vop_bmap_desc, (vop_t *)hpfs_bmap },
1381         { &vop_getpages_desc, (vop_t *) hpfs_getpages },
1382         { &vop_putpages_desc, (vop_t *) hpfs_putpages },
1383         { &vop_strategy_desc, (vop_t *)hpfs_strategy },
1384         { &vop_bwrite_desc, (vop_t *)vop_stdbwrite },
1385         { &vop_read_desc, (vop_t *)hpfs_read },
1386         { &vop_write_desc, (vop_t *)hpfs_write },
1387         { &vop_ioctl_desc, (vop_t *)hpfs_ioctl },
1388         { &vop_pathconf_desc, (vop_t *)hpfs_pathconf },
1389         { NULL, NULL }
1390 };
1391
1392 static
1393 struct vnodeopv_desc hpfs_vnodeop_opv_desc =
1394         { &hpfs_vnodeop_p, hpfs_vnodeop_entries };
1395
1396 VNODEOP_SET(hpfs_vnodeop_opv_desc);
1397 #else /* defined(__NetBSD__) */
1398 struct vnodeopv_entry_desc ntfs_vnodeop_entries[] = {
1399         { &vop_default_desc, (vop_t *) genfs_badop },   /* XXX */
1400         { &vop_lookup_desc, (vop_t *) hpfs_lookup },    /* lookup */
1401         { &vop_create_desc, genfs_eopnotsupp },         /* create */
1402         { &vop_mknod_desc, genfs_eopnotsupp },          /* mknod */
1403         { &vop_open_desc, (vop_t *) hpfs_open },        /* open */
1404         { &vop_close_desc,(vop_t *) hpfs_close },       /* close */
1405         { &vop_access_desc, (vop_t *) hpfs_access },    /* access */
1406         { &vop_getattr_desc, (vop_t *) hpfs_getattr },  /* getattr */
1407         { &vop_setattr_desc, genfs_eopnotsupp },        /* setattr */
1408         { &vop_read_desc, (vop_t *) hpfs_read },        /* read */
1409         { &vop_write_desc, (vop_t *) hpfs_write },      /* write */
1410         { &vop_lease_desc, genfs_lease_check },         /* lease */
1411         { &vop_fcntl_desc, genfs_fcntl },               /* fcntl */
1412         { &vop_ioctl_desc, genfs_enoioctl },            /* ioctl */
1413         { &vop_poll_desc, genfs_poll },                 /* poll */
1414         { &vop_revoke_desc, genfs_revoke },             /* revoke */
1415         { &vop_mmap_desc, genfs_eopnotsupp },           /* mmap */
1416         { &vop_fsync_desc, genfs_fsync },               /* fsync */
1417         { &vop_seek_desc, genfs_seek },                 /* seek */
1418         { &vop_remove_desc, genfs_eopnotsupp },         /* remove */
1419         { &vop_link_desc, genfs_eopnotsupp },           /* link */
1420         { &vop_rename_desc, genfs_eopnotsupp },         /* rename */
1421         { &vop_mkdir_desc, genfs_eopnotsupp },          /* mkdir */
1422         { &vop_rmdir_desc, genfs_eopnotsupp },          /* rmdir */
1423         { &vop_symlink_desc, genfs_eopnotsupp },        /* symlink */
1424         { &vop_readdir_desc, (vop_t *) hpfs_readdir },  /* readdir */
1425         { &vop_readlink_desc, genfs_eopnotsupp },       /* readlink */
1426         { &vop_abortop_desc, genfs_abortop },           /* abortop */
1427         { &vop_inactive_desc, (vop_t *) hpfs_inactive },        /* inactive */
1428         { &vop_reclaim_desc, (vop_t *) hpfs_reclaim },  /* reclaim */
1429         { &vop_lock_desc, genfs_lock },                 /* lock */
1430         { &vop_unlock_desc, genfs_unlock },             /* unlock */
1431         { &vop_bmap_desc, (vop_t *) hpfs_bmap },        /* bmap */
1432         { &vop_strategy_desc, (vop_t *) hpfs_strategy },        /* strategy */
1433         { &vop_print_desc, (vop_t *) hpfs_print },      /* print */
1434         { &vop_islocked_desc, genfs_islocked },         /* islocked */
1435         { &vop_pathconf_desc, hpfs_pathconf },          /* pathconf */
1436         { &vop_advlock_desc, genfs_nullop },            /* advlock */
1437         { &vop_blkatoff_desc, genfs_eopnotsupp },       /* blkatoff */
1438         { &vop_valloc_desc, genfs_eopnotsupp },         /* valloc */
1439         { &vop_reallocblks_desc, genfs_eopnotsupp },    /* reallocblks */
1440         { &vop_vfree_desc, genfs_eopnotsupp },          /* vfree */
1441         { &vop_truncate_desc, genfs_eopnotsupp },       /* truncate */
1442         { &vop_update_desc, genfs_eopnotsupp },         /* update */
1443         { &vop_bwrite_desc, vn_bwrite },                /* bwrite */
1444         { (struct vnodeop_desc *)NULL, (int (*) (void *))NULL }
1445 };
1446 struct vnodeopv_desc ntfs_vnodeop_opv_desc =
1447         { &ntfs_vnodeop_p, ntfs_vnodeop_entries };
1448
1449 #endif