ffs_vfsops.c revision 1.278.2.7 1 /* $NetBSD: ffs_vfsops.c,v 1.278.2.7 2017/12/03 11:39:21 jdolecek Exp $ */
2
3 /*-
4 * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Wasabi Systems, Inc, and by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1989, 1991, 1993, 1994
34 * The Regents of the University of California. All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 * 3. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95
61 */
62
63 #include <sys/cdefs.h>
64 __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.278.2.7 2017/12/03 11:39:21 jdolecek Exp $");
65
66 #if defined(_KERNEL_OPT)
67 #include "opt_ffs.h"
68 #include "opt_quota.h"
69 #include "opt_wapbl.h"
70 #endif
71
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/namei.h>
75 #include <sys/proc.h>
76 #include <sys/kernel.h>
77 #include <sys/vnode.h>
78 #include <sys/socket.h>
79 #include <sys/mount.h>
80 #include <sys/buf.h>
81 #include <sys/device.h>
82 #include <sys/disk.h>
83 #include <sys/mbuf.h>
84 #include <sys/file.h>
85 #include <sys/disklabel.h>
86 #include <sys/ioctl.h>
87 #include <sys/errno.h>
88 #include <sys/kmem.h>
89 #include <sys/pool.h>
90 #include <sys/lock.h>
91 #include <sys/sysctl.h>
92 #include <sys/conf.h>
93 #include <sys/kauth.h>
94 #include <sys/wapbl.h>
95 #include <sys/module.h>
96
97 #include <miscfs/genfs/genfs.h>
98 #include <miscfs/specfs/specdev.h>
99
100 #include <ufs/ufs/quota.h>
101 #include <ufs/ufs/ufsmount.h>
102 #include <ufs/ufs/inode.h>
103 #include <ufs/ufs/dir.h>
104 #include <ufs/ufs/ufs_extern.h>
105 #include <ufs/ufs/ufs_bswap.h>
106 #include <ufs/ufs/ufs_wapbl.h>
107
108 #include <ufs/ffs/fs.h>
109 #include <ufs/ffs/ffs_extern.h>
110
111 #ifdef WAPBL
112 MODULE(MODULE_CLASS_VFS, ffs, "wapbl");
113 #else
114 MODULE(MODULE_CLASS_VFS, ffs, NULL);
115 #endif
116
117 static int ffs_vfs_fsync(vnode_t *, int);
118 static int ffs_superblock_validate(struct fs *);
119 static int ffs_is_appleufs(struct vnode *, struct fs *);
120
121 static int ffs_init_vnode(struct ufsmount *, struct vnode *, ino_t);
122 static void ffs_deinit_vnode(struct ufsmount *, struct vnode *);
123
124 static struct sysctllog *ffs_sysctl_log;
125
126 static kauth_listener_t ffs_snapshot_listener;
127
128 /* how many times ffs_init() was called */
129 int ffs_initcount = 0;
130
131 #ifdef DEBUG_FFS_MOUNT
132 #define DPRINTF(_fmt, args...) printf("%s: " _fmt "\n", __func__, ##args)
133 #else
134 #define DPRINTF(_fmt, args...) do {} while (/*CONSTCOND*/0)
135 #endif
136
137 extern const struct vnodeopv_desc ffs_vnodeop_opv_desc;
138 extern const struct vnodeopv_desc ffs_specop_opv_desc;
139 extern const struct vnodeopv_desc ffs_fifoop_opv_desc;
140
141 const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
142 &ffs_vnodeop_opv_desc,
143 &ffs_specop_opv_desc,
144 &ffs_fifoop_opv_desc,
145 NULL,
146 };
147
148 struct vfsops ffs_vfsops = {
149 .vfs_name = MOUNT_FFS,
150 .vfs_min_mount_data = sizeof (struct ufs_args),
151 .vfs_mount = ffs_mount,
152 .vfs_start = ufs_start,
153 .vfs_unmount = ffs_unmount,
154 .vfs_root = ufs_root,
155 .vfs_quotactl = ufs_quotactl,
156 .vfs_statvfs = ffs_statvfs,
157 .vfs_sync = ffs_sync,
158 .vfs_vget = ufs_vget,
159 .vfs_loadvnode = ffs_loadvnode,
160 .vfs_newvnode = ffs_newvnode,
161 .vfs_fhtovp = ffs_fhtovp,
162 .vfs_vptofh = ffs_vptofh,
163 .vfs_init = ffs_init,
164 .vfs_reinit = ffs_reinit,
165 .vfs_done = ffs_done,
166 .vfs_mountroot = ffs_mountroot,
167 .vfs_snapshot = ffs_snapshot,
168 .vfs_extattrctl = ffs_extattrctl,
169 .vfs_suspendctl = genfs_suspendctl,
170 .vfs_renamelock_enter = genfs_renamelock_enter,
171 .vfs_renamelock_exit = genfs_renamelock_exit,
172 .vfs_fsync = ffs_vfs_fsync,
173 .vfs_opv_descs = ffs_vnodeopv_descs
174 };
175
176 static const struct genfs_ops ffs_genfsops = {
177 .gop_size = ffs_gop_size,
178 .gop_alloc = ufs_gop_alloc,
179 .gop_write = genfs_gop_write,
180 .gop_markupdate = ufs_gop_markupdate,
181 };
182
183 static const struct ufs_ops ffs_ufsops = {
184 .uo_itimes = ffs_itimes,
185 .uo_update = ffs_update,
186 .uo_truncate = ffs_truncate,
187 .uo_balloc = ffs_balloc,
188 .uo_snapgone = ffs_snapgone,
189 .uo_bufrd = ffs_bufrd,
190 .uo_bufwr = ffs_bufwr,
191 };
192
193 static int
194 ffs_checkrange(struct mount *mp, uint32_t ino)
195 {
196 struct fs *fs = VFSTOUFS(mp)->um_fs;
197
198 if (ino < UFS_ROOTINO || ino >= fs->fs_ncg * fs->fs_ipg) {
199 DPRINTF("out of range %u\n", ino);
200 return ESTALE;
201 }
202
203 /*
204 * Need to check if inode is initialized because ffsv2 does
205 * lazy initialization and we can get here from nfs_fhtovp
206 */
207 if (fs->fs_magic != FS_UFS2_MAGIC)
208 return 0;
209
210 struct buf *bp;
211 int cg = ino_to_cg(fs, ino);
212 struct ufsmount *ump = VFSTOUFS(mp);
213
214 int error = bread(ump->um_devvp, FFS_FSBTODB(fs, cgtod(fs, cg)),
215 (int)fs->fs_cgsize, B_MODIFY, &bp);
216 if (error) {
217 DPRINTF("error %d reading cg %d ino %u\n", error, cg, ino);
218 return error;
219 }
220
221 const int needswap = UFS_FSNEEDSWAP(fs);
222
223 struct cg *cgp = (struct cg *)bp->b_data;
224 if (!cg_chkmagic(cgp, needswap)) {
225 brelse(bp, 0);
226 DPRINTF("bad cylinder group magic cg %d ino %u\n", cg, ino);
227 return ESTALE;
228 }
229
230 int32_t initediblk = ufs_rw32(cgp->cg_initediblk, needswap);
231 brelse(bp, 0);
232
233 if (cg * fs->fs_ipg + initediblk < ino) {
234 DPRINTF("cg=%d fs->fs_ipg=%d initediblk=%d ino=%u\n",
235 cg, fs->fs_ipg, initediblk, ino);
236 return ESTALE;
237 }
238 return 0;
239 }
240
241 static int
242 ffs_snapshot_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
243 void *arg0, void *arg1, void *arg2, void *arg3)
244 {
245 vnode_t *vp = arg2;
246 int result = KAUTH_RESULT_DEFER;
247
248 if (action != KAUTH_SYSTEM_FS_SNAPSHOT)
249 return result;
250
251 if (VTOI(vp)->i_uid == kauth_cred_geteuid(cred))
252 result = KAUTH_RESULT_ALLOW;
253
254 return result;
255 }
256
257 static int
258 ffs_modcmd(modcmd_t cmd, void *arg)
259 {
260 int error;
261
262 #if 0
263 extern int doasyncfree;
264 #endif
265 #ifdef UFS_EXTATTR
266 extern int ufs_extattr_autocreate;
267 #endif
268 extern int ffs_log_changeopt;
269
270 switch (cmd) {
271 case MODULE_CMD_INIT:
272 error = vfs_attach(&ffs_vfsops);
273 if (error != 0)
274 break;
275
276 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
277 CTLFLAG_PERMANENT,
278 CTLTYPE_NODE, "ffs",
279 SYSCTL_DESCR("Berkeley Fast File System"),
280 NULL, 0, NULL, 0,
281 CTL_VFS, 1, CTL_EOL);
282 /*
283 * @@@ should we even bother with these first three?
284 */
285 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
286 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
287 CTLTYPE_INT, "doclusterread", NULL,
288 sysctl_notavail, 0, NULL, 0,
289 CTL_VFS, 1, FFS_CLUSTERREAD, CTL_EOL);
290 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
291 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
292 CTLTYPE_INT, "doclusterwrite", NULL,
293 sysctl_notavail, 0, NULL, 0,
294 CTL_VFS, 1, FFS_CLUSTERWRITE, CTL_EOL);
295 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
296 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
297 CTLTYPE_INT, "doreallocblks", NULL,
298 sysctl_notavail, 0, NULL, 0,
299 CTL_VFS, 1, FFS_REALLOCBLKS, CTL_EOL);
300 #if 0
301 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
302 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
303 CTLTYPE_INT, "doasyncfree",
304 SYSCTL_DESCR("Release dirty blocks asynchronously"),
305 NULL, 0, &doasyncfree, 0,
306 CTL_VFS, 1, FFS_ASYNCFREE, CTL_EOL);
307 #endif
308 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
309 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
310 CTLTYPE_INT, "log_changeopt",
311 SYSCTL_DESCR("Log changes in optimization strategy"),
312 NULL, 0, &ffs_log_changeopt, 0,
313 CTL_VFS, 1, FFS_LOG_CHANGEOPT, CTL_EOL);
314 #ifdef UFS_EXTATTR
315 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
316 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
317 CTLTYPE_INT, "extattr_autocreate",
318 SYSCTL_DESCR("Size of attribute for "
319 "backing file autocreation"),
320 NULL, 0, &ufs_extattr_autocreate, 0,
321 CTL_VFS, 1, FFS_EXTATTR_AUTOCREATE, CTL_EOL);
322
323 #endif /* UFS_EXTATTR */
324
325 ffs_snapshot_listener = kauth_listen_scope(KAUTH_SCOPE_SYSTEM,
326 ffs_snapshot_cb, NULL);
327 if (ffs_snapshot_listener == NULL)
328 printf("ffs_modcmd: can't listen on system scope.\n");
329
330 break;
331 case MODULE_CMD_FINI:
332 error = vfs_detach(&ffs_vfsops);
333 if (error != 0)
334 break;
335 sysctl_teardown(&ffs_sysctl_log);
336 if (ffs_snapshot_listener != NULL)
337 kauth_unlisten_scope(ffs_snapshot_listener);
338 break;
339 default:
340 error = ENOTTY;
341 break;
342 }
343
344 return (error);
345 }
346
347 pool_cache_t ffs_inode_cache;
348 pool_cache_t ffs_dinode1_cache;
349 pool_cache_t ffs_dinode2_cache;
350
351 static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t);
352 static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
353
354 /*
355 * Called by main() when ffs is going to be mounted as root.
356 */
357
358 int
359 ffs_mountroot(void)
360 {
361 struct fs *fs;
362 struct mount *mp;
363 struct lwp *l = curlwp; /* XXX */
364 struct ufsmount *ump;
365 int error;
366
367 if (device_class(root_device) != DV_DISK)
368 return (ENODEV);
369
370 if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
371 vrele(rootvp);
372 return (error);
373 }
374
375 /*
376 * We always need to be able to mount the root file system.
377 */
378 mp->mnt_flag |= MNT_FORCE;
379 if ((error = ffs_mountfs(rootvp, mp, l)) != 0) {
380 vfs_unbusy(mp);
381 vfs_rele(mp);
382 return (error);
383 }
384 mp->mnt_flag &= ~MNT_FORCE;
385 mountlist_append(mp);
386 ump = VFSTOUFS(mp);
387 fs = ump->um_fs;
388 memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
389 (void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
390 (void)ffs_statvfs(mp, &mp->mnt_stat);
391 vfs_unbusy(mp);
392 setrootfstime((time_t)fs->fs_time);
393 return (0);
394 }
395
396 /*
397 * VFS Operations.
398 *
399 * mount system call
400 */
401 int
402 ffs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
403 {
404 struct lwp *l = curlwp;
405 struct vnode *devvp = NULL;
406 struct ufs_args *args = data;
407 struct ufsmount *ump = NULL;
408 struct fs *fs;
409 int error = 0, flags, update;
410 mode_t accessmode;
411
412 if (args == NULL) {
413 DPRINTF("NULL args");
414 return EINVAL;
415 }
416 if (*data_len < sizeof(*args)) {
417 DPRINTF("bad size args %zu != %zu", *data_len, sizeof(*args));
418 return EINVAL;
419 }
420
421 ump = VFSTOUFS(mp);
422 if ((mp->mnt_flag & (MNT_GETARGS|MNT_UPDATE)) && ump == NULL) {
423 DPRINTF("no ump");
424 return EIO;
425 }
426
427 if (mp->mnt_flag & MNT_GETARGS) {
428 args->fspec = NULL;
429 *data_len = sizeof *args;
430 return 0;
431 }
432
433 update = mp->mnt_flag & MNT_UPDATE;
434
435 /* Check arguments */
436 if (args->fspec == NULL) {
437 if (!update) {
438 /* New mounts must have a filename for the device */
439 DPRINTF("no filename for mount");
440 return EINVAL;
441 }
442 } else {
443 /*
444 * Look up the name and verify that it's sane.
445 */
446 error = namei_simple_user(args->fspec,
447 NSM_FOLLOW_NOEMULROOT, &devvp);
448 if (error != 0) {
449 DPRINTF("namei_simple_user returned %d", error);
450 return error;
451 }
452
453 /*
454 * Be sure this is a valid block device
455 */
456 if (devvp->v_type != VBLK) {
457 DPRINTF("non block device %d", devvp->v_type);
458 error = ENOTBLK;
459 goto fail;
460 }
461
462 if (bdevsw_lookup(devvp->v_rdev) == NULL) {
463 DPRINTF("can't find block device 0x%jx",
464 devvp->v_rdev);
465 error = ENXIO;
466 goto fail;
467 }
468
469 if (update) {
470 /*
471 * Be sure we're still naming the same device
472 * used for our initial mount
473 */
474 if (devvp != ump->um_devvp &&
475 devvp->v_rdev != ump->um_devvp->v_rdev) {
476 DPRINTF("wrong device 0x%jx != 0x%jx",
477 (uintmax_t)devvp->v_rdev,
478 (uintmax_t)ump->um_devvp->v_rdev);
479 error = EINVAL;
480 goto fail;
481 }
482 vrele(devvp);
483 devvp = NULL;
484 }
485 }
486
487 if (devvp == NULL) {
488 devvp = ump->um_devvp;
489 vref(devvp);
490 }
491
492 /*
493 * If mount by non-root, then verify that user has necessary
494 * permissions on the device.
495 *
496 * Permission to update a mount is checked higher, so here we presume
497 * updating the mount is okay (for example, as far as securelevel goes)
498 * which leaves us with the normal check.
499 */
500 accessmode = VREAD;
501 if (update ? (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
502 (mp->mnt_flag & MNT_RDONLY) == 0)
503 accessmode |= VWRITE;
504 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
505 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
506 KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp, KAUTH_ARG(accessmode));
507 VOP_UNLOCK(devvp);
508 if (error) {
509 DPRINTF("kauth returned %d", error);
510 goto fail;
511 }
512
513 #ifdef WAPBL
514 /* WAPBL can only be enabled on a r/w mount. */
515 if (((mp->mnt_flag & MNT_RDONLY) && !(mp->mnt_iflag & IMNT_WANTRDWR)) ||
516 (mp->mnt_iflag & IMNT_WANTRDONLY)) {
517 mp->mnt_flag &= ~MNT_LOG;
518 }
519 #else /* !WAPBL */
520 mp->mnt_flag &= ~MNT_LOG;
521 #endif /* !WAPBL */
522
523 if (!update) {
524 int xflags;
525
526 if (mp->mnt_flag & MNT_RDONLY)
527 xflags = FREAD;
528 else
529 xflags = FREAD | FWRITE;
530 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
531 error = VOP_OPEN(devvp, xflags, FSCRED);
532 VOP_UNLOCK(devvp);
533 if (error) {
534 DPRINTF("VOP_OPEN returned %d", error);
535 goto fail;
536 }
537 error = ffs_mountfs(devvp, mp, l);
538 if (error) {
539 DPRINTF("ffs_mountfs returned %d", error);
540 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
541 (void)VOP_CLOSE(devvp, xflags, NOCRED);
542 VOP_UNLOCK(devvp);
543 goto fail;
544 }
545
546 ump = VFSTOUFS(mp);
547 fs = ump->um_fs;
548 } else {
549 /*
550 * Update the mount.
551 */
552
553 /*
554 * The initial mount got a reference on this
555 * device, so drop the one obtained via
556 * namei(), above.
557 */
558 vrele(devvp);
559
560 ump = VFSTOUFS(mp);
561 fs = ump->um_fs;
562 if (fs->fs_ronly == 0 && (mp->mnt_iflag & IMNT_WANTRDONLY)) {
563 /*
564 * Changing from r/w to r/o
565 */
566 flags = WRITECLOSE;
567 if (mp->mnt_flag & MNT_FORCE)
568 flags |= FORCECLOSE;
569 error = ffs_flushfiles(mp, flags, l);
570 if (error)
571 return error;
572
573 error = UFS_WAPBL_BEGIN(mp);
574 if (error) {
575 DPRINTF("wapbl %d", error);
576 return error;
577 }
578
579 if (ffs_cgupdate(ump, MNT_WAIT) == 0 &&
580 fs->fs_clean & FS_WASCLEAN) {
581 if (mp->mnt_flag & MNT_SOFTDEP)
582 fs->fs_flags &= ~FS_DOSOFTDEP;
583 fs->fs_clean = FS_ISCLEAN;
584 (void) ffs_sbupdate(ump, MNT_WAIT);
585 }
586
587 UFS_WAPBL_END(mp);
588 }
589
590 #ifdef WAPBL
591 if ((mp->mnt_flag & MNT_LOG) == 0) {
592 error = ffs_wapbl_stop(mp, mp->mnt_flag & MNT_FORCE);
593 if (error) {
594 DPRINTF("ffs_wapbl_stop returned %d", error);
595 return error;
596 }
597 }
598 #endif /* WAPBL */
599
600 if (fs->fs_ronly == 0 && (mp->mnt_iflag & IMNT_WANTRDONLY)) {
601 /*
602 * Finish change from r/w to r/o
603 */
604 fs->fs_ronly = 1;
605 fs->fs_fmod = 0;
606 }
607
608 if (mp->mnt_flag & MNT_RELOAD) {
609 error = ffs_reload(mp, l->l_cred, l);
610 if (error) {
611 DPRINTF("ffs_reload returned %d", error);
612 return error;
613 }
614 }
615
616 if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
617 /*
618 * Changing from read-only to read/write
619 */
620 #ifndef QUOTA2
621 if (fs->fs_flags & FS_DOQUOTA2) {
622 ump->um_flags |= UFS_QUOTA2;
623 uprintf("%s: options QUOTA2 not enabled%s\n",
624 mp->mnt_stat.f_mntonname,
625 (mp->mnt_flag & MNT_FORCE) ? "" :
626 ", not mounting");
627 DPRINTF("ffs_quota2 %d", EINVAL);
628 return EINVAL;
629 }
630 #endif
631 fs->fs_ronly = 0;
632 fs->fs_clean <<= 1;
633 fs->fs_fmod = 1;
634 #ifdef WAPBL
635 if (fs->fs_flags & FS_DOWAPBL) {
636 const char *nm = mp->mnt_stat.f_mntonname;
637 if (!mp->mnt_wapbl_replay) {
638 printf("%s: log corrupted;"
639 " replay cancelled\n", nm);
640 return EFTYPE;
641 }
642 printf("%s: replaying log to disk\n", nm);
643 error = wapbl_replay_write(mp->mnt_wapbl_replay,
644 devvp);
645 if (error) {
646 DPRINTF("%s: wapbl_replay_write %d",
647 nm, error);
648 return error;
649 }
650 wapbl_replay_stop(mp->mnt_wapbl_replay);
651 fs->fs_clean = FS_WASCLEAN;
652 }
653 #endif /* WAPBL */
654 if (fs->fs_snapinum[0] != 0)
655 ffs_snapshot_mount(mp);
656 }
657
658 #ifdef WAPBL
659 error = ffs_wapbl_start(mp);
660 if (error) {
661 DPRINTF("ffs_wapbl_start returned %d", error);
662 return error;
663 }
664 #endif /* WAPBL */
665
666 #ifdef QUOTA2
667 if (!fs->fs_ronly) {
668 error = ffs_quota2_mount(mp);
669 if (error) {
670 DPRINTF("ffs_quota2_mount returned %d", error);
671 return error;
672 }
673 }
674 #endif
675
676 if ((mp->mnt_flag & MNT_DISCARD) && !(ump->um_discarddata))
677 ump->um_discarddata = ffs_discard_init(devvp, fs);
678
679 if (args->fspec == NULL)
680 return 0;
681 }
682
683 error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
684 UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
685 if (error == 0)
686 (void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,
687 sizeof(fs->fs_fsmnt));
688 else {
689 DPRINTF("set_statvfs_info returned %d", error);
690 }
691 fs->fs_flags &= ~FS_DOSOFTDEP;
692 if (fs->fs_fmod != 0) { /* XXX */
693 int err;
694
695 fs->fs_fmod = 0;
696 if (fs->fs_clean & FS_WASCLEAN)
697 fs->fs_time = time_second;
698 else {
699 printf("%s: file system not clean (fs_clean=%#x); "
700 "please fsck(8)\n", mp->mnt_stat.f_mntfromname,
701 fs->fs_clean);
702 printf("%s: lost blocks %" PRId64 " files %d\n",
703 mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
704 fs->fs_pendinginodes);
705 }
706 err = UFS_WAPBL_BEGIN(mp);
707 if (err == 0) {
708 (void) ffs_cgupdate(ump, MNT_WAIT);
709 UFS_WAPBL_END(mp);
710 }
711 }
712 if ((mp->mnt_flag & MNT_SOFTDEP) != 0) {
713 printf("%s: `-o softdep' is no longer supported, "
714 "consider `-o log'\n", mp->mnt_stat.f_mntfromname);
715 mp->mnt_flag &= ~MNT_SOFTDEP;
716 }
717
718 return (error);
719
720 fail:
721 vrele(devvp);
722 return (error);
723 }
724
725 /*
726 * Reload all incore data for a filesystem (used after running fsck on
727 * the root filesystem and finding things to fix). The filesystem must
728 * be mounted read-only.
729 *
730 * Things to do to update the mount:
731 * 1) invalidate all cached meta-data.
732 * 2) re-read superblock from disk.
733 * 3) re-read summary information from disk.
734 * 4) invalidate all inactive vnodes.
735 * 5) invalidate all cached file data.
736 * 6) re-read inode data for all active vnodes.
737 */
738 int
739 ffs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
740 {
741 struct vnode *vp, *devvp;
742 struct inode *ip;
743 void *space;
744 struct buf *bp;
745 struct fs *fs, *newfs;
746 int i, bsize, blks, error;
747 int32_t *lp, fs_sbsize;
748 struct ufsmount *ump;
749 daddr_t sblockloc;
750 struct vnode_iterator *marker;
751
752 if ((mp->mnt_flag & MNT_RDONLY) == 0)
753 return (EINVAL);
754
755 ump = VFSTOUFS(mp);
756
757 /*
758 * Step 1: invalidate all cached meta-data.
759 */
760 devvp = ump->um_devvp;
761 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
762 error = vinvalbuf(devvp, 0, cred, l, 0, 0);
763 VOP_UNLOCK(devvp);
764 if (error)
765 panic("%s: dirty1", __func__);
766
767 /*
768 * Step 2: re-read superblock from disk. XXX: We don't handle
769 * possibility that superblock moved. Which implies that we don't
770 * want its size to change either.
771 */
772 fs = ump->um_fs;
773 fs_sbsize = fs->fs_sbsize;
774 error = bread(devvp, fs->fs_sblockloc / DEV_BSIZE, fs_sbsize,
775 0, &bp);
776 if (error)
777 return (error);
778 newfs = kmem_alloc(fs_sbsize, KM_SLEEP);
779 memcpy(newfs, bp->b_data, fs_sbsize);
780
781 #ifdef FFS_EI
782 if (ump->um_flags & UFS_NEEDSWAP) {
783 ffs_sb_swap((struct fs *)bp->b_data, newfs);
784 newfs->fs_flags |= FS_SWAPPED;
785 } else
786 #endif
787 newfs->fs_flags &= ~FS_SWAPPED;
788
789 brelse(bp, 0);
790
791 if ((newfs->fs_magic != FS_UFS1_MAGIC) &&
792 (newfs->fs_magic != FS_UFS2_MAGIC)) {
793 kmem_free(newfs, fs_sbsize);
794 return (EIO); /* XXX needs translation */
795 }
796 if (!ffs_superblock_validate(newfs)) {
797 kmem_free(newfs, fs_sbsize);
798 return (EINVAL);
799 }
800
801 /*
802 * The current implementation doesn't handle the possibility that
803 * these values may have changed.
804 */
805 if ((newfs->fs_sbsize != fs_sbsize) ||
806 (newfs->fs_cssize != fs->fs_cssize) ||
807 (newfs->fs_contigsumsize != fs->fs_contigsumsize) ||
808 (newfs->fs_ncg != fs->fs_ncg)) {
809 kmem_free(newfs, fs_sbsize);
810 return (EINVAL);
811 }
812
813 /* Store off old fs_sblockloc for fs_oldfscompat_read. */
814 sblockloc = fs->fs_sblockloc;
815 /*
816 * Copy pointer fields back into superblock before copying in XXX
817 * new superblock. These should really be in the ufsmount. XXX
818 * Note that important parameters (eg fs_ncg) are unchanged.
819 */
820 newfs->fs_csp = fs->fs_csp;
821 newfs->fs_maxcluster = fs->fs_maxcluster;
822 newfs->fs_contigdirs = fs->fs_contigdirs;
823 newfs->fs_ronly = fs->fs_ronly;
824 newfs->fs_active = fs->fs_active;
825 memcpy(fs, newfs, (u_int)fs_sbsize);
826 kmem_free(newfs, fs_sbsize);
827
828 /*
829 * Recheck for Apple UFS filesystem.
830 */
831 ump->um_flags &= ~UFS_ISAPPLEUFS;
832 if (ffs_is_appleufs(devvp, fs)) {
833 #ifdef APPLE_UFS
834 ump->um_flags |= UFS_ISAPPLEUFS;
835 #else
836 DPRINTF("AppleUFS not supported");
837 return (EIO); /* XXX: really? */
838 #endif
839 }
840
841 if (UFS_MPISAPPLEUFS(ump)) {
842 /* see comment about NeXT below */
843 ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
844 ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
845 mp->mnt_iflag |= IMNT_DTYPE;
846 } else {
847 ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
848 ump->um_dirblksiz = UFS_DIRBLKSIZ;
849 if (ump->um_maxsymlinklen > 0)
850 mp->mnt_iflag |= IMNT_DTYPE;
851 else
852 mp->mnt_iflag &= ~IMNT_DTYPE;
853 }
854 ffs_oldfscompat_read(fs, ump, sblockloc);
855
856 mutex_enter(&ump->um_lock);
857 ump->um_maxfilesize = fs->fs_maxfilesize;
858 if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {
859 uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n",
860 mp->mnt_stat.f_mntonname, fs->fs_flags,
861 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
862 if ((mp->mnt_flag & MNT_FORCE) == 0) {
863 mutex_exit(&ump->um_lock);
864 return (EINVAL);
865 }
866 }
867 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
868 fs->fs_pendingblocks = 0;
869 fs->fs_pendinginodes = 0;
870 }
871 mutex_exit(&ump->um_lock);
872
873 ffs_statvfs(mp, &mp->mnt_stat);
874 /*
875 * Step 3: re-read summary information from disk.
876 */
877 blks = howmany(fs->fs_cssize, fs->fs_fsize);
878 space = fs->fs_csp;
879 for (i = 0; i < blks; i += fs->fs_frag) {
880 bsize = fs->fs_bsize;
881 if (i + fs->fs_frag > blks)
882 bsize = (blks - i) * fs->fs_fsize;
883 error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), bsize,
884 0, &bp);
885 if (error) {
886 return (error);
887 }
888 #ifdef FFS_EI
889 if (UFS_FSNEEDSWAP(fs))
890 ffs_csum_swap((struct csum *)bp->b_data,
891 (struct csum *)space, bsize);
892 else
893 #endif
894 memcpy(space, bp->b_data, (size_t)bsize);
895 space = (char *)space + bsize;
896 brelse(bp, 0);
897 }
898 /*
899 * We no longer know anything about clusters per cylinder group.
900 */
901 if (fs->fs_contigsumsize > 0) {
902 lp = fs->fs_maxcluster;
903 for (i = 0; i < fs->fs_ncg; i++)
904 *lp++ = fs->fs_contigsumsize;
905 }
906
907 vfs_vnode_iterator_init(mp, &marker);
908 while ((vp = vfs_vnode_iterator_next(marker, NULL, NULL))) {
909 /*
910 * Step 4: invalidate all inactive vnodes.
911 */
912 if (vrecycle(vp))
913 continue;
914 /*
915 * Step 5: invalidate all cached file data.
916 */
917 if (vn_lock(vp, LK_EXCLUSIVE)) {
918 vrele(vp);
919 continue;
920 }
921 if (vinvalbuf(vp, 0, cred, l, 0, 0))
922 panic("%s: dirty2", __func__);
923 /*
924 * Step 6: re-read inode data for all active vnodes.
925 */
926 ip = VTOI(vp);
927 error = bread(devvp, FFS_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),
928 (int)fs->fs_bsize, 0, &bp);
929 if (error) {
930 vput(vp);
931 break;
932 }
933 ffs_load_inode(bp, ip, fs, ip->i_number);
934 brelse(bp, 0);
935 vput(vp);
936 }
937 vfs_vnode_iterator_destroy(marker);
938 return (error);
939 }
940
941 /*
942 * Possible superblock locations ordered from most to least likely.
943 */
944 static const int sblock_try[] = SBLOCKSEARCH;
945
946
947 static int
948 ffs_superblock_validate(struct fs *fs)
949 {
950 int32_t i, fs_bshift = 0, fs_fshift = 0, fs_fragshift = 0, fs_frag;
951 int32_t fs_inopb;
952
953 /* Check the superblock size */
954 if (fs->fs_sbsize > SBLOCKSIZE || fs->fs_sbsize < sizeof(struct fs))
955 return 0;
956
957 /* Check the file system blocksize */
958 if (fs->fs_bsize > MAXBSIZE || fs->fs_bsize < MINBSIZE)
959 return 0;
960 if (!powerof2(fs->fs_bsize))
961 return 0;
962
963 /* Check the size of frag blocks */
964 if (!powerof2(fs->fs_fsize))
965 return 0;
966 if (fs->fs_fsize == 0)
967 return 0;
968
969 /*
970 * XXX: these values are just zero-checked to prevent obvious
971 * bugs. We need more strict checks.
972 */
973 if (fs->fs_size == 0)
974 return 0;
975 if (fs->fs_cssize == 0)
976 return 0;
977 if (fs->fs_ipg == 0)
978 return 0;
979 if (fs->fs_fpg == 0)
980 return 0;
981 if (fs->fs_ncg == 0)
982 return 0;
983 if (fs->fs_maxbpg == 0)
984 return 0;
985
986 /* Check the number of inodes per block */
987 if (fs->fs_magic == FS_UFS1_MAGIC)
988 fs_inopb = fs->fs_bsize / sizeof(struct ufs1_dinode);
989 else /* fs->fs_magic == FS_UFS2_MAGIC */
990 fs_inopb = fs->fs_bsize / sizeof(struct ufs2_dinode);
991 if (fs->fs_inopb != fs_inopb)
992 return 0;
993
994 /* Block size cannot be smaller than fragment size */
995 if (fs->fs_bsize < fs->fs_fsize)
996 return 0;
997
998 /* Compute fs_bshift and ensure it is consistent */
999 for (i = fs->fs_bsize; i > 1; i >>= 1)
1000 fs_bshift++;
1001 if (fs->fs_bshift != fs_bshift)
1002 return 0;
1003
1004 /* Compute fs_fshift and ensure it is consistent */
1005 for (i = fs->fs_fsize; i > 1; i >>= 1)
1006 fs_fshift++;
1007 if (fs->fs_fshift != fs_fshift)
1008 return 0;
1009
1010 /* Compute fs_fragshift and ensure it is consistent */
1011 for (i = fs->fs_frag; i > 1; i >>= 1)
1012 fs_fragshift++;
1013 if (fs->fs_fragshift != fs_fragshift)
1014 return 0;
1015
1016 /* Check the masks */
1017 if (fs->fs_bmask != ~(fs->fs_bsize - 1))
1018 return 0;
1019 if (fs->fs_fmask != ~(fs->fs_fsize - 1))
1020 return 0;
1021
1022 /*
1023 * Now that the shifts and masks are sanitized, we can use the ffs_ API.
1024 */
1025
1026 /* Check the number of frag blocks */
1027 if ((fs_frag = ffs_numfrags(fs, fs->fs_bsize)) > MAXFRAG)
1028 return 0;
1029 if (fs->fs_frag != fs_frag)
1030 return 0;
1031
1032 /* Check the size of cylinder groups */
1033 if ((fs->fs_cgsize < sizeof(struct cg)) ||
1034 (fs->fs_cgsize > fs->fs_bsize))
1035 return 0;
1036
1037 return 1;
1038 }
1039
1040 static int
1041 ffs_is_appleufs(struct vnode *devvp, struct fs *fs)
1042 {
1043 struct dkwedge_info dkw;
1044 int ret = 0;
1045
1046 /*
1047 * First check to see if this is tagged as an Apple UFS filesystem
1048 * in the disklabel.
1049 */
1050 if (getdiskinfo(devvp, &dkw) == 0 &&
1051 strcmp(dkw.dkw_ptype, DKW_PTYPE_APPLEUFS) == 0)
1052 ret = 1;
1053 #ifdef APPLE_UFS
1054 else {
1055 struct appleufslabel *applefs;
1056 struct buf *bp;
1057 daddr_t blkno = APPLEUFS_LABEL_OFFSET / DEV_BSIZE;
1058 int error;
1059
1060 /*
1061 * Manually look for an Apple UFS label, and if a valid one
1062 * is found, then treat it like an Apple UFS filesystem anyway.
1063 */
1064 error = bread(devvp, blkno, APPLEUFS_LABEL_SIZE, 0, &bp);
1065 if (error) {
1066 DPRINTF("bread@0x%jx returned %d", (intmax_t)blkno, error);
1067 return 0;
1068 }
1069 applefs = (struct appleufslabel *)bp->b_data;
1070 error = ffs_appleufs_validate(fs->fs_fsmnt, applefs, NULL);
1071 if (error == 0)
1072 ret = 1;
1073 brelse(bp, 0);
1074 }
1075 #endif
1076
1077 return ret;
1078 }
1079
1080 /*
1081 * Common code for mount and mountroot
1082 */
1083 int
1084 ffs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
1085 {
1086 struct ufsmount *ump = NULL;
1087 struct buf *bp = NULL;
1088 struct fs *fs = NULL;
1089 dev_t dev;
1090 void *space;
1091 daddr_t sblockloc = 0;
1092 int blks, fstype = 0;
1093 int error, i, bsize, ronly, bset = 0;
1094 #ifdef FFS_EI
1095 int needswap = 0; /* keep gcc happy */
1096 #endif
1097 int32_t *lp;
1098 kauth_cred_t cred;
1099 u_int32_t allocsbsize, fs_sbsize = 0;
1100
1101 dev = devvp->v_rdev;
1102
1103 cred = l ? l->l_cred : NOCRED;
1104
1105 /* Flush out any old buffers remaining from a previous use. */
1106 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
1107 error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
1108 VOP_UNLOCK(devvp);
1109 if (error) {
1110 DPRINTF("vinvalbuf returned %d", error);
1111 return error;
1112 }
1113
1114 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
1115
1116 ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
1117 mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE);
1118 error = ffs_snapshot_init(ump);
1119 if (error) {
1120 DPRINTF("ffs_snapshot_init returned %d", error);
1121 goto out;
1122 }
1123 ump->um_ops = &ffs_ufsops;
1124
1125 #ifdef WAPBL
1126 sbagain:
1127 #endif
1128 /*
1129 * Try reading the superblock in each of its possible locations.
1130 */
1131 for (i = 0; ; i++) {
1132 daddr_t fs_sblockloc;
1133
1134 if (bp != NULL) {
1135 brelse(bp, BC_NOCACHE);
1136 bp = NULL;
1137 }
1138 if (sblock_try[i] == -1) {
1139 DPRINTF("no superblock found");
1140 error = EINVAL;
1141 fs = NULL;
1142 goto out;
1143 }
1144
1145 error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE,
1146 0, &bp);
1147 if (error) {
1148 DPRINTF("bread@0x%x returned %d",
1149 sblock_try[i] / DEV_BSIZE, error);
1150 fs = NULL;
1151 goto out;
1152 }
1153 fs = (struct fs *)bp->b_data;
1154
1155 sblockloc = sblock_try[i];
1156 DPRINTF("fs_magic 0x%x", fs->fs_magic);
1157
1158 /*
1159 * Swap: here, we swap fs->fs_sbsize in order to get the correct
1160 * size to read the superblock. Once read, we swap the whole
1161 * superblock structure.
1162 */
1163 if (fs->fs_magic == FS_UFS1_MAGIC) {
1164 fs_sbsize = fs->fs_sbsize;
1165 fstype = UFS1;
1166 #ifdef FFS_EI
1167 needswap = 0;
1168 } else if (fs->fs_magic == FS_UFS1_MAGIC_SWAPPED) {
1169 fs_sbsize = bswap32(fs->fs_sbsize);
1170 fstype = UFS1;
1171 needswap = 1;
1172 #endif
1173 } else if (fs->fs_magic == FS_UFS2_MAGIC) {
1174 fs_sbsize = fs->fs_sbsize;
1175 fstype = UFS2;
1176 #ifdef FFS_EI
1177 needswap = 0;
1178 } else if (fs->fs_magic == FS_UFS2_MAGIC_SWAPPED) {
1179 fs_sbsize = bswap32(fs->fs_sbsize);
1180 fstype = UFS2;
1181 needswap = 1;
1182 #endif
1183 } else
1184 continue;
1185
1186 /* fs->fs_sblockloc isn't defined for old filesystems */
1187 if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) {
1188 if (sblockloc == SBLOCK_UFS2)
1189 /*
1190 * This is likely to be the first alternate
1191 * in a filesystem with 64k blocks.
1192 * Don't use it.
1193 */
1194 continue;
1195 fs_sblockloc = sblockloc;
1196 } else {
1197 fs_sblockloc = fs->fs_sblockloc;
1198 #ifdef FFS_EI
1199 if (needswap)
1200 fs_sblockloc = bswap64(fs_sblockloc);
1201 #endif
1202 }
1203
1204 /* Check we haven't found an alternate superblock */
1205 if (fs_sblockloc != sblockloc)
1206 continue;
1207
1208 /* Check the superblock size */
1209 if (fs_sbsize > SBLOCKSIZE || fs_sbsize < sizeof(struct fs))
1210 continue;
1211 fs = kmem_alloc((u_long)fs_sbsize, KM_SLEEP);
1212 memcpy(fs, bp->b_data, fs_sbsize);
1213
1214 /* Swap the whole superblock structure, if necessary. */
1215 #ifdef FFS_EI
1216 if (needswap) {
1217 ffs_sb_swap((struct fs*)bp->b_data, fs);
1218 fs->fs_flags |= FS_SWAPPED;
1219 } else
1220 #endif
1221 fs->fs_flags &= ~FS_SWAPPED;
1222
1223 /*
1224 * Now that everything is swapped, the superblock is ready to
1225 * be sanitized.
1226 */
1227 if (!ffs_superblock_validate(fs)) {
1228 kmem_free(fs, fs_sbsize);
1229 continue;
1230 }
1231
1232 /* Ok seems to be a good superblock */
1233 break;
1234 }
1235
1236 ump->um_fs = fs;
1237
1238 #ifdef WAPBL
1239 if ((mp->mnt_wapbl_replay == 0) && (fs->fs_flags & FS_DOWAPBL)) {
1240 error = ffs_wapbl_replay_start(mp, fs, devvp);
1241 if (error && (mp->mnt_flag & MNT_FORCE) == 0) {
1242 DPRINTF("ffs_wapbl_replay_start returned %d", error);
1243 goto out;
1244 }
1245 if (!error) {
1246 if (!ronly) {
1247 /* XXX fsmnt may be stale. */
1248 printf("%s: replaying log to disk\n",
1249 fs->fs_fsmnt);
1250 error = wapbl_replay_write(mp->mnt_wapbl_replay,
1251 devvp);
1252 if (error) {
1253 DPRINTF("wapbl_replay_write returned %d",
1254 error);
1255 goto out;
1256 }
1257 wapbl_replay_stop(mp->mnt_wapbl_replay);
1258 fs->fs_clean = FS_WASCLEAN;
1259 } else {
1260 /* XXX fsmnt may be stale */
1261 printf("%s: replaying log to memory\n",
1262 fs->fs_fsmnt);
1263 }
1264
1265 /* Force a re-read of the superblock */
1266 brelse(bp, BC_INVAL);
1267 bp = NULL;
1268 kmem_free(fs, fs_sbsize);
1269 fs = NULL;
1270 goto sbagain;
1271 }
1272 }
1273 #else /* !WAPBL */
1274 if ((fs->fs_flags & FS_DOWAPBL) && (mp->mnt_flag & MNT_FORCE) == 0) {
1275 error = EPERM;
1276 DPRINTF("no force %d", error);
1277 goto out;
1278 }
1279 #endif /* !WAPBL */
1280
1281 ffs_oldfscompat_read(fs, ump, sblockloc);
1282 ump->um_maxfilesize = fs->fs_maxfilesize;
1283
1284 if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {
1285 uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n",
1286 mp->mnt_stat.f_mntonname, fs->fs_flags,
1287 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
1288 if ((mp->mnt_flag & MNT_FORCE) == 0) {
1289 error = EINVAL;
1290 DPRINTF("no force %d", error);
1291 goto out;
1292 }
1293 }
1294
1295 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
1296 fs->fs_pendingblocks = 0;
1297 fs->fs_pendinginodes = 0;
1298 }
1299
1300 ump->um_fstype = fstype;
1301 if (fs->fs_sbsize < SBLOCKSIZE)
1302 brelse(bp, BC_INVAL);
1303 else
1304 brelse(bp, 0);
1305 bp = NULL;
1306
1307 if (ffs_is_appleufs(devvp, fs)) {
1308 #ifdef APPLE_UFS
1309 ump->um_flags |= UFS_ISAPPLEUFS;
1310 #else
1311 DPRINTF("AppleUFS not supported");
1312 error = EINVAL;
1313 goto out;
1314 #endif
1315 }
1316
1317 #if 0
1318 /*
1319 * XXX This code changes the behaviour of mounting dirty filesystems, to
1320 * XXX require "mount -f ..." to mount them. This doesn't match what
1321 * XXX mount(8) describes and is disabled for now.
1322 */
1323 /*
1324 * If the file system is not clean, don't allow it to be mounted
1325 * unless MNT_FORCE is specified. (Note: MNT_FORCE is always set
1326 * for the root file system.)
1327 */
1328 if (fs->fs_flags & FS_DOWAPBL) {
1329 /*
1330 * wapbl normally expects to be FS_WASCLEAN when the FS_DOWAPBL
1331 * bit is set, although there's a window in unmount where it
1332 * could be FS_ISCLEAN
1333 */
1334 if ((mp->mnt_flag & MNT_FORCE) == 0 &&
1335 (fs->fs_clean & (FS_WASCLEAN | FS_ISCLEAN)) == 0) {
1336 error = EPERM;
1337 goto out;
1338 }
1339 } else
1340 if ((fs->fs_clean & FS_ISCLEAN) == 0 &&
1341 (mp->mnt_flag & MNT_FORCE) == 0) {
1342 error = EPERM;
1343 goto out;
1344 }
1345 #endif
1346
1347 /*
1348 * Verify that we can access the last block in the fs
1349 * if we're mounting read/write.
1350 */
1351 if (!ronly) {
1352 error = bread(devvp, FFS_FSBTODB(fs, fs->fs_size - 1),
1353 fs->fs_fsize, 0, &bp);
1354 if (error) {
1355 DPRINTF("bread@0x%jx returned %d",
1356 (intmax_t)FFS_FSBTODB(fs, fs->fs_size - 1),
1357 error);
1358 bset = BC_INVAL;
1359 goto out;
1360 }
1361 if (bp->b_bcount != fs->fs_fsize) {
1362 DPRINTF("bcount %x != fsize %x", bp->b_bcount,
1363 fs->fs_fsize);
1364 error = EINVAL;
1365 bset = BC_INVAL;
1366 goto out;
1367 }
1368 brelse(bp, BC_INVAL);
1369 bp = NULL;
1370 }
1371
1372 fs->fs_ronly = ronly;
1373 /* Don't bump fs_clean if we're replaying journal */
1374 if (!((fs->fs_flags & FS_DOWAPBL) && (fs->fs_clean & FS_WASCLEAN))) {
1375 if (ronly == 0) {
1376 fs->fs_clean <<= 1;
1377 fs->fs_fmod = 1;
1378 }
1379 }
1380
1381 bsize = fs->fs_cssize;
1382 blks = howmany(bsize, fs->fs_fsize);
1383 if (fs->fs_contigsumsize > 0)
1384 bsize += fs->fs_ncg * sizeof(int32_t);
1385 bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
1386 allocsbsize = bsize;
1387 space = kmem_alloc((u_long)allocsbsize, KM_SLEEP);
1388 fs->fs_csp = space;
1389
1390 for (i = 0; i < blks; i += fs->fs_frag) {
1391 bsize = fs->fs_bsize;
1392 if (i + fs->fs_frag > blks)
1393 bsize = (blks - i) * fs->fs_fsize;
1394 error = bread(devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i), bsize,
1395 0, &bp);
1396 if (error) {
1397 DPRINTF("bread@0x%jx %d",
1398 (intmax_t)FFS_FSBTODB(fs, fs->fs_csaddr + i),
1399 error);
1400 goto out1;
1401 }
1402 #ifdef FFS_EI
1403 if (needswap)
1404 ffs_csum_swap((struct csum *)bp->b_data,
1405 (struct csum *)space, bsize);
1406 else
1407 #endif
1408 memcpy(space, bp->b_data, (u_int)bsize);
1409
1410 space = (char *)space + bsize;
1411 brelse(bp, 0);
1412 bp = NULL;
1413 }
1414 if (fs->fs_contigsumsize > 0) {
1415 fs->fs_maxcluster = lp = space;
1416 for (i = 0; i < fs->fs_ncg; i++)
1417 *lp++ = fs->fs_contigsumsize;
1418 space = lp;
1419 }
1420 bsize = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
1421 fs->fs_contigdirs = space;
1422 space = (char *)space + bsize;
1423 memset(fs->fs_contigdirs, 0, bsize);
1424
1425 /* Compatibility for old filesystems - XXX */
1426 if (fs->fs_avgfilesize <= 0)
1427 fs->fs_avgfilesize = AVFILESIZ;
1428 if (fs->fs_avgfpdir <= 0)
1429 fs->fs_avgfpdir = AFPDIR;
1430 fs->fs_active = NULL;
1431
1432 mp->mnt_data = ump;
1433 mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
1434 mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_FFS);
1435 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
1436 mp->mnt_stat.f_namemax = FFS_MAXNAMLEN;
1437 if (UFS_MPISAPPLEUFS(ump)) {
1438 /* NeXT used to keep short symlinks in the inode even
1439 * when using FS_42INODEFMT. In that case fs->fs_maxsymlinklen
1440 * is probably -1, but we still need to be able to identify
1441 * short symlinks.
1442 */
1443 ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
1444 ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
1445 mp->mnt_iflag |= IMNT_DTYPE;
1446 } else {
1447 ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
1448 ump->um_dirblksiz = UFS_DIRBLKSIZ;
1449 if (ump->um_maxsymlinklen > 0)
1450 mp->mnt_iflag |= IMNT_DTYPE;
1451 else
1452 mp->mnt_iflag &= ~IMNT_DTYPE;
1453 }
1454 mp->mnt_fs_bshift = fs->fs_bshift;
1455 mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */
1456 mp->mnt_flag |= MNT_LOCAL;
1457 mp->mnt_iflag |= IMNT_MPSAFE | IMNT_CAN_RWTORO;
1458 #ifdef FFS_EI
1459 if (needswap)
1460 ump->um_flags |= UFS_NEEDSWAP;
1461 #endif
1462 ump->um_mountp = mp;
1463 ump->um_dev = dev;
1464 ump->um_devvp = devvp;
1465 ump->um_nindir = fs->fs_nindir;
1466 ump->um_lognindir = ffs(fs->fs_nindir) - 1;
1467 ump->um_bptrtodb = fs->fs_fshift - DEV_BSHIFT;
1468 ump->um_seqinc = fs->fs_frag;
1469 for (i = 0; i < MAXQUOTAS; i++)
1470 ump->um_quotas[i] = NULLVP;
1471 spec_node_setmountedfs(devvp, mp);
1472
1473 /* Before we start WAPBL or touch any snapshots, adjust maxphys */
1474 ufs_update_maxphys(mp);
1475
1476 if (ronly == 0 && fs->fs_snapinum[0] != 0)
1477 ffs_snapshot_mount(mp);
1478
1479 #ifdef WAPBL
1480 if (!ronly) {
1481 KDASSERT(fs->fs_ronly == 0);
1482 /*
1483 * ffs_wapbl_start() needs mp->mnt_stat initialised if it
1484 * needs to create a new log file in-filesystem.
1485 */
1486 error = ffs_statvfs(mp, &mp->mnt_stat);
1487 if (error) {
1488 DPRINTF("ffs_statvfs returned %d", error);
1489 goto out1;
1490 }
1491
1492 error = ffs_wapbl_start(mp);
1493 if (error) {
1494 DPRINTF("ffs_wapbl_start returned %d", error);
1495 goto out1;
1496 }
1497 }
1498 #endif /* WAPBL */
1499 if (ronly == 0) {
1500 #ifdef QUOTA2
1501 error = ffs_quota2_mount(mp);
1502 if (error) {
1503 DPRINTF("ffs_quota2_mount returned %d", error);
1504 goto out1;
1505 }
1506 #else
1507 if (fs->fs_flags & FS_DOQUOTA2) {
1508 ump->um_flags |= UFS_QUOTA2;
1509 uprintf("%s: options QUOTA2 not enabled%s\n",
1510 mp->mnt_stat.f_mntonname,
1511 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
1512 if ((mp->mnt_flag & MNT_FORCE) == 0) {
1513 error = EINVAL;
1514 DPRINTF("quota disabled %d", error);
1515 goto out1;
1516 }
1517 }
1518 #endif
1519 }
1520
1521 if (mp->mnt_flag & MNT_DISCARD)
1522 ump->um_discarddata = ffs_discard_init(devvp, fs);
1523
1524 return (0);
1525 out1:
1526 kmem_free(fs->fs_csp, allocsbsize);
1527 out:
1528 #ifdef WAPBL
1529 if (mp->mnt_wapbl_replay) {
1530 wapbl_replay_stop(mp->mnt_wapbl_replay);
1531 wapbl_replay_free(mp->mnt_wapbl_replay);
1532 mp->mnt_wapbl_replay = 0;
1533 }
1534 #endif
1535
1536 if (fs)
1537 kmem_free(fs, fs->fs_sbsize);
1538 spec_node_setmountedfs(devvp, NULL);
1539 if (bp)
1540 brelse(bp, bset);
1541 if (ump) {
1542 if (ump->um_oldfscompat)
1543 kmem_free(ump->um_oldfscompat, 512 + 3*sizeof(int32_t));
1544 mutex_destroy(&ump->um_lock);
1545 kmem_free(ump, sizeof(*ump));
1546 mp->mnt_data = NULL;
1547 }
1548 return (error);
1549 }
1550
1551 /*
1552 * Sanity checks for loading old filesystem superblocks.
1553 * See ffs_oldfscompat_write below for unwound actions.
1554 *
1555 * XXX - Parts get retired eventually.
1556 * Unfortunately new bits get added.
1557 */
1558 static void
1559 ffs_oldfscompat_read(struct fs *fs, struct ufsmount *ump, daddr_t sblockloc)
1560 {
1561 off_t maxfilesize;
1562 int32_t *extrasave;
1563
1564 if ((fs->fs_magic != FS_UFS1_MAGIC) ||
1565 (fs->fs_old_flags & FS_FLAGS_UPDATED))
1566 return;
1567
1568 if (!ump->um_oldfscompat)
1569 ump->um_oldfscompat = kmem_alloc(512 + 3*sizeof(int32_t),
1570 KM_SLEEP);
1571
1572 memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512);
1573 extrasave = ump->um_oldfscompat;
1574 extrasave += 512/sizeof(int32_t);
1575 extrasave[0] = fs->fs_old_npsect;
1576 extrasave[1] = fs->fs_old_interleave;
1577 extrasave[2] = fs->fs_old_trackskew;
1578
1579 /* These fields will be overwritten by their
1580 * original values in fs_oldfscompat_write, so it is harmless
1581 * to modify them here.
1582 */
1583 fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
1584 fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
1585 fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
1586 fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
1587
1588 fs->fs_maxbsize = fs->fs_bsize;
1589 fs->fs_time = fs->fs_old_time;
1590 fs->fs_size = fs->fs_old_size;
1591 fs->fs_dsize = fs->fs_old_dsize;
1592 fs->fs_csaddr = fs->fs_old_csaddr;
1593 fs->fs_sblockloc = sblockloc;
1594
1595 fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL);
1596
1597 if (fs->fs_old_postblformat == FS_42POSTBLFMT) {
1598 fs->fs_old_nrpos = 8;
1599 fs->fs_old_npsect = fs->fs_old_nsect;
1600 fs->fs_old_interleave = 1;
1601 fs->fs_old_trackskew = 0;
1602 }
1603
1604 if (fs->fs_magic == FS_UFS1_MAGIC &&
1605 fs->fs_old_inodefmt < FS_44INODEFMT) {
1606 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
1607 fs->fs_qbmask = ~fs->fs_bmask;
1608 fs->fs_qfmask = ~fs->fs_fmask;
1609 }
1610
1611 maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;
1612 if (fs->fs_maxfilesize > maxfilesize)
1613 fs->fs_maxfilesize = maxfilesize;
1614
1615 /* Compatibility for old filesystems */
1616 if (fs->fs_avgfilesize <= 0)
1617 fs->fs_avgfilesize = AVFILESIZ;
1618 if (fs->fs_avgfpdir <= 0)
1619 fs->fs_avgfpdir = AFPDIR;
1620
1621 #if 0
1622 if (bigcgs) {
1623 fs->fs_save_cgsize = fs->fs_cgsize;
1624 fs->fs_cgsize = fs->fs_bsize;
1625 }
1626 #endif
1627 }
1628
1629 /*
1630 * Unwinding superblock updates for old filesystems.
1631 * See ffs_oldfscompat_read above for details.
1632 *
1633 * XXX - Parts get retired eventually.
1634 * Unfortunately new bits get added.
1635 */
1636 static void
1637 ffs_oldfscompat_write(struct fs *fs, struct ufsmount *ump)
1638 {
1639 int32_t *extrasave;
1640
1641 if ((fs->fs_magic != FS_UFS1_MAGIC) ||
1642 (fs->fs_old_flags & FS_FLAGS_UPDATED))
1643 return;
1644
1645 fs->fs_old_time = fs->fs_time;
1646 fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
1647 fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
1648 fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
1649 fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
1650 fs->fs_old_flags = fs->fs_flags;
1651
1652 #if 0
1653 if (bigcgs) {
1654 fs->fs_cgsize = fs->fs_save_cgsize;
1655 }
1656 #endif
1657
1658 memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512);
1659 extrasave = ump->um_oldfscompat;
1660 extrasave += 512/sizeof(int32_t);
1661 fs->fs_old_npsect = extrasave[0];
1662 fs->fs_old_interleave = extrasave[1];
1663 fs->fs_old_trackskew = extrasave[2];
1664
1665 }
1666
1667 /*
1668 * unmount vfs operation
1669 */
1670 int
1671 ffs_unmount(struct mount *mp, int mntflags)
1672 {
1673 struct lwp *l = curlwp;
1674 struct ufsmount *ump = VFSTOUFS(mp);
1675 struct fs *fs = ump->um_fs;
1676 int error, flags;
1677 u_int32_t bsize;
1678 #ifdef WAPBL
1679 extern int doforce;
1680 #endif
1681
1682 if (ump->um_discarddata) {
1683 ffs_discard_finish(ump->um_discarddata, mntflags);
1684 ump->um_discarddata = NULL;
1685 }
1686
1687 flags = 0;
1688 if (mntflags & MNT_FORCE)
1689 flags |= FORCECLOSE;
1690 if ((error = ffs_flushfiles(mp, flags, l)) != 0)
1691 return (error);
1692 error = UFS_WAPBL_BEGIN(mp);
1693 if (error == 0)
1694 if (fs->fs_ronly == 0 &&
1695 ffs_cgupdate(ump, MNT_WAIT) == 0 &&
1696 fs->fs_clean & FS_WASCLEAN) {
1697 fs->fs_clean = FS_ISCLEAN;
1698 fs->fs_fmod = 0;
1699 (void) ffs_sbupdate(ump, MNT_WAIT);
1700 }
1701 if (error == 0)
1702 UFS_WAPBL_END(mp);
1703 #ifdef WAPBL
1704 KASSERT(!(mp->mnt_wapbl_replay && mp->mnt_wapbl));
1705 if (mp->mnt_wapbl_replay) {
1706 KDASSERT(fs->fs_ronly);
1707 wapbl_replay_stop(mp->mnt_wapbl_replay);
1708 wapbl_replay_free(mp->mnt_wapbl_replay);
1709 mp->mnt_wapbl_replay = 0;
1710 }
1711 error = ffs_wapbl_stop(mp, doforce && (mntflags & MNT_FORCE));
1712 if (error) {
1713 return error;
1714 }
1715 #endif /* WAPBL */
1716
1717 if (ump->um_devvp->v_type != VBAD)
1718 spec_node_setmountedfs(ump->um_devvp, NULL);
1719 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1720 (void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD | FWRITE,
1721 NOCRED);
1722 vput(ump->um_devvp);
1723
1724 bsize = fs->fs_cssize;
1725 if (fs->fs_contigsumsize > 0)
1726 bsize += fs->fs_ncg * sizeof(int32_t);
1727 bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
1728 kmem_free(fs->fs_csp, bsize);
1729
1730 kmem_free(fs, fs->fs_sbsize);
1731 if (ump->um_oldfscompat != NULL)
1732 kmem_free(ump->um_oldfscompat, 512 + 3*sizeof(int32_t));
1733 mutex_destroy(&ump->um_lock);
1734 ffs_snapshot_fini(ump);
1735 kmem_free(ump, sizeof(*ump));
1736 mp->mnt_data = NULL;
1737 mp->mnt_flag &= ~MNT_LOCAL;
1738 return (0);
1739 }
1740
1741 /*
1742 * Flush out all the files in a filesystem.
1743 */
1744 int
1745 ffs_flushfiles(struct mount *mp, int flags, struct lwp *l)
1746 {
1747 extern int doforce;
1748 struct ufsmount *ump;
1749 int error;
1750
1751 if (!doforce)
1752 flags &= ~FORCECLOSE;
1753 ump = VFSTOUFS(mp);
1754 #ifdef QUOTA
1755 if ((error = quota1_umount(mp, flags)) != 0)
1756 return (error);
1757 #endif
1758 #ifdef QUOTA2
1759 if ((error = quota2_umount(mp, flags)) != 0)
1760 return (error);
1761 #endif
1762 #ifdef UFS_EXTATTR
1763 if (ump->um_fstype == UFS1) {
1764 if (ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_STARTED)
1765 ufs_extattr_stop(mp, l);
1766 if (ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_INITIALIZED)
1767 ufs_extattr_uepm_destroy(&ump->um_extattr);
1768 mp->mnt_flag &= ~MNT_EXTATTR;
1769 }
1770 #endif
1771 if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0)
1772 return (error);
1773 ffs_snapshot_unmount(mp);
1774 /*
1775 * Flush all the files.
1776 */
1777 error = vflush(mp, NULLVP, flags);
1778 if (error)
1779 return (error);
1780 /*
1781 * Flush filesystem metadata.
1782 */
1783 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1784 error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0);
1785 VOP_UNLOCK(ump->um_devvp);
1786 if (flags & FORCECLOSE) /* XXXDBJ */
1787 error = 0;
1788
1789 #ifdef WAPBL
1790 if (error)
1791 return error;
1792 if (mp->mnt_wapbl) {
1793 error = wapbl_flush(mp->mnt_wapbl, 1);
1794 if (flags & FORCECLOSE)
1795 error = 0;
1796 }
1797 #endif
1798
1799 return (error);
1800 }
1801
1802 /*
1803 * Get file system statistics.
1804 */
1805 int
1806 ffs_statvfs(struct mount *mp, struct statvfs *sbp)
1807 {
1808 struct ufsmount *ump;
1809 struct fs *fs;
1810
1811 ump = VFSTOUFS(mp);
1812 fs = ump->um_fs;
1813 mutex_enter(&ump->um_lock);
1814 sbp->f_bsize = fs->fs_bsize;
1815 sbp->f_frsize = fs->fs_fsize;
1816 sbp->f_iosize = fs->fs_bsize;
1817 sbp->f_blocks = fs->fs_dsize;
1818 sbp->f_bfree = ffs_blkstofrags(fs, fs->fs_cstotal.cs_nbfree) +
1819 fs->fs_cstotal.cs_nffree + FFS_DBTOFSB(fs, fs->fs_pendingblocks);
1820 sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t)
1821 fs->fs_minfree) / (u_int64_t) 100;
1822 if (sbp->f_bfree > sbp->f_bresvd)
1823 sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
1824 else
1825 sbp->f_bavail = 0;
1826 sbp->f_files = fs->fs_ncg * fs->fs_ipg - UFS_ROOTINO;
1827 sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
1828 sbp->f_favail = sbp->f_ffree;
1829 sbp->f_fresvd = 0;
1830 mutex_exit(&ump->um_lock);
1831 copy_statvfs_info(sbp, mp);
1832
1833 return (0);
1834 }
1835
1836 struct ffs_sync_ctx {
1837 int waitfor;
1838 };
1839
1840 static bool
1841 ffs_sync_selector(void *cl, struct vnode *vp)
1842 {
1843 struct ffs_sync_ctx *c = cl;
1844 struct inode *ip;
1845
1846 KASSERT(mutex_owned(vp->v_interlock));
1847
1848 ip = VTOI(vp);
1849 /*
1850 * Skip the vnode/inode if inaccessible.
1851 */
1852 if (ip == NULL || vp->v_type == VNON)
1853 return false;
1854
1855 /*
1856 * We deliberately update inode times here. This will
1857 * prevent a massive queue of updates accumulating, only
1858 * to be handled by a call to unmount.
1859 *
1860 * XXX It would be better to have the syncer trickle these
1861 * out. Adjustment needed to allow registering vnodes for
1862 * sync when the vnode is clean, but the inode dirty. Or
1863 * have ufs itself trickle out inode updates.
1864 *
1865 * If doing a lazy sync, we don't care about metadata or
1866 * data updates, because they are handled by each vnode's
1867 * synclist entry. In this case we are only interested in
1868 * writing back modified inodes.
1869 */
1870 if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE |
1871 IN_MODIFY | IN_MODIFIED | IN_ACCESSED)) == 0 &&
1872 (c->waitfor == MNT_LAZY || (LIST_EMPTY(&vp->v_dirtyblkhd) &&
1873 UVM_OBJ_IS_CLEAN(&vp->v_uobj))))
1874 return false;
1875
1876 return true;
1877 }
1878
1879 /*
1880 * Go through the disk queues to initiate sandbagged IO;
1881 * go through the inodes to write those that have been modified;
1882 * initiate the writing of the super block if it has been modified.
1883 *
1884 * Note: we are always called with the filesystem marked `MPBUSY'.
1885 */
1886 int
1887 ffs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
1888 {
1889 struct vnode *vp;
1890 struct ufsmount *ump = VFSTOUFS(mp);
1891 struct fs *fs;
1892 struct vnode_iterator *marker;
1893 int error, allerror = 0;
1894 struct ffs_sync_ctx ctx;
1895
1896 fs = ump->um_fs;
1897 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
1898 panic("%s: rofs mod, fs=%s", __func__, fs->fs_fsmnt);
1899 }
1900
1901 /*
1902 * Write back each (modified) inode.
1903 */
1904 vfs_vnode_iterator_init(mp, &marker);
1905
1906 ctx.waitfor = waitfor;
1907 while ((vp = vfs_vnode_iterator_next(marker, ffs_sync_selector, &ctx)))
1908 {
1909 error = vn_lock(vp,
1910 LK_EXCLUSIVE | (waitfor == MNT_LAZY ? LK_NOWAIT : 0));
1911 if (error) {
1912 vrele(vp);
1913 continue;
1914 }
1915 if (waitfor == MNT_LAZY) {
1916 error = UFS_WAPBL_BEGIN(vp->v_mount);
1917 if (!error) {
1918 error = ffs_update(vp, NULL, NULL,
1919 UPDATE_CLOSE);
1920 UFS_WAPBL_END(vp->v_mount);
1921 }
1922 } else {
1923 error = VOP_FSYNC(vp, cred, FSYNC_NOLOG |
1924 (waitfor == MNT_WAIT ? FSYNC_WAIT : 0), 0, 0);
1925 }
1926 if (error)
1927 allerror = error;
1928 vput(vp);
1929 }
1930 vfs_vnode_iterator_destroy(marker);
1931
1932 /*
1933 * Force stale file system control information to be flushed.
1934 */
1935 if (waitfor != MNT_LAZY && (ump->um_devvp->v_numoutput > 0 ||
1936 !LIST_EMPTY(&ump->um_devvp->v_dirtyblkhd))) {
1937 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1938 if ((error = VOP_FSYNC(ump->um_devvp, cred,
1939 (waitfor == MNT_WAIT ? FSYNC_WAIT : 0) | FSYNC_NOLOG,
1940 0, 0)) != 0)
1941 allerror = error;
1942 VOP_UNLOCK(ump->um_devvp);
1943 }
1944 #if defined(QUOTA) || defined(QUOTA2)
1945 qsync(mp);
1946 #endif
1947 /*
1948 * Write back modified superblock.
1949 */
1950 if (fs->fs_fmod != 0) {
1951 fs->fs_fmod = 0;
1952 fs->fs_time = time_second;
1953 error = UFS_WAPBL_BEGIN(mp);
1954 if (error)
1955 allerror = error;
1956 else {
1957 if ((error = ffs_cgupdate(ump, waitfor)))
1958 allerror = error;
1959 UFS_WAPBL_END(mp);
1960 }
1961 }
1962
1963 #ifdef WAPBL
1964 if (mp->mnt_wapbl) {
1965 error = wapbl_flush(mp->mnt_wapbl, (waitfor == MNT_WAIT));
1966 if (error)
1967 allerror = error;
1968 }
1969 #endif
1970
1971 return (allerror);
1972 }
1973
1974 /*
1975 * Load inode from disk and initialize vnode.
1976 */
1977 static int
1978 ffs_init_vnode(struct ufsmount *ump, struct vnode *vp, ino_t ino)
1979 {
1980 struct fs *fs;
1981 struct inode *ip;
1982 struct buf *bp;
1983 int error;
1984
1985 fs = ump->um_fs;
1986
1987 /* Read in the disk contents for the inode. */
1988 error = bread(ump->um_devvp, FFS_FSBTODB(fs, ino_to_fsba(fs, ino)),
1989 (int)fs->fs_bsize, 0, &bp);
1990 if (error)
1991 return error;
1992
1993 /* Allocate and initialize inode. */
1994 ip = pool_cache_get(ffs_inode_cache, PR_WAITOK);
1995 memset(ip, 0, sizeof(struct inode));
1996 ip->i_ump = ump;
1997 ip->i_fs = fs;
1998 ip->i_dev = ump->um_dev;
1999 ip->i_number = ino;
2000 if (ump->um_fstype == UFS1)
2001 ip->i_din.ffs1_din = pool_cache_get(ffs_dinode1_cache,
2002 PR_WAITOK);
2003 else
2004 ip->i_din.ffs2_din = pool_cache_get(ffs_dinode2_cache,
2005 PR_WAITOK);
2006 ffs_load_inode(bp, ip, fs, ino);
2007 brelse(bp, 0);
2008 ip->i_vnode = vp;
2009 #if defined(QUOTA) || defined(QUOTA2)
2010 ufsquota_init(ip);
2011 #endif
2012
2013 /* Initialise vnode with this inode. */
2014 vp->v_tag = VT_UFS;
2015 vp->v_op = ffs_vnodeop_p;
2016 vp->v_vflag |= VV_LOCKSWORK;
2017 vp->v_data = ip;
2018
2019 /* Initialize genfs node. */
2020 genfs_node_init(vp, &ffs_genfsops);
2021
2022 return 0;
2023 }
2024
2025 /*
2026 * Undo ffs_init_vnode().
2027 */
2028 static void
2029 ffs_deinit_vnode(struct ufsmount *ump, struct vnode *vp)
2030 {
2031 struct inode *ip = VTOI(vp);
2032
2033 if (ump->um_fstype == UFS1)
2034 pool_cache_put(ffs_dinode1_cache, ip->i_din.ffs1_din);
2035 else
2036 pool_cache_put(ffs_dinode2_cache, ip->i_din.ffs2_din);
2037 pool_cache_put(ffs_inode_cache, ip);
2038
2039 genfs_node_destroy(vp);
2040 vp->v_data = NULL;
2041 }
2042
2043 /*
2044 * Read an inode from disk and initialize this vnode / inode pair.
2045 * Caller assures no other thread will try to load this inode.
2046 */
2047 int
2048 ffs_loadvnode(struct mount *mp, struct vnode *vp,
2049 const void *key, size_t key_len, const void **new_key)
2050 {
2051 ino_t ino;
2052 struct fs *fs;
2053 struct inode *ip;
2054 struct ufsmount *ump;
2055 int error;
2056
2057 KASSERT(key_len == sizeof(ino));
2058 memcpy(&ino, key, key_len);
2059 ump = VFSTOUFS(mp);
2060 fs = ump->um_fs;
2061
2062 error = ffs_init_vnode(ump, vp, ino);
2063 if (error)
2064 return error;
2065
2066 ip = VTOI(vp);
2067 if (ip->i_mode == 0) {
2068 ffs_deinit_vnode(ump, vp);
2069
2070 return ENOENT;
2071 }
2072
2073 /* Initialize the vnode from the inode. */
2074 ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
2075
2076 /* Finish inode initialization. */
2077 ip->i_devvp = ump->um_devvp;
2078 vref(ip->i_devvp);
2079
2080 /*
2081 * Ensure that uid and gid are correct. This is a temporary
2082 * fix until fsck has been changed to do the update.
2083 */
2084
2085 if (fs->fs_magic == FS_UFS1_MAGIC && /* XXX */
2086 fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */
2087 ip->i_uid = ip->i_ffs1_ouid; /* XXX */
2088 ip->i_gid = ip->i_ffs1_ogid; /* XXX */
2089 } /* XXX */
2090 uvm_vnp_setsize(vp, ip->i_size);
2091 *new_key = &ip->i_number;
2092 return 0;
2093 }
2094
2095 /*
2096 * Create a new inode on disk and initialize this vnode / inode pair.
2097 */
2098 int
2099 ffs_newvnode(struct mount *mp, struct vnode *dvp, struct vnode *vp,
2100 struct vattr *vap, kauth_cred_t cred,
2101 size_t *key_len, const void **new_key)
2102 {
2103 ino_t ino;
2104 struct fs *fs;
2105 struct inode *ip;
2106 struct timespec ts;
2107 struct ufsmount *ump;
2108 int error, mode;
2109
2110 KASSERT(dvp->v_mount == mp);
2111 KASSERT(vap->va_type != VNON);
2112
2113 *key_len = sizeof(ino);
2114 ump = VFSTOUFS(mp);
2115 fs = ump->um_fs;
2116 mode = MAKEIMODE(vap->va_type, vap->va_mode);
2117
2118 /* Allocate fresh inode. */
2119 error = ffs_valloc(dvp, mode, cred, &ino);
2120 if (error)
2121 return error;
2122
2123 /* Attach inode to vnode. */
2124 error = ffs_init_vnode(ump, vp, ino);
2125 if (error) {
2126 if (UFS_WAPBL_BEGIN(mp) == 0) {
2127 ffs_vfree(dvp, ino, mode);
2128 UFS_WAPBL_END(mp);
2129 }
2130 return error;
2131 }
2132
2133 ip = VTOI(vp);
2134 if (ip->i_mode) {
2135 panic("%s: dup alloc ino=%" PRId64 " on %s: mode %o/%o "
2136 "gen %x/%x size %" PRIx64 " blocks %" PRIx64,
2137 __func__, ino, fs->fs_fsmnt, DIP(ip, mode), ip->i_mode,
2138 DIP(ip, gen), ip->i_gen, DIP(ip, size), DIP(ip, blocks));
2139 }
2140 if (DIP(ip, size) || DIP(ip, blocks)) {
2141 printf("%s: ino=%" PRId64 " on %s: "
2142 "gen %x/%x has non zero blocks %" PRIx64 " or size %"
2143 PRIx64 "\n",
2144 __func__, ino, fs->fs_fsmnt, DIP(ip, gen), ip->i_gen,
2145 DIP(ip, blocks), DIP(ip, size));
2146 if ((ip)->i_ump->um_fstype == UFS1)
2147 panic("%s: dirty filesystem?", __func__);
2148 DIP_ASSIGN(ip, blocks, 0);
2149 DIP_ASSIGN(ip, size, 0);
2150 }
2151
2152 /* Set uid / gid. */
2153 if (cred == NOCRED || cred == FSCRED) {
2154 ip->i_gid = 0;
2155 ip->i_uid = 0;
2156 } else {
2157 ip->i_gid = VTOI(dvp)->i_gid;
2158 ip->i_uid = kauth_cred_geteuid(cred);
2159 }
2160 DIP_ASSIGN(ip, gid, ip->i_gid);
2161 DIP_ASSIGN(ip, uid, ip->i_uid);
2162
2163 #if defined(QUOTA) || defined(QUOTA2)
2164 error = UFS_WAPBL_BEGIN(mp);
2165 if (error) {
2166 ffs_deinit_vnode(ump, vp);
2167
2168 return error;
2169 }
2170 error = chkiq(ip, 1, cred, 0);
2171 if (error) {
2172 ffs_vfree(dvp, ino, mode);
2173 UFS_WAPBL_END(mp);
2174 ffs_deinit_vnode(ump, vp);
2175
2176 return error;
2177 }
2178 UFS_WAPBL_END(mp);
2179 #endif
2180
2181 /* Set type and finalize. */
2182 ip->i_flags = 0;
2183 DIP_ASSIGN(ip, flags, 0);
2184 ip->i_mode = mode;
2185 DIP_ASSIGN(ip, mode, mode);
2186 if (vap->va_rdev != VNOVAL) {
2187 /*
2188 * Want to be able to use this to make badblock
2189 * inodes, so don't truncate the dev number.
2190 */
2191 if (ump->um_fstype == UFS1)
2192 ip->i_ffs1_rdev = ufs_rw32(vap->va_rdev,
2193 UFS_MPNEEDSWAP(ump));
2194 else
2195 ip->i_ffs2_rdev = ufs_rw64(vap->va_rdev,
2196 UFS_MPNEEDSWAP(ump));
2197 }
2198 ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
2199 ip->i_devvp = ump->um_devvp;
2200 vref(ip->i_devvp);
2201
2202 /* Set up a new generation number for this inode. */
2203 ip->i_gen++;
2204 DIP_ASSIGN(ip, gen, ip->i_gen);
2205 if (fs->fs_magic == FS_UFS2_MAGIC) {
2206 vfs_timestamp(&ts);
2207 ip->i_ffs2_birthtime = ts.tv_sec;
2208 ip->i_ffs2_birthnsec = ts.tv_nsec;
2209 }
2210
2211 uvm_vnp_setsize(vp, ip->i_size);
2212 *new_key = &ip->i_number;
2213 return 0;
2214 }
2215
2216 /*
2217 * File handle to vnode
2218 *
2219 * Have to be really careful about stale file handles:
2220 * - check that the inode number is valid
2221 * - call ffs_vget() to get the locked inode
2222 * - check for an unallocated inode (i_mode == 0)
2223 * - check that the given client host has export rights and return
2224 * those rights via. exflagsp and credanonp
2225 */
2226 int
2227 ffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
2228 {
2229 struct ufid ufh;
2230 int error;
2231
2232 if (fhp->fid_len != sizeof(struct ufid))
2233 return EINVAL;
2234
2235 memcpy(&ufh, fhp, sizeof(ufh));
2236 if ((error = ffs_checkrange(mp, ufh.ufid_ino)) != 0)
2237 return error;
2238
2239 return (ufs_fhtovp(mp, &ufh, vpp));
2240 }
2241
2242 /*
2243 * Vnode pointer to File handle
2244 */
2245 /* ARGSUSED */
2246 int
2247 ffs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
2248 {
2249 struct inode *ip;
2250 struct ufid ufh;
2251
2252 if (*fh_size < sizeof(struct ufid)) {
2253 *fh_size = sizeof(struct ufid);
2254 return E2BIG;
2255 }
2256 ip = VTOI(vp);
2257 *fh_size = sizeof(struct ufid);
2258 memset(&ufh, 0, sizeof(ufh));
2259 ufh.ufid_len = sizeof(struct ufid);
2260 ufh.ufid_ino = ip->i_number;
2261 ufh.ufid_gen = ip->i_gen;
2262 memcpy(fhp, &ufh, sizeof(ufh));
2263 return (0);
2264 }
2265
2266 void
2267 ffs_init(void)
2268 {
2269 if (ffs_initcount++ > 0)
2270 return;
2271
2272 ffs_inode_cache = pool_cache_init(sizeof(struct inode), 0, 0, 0,
2273 "ffsino", NULL, IPL_NONE, NULL, NULL, NULL);
2274 ffs_dinode1_cache = pool_cache_init(sizeof(struct ufs1_dinode), 0, 0, 0,
2275 "ffsdino1", NULL, IPL_NONE, NULL, NULL, NULL);
2276 ffs_dinode2_cache = pool_cache_init(sizeof(struct ufs2_dinode), 0, 0, 0,
2277 "ffsdino2", NULL, IPL_NONE, NULL, NULL, NULL);
2278 ufs_init();
2279 }
2280
2281 void
2282 ffs_reinit(void)
2283 {
2284 ufs_reinit();
2285 }
2286
2287 void
2288 ffs_done(void)
2289 {
2290 if (--ffs_initcount > 0)
2291 return;
2292
2293 ufs_done();
2294 pool_cache_destroy(ffs_dinode2_cache);
2295 pool_cache_destroy(ffs_dinode1_cache);
2296 pool_cache_destroy(ffs_inode_cache);
2297 }
2298
2299 /*
2300 * Write a superblock and associated information back to disk.
2301 */
2302 int
2303 ffs_sbupdate(struct ufsmount *mp, int waitfor)
2304 {
2305 struct fs *fs = mp->um_fs;
2306 struct buf *bp;
2307 int error;
2308 u_int32_t saveflag;
2309
2310 error = ffs_getblk(mp->um_devvp,
2311 fs->fs_sblockloc / DEV_BSIZE, FFS_NOBLK,
2312 fs->fs_sbsize, false, &bp);
2313 if (error)
2314 return error;
2315 saveflag = fs->fs_flags & FS_INTERNAL;
2316 fs->fs_flags &= ~FS_INTERNAL;
2317
2318 memcpy(bp->b_data, fs, fs->fs_sbsize);
2319
2320 ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
2321 #ifdef FFS_EI
2322 if (mp->um_flags & UFS_NEEDSWAP)
2323 ffs_sb_swap((struct fs *)bp->b_data, (struct fs *)bp->b_data);
2324 #endif
2325 fs->fs_flags |= saveflag;
2326
2327 if (waitfor == MNT_WAIT)
2328 error = bwrite(bp);
2329 else
2330 bawrite(bp);
2331 return (error);
2332 }
2333
2334 int
2335 ffs_cgupdate(struct ufsmount *mp, int waitfor)
2336 {
2337 struct fs *fs = mp->um_fs;
2338 struct buf *bp;
2339 int blks;
2340 void *space;
2341 int i, size, error = 0, allerror = 0;
2342
2343 UFS_WAPBL_JLOCK_ASSERT(mp);
2344
2345 allerror = ffs_sbupdate(mp, waitfor);
2346 blks = howmany(fs->fs_cssize, fs->fs_fsize);
2347 space = fs->fs_csp;
2348 for (i = 0; i < blks; i += fs->fs_frag) {
2349 size = fs->fs_bsize;
2350 if (i + fs->fs_frag > blks)
2351 size = (blks - i) * fs->fs_fsize;
2352 error = ffs_getblk(mp->um_devvp, FFS_FSBTODB(fs, fs->fs_csaddr + i),
2353 FFS_NOBLK, size, false, &bp);
2354 if (error)
2355 break;
2356 #ifdef FFS_EI
2357 if (mp->um_flags & UFS_NEEDSWAP)
2358 ffs_csum_swap((struct csum*)space,
2359 (struct csum*)bp->b_data, size);
2360 else
2361 #endif
2362 memcpy(bp->b_data, space, (u_int)size);
2363 space = (char *)space + size;
2364 if (waitfor == MNT_WAIT)
2365 error = bwrite(bp);
2366 else
2367 bawrite(bp);
2368 }
2369 if (!allerror && error)
2370 allerror = error;
2371 return (allerror);
2372 }
2373
2374 int
2375 ffs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
2376 int attrnamespace, const char *attrname)
2377 {
2378 #ifdef UFS_EXTATTR
2379 /*
2380 * File-backed extended attributes are only supported on UFS1.
2381 * UFS2 has native extended attributes.
2382 */
2383 if (VFSTOUFS(mp)->um_fstype == UFS1)
2384 return (ufs_extattrctl(mp, cmd, vp, attrnamespace, attrname));
2385 #endif
2386 return (vfs_stdextattrctl(mp, cmd, vp, attrnamespace, attrname));
2387 }
2388
2389 /*
2390 * Synch vnode for a mounted file system.
2391 */
2392 static int
2393 ffs_vfs_fsync(vnode_t *vp, int flags)
2394 {
2395 int error, i, pflags;
2396 #ifdef WAPBL
2397 struct mount *mp;
2398 #endif
2399
2400 KASSERT(vp->v_type == VBLK);
2401 KASSERT(spec_node_getmountedfs(vp) != NULL);
2402
2403 /*
2404 * Flush all dirty data associated with the vnode.
2405 */
2406 pflags = PGO_ALLPAGES | PGO_CLEANIT;
2407 if ((flags & FSYNC_WAIT) != 0)
2408 pflags |= PGO_SYNCIO;
2409 mutex_enter(vp->v_interlock);
2410 error = VOP_PUTPAGES(vp, 0, 0, pflags);
2411 if (error)
2412 return error;
2413
2414 #ifdef WAPBL
2415 mp = spec_node_getmountedfs(vp);
2416 if (mp && mp->mnt_wapbl) {
2417 /*
2418 * Don't bother writing out metadata if the syncer is
2419 * making the request. We will let the sync vnode
2420 * write it out in a single burst through a call to
2421 * VFS_SYNC().
2422 */
2423 if ((flags & (FSYNC_DATAONLY | FSYNC_LAZY | FSYNC_NOLOG)) != 0)
2424 return 0;
2425
2426 /*
2427 * Don't flush the log if the vnode being flushed
2428 * contains no dirty buffers that could be in the log.
2429 */
2430 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
2431 error = wapbl_flush(mp->mnt_wapbl, 0);
2432 if (error)
2433 return error;
2434 }
2435
2436 if ((flags & FSYNC_WAIT) != 0) {
2437 mutex_enter(vp->v_interlock);
2438 while (vp->v_numoutput)
2439 cv_wait(&vp->v_cv, vp->v_interlock);
2440 mutex_exit(vp->v_interlock);
2441 }
2442
2443 return 0;
2444 }
2445 #endif /* WAPBL */
2446
2447 error = vflushbuf(vp, flags);
2448 if (error == 0 && (flags & FSYNC_CACHE) != 0) {
2449 i = 1;
2450 (void)VOP_IOCTL(vp, DIOCCACHESYNC, &i, FWRITE,
2451 kauth_cred_get());
2452 }
2453
2454 return error;
2455 }
2456