Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / vfs / ntfs / ntfs_vfsops.c
CommitLineData
984263bc
MD
1/* $NetBSD: ntfs_vfsops.c,v 1.23 1999/11/15 19:38:14 jdolecek Exp $ */
2
3/*-
4 * Copyright (c) 1998, 1999 Semen Ustimenko
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sys/ntfs/ntfs_vfsops.c,v 1.20.2.5 2001/12/25 01:44:45 dillon Exp $
b13267a5 29 * $DragonFly: src/sys/vfs/ntfs/ntfs_vfsops.c,v 1.42 2006/09/10 01:26:41 dillon Exp $
984263bc
MD
30 */
31
32
33#include <sys/param.h>
34#include <sys/systm.h>
984263bc
MD
35#include <sys/conf.h>
36#include <sys/proc.h>
fad57d0e 37#include <sys/nlookup.h>
984263bc
MD
38#include <sys/kernel.h>
39#include <sys/vnode.h>
40#include <sys/mount.h>
41#include <sys/buf.h>
42#include <sys/fcntl.h>
43#include <sys/malloc.h>
44#include <sys/systm.h>
45#if defined(__NetBSD__)
46#include <sys/device.h>
47#endif
48
f91a71dd
JS
49#include <machine/inttypes.h>
50
984263bc
MD
51#include <vm/vm.h>
52#include <vm/vm_param.h>
53#if defined(__NetBSD__)
54#include <vm/vm_prot.h>
55#endif
56#include <vm/vm_page.h>
57#include <vm/vm_object.h>
58#include <vm/vm_extern.h>
59#include <vm/vm_zone.h>
60
61#if defined(__NetBSD__)
62#include <miscfs/specfs/specdev.h>
63#endif
64
65/*#define NTFS_DEBUG 1*/
1f2de5d4
MD
66#include "ntfs.h"
67#include "ntfs_inode.h"
68#include "ntfs_subr.h"
69#include "ntfs_vfsops.h"
70#include "ntfs_ihash.h"
71#include "ntfsmount.h"
984263bc 72
66a1ddf5 73extern struct vop_ops ntfs_vnode_vops;
0961aa92 74
08c23b99 75#if defined(__DragonFly__)
984263bc
MD
76MALLOC_DEFINE(M_NTFSMNT, "NTFS mount", "NTFS mount structure");
77MALLOC_DEFINE(M_NTFSNTNODE,"NTFS ntnode", "NTFS ntnode information");
78MALLOC_DEFINE(M_NTFSFNODE,"NTFS fnode", "NTFS fnode information");
79MALLOC_DEFINE(M_NTFSDIR,"NTFS dir", "NTFS dir buffer");
80#endif
81
a6ee311a 82static int ntfs_root (struct mount *, struct vnode **);
acde96db
MD
83static int ntfs_statfs (struct mount *, struct statfs *, struct ucred *cred);
84static int ntfs_unmount (struct mount *, int);
85static int ntfs_vget (struct mount *mp, ino_t ino, struct vnode **vpp);
a6ee311a 86static int ntfs_mountfs (struct vnode *, struct mount *,
acde96db 87 struct ntfs_args *, struct ucred *);
a6ee311a
RG
88static int ntfs_vptofh (struct vnode *, struct fid *);
89static int ntfs_fhtovp (struct mount *, struct fid *,
90 struct vnode **);
984263bc 91
08c23b99 92#if !defined (__DragonFly__)
a6ee311a
RG
93static int ntfs_quotactl (struct mount *, int, uid_t, caddr_t,
94 struct thread *);
95static int ntfs_start (struct mount *, int, struct thread *);
96static int ntfs_sync (struct mount *, int, struct ucred *,
97 struct thread *);
984263bc
MD
98#endif
99
08c23b99 100#if defined(__DragonFly__)
984263bc 101struct sockaddr;
acde96db 102static int ntfs_mount (struct mount *, char *, caddr_t, struct ucred *);
a6ee311a
RG
103static int ntfs_init (struct vfsconf *);
104static int ntfs_checkexp (struct mount *, struct sockaddr *,
105 int *, struct ucred **);
984263bc 106#elif defined(__NetBSD__)
a6ee311a
RG
107static int ntfs_mount (struct mount *, const char *, void *,
108 struct nameidata *, struct thread *);
109static void ntfs_init (void);
110static int ntfs_mountroot (void);
111static int ntfs_sysctl (int *, u_int, void *, size_t *, void *,
112 size_t, struct thread *);
113static int ntfs_checkexp (struct mount *, struct mbuf *,
114 int *, struct ucred **);
984263bc
MD
115#endif
116
117/*
118 * Verify a remote client has export rights and return these rights via.
119 * exflagsp and credanonp.
120 */
121static int
cd0a65a2 122ntfs_checkexp(struct mount *mp,
08c23b99 123#if defined(__DragonFly__)
cd0a65a2 124 struct sockaddr *nam,
984263bc 125#else /* defined(__NetBSD__) */
cd0a65a2 126 struct mbuf *nam,
984263bc 127#endif
cd0a65a2 128 int *exflagsp, struct ucred **credanonp)
984263bc 129{
34ee9825
RG
130 struct netcred *np;
131 struct ntfsmount *ntm = VFSTONTFS(mp);
984263bc
MD
132
133 /*
134 * Get the export permission structure for this <mp, client> tuple.
135 */
136 np = vfs_export_lookup(mp, &ntm->ntm_export, nam);
137 if (np == NULL)
138 return (EACCES);
139
140 *exflagsp = np->netc_exflags;
141 *credanonp = &np->netc_anon;
142 return (0);
143}
144
145#if defined(__NetBSD__)
146/*ARGSUSED*/
147static int
cd0a65a2
CP
148ntfs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
149 size_t newlen, struct thread *td)
984263bc
MD
150{
151 return (EINVAL);
152}
153
154static int
cd0a65a2 155ntfs_mountroot(void)
984263bc
MD
156{
157 struct mount *mp;
21739618 158 struct vnode *rootvp;
dadab5e9 159 struct thread *td = curthread; /* XXX */
984263bc 160 struct ntfs_args args;
41a01a4d
MD
161 lwkt_tokref ilock;
162 int error;
984263bc
MD
163
164 if (root_device->dv_class != DV_DISK)
165 return (ENODEV);
166
167 /*
168 * Get vnodes for rootdev.
169 */
170 if (bdevvp(rootdev, &rootvp))
171 panic("ntfs_mountroot: can't setup rootvp");
172
173 if ((error = vfs_rootmountalloc(MOUNT_NTFS, "root_device", &mp))) {
174 vrele(rootvp);
175 return (error);
176 }
177
178 args.flag = 0;
179 args.uid = 0;
180 args.gid = 0;
181 args.mode = 0777;
182
acde96db 183 if ((error = ntfs_mountfs(rootvp, mp, &args, proc0.p_ucred)) != 0) {
984263bc
MD
184 mp->mnt_op->vfs_refcount--;
185 vfs_unbusy(mp);
efda3bd0 186 kfree(mp, M_MOUNT);
984263bc
MD
187 vrele(rootvp);
188 return (error);
189 }
861905fb 190 mountlist_insert(mp, MNTINS_LAST);
acde96db 191 (void)ntfs_statfs(mp, &mp->mnt_stat, proc0.p_ucred);
984263bc
MD
192 vfs_unbusy(mp);
193 return (0);
194}
195
196static void
cd0a65a2 197ntfs_init(void)
984263bc
MD
198{
199 ntfs_nthashinit();
200 ntfs_toupper_init();
201}
202
08c23b99 203#elif defined(__DragonFly__)
984263bc
MD
204
205static int
cd0a65a2 206ntfs_init(struct vfsconf *vcp)
984263bc
MD
207{
208 ntfs_nthashinit();
209 ntfs_toupper_init();
210 return 0;
211}
212
213#endif /* NetBSD */
214
215static int
acde96db 216ntfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
cd0a65a2 217{
984263bc 218 size_t size;
fad57d0e 219 int error;
984263bc
MD
220 struct vnode *devvp;
221 struct ntfs_args args;
fad57d0e 222 struct nlookupdata nd;
21739618 223 struct vnode *rootvp;
984263bc 224
fad57d0e 225 error = 0;
08c23b99 226#ifdef __DragonFly__
984263bc
MD
227 /*
228 * Use NULL path to flag a root mount
229 */
230 if( path == NULL) {
231 /*
232 ***
233 * Mounting root file system
234 ***
235 */
236
237 /* Get vnode for root device*/
238 if( bdevvp( rootdev, &rootvp))
239 panic("ffs_mountroot: can't setup bdevvp for root");
240
241 /*
242 * FS specific handling
243 */
244 mp->mnt_flag |= MNT_RDONLY; /* XXX globally applicable?*/
245
246 /*
247 * Attempt mount
248 */
acde96db 249 if( ( error = ntfs_mountfs(rootvp, mp, &args, cred)) != 0) {
984263bc
MD
250 /* fs specific cleanup (if any)*/
251 goto error_1;
252 }
253
254 goto dostatfs; /* success*/
255
256 }
257#endif /* FreeBSD */
258
259 /*
260 ***
261 * Mounting non-root file system or updating a file system
262 ***
263 */
264
265 /* copy in user arguments*/
fad57d0e
MD
266 error = copyin(data, (caddr_t)&args, sizeof (struct ntfs_args));
267 if (error)
984263bc
MD
268 goto error_1; /* can't get arguments*/
269
270 /*
271 * If updating, check whether changing from read-only to
272 * read/write; if there is no device name, that's all we do.
273 */
274 if (mp->mnt_flag & MNT_UPDATE) {
275 /* if not updating name...*/
276 if (args.fspec == 0) {
277 /*
278 * Process export requests. Jumping to "success"
279 * will return the vfs_export() error code.
280 */
281 struct ntfsmount *ntm = VFSTONTFS(mp);
fad57d0e 282 error = vfs_export(mp, &ntm->ntm_export, &args.export);
984263bc
MD
283 goto success;
284 }
285
286 printf("ntfs_mount(): MNT_UPDATE not supported\n");
fad57d0e 287 error = EINVAL;
984263bc
MD
288 goto error_1;
289 }
290
291 /*
292 * Not an update, or updating the name: look up the name
293 * and verify that it refers to a sensible block device.
294 */
fad57d0e
MD
295 devvp = NULL;
296 error = nlookup_init(&nd, args.fspec, UIO_USERSPACE, NLC_FOLLOW);
297 if (error == 0)
298 error = nlookup(&nd);
299 if (error == 0)
300 error = cache_vref(nd.nl_ncp, nd.nl_cred, &devvp);
301 nlookup_done(&nd);
302 if (error)
984263bc 303 goto error_1;
984263bc 304
08c23b99 305#if defined(__DragonFly__)
fad57d0e 306 if (!vn_isdisk(devvp, &error))
984263bc
MD
307 goto error_2;
308#else
309 if (devvp->v_type != VBLK) {
fad57d0e 310 error = ENOTBLK;
984263bc
MD
311 goto error_2;
312 }
e4c9c0c8 313 if (umajor(devvp->v_udev) >= nblkdev) {
fad57d0e 314 error = ENXIO;
984263bc
MD
315 goto error_2;
316 }
317#endif
318 if (mp->mnt_flag & MNT_UPDATE) {
319#if 0
320 /*
321 ********************
322 * UPDATE
323 ********************
324 */
325
326 if (devvp != ntmp->um_devvp)
fad57d0e 327 error = EINVAL; /* needs translation */
984263bc
MD
328 else
329 vrele(devvp);
330 /*
331 * Update device name only on success
332 */
fad57d0e 333 if( !error) {
984263bc
MD
334 /* Save "mounted from" info for mount point (NULL pad)*/
335 copyinstr( args.fspec,
336 mp->mnt_stat.f_mntfromname,
337 MNAMELEN - 1,
338 &size);
339 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
340 }
341#endif
342 } else {
343 /*
344 ********************
345 * NEW MOUNT
346 ********************
347 */
348
984263bc
MD
349 /* Save "mounted from" info for mount point (NULL pad)*/
350 copyinstr( args.fspec, /* device name*/
351 mp->mnt_stat.f_mntfromname, /* save area*/
352 MNAMELEN - 1, /* max size*/
353 &size); /* real size*/
354 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
355
acde96db 356 error = ntfs_mountfs(devvp, mp, &args, cred);
984263bc 357 }
fad57d0e 358 if (error) {
984263bc
MD
359 goto error_2;
360 }
361
08c23b99 362#ifdef __DragonFly__
984263bc
MD
363dostatfs:
364#endif
365 /*
75ffff0d
JS
366 * Initialize FS stat information in mount struct; uses
367 * mp->mnt_stat.f_mntfromname.
984263bc
MD
368 *
369 * This code is common to root and non-root mounts
370 */
acde96db 371 (void)VFS_STATFS(mp, &mp->mnt_stat, cred);
984263bc
MD
372
373 goto success;
374
375
376error_2: /* error with devvp held*/
377
378 /* release devvp before failing*/
379 vrele(devvp);
380
381error_1: /* no state to back out*/
382
383success:
fad57d0e 384 return(error);
984263bc
MD
385}
386
387/*
388 * Common code for mount and mountroot
389 */
390int
cd0a65a2 391ntfs_mountfs(struct vnode *devvp, struct mount *mp, struct ntfs_args *argsp,
acde96db 392 struct ucred *cred)
984263bc
MD
393{
394 struct buf *bp;
395 struct ntfsmount *ntmp;
b13267a5 396 cdev_t dev;
984263bc
MD
397 int error, ronly, ncount, i;
398 struct vnode *vp;
399
400 /*
401 * Disallow multiple mounts of the same device.
402 * Disallow mounting of a device that is currently in use
403 * (except for root, which might share swap device for miniroot).
404 * Flush out any old buffers remaining from a previous use.
405 */
406 error = vfs_mountedon(devvp);
407 if (error)
408 return (error);
715f92b6 409 ncount = count_udev(devvp->v_udev);
08c23b99 410#if defined(__DragonFly__)
984263bc
MD
411 if (devvp->v_object)
412 ncount -= 1;
413#endif
21739618 414 if (ncount > 1)
984263bc 415 return (EBUSY);
08c23b99 416#if defined(__DragonFly__)
acde96db 417 VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY);
87de5057 418 error = vinvalbuf(devvp, V_SAVE, 0, 0);
acde96db 419 VOP__UNLOCK(devvp, 0);
984263bc 420#else
87de5057 421 error = vinvalbuf(devvp, V_SAVE, 0, 0);
984263bc
MD
422#endif
423 if (error)
424 return (error);
425
426 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
acde96db 427 VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY);
87de5057 428 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, NULL);
acde96db 429 VOP__UNLOCK(devvp, 0);
984263bc
MD
430 if (error)
431 return (error);
e4c9c0c8 432 dev = devvp->v_rdev;
984263bc
MD
433
434 bp = NULL;
435
54078292 436 error = bread(devvp, ntfs_bntodoff(BBLOCK), BBSIZE, &bp);
984263bc
MD
437 if (error)
438 goto out;
efda3bd0 439 ntmp = kmalloc( sizeof *ntmp, M_NTFSMNT, M_WAITOK );
984263bc
MD
440 bzero( ntmp, sizeof *ntmp );
441 bcopy( bp->b_data, &ntmp->ntm_bootfile, sizeof(struct bootfile) );
442 brelse( bp );
443 bp = NULL;
444
445 if (strncmp(ntmp->ntm_bootfile.bf_sysid, NTFS_BBID, NTFS_BBIDLEN)) {
446 error = EINVAL;
447 dprintf(("ntfs_mountfs: invalid boot block\n"));
448 goto out;
449 }
450
451 {
452 int8_t cpr = ntmp->ntm_mftrecsz;
453 if( cpr > 0 )
454 ntmp->ntm_bpmftrec = ntmp->ntm_spc * cpr;
455 else
456 ntmp->ntm_bpmftrec = (1 << (-cpr)) / ntmp->ntm_bps;
457 }
458 dprintf(("ntfs_mountfs(): bps: %d, spc: %d, media: %x, mftrecsz: %d (%d sects)\n",
459 ntmp->ntm_bps,ntmp->ntm_spc,ntmp->ntm_bootfile.bf_media,
460 ntmp->ntm_mftrecsz,ntmp->ntm_bpmftrec));
461 dprintf(("ntfs_mountfs(): mftcn: 0x%x|0x%x\n",
462 (u_int32_t)ntmp->ntm_mftcn,(u_int32_t)ntmp->ntm_mftmirrcn));
463
464 ntmp->ntm_mountp = mp;
465 ntmp->ntm_dev = dev;
466 ntmp->ntm_devvp = devvp;
467 ntmp->ntm_uid = argsp->uid;
468 ntmp->ntm_gid = argsp->gid;
469 ntmp->ntm_mode = argsp->mode;
470 ntmp->ntm_flag = argsp->flag;
471
472 /* Copy in the 8-bit to Unicode conversion table */
473 if (argsp->flag & NTFSMNT_U2WTABLE) {
474 ntfs_82u_init(ntmp, argsp->u2w);
475 } else {
476 ntfs_82u_init(ntmp, NULL);
477 }
478
479 /* Initialize Unicode to 8-bit table from 8toU table */
480 ntfs_u28_init(ntmp, ntmp->ntm_82u);
481
482 mp->mnt_data = (qaddr_t)ntmp;
483
484 dprintf(("ntfs_mountfs(): case-%s,%s uid: %d, gid: %d, mode: %o\n",
485 (ntmp->ntm_flag & NTFS_MFLAG_CASEINS)?"insens.":"sens.",
486 (ntmp->ntm_flag & NTFS_MFLAG_ALLNAMES)?" allnames,":"",
487 ntmp->ntm_uid, ntmp->ntm_gid, ntmp->ntm_mode));
488
66a1ddf5 489 vfs_add_vnodeops(mp, &ntfs_vnode_vops, &mp->mnt_vn_norm_ops);
320bc044 490
984263bc
MD
491 /*
492 * We read in some system nodes to do not allow
493 * reclaim them and to have everytime access to them.
494 */
495 {
496 int pi[3] = { NTFS_MFTINO, NTFS_ROOTINO, NTFS_BITMAPINO };
497 for (i=0; i<3; i++) {
498 error = VFS_VGET(mp, pi[i], &(ntmp->ntm_sysvn[pi[i]]));
499 if(error)
500 goto out1;
501 ntmp->ntm_sysvn[pi[i]]->v_flag |= VSYSTEM;
597aea93 502 vref(ntmp->ntm_sysvn[pi[i]]);
984263bc
MD
503 vput(ntmp->ntm_sysvn[pi[i]]);
504 }
505 }
506
507 /* read the Unicode lowercase --> uppercase translation table,
508 * if necessary */
509 if ((error = ntfs_toupper_use(mp, ntmp)))
510 goto out1;
511
512 /*
513 * Scan $BitMap and count free clusters
514 */
515 error = ntfs_calccfree(ntmp, &ntmp->ntm_cfree);
516 if(error)
517 goto out1;
518
519 /*
520 * Read and translate to internal format attribute
521 * definition file.
522 */
523 {
524 int num,j;
525 struct attrdef ad;
526
527 /* Open $AttrDef */
acde96db 528 error = VFS_VGET(mp, NTFS_ATTRDEFINO, &vp);
984263bc
MD
529 if(error)
530 goto out1;
531
532 /* Count valid entries */
533 for(num=0;;num++) {
534 error = ntfs_readattr(ntmp, VTONT(vp),
535 NTFS_A_DATA, NULL,
536 num * sizeof(ad), sizeof(ad),
537 &ad, NULL);
538 if (error)
539 goto out1;
540 if (ad.ad_name[0] == 0)
541 break;
542 }
543
544 /* Alloc memory for attribute definitions */
545 MALLOC(ntmp->ntm_ad, struct ntvattrdef *,
546 num * sizeof(struct ntvattrdef),
547 M_NTFSMNT, M_WAITOK);
548
549 ntmp->ntm_adnum = num;
550
551 /* Read them and translate */
552 for(i=0;i<num;i++){
553 error = ntfs_readattr(ntmp, VTONT(vp),
554 NTFS_A_DATA, NULL,
555 i * sizeof(ad), sizeof(ad),
556 &ad, NULL);
557 if (error)
558 goto out1;
559 j = 0;
560 do {
561 ntmp->ntm_ad[i].ad_name[j] = ad.ad_name[j];
562 } while(ad.ad_name[j++]);
563 ntmp->ntm_ad[i].ad_namelen = j - 1;
564 ntmp->ntm_ad[i].ad_type = ad.ad_type;
565 }
566
567 vput(vp);
568 }
569
08c23b99 570#if defined(__DragonFly__)
984263bc
MD
571 mp->mnt_stat.f_fsid.val[0] = dev2udev(dev);
572 mp->mnt_stat.f_fsid.val[1] = mp->mnt_vfc->vfc_typenum;
573#else
574 mp->mnt_stat.f_fsid.val[0] = dev;
575 mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_NTFS);
576#endif
577 mp->mnt_maxsymlinklen = 0;
578 mp->mnt_flag |= MNT_LOCAL;
e4c9c0c8 579 dev->si_mountpoint = mp;
0961aa92 580
984263bc
MD
581 return (0);
582
583out1:
584 for(i=0;i<NTFS_SYSNODESNUM;i++)
585 if(ntmp->ntm_sysvn[i]) vrele(ntmp->ntm_sysvn[i]);
586
587 if (vflush(mp, 0, 0))
588 dprintf(("ntfs_mountfs: vflush failed\n"));
589
590out:
e4c9c0c8 591 dev->si_mountpoint = NULL;
984263bc
MD
592 if (bp)
593 brelse(bp);
594
595#if defined __NetBSD__
596 /* lock the device vnode before calling VOP_CLOSE() */
acde96db 597 VN_LOCK(devvp, LK_EXCLUSIVE | LK_RETRY);
87de5057 598 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE);
acde96db 599 VOP__UNLOCK(devvp, 0);
984263bc 600#else
87de5057 601 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE);
984263bc
MD
602#endif
603
604 return (error);
605}
606
08c23b99 607#if !defined(__DragonFly__)
984263bc 608static int
cd0a65a2 609ntfs_start(struct mount *mp, int flags, struct thread *td)
984263bc
MD
610{
611 return (0);
612}
613#endif
614
615static int
acde96db 616ntfs_unmount(struct mount *mp, int mntflags)
984263bc 617{
34ee9825 618 struct ntfsmount *ntmp;
fb8c9c01 619 int error, ronly, flags, i;
984263bc
MD
620
621 dprintf(("ntfs_unmount: unmounting...\n"));
622 ntmp = VFSTONTFS(mp);
623
fb8c9c01 624 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
984263bc
MD
625 flags = 0;
626 if(mntflags & MNT_FORCE)
627 flags |= FORCECLOSE;
628
629 dprintf(("ntfs_unmount: vflushing...\n"));
630 error = vflush(mp, 0, flags | SKIPSYSTEM);
631 if (error) {
632 printf("ntfs_unmount: vflush failed: %d\n",error);
633 return (error);
634 }
635
636 /* Check if only system vnodes are rest */
637 for(i=0;i<NTFS_SYSNODESNUM;i++)
638 if((ntmp->ntm_sysvn[i]) &&
639 (ntmp->ntm_sysvn[i]->v_usecount > 1)) return (EBUSY);
640
641 /* Dereference all system vnodes */
642 for(i=0;i<NTFS_SYSNODESNUM;i++)
643 if(ntmp->ntm_sysvn[i]) vrele(ntmp->ntm_sysvn[i]);
644
645 /* vflush system vnodes */
646 error = vflush(mp, 0, flags);
647 if (error)
648 printf("ntfs_unmount: vflush failed(sysnodes): %d\n",error);
649
650 /* Check if the type of device node isn't VBAD before
0de08e6d 651 * touching v_cdevinfo. If the device vnode is revoked, the
984263bc
MD
652 * field is NULL and touching it causes null pointer derefercence.
653 */
654 if (ntmp->ntm_devvp->v_type != VBAD)
e4c9c0c8 655 ntmp->ntm_devvp->v_rdev->si_mountpoint = NULL;
984263bc 656
87de5057 657 vinvalbuf(ntmp->ntm_devvp, V_SAVE, 0, 0);
984263bc 658
87de5057 659 error = VOP_CLOSE(ntmp->ntm_devvp, ronly ? FREAD : FREAD|FWRITE);
984263bc
MD
660
661 vrele(ntmp->ntm_devvp);
662
663 /* free the toupper table, if this has been last mounted ntfs volume */
664 ntfs_toupper_unuse();
665
666 dprintf(("ntfs_umount: freeing memory...\n"));
667 ntfs_u28_uninit(ntmp);
668 ntfs_82u_uninit(ntmp);
669 mp->mnt_data = (qaddr_t)0;
670 mp->mnt_flag &= ~MNT_LOCAL;
671 FREE(ntmp->ntm_ad, M_NTFSMNT);
672 FREE(ntmp, M_NTFSMNT);
673 return (error);
674}
675
676static int
cd0a65a2 677ntfs_root(struct mount *mp, struct vnode **vpp)
984263bc
MD
678{
679 struct vnode *nvp;
680 int error = 0;
681
682 dprintf(("ntfs_root(): sysvn: %p\n",
683 VFSTONTFS(mp)->ntm_sysvn[NTFS_ROOTINO]));
684 error = VFS_VGET(mp, (ino_t)NTFS_ROOTINO, &nvp);
685 if(error) {
686 printf("ntfs_root: VFS_VGET failed: %d\n",error);
687 return (error);
688 }
689
690 *vpp = nvp;
691 return (0);
692}
693
08c23b99 694#if !defined(__DragonFly__)
984263bc 695static int
cd0a65a2
CP
696ntfs_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t arg,
697 struct thread *td)
984263bc
MD
698{
699 printf("\nntfs_quotactl():\n");
700 return EOPNOTSUPP;
701}
702#endif
703
704int
cd0a65a2 705ntfs_calccfree(struct ntfsmount *ntmp, cn_t *cfreep)
984263bc
MD
706{
707 struct vnode *vp;
708 u_int8_t *tmp;
709 int j, error;
710 long cfree = 0;
711 size_t bmsize, i;
712
713 vp = ntmp->ntm_sysvn[NTFS_BITMAPINO];
714
715 bmsize = VTOF(vp)->f_size;
716
717 MALLOC(tmp, u_int8_t *, bmsize, M_TEMP, M_WAITOK);
718
719 error = ntfs_readattr(ntmp, VTONT(vp), NTFS_A_DATA, NULL,
720 0, bmsize, tmp, NULL);
721 if (error)
722 goto out;
723
724 for(i=0;i<bmsize;i++)
725 for(j=0;j<8;j++)
726 if(~tmp[i] & (1 << j)) cfree++;
727 *cfreep = cfree;
728
729 out:
730 FREE(tmp, M_TEMP);
731 return(error);
732}
733
734static int
acde96db 735ntfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
984263bc
MD
736{
737 struct ntfsmount *ntmp = VFSTONTFS(mp);
738 u_int64_t mftsize,mftallocated;
739
740 dprintf(("ntfs_statfs():\n"));
741
742 mftsize = VTOF(ntmp->ntm_sysvn[NTFS_MFTINO])->f_size;
743 mftallocated = VTOF(ntmp->ntm_sysvn[NTFS_MFTINO])->f_allocated;
744
08c23b99 745#if defined(__DragonFly__)
984263bc
MD
746 sbp->f_type = mp->mnt_vfc->vfc_typenum;
747#elif defined(__NetBSD__)
748 sbp->f_type = 0;
749#else
750 sbp->f_type = MOUNT_NTFS;
751#endif
752 sbp->f_bsize = ntmp->ntm_bps;
753 sbp->f_iosize = ntmp->ntm_bps * ntmp->ntm_spc;
754 sbp->f_blocks = ntmp->ntm_bootfile.bf_spv;
755 sbp->f_bfree = sbp->f_bavail = ntfs_cntobn(ntmp->ntm_cfree);
756 sbp->f_ffree = sbp->f_bfree / ntmp->ntm_bpmftrec;
757 sbp->f_files = mftallocated / ntfs_bntob(ntmp->ntm_bpmftrec) +
758 sbp->f_ffree;
759 if (sbp != &mp->mnt_stat) {
984263bc
MD
760 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
761 (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
762 }
763 sbp->f_flags = mp->mnt_flag;
764#ifdef __NetBSD__
765 strncpy(sbp->f_fstypename, mp->mnt_op->vfs_name, MFSNAMELEN);
766#endif
767
768 return (0);
769}
770
08c23b99 771#if !defined(__DragonFly__)
984263bc 772static int
cd0a65a2 773ntfs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct thread *td)
984263bc
MD
774{
775 /*dprintf(("ntfs_sync():\n"));*/
776 return (0);
777}
778#endif
779
780/*ARGSUSED*/
781static int
cd0a65a2 782ntfs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
984263bc
MD
783{
784 struct vnode *nvp;
785 struct ntfid *ntfhp = (struct ntfid *)fhp;
786 int error;
787
788 ddprintf(("ntfs_fhtovp(): %d\n", ntfhp->ntfid_ino));
789
790 if ((error = VFS_VGET(mp, ntfhp->ntfid_ino, &nvp)) != 0) {
791 *vpp = NULLVP;
792 return (error);
793 }
794 /* XXX as unlink/rmdir/mkdir/creat are not currently possible
795 * with NTFS, we don't need to check anything else for now */
796 *vpp = nvp;
797
798 return (0);
799}
800
801static int
cd0a65a2 802ntfs_vptofh(struct vnode *vp, struct fid *fhp)
984263bc 803{
34ee9825
RG
804 struct ntnode *ntp;
805 struct ntfid *ntfhp;
984263bc
MD
806
807 ddprintf(("ntfs_fhtovp(): %p\n", vp));
808
809 ntp = VTONT(vp);
810 ntfhp = (struct ntfid *)fhp;
811 ntfhp->ntfid_len = sizeof(struct ntfid);
812 ntfhp->ntfid_ino = ntp->i_number;
813 /* ntfhp->ntfid_gen = ntp->i_gen; */
814 return (0);
815}
816
817int
cd0a65a2
CP
818ntfs_vgetex(struct mount *mp, ino_t ino, u_int32_t attrtype, char *attrname,
819 u_long lkflags, u_long flags, struct thread *td,
820 struct vnode **vpp)
984263bc
MD
821{
822 int error;
34ee9825 823 struct ntfsmount *ntmp;
984263bc
MD
824 struct ntnode *ip;
825 struct fnode *fp;
826 struct vnode *vp;
827 enum vtype f_type;
828
829 dprintf(("ntfs_vgetex: ino: %d, attr: 0x%x:%s, lkf: 0x%lx, f: 0x%lx\n",
830 ino, attrtype, attrname?attrname:"", (u_long)lkflags,
831 (u_long)flags ));
832
833 ntmp = VFSTONTFS(mp);
834 *vpp = NULL;
835
836 /* Get ntnode */
837 error = ntfs_ntlookup(ntmp, ino, &ip);
838 if (error) {
839 printf("ntfs_vget: ntfs_ntget failed\n");
840 return (error);
841 }
842
843 /* It may be not initialized fully, so force load it */
844 if (!(flags & VG_DONTLOADIN) && !(ip->i_flag & IN_LOADED)) {
845 error = ntfs_loadntnode(ntmp, ip);
846 if(error) {
f91a71dd 847 printf("ntfs_vget: CAN'T LOAD ATTRIBUTES FOR INO: %"PRId64"\n",
984263bc
MD
848 ip->i_number);
849 ntfs_ntput(ip);
850 return (error);
851 }
852 }
853
854 error = ntfs_fget(ntmp, ip, attrtype, attrname, &fp);
855 if (error) {
856 printf("ntfs_vget: ntfs_fget failed\n");
857 ntfs_ntput(ip);
858 return (error);
859 }
860
861 f_type = VNON;
862 if (!(flags & VG_DONTVALIDFN) && !(fp->f_flag & FN_VALID)) {
863 if ((ip->i_frflag & NTFS_FRFLAG_DIR) &&
864 (fp->f_attrtype == NTFS_A_DATA && fp->f_attrname == NULL)) {
865 f_type = VDIR;
866 } else if (flags & VG_EXT) {
867 f_type = VNON;
868 fp->f_size = fp->f_allocated = 0;
869 } else {
870 f_type = VREG;
871
872 error = ntfs_filesize(ntmp, fp,
873 &fp->f_size, &fp->f_allocated);
874 if (error) {
875 ntfs_ntput(ip);
876 return (error);
877 }
878 }
879
880 fp->f_flag |= FN_VALID;
881 }
882
883 if (FTOV(fp)) {
acde96db 884 VGET(FTOV(fp), lkflags);
984263bc
MD
885 *vpp = FTOV(fp);
886 ntfs_ntput(ip);
887 return (0);
888 }
889
6ddb7618 890 error = getnewvnode(VT_NTFS, ntmp->ntm_mountp, &vp, VLKTIMEOUT, 0);
984263bc
MD
891 if(error) {
892 ntfs_frele(fp);
893 ntfs_ntput(ip);
894 return (error);
895 }
896 dprintf(("ntfs_vget: vnode: %p for ntnode: %d\n", vp,ino));
897
984263bc
MD
898 fp->f_vp = vp;
899 vp->v_data = fp;
900 vp->v_type = f_type;
901
902 if (ino == NTFS_ROOTINO)
903 vp->v_flag |= VROOT;
904
30365587
MD
905 /*
906 * Normal files use the buffer cache
907 */
908 if (f_type == VREG)
7d5a83ff 909 vinitvmio(vp, fp->f_size);
30365587 910
984263bc
MD
911 ntfs_ntput(ip);
912
5fd012e0 913 KKASSERT(lkflags & LK_TYPE_MASK);
5fd012e0 914 /* XXX leave vnode locked exclusively from getnewvnode */
984263bc
MD
915 *vpp = vp;
916 return (0);
917
918}
919
920static int
cd0a65a2 921ntfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
984263bc
MD
922{
923 return ntfs_vgetex(mp, ino, NTFS_A_DATA, NULL,
dadab5e9 924 LK_EXCLUSIVE | LK_RETRY, 0, curthread, vpp);
984263bc
MD
925}
926
08c23b99 927#if defined(__DragonFly__)
984263bc 928static struct vfsops ntfs_vfsops = {
43c45e8f
HP
929 .vfs_mount = ntfs_mount,
930 .vfs_unmount = ntfs_unmount,
931 .vfs_root = ntfs_root,
932 .vfs_statfs = ntfs_statfs,
933 .vfs_sync = vfs_stdsync,
934 .vfs_vget = ntfs_vget,
935 .vfs_fhtovp = ntfs_fhtovp,
936 .vfs_checkexp = ntfs_checkexp,
937 .vfs_vptofh = ntfs_vptofh,
938 .vfs_init = ntfs_init,
939 .vfs_uninit = ntfs_nthash_uninit /* see ntfs_ihash.c */
984263bc
MD
940};
941VFS_SET(ntfs_vfsops, ntfs, 0);
942#elif defined(__NetBSD__)
943extern struct vnodeopv_desc ntfs_vnodeop_opv_desc;
944
945struct vnodeopv_desc *ntfs_vnodeopv_descs[] = {
946 &ntfs_vnodeop_opv_desc,
947 NULL,
948};
949
950struct vfsops ntfs_vfsops = {
951 MOUNT_NTFS,
952 ntfs_mount,
953 ntfs_start,
954 ntfs_unmount,
955 ntfs_root,
956 ntfs_quotactl,
957 ntfs_statfs,
958 ntfs_sync,
959 ntfs_vget,
960 ntfs_fhtovp,
961 ntfs_vptofh,
962 ntfs_init,
963 ntfs_sysctl,
964 ntfs_mountroot,
965 ntfs_checkexp,
966 ntfs_vnodeopv_descs,
967};
968#else /* !NetBSD && !FreeBSD */
969static struct vfsops ntfs_vfsops = {
970 ntfs_mount,
971 ntfs_start,
972 ntfs_unmount,
973 ntfs_root,
974 ntfs_quotactl,
975 ntfs_statfs,
976 ntfs_sync,
977 ntfs_vget,
978 ntfs_fhtovp,
979 ntfs_vptofh,
980 ntfs_init,
981};
982VFS_SET(ntfs_vfsops, ntfs, MOUNT_NTFS, 0);
983#endif
984
985