root/ntfs/ntfs_vnops.c

DEFINITIONS

1. ntfs_getpages
2. ntfs_putpages
3. ntfs_bmap
4. ntfs_read
5. ntfs_bypass
6. ntfs_getattr
7. ntfs_inactive
8. ntfs_reclaim
9. ntfs_print
10. ntfs_strategy
11. ntfs_write
12. ntfs_access
13. ntfs_open
14. ntfs_close
15. ntfs_readdir
16. ntfs_lookup
17. ntfs_fsync
18. ntfs_pathconf

    1 /*      $OpenBSD: ntfs_vnops.c,v 1.11 2007/06/01 23:52:38 deraadt Exp $ */
    2 /*      $NetBSD: ntfs_vnops.c,v 1.6 2003/04/10 21:57:26 jdolecek Exp $  */
    4 /*
    5  * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * This code is derived from software contributed to Berkeley by
    9  * John Heidemann of the UCLA Ficus project.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      Id: ntfs_vnops.c,v 1.5 1999/05/12 09:43:06 semenu Exp
   36  *
   37  */
   39 #include <sys/cdefs.h>
   40 #ifdef __KERNEL_RCSID
   41 __KERNEL_RCSID(0, "$NetBSD: ntfs_vnops.c,v 1.6 2003/04/10 21:57:26 jdolecek Exp $");
   42 #endif
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/kernel.h>
   47 #include <sys/time.h>
   48 #include <sys/stat.h>
   49 #include <sys/vnode.h>
   50 #include <sys/mount.h>
   51 #include <sys/namei.h>
   52 #include <sys/malloc.h>
   53 #include <sys/buf.h>
   54 #include <sys/dirent.h>
   56 #if !defined(__NetBSD__) && !defined(__OpenBSD__)
   57 #include <vm/vm.h>
   58 #endif
   60 #if defined(__FreeBSD__)
   61 #include <vm/vnode_pager.h>
   62 #endif
   64 #include <sys/sysctl.h>
   67 /*#define NTFS_DEBUG 1*/
   68 #if defined(__FreeBSD__) || defined(__NetBSD__)
   69 #include <fs/ntfs/ntfs.h>
   70 #include <fs/ntfs/ntfs_inode.h>
   71 #include <fs/ntfs/ntfs_subr.h>
   72 #include <miscfs/genfs/genfs.h>
   73 #else
   74 #include <ntfs/ntfs.h>
   75 #include <ntfs/ntfs_inode.h>
   76 #include <ntfs/ntfs_subr.h>
   77 #endif
   79 #include <miscfs/specfs/specdev.h>
   81 #include <sys/unistd.h> /* for pathconf(2) constants */
   83 static int      ntfs_bypass(struct vop_generic_args *ap);
   84 static int      ntfs_read(struct vop_read_args *);
   85 static int      ntfs_write(struct vop_write_args *ap);
   86 static int      ntfs_getattr(struct vop_getattr_args *ap);
   87 static int      ntfs_inactive(struct vop_inactive_args *ap);
   88 static int      ntfs_print(struct vop_print_args *ap);
   89 static int      ntfs_reclaim(struct vop_reclaim_args *ap);
   90 static int      ntfs_strategy(struct vop_strategy_args *ap);
   91 static int      ntfs_access(struct vop_access_args *ap);
   92 static int      ntfs_open(struct vop_open_args *ap);
   93 static int      ntfs_close(struct vop_close_args *ap);
   94 static int      ntfs_readdir(struct vop_readdir_args *ap);
   95 static int      ntfs_lookup(struct vop_lookup_args *ap);
   96 static int      ntfs_bmap(struct vop_bmap_args *ap);
   97 #if defined(__FreeBSD__)
   98 static int      ntfs_getpages(struct vop_getpages_args *ap);
   99 static int      ntfs_putpages(struct vop_putpages_args *);
  100 #endif
  101 #if defined(__FreeBSD__) || defined(__OpenBSD__)
  102 static int      ntfs_fsync(struct vop_fsync_args *ap);
  103 #endif
  104 static int      ntfs_pathconf(void *);
  106 int     ntfs_prtactive = 1;     /* 1 => print out reclaim of active vnodes */
  108 #if defined(__FreeBSD__)
  109 int
ntfs_getpages(ap)
  111         struct vop_getpages_args *ap;
  112 {
  113         return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, ap->a_count,
ap->a_reqpage);
  115 }
  117 int
ntfs_putpages(ap)
  119         struct vop_putpages_args *ap;
  120 {
  121         return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
ap->a_sync, ap->a_rtvals);
  123 }
  124 #endif
  126 /*
  127  * This is a noop, simply returning what one has been given.
  128  */
  129 int
ntfs_bmap(ap)
  131         struct vop_bmap_args *ap;
  132 {
dprintf(("ntfs_bmap: vn: %p, blk: %d\n", ap->a_vp,(u_int32_t)ap->a_bn));
  134         if (ap->a_vpp != NULL)
  135                 *ap->a_vpp = ap->a_vp;
  136         if (ap->a_bnp != NULL)
  137                 *ap->a_bnp = ap->a_bn;
  138         if (ap->a_runp != NULL)
  139                 *ap->a_runp = 0;
  140 #if !defined(__NetBSD__) && !defined(__OpenBSD__)
  141         if (ap->a_runb != NULL)
  142                 *ap->a_runb = 0;
  143 #endif
  144         return (0);
  145 }
  147 static int
ntfs_read(ap)
  149         struct vop_read_args *ap;
  150 {
  151         struct vnode *vp = ap->a_vp;
  152         struct fnode *fp = VTOF(vp);
  153         struct ntnode *ip = FTONT(fp);
  154         struct uio *uio = ap->a_uio;
  155         struct ntfsmount *ntmp = ip->i_mp;
u_int64_t toread;
  157         int error;
dprintf(("ntfs_read: ino: %d, off: %d resid: %d, segflg: %d\n",ip->i_number,(u_int32_t)uio->uio_offset,uio->uio_resid,uio->uio_segflg));
dprintf(("ntfs_read: filesize: %d",(u_int32_t)fp->f_size));
  163         /* don't allow reading after end of file */
  164         if (uio->uio_offset > fp->f_size)
toread = 0;
  166         else
toread = MIN(uio->uio_resid, fp->f_size - uio->uio_offset );
dprintf((", toread: %d\n",(u_int32_t)toread));
  171         if (toread == 0)
  172                 return (0);
error = ntfs_readattr(ntmp, ip, fp->f_attrtype,
fp->f_attrname, uio->uio_offset, toread, NULL, uio);
  176         if (error) {
printf("ntfs_read: ntfs_readattr failed: %d\n",error);
  178                 return (error);
  179         }
  181         return (0);
  182 }
  184 static int
ntfs_bypass(ap)
  186         struct vop_generic_args *ap;
  187 {
  188         int error = ENOTTY;
dprintf(("ntfs_bypass: %s\n", ap->a_desc->vdesc_name));
  190         return (error);
  191 }
  194 static int
ntfs_getattr(ap)
  196         struct vop_getattr_args *ap;
  197 {
  198         struct vnode *vp = ap->a_vp;
  199         struct fnode *fp = VTOF(vp);
  200         struct ntnode *ip = FTONT(fp);
  201         struct vattr *vap = ap->a_vap;
dprintf(("ntfs_getattr: %d, flags: %d\n",ip->i_number,ip->i_flag));
  205 #if defined(__FreeBSD__)
vap->va_fsid = dev2udev(ip->i_dev);
  207 #else /* NetBSD */
vap->va_fsid = ip->i_dev;
  209 #endif
vap->va_fileid = ip->i_number;
vap->va_mode = ip->i_mp->ntm_mode;
vap->va_nlink = ip->i_nlink;
vap->va_uid = ip->i_mp->ntm_uid;
vap->va_gid = ip->i_mp->ntm_gid;
vap->va_rdev = 0;                               /* XXX UNODEV ? */
vap->va_size = fp->f_size;
vap->va_bytes = fp->f_allocated;
vap->va_atime = ntfs_nttimetounix(fp->f_times.t_access);
vap->va_mtime = ntfs_nttimetounix(fp->f_times.t_write);
vap->va_ctime = ntfs_nttimetounix(fp->f_times.t_create);
vap->va_flags = ip->i_flag;
vap->va_gen = 0;
vap->va_blocksize = ip->i_mp->ntm_spc * ip->i_mp->ntm_bps;
vap->va_type = vp->v_type;
vap->va_filerev = 0;
  226         return (0);
  227 }
  230 /*
  231  * Last reference to an ntnode.  If necessary, write or delete it.
  232  */
  233 int
ntfs_inactive(ap)
  235         struct vop_inactive_args *ap;
  236 {
  237         struct vnode *vp = ap->a_vp;
  238 #ifdef __OpenBSD__
  239         struct proc *p = ap->a_p;
  240 #endif
  241 #ifdef NTFS_DEBUG
  242         struct ntnode *ip = VTONT(vp);
  243 #endif
dprintf(("ntfs_inactive: vnode: %p, ntnode: %d\n", vp, ip->i_number));
  247 #ifdef DIAGNOSTIC
  248         if (ntfs_prtactive && vp->v_usecount != 0)
vprint("ntfs_inactive: pushing active", vp);
  250 #endif
VOP__UNLOCK(vp, 0, p);
  254         /* XXX since we don't support any filesystem changes
  255          * right now, nothing more needs to be done
  256          */
  257         return (0);
  258 }
  260 /*
  261  * Reclaim an fnode/ntnode so that it can be used for other purposes.
  262  */
  263 int
ntfs_reclaim(ap)
  265         struct vop_reclaim_args *ap;
  266 {
  267         struct vnode *vp = ap->a_vp;
  268         struct fnode *fp = VTOF(vp);
  269         struct ntnode *ip = FTONT(fp);
  270 #ifdef __OpenBSD__
  271         struct proc *p = ap->a_p;
  272 #endif
  273         int error;
dprintf(("ntfs_reclaim: vnode: %p, ntnode: %d\n", vp, ip->i_number));
  277 #ifdef DIAGNOSTIC
  278         if (ntfs_prtactive && vp->v_usecount != 0)
vprint("ntfs_reclaim: pushing active", vp);
  280 #endif
  282 #ifndef __OpenBSD__
  283         if ((error = ntfs_ntget(ip)) != 0)
  284 #else
  285         if ((error = ntfs_ntget(ip, p)) != 0)
  286 #endif
  287                 return (error);
  289         /* Purge old data structures associated with the inode. */
cache_purge(vp);
ntfs_frele(fp);
  293 #ifndef __OpenBSD__
ntfs_ntput(ip);
  295 #else
ntfs_ntput(ip, p);
  297 #endif
vp->v_data = NULL;
  300         return (0);
  301 }
  303 static int
ntfs_print(ap)
  305         struct vop_print_args *ap;
  306 {
  307         struct ntnode *ip = VTONT(ap->a_vp);
printf("tag VT_NTFS, ino %u, flag %#x, usecount %d, nlink %ld\n",
ip->i_number, ip->i_flag, ip->i_usecount, ip->i_nlink);
  312         return (0);
  313 }
  315 /*
  316  * Calculate the logical to physical mapping if not done already,
  317  * then call the device strategy routine.
  318  */
  319 int
ntfs_strategy(ap)
  321         struct vop_strategy_args *ap;
  322 {
  323         struct buf *bp = ap->a_bp;
  324         struct vnode *vp = bp->b_vp;
  325         struct fnode *fp = VTOF(vp);
  326         struct ntnode *ip = FTONT(fp);
  327         struct ntfsmount *ntmp = ip->i_mp;
  328         int error;
  330 #ifdef __FreeBSD__
dprintf(("ntfs_strategy: offset: %d, blkno: %d, lblkno: %d\n",
  332                 (u_int32_t)bp->b_offset,(u_int32_t)bp->b_blkno,
  333                 (u_int32_t)bp->b_lblkno));
  334 #else
dprintf(("ntfs_strategy: blkno: %d, lblkno: %d\n",
  336                 (u_int32_t)bp->b_blkno,
  337                 (u_int32_t)bp->b_lblkno));
  338 #endif
dprintf(("strategy: bcount: %u flags: 0x%x\n", 
  341                 (u_int32_t)bp->b_bcount,bp->b_flags));
  343         if (bp->b_flags & B_READ) {
u_int32_t toread;
  346                 if (ntfs_cntob(bp->b_blkno) >= fp->f_size) {
clrbuf(bp);
error = 0;
  349                 } else {
toread = MIN(bp->b_bcount,
fp->f_size - ntfs_cntob(bp->b_blkno));
dprintf(("ntfs_strategy: toread: %d, fsize: %d\n",
toread,(u_int32_t)fp->f_size));
error = ntfs_readattr(ntmp, ip, fp->f_attrtype,
fp->f_attrname, ntfs_cntob(bp->b_blkno),
toread, bp->b_data, NULL);
  359                         if (error) {
printf("ntfs_strategy: ntfs_readattr failed\n");
bp->b_error = error;
bp->b_flags |= B_ERROR;
  363                         }
bzero(bp->b_data + toread, bp->b_bcount - toread);
  366                 }
  367         } else {
size_t tmp;
u_int32_t towrite;
  371                 if (ntfs_cntob(bp->b_blkno) + bp->b_bcount >= fp->f_size) {
printf("ntfs_strategy: CAN'T EXTEND FILE\n");
bp->b_error = error = EFBIG;
bp->b_flags |= B_ERROR;
  375                 } else {
towrite = MIN(bp->b_bcount,
fp->f_size - ntfs_cntob(bp->b_blkno));
dprintf(("ntfs_strategy: towrite: %d, fsize: %d\n",
towrite,(u_int32_t)fp->f_size));
error = ntfs_writeattr_plain(ntmp, ip, fp->f_attrtype,  
fp->f_attrname, ntfs_cntob(bp->b_blkno),towrite,
bp->b_data, &tmp, NULL);
  385                         if (error) {
printf("ntfs_strategy: ntfs_writeattr fail\n");
bp->b_error = error;
bp->b_flags |= B_ERROR;
  389                         }
  390                 }
  391         }
biodone(bp);
  393         return (error);
  394 }
  396 static int
ntfs_write(ap)
  398         struct vop_write_args *ap;
  399 {
  400         struct vnode *vp = ap->a_vp;
  401         struct fnode *fp = VTOF(vp);
  402         struct ntnode *ip = FTONT(fp);
  403         struct uio *uio = ap->a_uio;
  404         struct ntfsmount *ntmp = ip->i_mp;
u_int64_t towrite;
size_t written;
  407         int error;
dprintf(("ntfs_write: ino: %d, off: %d resid: %d, segflg: %d\n",ip->i_number,(u_int32_t)uio->uio_offset,uio->uio_resid,uio->uio_segflg));
dprintf(("ntfs_write: filesize: %d",(u_int32_t)fp->f_size));
  412         if (uio->uio_resid + uio->uio_offset > fp->f_size) {
printf("ntfs_write: CAN'T WRITE BEYOND END OF FILE\n");
  414                 return (EFBIG);
  415         }
towrite = MIN(uio->uio_resid, fp->f_size - uio->uio_offset);
dprintf((", towrite: %d\n",(u_int32_t)towrite));
error = ntfs_writeattr_plain(ntmp, ip, fp->f_attrtype,
fp->f_attrname, uio->uio_offset, towrite, NULL, &written, uio);
  423 #ifdef NTFS_DEBUG
  424         if (error)
printf("ntfs_write: ntfs_writeattr failed: %d\n", error);
  426 #endif
  428         return (error);
  429 }
  431 int
ntfs_access(ap)
  433         struct vop_access_args *ap;
  434 {
  435         struct vnode *vp = ap->a_vp;
  436         struct ntnode *ip = VTONT(vp);
  437         struct ucred *cred = ap->a_cred;
mode_t mask, mode = ap->a_mode;
gid_t *gp;
  440         int i;
dprintf(("ntfs_access: %d\n",ip->i_number));
  444         /*
  445          * Disallow write attempts on read-only file systems;
  446          * unless the file is a socket, fifo, or a block or
  447          * character device resident on the file system.
  448          */
  449         if (mode & VWRITE) {
  450                 switch ((int)vp->v_type) {
  451                 case VDIR:
  452                 case VLNK:
  453                 case VREG:
  454                         if (vp->v_mount->mnt_flag & MNT_RDONLY)
  455                                 return (EROFS);
  456                         break;
  457                 }
  458         }
  460         /* Otherwise, user id 0 always gets access. */
  461         if (cred->cr_uid == 0)
  462                 return (0);
mask = 0;
  466         /* Otherwise, check the owner. */
  467         if (cred->cr_uid == ip->i_mp->ntm_uid) {
  468                 if (mode & VEXEC)
mask |= S_IXUSR;
  470                 if (mode & VREAD)
mask |= S_IRUSR;
  472                 if (mode & VWRITE)
mask |= S_IWUSR;
  474                 return ((ip->i_mp->ntm_mode & mask) == mask ? 0 : EACCES);
  475         }
  477         /* Otherwise, check the groups. */
  478         for (i = 0, gp = cred->cr_groups; i < cred->cr_ngroups; i++, gp++)
  479                 if (ip->i_mp->ntm_gid == *gp) {
  480                         if (mode & VEXEC)
mask |= S_IXGRP;
  482                         if (mode & VREAD)
mask |= S_IRGRP;
  484                         if (mode & VWRITE)
mask |= S_IWGRP;
  486                         return ((ip->i_mp->ntm_mode&mask) == mask ? 0 : EACCES);
  487                 }
  489         /* Otherwise, check everyone else. */
  490         if (mode & VEXEC)
mask |= S_IXOTH;
  492         if (mode & VREAD)
mask |= S_IROTH;
  494         if (mode & VWRITE)
mask |= S_IWOTH;
  496         return ((ip->i_mp->ntm_mode & mask) == mask ? 0 : EACCES);
  497 }
  499 /*
  500  * Open called.
  501  *
  502  * Nothing to do.
  503  */
  504 /* ARGSUSED */
  505 static int
ntfs_open(ap)
  507         struct vop_open_args *ap;
  508 {
  509 #if NTFS_DEBUG
  510         struct vnode *vp = ap->a_vp;
  511         struct ntnode *ip = VTONT(vp);
printf("ntfs_open: %d\n",ip->i_number);
  514 #endif
  516         /*
  517          * Files marked append-only must be opened for appending.
  518          */
  520         return (0);
  521 }
  523 /*
  524  * Close called.
  525  *
  526  * Update the times on the inode.
  527  */
  528 /* ARGSUSED */
  529 static int
ntfs_close(ap)
  531         struct vop_close_args *ap;
  532 {
  533 #if NTFS_DEBUG
  534         struct vnode *vp = ap->a_vp;
  535         struct ntnode *ip = VTONT(vp);
printf("ntfs_close: %d\n",ip->i_number);
  538 #endif
  540         return (0);
  541 }
  543 int
ntfs_readdir(ap)
  545         struct vop_readdir_args *ap;
  546 {
  547         struct vnode *vp = ap->a_vp;
  548         struct fnode *fp = VTOF(vp);
  549         struct ntnode *ip = FTONT(fp);
  550         struct uio *uio = ap->a_uio;
  551         struct ntfsmount *ntmp = ip->i_mp;
  552         int i, error = 0;
u_int32_t faked = 0, num;
  554         int ncookies = 0;
  555         struct dirent *cde;
off_t off;
dprintf(("ntfs_readdir %d off: %d resid: %d\n",ip->i_number,(u_int32_t)uio->uio_offset,uio->uio_resid));
off = uio->uio_offset;
MALLOC(cde, struct dirent *, sizeof(struct dirent), M_TEMP, M_WAITOK);
  564         /* Simulate . in every dir except ROOT */
  565         if (ip->i_number != NTFS_ROOTINO
  566             && uio->uio_offset < sizeof(struct dirent)) {
cde->d_fileno = ip->i_number;
cde->d_reclen = sizeof(struct dirent);
cde->d_type = DT_DIR;
cde->d_namlen = 1;
strncpy(cde->d_name, ".", 2);
error = uiomove((void *)cde, sizeof(struct dirent), uio);
  573                 if (error)
  574                         goto out;
ncookies++;
  577         }
  579         /* Simulate .. in every dir including ROOT */
  580         if (uio->uio_offset < 2 * sizeof(struct dirent)) {
cde->d_fileno = NTFS_ROOTINO;   /* XXX */
cde->d_reclen = sizeof(struct dirent);
cde->d_type = DT_DIR;
cde->d_namlen = 2;
strncpy(cde->d_name, "..", 3);
error = uiomove((void *) cde, sizeof(struct dirent), uio);
  588                 if (error)
  589                         goto out;
ncookies++;
  592         }
faked = (ip->i_number == NTFS_ROOTINO) ? 1 : 2;
num = uio->uio_offset / sizeof(struct dirent) - faked;
  597         while (uio->uio_resid >= sizeof(struct dirent)) {
  598                 struct attr_indexentry *iep;
  599                 char *fname;
size_t remains;
  601                 int sz;
  603 #ifndef __OpenBSD__
error = ntfs_ntreaddir(ntmp, fp, num, &iep);
  605 #else
error = ntfs_ntreaddir(ntmp, fp, num, &iep, uio->uio_procp);
  607 #endif
  608                 if (error)
  609                         goto out;
  611                 if (NULL == iep)
  612                         break;
  614                 for(; !(iep->ie_flag & NTFS_IEFLAG_LAST) && (uio->uio_resid >= sizeof(struct dirent));
iep = NTFS_NEXTREC(iep, struct attr_indexentry *))
  616                 {
  617                         if(!ntfs_isnamepermitted(ntmp,iep))
  618                                 continue;
remains = sizeof(cde->d_name) - 1;
fname = cde->d_name;
  622                         for(i=0; i<iep->ie_fnamelen; i++) {
sz = (*ntmp->ntm_wput)(fname, remains,
iep->ie_fname[i]);
fname += sz;
remains -= sz;
  627                         }
  628                         *fname = '\0';
dprintf(("ntfs_readdir: elem: %d, fname:[%s] type: %d, flag: %d, ",
num, cde->d_name, iep->ie_fnametype,
iep->ie_flag));
cde->d_namlen = fname - (char *) cde->d_name;
cde->d_fileno = iep->ie_number;
cde->d_type = (iep->ie_fflag & NTFS_FFLAG_DIR) ? DT_DIR : DT_REG;
cde->d_reclen = sizeof(struct dirent);
dprintf(("%s\n", (cde->d_type == DT_DIR) ? "dir":"reg"));
error = uiomove((void *)cde, sizeof(struct dirent), uio);
  639                         if (error)
  640                                 goto out;
ncookies++;
num++;
  644                 }
  645         }
dprintf(("ntfs_readdir: %d entries (%d bytes) read\n",
ncookies,(u_int)(uio->uio_offset - off)));
dprintf(("ntfs_readdir: off: %d resid: %d\n",
  650                 (u_int32_t)uio->uio_offset,uio->uio_resid));
  652         if (!error && ap->a_ncookies != NULL) {
  653                 struct dirent* dpStart;
  654                 struct dirent* dp;
  655 #if defined(__FreeBSD__) || defined(__OpenBSD__)
u_long *cookies;
u_long *cookiep;
  658 #else /* defined(__NetBSD__) */
off_t *cookies;
off_t *cookiep;
  661 #endif
dprintf(("ntfs_readdir: %d cookies\n",ncookies));
  664                 if (uio->uio_segflg != UIO_SYSSPACE || uio->uio_iovcnt != 1)
panic("ntfs_readdir: unexpected uio from NFS server");
dpStart = (struct dirent *)
  667                      ((caddr_t)uio->uio_iov->iov_base -
  668                          (uio->uio_offset - off));
  669 #if defined(__FreeBSD__)
MALLOC(cookies, u_long *, ncookies * sizeof(u_long),
M_TEMP, M_WAITOK);
  672 #else /* defined(__NetBSD__) */
cookies = malloc(ncookies * sizeof(off_t), M_TEMP, M_WAITOK);
  674 #endif
  675                 for (dp = dpStart, cookiep = cookies, i=0;
i < ncookies;
dp = (struct dirent *)((caddr_t) dp + dp->d_reclen), i++) {
off += dp->d_reclen;
  679                         *cookiep++ = (u_int) off;
  680                 }
  681                 *ap->a_ncookies = ncookies;
  682                 *ap->a_cookies = cookies;
  683         }
  684 /*
  685         if (ap->a_eofflag)
  686             *ap->a_eofflag = VTONT(ap->a_vp)->i_size <= uio->uio_offset;
  687 */
out:
FREE(cde, M_TEMP);
  690         return (error);
  691 }
  693 int
ntfs_lookup(ap)
  695         struct vop_lookup_args *ap;
  696 {
  697         struct vnode *dvp = ap->a_dvp;
  698         struct ntnode *dip = VTONT(dvp);
  699         struct ntfsmount *ntmp = dip->i_mp;
  700         struct componentname *cnp = ap->a_cnp;
  701         struct ucred *cred = cnp->cn_cred;
  702         int error;
  703         int lockparent = cnp->cn_flags & LOCKPARENT;
  704 #ifdef __OpenBSD__
  705         struct proc *p = cnp->cn_proc;
  706 #endif
  707 #if NTFS_DEBUG
  708         int wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
  709 #endif
dprintf(("ntfs_lookup: \"%.*s\" (%ld bytes) in %d, lp: %d, wp: %d \n",
  711                 (int)cnp->cn_namelen, cnp->cn_nameptr, cnp->cn_namelen,
dip->i_number, lockparent, wantparent));
error = VOP_ACCESS(dvp, VEXEC, cred, cnp->cn_proc);
  715         if(error)
  716                 return (error);
  718         if ((cnp->cn_flags & ISLASTCN) &&
  719             (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
  720             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
  721                 return (EROFS);
  723 #if defined(__NetBSD__) || defined(__OpenBSD__)
  724         /*
  725          * We now have a segment name to search for, and a directory
  726          * to search.
  727          *
  728          * Before tediously performing a linear scan of the directory,
  729          * check the name cache to see if the directory/name pair
  730          * we are looking for is known already.
  731          */
  732         if ((error = cache_lookup(ap->a_dvp, ap->a_vpp, cnp)) >= 0)
  733                 return (error);
  734 #endif
  736         if(cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
dprintf(("ntfs_lookup: faking . directory in %d\n",
dip->i_number));
VREF(dvp);
  741                 *ap->a_vpp = dvp;
error = 0;
  743         } else if (cnp->cn_flags & ISDOTDOT) {
  744                 struct ntvattr *vap;
dprintf(("ntfs_lookup: faking .. directory in %d\n",
dip->i_number));
VOP__UNLOCK(dvp, 0, p);
cnp->cn_flags |= PDIRUNLOCK;
error = ntfs_ntvattrget(ntmp, dip, NTFS_A_NAME, NULL, 0, &vap);
  753                 if(error)
  754                         return (error);
dprintf(("ntfs_lookup: parentdir: %d\n",
vap->va_a_name->n_pnumber));
error = VFS_VGET(ntmp->ntm_mountp,
vap->va_a_name->n_pnumber,ap->a_vpp); 
ntfs_ntvattrrele(vap);
  761                 if (error) {
  762                         if (VN_LOCK(dvp, LK_EXCLUSIVE | LK_RETRY, p) == 0)
cnp->cn_flags &= ~PDIRUNLOCK;
  764                         return (error);
  765                 }
  767                 if (lockparent && (cnp->cn_flags & ISLASTCN)) {
error = VN_LOCK(dvp, LK_EXCLUSIVE, p);
  769                         if (error) {
vput( *(ap->a_vpp) );
  771                                 return (error);
  772                         }
cnp->cn_flags &= ~PDIRUNLOCK;
  774                 }
  775         } else {
  776 #ifndef __OpenBSD__
error = ntfs_ntlookupfile(ntmp, dvp, cnp, ap->a_vpp);
  778 #else
error = ntfs_ntlookupfile(ntmp, dvp, cnp, ap->a_vpp, p);
  780 #endif
  781                 if (error) {
dprintf(("ntfs_ntlookupfile: returned %d\n", error));
  783                         return (error);
  784                 }
dprintf(("ntfs_lookup: found ino: %d\n", 
VTONT(*ap->a_vpp)->i_number));
  789                 if(!lockparent || (cnp->cn_flags & ISLASTCN) == 0) {
VOP__UNLOCK(dvp, 0, p);
cnp->cn_flags |= PDIRUNLOCK;
  792                 }
  793         }
  795         if (cnp->cn_flags & MAKEENTRY)
cache_enter(dvp, *ap->a_vpp, cnp);
  798         return (error);
  799 }
  801 #if defined(__FreeBSD__) || defined(__OpenBSD__)
  802 /*
  803  * Flush the blocks of a file to disk.
  804  *
  805  * This function is worthless for vnodes that represent directories. Maybe we
  806  * could just do a sync if they try an fsync on a directory file.
  807  */
  808 static int
ntfs_fsync(ap)
  810         struct vop_fsync_args *ap;
  811 {
  812         return (0);
  813 }
  814 #endif
  816 /*
  817  * Return POSIX pathconf information applicable to NTFS filesystem
  818  */
  819 static int
ntfs_pathconf(v)
  821         void *v;
  822 {
  823         struct vop_pathconf_args *ap = v;
  825         switch (ap->a_name) {
  826         case _PC_LINK_MAX:
  827                 *ap->a_retval = 1;
  828                 return (0);
  829         case _PC_NAME_MAX:
  830                 *ap->a_retval = NTFS_MAXFILENAME;
  831                 return (0);
  832         case _PC_PATH_MAX:
  833                 *ap->a_retval = PATH_MAX;
  834                 return (0);
  835         case _PC_CHOWN_RESTRICTED:
  836                 *ap->a_retval = 1;
  837                 return (0);
  838         case _PC_NO_TRUNC:
  839                 *ap->a_retval = 0;
  840                 return (0);
  841 #ifdef __NetBSD__
  842         case _PC_SYNC_IO:
  843                 *ap->a_retval = 1;
  844                 return (0);
  845         case _PC_FILESIZEBITS:
  846                 *ap->a_retval = 64;
  847                 return (0);
  848 #endif
  849         default:
  850                 return (EINVAL);
  851         }
  852         /* NOTREACHED */
  853 }
  855 /*
  856  * Global vfs data structures
  857  */
vop_t **ntfs_vnodeop_p;
  859 #if defined(__FreeBSD__)
  860 static
  861 struct vnodeopv_entry_desc ntfs_vnodeop_entries[] = {
  862         { &vop_default_desc, (vop_t *)ntfs_bypass },
  864         { &vop_getattr_desc, (vop_t *)ntfs_getattr },
  865         { &vop_inactive_desc, (vop_t *)ntfs_inactive },
  866         { &vop_reclaim_desc, (vop_t *)ntfs_reclaim },
  867         { &vop_print_desc, (vop_t *)ntfs_print },
  868         { &vop_pathconf_desc, ntfs_pathconf },
  870         { &vop_islocked_desc, (vop_t *)vop_stdislocked },
  871         { &vop_unlock_desc, (vop_t *)vop_stdunlock },
  872         { &vop_lock_desc, (vop_t *)vop_stdlock },
  873         { &vop_cachedlookup_desc, (vop_t *)ntfs_lookup },
  874         { &vop_lookup_desc, (vop_t *)vfs_cache_lookup },
  876         { &vop_access_desc, (vop_t *)ntfs_access },
  877         { &vop_close_desc, (vop_t *)ntfs_close },
  878         { &vop_open_desc, (vop_t *)ntfs_open },
  879         { &vop_readdir_desc, (vop_t *)ntfs_readdir },
  880         { &vop_fsync_desc, (vop_t *)ntfs_fsync },
  882         { &vop_bmap_desc, (vop_t *)ntfs_bmap },
  883         { &vop_getpages_desc, (vop_t *) ntfs_getpages },
  884         { &vop_putpages_desc, (vop_t *) ntfs_putpages },
  885         { &vop_strategy_desc, (vop_t *)ntfs_strategy },
  886         { &vop_bwrite_desc, (vop_t *)vop_stdbwrite },
  887         { &vop_read_desc, (vop_t *)ntfs_read },
  888         { &vop_write_desc, (vop_t *)ntfs_write },
  890         { NULL, NULL }
  891 };
  893 static
  894 struct vnodeopv_desc ntfs_vnodeop_opv_desc =
  895         { &ntfs_vnodeop_p, ntfs_vnodeop_entries };
  897 VNODEOP_SET(ntfs_vnodeop_opv_desc);
  899 #elif defined(__OpenBSD__)
  900 static
  901 struct vnodeopv_entry_desc ntfs_vnodeop_entries[] = {
  902         { &vop_default_desc, (vop_t *)ntfs_bypass },
  904         { &vop_getattr_desc, (vop_t *)ntfs_getattr },
  905         { &vop_inactive_desc, (vop_t *)ntfs_inactive },
  906         { &vop_reclaim_desc, (vop_t *)ntfs_reclaim },
  907         { &vop_print_desc, (vop_t *)ntfs_print },
  908         { &vop_pathconf_desc, ntfs_pathconf },
  910         { &vop_islocked_desc, (vop_t *)vop_generic_islocked },
  911         { &vop_unlock_desc, (vop_t *)vop_generic_unlock },
  912         { &vop_lock_desc, (vop_t *)vop_generic_lock },
  913         { &vop_lookup_desc, (vop_t *)ntfs_lookup },
  915         { &vop_access_desc, (vop_t *)ntfs_access },
  916         { &vop_close_desc, (vop_t *)ntfs_close },
  917         { &vop_open_desc, (vop_t *)ntfs_open },
  918         { &vop_readdir_desc, (vop_t *)ntfs_readdir },
  919         { &vop_fsync_desc, (vop_t *)ntfs_fsync },
  921         { &vop_bmap_desc, (vop_t *)ntfs_bmap },
  922         { &vop_strategy_desc, (vop_t *)ntfs_strategy },
  923         { &vop_bwrite_desc, (vop_t *)vop_generic_bwrite },
  924         { &vop_read_desc, (vop_t *)ntfs_read },
  925         { &vop_write_desc, (vop_t *)ntfs_write },
  927         { NULL, NULL }
  928 };
  930 const struct vnodeopv_desc ntfs_vnodeop_opv_desc =
  931         { &ntfs_vnodeop_p, ntfs_vnodeop_entries };
  933 #else /* !FreeBSD && !OpenBSD*/
  935 const struct vnodeopv_entry_desc ntfs_vnodeop_entries[] = {
  936         { &vop_default_desc, (vop_t *) ntfs_bypass },
  937         { &vop_lookup_desc, (vop_t *) ntfs_lookup },    /* lookup */
  938         { &vop_create_desc, genfs_eopnotsupp },         /* create */
  939         { &vop_mknod_desc, genfs_eopnotsupp },          /* mknod */
  940         { &vop_open_desc, (vop_t *) ntfs_open },        /* open */
  941         { &vop_close_desc,(vop_t *)  ntfs_close },      /* close */
  942         { &vop_access_desc, (vop_t *) ntfs_access },    /* access */
  943         { &vop_getattr_desc, (vop_t *) ntfs_getattr },  /* getattr */
  944         { &vop_setattr_desc, genfs_eopnotsupp },        /* setattr */
  945         { &vop_read_desc, (vop_t *) ntfs_read },        /* read */
  946         { &vop_write_desc, (vop_t *) ntfs_write },      /* write */
  947         { &vop_lease_desc, genfs_lease_check },         /* lease */
  948         { &vop_fcntl_desc, genfs_fcntl },               /* fcntl */
  949         { &vop_ioctl_desc, genfs_enoioctl },            /* ioctl */
  950         { &vop_poll_desc, genfs_poll },                 /* poll */
  951         { &vop_kqfilter_desc, genfs_kqfilter },         /* kqfilter */
  952         { &vop_revoke_desc, genfs_revoke },             /* revoke */
  953         { &vop_mmap_desc, genfs_mmap },                 /* mmap */
  954         { &vop_fsync_desc, genfs_fsync },               /* fsync */
  955         { &vop_seek_desc, genfs_seek },                 /* seek */
  956         { &vop_remove_desc, genfs_eopnotsupp },         /* remove */
  957         { &vop_link_desc, genfs_eopnotsupp },           /* link */
  958         { &vop_rename_desc, genfs_eopnotsupp },         /* rename */
  959         { &vop_mkdir_desc, genfs_eopnotsupp },          /* mkdir */
  960         { &vop_rmdir_desc, genfs_eopnotsupp },          /* rmdir */
  961         { &vop_symlink_desc, genfs_eopnotsupp },        /* symlink */
  962         { &vop_readdir_desc, (vop_t *) ntfs_readdir },  /* readdir */
  963         { &vop_readlink_desc, genfs_eopnotsupp },       /* readlink */
  964         { &vop_abortop_desc, genfs_abortop },           /* abortop */
  965         { &vop_inactive_desc, (vop_t *) ntfs_inactive },        /* inactive */
  966         { &vop_reclaim_desc, (vop_t *) ntfs_reclaim },  /* reclaim */
  967         { &vop_lock_desc, genfs_lock },                 /* lock */
  968         { &vop_unlock_desc, genfs_unlock },             /* unlock */
  969         { &vop_bmap_desc, (vop_t *) ntfs_bmap },        /* bmap */
  970         { &vop_strategy_desc, (vop_t *) ntfs_strategy },        /* strategy */
  971         { &vop_print_desc, (vop_t *) ntfs_print },      /* print */
  972         { &vop_islocked_desc, genfs_islocked },         /* islocked */
  973         { &vop_pathconf_desc, ntfs_pathconf },          /* pathconf */
  974         { &vop_advlock_desc, genfs_nullop },            /* advlock */
  975         { &vop_blkatoff_desc, genfs_eopnotsupp },       /* blkatoff */
  976         { &vop_valloc_desc, genfs_eopnotsupp },         /* valloc */
  977         { &vop_reallocblks_desc, genfs_eopnotsupp },    /* reallocblks */
  978         { &vop_vfree_desc, genfs_eopnotsupp },          /* vfree */
  979         { &vop_truncate_desc, genfs_eopnotsupp },       /* truncate */
  980         { &vop_update_desc, genfs_eopnotsupp },         /* update */
  981         { &vop_bwrite_desc, vn_bwrite },                /* bwrite */
  982         { &vop_getpages_desc, genfs_compat_getpages },  /* getpages */
  983         { &vop_putpages_desc, genfs_putpages },         /* putpages */
  984         { NULL, NULL }
  985 };
  986 const struct vnodeopv_desc ntfs_vnodeop_opv_desc =
  987         { &ntfs_vnodeop_p, ntfs_vnodeop_entries };
  989 #endif