Merge from vendor branch BINUTILS:
[dragonfly.git] / sys / vfs / hpfs / hpfs_vfsops.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_vfsops.c,v 1.3.2.2 2001/12/25 01:44:45 dillon Exp $
27  * $DragonFly: src/sys/vfs/hpfs/hpfs_vfsops.c,v 1.11 2003/10/19 21:24:55 hmp Exp $
28  */
29
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/namei.h>
34 #include <sys/conf.h>
35 #include <sys/proc.h>
36 #include <sys/kernel.h>
37 #include <sys/vnode.h>
38 #include <sys/mount.h>
39 #include <sys/buf.h>
40 #include <sys/fcntl.h>
41 #include <sys/malloc.h>
42
43 #include <vm/vm.h>
44 #include <vm/vm_param.h>
45 #if defined(__NetBSD__)
46 #include <vm/vm_prot.h>
47 #endif
48 #include <vm/vm_page.h>
49 #include <vm/vm_object.h>
50 #include <vm/vm_extern.h>
51 #include <sys/buf2.h>
52
53 #if defined(__NetBSD__)
54 #include <miscfs/specfs/specdev.h>
55 #endif
56
57 #include "hpfs.h"
58 #include "hpfsmount.h"
59 #include "hpfs_subr.h"
60
61 #if defined(__FreeBSD__)
62 MALLOC_DEFINE(M_HPFSMNT, "HPFS mount", "HPFS mount structure");
63 MALLOC_DEFINE(M_HPFSNO, "HPFS node", "HPFS node structure");
64 #endif
65
66 static int      hpfs_root (struct mount *, struct vnode **);
67 static int      hpfs_statfs (struct mount *, struct statfs *,
68                                  struct thread *);
69 static int      hpfs_unmount (struct mount *, int, struct thread *);
70 static int      hpfs_vget (struct mount *mp, ino_t ino,
71                                struct vnode **vpp);
72 static int      hpfs_mountfs (struct vnode *, struct mount *, 
73                                   struct hpfs_args *, struct thread *);
74 static int      hpfs_vptofh (struct vnode *, struct fid *);
75 static int      hpfs_fhtovp (struct mount *, struct fid *,
76                                  struct vnode **);
77
78 #if !defined(__FreeBSD__)
79 static int      hpfs_quotactl (struct mount *, int, uid_t, caddr_t,
80                                    struct proc *);
81 static int      hpfs_start (struct mount *, int, struct proc *);
82 static int      hpfs_sync (struct mount *, int, struct ucred *,
83                                struct proc *);
84 #endif
85
86 #if defined(__FreeBSD__)
87 struct sockaddr;
88 static int      hpfs_mount (struct mount *, char *, caddr_t,
89                                 struct nameidata *, struct thread *);
90 static int      hpfs_init (struct vfsconf *);
91 static int      hpfs_checkexp (struct mount *, struct sockaddr *,
92                                    int *, struct ucred **);
93 #else /* defined(__NetBSD__) */
94 static int      hpfs_mount (struct mount *, const char *, void *,
95                                 struct nameidata *, struct proc *);
96 static void     hpfs_init (void);
97 static int      hpfs_mountroot (void);
98 static int      hpfs_sysctl (int *, u_int, void *, size_t *, void *,
99                                  size_t, struct proc *);
100 static int      hpfs_checkexp (struct mount *, struct mbuf *,
101                                    int *, struct ucred **);
102 #endif
103
104 /*ARGSUSED*/
105 static int
106 hpfs_checkexp(mp, nam, exflagsp, credanonp)
107 #if defined(__FreeBSD__)
108         struct mount *mp;
109         struct sockaddr *nam;
110         int *exflagsp;
111         struct ucred **credanonp;
112 #else /* defined(__NetBSD__) */
113         struct mount *mp;
114         struct mbuf *nam;
115         int *exflagsp;
116         struct ucred **credanonp;
117 #endif
118 {
119         struct netcred *np;
120         struct hpfsmount *hpm = VFSTOHPFS(mp);
121
122         /*
123          * Get the export permission structure for this <mp, client> tuple.
124          */
125         np = vfs_export_lookup(mp, &hpm->hpm_export, nam);
126         if (np == NULL)
127                 return (EACCES);
128
129         *exflagsp = np->netc_exflags;
130         *credanonp = &np->netc_anon;
131         return (0);
132 }
133
134 #if !defined(__FreeBSD__)
135 /*ARGSUSED*/
136 static int
137 hpfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, td)
138         int *name;
139         u_int namelen;
140         void *oldp;
141         size_t *oldlenp;
142         void *newp;
143         size_t newlen;
144         struct thread *td;
145 {
146         return (EINVAL);
147 }
148
149 static int
150 hpfs_mountroot()
151 {
152         return (EINVAL);
153 }
154 #endif
155
156 #if defined(__FreeBSD__)
157 static int
158 hpfs_init (
159         struct vfsconf *vcp )
160 #else /* defined(__NetBSD__) */
161 static void
162 hpfs_init ()
163 #endif
164 {
165         dprintf(("hpfs_init():\n"));
166         
167         hpfs_hphashinit();
168 #if defined(__FreeBSD__)
169         return 0;
170 #endif
171 }
172
173 static int
174 hpfs_mount ( 
175         struct mount *mp,
176 #if defined(__FreeBSD__)
177         char *path,
178         caddr_t data,
179 #else /* defined(__NetBSD__) */
180         const char *path,
181         void *data,
182 #endif
183         struct nameidata *ndp,
184         struct thread *td )
185 {
186         u_int           size;
187         int             err = 0;
188         struct vnode    *devvp;
189         struct hpfs_args args;
190         struct hpfsmount *hpmp = 0;
191
192         dprintf(("hpfs_mount():\n"));
193         /*
194          ***
195          * Mounting non-root file system or updating a file system
196          ***
197          */
198
199         /* copy in user arguments*/
200         err = copyin(data, (caddr_t)&args, sizeof (struct hpfs_args));
201         if (err)
202                 goto error_1;           /* can't get arguments*/
203
204         /*
205          * If updating, check whether changing from read-only to
206          * read/write; if there is no device name, that's all we do.
207          */
208         if (mp->mnt_flag & MNT_UPDATE) {
209                 dprintf(("hpfs_mount: MNT_UPDATE: "));
210
211                 hpmp = VFSTOHPFS(mp);
212
213                 if (args.fspec == 0) {
214                         dprintf(("export 0x%x\n",args.export.ex_flags));
215                         err = vfs_export(mp, &hpmp->hpm_export, &args.export);
216                         if (err) {
217                                 printf("hpfs_mount: vfs_export failed %d\n",
218                                         err);
219                         }
220                         goto success;
221                 } else {
222                         dprintf(("name [FAILED]\n"));
223                         err = EINVAL;
224                         goto success;
225                 }
226                 dprintf(("\n"));
227         }
228
229         /*
230          * Not an update, or updating the name: look up the name
231          * and verify that it refers to a sensible block device.
232          */
233         NDINIT(ndp, NAMEI_LOOKUP, CNP_FOLLOW, UIO_USERSPACE, args.fspec, td);
234         err = namei(ndp);
235         if (err) {
236                 /* can't get devvp!*/
237                 goto error_1;
238         }
239
240         devvp = ndp->ni_vp;
241
242 #if defined(__FreeBSD__)
243         if (!vn_isdisk(devvp, &err)) 
244                 goto error_2;
245 #else /* defined(__NetBSD__) */
246         if (devvp->v_type != VBLK) {
247                 err = ENOTBLK;
248                 goto error_2;
249         }
250         if (major(devvp->v_rdev) >= nblkdev) {
251                 err = ENXIO;
252                 goto error_2;
253         }
254 #endif
255
256         /*
257          ********************
258          * NEW MOUNT
259          ********************
260          */
261
262         /*
263          * Since this is a new mount, we want the names for
264          * the device and the mount point copied in.  If an
265          * error occurs,  the mountpoint is discarded by the
266          * upper level code.
267          */
268         /* Save "last mounted on" info for mount point (NULL pad)*/
269         copyinstr(      path,                           /* mount point*/
270                         mp->mnt_stat.f_mntonname,       /* save area*/
271                         MNAMELEN - 1,                   /* max size*/
272                         &size);                         /* real size*/
273         bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
274
275         /* Save "mounted from" info for mount point (NULL pad)*/
276         copyinstr(      args.fspec,                     /* device name*/
277                         mp->mnt_stat.f_mntfromname,     /* save area*/
278                         MNAMELEN - 1,                   /* max size*/
279                         &size);                         /* real size*/
280         bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
281
282         err = hpfs_mountfs(devvp, mp, &args, td);
283         if (err)
284                 goto error_2;
285
286         /*
287          * Initialize FS stat information in mount struct; uses both
288          * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
289          *
290          * This code is common to root and non-root mounts
291          */
292         (void)VFS_STATFS(mp, &mp->mnt_stat, td);
293
294         goto success;
295
296
297 error_2:        /* error with devvp held*/
298
299         /* release devvp before failing*/
300         vrele(devvp);
301
302 error_1:        /* no state to back out*/
303
304 success:
305         return( err);
306 }
307
308 /*
309  * Common code for mount and mountroot
310  */
311 int
312 hpfs_mountfs(devvp, mp, argsp, td)
313         struct vnode *devvp;
314         struct mount *mp;
315         struct hpfs_args *argsp;
316         struct thread *td;
317 {
318         int error, ncount, ronly;
319         struct sublock *sup;
320         struct spblock *spp;
321         struct hpfsmount *hpmp;
322         struct buf *bp = NULL;
323         struct vnode *vp;
324         dev_t dev = devvp->v_rdev;
325
326         dprintf(("hpfs_mountfs():\n"));
327         /*
328          * Disallow multiple mounts of the same device.
329          * Disallow mounting of a device that is currently in use
330          * (except for root, which might share swap device for miniroot).
331          * Flush out any old buffers remaining from a previous use.
332          */
333         error = vfs_mountedon(devvp);
334         if (error)
335                 return (error);
336         ncount = vcount(devvp);
337 #if defined(__FreeBSD__)
338         if (devvp->v_object)
339                 ncount -= 1;
340 #endif
341         if (ncount > 1 && devvp != rootvp)
342                 return (EBUSY);
343
344 #if defined(__FreeBSD__)
345         VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td);
346         error = vinvalbuf(devvp, V_SAVE, td, 0, 0);
347         VOP__UNLOCK(devvp, 0, td);
348 #else
349         error = vinvalbuf(devvp, V_SAVE, td, 0, 0);
350 #endif
351         if (error)
352                 return (error);
353
354         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
355         VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, td);
356         error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td);
357         VOP__UNLOCK(devvp, 0, td);
358         if (error)
359                 return (error);
360
361         /*
362          * Do actual mount
363          */
364         hpmp = malloc(sizeof(struct hpfsmount), M_HPFSMNT, M_WAITOK);
365         bzero(hpmp, sizeof(struct hpfsmount));
366
367         /* Read in SuperBlock */
368         error = bread(devvp, SUBLOCK, SUSIZE, &bp);
369         if (error)
370                 goto failed;
371         bcopy(bp->b_data, &hpmp->hpm_su, sizeof(struct sublock));
372         brelse(bp); bp = NULL;
373
374         /* Read in SpareBlock */
375         error = bread(devvp, SPBLOCK, SPSIZE, &bp);
376         if (error)
377                 goto failed;
378         bcopy(bp->b_data, &hpmp->hpm_sp, sizeof(struct spblock));
379         brelse(bp); bp = NULL;
380
381         sup = &hpmp->hpm_su;
382         spp = &hpmp->hpm_sp;
383
384         /* Check magic */
385         if (sup->su_magic != SU_MAGIC) {
386                 printf("hpfs_mountfs: SuperBlock MAGIC DOESN'T MATCH\n");
387                 error = EINVAL;
388                 goto failed;
389         }
390         if (spp->sp_magic != SP_MAGIC) {
391                 printf("hpfs_mountfs: SpareBlock MAGIC DOESN'T MATCH\n");
392                 error = EINVAL;
393                 goto failed;
394         }
395
396         mp->mnt_data = (qaddr_t)hpmp;
397         hpmp->hpm_devvp = devvp;
398         hpmp->hpm_dev = devvp->v_rdev;
399         hpmp->hpm_mp = mp;
400         hpmp->hpm_uid = argsp->uid;
401         hpmp->hpm_gid = argsp->gid;
402         hpmp->hpm_mode = argsp->mode;
403
404         error = hpfs_bminit(hpmp);
405         if (error)
406                 goto failed;
407
408         error = hpfs_cpinit(hpmp, argsp);
409         if (error) {
410                 hpfs_bmdeinit(hpmp);
411                 goto failed;
412         }
413
414         error = hpfs_root(mp, &vp);
415         if (error) {
416                 hpfs_cpdeinit(hpmp);
417                 hpfs_bmdeinit(hpmp);
418                 goto failed;
419         }
420
421         vput(vp);
422
423 #if defined(__FreeBSD__)
424         mp->mnt_stat.f_fsid.val[0] = (long)dev2udev(dev);
425         mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
426 #else
427         mp->mnt_stat.f_fsid.val[0] = (long)dev;
428         mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_HPFS);
429 #endif
430         mp->mnt_maxsymlinklen = 0;
431         mp->mnt_flag |= MNT_LOCAL;
432         devvp->v_specmountpoint = mp;
433         return (0);
434
435 failed:
436         if (bp)
437                 brelse (bp);
438         mp->mnt_data = (qaddr_t)NULL;
439 #if defined(__FreeBSD__)
440         devvp->v_specmountpoint = NULL;
441 #else
442         devvp->v_specflags &= ~SI_MOUNTEDON;
443 #endif
444         (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, td);
445         return (error);
446 }
447
448 #if !defined(__FreeBSD__)
449 static int
450 hpfs_start (
451         struct mount *mp,
452         int flags,
453         struct thread *td )
454 {
455         return (0);
456 }
457 #endif
458
459 static int
460 hpfs_unmount( 
461         struct mount *mp,
462         int mntflags,
463         struct thread *td)
464 {
465         int error, flags, ronly;
466         struct hpfsmount *hpmp = VFSTOHPFS(mp);
467
468         dprintf(("hpfs_unmount():\n"));
469
470         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
471
472         flags = 0;
473         if(mntflags & MNT_FORCE)
474                 flags |= FORCECLOSE;
475
476         dprintf(("hpfs_unmount: vflushing...\n"));
477         
478         error = vflush(mp, 0, flags);
479         if (error) {
480                 printf("hpfs_unmount: vflush failed: %d\n",error);
481                 return (error);
482         }
483
484 #if defined(__FreeBSD__)
485         hpmp->hpm_devvp->v_specmountpoint = NULL;
486 #else
487         hpmp->hpm_devvp->v_specflags &= ~SI_MOUNTEDON;
488 #endif
489
490         vinvalbuf(hpmp->hpm_devvp, V_SAVE, td, 0, 0);
491         error = VOP_CLOSE(hpmp->hpm_devvp, ronly ? FREAD : FREAD|FWRITE, td);
492
493         vrele(hpmp->hpm_devvp);
494
495         dprintf(("hpfs_umount: freeing memory...\n"));
496         hpfs_cpdeinit(hpmp);
497         hpfs_bmdeinit(hpmp);
498         mp->mnt_data = (qaddr_t)0;
499         mp->mnt_flag &= ~MNT_LOCAL;
500         FREE(hpmp, M_HPFSMNT);
501
502         return (0);
503 }
504
505 static int
506 hpfs_root(
507         struct mount *mp,
508         struct vnode **vpp )
509 {
510         int error = 0;
511         struct hpfsmount *hpmp = VFSTOHPFS(mp);
512
513         dprintf(("hpfs_root():\n"));
514         error = VFS_VGET(mp, (ino_t)hpmp->hpm_su.su_rootfno, vpp);
515         if(error) {
516                 printf("hpfs_root: VFS_VGET failed: %d\n",error);
517                 return (error);
518         }
519
520         return (error);
521 }
522
523 static int
524 hpfs_statfs(
525         struct mount *mp,
526         struct statfs *sbp,
527         struct thread *td)
528 {
529         struct hpfsmount *hpmp = VFSTOHPFS(mp);
530
531         dprintf(("hpfs_statfs(): HPFS%d.%d\n",
532                 hpmp->hpm_su.su_hpfsver, hpmp->hpm_su.su_fnctver));
533
534 #if defined(__FreeBSD__)
535         sbp->f_type = mp->mnt_vfc->vfc_typenum;
536 #else /* defined(__NetBSD__) */
537         sbp->f_type = 0;
538 #endif
539         sbp->f_bsize = DEV_BSIZE;
540         sbp->f_iosize = DEV_BSIZE;
541         sbp->f_blocks = hpmp->hpm_su.su_btotal;
542         sbp->f_bfree = sbp->f_bavail = hpmp->hpm_bavail;
543         sbp->f_ffree = 0;
544         sbp->f_files = 0;
545         if (sbp != &mp->mnt_stat) {
546                 bcopy((caddr_t)mp->mnt_stat.f_mntonname,
547                         (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
548                 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
549                         (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
550         }
551         sbp->f_flags = mp->mnt_flag;
552         
553         return (0);
554 }
555
556 #if !defined(__FreeBSD__)
557 static int
558 hpfs_sync (
559         struct mount *mp,
560         int waitfor,
561         struct ucred *cred,
562         struct thread *td)
563 {
564         return (0);
565 }
566
567 static int
568 hpfs_quotactl ( 
569         struct mount *mp,
570         int cmds,
571         uid_t uid,
572         caddr_t arg,
573         struct thread *td)
574 {
575         printf("hpfs_quotactl():\n");
576         return (EOPNOTSUPP);
577 }
578 #endif
579
580 /*ARGSUSED*/
581 static int
582 hpfs_fhtovp(
583         struct mount *mp,
584         struct fid *fhp,
585         struct vnode **vpp)
586 {
587         struct vnode *nvp;
588         struct hpfid *hpfhp = (struct hpfid *)fhp;
589         int error;
590
591         if ((error = VFS_VGET(mp, hpfhp->hpfid_ino, &nvp)) != 0) {
592                 *vpp = NULLVP;
593                 return (error);
594         }
595         /* XXX as unlink/rmdir/mkdir/creat are not currently possible
596          * with HPFS, we don't need to check anything else for now */
597         *vpp = nvp;
598
599         return (0);
600 }
601
602 static int
603 hpfs_vptofh(
604         struct vnode *vp,
605         struct fid *fhp)
606 {
607         struct hpfsnode *hpp;
608         struct hpfid *hpfhp;
609
610         hpp = VTOHP(vp);
611         hpfhp = (struct hpfid *)fhp;
612         hpfhp->hpfid_len = sizeof(struct hpfid);
613         hpfhp->hpfid_ino = hpp->h_no;
614         /* hpfhp->hpfid_gen = hpp->h_gen; */
615         return (0);
616 }
617
618 static int
619 hpfs_vget(
620         struct mount *mp,
621         ino_t ino,
622         struct vnode **vpp) 
623 {
624         struct hpfsmount *hpmp = VFSTOHPFS(mp);
625         struct vnode *vp;
626         struct hpfsnode *hp;
627         struct buf *bp;
628         struct thread *td = curthread;  /* XXX */
629         int error;
630
631         dprintf(("hpfs_vget(0x%x): ",ino));
632
633         *vpp = NULL;
634         hp = NULL;
635         vp = NULL;
636
637         if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, td)) != NULL) {
638                 dprintf(("hashed\n"));
639                 return (0);
640         }
641
642         /*
643          * We have to lock node creation for a while,
644          * but then we have to call getnewvnode(), 
645          * this may cause hpfs_reclaim() to be called,
646          * this may need to VOP_VGET() parent dir for
647          * update reasons, and if parent is not in
648          * hash, we have to lock node creation...
649          * To solve this, we MALLOC, getnewvnode and init while
650          * not locked (probability of node appearence
651          * at that time is little, and anyway - we'll
652          * check for it).
653          */
654         MALLOC(hp, struct hpfsnode *, sizeof(struct hpfsnode), 
655                 M_HPFSNO, M_WAITOK);
656
657         error = getnewvnode(VT_HPFS, hpmp->hpm_mp, hpfs_vnodeop_p, &vp);
658         if (error) {
659                 printf("hpfs_vget: can't get new vnode\n");
660                 FREE(hp, M_HPFSNO);
661                 return (error);
662         }
663
664         dprintf(("prenew "));
665
666         vp->v_data = hp;
667
668         if (ino == (ino_t)hpmp->hpm_su.su_rootfno) 
669                 vp->v_flag |= VROOT;
670
671         lwkt_inittoken(&hp->h_interlock);
672         lockinit(&hp->h_lock, 0, "hpnode", VLKTIMEOUT, 0);
673
674         hp->h_flag = H_INVAL;
675         hp->h_vp = vp;
676         hp->h_hpmp = hpmp;
677         hp->h_no = ino;
678         hp->h_dev = hpmp->hpm_dev;
679         hp->h_uid = hpmp->hpm_uid;
680         hp->h_gid = hpmp->hpm_uid;
681         hp->h_mode = hpmp->hpm_mode;
682         hp->h_devvp = hpmp->hpm_devvp;
683         VREF(hp->h_devvp);
684
685         error = VN_LOCK(vp, LK_EXCLUSIVE, td);
686         if (error) {
687                 vput(vp);
688                 return (error);
689         }
690
691         do {
692                 if ((*vpp = hpfs_hphashvget(hpmp->hpm_dev, ino, td)) != NULL) {
693                         dprintf(("hashed2\n"));
694                         vput(vp);
695                         return (0);
696                 }
697         } while(LOCKMGR(&hpfs_hphash_lock,LK_EXCLUSIVE|LK_SLEEPFAIL,NULL,NULL));
698
699         hpfs_hphashins(hp);
700
701         LOCKMGR(&hpfs_hphash_lock, LK_RELEASE, NULL, NULL);
702
703         error = bread(hpmp->hpm_devvp, ino, FNODESIZE, &bp);
704         if (error) {
705                 printf("hpfs_vget: can't read ino %d\n",ino);
706                 vput(vp);
707                 return (error);
708         }
709         bcopy(bp->b_data, &hp->h_fn, sizeof(struct fnode));
710         brelse(bp);
711
712         if (hp->h_fn.fn_magic != FN_MAGIC) {
713                 printf("hpfs_vget: MAGIC DOESN'T MATCH\n");
714                 vput(vp);
715                 return (EINVAL);
716         }
717
718         vp->v_type = hp->h_fn.fn_flag ? VDIR:VREG;
719         hp->h_flag &= ~H_INVAL;
720
721         *vpp = vp;
722
723         return (0);
724 }
725
726 #if defined(__FreeBSD__)
727 static struct vfsops hpfs_vfsops = {
728         hpfs_mount,
729         vfs_stdstart,
730         hpfs_unmount,
731         hpfs_root,
732         vfs_stdquotactl,
733         hpfs_statfs,
734         vfs_stdsync,
735         hpfs_vget,
736         hpfs_fhtovp,
737         hpfs_checkexp,
738         hpfs_vptofh,
739         hpfs_init,
740         hpfs_hphash_uninit,
741         vfs_stdextattrctl,
742 };
743 VFS_SET(hpfs_vfsops, hpfs, 0);
744 #else /* defined(__NetBSD__) */
745 extern struct vnodeopv_desc hpfs_vnodeop_opv_desc;
746
747 struct vnodeopv_desc *hpfs_vnodeopv_descs[] = {
748         &hpfs_vnodeop_opv_desc,
749         NULL,
750 };
751
752 struct vfsops hpfs_vfsops = {
753         MOUNT_HPFS,
754         hpfs_mount,
755         hpfs_start,
756         hpfs_unmount,
757         hpfs_root,
758         hpfs_quotactl,
759         hpfs_statfs,
760         hpfs_sync,
761         hpfs_vget,
762         hpfs_fhtovp,
763         hpfs_vptofh,
764         hpfs_init,
765         hpfs_sysctl,
766         hpfs_mountroot,
767         hpfs_checkexp,
768         hpfs_vnodeopv_descs,
769 };
770 #endif