root/ntfs/ntfs_subr.c

DEFINITIONS

1. ntfs_ntvattrrele
2. ntfs_findvattr
3. ntfs_ntvattrget
4. ntfs_loadntnode
5. ntfs_ntget
6. ntfs_ntlookup
7. ntfs_ntput
8. ntfs_ntref
9. ntfs_ntrele
10. ntfs_freentvattr
11. ntfs_attrtontvattr
12. ntfs_runtovrun
13. ntfs_uastricmp
14. ntfs_uastrcmp
15. ntfs_fget
16. ntfs_frele
17. ntfs_ntlookupattr
18. ntfs_ntlookupfile
19. ntfs_isnamepermitted
20. ntfs_ntreaddir
21. ntfs_nttimetounix
22. ntfs_times
23. ntfs_filesize
24. ntfs_writeattr_plain
25. ntfs_writentvattr_plain
26. ntfs_readntvattr_plain
27. ntfs_readattr_plain
28. ntfs_readattr
29. ntfs_parserun
30. ntfs_procfixups
31. ntfs_runtocn
32. ntfs_toupper_init
33. ntfs_toupper_use
34. ntfs_toupper_unuse

    1 /*      $OpenBSD: ntfs_subr.c,v 1.11 2007/06/02 01:02:56 deraadt Exp $  */
    2 /*      $NetBSD: ntfs_subr.c,v 1.4 2003/04/10 21:37:32 jdolecek Exp $   */
    4 /*-
    5  * Copyright (c) 1998, 1999 Semen Ustimenko (semenu@FreeBSD.org)
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      Id: ntfs_subr.c,v 1.4 1999/05/12 09:43:01 semenu Exp
   30  */
   32 #include <sys/cdefs.h>
   33 #ifdef __KERNEL_RCSID
   34 __KERNEL_RCSID(0, "$NetBSD: ntfs_subr.c,v 1.4 2003/04/10 21:37:32 jdolecek Exp $");
   35 #endif
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/namei.h>
   40 #include <sys/proc.h>
   41 #include <sys/kernel.h>
   42 #include <sys/vnode.h>
   43 #include <sys/mount.h>
   44 #include <sys/buf.h>
   45 #include <sys/file.h>
   46 #include <sys/malloc.h>
   47 #include <sys/lock.h>
   48 #if defined(__FreeBSD__)
   49 #include <machine/clock.h>
   50 #endif
   52 #include <miscfs/specfs/specdev.h>
   54 /* #define NTFS_DEBUG 1 */
   55 #if defined(__FreeBSD__) || defined(__NetBSD__)
   56 #include <fs/ntfs/ntfs.h>
   57 #include <fs/ntfs/ntfsmount.h>
   58 #include <fs/ntfs/ntfs_inode.h>
   59 #include <fs/ntfs/ntfs_vfsops.h>
   60 #include <fs/ntfs/ntfs_subr.h>
   61 #include <fs/ntfs/ntfs_compr.h>
   62 #include <fs/ntfs/ntfs_ihash.h>
   63 #else
   64 #include <ntfs/ntfs.h>
   65 #include <ntfs/ntfsmount.h>
   66 #include <ntfs/ntfs_inode.h>
   67 #include <ntfs/ntfs_vfsops.h>
   68 #include <ntfs/ntfs_subr.h>
   69 #include <ntfs/ntfs_compr.h>
   70 #include <ntfs/ntfs_ihash.h>
   71 #endif
   73 #if defined(NTFS_DEBUG)
   74 int ntfs_debug = NTFS_DEBUG;
   75 #endif
   77 #ifdef MALLOC_DEFINE
   78 MALLOC_DEFINE(M_NTFSNTVATTR, "NTFS vattr", "NTFS file attribute information");
   79 MALLOC_DEFINE(M_NTFSRDATA, "NTFS res data", "NTFS resident data");
   80 MALLOC_DEFINE(M_NTFSRUN, "NTFS vrun", "NTFS vrun storage");
   81 MALLOC_DEFINE(M_NTFSDECOMP, "NTFS decomp", "NTFS decompression temporary");
   82 #endif
   84 /* Local struct used in ntfs_ntlookupfile() */
   85 struct ntfs_lookup_ctx {
u_int32_t       aoff;
u_int32_t       rdsize;
cn_t            cn;
   89         struct ntfs_lookup_ctx *prev;
   90 };
   92 static int ntfs_ntlookupattr(struct ntfsmount *, const char *, int, int *, char **);
   93 static int ntfs_findvattr(struct ntfsmount *, struct ntnode *, struct ntvattr **, struct ntvattr **, u_int32_t, const char *, size_t, cn_t);
   94 static int ntfs_uastricmp(struct ntfsmount *, const wchar *, size_t, const char *, size_t);
   95 static int ntfs_uastrcmp(struct ntfsmount *, const wchar *, size_t, const char *, size_t);
   97 /* table for mapping Unicode chars into uppercase; it's filled upon first
   98  * ntfs mount, freed upon last ntfs umount */
   99 static wchar *ntfs_toupper_tab;
  100 #define NTFS_U28(ch)            ((((ch) & 0xE0) == 0) ? '_' : (ch) & 0xFF)
  101 #define NTFS_TOUPPER(ch)        (ntfs_toupper_tab[(unsigned char)(ch)])
  102 static struct lock ntfs_toupper_lock;
  103 static signed int ntfs_toupper_usecount;
  105 /* support macro for ntfs_ntvattrget() */
  106 #define NTFS_AALPCMP(aalp,type,name,namelen) (                          \
  107   (aalp->al_type == type) && (aalp->al_namelen == namelen) &&           \
  108   !ntfs_uastrcmp(ntmp, aalp->al_name,aalp->al_namelen,name,namelen) )
  110 /*
  111  * 
  112  */
  113 int
ntfs_ntvattrrele(vap)
  115         struct ntvattr * vap;
  116 {
dprintf(("ntfs_ntvattrrele: ino: %d, type: 0x%x\n",
vap->va_ip->i_number, vap->va_type));
ntfs_ntrele(vap->va_ip);
  122         return (0);
  123 }
  125 /*
  126  * find the attribute in the ntnode
  127  */
  128 static int
ntfs_findvattr(ntmp, ip, lvapp, vapp, type, name, namelen, vcn)
  130         struct ntfsmount *ntmp;
  131         struct ntnode *ip;
  132         struct ntvattr **lvapp, **vapp;
u_int32_t type;
  134         const char *name;
size_t namelen;
cn_t vcn;
  137 {
  138         int error;
  139         struct ntvattr *vap;
  141         if((ip->i_flag & IN_LOADED) == 0) {
dprintf(("ntfs_findvattr: node not loaded, ino: %d\n",
ip->i_number));
error = ntfs_loadntnode(ntmp,ip);
  145                 if (error) {
printf("ntfs_findvattr: FAILED TO LOAD INO: %d\n",
ip->i_number);
  148                         return (error);
  149                 }
  150         }
  152         *lvapp = NULL;
  153         *vapp = NULL;
LIST_FOREACH(vap, &ip->i_valist, va_list) {
ddprintf(("ntfs_findvattr: type: 0x%x, vcn: %d - %d\n", \
vap->va_type, (u_int32_t) vap->va_vcnstart, \
  157                           (u_int32_t) vap->va_vcnend));
  158                 if ((vap->va_type == type) &&
  159                     (vap->va_vcnstart <= vcn) && (vap->va_vcnend >= vcn) &&
  160                     (vap->va_namelen == namelen) &&
  161                     (strncmp(name, vap->va_name, namelen) == 0)) {
  162                         *vapp = vap;
ntfs_ntref(vap->va_ip);
  164                         return (0);
  165                 }
  166                 if (vap->va_type == NTFS_A_ATTRLIST)
  167                         *lvapp = vap;
  168         }
  170         return (-1);
  171 }
  173 /*
  174  * Search attribute specified in ntnode (load ntnode if necessary).
  175  * If not found but ATTR_A_ATTRLIST present, read it in and search through.
  176  * VOP_VGET node needed, and lookup through its ntnode (load if nessesary).
  177  *
  178  * ntnode should be locked
  179  */
  180 int
ntfs_ntvattrget(
  182                 struct ntfsmount * ntmp,
  183                 struct ntnode * ip,
u_int32_t type,
  185                 const char *name,
cn_t vcn,
  187                 struct ntvattr ** vapp)
  188 {
  189         struct ntvattr *lvap = NULL;
  190         struct attr_attrlist *aalp;
  191         struct attr_attrlist *nextaalp;
  192         struct vnode   *newvp;
  193         struct ntnode  *newip;
caddr_t         alpool;
size_t          namelen, len;
  196         int             error;
  198         *vapp = NULL;
  200         if (name) {
dprintf(("ntfs_ntvattrget: " \
  202                          "ino: %d, type: 0x%x, name: %s, vcn: %d\n", \
ip->i_number, type, name, (u_int32_t) vcn));
namelen = strlen(name);
  205         } else {
dprintf(("ntfs_ntvattrget: " \
  207                          "ino: %d, type: 0x%x, vcn: %d\n", \
ip->i_number, type, (u_int32_t) vcn));
name = "";
namelen = 0;
  211         }
error = ntfs_findvattr(ntmp, ip, &lvap, vapp, type, name, namelen, vcn);
  214         if (error >= 0)
  215                 return (error);
  217         if (!lvap) {
dprintf(("ntfs_ntvattrget: UNEXISTED ATTRIBUTE: " \
  219                        "ino: %d, type: 0x%x, name: %s, vcn: %d\n", \
ip->i_number, type, name, (u_int32_t) vcn));
  221                 return (ENOENT);
  222         }
  223         /* Scan $ATTRIBUTE_LIST for requested attribute */
len = lvap->va_datalen;
alpool = (caddr_t) malloc(len, M_TEMP, M_WAITOK);
error = ntfs_readntvattr_plain(ntmp, ip, lvap, 0, len, alpool, &len,
NULL);
  228         if (error)
  229                 goto out;
aalp = (struct attr_attrlist *) alpool;
nextaalp = NULL;
  234         for(; len > 0; aalp = nextaalp) {
dprintf(("ntfs_ntvattrget: " \
  236                          "attrlist: ino: %d, attr: 0x%x, vcn: %d\n", \
aalp->al_inumber, aalp->al_type, \
  238                          (u_int32_t) aalp->al_vcnstart));
  240                 if (len > aalp->reclen) {
nextaalp = NTFS_NEXTREC(aalp, struct attr_attrlist *);
  242                 } else {
nextaalp = NULL;
  244                 }
len -= aalp->reclen;
  247                 if (!NTFS_AALPCMP(aalp, type, name, namelen) ||
  248                     (nextaalp && (nextaalp->al_vcnstart <= vcn) &&
NTFS_AALPCMP(nextaalp, type, name, namelen)))
  250                         continue;
dprintf(("ntfs_ntvattrget: attribute in ino: %d\n",
aalp->al_inumber));
  255                 /* this is not a main record, so we can't use just plain
  256                    vget() */
error = ntfs_vgetex(ntmp->ntm_mountp, aalp->al_inumber,
NTFS_A_DATA, NULL, LK_EXCLUSIVE,
VG_EXT, curproc, &newvp);
  260                 if (error) {
printf("ntfs_ntvattrget: CAN'T VGET INO: %d\n",
aalp->al_inumber);
  263                         goto out;
  264                 }
newip = VTONT(newvp);
  266                 /* XXX have to lock ntnode */
error = ntfs_findvattr(ntmp, newip, &lvap, vapp,
type, name, namelen, vcn);
vput(newvp);
  270                 if (error == 0)
  271                         goto out;
printf("ntfs_ntvattrget: ATTRLIST ERROR.\n");
  273                 break;
  274         }
error = ENOENT;
dprintf(("ntfs_ntvattrget: UNEXISTED ATTRIBUTE: " \
  278                "ino: %d, type: 0x%x, name: %.*s, vcn: %d\n", \
ip->i_number, type, (int) namelen, name, (u_int32_t) vcn));
out:
free(alpool, M_TEMP);
  282         return (error);
  283 }
  285 /*
  286  * Read ntnode from disk, make ntvattr list.
  287  *
  288  * ntnode should be locked
  289  */
  290 int
ntfs_loadntnode(
  292               struct ntfsmount * ntmp,
  293               struct ntnode * ip)
  294 {
  295         struct filerec  *mfrp;
daddr64_t         bn;
  297         int             error,off;
  298         struct attr    *ap;
  299         struct ntvattr *nvap;
dprintf(("ntfs_loadntnode: loading ino: %d\n",ip->i_number));
mfrp = (struct filerec *) malloc(ntfs_bntob(ntmp->ntm_bpmftrec),
M_TEMP, M_WAITOK);
  306         if (ip->i_number < NTFS_SYSNODESNUM) {
  307                 struct buf     *bp;
dprintf(("ntfs_loadntnode: read system node\n"));
bn = ntfs_cntobn(ntmp->ntm_mftcn) +
ntmp->ntm_bpmftrec * ip->i_number;
error = bread(ntmp->ntm_devvp,
bn, ntfs_bntob(ntmp->ntm_bpmftrec),
NOCRED, &bp);
  317                 if (error) {
printf("ntfs_loadntnode: BREAD FAILED\n");
brelse(bp);
  320                         goto out;
  321                 }
memcpy(mfrp, bp->b_data, ntfs_bntob(ntmp->ntm_bpmftrec));
bqrelse(bp);
  324         } else {
  325                 struct vnode   *vp;
vp = ntmp->ntm_sysvn[NTFS_MFTINO];
error = ntfs_readattr(ntmp, VTONT(vp), NTFS_A_DATA, NULL,
ip->i_number * ntfs_bntob(ntmp->ntm_bpmftrec),
ntfs_bntob(ntmp->ntm_bpmftrec), mfrp, NULL);
  331                 if (error) {
printf("ntfs_loadntnode: ntfs_readattr failed\n");
  333                         goto out;
  334                 }
  335         }
  337         /* Check if magic and fixups are correct */
error = ntfs_procfixups(ntmp, NTFS_FILEMAGIC, (caddr_t)mfrp,
ntfs_bntob(ntmp->ntm_bpmftrec));
  340         if (error) {
printf("ntfs_loadntnode: BAD MFT RECORD %d\n",
  342                        (u_int32_t) ip->i_number);
  343                 goto out;
  344         }
dprintf(("ntfs_loadntnode: load attrs for ino: %d\n",ip->i_number));
off = mfrp->fr_attroff;
ap = (struct attr *) ((caddr_t)mfrp + off);
LIST_INIT(&ip->i_valist);
  352         while (ap->a_hdr.a_type != -1) {
error = ntfs_attrtontvattr(ntmp, &nvap, ap);
  354                 if (error)
  355                         break;
nvap->va_ip = ip;
LIST_INSERT_HEAD(&ip->i_valist, nvap, va_list);
off += ap->a_hdr.reclen;
ap = (struct attr *) ((caddr_t)mfrp + off);
  362         }
  363         if (error) {
printf("ntfs_loadntnode: failed to load attr ino: %d\n",
ip->i_number);
  366                 goto out;
  367         }
ip->i_mainrec = mfrp->fr_mainrec;
ip->i_nlink = mfrp->fr_nlink;
ip->i_frflag = mfrp->fr_flags;
ip->i_flag |= IN_LOADED;
out:
free(mfrp, M_TEMP);
  377         return (error);
  378 }
  380 /*
  381  * Routine locks ntnode and increase usecount, just opposite of
  382  * ntfs_ntput().
  383  */
  384 int
ntfs_ntget(
  386         struct ntnode *ip,
  387 #ifdef __OpenBSD__
  388         struct proc *p
  389 #endif
  390         )
  391 {
dprintf(("ntfs_ntget: get ntnode %d: %p, usecount: %d\n",
ip->i_number, ip, ip->i_usecount));
ip->i_usecount++;
lockmgr(&ip->i_lock, LK_EXCLUSIVE, NULL);
  399         return 0;
  400 }
  402 /*
  403  * Routine search ntnode in hash, if found: lock, inc usecount and return.
  404  * If not in hash allocate structure for ntnode, prefill it, lock,
  405  * inc count and return.
  406  *
  407  * ntnode returned locked
  408  */
  409 int
ntfs_ntlookup(
  411            struct ntfsmount * ntmp,
ino_t ino,
  413 #ifndef __OpenBSD__
  414            struct ntnode ** ipp)
  415 #else
  416            struct ntnode ** ipp,
  417            struct proc * p)
  418 #endif
  419 {
  420         struct ntnode  *ip;
dprintf(("ntfs_ntlookup: looking for ntnode %d\n", ino));
  424         do {
  425                 if ((ip = ntfs_nthashlookup(ntmp->ntm_dev, ino)) != NULL) {
  426 #ifndef __OpenBSD__
ntfs_ntget(ip);
  428 #else
ntfs_ntget(ip, p);
  430 #endif
dprintf(("ntfs_ntlookup: ntnode %d: %p, usecount: %d\n",
ino, ip, ip->i_usecount));
  433                         *ipp = ip;
  434                         return (0);
  435                 }
  436         } while (lockmgr(&ntfs_hashlock, LK_EXCLUSIVE | LK_SLEEPFAIL, NULL));
MALLOC(ip, struct ntnode *, sizeof(struct ntnode),
M_NTFSNTNODE, M_WAITOK);
ddprintf(("ntfs_ntlookup: allocating ntnode: %d: %p\n", ino, ip));
bzero((caddr_t) ip, sizeof(struct ntnode));
  443         /* Generic initialization */
ip->i_devvp = ntmp->ntm_devvp;
ip->i_dev = ntmp->ntm_dev;
ip->i_number = ino;
ip->i_mp = ntmp;
LIST_INIT(&ip->i_fnlist);
VREF(ip->i_devvp);
  452         /* init lock and lock the newborn ntnode */
lockinit(&ip->i_lock, PINOD, "ntnode", 0, LK_EXCLUSIVE);
  454 #ifndef __OpenBSD__
ntfs_ntget(ip);
  456 #else
ntfs_ntget(ip, p);
  458 #endif
ntfs_nthashins(ip);
lockmgr(&ntfs_hashlock, LK_RELEASE, NULL);
  464         *ipp = ip;
dprintf(("ntfs_ntlookup: ntnode %d: %p, usecount: %d\n",
ino, ip, ip->i_usecount));
  469         return (0);
  470 }
  472 /*
  473  * Decrement usecount of ntnode and unlock it, if usecount reach zero,
  474  * deallocate ntnode.
  475  *
  476  * ntnode should be locked on entry, and unlocked on return.
  477  */
  478 void
ntfs_ntput(
  480         struct ntnode *ip,
  481 #ifdef __OpenBSD__
  482         struct proc *p
  483 #endif
  484         )
  485 {
  486         struct ntvattr *vap;
dprintf(("ntfs_ntput: rele ntnode %d: %p, usecount: %d\n",
ip->i_number, ip, ip->i_usecount));
ip->i_usecount--;
  493 #ifdef DIAGNOSTIC
  494         if (ip->i_usecount < 0) {
panic("ntfs_ntput: ino: %d usecount: %d ",
ip->i_number,ip->i_usecount);
  497         }
  498 #endif
  500         if (ip->i_usecount > 0) {
lockmgr(&ip->i_lock, LK_RELEASE, NULL);
  502                 return;
  503         }
dprintf(("ntfs_ntput: deallocating ntnode: %d\n", ip->i_number));
  507         if (LIST_FIRST(&ip->i_fnlist))
panic("ntfs_ntput: ntnode has fnodes");
ntfs_nthashrem(ip);
  512         while ((vap = LIST_FIRST(&ip->i_valist)) != NULL) {
LIST_REMOVE(vap, va_list);
ntfs_freentvattr(vap);
  515         }
vrele(ip->i_devvp);
FREE(ip, M_NTFSNTNODE);
  519 }
  521 /*
  522  * increment usecount of ntnode 
  523  */
  524 void
ntfs_ntref(ip)
  526         struct ntnode *ip;
  527 {
ip->i_usecount++;
dprintf(("ntfs_ntref: ino %d, usecount: %d\n",
ip->i_number, ip->i_usecount));
  533 }
  535 /*
  536  * Decrement usecount of ntnode.
  537  */
  538 void
ntfs_ntrele(ip)
  540         struct ntnode *ip;
  541 {
dprintf(("ntfs_ntrele: rele ntnode %d: %p, usecount: %d\n",
ip->i_number, ip, ip->i_usecount));
ip->i_usecount--;
  547         if (ip->i_usecount < 0)
panic("ntfs_ntrele: ino: %d usecount: %d ",
ip->i_number,ip->i_usecount);
  550 }
  552 /*
  553  * Deallocate all memory allocated for ntvattr
  554  */
  555 void
ntfs_freentvattr(vap)
  557         struct ntvattr * vap;
  558 {
  559         if (vap->va_flag & NTFS_AF_INRUN) {
  560                 if (vap->va_vruncn)
free(vap->va_vruncn, M_NTFSRUN);
  562                 if (vap->va_vruncl)
free(vap->va_vruncl, M_NTFSRUN);
  564         } else {
  565                 if (vap->va_datap)
free(vap->va_datap, M_NTFSRDATA);
  567         }
FREE(vap, M_NTFSNTVATTR);
  569 }
  571 /*
  572  * Convert disk image of attribute into ntvattr structure,
  573  * runs are expanded also.
  574  */
  575 int
ntfs_attrtontvattr(
  577                    struct ntfsmount * ntmp,
  578                    struct ntvattr ** rvapp,
  579                    struct attr * rap)
  580 {
  581         int             error, i;
  582         struct ntvattr *vap;
error = 0;
  585         *rvapp = NULL;
MALLOC(vap, struct ntvattr *, sizeof(struct ntvattr),
M_NTFSNTVATTR, M_WAITOK);
bzero(vap, sizeof(struct ntvattr));
vap->va_ip = NULL;
vap->va_flag = rap->a_hdr.a_flag;
vap->va_type = rap->a_hdr.a_type;
vap->va_compression = rap->a_hdr.a_compression;
vap->va_index = rap->a_hdr.a_index;
ddprintf(("type: 0x%x, index: %d", vap->va_type, vap->va_index));
vap->va_namelen = rap->a_hdr.a_namelen;
  599         if (rap->a_hdr.a_namelen) {
wchar *unp = (wchar *) ((caddr_t) rap + rap->a_hdr.a_nameoff);
ddprintf((", name:["));
  602                 for (i = 0; i < vap->va_namelen; i++) {
vap->va_name[i] = unp[i];
ddprintf(("%c", vap->va_name[i]));
  605                 }
ddprintf(("]"));
  607         }
  608         if (vap->va_flag & NTFS_AF_INRUN) {
ddprintf((", nonres."));
vap->va_datalen = rap->a_nr.a_datalen;
vap->va_allocated = rap->a_nr.a_allocated;
vap->va_vcnstart = rap->a_nr.a_vcnstart;
vap->va_vcnend = rap->a_nr.a_vcnend;
vap->va_compressalg = rap->a_nr.a_compressalg;
error = ntfs_runtovrun(&(vap->va_vruncn), &(vap->va_vruncl),
  616                                        &(vap->va_vruncnt),
  617                                        (caddr_t) rap + rap->a_nr.a_dataoff);
  618         } else {
vap->va_compressalg = 0;
ddprintf((", res."));
vap->va_datalen = rap->a_r.a_datalen;
vap->va_allocated = rap->a_r.a_datalen;
vap->va_vcnstart = 0;
vap->va_vcnend = ntfs_btocn(vap->va_allocated);
vap->va_datap = (caddr_t) malloc(vap->va_datalen,
M_NTFSRDATA, M_WAITOK);
memcpy(vap->va_datap, (caddr_t) rap + rap->a_r.a_dataoff,
rap->a_r.a_datalen);
  629         }
ddprintf((", len: %d", vap->va_datalen));
  632         if (error)
FREE(vap, M_NTFSNTVATTR);
  634         else
  635                 *rvapp = vap;
ddprintf(("\n"));
  639         return (error);
  640 }
  642 /*
  643  * Expand run into more utilizable and more memory eating format.
  644  */
  645 int
ntfs_runtovrun(
cn_t ** rcnp,
cn_t ** rclp,
u_long * rcntp,
u_int8_t * run)
  651 {
u_int32_t       off;
u_int32_t       sz, i;
cn_t           *cn;
cn_t           *cl;
u_long          cnt;
cn_t            prev;
cn_t            tmp;
off = 0;
cnt = 0;
i = 0;
  663         while (run[off]) {
off += (run[off] & 0xF) + ((run[off] >> 4) & 0xF) + 1;
cnt++;
  666         }
cn = (cn_t *) malloc(cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
cl = (cn_t *) malloc(cnt * sizeof(cn_t), M_NTFSRUN, M_WAITOK);
off = 0;
cnt = 0;
prev = 0;
  673         while (run[off]) {
sz = run[off++];
cl[cnt] = 0;
  678                 for (i = 0; i < (sz & 0xF); i++)
cl[cnt] += (u_int32_t) run[off++] << (i << 3);
sz >>= 4;
  682                 if (run[off + sz - 1] & 0x80) {
tmp = ((u_int64_t) - 1) << (sz << 3);
  684                         for (i = 0; i < sz; i++)
tmp |= (u_int64_t) run[off++] << (i << 3);
  686                 } else {
tmp = 0;
  688                         for (i = 0; i < sz; i++)
tmp |= (u_int64_t) run[off++] << (i << 3);
  690                 }
  691                 if (tmp)
prev = cn[cnt] = prev + tmp;
  693                 else
cn[cnt] = tmp;
cnt++;
  697         }
  698         *rcnp = cn;
  699         *rclp = cl;
  700         *rcntp = cnt;
  701         return (0);
  702 }
  704 /*
  705  * Compare unicode and ascii string case insens.
  706  */
  707 static int
ntfs_uastricmp(ntmp, ustr, ustrlen, astr, astrlen)
  709         struct ntfsmount *ntmp;
  710         const wchar *ustr;
size_t ustrlen;
  712         const char *astr;
size_t astrlen;
  714 {
size_t  i;
  716         int             res;
  717         const char *astrend = astr + astrlen;
  719         for (i = 0; i < ustrlen && astr < astrend; i++) {
res = (*ntmp->ntm_wcmp)(NTFS_TOUPPER(ustr[i]),
NTFS_TOUPPER((*ntmp->ntm_wget)(&astr)) );
  722                 if (res)
  723                         return res;
  724         }
  726         if (i == ustrlen && astr == astrend)
  727                 return 0;
  728         else if (i == ustrlen)
  729                 return -1;
  730         else
  731                 return 1;
  732 }
  734 /*
  735  * Compare unicode and ascii string case sens.
  736  */
  737 static int
ntfs_uastrcmp(ntmp, ustr, ustrlen, astr, astrlen)
  739         struct ntfsmount *ntmp;
  740         const wchar *ustr;
size_t ustrlen;
  742         const char *astr;
size_t astrlen;
  744 {
size_t             i;
  746         int             res;
  747         const char *astrend = astr + astrlen;
  749         for (i = 0; (i < ustrlen) && (astr < astrend); i++) {
res = (*ntmp->ntm_wcmp)(ustr[i], (*ntmp->ntm_wget)(&astr));
  751                 if (res)
  752                         return res;
  753         }
  755         if (i == ustrlen && astr == astrend)
  756                 return 0;
  757         else if (i == ustrlen)
  758                 return -1;
  759         else
  760                 return 1;
  761 }
  763 /* 
  764  * Search fnode in ntnode, if not found allocate and preinitialize.
  765  *
  766  * ntnode should be locked on entry.
  767  */
  768 int
ntfs_fget(
  770         struct ntfsmount *ntmp,
  771         struct ntnode *ip,
  772         int attrtype,
  773         char *attrname,
  774         struct fnode **fpp)
  775 {
  776         struct fnode *fp;
dprintf(("ntfs_fget: ino: %d, attrtype: 0x%x, attrname: %s\n",
ip->i_number,attrtype, attrname?attrname:""));
  780         *fpp = NULL;
LIST_FOREACH(fp, &ip->i_fnlist, f_fnlist) {
dprintf(("ntfs_fget: fnode: attrtype: %d, attrname: %s\n",
fp->f_attrtype, fp->f_attrname?fp->f_attrname:""));
  785                 if ((attrtype == fp->f_attrtype) && 
  786                     ((!attrname && !fp->f_attrname) ||
  787                      (attrname && fp->f_attrname &&
  788                       !strcmp(attrname,fp->f_attrname)))){
dprintf(("ntfs_fget: found existed: %p\n",fp));
  790                         *fpp = fp;
  791                 }
  792         }
  794         if (*fpp)
  795                 return (0);
MALLOC(fp, struct fnode *, sizeof(struct fnode), M_NTFSFNODE, M_WAITOK);
bzero(fp, sizeof(struct fnode));
dprintf(("ntfs_fget: allocating fnode: %p\n",fp));
fp->f_ip = ip;
fp->f_attrname = attrname;
  803         if (fp->f_attrname) fp->f_flag |= FN_AATTRNAME;
fp->f_attrtype = attrtype;
ntfs_ntref(ip);
LIST_INSERT_HEAD(&ip->i_fnlist, fp, f_fnlist);
  810         *fpp = fp;
  812         return (0);
  813 }
  815 /*
  816  * Deallocate fnode, remove it from ntnode's fnode list.
  817  *
  818  * ntnode should be locked.
  819  */
  820 void
ntfs_frele(
  822         struct fnode *fp)
  823 {
  824         struct ntnode *ip = FTONT(fp);
dprintf(("ntfs_frele: fnode: %p for %d: %p\n", fp, ip->i_number, ip));
dprintf(("ntfs_frele: deallocating fnode\n"));
LIST_REMOVE(fp,f_fnlist);
  830         if (fp->f_flag & FN_AATTRNAME)
FREE(fp->f_attrname, M_TEMP);
  832         if (fp->f_dirblbuf)
FREE(fp->f_dirblbuf, M_NTFSDIR);
FREE(fp, M_NTFSFNODE);
ntfs_ntrele(ip);
  836 }
  838 /*
  839  * Lookup attribute name in format: [[:$ATTR_TYPE]:$ATTR_NAME], 
  840  * $ATTR_TYPE is searched in attrdefs read from $AttrDefs.
  841  * If $ATTR_TYPE not specified, ATTR_A_DATA assumed.
  842  */
  843 static int
ntfs_ntlookupattr(
  845                 struct ntfsmount * ntmp,
  846                 const char * name,
  847                 int namelen,
  848                 int *attrtype,
  849                 char **attrname)
  850 {
  851         const char *sys;
size_t syslen, i;
  853         struct ntvattrdef *adp;
  855         if (namelen == 0)
  856                 return (0);
  858         if (name[0] == '$') {
sys = name;
  860                 for (syslen = 0; syslen < namelen; syslen++) {
  861                         if(sys[syslen] == ':') {
name++;
namelen--;
  864                                 break;
  865                         }
  866                 }
name += syslen;
namelen -= syslen;
adp = ntmp->ntm_ad;
  871                 for (i = 0; i < ntmp->ntm_adnum; i++, adp++){
  872                         if (syslen != adp->ad_namelen || 
strncmp(sys, adp->ad_name, syslen) != 0)
  874                                 continue;
  876                         *attrtype = adp->ad_type;
  877                         goto out;
  878                 }
  879                 return (ENOENT);
  880         }
out:
  883         if (namelen) {
  884                 *attrname = (char *) malloc(namelen, M_TEMP, M_WAITOK);
memcpy((*attrname), name, namelen);
  886                 (*attrname)[namelen] = '\0';
  887                 *attrtype = NTFS_A_DATA;
  888         }
  890         return (0);
  891 }
  893 /*
  894  * Lookup specified node for filename, matching cnp,
  895  * return fnode filled.
  896  */
  897 int
ntfs_ntlookupfile(
  899               struct ntfsmount * ntmp,
  900               struct vnode * vp,
  901               struct componentname * cnp,
  902 #ifndef __OpenBSD__
  903               struct vnode ** vpp)
  904 #else
  905               struct vnode ** vpp,
  906               struct proc *p)
  907 #endif
  908 {
  909         struct fnode   *fp = VTOF(vp);
  910         struct ntnode  *ip = FTONT(fp);
  911         struct ntvattr *vap;    /* Root attribute */
cn_t            cn = 0; /* VCN in current attribute */
caddr_t         rdbuf;  /* Buffer to read directory's blocks  */
u_int32_t       blsize;
u_int32_t       rdsize; /* Length of data to read from current block */
  916         struct attr_indexentry *iep;
  917         int             error, res, anamelen, fnamelen;
  918         const char     *fname,*aname;
u_int32_t       aoff;
  920         int attrtype = NTFS_A_DATA;
  921         char *attrname = NULL;
  922         struct fnode   *nfp;
  923         struct vnode   *nvp;
  924         enum vtype      f_type;
  925         int fullscan = 0;
  926         struct ntfs_lookup_ctx *lookup_ctx = NULL, *tctx;
  928 #ifndef __OpenBSD__
error = ntfs_ntget(ip);
  930 #else
error = ntfs_ntget(ip, p);
  932 #endif
  933         if (error)
  934                 return (error);
error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDXROOT, "$I30", 0, &vap);
  937         if (error || (vap->va_flag & NTFS_AF_INRUN))
  938                 return (ENOTDIR);
  940         /*
  941          * Divide file name into: foofilefoofilefoofile[:attrspec]
  942          * Store like this:       fname:fnamelen       [aname:anamelen]
  943          */
fname = cnp->cn_nameptr;
aname = NULL;
anamelen = 0;
  947         for (fnamelen = 0; fnamelen < cnp->cn_namelen; fnamelen++)
  948                 if(fname[fnamelen] == ':') {
aname = fname + fnamelen + 1;
anamelen = cnp->cn_namelen - fnamelen - 1;
dprintf(("ntfs_ntlookupfile: %s (%d), attr: %s (%d)\n",
fname, fnamelen, aname, anamelen));
  953                         break;
  954                 }
blsize = vap->va_a_iroot->ir_size;
dprintf(("ntfs_ntlookupfile: blksz: %d\n", blsize));
rdbuf = (caddr_t) malloc(blsize, M_TEMP, M_WAITOK);
loop:
rdsize = vap->va_datalen;
dprintf(("ntfs_ntlookupfile: rdsz: %d\n", rdsize));
error = ntfs_readattr(ntmp, ip, NTFS_A_INDXROOT, "$I30",
  966                                0, rdsize, rdbuf, NULL);
  967         if (error)
  968                 goto fail;
aoff = sizeof(struct attr_indexroot);
  972         do {
iep = (struct attr_indexentry *) (rdbuf + aoff);
  975                 for (; !(iep->ie_flag & NTFS_IEFLAG_LAST) && (rdsize > aoff);
aoff += iep->reclen,
iep = (struct attr_indexentry *) (rdbuf + aoff))
  978                 {
ddprintf(("scan: %d, %d\n",
  980                                   (u_int32_t) iep->ie_number,
  981                                   (u_int32_t) iep->ie_fnametype));
  983                         /* check the name - the case-insensitive check
  984                          * has to come first, to break from this for loop
  985                          * if needed, so we can dive correctly */
res = ntfs_uastricmp(ntmp, iep->ie_fname,
iep->ie_fnamelen, fname, fnamelen);
  988                         if (!fullscan) {
  989                                 if (res > 0) break;
  990                                 if (res < 0) continue;
  991                         }
  993                         if (iep->ie_fnametype == 0 ||
  994                             !(ntmp->ntm_flag & NTFS_MFLAG_CASEINS))
  995                         {
res = ntfs_uastrcmp(ntmp, iep->ie_fname,
iep->ie_fnamelen, fname, fnamelen);
  998                                 if (res != 0 && !fullscan) continue;
  999                         }
 1001                         /* if we perform full scan, the file does not match
 1002                          * and this is subnode, dive */
 1003                         if (fullscan && res != 0) {
 1004                             if (iep->ie_flag & NTFS_IEFLAG_SUBNODE) {
MALLOC(tctx, struct ntfs_lookup_ctx *,
 1006                                         sizeof(struct ntfs_lookup_ctx),
M_TEMP, M_WAITOK);
tctx->aoff      = aoff + iep->reclen;
tctx->rdsize    = rdsize;
tctx->cn        = cn;
tctx->prev      = lookup_ctx;
lookup_ctx = tctx;
 1013                                 break;
 1014                             } else
 1015                                 continue;
 1016                         }
 1018                         if (aname) {
error = ntfs_ntlookupattr(ntmp,
aname, anamelen,
 1021                                         &attrtype, &attrname);
 1022                                 if (error)
 1023                                         goto fail;
 1024                         }
 1026                         /* Check if we've found ourselves */
 1027                         if ((iep->ie_number == ip->i_number) &&
 1028                             (attrtype == fp->f_attrtype) &&
 1029                             ((!attrname && !fp->f_attrname) ||
 1030                              (attrname && fp->f_attrname &&
 1031                               !strcmp(attrname, fp->f_attrname))))
 1032                         {
VREF(vp);
 1034                                 *vpp = vp;
error = 0;
 1036                                 goto fail;
 1037                         }
 1039                         /* free the buffer returned by ntfs_ntlookupattr() */
 1040                         if (attrname) {
FREE(attrname, M_TEMP);
attrname = NULL;
 1043                         }
 1045                         /* vget node, but don't load it */
error = ntfs_vgetex(ntmp->ntm_mountp,
iep->ie_number, attrtype, attrname,
LK_EXCLUSIVE, VG_DONTLOADIN | VG_DONTVALIDFN,
curproc, &nvp);
 1050                         if (error)
 1051                                 goto fail;
nfp = VTOF(nvp);
 1055                         if (nfp->f_flag & FN_VALID) {
 1056                                 *vpp = nvp;
 1057                                 goto fail;
 1058                         }
nfp->f_fflag = iep->ie_fflag;
nfp->f_pnumber = iep->ie_fpnumber;
nfp->f_times = iep->ie_ftimes;
 1064                         if((nfp->f_fflag & NTFS_FFLAG_DIR) &&
 1065                            (nfp->f_attrtype == NTFS_A_DATA) &&
 1066                            (nfp->f_attrname == NULL))
f_type = VDIR;  
 1068                         else
f_type = VREG;  
nvp->v_type = f_type;
 1073                         if ((nfp->f_attrtype == NTFS_A_DATA) &&
 1074                             (nfp->f_attrname == NULL))
 1075                         {
 1076                                 /* Opening default attribute */
nfp->f_size = iep->ie_fsize;
nfp->f_allocated = iep->ie_fallocated;
nfp->f_flag |= FN_PRELOADED;
 1080                         } else {
error = ntfs_filesize(ntmp, nfp,
 1082                                             &nfp->f_size, &nfp->f_allocated);
 1083                                 if (error) {
vput(nvp);
 1085                                         goto fail;
 1086                                 }
 1087                         }
nfp->f_flag &= ~FN_VALID;
 1090                         *vpp = nvp;
 1091                         goto fail;
 1092                 }
 1094                 /* Dive if possible */
 1095                 if (iep->ie_flag & NTFS_IEFLAG_SUBNODE) {
dprintf(("ntfs_ntlookupfile: diving\n"));
cn = *(cn_t *) (rdbuf + aoff +
iep->reclen - sizeof(cn_t));
rdsize = blsize;
error = ntfs_readattr(ntmp, ip, NTFS_A_INDX, "$I30",
ntfs_cntob(cn), rdsize, rdbuf, NULL);
 1104                         if (error)
 1105                                 goto fail;
error = ntfs_procfixups(ntmp, NTFS_INDXMAGIC,
rdbuf, rdsize);
 1109                         if (error)
 1110                                 goto fail;
aoff = (((struct attr_indexalloc *) rdbuf)->ia_hdrsize +
 1113                                 0x18);
 1114                 } else if (fullscan && lookup_ctx) {
cn = lookup_ctx->cn;
aoff = lookup_ctx->aoff;
rdsize = lookup_ctx->rdsize;
error = ntfs_readattr(ntmp, ip,
 1120                                 (cn == 0) ? NTFS_A_INDXROOT : NTFS_A_INDX,
 1121                                 "$I30", ntfs_cntob(cn), rdsize, rdbuf, NULL);
 1122                         if (error)
 1123                                 goto fail;
 1125                         if (cn != 0) {
error = ntfs_procfixups(ntmp, NTFS_INDXMAGIC,
rdbuf, rdsize);
 1128                                 if (error)
 1129                                         goto fail;
 1130                         }
tctx = lookup_ctx;
lookup_ctx = lookup_ctx->prev;
FREE(tctx, M_TEMP);
 1135                 } else {
dprintf(("ntfs_ntlookupfile: nowhere to dive :-(\n"));
error = ENOENT;
 1138                         break;
 1139                 }
 1140         } while (1);
 1142         /* perform full scan if no entry was found */
 1143         if (!fullscan && error == ENOENT) {
fullscan = 1;
cn = 0;         /* need zero, used by lookup_ctx */
ddprintf(("ntfs_ntlookupfile: fullscan performed for: %.*s\n",
 1148                         (int) fnamelen, fname));
 1149                 goto loop;
 1150         }
dprintf(("finish\n"));
fail:
 1155         if (attrname)
FREE(attrname, M_TEMP);
 1157         if (lookup_ctx) {
 1158                 while(lookup_ctx) {
tctx = lookup_ctx;
lookup_ctx = lookup_ctx->prev;
FREE(tctx, M_TEMP);
 1162                 }
 1163         }
ntfs_ntvattrrele(vap);
 1165 #ifndef __OpenBSD__
ntfs_ntput(ip);
 1167 #else
ntfs_ntput(ip, p);
 1169 #endif
free(rdbuf, M_TEMP);
 1171         return (error);
 1172 }
 1174 /*
 1175  * Check if name type is permitted to show.
 1176  */
 1177 int
ntfs_isnamepermitted(
 1179                      struct ntfsmount * ntmp,
 1180                      struct attr_indexentry * iep)
 1181 {
 1182         if (ntmp->ntm_flag & NTFS_MFLAG_ALLNAMES)
 1183                 return 1;
 1185         switch (iep->ie_fnametype) {
 1186         case 2:
ddprintf(("ntfs_isnamepermitted: skipped DOS name\n"));
 1188                 return 0;
 1189         case 0: case 1: case 3:
 1190                 return 1;
 1191         default:
printf("ntfs_isnamepermitted: " \
 1193                        "WARNING! Unknown file name type: %d\n",
iep->ie_fnametype);
 1195                 break;
 1196         }
 1197         return 0;
 1198 }
 1200 /*
 1201  * Read ntfs dir like stream of attr_indexentry, not like btree of them.
 1202  * This is done by scanning $BITMAP:$I30 for busy clusters and reading them.
 1203  * Of course $INDEX_ROOT:$I30 is read before. Last read values are stored in
 1204  * fnode, so we can skip toward record number num almost immediately.
 1205  * Anyway this is rather slow routine. The problem is that we don't know
 1206  * how many records are there in $INDEX_ALLOCATION:$I30 block.
 1207  */
 1208 int
ntfs_ntreaddir(
 1210                struct ntfsmount * ntmp,
 1211                struct fnode * fp,
u_int32_t num,
 1213 #ifndef __OpenBSD__
 1214                struct attr_indexentry ** riepp)
 1215 #else
 1216                struct attr_indexentry ** riepp,
 1217                struct proc *p)
 1218 #endif
 1219 {
 1220         struct ntnode  *ip = FTONT(fp);
 1221         struct ntvattr *vap = NULL;     /* IndexRoot attribute */
 1222         struct ntvattr *bmvap = NULL;   /* BitMap attribute */
 1223         struct ntvattr *iavap = NULL;   /* IndexAllocation attribute */
caddr_t         rdbuf;          /* Buffer to read directory's blocks  */
u_int8_t       *bmp = NULL;     /* Bitmap */
u_int32_t       blsize;         /* Index allocation size (2048) */
u_int32_t       rdsize;         /* Length of data to read */
u_int32_t       attrnum;        /* Current attribute type */
u_int32_t       cpbl = 1;       /* Clusters per directory block */
u_int32_t       blnum;
 1231         struct attr_indexentry *iep;
 1232         int             error = ENOENT;
u_int32_t       aoff, cnum;
dprintf(("ntfs_ntreaddir: read ino: %d, num: %d\n", ip->i_number, num));
 1236 #ifndef __OpenBSD__
error = ntfs_ntget(ip);
 1238 #else
error = ntfs_ntget(ip, p);
 1240 #endif
 1241         if (error)
 1242                 return (error);
error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDXROOT, "$I30", 0, &vap);
 1245         if (error)
 1246                 return (ENOTDIR);
 1248         if (fp->f_dirblbuf == NULL) {
fp->f_dirblsz = vap->va_a_iroot->ir_size;
fp->f_dirblbuf = (caddr_t) malloc(
MAX(vap->va_datalen,fp->f_dirblsz), M_NTFSDIR, M_WAITOK);
 1252         }
blsize = fp->f_dirblsz;
rdbuf = fp->f_dirblbuf;
dprintf(("ntfs_ntreaddir: rdbuf: %p, blsize: %d\n", rdbuf, blsize));
 1259         if (vap->va_a_iroot->ir_flag & NTFS_IRFLAG_INDXALLOC) {
error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDXBITMAP, "$I30",
 1261                                         0, &bmvap);
 1262                 if (error) {
error = ENOTDIR;
 1264                         goto fail;
 1265                 }
bmp = (u_int8_t *) malloc(bmvap->va_datalen, M_TEMP, M_WAITOK);
error = ntfs_readattr(ntmp, ip, NTFS_A_INDXBITMAP, "$I30", 0,
bmvap->va_datalen, bmp, NULL);
 1269                 if (error)
 1270                         goto fail;
error = ntfs_ntvattrget(ntmp, ip, NTFS_A_INDX, "$I30",
 1273                                         0, &iavap);
 1274                 if (error) {
error = ENOTDIR;
 1276                         goto fail;
 1277                 }
cpbl = ntfs_btocn(blsize + ntfs_cntob(1) - 1);
dprintf(("ntfs_ntreaddir: indexalloc: %d, cpbl: %d\n",
iavap->va_datalen, cpbl));
 1281         } else {
dprintf(("ntfs_ntreadidir: w/o BitMap and IndexAllocation\n"));
iavap = bmvap = NULL;
bmp = NULL;
 1285         }
 1287         /* Try use previous values */
 1288         if ((fp->f_lastdnum < num) && (fp->f_lastdnum != 0)) {
attrnum = fp->f_lastdattr;
aoff = fp->f_lastdoff;
blnum = fp->f_lastdblnum;
cnum = fp->f_lastdnum;
 1293         } else {
attrnum = NTFS_A_INDXROOT;
aoff = sizeof(struct attr_indexroot);
blnum = 0;
cnum = 0;
 1298         }
 1300         do {
dprintf(("ntfs_ntreaddir: scan: 0x%x, %d, %d, %d, %d\n",
attrnum, (u_int32_t) blnum, cnum, num, aoff));
rdsize = (attrnum == NTFS_A_INDXROOT) ? vap->va_datalen : blsize;
error = ntfs_readattr(ntmp, ip, attrnum, "$I30",
ntfs_cntob(blnum * cpbl), rdsize, rdbuf, NULL);
 1306                 if (error)
 1307                         goto fail;
 1309                 if (attrnum == NTFS_A_INDX) {
error = ntfs_procfixups(ntmp, NTFS_INDXMAGIC,
rdbuf, rdsize);
 1312                         if (error)
 1313                                 goto fail;
 1314                 }
 1315                 if (aoff == 0)
aoff = (attrnum == NTFS_A_INDX) ?
 1317                                 (0x18 + ((struct attr_indexalloc *) rdbuf)->ia_hdrsize) :
 1318                                 sizeof(struct attr_indexroot);
iep = (struct attr_indexentry *) (rdbuf + aoff);
 1321                 for (; !(iep->ie_flag & NTFS_IEFLAG_LAST) && (rdsize > aoff);
aoff += iep->reclen,
iep = (struct attr_indexentry *) (rdbuf + aoff))
 1324                 {
 1325                         if (!ntfs_isnamepermitted(ntmp, iep)) continue;
 1327                         if (cnum >= num) {
fp->f_lastdnum = cnum;
fp->f_lastdoff = aoff;
fp->f_lastdblnum = blnum;
fp->f_lastdattr = attrnum;
 1333                                 *riepp = iep;
error = 0;
 1336                                 goto fail;
 1337                         }
cnum++;
 1339                 }
 1341                 if (iavap) {
 1342                         if (attrnum == NTFS_A_INDXROOT)
blnum = 0;
 1344                         else
blnum++;
 1347                         while (ntfs_cntob(blnum * cpbl) < iavap->va_datalen) {
 1348                                 if (bmp[blnum >> 3] & (1 << (blnum & 7)))
 1349                                         break;
blnum++;
 1351                         }
attrnum = NTFS_A_INDX;
aoff = 0;
 1355                         if (ntfs_cntob(blnum * cpbl) >= iavap->va_datalen)
 1356                                 break;
dprintf(("ntfs_ntreaddir: blnum: %d\n", (u_int32_t) blnum));
 1358                 }
 1359         } while (iavap);
 1361         *riepp = NULL;
fp->f_lastdnum = 0;
fail:
 1365         if (vap)
ntfs_ntvattrrele(vap);
 1367         if (bmvap)
ntfs_ntvattrrele(bmvap);
 1369         if (iavap)
ntfs_ntvattrrele(iavap);
 1371         if (bmp)
FREE(bmp, M_TEMP);
 1373 #ifndef __OpenBSD__
ntfs_ntput(ip);
 1375 #else
ntfs_ntput(ip, p);
 1377 #endif
 1378         return (error);
 1379 }
 1381 /*
 1382  * Convert NTFS times that are in 100 ns units and begins from
 1383  * 1601 Jan 1 into unix times.
 1384  */
 1385 struct timespec
ntfs_nttimetounix(
u_int64_t nt)
 1388 {
 1389         struct timespec t;
 1391         /* WindowNT times are in 100 ns and from 1601 Jan 1 */
t.tv_nsec = (nt % (1000 * 1000 * 10)) * 100;
t.tv_sec = nt / (1000 * 1000 * 10) -
 1394                 369LL * 365LL * 24LL * 60LL * 60LL -
 1395                 89LL * 1LL * 24LL * 60LL * 60LL;
 1396         return (t);
 1397 }
 1399 #ifndef __OpenBSD__
 1400 /*
 1401  * Get file times from NTFS_A_NAME attribute.
 1402  */
 1403 int
ntfs_times(
 1405            struct ntfsmount * ntmp,
 1406            struct ntnode * ip,
ntfs_times_t * tm)
 1408 {
 1409         struct ntvattr *vap;
 1410         int             error;
dprintf(("ntfs_times: ino: %d...\n", ip->i_number));
error = ntfs_ntget(ip);
 1415         if (error)
 1416                 return (error);
error = ntfs_ntvattrget(ntmp, ip, NTFS_A_NAME, NULL, 0, &vap);
 1419         if (error) {
ntfs_ntput(ip);
 1421                 return (error);
 1422         }
 1423         *tm = vap->va_a_name->n_times;
ntfs_ntvattrrele(vap);
ntfs_ntput(ip);
 1427         return (0);
 1428 }
 1429 #endif
 1431 /*
 1432  * Get file sizes from corresponding attribute. 
 1433  * 
 1434  * ntnode under fnode should be locked.
 1435  */
 1436 int
ntfs_filesize(
 1438               struct ntfsmount * ntmp,
 1439               struct fnode * fp,
u_int64_t * size,
u_int64_t * bytes)
 1442 {
 1443         struct ntvattr *vap;
 1444         struct ntnode *ip = FTONT(fp);
u_int64_t       sz, bn;
 1446         int             error;
dprintf(("ntfs_filesize: ino: %d\n", ip->i_number));
error = ntfs_ntvattrget(ntmp, ip,
fp->f_attrtype, fp->f_attrname, 0, &vap);
 1452         if (error)
 1453                 return (error);
bn = vap->va_allocated;
sz = vap->va_datalen;
dprintf(("ntfs_filesize: %d bytes (%d bytes allocated)\n",
 1459                 (u_int32_t) sz, (u_int32_t) bn));
 1461         if (size)
 1462                 *size = sz;
 1463         if (bytes)
 1464                 *bytes = bn;
ntfs_ntvattrrele(vap);
 1468         return (0);
 1469 }
 1471 /*
 1472  * This is one of the write routines.
 1473  */
 1474 int
ntfs_writeattr_plain(
 1476         struct ntfsmount * ntmp,
 1477         struct ntnode * ip,
u_int32_t attrnum,      
 1479         char *attrname,
off_t roff,
size_t rsize,
 1482         void *rdata,
size_t * initp,
 1484         struct uio *uio)
 1485 {
size_t          init;
 1487         int             error = 0;
off_t           off = roff, left = rsize, towrite;
caddr_t         data = rdata;
 1490         struct ntvattr *vap;
 1491         *initp = 0;
 1493         while (left) {
error = ntfs_ntvattrget(ntmp, ip, attrnum, attrname,
ntfs_btocn(off), &vap);
 1496                 if (error)
 1497                         return (error);
towrite = MIN(left, ntfs_cntob(vap->va_vcnend + 1) - off);
ddprintf(("ntfs_writeattr_plain: o: %d, s: %d (%d - %d)\n",
 1500                          (u_int32_t) off, (u_int32_t) towrite,
 1501                          (u_int32_t) vap->va_vcnstart,
 1502                          (u_int32_t) vap->va_vcnend));
error = ntfs_writentvattr_plain(ntmp, ip, vap,
off - ntfs_cntob(vap->va_vcnstart),
towrite, data, &init, uio);
 1506                 if (error) {
dprintf(("ntfs_writeattr_plain: " \
 1508                                "ntfs_writentvattr_plain failed: o: %d, s: %d\n",
 1509                                (u_int32_t) off, (u_int32_t) towrite));
dprintf(("ntfs_writeattr_plain: attrib: %d - %d\n",
 1511                                (u_int32_t) vap->va_vcnstart, 
 1512                                (u_int32_t) vap->va_vcnend));
ntfs_ntvattrrele(vap);
 1514                         break;
 1515                 }
ntfs_ntvattrrele(vap);
left -= towrite;
off += towrite;
data = data + towrite;
 1520                 *initp += init;
 1521         }
 1523         return (error);
 1524 }
 1526 /*
 1527  * This is one of the write routines.
 1528  *
 1529  * ntnode should be locked.
 1530  */
 1531 int
ntfs_writentvattr_plain(
 1533         struct ntfsmount * ntmp,
 1534         struct ntnode * ip,
 1535         struct ntvattr * vap,
off_t roff,
size_t rsize,
 1538         void *rdata,
size_t * initp,
 1540         struct uio *uio)
 1541 {
 1542         int             error = 0;
 1543         int             off;
 1544         int             cnt;
cn_t            ccn, ccl, cn, left, cl;
caddr_t         data = rdata;
 1547         struct buf     *bp;
size_t          tocopy;
 1550         *initp = 0;
 1552         if ((vap->va_flag & NTFS_AF_INRUN) == 0) {
dprintf(("ntfs_writevattr_plain: CAN'T WRITE RES. ATTRIBUTE\n"));
 1554                 return ENOTTY;
 1555         }
ddprintf(("ntfs_writentvattr_plain: data in run: %lu chains\n",
vap->va_vruncnt));
off = roff;
left = rsize;
ccl = 0;
ccn = 0;
cnt = 0;
 1565         for (; left && (cnt < vap->va_vruncnt); cnt++) {
ccn = vap->va_vruncn[cnt];
ccl = vap->va_vruncl[cnt];
ddprintf(("ntfs_writentvattr_plain: " \
 1570                          "left %d, cn: 0x%x, cl: %d, off: %d\n", \
 1571                          (u_int32_t) left, (u_int32_t) ccn, \
 1572                          (u_int32_t) ccl, (u_int32_t) off));
 1574                 if (ntfs_cntob(ccl) < off) {
off -= ntfs_cntob(ccl);
cnt++;
 1577                         continue;
 1578                 }
 1579                 if (!ccn && ip->i_number != NTFS_BOOTINO)
 1580                         continue; /* XXX */
ccl -= ntfs_btocn(off);
cn = ccn + ntfs_btocn(off);
off = ntfs_btocnoff(off);
 1586                 while (left && ccl) {
 1587                         /*
 1588                          * Always read and write single clusters at a time -
 1589                          * we need to avoid requesting differently-sized
 1590                          * blocks at the same disk offsets to avoid
 1591                          * confusing the buffer cache.
 1592                          */
tocopy = MIN(left, ntfs_cntob(1) - off);
cl = ntfs_btocl(tocopy + off);
KASSERT(cl == 1 && tocopy <= ntfs_cntob(1));
ddprintf(("ntfs_writentvattr_plain: write: " \
 1597                                 "cn: 0x%x cl: %d, off: %d len: %d, left: %d\n",
 1598                                 (u_int32_t) cn, (u_int32_t) cl, 
 1599                                 (u_int32_t) off, (u_int32_t) tocopy, 
 1600                                 (u_int32_t) left));
 1601                         if ((off == 0) && (tocopy == ntfs_cntob(cl)))
 1602                         {
bp = getblk(ntmp->ntm_devvp, ntfs_cntobn(cn),
ntfs_cntob(cl), 0, 0);
clrbuf(bp);
 1606                         } else {
error = bread(ntmp->ntm_devvp, ntfs_cntobn(cn),
ntfs_cntob(cl), NOCRED, &bp);
 1609                                 if (error) {
brelse(bp);
 1611                                         return (error);
 1612                                 }
 1613                         }
 1614                         if (uio)
uiomove(bp->b_data + off, tocopy, uio);
 1616                         else
memcpy(bp->b_data + off, data, tocopy);
bawrite(bp);
data = data + tocopy;
 1620                         *initp += tocopy;
off = 0;
left -= tocopy;
cn += cl;
ccl -= cl;
 1625                 }
 1626         }
 1628         if (left) {
printf("ntfs_writentvattr_plain: POSSIBLE RUN ERROR\n");
error = EINVAL;
 1631         }
 1633         return (error);
 1634 }
 1636 /*
 1637  * This is one of the read routines.
 1638  *
 1639  * ntnode should be locked.
 1640  */
 1641 int
ntfs_readntvattr_plain(
 1643         struct ntfsmount * ntmp,
 1644         struct ntnode * ip,
 1645         struct ntvattr * vap,
off_t roff,
size_t rsize,
 1648         void *rdata,
size_t * initp,
 1650         struct uio *uio)
 1651 {
 1652         int             error = 0;
 1653         int             off;
 1655         *initp = 0;
 1656         if (vap->va_flag & NTFS_AF_INRUN) {
 1657                 int             cnt;
cn_t            ccn, ccl, cn, left, cl;
caddr_t         data = rdata;
 1660                 struct buf     *bp;
size_t          tocopy;
ddprintf(("ntfs_readntvattr_plain: data in run: %lu chains\n",
vap->va_vruncnt));
off = roff;
left = rsize;
ccl = 0;
ccn = 0;
cnt = 0;
 1671                 while (left && (cnt < vap->va_vruncnt)) {
ccn = vap->va_vruncn[cnt];
ccl = vap->va_vruncl[cnt];
ddprintf(("ntfs_readntvattr_plain: " \
 1676                                  "left %d, cn: 0x%x, cl: %d, off: %d\n", \
 1677                                  (u_int32_t) left, (u_int32_t) ccn, \
 1678                                  (u_int32_t) ccl, (u_int32_t) off));
 1680                         if (ntfs_cntob(ccl) < off) {
off -= ntfs_cntob(ccl);
cnt++;
 1683                                 continue;
 1684                         }
 1685                         if (ccn || ip->i_number == NTFS_BOOTINO) {
ccl -= ntfs_btocn(off);
cn = ccn + ntfs_btocn(off);
off = ntfs_btocnoff(off);
 1690                                 while (left && ccl) {
 1691                                         /*
 1692                                          * Always read single clusters at a
 1693                                          * time - we need to avoid reading
 1694                                          * differently-sized blocks at the
 1695                                          * same disk offsets to avoid
 1696                                          * confusing the buffer cache.
 1697                                          */
tocopy = MIN(left,
ntfs_cntob(1) - off);
cl = ntfs_btocl(tocopy + off);
KASSERT(cl == 1 &&
tocopy <= ntfs_cntob(1));
ddprintf(("ntfs_readntvattr_plain: " \
 1705                                                 "read: cn: 0x%x cl: %d, " \
 1706                                                 "off: %d len: %d, left: %d\n",
 1707                                                 (u_int32_t) cn, 
 1708                                                 (u_int32_t) cl, 
 1709                                                 (u_int32_t) off, 
 1710                                                 (u_int32_t) tocopy, 
 1711                                                 (u_int32_t) left));
error = bread(ntmp->ntm_devvp,
ntfs_cntobn(cn),
ntfs_cntob(cl),
NOCRED, &bp);
 1716                                         if (error) {
brelse(bp);
 1718                                                 return (error);
 1719                                         }
 1720                                         if (uio) {
uiomove(bp->b_data + off,
tocopy, uio);
 1723                                         } else {
memcpy(data, bp->b_data + off,
tocopy);
 1726                                         }
brelse(bp);
data = data + tocopy;
 1729                                         *initp += tocopy;
off = 0;
left -= tocopy;
cn += cl;
ccl -= cl;
 1734                                 }
 1735                         } else {
tocopy = MIN(left, ntfs_cntob(ccl) - off);
ddprintf(("ntfs_readntvattr_plain: "
 1738                                         "hole: ccn: 0x%x ccl: %d, off: %d, " \
 1739                                         " len: %d, left: %d\n", 
 1740                                         (u_int32_t) ccn, (u_int32_t) ccl, 
 1741                                         (u_int32_t) off, (u_int32_t) tocopy, 
 1742                                         (u_int32_t) left));
left -= tocopy;
off = 0;
 1745                                 if (uio) {
size_t remains = tocopy;
 1747                                         for(; remains; remains--)
uiomove("", 1, uio);
 1749                                 } else 
bzero(data, tocopy);
data = data + tocopy;
 1752                         }
cnt++;
 1754                 }
 1755                 if (left) {
printf("ntfs_readntvattr_plain: POSSIBLE RUN ERROR\n");
error = E2BIG;
 1758                 }
 1759         } else {
ddprintf(("ntfs_readnvattr_plain: data is in mft record\n"));
 1761                 if (uio) 
uiomove(vap->va_datap + roff, rsize, uio);
 1763                 else
memcpy(rdata, vap->va_datap + roff, rsize);
 1765                 *initp += rsize;
 1766         }
 1768         return (error);
 1769 }
 1771 /*
 1772  * This is one of read routines.
 1773  */
 1774 int
ntfs_readattr_plain(
 1776         struct ntfsmount * ntmp,
 1777         struct ntnode * ip,
u_int32_t attrnum,      
 1779         char *attrname,
off_t roff,
size_t rsize,
 1782         void *rdata,
size_t * initp,
 1784         struct uio *uio)
 1785 {
size_t          init;
 1787         int             error = 0;
off_t           off = roff, left = rsize, toread;
caddr_t         data = rdata;
 1790         struct ntvattr *vap;
 1791         *initp = 0;
 1793         while (left) {
error = ntfs_ntvattrget(ntmp, ip, attrnum, attrname,
ntfs_btocn(off), &vap);
 1796                 if (error)
 1797                         return (error);
toread = MIN(left, ntfs_cntob(vap->va_vcnend + 1) - off);
ddprintf(("ntfs_readattr_plain: o: %d, s: %d (%d - %d)\n",
 1800                          (u_int32_t) off, (u_int32_t) toread,
 1801                          (u_int32_t) vap->va_vcnstart,
 1802                          (u_int32_t) vap->va_vcnend));
error = ntfs_readntvattr_plain(ntmp, ip, vap,
off - ntfs_cntob(vap->va_vcnstart),
toread, data, &init, uio);
 1806                 if (error) {
printf("ntfs_readattr_plain: " \
 1808                                "ntfs_readntvattr_plain failed: o: %d, s: %d\n",
 1809                                (u_int32_t) off, (u_int32_t) toread);
printf("ntfs_readattr_plain: attrib: %d - %d\n",
 1811                                (u_int32_t) vap->va_vcnstart, 
 1812                                (u_int32_t) vap->va_vcnend);
ntfs_ntvattrrele(vap);
 1814                         break;
 1815                 }
ntfs_ntvattrrele(vap);
left -= toread;
off += toread;
data = data + toread;
 1820                 *initp += init;
 1821         }
 1823         return (error);
 1824 }
 1826 /*
 1827  * This is one of read routines.
 1828  */
 1829 int
ntfs_readattr(
 1831         struct ntfsmount * ntmp,
 1832         struct ntnode * ip,
u_int32_t attrnum,
 1834         char *attrname,
off_t roff,
size_t rsize,
 1837         void *rdata,
 1838         struct uio *uio)
 1839 {
 1840         int             error = 0;
 1841         struct ntvattr *vap;
size_t          init;
ddprintf(("ntfs_readattr: reading %d: 0x%x, from %d size %d bytes\n",
ip->i_number, attrnum, (u_int32_t) roff, (u_int32_t) rsize));
error = ntfs_ntvattrget(ntmp, ip, attrnum, attrname, 0, &vap);
 1848         if (error)
 1849                 return (error);
 1851         if ((roff > vap->va_datalen) ||
 1852             (roff + rsize > vap->va_datalen)) {
printf("ntfs_readattr: offset too big: %ld (%ld) > %ld\n",
 1854                         (long int) roff, (long int) roff + rsize,
 1855                         (long int) vap->va_datalen);
ntfs_ntvattrrele(vap);
 1857                 return (E2BIG);
 1858         }
 1859         if (vap->va_compression && vap->va_compressalg) {
u_int8_t       *cup;
u_int8_t       *uup;
off_t           off = roff, left = rsize, tocopy;
caddr_t         data = rdata;
cn_t            cn;
ddprintf(("ntfs_ntreadattr: compression: %d\n",
vap->va_compressalg));
MALLOC(cup, u_int8_t *, ntfs_cntob(NTFS_COMPUNIT_CL),
M_NTFSDECOMP, M_WAITOK);
MALLOC(uup, u_int8_t *, ntfs_cntob(NTFS_COMPUNIT_CL),
M_NTFSDECOMP, M_WAITOK);
cn = (ntfs_btocn(roff)) & (~(NTFS_COMPUNIT_CL - 1));
off = roff - ntfs_cntob(cn);
 1877                 while (left) {
error = ntfs_readattr_plain(ntmp, ip, attrnum,
attrname, ntfs_cntob(cn),
ntfs_cntob(NTFS_COMPUNIT_CL),
cup, &init, NULL);
 1882                         if (error)
 1883                                 break;
tocopy = MIN(left, ntfs_cntob(NTFS_COMPUNIT_CL) - off);
 1887                         if (init == ntfs_cntob(NTFS_COMPUNIT_CL)) {
 1888                                 if (uio)
uiomove(cup + off, tocopy, uio);
 1890                                 else
memcpy(data, cup + off, tocopy);
 1892                         } else if (init == 0) {
 1893                                 if (uio) {
size_t remains = tocopy;
 1895                                         for(; remains; remains--)
uiomove("", 1, uio);
 1897                                 }
 1898                                 else
bzero(data, tocopy);
 1900                         } else {
error = ntfs_uncompunit(ntmp, uup, cup);
 1902                                 if (error)
 1903                                         break;
 1904                                 if (uio)
uiomove(uup + off, tocopy, uio);
 1906                                 else
memcpy(data, uup + off, tocopy);
 1908                         }
left -= tocopy;
data = data + tocopy;
off += tocopy - ntfs_cntob(NTFS_COMPUNIT_CL);
cn += NTFS_COMPUNIT_CL;
 1914                 }
FREE(uup, M_NTFSDECOMP);
FREE(cup, M_NTFSDECOMP);
 1918         } else
error = ntfs_readattr_plain(ntmp, ip, attrnum, attrname,
roff, rsize, rdata, &init, uio);
ntfs_ntvattrrele(vap);
 1922         return (error);
 1923 }
 1925 #if UNUSED_CODE
 1926 int
ntfs_parserun(
cn_t * cn,
cn_t * cl,
u_int8_t * run,
u_long len,
u_long *off)
 1933 {
u_int8_t        sz;
 1935         int             i;
 1937         if (NULL == run) {
printf("ntfs_parsetun: run == NULL\n");
 1939                 return (EINVAL);
 1940         }
sz = run[(*off)++];
 1942         if (0 == sz) {
printf("ntfs_parserun: trying to go out of run\n");
 1944                 return (E2BIG);
 1945         }
 1946         *cl = 0;
 1947         if ((sz & 0xF) > 8 || (*off) + (sz & 0xF) > len) {
printf("ntfs_parserun: " \
 1949                        "bad run: length too big: sz: 0x%02x (%ld < %ld + sz)\n",
sz, len, *off);
 1951                 return (EINVAL);
 1952         }
 1953         for (i = 0; i < (sz & 0xF); i++)
 1954                 *cl += (u_int32_t) run[(*off)++] << (i << 3);
sz >>= 4;
 1957         if ((sz & 0xF) > 8 || (*off) + (sz & 0xF) > len) {
printf("ntfs_parserun: " \
 1959                        "bad run: length too big: sz: 0x%02x (%ld < %ld + sz)\n",
sz, len, *off);
 1961                 return (EINVAL);
 1962         }
 1963         for (i = 0; i < (sz & 0xF); i++)
 1964                 *cn += (u_int32_t) run[(*off)++] << (i << 3);
 1966         return (0);
 1967 }
 1968 #endif
 1970 /*
 1971  * Process fixup routine on given buffer.
 1972  */
 1973 int
ntfs_procfixups(
 1975                 struct ntfsmount * ntmp,
u_int32_t magic,
caddr_t buf,
size_t len)
 1979 {
 1980         struct fixuphdr *fhp = (struct fixuphdr *) buf;
 1981         int             i;
u_int16_t       fixup;
u_int16_t      *fxp;
u_int16_t      *cfxp;
 1986         if (fhp->fh_magic != magic) {
printf("ntfs_procfixups: magic doesn't match: %08x != %08x\n",
fhp->fh_magic, magic);
 1989                 return (EINVAL);
 1990         }
 1991         if ((fhp->fh_fnum - 1) * ntmp->ntm_bps != len) {
printf("ntfs_procfixups: " \
 1993                        "bad fixups number: %d for %ld bytes block\n", 
fhp->fh_fnum, (long)len);        /* XXX printf kludge */
 1995                 return (EINVAL);
 1996         }
 1997         if (fhp->fh_foff >= ntmp->ntm_spc * ntmp->ntm_mftrecsz * ntmp->ntm_bps) {
printf("ntfs_procfixups: invalid offset: %x", fhp->fh_foff);
 1999                 return (EINVAL);
 2000         }
fxp = (u_int16_t *) (buf + fhp->fh_foff);
cfxp = (u_int16_t *) (buf + ntmp->ntm_bps - 2);
fixup = *fxp++;
 2004         for (i = 1; i < fhp->fh_fnum; i++, fxp++) {
 2005                 if (*cfxp != fixup) {
printf("ntfs_procfixups: fixup %d doesn't match\n", i);
 2007                         return (EINVAL);
 2008                 }
 2009                 *cfxp = *fxp;
cfxp = (u_int16_t *)((caddr_t)cfxp + ntmp->ntm_bps);
 2011         }
 2012         return (0);
 2013 }
 2015 #if UNUSED_CODE
 2016 int
ntfs_runtocn(
cn_t * cn, 
 2019              struct ntfsmount * ntmp,
u_int8_t * run,
u_long len,
cn_t vcn)
 2023 {
cn_t            ccn = 0;
cn_t            ccl = 0;
u_long          off = 0;
 2027         int             error = 0;
 2029 #if NTFS_DEBUG
 2030         int             i;
printf("ntfs_runtocn: run: %p, %ld bytes, vcn:%ld\n",
run, len, (u_long) vcn);
printf("ntfs_runtocn: run: ");
 2034         for (i = 0; i < len; i++)
printf("0x%02x ", run[i]);
printf("\n");
 2037 #endif
 2039         if (NULL == run) {
printf("ntfs_runtocn: run == NULL\n");
 2041                 return (EINVAL);
 2042         }
 2043         do {
 2044                 if (run[off] == 0) {
printf("ntfs_runtocn: vcn too big\n");
 2046                         return (E2BIG);
 2047                 }
vcn -= ccl;
error = ntfs_parserun(&ccn, &ccl, run, len, &off);
 2050                 if (error) {
printf("ntfs_runtocn: ntfs_parserun failed\n");
 2052                         return (error);
 2053                 }
 2054         } while (ccl <= vcn);
 2055         *cn = ccn + vcn;
 2056         return (0);
 2057 }
 2058 #endif
 2060 /*
 2061  * this initializes toupper table & dependant variables to be ready for
 2062  * later work
 2063  */
 2064 void
ntfs_toupper_init()
 2066 {
ntfs_toupper_tab = (wchar *) NULL;
lockinit(&ntfs_toupper_lock, PVFS, "ntfs_toupper", 0, 0);
ntfs_toupper_usecount = 0;
 2070 }
 2072 /*
 2073  * if the ntfs_toupper_tab[] is filled already, just raise use count;
 2074  * otherwise read the data from the filesystem we are currently mounting
 2075  */
 2076 int
 2077 #ifndef __OpenBSD__
ntfs_toupper_use(mp, ntmp)
 2079         struct mount *mp;
 2080         struct ntfsmount *ntmp;
 2081 #else
ntfs_toupper_use(mp, ntmp, p)
 2083         struct mount *mp;
 2084         struct ntfsmount *ntmp;
 2085         struct proc *p;
 2086 #endif
 2087 {
 2088         int error = 0;
 2089         struct vnode *vp;
 2091         /* get exclusive access */
lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
 2094         /* only read the translation data from a file if it hasn't been
 2095          * read already */
 2096         if (ntfs_toupper_tab)
 2097                 goto out;
 2099         /*
 2100          * Read in Unicode lowercase -> uppercase translation file.
 2101          * XXX for now, just the first 256 entries are used anyway,
 2102          * so don't bother reading more
 2103          */
MALLOC(ntfs_toupper_tab, wchar *, 256 * 256 * sizeof(wchar),
M_NTFSRDATA, M_WAITOK);
 2107         if ((error = VFS_VGET(mp, NTFS_UPCASEINO, &vp)))
 2108                 goto out;
error = ntfs_readattr(ntmp, VTONT(vp), NTFS_A_DATA, NULL,
 2110                         0, 256*256*sizeof(wchar), (char *) ntfs_toupper_tab,
NULL);
vput(vp);
out:
ntfs_toupper_usecount++;
lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL);
 2117         return (error);
 2118 }
 2120 /*
 2121  * lower the use count and if it reaches zero, free the memory
 2122  * tied by toupper table
 2123  */
 2124 void
 2125 #ifndef __OpenBSD__
ntfs_toupper_unuse()
 2127 #else
ntfs_toupper_unuse(p)
 2129         struct proc *p;
 2130 #endif
 2131 {
 2132         /* get exclusive access */
lockmgr(&ntfs_toupper_lock, LK_EXCLUSIVE, NULL);
ntfs_toupper_usecount--;
 2136         if (ntfs_toupper_usecount == 0) {
FREE(ntfs_toupper_tab, M_NTFSRDATA);
ntfs_toupper_tab = NULL;
 2139         }
 2140 #ifdef DIAGNOSTIC
 2141         else if (ntfs_toupper_usecount < 0) {
panic("ntfs_toupper_unuse(): use count negative: %d",
ntfs_toupper_usecount);
 2144         }
 2145 #endif
 2147         /* release the lock */
lockmgr(&ntfs_toupper_lock, LK_RELEASE, NULL);
 2149 }