Merge from FreeBSD:
[dragonfly.git] / sys / vfs / ufs / ffs_vfsops.c
1 /*
2  * Copyright (c) 1989, 1991, 1993, 1994
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      @(#)ffs_vfsops.c        8.31 (Berkeley) 5/20/95
34  * $FreeBSD: src/sys/ufs/ffs/ffs_vfsops.c,v 1.117.2.10 2002/06/23 22:34:52 iedowse Exp $
35  * $DragonFly: src/sys/vfs/ufs/ffs_vfsops.c,v 1.13 2004/02/08 05:56:10 hmp Exp $
36  */
37
38 #include "opt_quota.h"
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/proc.h>
43 #include <sys/namei.h>
44 #include <sys/kernel.h>
45 #include <sys/vnode.h>
46 #include <sys/mount.h>
47 #include <sys/buf.h>
48 #include <sys/conf.h>
49 #include <sys/fcntl.h>
50 #include <sys/disklabel.h>
51 #include <sys/malloc.h>
52
53 #include "quota.h"
54 #include "ufsmount.h"
55 #include "inode.h"
56 #include "ufs_extern.h"
57
58 #include "fs.h"
59 #include "ffs_extern.h"
60
61 #include <vm/vm.h>
62 #include <vm/vm_page.h>
63 #include <vm/vm_zone.h>
64
65 static MALLOC_DEFINE(M_FFSNODE, "FFS node", "FFS vnode private part");
66
67 static int      ffs_sbupdate (struct ufsmount *, int);
68 static int      ffs_reload (struct mount *,struct ucred *,struct thread *);
69 static int      ffs_oldfscompat (struct fs *);
70 static int      ffs_mount (struct mount *, char *, caddr_t,
71                                 struct nameidata *, struct thread *);
72 static int      ffs_init (struct vfsconf *);
73
74 static struct vfsops ufs_vfsops = {
75         ffs_mount,
76         ufs_start,
77         ffs_unmount,
78         ufs_root,
79         ufs_quotactl,
80         ffs_statfs,
81         ffs_sync,
82         ffs_vget,
83         ffs_fhtovp,
84         ufs_check_export,
85         ffs_vptofh,
86         ffs_init,
87         vfs_stduninit,
88         vfs_stdextattrctl,
89 };
90
91 VFS_SET(ufs_vfsops, ufs, 0);
92
93 /*
94  * ffs_mount
95  *
96  * Called when mounting local physical media
97  *
98  * PARAMETERS:
99  *              mountroot
100  *                      mp      mount point structure
101  *                      path    NULL (flag for root mount!!!)
102  *                      data    <unused>
103  *                      ndp     <unused>
104  *                      p       process (user credentials check [statfs])
105  *
106  *              mount
107  *                      mp      mount point structure
108  *                      path    path to mount point
109  *                      data    pointer to argument struct in user space
110  *                      ndp     mount point namei() return (used for
111  *                              credentials on reload), reused to look
112  *                              up block device.
113  *                      p       process (user credentials check)
114  *
115  * RETURNS:     0       Success
116  *              !0      error number (errno.h)
117  *
118  * LOCK STATE:
119  *
120  *              ENTRY
121  *                      mount point is locked
122  *              EXIT
123  *                      mount point is locked
124  *
125  * NOTES:
126  *              A NULL path can be used for a flag since the mount
127  *              system call will fail with EFAULT in copyinstr in
128  *              namei() if it is a genuine NULL from the user.
129  */
130 static int
131 ffs_mount( mp, path, data, ndp, td)
132         struct mount            *mp;    /* mount struct pointer*/
133         char                    *path;  /* path to mount point*/
134         caddr_t                 data;   /* arguments to FS specific mount*/
135         struct nameidata        *ndp;   /* mount point credentials*/
136         struct thread           *td;    /* process requesting mount*/
137 {
138         size_t          size;
139         int             err = 0;
140         struct vnode    *devvp;
141
142         struct ufs_args args;
143         struct ufsmount *ump = 0;
144         struct fs *fs;
145         int error, flags, ronly = 0;
146         mode_t accessmode;
147         struct ucred *cred;
148
149         KKASSERT(td->td_proc);
150         cred = td->td_proc->p_ucred;
151
152         /*
153          * Use NULL path to flag a root mount
154          */
155         if( path == NULL) {
156                 /*
157                  ***
158                  * Mounting root file system
159                  ***
160                  */
161         
162                 if ((err = bdevvp(rootdev, &rootvp))) {
163                         printf("ffs_mountroot: can't find rootvp\n");
164                         return (err);
165                 }
166
167                 if( ( err = ffs_mountfs(rootvp, mp, td, M_FFSNODE)) != 0) {
168                         /* fs specific cleanup (if any)*/
169                         goto error_1;
170                 }
171
172                 goto dostatfs;          /* success*/
173
174         }
175
176         /*
177          ***
178          * Mounting non-root file system or updating a file system
179          ***
180          */
181
182         /* copy in user arguments*/
183         err = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
184         if (err)
185                 goto error_1;           /* can't get arguments*/
186
187         /*
188          * If updating, check whether changing from read-only to
189          * read/write; if there is no device name, that's all we do.
190          */
191         if (mp->mnt_flag & MNT_UPDATE) {
192                 ump = VFSTOUFS(mp);
193                 fs = ump->um_fs;
194                 devvp = ump->um_devvp;
195                 err = 0;
196                 ronly = fs->fs_ronly;   /* MNT_RELOAD might change this */
197                 if (ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
198                         /*
199                          * Flush any dirty data.
200                          */
201                         VFS_SYNC(mp, MNT_WAIT, td);
202                         /*
203                          * Check for and optionally get rid of files open
204                          * for writing.
205                          */
206                         flags = WRITECLOSE;
207                         if (mp->mnt_flag & MNT_FORCE)
208                                 flags |= FORCECLOSE;
209                         if (mp->mnt_flag & MNT_SOFTDEP) {
210                                 err = softdep_flushfiles(mp, flags, td);
211                         } else {
212                                 err = ffs_flushfiles(mp, flags, td);
213                         }
214                         ronly = 1;
215                 }
216                 if (!err && (mp->mnt_flag & MNT_RELOAD))
217                         err = ffs_reload(mp, ndp->ni_cnd.cn_cred, td);
218                 if (err) {
219                         goto error_1;
220                 }
221                 if (ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
222                         /*
223                          * If upgrade to read-write by non-root, then verify
224                          * that user has necessary permissions on the device.
225                          */
226                         if (cred->cr_uid != 0) {
227                                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
228                                 if ((error = VOP_ACCESS(devvp, VREAD | VWRITE,
229                                     cred, td)) != 0) {
230                                         VOP_UNLOCK(devvp, 0, td);
231                                         return (error);
232                                 }
233                                 VOP_UNLOCK(devvp, 0, td);
234                         }
235
236                         fs->fs_flags &= ~FS_UNCLEAN;
237                         if (fs->fs_clean == 0) {
238                                 fs->fs_flags |= FS_UNCLEAN;
239                                 if (mp->mnt_flag & MNT_FORCE) {
240                                         printf(
241 "WARNING: %s was not properly dismounted\n",
242                                             fs->fs_fsmnt);
243                                 } else {
244                                         printf(
245 "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
246                                             fs->fs_fsmnt);
247                                         err = EPERM;
248                                         goto error_1;
249                                 }
250                         }
251
252                         /* check to see if we need to start softdep */
253                         if (fs->fs_flags & FS_DOSOFTDEP) {
254                                 err = softdep_mount(devvp, mp, fs);
255                                 if (err)
256                                         goto error_1;
257                         }
258
259                         ronly = 0;
260                 }
261                 /*
262                  * Soft updates is incompatible with "async",
263                  * so if we are doing softupdates stop the user
264                  * from setting the async flag in an update.
265                  * Softdep_mount() clears it in an initial mount 
266                  * or ro->rw remount.
267                  */
268                 if (mp->mnt_flag & MNT_SOFTDEP) {
269                         mp->mnt_flag &= ~MNT_ASYNC;
270                 }
271                 /* if not updating name...*/
272                 if (args.fspec == 0) {
273                         /*
274                          * Process export requests.  Jumping to "success"
275                          * will return the vfs_export() error code.
276                          */
277                         err = vfs_export(mp, &ump->um_export, &args.export);
278                         goto success;
279                 }
280         }
281
282         /*
283          * Not an update, or updating the name: look up the name
284          * and verify that it refers to a sensible block device.
285          */
286         NDINIT(ndp, NAMEI_LOOKUP, CNP_FOLLOW, UIO_USERSPACE, args.fspec, td);
287         err = namei(ndp);
288         if (err) {
289                 /* can't get devvp!*/
290                 goto error_1;
291         }
292
293         NDFREE(ndp, NDF_ONLY_PNBUF);
294         devvp = ndp->ni_vp;
295
296         if (!vn_isdisk(devvp, &err))
297                 goto error_2;
298
299         /*
300          * If mount by non-root, then verify that user has necessary
301          * permissions on the device.
302          */
303         if (cred->cr_uid != 0) {
304                 accessmode = VREAD;
305                 if ((mp->mnt_flag & MNT_RDONLY) == 0)
306                         accessmode |= VWRITE;
307                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
308                 if ((error = VOP_ACCESS(devvp, accessmode, cred, td)) != 0) {
309                         vput(devvp);
310                         return (error);
311                 }
312                 VOP_UNLOCK(devvp, 0, td);
313         }
314
315         if (mp->mnt_flag & MNT_UPDATE) {
316                 /*
317                  ********************
318                  * UPDATE
319                  * If it's not the same vnode, or at least the same device
320                  * then it's not correct.
321                  ********************
322                  */
323
324                 if (devvp != ump->um_devvp) {
325                         if ( devvp->v_rdev == ump->um_devvp->v_rdev) {
326                                 vrele(devvp);
327                         } else {
328                                 err = EINVAL;   /* needs translation */
329                         }
330                 } else
331                         vrele(devvp);
332                 /*
333                  * Update device name only on success
334                  */
335                 if( !err) {
336                         /* Save "mounted from" info for mount point (NULL pad)*/
337                         copyinstr(      args.fspec,
338                                         mp->mnt_stat.f_mntfromname,
339                                         MNAMELEN - 1,
340                                         &size);
341                         bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
342                 }
343         } else {
344                 /*
345                  ********************
346                  * NEW MOUNT
347                  ********************
348                  */
349
350                 /*
351                  * Since this is a new mount, we want the names for
352                  * the device and the mount point copied in.  If an
353                  * error occurs,  the mountpoint is discarded by the
354                  * upper level code.
355                  */
356                 /* Save "last mounted on" info for mount point (NULL pad)*/
357                 copyinstr(      path,                           /* mount point*/
358                                 mp->mnt_stat.f_mntonname,       /* save area*/
359                                 MNAMELEN - 1,                   /* max size*/
360                                 &size);                         /* real size*/
361                 bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
362
363                 /* Save "mounted from" info for mount point (NULL pad)*/
364                 copyinstr(      args.fspec,                     /* device name*/
365                                 mp->mnt_stat.f_mntfromname,     /* save area*/
366                                 MNAMELEN - 1,                   /* max size*/
367                                 &size);                         /* real size*/
368                 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
369
370                 err = ffs_mountfs(devvp, mp, td, M_FFSNODE);
371         }
372         if (err) {
373                 goto error_2;
374         }
375
376 dostatfs:
377         /*
378          * Initialize FS stat information in mount struct; uses both
379          * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
380          *
381          * This code is common to root and non-root mounts
382          */
383         (void)VFS_STATFS(mp, &mp->mnt_stat, td);
384
385         goto success;
386
387
388 error_2:        /* error with devvp held*/
389
390         /* release devvp before failing*/
391         vrele(devvp);
392
393 error_1:        /* no state to back out*/
394
395 success:
396         if (!err && path && (mp->mnt_flag & MNT_UPDATE)) {
397                 /* Update clean flag after changing read-onlyness. */
398                 fs = ump->um_fs;
399                 if (ronly != fs->fs_ronly) {
400                         fs->fs_ronly = ronly;
401                         fs->fs_clean = ronly &&
402                             (fs->fs_flags & FS_UNCLEAN) == 0 ? 1 : 0;
403                         ffs_sbupdate(ump, MNT_WAIT);
404                 }
405         }
406         return (err);
407 }
408
409 /*
410  * Reload all incore data for a filesystem (used after running fsck on
411  * the root filesystem and finding things to fix). The filesystem must
412  * be mounted read-only.
413  *
414  * Things to do to update the mount:
415  *      1) invalidate all cached meta-data.
416  *      2) re-read superblock from disk.
417  *      3) re-read summary information from disk.
418  *      4) invalidate all inactive vnodes.
419  *      5) invalidate all cached file data.
420  *      6) re-read inode data for all active vnodes.
421  */
422 static int
423 ffs_reload(struct mount *mp, struct ucred *cred, struct thread *td)
424 {
425         struct vnode *vp, *nvp, *devvp;
426         struct inode *ip;
427         void *space;
428         struct buf *bp;
429         struct fs *fs, *newfs;
430         struct partinfo dpart;
431         dev_t dev;
432         int i, blks, size, error;
433         int gen;
434         int vgen;
435         int32_t *lp;
436
437         if ((mp->mnt_flag & MNT_RDONLY) == 0)
438                 return (EINVAL);
439         /*
440          * Step 1: invalidate all cached meta-data.
441          */
442         devvp = VFSTOUFS(mp)->um_devvp;
443         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
444         error = vinvalbuf(devvp, 0, td, 0, 0);
445         VOP_UNLOCK(devvp, 0, td);
446         if (error)
447                 panic("ffs_reload: dirty1");
448
449         dev = devvp->v_rdev;
450
451         /*
452          * Only VMIO the backing device if the backing device is a real
453          * block device.  See ffs_mountmfs() for more details.
454          */
455         if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
456                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
457                 vfs_object_create(devvp, td);
458                 lwkt_gettoken(&devvp->v_interlock);
459                 VOP_UNLOCK(devvp, LK_INTERLOCK, td);
460         }
461
462         /*
463          * Step 2: re-read superblock from disk.
464          */
465         if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, td) != 0)
466                 size = DEV_BSIZE;
467         else
468                 size = dpart.disklab->d_secsize;
469         if ((error = bread(devvp, (ufs_daddr_t)(SBOFF/size), SBSIZE, &bp)) != 0)
470                 return (error);
471         newfs = (struct fs *)bp->b_data;
472         if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
473                 newfs->fs_bsize < sizeof(struct fs)) {
474                         brelse(bp);
475                         return (EIO);           /* XXX needs translation */
476         }
477         fs = VFSTOUFS(mp)->um_fs;
478         /*
479          * Copy pointer fields back into superblock before copying in   XXX
480          * new superblock. These should really be in the ufsmount.      XXX
481          * Note that important parameters (eg fs_ncg) are unchanged.
482          */
483         newfs->fs_csp = fs->fs_csp;
484         newfs->fs_maxcluster = fs->fs_maxcluster;
485         newfs->fs_contigdirs = fs->fs_contigdirs;
486         /* The file system is still read-only. */
487         newfs->fs_ronly = 1;
488         bcopy(newfs, fs, (u_int)fs->fs_sbsize);
489         if (fs->fs_sbsize < SBSIZE)
490                 bp->b_flags |= B_INVAL;
491         brelse(bp);
492         mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
493         ffs_oldfscompat(fs);
494         /* An old fsck may have zeroed these fields, so recheck them. */
495         if (fs->fs_avgfilesize <= 0)            /* XXX */
496                 fs->fs_avgfilesize = AVFILESIZ; /* XXX */
497         if (fs->fs_avgfpdir <= 0)               /* XXX */
498                 fs->fs_avgfpdir = AFPDIR;       /* XXX */
499
500         /*
501          * Step 3: re-read summary information from disk.
502          */
503         blks = howmany(fs->fs_cssize, fs->fs_fsize);
504         space = fs->fs_csp;
505         for (i = 0; i < blks; i += fs->fs_frag) {
506                 size = fs->fs_bsize;
507                 if (i + fs->fs_frag > blks)
508                         size = (blks - i) * fs->fs_fsize;
509                 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size, &bp);
510                 if (error)
511                         return (error);
512                 bcopy(bp->b_data, space, (u_int)size);
513                 space = (char *)space + size;
514                 brelse(bp);
515         }
516         /*
517          * We no longer know anything about clusters per cylinder group.
518          */
519         if (fs->fs_contigsumsize > 0) {
520                 lp = fs->fs_maxcluster;
521                 for (i = 0; i < fs->fs_ncg; i++)
522                         *lp++ = fs->fs_contigsumsize;
523         }
524
525         gen = lwkt_gettoken(&mntvnode_token);
526 loop:
527         for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
528                 if (vp->v_mount != mp) {
529                         lwkt_gentoken(&mntvnode_token, &gen);
530                         goto loop;
531                 }
532                 nvp = TAILQ_NEXT(vp, v_nmntvnodes);
533                 /*
534                  * Step 4: invalidate all inactive vnodes. 
535                  */
536                 if (vrecycle(vp, NULL, td)) {
537                         lwkt_gentoken(&mntvnode_token, &gen);
538                         goto loop;
539                 }
540                 /*
541                  * Step 5: invalidate all cached file data.
542                  */
543                 vgen = lwkt_gettoken(&vp->v_interlock);
544                 if (lwkt_gentoken(&mntvnode_token, &gen) != 0 ||
545                     lwkt_gentoken(&vp->v_interlock, &vgen) != 0) {
546                         lwkt_reltoken(&vp->v_interlock);
547                         lwkt_gentoken(&mntvnode_token, &gen);
548                         goto loop;
549                 }
550                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
551                         lwkt_gentoken(&mntvnode_token, &gen);
552                         goto loop;
553                 }
554                 if (vinvalbuf(vp, 0, td, 0, 0))
555                         panic("ffs_reload: dirty2");
556                 /*
557                  * Step 6: re-read inode data for all active vnodes.
558                  */
559                 ip = VTOI(vp);
560                 error =
561                     bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
562                     (int)fs->fs_bsize, &bp);
563                 if (error) {
564                         vput(vp);
565                         lwkt_reltoken(&mntvnode_token);
566                         return (error);
567                 }
568                 ip->i_din = *((struct dinode *)bp->b_data +
569                     ino_to_fsbo(fs, ip->i_number));
570                 ip->i_effnlink = ip->i_nlink;
571                 brelse(bp);
572                 vput(vp);
573         }
574         lwkt_reltoken(&mntvnode_token);
575         return (0);
576 }
577
578 /*
579  * Common code for mount and mountroot
580  */
581 int
582 ffs_mountfs(devvp, mp, td, malloctype)
583         struct vnode *devvp;
584         struct mount *mp;
585         struct thread *td;
586         struct malloc_type *malloctype;
587 {
588         struct ufsmount *ump;
589         struct buf *bp;
590         struct fs *fs;
591         dev_t dev;
592         struct partinfo dpart;
593         void *space;
594         int error, i, blks, size, ronly;
595         int32_t *lp;
596         u_int64_t maxfilesize;                                  /* XXX */
597         size_t strsize;
598         int ncount;
599
600         dev = devvp->v_rdev;
601         /*
602          * Disallow multiple mounts of the same device.
603          * Disallow mounting of a device that is currently in use
604          * (except for root, which might share swap device for miniroot).
605          * Flush out any old buffers remaining from a previous use.
606          */
607         error = vfs_mountedon(devvp);
608         if (error)
609                 return (error);
610         ncount = vcount(devvp);
611
612         if (ncount > 1 && devvp != rootvp)
613                 return (EBUSY);
614         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
615         error = vinvalbuf(devvp, V_SAVE, td, 0, 0);
616         VOP_UNLOCK(devvp, 0, td);
617         if (error)
618                 return (error);
619
620         /*
621          * Only VMIO the backing device if the backing device is a real
622          * block device.  This excludes the original MFS implementation.
623          * Note that it is optional that the backing device be VMIOed.  This
624          * increases the opportunity for metadata caching.
625          */
626         if (devvp->v_tag != VT_MFS && vn_isdisk(devvp, NULL)) {
627                 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
628                 vfs_object_create(devvp, td);
629                 lwkt_gettoken(&devvp->v_interlock);
630                 VOP_UNLOCK(devvp, LK_INTERLOCK, td);
631         }
632
633         ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
634         vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
635         error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td);
636         VOP_UNLOCK(devvp, 0, td);
637         if (error)
638                 return (error);
639         if (devvp->v_rdev->si_iosize_max != 0)
640                 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
641         if (mp->mnt_iosize_max > MAXPHYS)
642                 mp->mnt_iosize_max = MAXPHYS;
643
644         if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, proc0.p_ucred, td) != 0)
645                 size = DEV_BSIZE;
646         else
647                 size = dpart.disklab->d_secsize;
648
649         bp = NULL;
650         ump = NULL;
651         if ((error = bread(devvp, SBLOCK, SBSIZE, &bp)) != 0)
652                 goto out;
653         fs = (struct fs *)bp->b_data;
654         if (fs->fs_magic != FS_MAGIC || fs->fs_bsize > MAXBSIZE ||
655             fs->fs_bsize < sizeof(struct fs)) {
656                 error = EINVAL;         /* XXX needs translation */
657                 goto out;
658         }
659         fs->fs_fmod = 0;
660         fs->fs_flags &= ~FS_UNCLEAN;
661         if (fs->fs_clean == 0) {
662                 fs->fs_flags |= FS_UNCLEAN;
663                 if (ronly || (mp->mnt_flag & MNT_FORCE)) {
664                         printf(
665 "WARNING: %s was not properly dismounted\n",
666                             fs->fs_fsmnt);
667                 } else {
668                         printf(
669 "WARNING: R/W mount of %s denied.  Filesystem is not clean - run fsck\n",
670                             fs->fs_fsmnt);
671                         error = EPERM;
672                         goto out;
673                 }
674         }
675         /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
676         if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
677                 error = EROFS;          /* needs translation */
678                 goto out;
679         }
680         ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
681         bzero((caddr_t)ump, sizeof *ump);
682         ump->um_malloctype = malloctype;
683         ump->um_i_effnlink_valid = 1;
684         ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
685             M_WAITOK);
686         ump->um_blkatoff = ffs_blkatoff;
687         ump->um_truncate = ffs_truncate;
688         ump->um_update = ffs_update;
689         ump->um_valloc = ffs_valloc;
690         ump->um_vfree = ffs_vfree;
691         bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
692         if (fs->fs_sbsize < SBSIZE)
693                 bp->b_flags |= B_INVAL;
694         brelse(bp);
695         bp = NULL;
696         fs = ump->um_fs;
697         fs->fs_ronly = ronly;
698         size = fs->fs_cssize;
699         blks = howmany(size, fs->fs_fsize);
700         if (fs->fs_contigsumsize > 0)
701                 size += fs->fs_ncg * sizeof(int32_t);
702         size += fs->fs_ncg * sizeof(u_int8_t);
703         space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
704         fs->fs_csp = space;
705         for (i = 0; i < blks; i += fs->fs_frag) {
706                 size = fs->fs_bsize;
707                 if (i + fs->fs_frag > blks)
708                         size = (blks - i) * fs->fs_fsize;
709                 if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
710                     &bp)) != 0) {
711                         free(fs->fs_csp, M_UFSMNT);
712                         goto out;
713                 }
714                 bcopy(bp->b_data, space, (u_int)size);
715                 space = (char *)space + size;
716                 brelse(bp);
717                 bp = NULL;
718         }
719         if (fs->fs_contigsumsize > 0) {
720                 fs->fs_maxcluster = lp = space;
721                 for (i = 0; i < fs->fs_ncg; i++)
722                         *lp++ = fs->fs_contigsumsize;
723                 space = lp;
724         }
725         size = fs->fs_ncg * sizeof(u_int8_t);
726         fs->fs_contigdirs = (u_int8_t *)space;
727         bzero(fs->fs_contigdirs, size);
728         /* Compatibility for old filesystems       XXX */
729         if (fs->fs_avgfilesize <= 0)            /* XXX */
730                 fs->fs_avgfilesize = AVFILESIZ; /* XXX */
731         if (fs->fs_avgfpdir <= 0)               /* XXX */
732                 fs->fs_avgfpdir = AFPDIR;       /* XXX */
733         mp->mnt_data = (qaddr_t)ump;
734         mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
735         mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
736         if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 || 
737             vfs_getvfs(&mp->mnt_stat.f_fsid)) 
738                 vfs_getnewfsid(mp);
739         mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
740         mp->mnt_flag |= MNT_LOCAL;
741         ump->um_mountp = mp;
742         ump->um_dev = dev;
743         ump->um_devvp = devvp;
744         ump->um_nindir = fs->fs_nindir;
745         ump->um_bptrtodb = fs->fs_fsbtodb;
746         ump->um_seqinc = fs->fs_frag;
747         for (i = 0; i < MAXQUOTAS; i++)
748                 ump->um_quotas[i] = NULLVP;
749         devvp->v_specmountpoint = mp;
750         ffs_oldfscompat(fs);
751
752         /*
753          * Set FS local "last mounted on" information (NULL pad)
754          */
755         copystr(        mp->mnt_stat.f_mntonname,       /* mount point*/
756                         fs->fs_fsmnt,                   /* copy area*/
757                         sizeof(fs->fs_fsmnt) - 1,       /* max size*/
758                         &strsize);                      /* real size*/
759         bzero( fs->fs_fsmnt + strsize, sizeof(fs->fs_fsmnt) - strsize);
760
761         if( mp->mnt_flag & MNT_ROOTFS) {
762                 /*
763                  * Root mount; update timestamp in mount structure.
764                  * this will be used by the common root mount code
765                  * to update the system clock.
766                  */
767                 mp->mnt_time = fs->fs_time;
768         }
769
770         ump->um_savedmaxfilesize = fs->fs_maxfilesize;          /* XXX */
771         maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1; /* XXX */
772         /* Enforce limit caused by vm object backing (32 bits vm_pindex_t). */
773         if (maxfilesize > (u_int64_t)0x80000000u * PAGE_SIZE - 1)
774                 maxfilesize = (u_int64_t)0x80000000u * PAGE_SIZE - 1;
775         if (fs->fs_maxfilesize > maxfilesize)                   /* XXX */
776                 fs->fs_maxfilesize = maxfilesize;               /* XXX */
777         if (ronly == 0) {
778                 if ((fs->fs_flags & FS_DOSOFTDEP) &&
779                     (error = softdep_mount(devvp, mp, fs)) != 0) {
780                         free(fs->fs_csp, M_UFSMNT);
781                         goto out;
782                 }
783                 fs->fs_fmod = 1;
784                 fs->fs_clean = 0;
785                 (void) ffs_sbupdate(ump, MNT_WAIT);
786         }
787         return (0);
788 out:
789         devvp->v_specmountpoint = NULL;
790         if (bp)
791                 brelse(bp);
792         (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, td);
793         if (ump) {
794                 free(ump->um_fs, M_UFSMNT);
795                 free(ump, M_UFSMNT);
796                 mp->mnt_data = (qaddr_t)0;
797         }
798         return (error);
799 }
800
801 /*
802  * Sanity checks for old file systems.
803  *
804  * XXX - goes away some day.
805  */
806 static int
807 ffs_oldfscompat(fs)
808         struct fs *fs;
809 {
810
811         fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect);       /* XXX */
812         fs->fs_interleave = max(fs->fs_interleave, 1);          /* XXX */
813         if (fs->fs_postblformat == FS_42POSTBLFMT)              /* XXX */
814                 fs->fs_nrpos = 8;                               /* XXX */
815         if (fs->fs_inodefmt < FS_44INODEFMT) {                  /* XXX */
816 #if 0
817                 int i;                                          /* XXX */
818                 u_int64_t sizepb = fs->fs_bsize;                /* XXX */
819                                                                 /* XXX */
820                 fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
821                 for (i = 0; i < NIADDR; i++) {                  /* XXX */
822                         sizepb *= NINDIR(fs);                   /* XXX */
823                         fs->fs_maxfilesize += sizepb;           /* XXX */
824                 }                                               /* XXX */
825 #endif
826                 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
827                 fs->fs_qbmask = ~fs->fs_bmask;                  /* XXX */
828                 fs->fs_qfmask = ~fs->fs_fmask;                  /* XXX */
829         }                                                       /* XXX */
830         return (0);
831 }
832
833 /*
834  * unmount system call
835  */
836 int
837 ffs_unmount(struct mount *mp, int mntflags, struct thread *td)
838 {
839         struct ufsmount *ump;
840         struct fs *fs;
841         int error, flags;
842
843         flags = 0;
844         if (mntflags & MNT_FORCE) {
845                 flags |= FORCECLOSE;
846         }
847         if (mp->mnt_flag & MNT_SOFTDEP) {
848                 if ((error = softdep_flushfiles(mp, flags, td)) != 0)
849                         return (error);
850         } else {
851                 if ((error = ffs_flushfiles(mp, flags, td)) != 0)
852                         return (error);
853         }
854         ump = VFSTOUFS(mp);
855         fs = ump->um_fs;
856         if (fs->fs_ronly == 0) {
857                 fs->fs_clean = fs->fs_flags & FS_UNCLEAN ? 0 : 1;
858                 error = ffs_sbupdate(ump, MNT_WAIT);
859                 if (error) {
860                         fs->fs_clean = 0;
861                         return (error);
862                 }
863         }
864         ump->um_devvp->v_specmountpoint = NULL;
865
866         vinvalbuf(ump->um_devvp, V_SAVE, td, 0, 0);
867         error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE, td);
868
869         vrele(ump->um_devvp);
870
871         free(fs->fs_csp, M_UFSMNT);
872         free(fs, M_UFSMNT);
873         free(ump, M_UFSMNT);
874         mp->mnt_data = (qaddr_t)0;
875         mp->mnt_flag &= ~MNT_LOCAL;
876         return (error);
877 }
878
879 /*
880  * Flush out all the files in a filesystem.
881  */
882 int
883 ffs_flushfiles(struct mount *mp, int flags, struct thread *td)
884 {
885         struct ufsmount *ump;
886         int error;
887
888         ump = VFSTOUFS(mp);
889 #ifdef QUOTA
890         if (mp->mnt_flag & MNT_QUOTA) {
891                 int i;
892                 error = vflush(mp, 0, SKIPSYSTEM|flags);
893                 if (error)
894                         return (error);
895                 for (i = 0; i < MAXQUOTAS; i++) {
896                         if (ump->um_quotas[i] == NULLVP)
897                                 continue;
898                         quotaoff(td, mp, i);
899                 }
900                 /*
901                  * Here we fall through to vflush again to ensure
902                  * that we have gotten rid of all the system vnodes.
903                  */
904         }
905 #endif
906         /*
907          * Flush all the files.
908          */
909         if ((error = vflush(mp, 0, flags)) != 0)
910                 return (error);
911         /*
912          * Flush filesystem metadata.
913          */
914         vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td);
915         error = VOP_FSYNC(ump->um_devvp, MNT_WAIT, td);
916         VOP_UNLOCK(ump->um_devvp, 0, td);
917         return (error);
918 }
919
920 /*
921  * Get file system statistics.
922  */
923 int
924 ffs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
925 {
926         struct ufsmount *ump;
927         struct fs *fs;
928
929         ump = VFSTOUFS(mp);
930         fs = ump->um_fs;
931         if (fs->fs_magic != FS_MAGIC)
932                 panic("ffs_statfs");
933         sbp->f_bsize = fs->fs_fsize;
934         sbp->f_iosize = fs->fs_bsize;
935         sbp->f_blocks = fs->fs_dsize;
936         sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
937                 fs->fs_cstotal.cs_nffree;
938         sbp->f_bavail = freespace(fs, fs->fs_minfree);
939         sbp->f_files =  fs->fs_ncg * fs->fs_ipg - ROOTINO;
940         sbp->f_ffree = fs->fs_cstotal.cs_nifree;
941         if (sbp != &mp->mnt_stat) {
942                 sbp->f_type = mp->mnt_vfc->vfc_typenum;
943                 bcopy((caddr_t)mp->mnt_stat.f_mntonname,
944                         (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
945                 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
946                         (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
947         }
948         return (0);
949 }
950
951 /*
952  * Go through the disk queues to initiate sandbagged IO;
953  * go through the inodes to write those that have been modified;
954  * initiate the writing of the super block if it has been modified.
955  *
956  * Note: we are always called with the filesystem marked `MPBUSY'.
957  */
958 int
959 ffs_sync(struct mount *mp, int waitfor, struct thread *td)
960 {
961         struct vnode *nvp, *vp;
962         struct inode *ip;
963         struct ufsmount *ump = VFSTOUFS(mp);
964         struct fs *fs;
965         int error, allerror = 0;
966
967         fs = ump->um_fs;
968         if (fs->fs_fmod != 0 && fs->fs_ronly != 0) {            /* XXX */
969                 printf("fs = %s\n", fs->fs_fsmnt);
970                 panic("ffs_sync: rofs mod");
971         }
972         /*
973          * Write back each (modified) inode.
974          */
975         lwkt_gettoken(&mntvnode_token);
976 loop:
977         for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
978                 /*
979                  * If the vnode that we are about to sync is no longer
980                  * associated with this mount point, start over.
981                  */
982                 if (vp->v_mount != mp)
983                         goto loop;
984
985                 /*
986                  * Depend on the mntvnode_token to keep things stable enough
987                  * for a quick test.  Since there might be hundreds of 
988                  * thousands of vnodes, we cannot afford even a subroutine
989                  * call unless there's a good chance that we have work to do.
990                  */
991                 nvp = TAILQ_NEXT(vp, v_nmntvnodes);
992                 ip = VTOI(vp);
993                 if (vp->v_type == VNON || ((ip->i_flag &
994                      (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
995                      TAILQ_EMPTY(&vp->v_dirtyblkhd))) {
996                         continue;
997                 }
998                 if (vp->v_type != VCHR) {
999                         lwkt_reltoken(&mntvnode_token);
1000                         error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT, td);
1001                         if (error) {
1002                                 lwkt_gettoken(&mntvnode_token);
1003                                 if (error == ENOENT)
1004                                         goto loop;
1005                         } else {
1006                                 if ((error = VOP_FSYNC(vp, waitfor, td)) != 0)
1007                                         allerror = error;
1008                                 VOP_UNLOCK(vp, 0, td);
1009                                 vrele(vp);
1010                                 lwkt_gettoken(&mntvnode_token);
1011                         }
1012                 } else {
1013                         /*
1014                          * We must reference the vp to prevent it from
1015                          * getting ripped out from under UFS_UPDATE, since
1016                          * we are not holding a vnode lock.  XXX why aren't
1017                          * we holding a vnode lock?
1018                          */
1019                         VREF(vp);
1020                         lwkt_reltoken(&mntvnode_token);
1021                         /* UFS_UPDATE(vp, waitfor == MNT_WAIT); */
1022                         UFS_UPDATE(vp, 0);
1023                         vrele(vp);
1024                         lwkt_gettoken(&mntvnode_token);
1025                 }
1026                 if (TAILQ_NEXT(vp, v_nmntvnodes) != nvp)
1027                         goto loop;
1028         }
1029         lwkt_reltoken(&mntvnode_token);
1030         /*
1031          * Force stale file system control information to be flushed.
1032          */
1033         if (waitfor != MNT_LAZY) {
1034                 if (ump->um_mountp->mnt_flag & MNT_SOFTDEP)
1035                         waitfor = MNT_NOWAIT;
1036                 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td);
1037                 if ((error = VOP_FSYNC(ump->um_devvp, waitfor, td)) != 0)
1038                         allerror = error;
1039                 VOP_UNLOCK(ump->um_devvp, 0, td);
1040         }
1041 #ifdef QUOTA
1042         qsync(mp);
1043 #endif
1044         /*
1045          * Write back modified superblock.
1046          */
1047         if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
1048                 allerror = error;
1049         return (allerror);
1050 }
1051
1052 /*
1053  * Look up a FFS dinode number to find its incore vnode, otherwise read it
1054  * in from disk.  If it is in core, wait for the lock bit to clear, then
1055  * return the inode locked.  Detection and handling of mount points must be
1056  * done by the calling routine.
1057  */
1058 static int ffs_inode_hash_lock;
1059
1060 int
1061 ffs_vget(mp, ino, vpp)
1062         struct mount *mp;
1063         ino_t ino;
1064         struct vnode **vpp;
1065 {
1066         struct fs *fs;
1067         struct inode *ip;
1068         struct ufsmount *ump;
1069         struct buf *bp;
1070         struct vnode *vp;
1071         dev_t dev;
1072         int error;
1073
1074         ump = VFSTOUFS(mp);
1075         dev = ump->um_dev;
1076 restart:
1077         if ((*vpp = ufs_ihashget(dev, ino)) != NULL) {
1078                 return (0);
1079         }
1080
1081         /*
1082          * Lock out the creation of new entries in the FFS hash table in
1083          * case getnewvnode() or MALLOC() blocks, otherwise a duplicate
1084          * may occur!
1085          */
1086         if (ffs_inode_hash_lock) {
1087                 while (ffs_inode_hash_lock) {
1088                         ffs_inode_hash_lock = -1;
1089                         tsleep(&ffs_inode_hash_lock, 0, "ffsvgt", 0);
1090                 }
1091                 goto restart;
1092         }
1093         ffs_inode_hash_lock = 1;
1094
1095         /*
1096          * If this MALLOC() is performed after the getnewvnode()
1097          * it might block, leaving a vnode with a NULL v_data to be
1098          * found by ffs_sync() if a sync happens to fire right then,
1099          * which will cause a panic because ffs_sync() blindly
1100          * dereferences vp->v_data (as well it should).
1101          */
1102         MALLOC(ip, struct inode *, sizeof(struct inode), 
1103             ump->um_malloctype, M_WAITOK);
1104
1105         /* Allocate a new vnode/inode. */
1106         error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp);
1107         if (error) {
1108                 if (ffs_inode_hash_lock < 0)
1109                         wakeup(&ffs_inode_hash_lock);
1110                 ffs_inode_hash_lock = 0;
1111                 *vpp = NULL;
1112                 FREE(ip, ump->um_malloctype);
1113                 return (error);
1114         }
1115         bzero((caddr_t)ip, sizeof(struct inode));
1116         lockinit(&ip->i_lock, 0, "inode", VLKTIMEOUT, LK_CANRECURSE);
1117         vp->v_data = ip;
1118         /*
1119          * FFS supports lock sharing in the stack of vnodes
1120          */
1121         vp->v_vnlock = &ip->i_lock;
1122         ip->i_vnode = vp;
1123         ip->i_fs = fs = ump->um_fs;
1124         ip->i_dev = dev;
1125         ip->i_number = ino;
1126 #ifdef QUOTA
1127         {
1128                 int i;
1129                 for (i = 0; i < MAXQUOTAS; i++)
1130                         ip->i_dquot[i] = NODQUOT;
1131         }
1132 #endif
1133         /*
1134          * Put it onto its hash chain and lock it so that other requests for
1135          * this inode will block if they arrive while we are sleeping waiting
1136          * for old data structures to be purged or for the contents of the
1137          * disk portion of this inode to be read.
1138          */
1139         ufs_ihashins(ip);
1140
1141         if (ffs_inode_hash_lock < 0)
1142                 wakeup(&ffs_inode_hash_lock);
1143         ffs_inode_hash_lock = 0;
1144
1145         /* Read in the disk contents for the inode, copy into the inode. */
1146         error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1147             (int)fs->fs_bsize, &bp);
1148         if (error) {
1149                 /*
1150                  * The inode does not contain anything useful, so it would
1151                  * be misleading to leave it on its hash chain. With mode
1152                  * still zero, it will be unlinked and returned to the free
1153                  * list by vput().
1154                  */
1155                 brelse(bp);
1156                 vput(vp);
1157                 *vpp = NULL;
1158                 return (error);
1159         }
1160         ip->i_din = *((struct dinode *)bp->b_data + ino_to_fsbo(fs, ino));
1161         if (DOINGSOFTDEP(vp))
1162                 softdep_load_inodeblock(ip);
1163         else
1164                 ip->i_effnlink = ip->i_nlink;
1165         bqrelse(bp);
1166
1167         /*
1168          * Initialize the vnode from the inode, check for aliases.
1169          * Note that the underlying vnode may have changed.
1170          */
1171         error = ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1172         if (error) {
1173                 vput(vp);
1174                 *vpp = NULL;
1175                 return (error);
1176         }
1177         /*
1178          * Finish inode initialization now that aliasing has been resolved.
1179          */
1180         ip->i_devvp = ump->um_devvp;
1181         VREF(ip->i_devvp);
1182         /*
1183          * Set up a generation number for this inode if it does not
1184          * already have one. This should only happen on old filesystems.
1185          */
1186         if (ip->i_gen == 0) {
1187                 ip->i_gen = random() / 2 + 1;
1188                 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1189                         ip->i_flag |= IN_MODIFIED;
1190         }
1191         /*
1192          * Ensure that uid and gid are correct. This is a temporary
1193          * fix until fsck has been changed to do the update.
1194          */
1195         if (fs->fs_inodefmt < FS_44INODEFMT) {          /* XXX */
1196                 ip->i_uid = ip->i_din.di_ouid;          /* XXX */
1197                 ip->i_gid = ip->i_din.di_ogid;          /* XXX */
1198         }                                               /* XXX */
1199
1200         *vpp = vp;
1201         return (0);
1202 }
1203
1204 /*
1205  * File handle to vnode
1206  *
1207  * Have to be really careful about stale file handles:
1208  * - check that the inode number is valid
1209  * - call ffs_vget() to get the locked inode
1210  * - check for an unallocated inode (i_mode == 0)
1211  * - check that the given client host has export rights and return
1212  *   those rights via. exflagsp and credanonp
1213  */
1214 int
1215 ffs_fhtovp(mp, fhp, vpp)
1216         struct mount *mp;
1217         struct fid *fhp;
1218         struct vnode **vpp;
1219 {
1220         struct ufid *ufhp;
1221         struct fs *fs;
1222
1223         ufhp = (struct ufid *)fhp;
1224         fs = VFSTOUFS(mp)->um_fs;
1225         if (ufhp->ufid_ino < ROOTINO ||
1226             ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1227                 return (ESTALE);
1228         return (ufs_fhtovp(mp, ufhp, vpp));
1229 }
1230
1231 /*
1232  * Vnode pointer to File handle
1233  */
1234 /* ARGSUSED */
1235 int
1236 ffs_vptofh(vp, fhp)
1237         struct vnode *vp;
1238         struct fid *fhp;
1239 {
1240         struct inode *ip;
1241         struct ufid *ufhp;
1242
1243         ip = VTOI(vp);
1244         ufhp = (struct ufid *)fhp;
1245         ufhp->ufid_len = sizeof(struct ufid);
1246         ufhp->ufid_ino = ip->i_number;
1247         ufhp->ufid_gen = ip->i_gen;
1248         return (0);
1249 }
1250
1251 /*
1252  * Initialize the filesystem; just use ufs_init.
1253  */
1254 static int
1255 ffs_init(vfsp)
1256         struct vfsconf *vfsp;
1257 {
1258
1259         softdep_initialize();
1260         return (ufs_init(vfsp));
1261 }
1262
1263 /*
1264  * Write a superblock and associated information back to disk.
1265  */
1266 static int
1267 ffs_sbupdate(mp, waitfor)
1268         struct ufsmount *mp;
1269         int waitfor;
1270 {
1271         struct fs *dfs, *fs = mp->um_fs;
1272         struct buf *bp;
1273         int blks;
1274         void *space;
1275         int i, size, error, allerror = 0;
1276
1277         /*
1278          * First write back the summary information.
1279          */
1280         blks = howmany(fs->fs_cssize, fs->fs_fsize);
1281         space = fs->fs_csp;
1282         for (i = 0; i < blks; i += fs->fs_frag) {
1283                 size = fs->fs_bsize;
1284                 if (i + fs->fs_frag > blks)
1285                         size = (blks - i) * fs->fs_fsize;
1286                 bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1287                     size, 0, 0);
1288                 bcopy(space, bp->b_data, (u_int)size);
1289                 space = (char *)space + size;
1290                 if (waitfor != MNT_WAIT)
1291                         bawrite(bp);
1292                 else if ((error = bwrite(bp)) != 0)
1293                         allerror = error;
1294         }
1295         /*
1296          * Now write back the superblock itself. If any errors occurred
1297          * up to this point, then fail so that the superblock avoids
1298          * being written out as clean.
1299          */
1300         if (allerror)
1301                 return (allerror);
1302         bp = getblk(mp->um_devvp, SBLOCK, (int)fs->fs_sbsize, 0, 0);
1303         fs->fs_fmod = 0;
1304         fs->fs_time = time_second;
1305         bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1306         /* Restore compatibility to old file systems.              XXX */
1307         dfs = (struct fs *)bp->b_data;                          /* XXX */
1308         if (fs->fs_postblformat == FS_42POSTBLFMT)              /* XXX */
1309                 dfs->fs_nrpos = -1;                             /* XXX */
1310         if (fs->fs_inodefmt < FS_44INODEFMT) {                  /* XXX */
1311                 int32_t *lp, tmp;                               /* XXX */
1312                                                                 /* XXX */
1313                 lp = (int32_t *)&dfs->fs_qbmask;                /* XXX */
1314                 tmp = lp[4];                                    /* XXX */
1315                 for (i = 4; i > 0; i--)                         /* XXX */
1316                         lp[i] = lp[i-1];                        /* XXX */
1317                 lp[0] = tmp;                                    /* XXX */
1318         }                                                       /* XXX */
1319         dfs->fs_maxfilesize = mp->um_savedmaxfilesize;          /* XXX */
1320         if (waitfor != MNT_WAIT)
1321                 bawrite(bp);
1322         else if ((error = bwrite(bp)) != 0)
1323                 allerror = error;
1324         return (allerror);
1325 }