Annotation of sys/ntfs/ntfs_vfsops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ntfs_vfsops.c,v 1.11 2006/04/19 11:55:55 pedro Exp $ */
! 2: /* $NetBSD: ntfs_vfsops.c,v 1.7 2003/04/24 07:50:19 christos Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1998, 1999 Semen Ustimenko
! 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_vfsops.c,v 1.7 1999/05/31 11:28:30 phk Exp
! 30: */
! 31:
! 32: #include <sys/cdefs.h>
! 33: #ifdef __KERNEL_RCSID
! 34: __KERNEL_RCSID(0, "$NetBSD: ntfs_vfsops.c,v 1.7 2003/04/24 07:50:19 christos Exp $");
! 35: #endif
! 36:
! 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/fcntl.h>
! 46: #include <sys/malloc.h>
! 47: #include <sys/systm.h>
! 48: #include <sys/device.h>
! 49: #include <sys/conf.h>
! 50:
! 51: #if defined(__NetBSD__) || defined(__OpenBSD__)
! 52: #include <uvm/uvm_extern.h>
! 53: #else
! 54: #include <vm/vm.h>
! 55: #endif
! 56:
! 57: #include <miscfs/specfs/specdev.h>
! 58:
! 59: /*#define NTFS_DEBUG 1*/
! 60: #if defined(__FreeBSD__) || defined(__NetBSD__)
! 61: #include <fs/ntfs/ntfs.h>
! 62: #include <fs/ntfs/ntfs_inode.h>
! 63: #include <fs/ntfs/ntfs_subr.h>
! 64: #include <fs/ntfs/ntfs_vfsops.h>
! 65: #include <fs/ntfs/ntfs_ihash.h>
! 66: #include <fs/ntfs/ntfsmount.h>
! 67: #else
! 68: #include <ntfs/ntfs.h>
! 69: #include <ntfs/ntfs_inode.h>
! 70: #include <ntfs/ntfs_subr.h>
! 71: #include <ntfs/ntfs_vfsops.h>
! 72: #include <ntfs/ntfs_ihash.h>
! 73: #include <ntfs/ntfsmount.h>
! 74: #endif
! 75:
! 76: #ifdef MALLOC_DEFINE
! 77: MALLOC_DEFINE(M_NTFSMNT, "NTFS mount", "NTFS mount structure");
! 78: MALLOC_DEFINE(M_NTFSNTNODE,"NTFS ntnode", "NTFS ntnode information");
! 79: MALLOC_DEFINE(M_NTFSFNODE,"NTFS fnode", "NTFS fnode information");
! 80: MALLOC_DEFINE(M_NTFSDIR,"NTFS dir", "NTFS dir buffer");
! 81: #endif
! 82:
! 83: #if defined(__FreeBSD__)
! 84: static int ntfs_mount(struct mount *, char *, caddr_t,
! 85: struct nameidata *, struct proc *);
! 86: #else
! 87: static int ntfs_mount(struct mount *, const char *, void *,
! 88: struct nameidata *, struct proc *);
! 89: #endif
! 90: static int ntfs_quotactl(struct mount *, int, uid_t, caddr_t,
! 91: struct proc *);
! 92: static int ntfs_root(struct mount *, struct vnode **);
! 93: static int ntfs_start(struct mount *, int, struct proc *);
! 94: static int ntfs_statfs(struct mount *, struct statfs *,
! 95: struct proc *);
! 96: static int ntfs_sync(struct mount *, int, struct ucred *,
! 97: struct proc *);
! 98: static int ntfs_unmount(struct mount *, int, struct proc *);
! 99: static int ntfs_vget(struct mount *mp, ino_t ino,
! 100: struct vnode **vpp);
! 101: static int ntfs_mountfs(struct vnode *, struct mount *,
! 102: struct ntfs_args *, struct proc *);
! 103: static int ntfs_vptofh(struct vnode *, struct fid *);
! 104:
! 105: #if defined(__FreeBSD__)
! 106: static int ntfs_init(struct vfsconf *);
! 107: static int ntfs_fhtovp(struct mount *, struct fid *,
! 108: struct sockaddr *, struct vnode **,
! 109: int *, struct ucred **);
! 110: #elif defined(__NetBSD__)
! 111: static void ntfs_init(void);
! 112: static void ntfs_reinit(void);
! 113: static void ntfs_done(void);
! 114: static int ntfs_fhtovp(struct mount *, struct fid *,
! 115: struct vnode **);
! 116: static int ntfs_checkexp(struct mount *, struct mbuf *,
! 117: int *, struct ucred **);
! 118: static int ntfs_mountroot(void);
! 119: static int ntfs_sysctl(int *, u_int, void *, size_t *, void *,
! 120: size_t, struct proc *);
! 121: #elif defined(__OpenBSD__)
! 122: static int ntfs_init(struct vfsconf *);
! 123: static int ntfs_fhtovp(struct mount *, struct fid *,
! 124: struct vnode **);
! 125: static int ntfs_checkexp(struct mount *, struct mbuf *,
! 126: int *, struct ucred **);
! 127: static int ntfs_sysctl(int *, u_int, void *, size_t *, void *,
! 128: size_t, struct proc *);
! 129: #else
! 130: static int ntfs_init(void);
! 131: static int ntfs_fhtovp(struct mount *, struct fid *,
! 132: struct mbuf *, struct vnode **,
! 133: int *, struct ucred **);
! 134: #endif
! 135:
! 136: #if defined(__FreeBSD__) || defined(__NetBSD__)
! 137: struct genfs_ops ntfs_genfsops = {
! 138: NULL,
! 139: NULL,
! 140: genfs_compat_gop_write,
! 141: };
! 142: #endif
! 143:
! 144: #if defined(__NetBSD__) || defined(__OpenBSD__)
! 145: /*
! 146: * Verify a remote client has export rights and return these rights via.
! 147: * exflagsp and credanonp.
! 148: */
! 149: static int
! 150: ntfs_checkexp(mp, nam, exflagsp, credanonp)
! 151: struct mount *mp;
! 152: struct mbuf *nam;
! 153: int *exflagsp;
! 154: struct ucred **credanonp;
! 155: {
! 156: struct netcred *np;
! 157: struct ntfsmount *ntm = VFSTONTFS(mp);
! 158:
! 159: /*
! 160: * Get the export permission structure for this <mp, client> tuple.
! 161: */
! 162: np = vfs_export_lookup(mp, &ntm->ntm_export, nam);
! 163: if (np == NULL)
! 164: return (EACCES);
! 165:
! 166: *exflagsp = np->netc_exflags;
! 167: *credanonp = &np->netc_anon;
! 168: return (0);
! 169: }
! 170:
! 171: /*ARGSUSED*/
! 172: static int
! 173: ntfs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
! 174: int *name;
! 175: u_int namelen;
! 176: void *oldp;
! 177: size_t *oldlenp;
! 178: void *newp;
! 179: size_t newlen;
! 180: struct proc *p;
! 181: {
! 182: return (EINVAL);
! 183: }
! 184:
! 185: #endif
! 186:
! 187: #ifdef __NetBSD__
! 188: static int
! 189: ntfs_mountroot()
! 190: {
! 191: struct mount *mp;
! 192: struct proc *p = curproc; /* XXX */
! 193: int error;
! 194: struct ntfs_args args;
! 195:
! 196: if (root_device->dv_class != DV_DISK)
! 197: return (ENODEV);
! 198:
! 199: /*
! 200: * Get vnodes for rootdev.
! 201: */
! 202: if (bdevvp(rootdev, &rootvp))
! 203: panic("ntfs_mountroot: can't setup rootvp");
! 204:
! 205: if ((error = vfs_rootmountalloc(MOUNT_NTFS, "root_device", &mp))) {
! 206: vrele(rootvp);
! 207: return (error);
! 208: }
! 209:
! 210: args.flag = 0;
! 211: args.uid = 0;
! 212: args.gid = 0;
! 213: args.mode = 0777;
! 214:
! 215: if ((error = ntfs_mountfs(rootvp, mp, &args, p)) != 0) {
! 216: mp->mnt_op->vfs_refcount--;
! 217: vfs_unbusy(mp);
! 218: free(mp, M_MOUNT);
! 219: vrele(rootvp);
! 220: return (error);
! 221: }
! 222:
! 223: CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
! 224: (void)ntfs_statfs(mp, &mp->mnt_stat, p);
! 225: vfs_unbusy(mp);
! 226:
! 227: return (0);
! 228: }
! 229:
! 230: static void
! 231: ntfs_init()
! 232: {
! 233: #ifdef _LKM
! 234: malloc_type_attach(M_NTFSMNT);
! 235: malloc_type_attach(M_NTFSNTNODE);
! 236: malloc_type_attach(M_NTFSFNODE);
! 237: malloc_type_attach(M_NTFSDIR);
! 238: malloc_type_attach(M_NTFSNTHASH);
! 239: malloc_type_attach(M_NTFSNTVATTR);
! 240: malloc_type_attach(M_NTFSRDATA);
! 241: malloc_type_attach(M_NTFSDECOMP);
! 242: malloc_type_attach(M_NTFSRUN);
! 243: #endif
! 244: ntfs_nthashinit();
! 245: ntfs_toupper_init();
! 246: }
! 247:
! 248: static void
! 249: ntfs_reinit()
! 250: {
! 251: ntfs_nthashreinit();
! 252: }
! 253:
! 254: static void
! 255: ntfs_done()
! 256: {
! 257: ntfs_nthashdone();
! 258: #ifdef _LKM
! 259: malloc_type_detach(M_NTFSMNT);
! 260: malloc_type_detach(M_NTFSNTNODE);
! 261: malloc_type_detach(M_NTFSFNODE);
! 262: malloc_type_detach(M_NTFSDIR);
! 263: malloc_type_detach(M_NTFSNTHASH);
! 264: malloc_type_detach(M_NTFSNTVATTR);
! 265: malloc_type_detach(M_NTFSRDATA);
! 266: malloc_type_detach(M_NTFSDECOMP);
! 267: malloc_type_detach(M_NTFSRUN);
! 268: #endif
! 269: }
! 270:
! 271: #elif defined(__FreeBSD__) || defined(__OpenBSD__)
! 272:
! 273: static int
! 274: ntfs_init (
! 275: struct vfsconf *vcp )
! 276: {
! 277: ntfs_nthashinit();
! 278: ntfs_toupper_init();
! 279: return 0;
! 280: }
! 281:
! 282: #endif /* NetBSD */
! 283:
! 284: static int
! 285: ntfs_mount(
! 286: struct mount *mp,
! 287: #if defined(__FreeBSD__)
! 288: char *path,
! 289: caddr_t data,
! 290: #else
! 291: const char *path,
! 292: void *data,
! 293: #endif
! 294: struct nameidata *ndp,
! 295: struct proc *p )
! 296: {
! 297: int err = 0;
! 298: struct vnode *devvp;
! 299: struct ntfs_args args;
! 300: size_t size;
! 301: mode_t amode;
! 302:
! 303: #ifdef __FreeBSD__
! 304: /*
! 305: * Use NULL path to flag a root mount
! 306: */
! 307: if( path == NULL) {
! 308: /*
! 309: ***
! 310: * Mounting root file system
! 311: ***
! 312: */
! 313:
! 314: /* Get vnode for root device*/
! 315: if( bdevvp( rootdev, &rootvp))
! 316: panic("ffs_mountroot: can't setup bdevvp for root");
! 317:
! 318: /*
! 319: * FS specific handling
! 320: */
! 321: mp->mnt_flag |= MNT_RDONLY; /* XXX globally applicable?*/
! 322:
! 323: /*
! 324: * Attempt mount
! 325: */
! 326: if( ( err = ntfs_mountfs(rootvp, mp, &args, p)) != 0) {
! 327: /* fs specific cleanup (if any)*/
! 328: goto error_1;
! 329: }
! 330:
! 331: goto dostatfs; /* success*/
! 332:
! 333: }
! 334: #endif /* FreeBSD */
! 335:
! 336: #ifdef __NetBSD__
! 337: if (mp->mnt_flag & MNT_GETARGS) {
! 338: struct ntfsmount *ntmp = VFSTONTFS(mp);
! 339: if (ntmp == NULL)
! 340: return EIO;
! 341: args.fspec = NULL;
! 342: args.uid = ntmp->ntm_uid;
! 343: args.gid = ntmp->ntm_gid;
! 344: args.mode = ntmp->ntm_mode;
! 345: args.flag = ntmp->ntm_flag;
! 346: vfs_showexport(mp, &args.export, &ntmp->ntm_export);
! 347: return copyout(&args, data, sizeof(args));
! 348: }
! 349: #endif
! 350:
! 351: /*
! 352: ***
! 353: * Mounting non-root file system or updating a file system
! 354: ***
! 355: */
! 356:
! 357: /* copy in user arguments*/
! 358: err = copyin(data, (caddr_t)&args, sizeof (struct ntfs_args));
! 359: if (err)
! 360: goto error_1; /* can't get arguments*/
! 361:
! 362: /*
! 363: * If updating, check whether changing from read-only to
! 364: * read/write; if there is no device name, that's all we do.
! 365: */
! 366: if (mp->mnt_flag & MNT_UPDATE) {
! 367: /* if not updating name...*/
! 368: if (args.fspec == 0) {
! 369: /*
! 370: * Process export requests. Jumping to "success"
! 371: * will return the vfs_export() error code.
! 372: */
! 373: struct ntfsmount *ntm = VFSTONTFS(mp);
! 374: err = vfs_export(mp, &ntm->ntm_export, &args.export_info);
! 375: goto success;
! 376: }
! 377:
! 378: printf("ntfs_mount(): MNT_UPDATE not supported\n");
! 379: err = EINVAL;
! 380: goto error_1;
! 381: }
! 382:
! 383: /*
! 384: * Not an update, or updating the name: look up the name
! 385: * and verify that it refers to a sensible block device.
! 386: */
! 387: NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
! 388: err = namei(ndp);
! 389: if (err) {
! 390: /* can't get devvp!*/
! 391: goto error_1;
! 392: }
! 393:
! 394: devvp = ndp->ni_vp;
! 395:
! 396: if (devvp->v_type != VBLK) {
! 397: err = ENOTBLK;
! 398: goto error_2;
! 399: }
! 400:
! 401: #ifdef __FreeBSD__
! 402: if (bdevsw(devvp->v_rdev) == NULL) {
! 403: #elif defined(__NetBSD__)
! 404: if (bdevsw_lookup(devvp->v_rdev) == NULL) {
! 405: #else
! 406: if (major(devvp->v_rdev) >= nblkdev) {
! 407: #endif
! 408: err = ENXIO;
! 409: goto error_2;
! 410: }
! 411:
! 412: /*
! 413: * If we are not root, make sure we have permission to access the
! 414: * requested device.
! 415: */
! 416: if (p->p_ucred->cr_uid) {
! 417: amode = (mp->mnt_flag & MNT_RDONLY) ? VREAD : (VREAD | VWRITE);
! 418: vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 419: err = VOP_ACCESS(devvp, amode, p->p_ucred, p);
! 420: VOP_UNLOCK(devvp, 0, p);
! 421: if (err)
! 422: goto error_2;
! 423: }
! 424:
! 425: if (mp->mnt_flag & MNT_UPDATE) {
! 426: #if 0
! 427: /*
! 428: ********************
! 429: * UPDATE
! 430: ********************
! 431: */
! 432:
! 433: if (devvp != ntmp->um_devvp)
! 434: err = EINVAL; /* needs translation */
! 435: else
! 436: vrele(devvp);
! 437: /*
! 438: * Update device name only on success
! 439: */
! 440: if( !err) {
! 441: err = set_statfs_info(NULL, UIO_USERSPACE, args.fspec,
! 442: UIO_USERSPACE, mp, p);
! 443: }
! 444: #endif
! 445: } else {
! 446: /*
! 447: ********************
! 448: * NEW MOUNT
! 449: ********************
! 450: */
! 451:
! 452: /*
! 453: * Since this is a new mount, we want the names for
! 454: * the device and the mount point copied in. If an
! 455: * error occurs, the mountpoint is discarded by the
! 456: * upper level code.
! 457: */
! 458: /* Save "last mounted on" info for mount point (NULL pad)*/
! 459: #if defined(__FreeBSD__) || defined(__NetBSD__)
! 460: err = set_statfs_info(path, UIO_USERSPACE, args.fspec,
! 461: UIO_USERSPACE, mp, p);
! 462: #else
! 463: (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1,
! 464: &size);
! 465: bzero(mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
! 466: (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname,
! 467: MNAMELEN - 1, &size);
! 468: bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
! 469: bcopy(&args, &mp->mnt_stat.mount_info.ntfs_args, sizeof(args));
! 470: #endif
! 471: if ( !err) {
! 472: err = ntfs_mountfs(devvp, mp, &args, p);
! 473: }
! 474: }
! 475: if (err) {
! 476: goto error_2;
! 477: }
! 478:
! 479: #ifdef __FreeBSD__
! 480: dostatfs:
! 481: #endif
! 482: /*
! 483: * Initialize FS stat information in mount struct; uses both
! 484: * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
! 485: *
! 486: * This code is common to root and non-root mounts
! 487: */
! 488: (void)VFS_STATFS(mp, &mp->mnt_stat, p);
! 489:
! 490: goto success;
! 491:
! 492:
! 493: error_2: /* error with devvp held*/
! 494:
! 495: /* release devvp before failing*/
! 496: vrele(devvp);
! 497:
! 498: error_1: /* no state to back out*/
! 499:
! 500: success:
! 501: return(err);
! 502: }
! 503:
! 504: /*
! 505: * Common code for mount and mountroot
! 506: */
! 507: int
! 508: ntfs_mountfs(devvp, mp, argsp, p)
! 509: struct vnode *devvp;
! 510: struct mount *mp;
! 511: struct ntfs_args *argsp;
! 512: struct proc *p;
! 513: {
! 514: struct buf *bp;
! 515: struct ntfsmount *ntmp = NULL;
! 516: dev_t dev = devvp->v_rdev;
! 517: int error, ronly, ncount, i;
! 518: struct vnode *vp;
! 519:
! 520: /*
! 521: * Disallow multiple mounts of the same device.
! 522: * Disallow mounting of a device that is currently in use
! 523: * (except for root, which might share swap device for miniroot).
! 524: * Flush out any old buffers remaining from a previous use.
! 525: */
! 526: error = vfs_mountedon(devvp);
! 527: if (error)
! 528: return (error);
! 529: ncount = vcount(devvp);
! 530: if (ncount > 1 && devvp != rootvp)
! 531: return (EBUSY);
! 532: error = vinvalbuf(devvp, V_SAVE, p->p_ucred, p, 0, 0);
! 533: if (error)
! 534: return (error);
! 535:
! 536: ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
! 537: error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
! 538: if (error)
! 539: return (error);
! 540:
! 541: bp = NULL;
! 542:
! 543: error = bread(devvp, BBLOCK, BBSIZE, NOCRED, &bp);
! 544: if (error)
! 545: goto out;
! 546: ntmp = malloc(sizeof *ntmp, M_NTFSMNT, M_WAITOK);
! 547: bzero(ntmp, sizeof *ntmp);
! 548: bcopy(bp->b_data, &ntmp->ntm_bootfile, sizeof(struct bootfile));
! 549: brelse(bp);
! 550: bp = NULL;
! 551:
! 552: if (strncmp(ntmp->ntm_bootfile.bf_sysid, NTFS_BBID, NTFS_BBIDLEN)) {
! 553: error = EINVAL;
! 554: dprintf(("ntfs_mountfs: invalid boot block\n"));
! 555: goto out;
! 556: }
! 557:
! 558: {
! 559: int8_t cpr = ntmp->ntm_mftrecsz;
! 560: if( cpr > 0 )
! 561: ntmp->ntm_bpmftrec = ntmp->ntm_spc * cpr;
! 562: else
! 563: ntmp->ntm_bpmftrec = (1 << (-cpr)) / ntmp->ntm_bps;
! 564: }
! 565: dprintf(("ntfs_mountfs(): bps: %d, spc: %d, media: %x, mftrecsz: %d (%d sects)\n",
! 566: ntmp->ntm_bps,ntmp->ntm_spc,ntmp->ntm_bootfile.bf_media,
! 567: ntmp->ntm_mftrecsz,ntmp->ntm_bpmftrec));
! 568: dprintf(("ntfs_mountfs(): mftcn: 0x%x|0x%x\n",
! 569: (u_int32_t)ntmp->ntm_mftcn,(u_int32_t)ntmp->ntm_mftmirrcn));
! 570:
! 571: ntmp->ntm_mountp = mp;
! 572: ntmp->ntm_dev = dev;
! 573: ntmp->ntm_devvp = devvp;
! 574: ntmp->ntm_uid = argsp->uid;
! 575: ntmp->ntm_gid = argsp->gid;
! 576: ntmp->ntm_mode = argsp->mode;
! 577: ntmp->ntm_flag = argsp->flag;
! 578: #ifdef __OpenBSD__
! 579: mp->mnt_data = (qaddr_t) ntmp;
! 580: #else
! 581: mp->mnt_data = ntmp;
! 582: #endif
! 583:
! 584: /* set file name encode/decode hooks XXX utf-8 only for now */
! 585: ntmp->ntm_wget = ntfs_utf8_wget;
! 586: ntmp->ntm_wput = ntfs_utf8_wput;
! 587: ntmp->ntm_wcmp = ntfs_utf8_wcmp;
! 588:
! 589: dprintf(("ntfs_mountfs(): case-%s,%s uid: %d, gid: %d, mode: %o\n",
! 590: (ntmp->ntm_flag & NTFS_MFLAG_CASEINS)?"insens.":"sens.",
! 591: (ntmp->ntm_flag & NTFS_MFLAG_ALLNAMES)?" allnames,":"",
! 592: ntmp->ntm_uid, ntmp->ntm_gid, ntmp->ntm_mode));
! 593:
! 594: /*
! 595: * We read in some system nodes to do not allow
! 596: * reclaim them and to have everytime access to them.
! 597: */
! 598: {
! 599: int pi[3] = { NTFS_MFTINO, NTFS_ROOTINO, NTFS_BITMAPINO };
! 600: for (i=0; i<3; i++) {
! 601: error = VFS_VGET(mp, pi[i], &(ntmp->ntm_sysvn[pi[i]]));
! 602: if(error)
! 603: goto out1;
! 604: ntmp->ntm_sysvn[pi[i]]->v_flag |= VSYSTEM;
! 605: VREF(ntmp->ntm_sysvn[pi[i]]);
! 606: vput(ntmp->ntm_sysvn[pi[i]]);
! 607: }
! 608: }
! 609:
! 610: /* read the Unicode lowercase --> uppercase translation table,
! 611: * if necessary */
! 612: #ifndef __OpenBSD__
! 613: if ((error = ntfs_toupper_use(mp, ntmp)))
! 614: #else
! 615: if ((error = ntfs_toupper_use(mp, ntmp, p)))
! 616: #endif
! 617: goto out1;
! 618:
! 619: /*
! 620: * Scan $BitMap and count free clusters
! 621: */
! 622: error = ntfs_calccfree(ntmp, &ntmp->ntm_cfree);
! 623: if(error)
! 624: goto out1;
! 625:
! 626: /*
! 627: * Read and translate to internal format attribute
! 628: * definition file.
! 629: */
! 630: {
! 631: int num,j;
! 632: struct attrdef ad;
! 633:
! 634: /* Open $AttrDef */
! 635: error = VFS_VGET(mp, NTFS_ATTRDEFINO, &vp );
! 636: if(error)
! 637: goto out1;
! 638:
! 639: /* Count valid entries */
! 640: for(num=0;;num++) {
! 641: error = ntfs_readattr(ntmp, VTONT(vp),
! 642: NTFS_A_DATA, NULL,
! 643: num * sizeof(ad), sizeof(ad),
! 644: &ad, NULL);
! 645: if (error)
! 646: goto out1;
! 647: if (ad.ad_name[0] == 0)
! 648: break;
! 649: }
! 650:
! 651: /* Alloc memory for attribute definitions */
! 652: ntmp->ntm_ad = (struct ntvattrdef *) malloc(
! 653: num * sizeof(struct ntvattrdef),
! 654: M_NTFSMNT, M_WAITOK);
! 655:
! 656: ntmp->ntm_adnum = num;
! 657:
! 658: /* Read them and translate */
! 659: for(i=0;i<num;i++){
! 660: error = ntfs_readattr(ntmp, VTONT(vp),
! 661: NTFS_A_DATA, NULL,
! 662: i * sizeof(ad), sizeof(ad),
! 663: &ad, NULL);
! 664: if (error)
! 665: goto out1;
! 666: j = 0;
! 667: do {
! 668: ntmp->ntm_ad[i].ad_name[j] = ad.ad_name[j];
! 669: } while(ad.ad_name[j++]);
! 670: ntmp->ntm_ad[i].ad_namelen = j - 1;
! 671: ntmp->ntm_ad[i].ad_type = ad.ad_type;
! 672: }
! 673:
! 674: vput(vp);
! 675: }
! 676:
! 677: #if defined(__FreeBSD__)
! 678: mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
! 679: mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
! 680: #else
! 681: mp->mnt_stat.f_fsid.val[0] = dev;
! 682: mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_NTFS);
! 683: #endif
! 684: mp->mnt_maxsymlinklen = 0;
! 685: mp->mnt_flag |= MNT_LOCAL;
! 686: devvp->v_specmountpoint = mp;
! 687: return (0);
! 688:
! 689: out1:
! 690: for (i = 0; i < NTFS_SYSNODESNUM; i++)
! 691: if (ntmp->ntm_sysvn[i])
! 692: vrele(ntmp->ntm_sysvn[i]);
! 693:
! 694: if (vflush(mp,NULLVP,0))
! 695: dprintf(("ntfs_mountfs: vflush failed\n"));
! 696:
! 697: out:
! 698: devvp->v_specmountpoint = NULL;
! 699: if (bp)
! 700: brelse(bp);
! 701:
! 702: if (ntmp != NULL) {
! 703: if (ntmp->ntm_ad != NULL)
! 704: free(ntmp->ntm_ad, M_NTFSMNT);
! 705: free(ntmp, M_NTFSMNT);
! 706: mp->mnt_data = NULL;
! 707: }
! 708:
! 709: /* lock the device vnode before calling VOP_CLOSE() */
! 710: VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 711: (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, NOCRED, p);
! 712: VOP__UNLOCK(devvp, 0, p);
! 713:
! 714: return (error);
! 715: }
! 716:
! 717: static int
! 718: ntfs_start (
! 719: struct mount *mp,
! 720: int flags,
! 721: struct proc *p )
! 722: {
! 723: return (0);
! 724: }
! 725:
! 726: static int
! 727: ntfs_unmount(
! 728: struct mount *mp,
! 729: int mntflags,
! 730: struct proc *p)
! 731: {
! 732: struct ntfsmount *ntmp;
! 733: int error, ronly = 0, flags, i;
! 734:
! 735: dprintf(("ntfs_unmount: unmounting...\n"));
! 736: ntmp = VFSTONTFS(mp);
! 737:
! 738: flags = 0;
! 739: if(mntflags & MNT_FORCE)
! 740: flags |= FORCECLOSE;
! 741:
! 742: dprintf(("ntfs_unmount: vflushing...\n"));
! 743: error = vflush(mp,NULLVP,flags | SKIPSYSTEM);
! 744: if (error) {
! 745: dprintf(("ntfs_unmount: vflush failed: %d\n",error));
! 746: return (error);
! 747: }
! 748:
! 749: /* Check if only system vnodes are rest */
! 750: for(i=0;i<NTFS_SYSNODESNUM;i++)
! 751: if((ntmp->ntm_sysvn[i]) &&
! 752: (ntmp->ntm_sysvn[i]->v_usecount > 1)) return (EBUSY);
! 753:
! 754: /* Dereference all system vnodes */
! 755: for(i=0;i<NTFS_SYSNODESNUM;i++)
! 756: if(ntmp->ntm_sysvn[i]) vrele(ntmp->ntm_sysvn[i]);
! 757:
! 758: /* vflush system vnodes */
! 759: error = vflush(mp,NULLVP,flags);
! 760: if (error) {
! 761: /* XXX should this be panic() ? */
! 762: printf("ntfs_unmount: vflush failed(sysnodes): %d\n",error);
! 763: }
! 764:
! 765: /* Check if the type of device node isn't VBAD before
! 766: * touching v_specinfo. If the device vnode is revoked, the
! 767: * field is NULL and touching it causes null pointer derefercence.
! 768: */
! 769: if (ntmp->ntm_devvp->v_type != VBAD)
! 770: ntmp->ntm_devvp->v_specmountpoint = NULL;
! 771:
! 772: vinvalbuf(ntmp->ntm_devvp, V_SAVE, NOCRED, p, 0, 0);
! 773:
! 774: /* lock the device vnode before calling VOP_CLOSE() */
! 775: #ifndef __OpenBSD__
! 776: VOP_LOCK(ntmp->ntm_devvp, LK_EXCLUSIVE | LK_RETRY);
! 777: #else
! 778: VOP_LOCK(ntmp->ntm_devvp, LK_EXCLUSIVE | LK_RETRY, p);
! 779: #endif
! 780: error = VOP_CLOSE(ntmp->ntm_devvp, ronly ? FREAD : FREAD|FWRITE,
! 781: NOCRED, p);
! 782: VOP__UNLOCK(ntmp->ntm_devvp, 0, p);
! 783:
! 784: vrele(ntmp->ntm_devvp);
! 785:
! 786: /* free the toupper table, if this has been last mounted ntfs volume */
! 787: #ifndef __OpenBSD__
! 788: ntfs_toupper_unuse();
! 789: #else
! 790: ntfs_toupper_unuse(p);
! 791: #endif
! 792:
! 793: dprintf(("ntfs_umount: freeing memory...\n"));
! 794: mp->mnt_data = NULL;
! 795: mp->mnt_flag &= ~MNT_LOCAL;
! 796: free(ntmp->ntm_ad, M_NTFSMNT);
! 797: free(ntmp, M_NTFSMNT);
! 798: return (error);
! 799: }
! 800:
! 801: static int
! 802: ntfs_root(
! 803: struct mount *mp,
! 804: struct vnode **vpp )
! 805: {
! 806: struct vnode *nvp;
! 807: int error = 0;
! 808:
! 809: dprintf(("ntfs_root(): sysvn: %p\n",
! 810: VFSTONTFS(mp)->ntm_sysvn[NTFS_ROOTINO]));
! 811: error = VFS_VGET(mp, (ino_t)NTFS_ROOTINO, &nvp);
! 812: if(error) {
! 813: printf("ntfs_root: VFS_VGET failed: %d\n",error);
! 814: return (error);
! 815: }
! 816:
! 817: *vpp = nvp;
! 818: return (0);
! 819: }
! 820:
! 821: /*
! 822: * Do operations associated with quotas, not supported
! 823: */
! 824: /* ARGSUSED */
! 825: static int
! 826: ntfs_quotactl (
! 827: struct mount *mp,
! 828: int cmds,
! 829: uid_t uid,
! 830: caddr_t arg,
! 831: struct proc *p)
! 832: {
! 833:
! 834: return EOPNOTSUPP;
! 835: }
! 836:
! 837: int
! 838: ntfs_calccfree(
! 839: struct ntfsmount *ntmp,
! 840: cn_t *cfreep)
! 841: {
! 842: struct vnode *vp;
! 843: u_int8_t *tmp;
! 844: int j, error;
! 845: cn_t cfree = 0;
! 846: size_t bmsize, i;
! 847:
! 848: vp = ntmp->ntm_sysvn[NTFS_BITMAPINO];
! 849:
! 850: bmsize = VTOF(vp)->f_size;
! 851:
! 852: tmp = (u_int8_t *) malloc(bmsize, M_TEMP, M_WAITOK);
! 853:
! 854: error = ntfs_readattr(ntmp, VTONT(vp), NTFS_A_DATA, NULL,
! 855: 0, bmsize, tmp, NULL);
! 856: if (error)
! 857: goto out;
! 858:
! 859: for(i=0;i<bmsize;i++)
! 860: for(j=0;j<8;j++)
! 861: if(~tmp[i] & (1 << j)) cfree++;
! 862: *cfreep = cfree;
! 863:
! 864: out:
! 865: free(tmp, M_TEMP);
! 866: return(error);
! 867: }
! 868:
! 869: static int
! 870: ntfs_statfs(
! 871: struct mount *mp,
! 872: struct statfs *sbp,
! 873: struct proc *p)
! 874: {
! 875: struct ntfsmount *ntmp = VFSTONTFS(mp);
! 876: u_int64_t mftallocated;
! 877:
! 878: dprintf(("ntfs_statfs():\n"));
! 879:
! 880: mftallocated = VTOF(ntmp->ntm_sysvn[NTFS_MFTINO])->f_allocated;
! 881:
! 882: #if defined(__FreeBSD__)
! 883: sbp->f_type = mp->mnt_vfc->vfc_typenum;
! 884: #elif defined(__NetBSD__)
! 885: sbp->f_type = 0;
! 886: #elif !defined(__OpenBSD__)
! 887: sbp->f_type = MOUNT_NTFS;
! 888: #endif
! 889: sbp->f_bsize = ntmp->ntm_bps;
! 890: sbp->f_iosize = ntmp->ntm_bps * ntmp->ntm_spc;
! 891: sbp->f_blocks = ntmp->ntm_bootfile.bf_spv;
! 892: sbp->f_bfree = sbp->f_bavail = ntfs_cntobn(ntmp->ntm_cfree);
! 893: sbp->f_ffree = sbp->f_bfree / ntmp->ntm_bpmftrec;
! 894: sbp->f_files = mftallocated / ntfs_bntob(ntmp->ntm_bpmftrec) +
! 895: sbp->f_ffree;
! 896: sbp->f_flags = mp->mnt_flag;
! 897: #if !defined(__OpenBSD__)
! 898: copy_statfs_info(sbp, mp);
! 899: #else
! 900: if (sbp != &mp->mnt_stat) {
! 901: bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
! 902: bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
! 903: bcopy(&mp->mnt_stat.mount_info.msdosfs_args,
! 904: &sbp->mount_info.msdosfs_args, sizeof(struct msdosfs_args));
! 905: }
! 906: strncpy(sbp->f_fstypename, mp->mnt_vfc->vfc_name, MFSNAMELEN);
! 907: #endif
! 908: return (0);
! 909: }
! 910:
! 911: static int
! 912: ntfs_sync (
! 913: struct mount *mp,
! 914: int waitfor,
! 915: struct ucred *cred,
! 916: struct proc *p)
! 917: {
! 918: /*dprintf(("ntfs_sync():\n"));*/
! 919: return (0);
! 920: }
! 921:
! 922: /*ARGSUSED*/
! 923: static int
! 924: ntfs_fhtovp(
! 925: #if defined(__FreeBSD__)
! 926: struct mount *mp,
! 927: struct fid *fhp,
! 928: struct sockaddr *nam,
! 929: struct vnode **vpp,
! 930: int *exflagsp,
! 931: struct ucred **credanonp)
! 932: #elif defined(__NetBSD__) || defined(__OpenBSD__)
! 933: struct mount *mp,
! 934: struct fid *fhp,
! 935: struct vnode **vpp)
! 936: #else
! 937: struct mount *mp,
! 938: struct fid *fhp,
! 939: struct mbuf *nam,
! 940: struct vnode **vpp,
! 941: int *exflagsp,
! 942: struct ucred **credanonp)
! 943: #endif
! 944: {
! 945: struct ntfid *ntfhp = (struct ntfid *)fhp;
! 946: int error;
! 947:
! 948: ddprintf(("ntfs_fhtovp(): %s: %d\n", mp->mnt_stat.f_mntonname,
! 949: ntfhp->ntfid_ino));
! 950:
! 951: error = ntfs_vgetex(mp, ntfhp->ntfid_ino, ntfhp->ntfid_attr, NULL,
! 952: LK_EXCLUSIVE | LK_RETRY, 0, curproc, vpp); /* XXX */
! 953: if (error != 0) {
! 954: *vpp = NULLVP;
! 955: return (error);
! 956: }
! 957:
! 958: /* XXX as unlink/rmdir/mkdir/creat are not currently possible
! 959: * with NTFS, we don't need to check anything else for now */
! 960: return (0);
! 961: }
! 962:
! 963: static int
! 964: ntfs_vptofh(
! 965: struct vnode *vp,
! 966: struct fid *fhp)
! 967: {
! 968: struct ntnode *ntp;
! 969: struct ntfid *ntfhp;
! 970: struct fnode *fn;
! 971:
! 972: ddprintf(("ntfs_fhtovp(): %s: %p\n", vp->v_mount->mnt_stat.f_mntonname,
! 973: vp));
! 974:
! 975: fn = VTOF(vp);
! 976: ntp = VTONT(vp);
! 977: ntfhp = (struct ntfid *)fhp;
! 978: ntfhp->ntfid_len = sizeof(struct ntfid);
! 979: ntfhp->ntfid_ino = ntp->i_number;
! 980: ntfhp->ntfid_attr = fn->f_attrtype;
! 981: #ifdef notyet
! 982: ntfhp->ntfid_gen = ntp->i_gen;
! 983: #endif
! 984: return (0);
! 985: }
! 986:
! 987: int
! 988: ntfs_vgetex(
! 989: struct mount *mp,
! 990: ino_t ino,
! 991: u_int32_t attrtype,
! 992: char *attrname,
! 993: u_long lkflags,
! 994: u_long flags,
! 995: struct proc *p,
! 996: struct vnode **vpp)
! 997: {
! 998: int error;
! 999: struct ntfsmount *ntmp;
! 1000: struct ntnode *ip;
! 1001: struct fnode *fp;
! 1002: struct vnode *vp;
! 1003: enum vtype f_type;
! 1004:
! 1005: dprintf(("ntfs_vgetex: ino: %d, attr: 0x%x:%s, lkf: 0x%lx, f: 0x%lx\n",
! 1006: ino, attrtype, attrname?attrname:"", (u_long)lkflags,
! 1007: (u_long)flags ));
! 1008:
! 1009: ntmp = VFSTONTFS(mp);
! 1010: *vpp = NULL;
! 1011:
! 1012: /* Get ntnode */
! 1013: #ifndef __OpenBSD__
! 1014: error = ntfs_ntlookup(ntmp, ino, &ip);
! 1015: #else
! 1016: error = ntfs_ntlookup(ntmp, ino, &ip, p);
! 1017: #endif
! 1018: if (error) {
! 1019: printf("ntfs_vget: ntfs_ntget failed\n");
! 1020: return (error);
! 1021: }
! 1022:
! 1023: /* It may be not initialized fully, so force load it */
! 1024: if (!(flags & VG_DONTLOADIN) && !(ip->i_flag & IN_LOADED)) {
! 1025: error = ntfs_loadntnode(ntmp, ip);
! 1026: if(error) {
! 1027: printf("ntfs_vget: CAN'T LOAD ATTRIBUTES FOR INO: %d\n",
! 1028: ip->i_number);
! 1029: #ifndef __OpenBSD__
! 1030: ntfs_ntput(ip);
! 1031: #else
! 1032: ntfs_ntput(ip, p);
! 1033: #endif
! 1034: return (error);
! 1035: }
! 1036: }
! 1037:
! 1038: error = ntfs_fget(ntmp, ip, attrtype, attrname, &fp);
! 1039: if (error) {
! 1040: printf("ntfs_vget: ntfs_fget failed\n");
! 1041: #ifndef __OpenBSD__
! 1042: ntfs_ntput(ip);
! 1043: #else
! 1044: ntfs_ntput(ip, p);
! 1045: #endif
! 1046: return (error);
! 1047: }
! 1048:
! 1049: if (!(flags & VG_DONTVALIDFN) && !(fp->f_flag & FN_VALID)) {
! 1050: if ((ip->i_frflag & NTFS_FRFLAG_DIR) &&
! 1051: (fp->f_attrtype == NTFS_A_DATA && fp->f_attrname == NULL)) {
! 1052: f_type = VDIR;
! 1053: } else if (flags & VG_EXT) {
! 1054: f_type = VNON;
! 1055: fp->f_size = fp->f_allocated = 0;
! 1056: } else {
! 1057: f_type = VREG;
! 1058:
! 1059: error = ntfs_filesize(ntmp, fp,
! 1060: &fp->f_size, &fp->f_allocated);
! 1061: if (error) {
! 1062: #ifndef __OpenBSD__
! 1063: ntfs_ntput(ip);
! 1064: #else
! 1065: ntfs_ntput(ip, p);
! 1066: #endif
! 1067: return (error);
! 1068: }
! 1069: }
! 1070:
! 1071: fp->f_flag |= FN_VALID;
! 1072: }
! 1073:
! 1074: /*
! 1075: * We may be calling vget() now. To avoid potential deadlock, we need
! 1076: * to release ntnode lock, since due to locking order vnode
! 1077: * lock has to be acquired first.
! 1078: * ntfs_fget() bumped ntnode usecount, so ntnode won't be recycled
! 1079: * prematurely.
! 1080: */
! 1081: #ifndef __OpenBSD__
! 1082: ntfs_ntput(ip);
! 1083: #else
! 1084: ntfs_ntput(ip, p);
! 1085: #endif
! 1086:
! 1087: if (FTOV(fp)) {
! 1088: /* vget() returns error if the vnode has been recycled */
! 1089: if (VGET(FTOV(fp), lkflags, p) == 0) {
! 1090: *vpp = FTOV(fp);
! 1091: return (0);
! 1092: }
! 1093: }
! 1094:
! 1095: error = getnewvnode(VT_NTFS, ntmp->ntm_mountp, ntfs_vnodeop_p, &vp);
! 1096: if(error) {
! 1097: ntfs_frele(fp);
! 1098: #ifndef __OpenBSD__
! 1099: ntfs_ntput(ip);
! 1100: #else
! 1101: ntfs_ntput(ip, p);
! 1102: #endif
! 1103: return (error);
! 1104: }
! 1105: dprintf(("ntfs_vget: vnode: %p for ntnode: %d\n", vp,ino));
! 1106:
! 1107: #ifdef __FreeBSD__
! 1108: lockinit(&fp->f_lock, PINOD, "fnode", 0, 0);
! 1109: #endif
! 1110: fp->f_vp = vp;
! 1111: vp->v_data = fp;
! 1112: vp->v_type = f_type;
! 1113:
! 1114: if (ino == NTFS_ROOTINO)
! 1115: vp->v_flag |= VROOT;
! 1116:
! 1117: if (lkflags & LK_TYPE_MASK) {
! 1118: error = VN_LOCK(vp, lkflags, p);
! 1119: if (error) {
! 1120: vput(vp);
! 1121: return (error);
! 1122: }
! 1123: }
! 1124:
! 1125: #if defined(__FreeBSD__) || defined(__NetBSD__)
! 1126: genfs_node_init(vp, &ntfs_genfsops);
! 1127: #endif
! 1128: *vpp = vp;
! 1129: return (0);
! 1130: }
! 1131:
! 1132: static int
! 1133: ntfs_vget(
! 1134: struct mount *mp,
! 1135: ino_t ino,
! 1136: struct vnode **vpp)
! 1137: {
! 1138: return ntfs_vgetex(mp, ino, NTFS_A_DATA, NULL,
! 1139: LK_EXCLUSIVE | LK_RETRY, 0, curproc, vpp); /* XXX */
! 1140: }
! 1141:
! 1142: #if defined(__FreeBSD__)
! 1143: static struct vfsops ntfs_vfsops = {
! 1144: ntfs_mount,
! 1145: ntfs_start,
! 1146: ntfs_unmount,
! 1147: ntfs_root,
! 1148: ntfs_quotactl,
! 1149: ntfs_statfs,
! 1150: ntfs_sync,
! 1151: ntfs_vget,
! 1152: ntfs_fhtovp,
! 1153: ntfs_vptofh,
! 1154: ntfs_init,
! 1155: NULL
! 1156: };
! 1157: VFS_SET(ntfs_vfsops, ntfs, 0);
! 1158: #elif defined(__NetBSD__)
! 1159: extern const struct vnodeopv_desc ntfs_vnodeop_opv_desc;
! 1160:
! 1161: const struct vnodeopv_desc * const ntfs_vnodeopv_descs[] = {
! 1162: &ntfs_vnodeop_opv_desc,
! 1163: NULL,
! 1164: };
! 1165:
! 1166: struct vfsops ntfs_vfsops = {
! 1167: MOUNT_NTFS,
! 1168: ntfs_mount,
! 1169: ntfs_start,
! 1170: ntfs_unmount,
! 1171: ntfs_root,
! 1172: ntfs_quotactl,
! 1173: ntfs_statfs,
! 1174: ntfs_sync,
! 1175: ntfs_vget,
! 1176: ntfs_fhtovp,
! 1177: ntfs_vptofh,
! 1178: ntfs_init,
! 1179: ntfs_reinit,
! 1180: ntfs_done,
! 1181: ntfs_sysctl,
! 1182: ntfs_mountroot,
! 1183: ntfs_checkexp,
! 1184: ntfs_vnodeopv_descs,
! 1185: };
! 1186: #elif defined(__OpenBSD__)
! 1187: extern const struct vnodeopv_desc ntfs_vnodeop_opv_desc;
! 1188:
! 1189: const struct vnodeopv_desc * const ntfs_vnodeopv_descs[] = {
! 1190: &ntfs_vnodeop_opv_desc,
! 1191: NULL,
! 1192: };
! 1193:
! 1194: const struct vfsops ntfs_vfsops = {
! 1195: ntfs_mount,
! 1196: ntfs_start,
! 1197: ntfs_unmount,
! 1198: ntfs_root,
! 1199: ntfs_quotactl,
! 1200: ntfs_statfs,
! 1201: ntfs_sync,
! 1202: ntfs_vget,
! 1203: ntfs_fhtovp,
! 1204: ntfs_vptofh,
! 1205: ntfs_init,
! 1206: ntfs_sysctl,
! 1207: ntfs_checkexp,
! 1208: };
! 1209:
! 1210: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ntfs_vfsops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ntfs