ffs_vfsops.c revision 1.278.2.1 1 /* $NetBSD: ffs_vfsops.c,v 1.278.2.1 2012/09/12 06:15:35 tls 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.1 2012/09/12 06:15:35 tls 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/fstrans.h>
96 #include <sys/module.h>
97
98 #include <miscfs/genfs/genfs.h>
99 #include <miscfs/specfs/specdev.h>
100
101 #include <ufs/ufs/quota.h>
102 #include <ufs/ufs/ufsmount.h>
103 #include <ufs/ufs/inode.h>
104 #include <ufs/ufs/dir.h>
105 #include <ufs/ufs/ufs_extern.h>
106 #include <ufs/ufs/ufs_bswap.h>
107 #include <ufs/ufs/ufs_wapbl.h>
108
109 #include <ufs/ffs/fs.h>
110 #include <ufs/ffs/ffs_extern.h>
111
112 MODULE(MODULE_CLASS_VFS, ffs, NULL);
113
114 static int ffs_vfs_fsync(vnode_t *, int);
115
116 static struct sysctllog *ffs_sysctl_log;
117
118 static kauth_listener_t ffs_snapshot_listener;
119
120 /* how many times ffs_init() was called */
121 int ffs_initcount = 0;
122
123 extern const struct vnodeopv_desc ffs_vnodeop_opv_desc;
124 extern const struct vnodeopv_desc ffs_specop_opv_desc;
125 extern const struct vnodeopv_desc ffs_fifoop_opv_desc;
126
127 const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
128 &ffs_vnodeop_opv_desc,
129 &ffs_specop_opv_desc,
130 &ffs_fifoop_opv_desc,
131 NULL,
132 };
133
134 struct vfsops ffs_vfsops = {
135 MOUNT_FFS,
136 sizeof (struct ufs_args),
137 ffs_mount,
138 ufs_start,
139 ffs_unmount,
140 ufs_root,
141 ufs_quotactl,
142 ffs_statvfs,
143 ffs_sync,
144 ffs_vget,
145 ffs_fhtovp,
146 ffs_vptofh,
147 ffs_init,
148 ffs_reinit,
149 ffs_done,
150 ffs_mountroot,
151 ffs_snapshot,
152 ffs_extattrctl,
153 ffs_suspendctl,
154 genfs_renamelock_enter,
155 genfs_renamelock_exit,
156 ffs_vfs_fsync,
157 ffs_vnodeopv_descs,
158 0,
159 { NULL, NULL },
160 };
161
162 static const struct genfs_ops ffs_genfsops = {
163 .gop_size = ffs_gop_size,
164 .gop_alloc = ufs_gop_alloc,
165 .gop_write = genfs_gop_write,
166 .gop_markupdate = ufs_gop_markupdate,
167 };
168
169 static const struct ufs_ops ffs_ufsops = {
170 .uo_itimes = ffs_itimes,
171 .uo_update = ffs_update,
172 .uo_truncate = ffs_truncate,
173 .uo_valloc = ffs_valloc,
174 .uo_vfree = ffs_vfree,
175 .uo_balloc = ffs_balloc,
176 .uo_unmark_vnode = (void (*)(vnode_t *))nullop,
177 };
178
179 static int
180 ffs_snapshot_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
181 void *arg0, void *arg1, void *arg2, void *arg3)
182 {
183 vnode_t *vp = arg2;
184 int result = KAUTH_RESULT_DEFER;;
185
186 if (action != KAUTH_SYSTEM_FS_SNAPSHOT)
187 return result;
188
189 if (VTOI(vp)->i_uid == kauth_cred_geteuid(cred))
190 result = KAUTH_RESULT_ALLOW;
191
192 return result;
193 }
194
195 static int
196 ffs_modcmd(modcmd_t cmd, void *arg)
197 {
198 int error;
199
200 #if 0
201 extern int doasyncfree;
202 #endif
203 #ifdef UFS_EXTATTR
204 extern int ufs_extattr_autocreate;
205 #endif
206 extern int ffs_log_changeopt;
207
208 switch (cmd) {
209 case MODULE_CMD_INIT:
210 error = vfs_attach(&ffs_vfsops);
211 if (error != 0)
212 break;
213
214 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
215 CTLFLAG_PERMANENT,
216 CTLTYPE_NODE, "vfs", NULL,
217 NULL, 0, NULL, 0,
218 CTL_VFS, CTL_EOL);
219 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
220 CTLFLAG_PERMANENT,
221 CTLTYPE_NODE, "ffs",
222 SYSCTL_DESCR("Berkeley Fast File System"),
223 NULL, 0, NULL, 0,
224 CTL_VFS, 1, CTL_EOL);
225 /*
226 * @@@ should we even bother with these first three?
227 */
228 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
229 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
230 CTLTYPE_INT, "doclusterread", NULL,
231 sysctl_notavail, 0, NULL, 0,
232 CTL_VFS, 1, FFS_CLUSTERREAD, CTL_EOL);
233 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
234 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
235 CTLTYPE_INT, "doclusterwrite", NULL,
236 sysctl_notavail, 0, NULL, 0,
237 CTL_VFS, 1, FFS_CLUSTERWRITE, CTL_EOL);
238 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
239 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
240 CTLTYPE_INT, "doreallocblks", NULL,
241 sysctl_notavail, 0, NULL, 0,
242 CTL_VFS, 1, FFS_REALLOCBLKS, CTL_EOL);
243 #if 0
244 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
245 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
246 CTLTYPE_INT, "doasyncfree",
247 SYSCTL_DESCR("Release dirty blocks asynchronously"),
248 NULL, 0, &doasyncfree, 0,
249 CTL_VFS, 1, FFS_ASYNCFREE, CTL_EOL);
250 #endif
251 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
252 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
253 CTLTYPE_INT, "log_changeopt",
254 SYSCTL_DESCR("Log changes in optimization strategy"),
255 NULL, 0, &ffs_log_changeopt, 0,
256 CTL_VFS, 1, FFS_LOG_CHANGEOPT, CTL_EOL);
257 #ifdef UFS_EXTATTR
258 sysctl_createv(&ffs_sysctl_log, 0, NULL, NULL,
259 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
260 CTLTYPE_INT, "extattr_autocreate",
261 SYSCTL_DESCR("Size of attribute for "
262 "backing file autocreation"),
263 NULL, 0, &ufs_extattr_autocreate, 0,
264 CTL_VFS, 1, FFS_EXTATTR_AUTOCREATE, CTL_EOL);
265
266 #endif /* UFS_EXTATTR */
267
268 ffs_snapshot_listener = kauth_listen_scope(KAUTH_SCOPE_SYSTEM,
269 ffs_snapshot_cb, NULL);
270 if (ffs_snapshot_listener == NULL)
271 printf("ffs_modcmd: can't listen on system scope.\n");
272
273 break;
274 case MODULE_CMD_FINI:
275 error = vfs_detach(&ffs_vfsops);
276 if (error != 0)
277 break;
278 sysctl_teardown(&ffs_sysctl_log);
279 if (ffs_snapshot_listener != NULL)
280 kauth_unlisten_scope(ffs_snapshot_listener);
281 break;
282 default:
283 error = ENOTTY;
284 break;
285 }
286
287 return (error);
288 }
289
290 pool_cache_t ffs_inode_cache;
291 pool_cache_t ffs_dinode1_cache;
292 pool_cache_t ffs_dinode2_cache;
293
294 static void ffs_oldfscompat_read(struct fs *, struct ufsmount *, daddr_t);
295 static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
296
297 /*
298 * Called by main() when ffs is going to be mounted as root.
299 */
300
301 int
302 ffs_mountroot(void)
303 {
304 struct fs *fs;
305 struct mount *mp;
306 struct lwp *l = curlwp; /* XXX */
307 struct ufsmount *ump;
308 int error;
309
310 if (device_class(root_device) != DV_DISK)
311 return (ENODEV);
312
313 if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
314 vrele(rootvp);
315 return (error);
316 }
317
318 /*
319 * We always need to be able to mount the root file system.
320 */
321 mp->mnt_flag |= MNT_FORCE;
322 if ((error = ffs_mountfs(rootvp, mp, l)) != 0) {
323 vfs_unbusy(mp, false, NULL);
324 vfs_destroy(mp);
325 return (error);
326 }
327 mp->mnt_flag &= ~MNT_FORCE;
328 mutex_enter(&mountlist_lock);
329 CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
330 mutex_exit(&mountlist_lock);
331 ump = VFSTOUFS(mp);
332 fs = ump->um_fs;
333 memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
334 (void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
335 (void)ffs_statvfs(mp, &mp->mnt_stat);
336 vfs_unbusy(mp, false, NULL);
337 setrootfstime((time_t)fs->fs_time);
338 return (0);
339 }
340
341 /*
342 * VFS Operations.
343 *
344 * mount system call
345 */
346 int
347 ffs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
348 {
349 struct lwp *l = curlwp;
350 struct vnode *devvp = NULL;
351 struct ufs_args *args = data;
352 struct ufsmount *ump = NULL;
353 struct fs *fs;
354 int error = 0, flags, update;
355 mode_t accessmode;
356
357 if (*data_len < sizeof *args)
358 return EINVAL;
359
360 if (mp->mnt_flag & MNT_GETARGS) {
361 ump = VFSTOUFS(mp);
362 if (ump == NULL)
363 return EIO;
364 args->fspec = NULL;
365 *data_len = sizeof *args;
366 return 0;
367 }
368
369 update = mp->mnt_flag & MNT_UPDATE;
370
371 /* Check arguments */
372 if (args->fspec != NULL) {
373 /*
374 * Look up the name and verify that it's sane.
375 */
376 error = namei_simple_user(args->fspec,
377 NSM_FOLLOW_NOEMULROOT, &devvp);
378 if (error != 0)
379 return (error);
380
381 if (!update) {
382 /*
383 * Be sure this is a valid block device
384 */
385 if (devvp->v_type != VBLK)
386 error = ENOTBLK;
387 else if (bdevsw_lookup(devvp->v_rdev) == NULL)
388 error = ENXIO;
389 } else {
390 /*
391 * Be sure we're still naming the same device
392 * used for our initial mount
393 */
394 ump = VFSTOUFS(mp);
395 if (devvp != ump->um_devvp) {
396 if (devvp->v_rdev != ump->um_devvp->v_rdev)
397 error = EINVAL;
398 else {
399 vrele(devvp);
400 devvp = ump->um_devvp;
401 vref(devvp);
402 }
403 }
404 }
405 } else {
406 if (!update) {
407 /* New mounts must have a filename for the device */
408 return (EINVAL);
409 } else {
410 /* Use the extant mount */
411 ump = VFSTOUFS(mp);
412 devvp = ump->um_devvp;
413 vref(devvp);
414 }
415 }
416
417 /*
418 * If mount by non-root, then verify that user has necessary
419 * permissions on the device.
420 *
421 * Permission to update a mount is checked higher, so here we presume
422 * updating the mount is okay (for example, as far as securelevel goes)
423 * which leaves us with the normal check.
424 */
425 if (error == 0) {
426 accessmode = VREAD;
427 if (update ?
428 (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
429 (mp->mnt_flag & MNT_RDONLY) == 0)
430 accessmode |= VWRITE;
431 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
432 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
433 KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp,
434 KAUTH_ARG(accessmode));
435 VOP_UNLOCK(devvp);
436 }
437
438 if (error) {
439 vrele(devvp);
440 return (error);
441 }
442
443 #ifdef WAPBL
444 /* WAPBL can only be enabled on a r/w mount. */
445 if ((mp->mnt_flag & MNT_RDONLY) && !(mp->mnt_iflag & IMNT_WANTRDWR)) {
446 mp->mnt_flag &= ~MNT_LOG;
447 }
448 #else /* !WAPBL */
449 mp->mnt_flag &= ~MNT_LOG;
450 #endif /* !WAPBL */
451
452 if (!update) {
453 int xflags;
454
455 if (mp->mnt_flag & MNT_RDONLY)
456 xflags = FREAD;
457 else
458 xflags = FREAD | FWRITE;
459 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
460 error = VOP_OPEN(devvp, xflags, FSCRED);
461 VOP_UNLOCK(devvp);
462 if (error)
463 goto fail;
464 error = ffs_mountfs(devvp, mp, l);
465 if (error) {
466 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
467 (void)VOP_CLOSE(devvp, xflags, NOCRED);
468 VOP_UNLOCK(devvp);
469 goto fail;
470 }
471
472 ump = VFSTOUFS(mp);
473 fs = ump->um_fs;
474 } else {
475 /*
476 * Update the mount.
477 */
478
479 /*
480 * The initial mount got a reference on this
481 * device, so drop the one obtained via
482 * namei(), above.
483 */
484 vrele(devvp);
485
486 ump = VFSTOUFS(mp);
487 fs = ump->um_fs;
488 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
489 /*
490 * Changing from r/w to r/o
491 */
492 flags = WRITECLOSE;
493 if (mp->mnt_flag & MNT_FORCE)
494 flags |= FORCECLOSE;
495 error = ffs_flushfiles(mp, flags, l);
496 if (error == 0)
497 error = UFS_WAPBL_BEGIN(mp);
498 if (error == 0 &&
499 ffs_cgupdate(ump, MNT_WAIT) == 0 &&
500 fs->fs_clean & FS_WASCLEAN) {
501 if (mp->mnt_flag & MNT_SOFTDEP)
502 fs->fs_flags &= ~FS_DOSOFTDEP;
503 fs->fs_clean = FS_ISCLEAN;
504 (void) ffs_sbupdate(ump, MNT_WAIT);
505 }
506 if (error == 0)
507 UFS_WAPBL_END(mp);
508 if (error)
509 return (error);
510 }
511
512 #ifdef WAPBL
513 if ((mp->mnt_flag & MNT_LOG) == 0) {
514 error = ffs_wapbl_stop(mp, mp->mnt_flag & MNT_FORCE);
515 if (error)
516 return error;
517 }
518 #endif /* WAPBL */
519
520 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
521 /*
522 * Finish change from r/w to r/o
523 */
524 fs->fs_ronly = 1;
525 fs->fs_fmod = 0;
526 }
527
528 if (mp->mnt_flag & MNT_RELOAD) {
529 error = ffs_reload(mp, l->l_cred, l);
530 if (error)
531 return (error);
532 }
533
534 if (fs->fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
535 /*
536 * Changing from read-only to read/write
537 */
538 #ifndef QUOTA2
539 if (fs->fs_flags & FS_DOQUOTA2) {
540 ump->um_flags |= UFS_QUOTA2;
541 uprintf("%s: options QUOTA2 not enabled%s\n",
542 mp->mnt_stat.f_mntonname,
543 (mp->mnt_flag & MNT_FORCE) ? "" :
544 ", not mounting");
545 return EINVAL;
546 }
547 #endif
548 fs->fs_ronly = 0;
549 fs->fs_clean <<= 1;
550 fs->fs_fmod = 1;
551 #ifdef WAPBL
552 if (fs->fs_flags & FS_DOWAPBL) {
553 printf("%s: replaying log to disk\n",
554 mp->mnt_stat.f_mntonname);
555 KDASSERT(mp->mnt_wapbl_replay);
556 error = wapbl_replay_write(mp->mnt_wapbl_replay,
557 devvp);
558 if (error) {
559 return error;
560 }
561 wapbl_replay_stop(mp->mnt_wapbl_replay);
562 fs->fs_clean = FS_WASCLEAN;
563 }
564 #endif /* WAPBL */
565 if (fs->fs_snapinum[0] != 0)
566 ffs_snapshot_mount(mp);
567 }
568
569 #ifdef WAPBL
570 error = ffs_wapbl_start(mp);
571 if (error)
572 return error;
573 #endif /* WAPBL */
574
575 #ifdef QUOTA2
576 if (!fs->fs_ronly) {
577 error = ffs_quota2_mount(mp);
578 if (error) {
579 return error;
580 }
581 }
582 #endif
583 if (args->fspec == NULL)
584 return 0;
585 }
586
587 error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
588 UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
589 if (error == 0)
590 (void)strncpy(fs->fs_fsmnt, mp->mnt_stat.f_mntonname,
591 sizeof(fs->fs_fsmnt));
592 fs->fs_flags &= ~FS_DOSOFTDEP;
593 if (fs->fs_fmod != 0) { /* XXX */
594 int err;
595
596 fs->fs_fmod = 0;
597 if (fs->fs_clean & FS_WASCLEAN)
598 fs->fs_time = time_second;
599 else {
600 printf("%s: file system not clean (fs_clean=%#x); "
601 "please fsck(8)\n", mp->mnt_stat.f_mntfromname,
602 fs->fs_clean);
603 printf("%s: lost blocks %" PRId64 " files %d\n",
604 mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
605 fs->fs_pendinginodes);
606 }
607 err = UFS_WAPBL_BEGIN(mp);
608 if (err == 0) {
609 (void) ffs_cgupdate(ump, MNT_WAIT);
610 UFS_WAPBL_END(mp);
611 }
612 }
613 if ((mp->mnt_flag & MNT_SOFTDEP) != 0) {
614 printf("%s: `-o softdep' is no longer supported, "
615 "consider `-o log'\n", mp->mnt_stat.f_mntfromname);
616 mp->mnt_flag &= ~MNT_SOFTDEP;
617 }
618
619 return (error);
620
621 fail:
622 vrele(devvp);
623 return (error);
624 }
625
626 /*
627 * Reload all incore data for a filesystem (used after running fsck on
628 * the root filesystem and finding things to fix). The filesystem must
629 * be mounted read-only.
630 *
631 * Things to do to update the mount:
632 * 1) invalidate all cached meta-data.
633 * 2) re-read superblock from disk.
634 * 3) re-read summary information from disk.
635 * 4) invalidate all inactive vnodes.
636 * 5) invalidate all cached file data.
637 * 6) re-read inode data for all active vnodes.
638 */
639 int
640 ffs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
641 {
642 struct vnode *vp, *mvp, *devvp;
643 struct inode *ip;
644 void *space;
645 struct buf *bp;
646 struct fs *fs, *newfs;
647 struct dkwedge_info dkw;
648 int i, bsize, blks, error;
649 int32_t *lp;
650 struct ufsmount *ump;
651 daddr_t sblockloc;
652
653 if ((mp->mnt_flag & MNT_RDONLY) == 0)
654 return (EINVAL);
655
656 ump = VFSTOUFS(mp);
657 /*
658 * Step 1: invalidate all cached meta-data.
659 */
660 devvp = ump->um_devvp;
661 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
662 error = vinvalbuf(devvp, 0, cred, l, 0, 0);
663 VOP_UNLOCK(devvp);
664 if (error)
665 panic("ffs_reload: dirty1");
666 /*
667 * Step 2: re-read superblock from disk.
668 */
669 fs = ump->um_fs;
670
671 /* XXX we don't handle possibility that superblock moved. */
672 error = bread(devvp, fs->fs_sblockloc / DEV_BSIZE, fs->fs_sbsize,
673 NOCRED, 0, &bp);
674 if (error) {
675 brelse(bp, 0);
676 return (error);
677 }
678 newfs = kmem_alloc(fs->fs_sbsize, KM_SLEEP);
679 memcpy(newfs, bp->b_data, fs->fs_sbsize);
680 #ifdef FFS_EI
681 if (ump->um_flags & UFS_NEEDSWAP) {
682 ffs_sb_swap((struct fs*)bp->b_data, newfs);
683 fs->fs_flags |= FS_SWAPPED;
684 } else
685 #endif
686 fs->fs_flags &= ~FS_SWAPPED;
687 if ((newfs->fs_magic != FS_UFS1_MAGIC &&
688 newfs->fs_magic != FS_UFS2_MAGIC)||
689 newfs->fs_bsize > MAXBSIZE ||
690 newfs->fs_bsize < sizeof(struct fs)) {
691 brelse(bp, 0);
692 kmem_free(newfs, fs->fs_sbsize);
693 return (EIO); /* XXX needs translation */
694 }
695 /* Store off old fs_sblockloc for fs_oldfscompat_read. */
696 sblockloc = fs->fs_sblockloc;
697 /*
698 * Copy pointer fields back into superblock before copying in XXX
699 * new superblock. These should really be in the ufsmount. XXX
700 * Note that important parameters (eg fs_ncg) are unchanged.
701 */
702 newfs->fs_csp = fs->fs_csp;
703 newfs->fs_maxcluster = fs->fs_maxcluster;
704 newfs->fs_contigdirs = fs->fs_contigdirs;
705 newfs->fs_ronly = fs->fs_ronly;
706 newfs->fs_active = fs->fs_active;
707 memcpy(fs, newfs, (u_int)fs->fs_sbsize);
708 brelse(bp, 0);
709 kmem_free(newfs, fs->fs_sbsize);
710
711 /* Recheck for apple UFS filesystem */
712 ump->um_flags &= ~UFS_ISAPPLEUFS;
713 /* First check to see if this is tagged as an Apple UFS filesystem
714 * in the disklabel
715 */
716 if (getdiskinfo(devvp, &dkw) == 0 &&
717 strcmp(dkw.dkw_ptype, DKW_PTYPE_APPLEUFS) == 0)
718 ump->um_flags |= UFS_ISAPPLEUFS;
719 #ifdef APPLE_UFS
720 else {
721 /* Manually look for an apple ufs label, and if a valid one
722 * is found, then treat it like an Apple UFS filesystem anyway
723 *
724 * EINVAL is most probably a blocksize or alignment problem,
725 * it is unlikely that this is an Apple UFS filesystem then.
726 */
727 error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE),
728 APPLEUFS_LABEL_SIZE, cred, 0, &bp);
729 if (error && error != EINVAL) {
730 brelse(bp, 0);
731 return (error);
732 }
733 if (error == 0) {
734 error = ffs_appleufs_validate(fs->fs_fsmnt,
735 (struct appleufslabel *)bp->b_data, NULL);
736 if (error == 0)
737 ump->um_flags |= UFS_ISAPPLEUFS;
738 }
739 brelse(bp, 0);
740 bp = NULL;
741 }
742 #else
743 if (ump->um_flags & UFS_ISAPPLEUFS)
744 return (EIO);
745 #endif
746
747 if (UFS_MPISAPPLEUFS(ump)) {
748 /* see comment about NeXT below */
749 ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
750 ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
751 mp->mnt_iflag |= IMNT_DTYPE;
752 } else {
753 ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
754 ump->um_dirblksiz = DIRBLKSIZ;
755 if (ump->um_maxsymlinklen > 0)
756 mp->mnt_iflag |= IMNT_DTYPE;
757 else
758 mp->mnt_iflag &= ~IMNT_DTYPE;
759 }
760 ffs_oldfscompat_read(fs, ump, sblockloc);
761
762 mutex_enter(&ump->um_lock);
763 ump->um_maxfilesize = fs->fs_maxfilesize;
764 if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {
765 uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n",
766 mp->mnt_stat.f_mntonname, fs->fs_flags,
767 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
768 if ((mp->mnt_flag & MNT_FORCE) == 0) {
769 mutex_exit(&ump->um_lock);
770 return (EINVAL);
771 }
772 }
773 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
774 fs->fs_pendingblocks = 0;
775 fs->fs_pendinginodes = 0;
776 }
777 mutex_exit(&ump->um_lock);
778
779 ffs_statvfs(mp, &mp->mnt_stat);
780 /*
781 * Step 3: re-read summary information from disk.
782 */
783 blks = howmany(fs->fs_cssize, fs->fs_fsize);
784 space = fs->fs_csp;
785 for (i = 0; i < blks; i += fs->fs_frag) {
786 bsize = fs->fs_bsize;
787 if (i + fs->fs_frag > blks)
788 bsize = (blks - i) * fs->fs_fsize;
789 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), bsize,
790 NOCRED, 0, &bp);
791 if (error) {
792 brelse(bp, 0);
793 return (error);
794 }
795 #ifdef FFS_EI
796 if (UFS_FSNEEDSWAP(fs))
797 ffs_csum_swap((struct csum *)bp->b_data,
798 (struct csum *)space, bsize);
799 else
800 #endif
801 memcpy(space, bp->b_data, (size_t)bsize);
802 space = (char *)space + bsize;
803 brelse(bp, 0);
804 }
805 if (fs->fs_snapinum[0] != 0)
806 ffs_snapshot_mount(mp);
807 /*
808 * We no longer know anything about clusters per cylinder group.
809 */
810 if (fs->fs_contigsumsize > 0) {
811 lp = fs->fs_maxcluster;
812 for (i = 0; i < fs->fs_ncg; i++)
813 *lp++ = fs->fs_contigsumsize;
814 }
815
816 /* Allocate a marker vnode. */
817 mvp = vnalloc(mp);
818 /*
819 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
820 * and vclean() can be called indirectly
821 */
822 mutex_enter(&mntvnode_lock);
823 loop:
824 for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) {
825 vmark(mvp, vp);
826 if (vp->v_mount != mp || vismarker(vp))
827 continue;
828 /*
829 * Step 4: invalidate all inactive vnodes.
830 */
831 if (vrecycle(vp, &mntvnode_lock, l)) {
832 mutex_enter(&mntvnode_lock);
833 (void)vunmark(mvp);
834 goto loop;
835 }
836 /*
837 * Step 5: invalidate all cached file data.
838 */
839 mutex_enter(vp->v_interlock);
840 mutex_exit(&mntvnode_lock);
841 if (vget(vp, LK_EXCLUSIVE)) {
842 (void)vunmark(mvp);
843 goto loop;
844 }
845 if (vinvalbuf(vp, 0, cred, l, 0, 0))
846 panic("ffs_reload: dirty2");
847 /*
848 * Step 6: re-read inode data for all active vnodes.
849 */
850 ip = VTOI(vp);
851 error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
852 (int)fs->fs_bsize, NOCRED, 0, &bp);
853 if (error) {
854 brelse(bp, 0);
855 vput(vp);
856 (void)vunmark(mvp);
857 break;
858 }
859 ffs_load_inode(bp, ip, fs, ip->i_number);
860 brelse(bp, 0);
861 vput(vp);
862 mutex_enter(&mntvnode_lock);
863 }
864 mutex_exit(&mntvnode_lock);
865 vnfree(mvp);
866 return (error);
867 }
868
869 /*
870 * Possible superblock locations ordered from most to least likely.
871 */
872 static const int sblock_try[] = SBLOCKSEARCH;
873
874 /*
875 * Common code for mount and mountroot
876 */
877 int
878 ffs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
879 {
880 struct ufsmount *ump;
881 struct buf *bp;
882 struct fs *fs;
883 dev_t dev;
884 struct disk *diskp;
885 struct dkwedge_info dkw;
886 void *space;
887 daddr_t sblockloc, fsblockloc;
888 int blks, fstype;
889 int error, i, bsize, ronly, bset = 0;
890 #ifdef FFS_EI
891 int needswap = 0; /* keep gcc happy */
892 #endif
893 int32_t *lp;
894 kauth_cred_t cred;
895 u_int32_t sbsize = 8192; /* keep gcc happy*/
896 u_int32_t allocsbsize;
897 int32_t fsbsize;
898
899 dev = devvp->v_rdev;
900 if ((diskp = disk_find_blk(dev)) == NULL) {
901 panic("no disk for device %d %d", major(dev), DISKUNIT(dev));
902 }
903
904 cred = l ? l->l_cred : NOCRED;
905
906 /* Flush out any old buffers remaining from a previous use. */
907 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
908 error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
909 VOP_UNLOCK(devvp);
910 if (error)
911 return (error);
912
913 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
914
915 bp = NULL;
916 ump = NULL;
917 fs = NULL;
918 sblockloc = 0;
919 fstype = 0;
920
921 error = fstrans_mount(mp);
922 if (error)
923 return error;
924
925 /*
926 * Get the maximum I/O size for the underlying device.
927 */
928 mp->mnt_maxphys = disk_maxphys(diskp);
929 aprint_debug("ffs_mount: disk %s maxphys %d\n",
930 diskp->dk_name, mp->mnt_maxphys);
931
932 ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
933 mutex_init(&ump->um_lock, MUTEX_DEFAULT, IPL_NONE);
934 error = ffs_snapshot_init(ump);
935 if (error)
936 goto out;
937 ump->um_ops = &ffs_ufsops;
938
939 #ifdef WAPBL
940 sbagain:
941 #endif
942 /*
943 * Try reading the superblock in each of its possible locations.
944 */
945 for (i = 0; ; i++) {
946 if (bp != NULL) {
947 brelse(bp, BC_NOCACHE);
948 bp = NULL;
949 }
950 if (sblock_try[i] == -1) {
951 error = EINVAL;
952 fs = NULL;
953 goto out;
954 }
955 error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE, cred,
956 0, &bp);
957 if (error) {
958 fs = NULL;
959 goto out;
960 }
961 fs = (struct fs*)bp->b_data;
962 fsblockloc = sblockloc = sblock_try[i];
963 if (fs->fs_magic == FS_UFS1_MAGIC) {
964 sbsize = fs->fs_sbsize;
965 fstype = UFS1;
966 fsbsize = fs->fs_bsize;
967 #ifdef FFS_EI
968 needswap = 0;
969 } else if (fs->fs_magic == FS_UFS1_MAGIC_SWAPPED) {
970 sbsize = bswap32(fs->fs_sbsize);
971 fstype = UFS1;
972 fsbsize = bswap32(fs->fs_bsize);
973 needswap = 1;
974 #endif
975 } else if (fs->fs_magic == FS_UFS2_MAGIC) {
976 sbsize = fs->fs_sbsize;
977 fstype = UFS2;
978 fsbsize = fs->fs_bsize;
979 #ifdef FFS_EI
980 needswap = 0;
981 } else if (fs->fs_magic == FS_UFS2_MAGIC_SWAPPED) {
982 sbsize = bswap32(fs->fs_sbsize);
983 fstype = UFS2;
984 fsbsize = bswap32(fs->fs_bsize);
985 needswap = 1;
986 #endif
987 } else
988 continue;
989
990
991 /* fs->fs_sblockloc isn't defined for old filesystems */
992 if (fstype == UFS1 && !(fs->fs_old_flags & FS_FLAGS_UPDATED)) {
993 if (sblockloc == SBLOCK_UFS2)
994 /*
995 * This is likely to be the first alternate
996 * in a filesystem with 64k blocks.
997 * Don't use it.
998 */
999 continue;
1000 fsblockloc = sblockloc;
1001 } else {
1002 fsblockloc = fs->fs_sblockloc;
1003 #ifdef FFS_EI
1004 if (needswap)
1005 fsblockloc = bswap64(fsblockloc);
1006 #endif
1007 }
1008
1009 /* Check we haven't found an alternate superblock */
1010 if (fsblockloc != sblockloc)
1011 continue;
1012
1013 /* Validate size of superblock */
1014 if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs))
1015 continue;
1016
1017 /* Check that we can handle the file system blocksize */
1018 if (fsbsize > MAXBSIZE) {
1019 printf("ffs_mountfs: block size (%d) > MAXBSIZE (%d)\n",
1020 fsbsize, MAXBSIZE);
1021 continue;
1022 }
1023
1024 /* Ok seems to be a good superblock */
1025 break;
1026 }
1027
1028 fs = kmem_alloc((u_long)sbsize, KM_SLEEP);
1029 memcpy(fs, bp->b_data, sbsize);
1030 ump->um_fs = fs;
1031
1032 #ifdef FFS_EI
1033 if (needswap) {
1034 ffs_sb_swap((struct fs*)bp->b_data, fs);
1035 fs->fs_flags |= FS_SWAPPED;
1036 } else
1037 #endif
1038 fs->fs_flags &= ~FS_SWAPPED;
1039
1040 #ifdef WAPBL
1041 if ((mp->mnt_wapbl_replay == 0) && (fs->fs_flags & FS_DOWAPBL)) {
1042 error = ffs_wapbl_replay_start(mp, fs, devvp);
1043 if (error && (mp->mnt_flag & MNT_FORCE) == 0)
1044 goto out;
1045 if (!error) {
1046 if (!ronly) {
1047 /* XXX fsmnt may be stale. */
1048 printf("%s: replaying log to disk\n",
1049 fs->fs_fsmnt);
1050 error = wapbl_replay_write(mp->mnt_wapbl_replay,
1051 devvp);
1052 if (error)
1053 goto out;
1054 wapbl_replay_stop(mp->mnt_wapbl_replay);
1055 fs->fs_clean = FS_WASCLEAN;
1056 } else {
1057 /* XXX fsmnt may be stale */
1058 printf("%s: replaying log to memory\n",
1059 fs->fs_fsmnt);
1060 }
1061
1062 /* Force a re-read of the superblock */
1063 brelse(bp, BC_INVAL);
1064 bp = NULL;
1065 kmem_free(fs, sbsize);
1066 fs = NULL;
1067 goto sbagain;
1068 }
1069 }
1070 #else /* !WAPBL */
1071 if ((fs->fs_flags & FS_DOWAPBL) && (mp->mnt_flag & MNT_FORCE) == 0) {
1072 error = EPERM;
1073 goto out;
1074 }
1075 #endif /* !WAPBL */
1076
1077 ffs_oldfscompat_read(fs, ump, sblockloc);
1078 ump->um_maxfilesize = fs->fs_maxfilesize;
1079
1080 if (fs->fs_flags & ~(FS_KNOWN_FLAGS | FS_INTERNAL)) {
1081 uprintf("%s: unknown ufs flags: 0x%08"PRIx32"%s\n",
1082 mp->mnt_stat.f_mntonname, fs->fs_flags,
1083 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
1084 if ((mp->mnt_flag & MNT_FORCE) == 0) {
1085 error = EINVAL;
1086 goto out;
1087 }
1088 }
1089
1090 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
1091 fs->fs_pendingblocks = 0;
1092 fs->fs_pendinginodes = 0;
1093 }
1094
1095 ump->um_fstype = fstype;
1096 if (fs->fs_sbsize < SBLOCKSIZE)
1097 brelse(bp, BC_INVAL);
1098 else
1099 brelse(bp, 0);
1100 bp = NULL;
1101
1102 /* First check to see if this is tagged as an Apple UFS filesystem
1103 * in the disklabel
1104 */
1105 if (getdiskinfo(devvp, &dkw) == 0 &&
1106 strcmp(dkw.dkw_ptype, DKW_PTYPE_APPLEUFS) == 0)
1107 ump->um_flags |= UFS_ISAPPLEUFS;
1108 #ifdef APPLE_UFS
1109 else {
1110 /* Manually look for an apple ufs label, and if a valid one
1111 * is found, then treat it like an Apple UFS filesystem anyway
1112 */
1113 error = bread(devvp, (daddr_t)(APPLEUFS_LABEL_OFFSET / DEV_BSIZE),
1114 APPLEUFS_LABEL_SIZE, cred, 0, &bp);
1115 if (error)
1116 goto out;
1117 error = ffs_appleufs_validate(fs->fs_fsmnt,
1118 (struct appleufslabel *)bp->b_data, NULL);
1119 if (error == 0) {
1120 ump->um_flags |= UFS_ISAPPLEUFS;
1121 }
1122 brelse(bp, 0);
1123 bp = NULL;
1124 }
1125 #else
1126 if (ump->um_flags & UFS_ISAPPLEUFS) {
1127 error = EINVAL;
1128 goto out;
1129 }
1130 #endif
1131
1132 #if 0
1133 /*
1134 * XXX This code changes the behaviour of mounting dirty filesystems, to
1135 * XXX require "mount -f ..." to mount them. This doesn't match what
1136 * XXX mount(8) describes and is disabled for now.
1137 */
1138 /*
1139 * If the file system is not clean, don't allow it to be mounted
1140 * unless MNT_FORCE is specified. (Note: MNT_FORCE is always set
1141 * for the root file system.)
1142 */
1143 if (fs->fs_flags & FS_DOWAPBL) {
1144 /*
1145 * wapbl normally expects to be FS_WASCLEAN when the FS_DOWAPBL
1146 * bit is set, although there's a window in unmount where it
1147 * could be FS_ISCLEAN
1148 */
1149 if ((mp->mnt_flag & MNT_FORCE) == 0 &&
1150 (fs->fs_clean & (FS_WASCLEAN | FS_ISCLEAN)) == 0) {
1151 error = EPERM;
1152 goto out;
1153 }
1154 } else
1155 if ((fs->fs_clean & FS_ISCLEAN) == 0 &&
1156 (mp->mnt_flag & MNT_FORCE) == 0) {
1157 error = EPERM;
1158 goto out;
1159 }
1160 #endif
1161
1162 /*
1163 * verify that we can access the last block in the fs
1164 * if we're mounting read/write.
1165 */
1166
1167 if (!ronly) {
1168 error = bread(devvp, fsbtodb(fs, fs->fs_size - 1), fs->fs_fsize,
1169 cred, 0, &bp);
1170 if (bp->b_bcount != fs->fs_fsize)
1171 error = EINVAL;
1172 if (error) {
1173 bset = BC_INVAL;
1174 goto out;
1175 }
1176 brelse(bp, BC_INVAL);
1177 bp = NULL;
1178 }
1179
1180 fs->fs_ronly = ronly;
1181 /* Don't bump fs_clean if we're replaying journal */
1182 if (!((fs->fs_flags & FS_DOWAPBL) && (fs->fs_clean & FS_WASCLEAN)))
1183 if (ronly == 0) {
1184 fs->fs_clean <<= 1;
1185 fs->fs_fmod = 1;
1186 }
1187 bsize = fs->fs_cssize;
1188 blks = howmany(bsize, fs->fs_fsize);
1189 if (fs->fs_contigsumsize > 0)
1190 bsize += fs->fs_ncg * sizeof(int32_t);
1191 bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
1192 allocsbsize = bsize;
1193 space = kmem_alloc((u_long)allocsbsize, KM_SLEEP);
1194 fs->fs_csp = space;
1195 for (i = 0; i < blks; i += fs->fs_frag) {
1196 bsize = fs->fs_bsize;
1197 if (i + fs->fs_frag > blks)
1198 bsize = (blks - i) * fs->fs_fsize;
1199 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), bsize,
1200 cred, 0, &bp);
1201 if (error) {
1202 kmem_free(fs->fs_csp, allocsbsize);
1203 goto out;
1204 }
1205 #ifdef FFS_EI
1206 if (needswap)
1207 ffs_csum_swap((struct csum *)bp->b_data,
1208 (struct csum *)space, bsize);
1209 else
1210 #endif
1211 memcpy(space, bp->b_data, (u_int)bsize);
1212
1213 space = (char *)space + bsize;
1214 brelse(bp, 0);
1215 bp = NULL;
1216 }
1217 if (fs->fs_contigsumsize > 0) {
1218 fs->fs_maxcluster = lp = space;
1219 for (i = 0; i < fs->fs_ncg; i++)
1220 *lp++ = fs->fs_contigsumsize;
1221 space = lp;
1222 }
1223 bsize = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
1224 fs->fs_contigdirs = space;
1225 space = (char *)space + bsize;
1226 memset(fs->fs_contigdirs, 0, bsize);
1227 /* Compatibility for old filesystems - XXX */
1228 if (fs->fs_avgfilesize <= 0)
1229 fs->fs_avgfilesize = AVFILESIZ;
1230 if (fs->fs_avgfpdir <= 0)
1231 fs->fs_avgfpdir = AFPDIR;
1232 fs->fs_active = NULL;
1233 mp->mnt_data = ump;
1234 mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
1235 mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_FFS);
1236 mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
1237 mp->mnt_stat.f_namemax = FFS_MAXNAMLEN;
1238 if (UFS_MPISAPPLEUFS(ump)) {
1239 /* NeXT used to keep short symlinks in the inode even
1240 * when using FS_42INODEFMT. In that case fs->fs_maxsymlinklen
1241 * is probably -1, but we still need to be able to identify
1242 * short symlinks.
1243 */
1244 ump->um_maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
1245 ump->um_dirblksiz = APPLEUFS_DIRBLKSIZ;
1246 mp->mnt_iflag |= IMNT_DTYPE;
1247 } else {
1248 ump->um_maxsymlinklen = fs->fs_maxsymlinklen;
1249 ump->um_dirblksiz = DIRBLKSIZ;
1250 if (ump->um_maxsymlinklen > 0)
1251 mp->mnt_iflag |= IMNT_DTYPE;
1252 else
1253 mp->mnt_iflag &= ~IMNT_DTYPE;
1254 }
1255 mp->mnt_fs_bshift = fs->fs_bshift;
1256 mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */
1257 mp->mnt_flag |= MNT_LOCAL;
1258 mp->mnt_iflag |= IMNT_MPSAFE;
1259 #ifdef FFS_EI
1260 if (needswap)
1261 ump->um_flags |= UFS_NEEDSWAP;
1262 #endif
1263 ump->um_mountp = mp;
1264 ump->um_dev = dev;
1265 ump->um_devvp = devvp;
1266 ump->um_nindir = fs->fs_nindir;
1267 ump->um_lognindir = ffs(fs->fs_nindir) - 1;
1268 ump->um_bptrtodb = fs->fs_fshift - DEV_BSHIFT;
1269 ump->um_seqinc = fs->fs_frag;
1270 for (i = 0; i < MAXQUOTAS; i++)
1271 ump->um_quotas[i] = NULLVP;
1272 devvp->v_specmountpoint = mp;
1273 if (ronly == 0 && fs->fs_snapinum[0] != 0)
1274 ffs_snapshot_mount(mp);
1275 #ifdef WAPBL
1276 if (!ronly) {
1277 KDASSERT(fs->fs_ronly == 0);
1278 /*
1279 * ffs_wapbl_start() needs mp->mnt_stat initialised if it
1280 * needs to create a new log file in-filesystem.
1281 */
1282 ffs_statvfs(mp, &mp->mnt_stat);
1283
1284 error = ffs_wapbl_start(mp);
1285 if (error) {
1286 kmem_free(fs->fs_csp, allocsbsize);
1287 goto out;
1288 }
1289 }
1290 #endif /* WAPBL */
1291 if (ronly == 0) {
1292 #ifdef QUOTA2
1293 error = ffs_quota2_mount(mp);
1294 if (error) {
1295 kmem_free(fs->fs_csp, allocsbsize);
1296 goto out;
1297 }
1298 #else
1299 if (fs->fs_flags & FS_DOQUOTA2) {
1300 ump->um_flags |= UFS_QUOTA2;
1301 uprintf("%s: options QUOTA2 not enabled%s\n",
1302 mp->mnt_stat.f_mntonname,
1303 (mp->mnt_flag & MNT_FORCE) ? "" : ", not mounting");
1304 if ((mp->mnt_flag & MNT_FORCE) == 0) {
1305 error = EINVAL;
1306 kmem_free(fs->fs_csp, allocsbsize);
1307 goto out;
1308 }
1309 }
1310 #endif
1311 }
1312 #ifdef UFS_EXTATTR
1313 /*
1314 * Initialize file-backed extended attributes on UFS1 file
1315 * systems.
1316 */
1317 if (ump->um_fstype == UFS1)
1318 ufs_extattr_uepm_init(&ump->um_extattr);
1319 #endif /* UFS_EXTATTR */
1320
1321 return (0);
1322 out:
1323 #ifdef WAPBL
1324 if (mp->mnt_wapbl_replay) {
1325 wapbl_replay_stop(mp->mnt_wapbl_replay);
1326 wapbl_replay_free(mp->mnt_wapbl_replay);
1327 mp->mnt_wapbl_replay = 0;
1328 }
1329 #endif
1330
1331 fstrans_unmount(mp);
1332 if (fs)
1333 kmem_free(fs, fs->fs_sbsize);
1334 devvp->v_specmountpoint = NULL;
1335 if (bp)
1336 brelse(bp, bset);
1337 if (ump) {
1338 if (ump->um_oldfscompat)
1339 kmem_free(ump->um_oldfscompat, 512 + 3*sizeof(int32_t));
1340 mutex_destroy(&ump->um_lock);
1341 kmem_free(ump, sizeof(*ump));
1342 mp->mnt_data = NULL;
1343 }
1344 return (error);
1345 }
1346
1347 /*
1348 * Sanity checks for loading old filesystem superblocks.
1349 * See ffs_oldfscompat_write below for unwound actions.
1350 *
1351 * XXX - Parts get retired eventually.
1352 * Unfortunately new bits get added.
1353 */
1354 static void
1355 ffs_oldfscompat_read(struct fs *fs, struct ufsmount *ump, daddr_t sblockloc)
1356 {
1357 off_t maxfilesize;
1358 int32_t *extrasave;
1359
1360 if ((fs->fs_magic != FS_UFS1_MAGIC) ||
1361 (fs->fs_old_flags & FS_FLAGS_UPDATED))
1362 return;
1363
1364 if (!ump->um_oldfscompat)
1365 ump->um_oldfscompat = kmem_alloc(512 + 3*sizeof(int32_t),
1366 KM_SLEEP);
1367
1368 memcpy(ump->um_oldfscompat, &fs->fs_old_postbl_start, 512);
1369 extrasave = ump->um_oldfscompat;
1370 extrasave += 512/sizeof(int32_t);
1371 extrasave[0] = fs->fs_old_npsect;
1372 extrasave[1] = fs->fs_old_interleave;
1373 extrasave[2] = fs->fs_old_trackskew;
1374
1375 /* These fields will be overwritten by their
1376 * original values in fs_oldfscompat_write, so it is harmless
1377 * to modify them here.
1378 */
1379 fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
1380 fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
1381 fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
1382 fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
1383
1384 fs->fs_maxbsize = fs->fs_bsize;
1385 fs->fs_time = fs->fs_old_time;
1386 fs->fs_size = fs->fs_old_size;
1387 fs->fs_dsize = fs->fs_old_dsize;
1388 fs->fs_csaddr = fs->fs_old_csaddr;
1389 fs->fs_sblockloc = sblockloc;
1390
1391 fs->fs_flags = fs->fs_old_flags | (fs->fs_flags & FS_INTERNAL);
1392
1393 if (fs->fs_old_postblformat == FS_42POSTBLFMT) {
1394 fs->fs_old_nrpos = 8;
1395 fs->fs_old_npsect = fs->fs_old_nsect;
1396 fs->fs_old_interleave = 1;
1397 fs->fs_old_trackskew = 0;
1398 }
1399
1400 if (fs->fs_old_inodefmt < FS_44INODEFMT) {
1401 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
1402 fs->fs_qbmask = ~fs->fs_bmask;
1403 fs->fs_qfmask = ~fs->fs_fmask;
1404 }
1405
1406 maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1;
1407 if (fs->fs_maxfilesize > maxfilesize)
1408 fs->fs_maxfilesize = maxfilesize;
1409
1410 /* Compatibility for old filesystems */
1411 if (fs->fs_avgfilesize <= 0)
1412 fs->fs_avgfilesize = AVFILESIZ;
1413 if (fs->fs_avgfpdir <= 0)
1414 fs->fs_avgfpdir = AFPDIR;
1415
1416 #if 0
1417 if (bigcgs) {
1418 fs->fs_save_cgsize = fs->fs_cgsize;
1419 fs->fs_cgsize = fs->fs_bsize;
1420 }
1421 #endif
1422 }
1423
1424 /*
1425 * Unwinding superblock updates for old filesystems.
1426 * See ffs_oldfscompat_read above for details.
1427 *
1428 * XXX - Parts get retired eventually.
1429 * Unfortunately new bits get added.
1430 */
1431 static void
1432 ffs_oldfscompat_write(struct fs *fs, struct ufsmount *ump)
1433 {
1434 int32_t *extrasave;
1435
1436 if ((fs->fs_magic != FS_UFS1_MAGIC) ||
1437 (fs->fs_old_flags & FS_FLAGS_UPDATED))
1438 return;
1439
1440 fs->fs_old_time = fs->fs_time;
1441 fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
1442 fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
1443 fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
1444 fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
1445 fs->fs_old_flags = fs->fs_flags;
1446
1447 #if 0
1448 if (bigcgs) {
1449 fs->fs_cgsize = fs->fs_save_cgsize;
1450 }
1451 #endif
1452
1453 memcpy(&fs->fs_old_postbl_start, ump->um_oldfscompat, 512);
1454 extrasave = ump->um_oldfscompat;
1455 extrasave += 512/sizeof(int32_t);
1456 fs->fs_old_npsect = extrasave[0];
1457 fs->fs_old_interleave = extrasave[1];
1458 fs->fs_old_trackskew = extrasave[2];
1459
1460 }
1461
1462 /*
1463 * unmount vfs operation
1464 */
1465 int
1466 ffs_unmount(struct mount *mp, int mntflags)
1467 {
1468 struct lwp *l = curlwp;
1469 struct ufsmount *ump = VFSTOUFS(mp);
1470 struct fs *fs = ump->um_fs;
1471 int error, flags;
1472 u_int32_t bsize;
1473 #ifdef WAPBL
1474 extern int doforce;
1475 #endif
1476
1477 flags = 0;
1478 if (mntflags & MNT_FORCE)
1479 flags |= FORCECLOSE;
1480 if ((error = ffs_flushfiles(mp, flags, l)) != 0)
1481 return (error);
1482 error = UFS_WAPBL_BEGIN(mp);
1483 if (error == 0)
1484 if (fs->fs_ronly == 0 &&
1485 ffs_cgupdate(ump, MNT_WAIT) == 0 &&
1486 fs->fs_clean & FS_WASCLEAN) {
1487 fs->fs_clean = FS_ISCLEAN;
1488 fs->fs_fmod = 0;
1489 (void) ffs_sbupdate(ump, MNT_WAIT);
1490 }
1491 if (error == 0)
1492 UFS_WAPBL_END(mp);
1493 #ifdef WAPBL
1494 KASSERT(!(mp->mnt_wapbl_replay && mp->mnt_wapbl));
1495 if (mp->mnt_wapbl_replay) {
1496 KDASSERT(fs->fs_ronly);
1497 wapbl_replay_stop(mp->mnt_wapbl_replay);
1498 wapbl_replay_free(mp->mnt_wapbl_replay);
1499 mp->mnt_wapbl_replay = 0;
1500 }
1501 error = ffs_wapbl_stop(mp, doforce && (mntflags & MNT_FORCE));
1502 if (error) {
1503 return error;
1504 }
1505 #endif /* WAPBL */
1506
1507 if (ump->um_devvp->v_type != VBAD)
1508 ump->um_devvp->v_specmountpoint = NULL;
1509 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1510 (void)VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD | FWRITE,
1511 NOCRED);
1512 vput(ump->um_devvp);
1513
1514 bsize = fs->fs_cssize;
1515 if (fs->fs_contigsumsize > 0)
1516 bsize += fs->fs_ncg * sizeof(int32_t);
1517 bsize += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
1518 kmem_free(fs->fs_csp, bsize);
1519
1520 kmem_free(fs, fs->fs_sbsize);
1521 if (ump->um_oldfscompat != NULL)
1522 kmem_free(ump->um_oldfscompat, 512 + 3*sizeof(int32_t));
1523 mutex_destroy(&ump->um_lock);
1524 ffs_snapshot_fini(ump);
1525 kmem_free(ump, sizeof(*ump));
1526 mp->mnt_data = NULL;
1527 mp->mnt_flag &= ~MNT_LOCAL;
1528 fstrans_unmount(mp);
1529 return (0);
1530 }
1531
1532 /*
1533 * Flush out all the files in a filesystem.
1534 */
1535 int
1536 ffs_flushfiles(struct mount *mp, int flags, struct lwp *l)
1537 {
1538 extern int doforce;
1539 struct ufsmount *ump;
1540 int error;
1541
1542 if (!doforce)
1543 flags &= ~FORCECLOSE;
1544 ump = VFSTOUFS(mp);
1545 #ifdef QUOTA
1546 if ((error = quota1_umount(mp, flags)) != 0)
1547 return (error);
1548 #endif
1549 #ifdef QUOTA2
1550 if ((error = quota2_umount(mp, flags)) != 0)
1551 return (error);
1552 #endif
1553 #ifdef UFS_EXTATTR
1554 if (ump->um_fstype == UFS1) {
1555 if (ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_STARTED)
1556 ufs_extattr_stop(mp, l);
1557 if (ump->um_extattr.uepm_flags & UFS_EXTATTR_UEPM_INITIALIZED)
1558 ufs_extattr_uepm_destroy(&ump->um_extattr);
1559 }
1560 #endif
1561 if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0)
1562 return (error);
1563 ffs_snapshot_unmount(mp);
1564 /*
1565 * Flush all the files.
1566 */
1567 error = vflush(mp, NULLVP, flags);
1568 if (error)
1569 return (error);
1570 /*
1571 * Flush filesystem metadata.
1572 */
1573 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1574 error = VOP_FSYNC(ump->um_devvp, l->l_cred, FSYNC_WAIT, 0, 0);
1575 VOP_UNLOCK(ump->um_devvp);
1576 if (flags & FORCECLOSE) /* XXXDBJ */
1577 error = 0;
1578
1579 #ifdef WAPBL
1580 if (error)
1581 return error;
1582 if (mp->mnt_wapbl) {
1583 error = wapbl_flush(mp->mnt_wapbl, 1);
1584 if (flags & FORCECLOSE)
1585 error = 0;
1586 }
1587 #endif
1588
1589 return (error);
1590 }
1591
1592 /*
1593 * Get file system statistics.
1594 */
1595 int
1596 ffs_statvfs(struct mount *mp, struct statvfs *sbp)
1597 {
1598 struct ufsmount *ump;
1599 struct fs *fs;
1600
1601 ump = VFSTOUFS(mp);
1602 fs = ump->um_fs;
1603 mutex_enter(&ump->um_lock);
1604 sbp->f_bsize = fs->fs_bsize;
1605 sbp->f_frsize = fs->fs_fsize;
1606 sbp->f_iosize = fs->fs_bsize;
1607 sbp->f_blocks = fs->fs_dsize;
1608 sbp->f_bfree = blkstofrags(fs, fs->fs_cstotal.cs_nbfree) +
1609 fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
1610 sbp->f_bresvd = ((u_int64_t) fs->fs_dsize * (u_int64_t)
1611 fs->fs_minfree) / (u_int64_t) 100;
1612 if (sbp->f_bfree > sbp->f_bresvd)
1613 sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
1614 else
1615 sbp->f_bavail = 0;
1616 sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
1617 sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
1618 sbp->f_favail = sbp->f_ffree;
1619 sbp->f_fresvd = 0;
1620 mutex_exit(&ump->um_lock);
1621 copy_statvfs_info(sbp, mp);
1622
1623 return (0);
1624 }
1625
1626 /*
1627 * Go through the disk queues to initiate sandbagged IO;
1628 * go through the inodes to write those that have been modified;
1629 * initiate the writing of the super block if it has been modified.
1630 *
1631 * Note: we are always called with the filesystem marked `MPBUSY'.
1632 */
1633 int
1634 ffs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
1635 {
1636 struct vnode *vp, *mvp, *nvp;
1637 struct inode *ip;
1638 struct ufsmount *ump = VFSTOUFS(mp);
1639 struct fs *fs;
1640 int error, allerror = 0;
1641 bool is_suspending;
1642
1643 fs = ump->um_fs;
1644 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
1645 printf("fs = %s\n", fs->fs_fsmnt);
1646 panic("update: rofs mod");
1647 }
1648
1649 /* Allocate a marker vnode. */
1650 mvp = vnalloc(mp);
1651
1652 fstrans_start(mp, FSTRANS_SHARED);
1653 is_suspending = (fstrans_getstate(mp) == FSTRANS_SUSPENDING);
1654 /*
1655 * Write back each (modified) inode.
1656 */
1657 mutex_enter(&mntvnode_lock);
1658 loop:
1659 /*
1660 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
1661 * and vclean() can be called indirectly
1662 */
1663 for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
1664 nvp = TAILQ_NEXT(vp, v_mntvnodes);
1665 /*
1666 * If the vnode that we are about to sync is no longer
1667 * associated with this mount point, start over.
1668 */
1669 if (vp->v_mount != mp)
1670 goto loop;
1671 /*
1672 * Don't interfere with concurrent scans of this FS.
1673 */
1674 if (vismarker(vp))
1675 continue;
1676 mutex_enter(vp->v_interlock);
1677 ip = VTOI(vp);
1678
1679 /*
1680 * Skip the vnode/inode if inaccessible.
1681 */
1682 if (ip == NULL || (vp->v_iflag & (VI_XLOCK | VI_CLEAN)) != 0 ||
1683 vp->v_type == VNON) {
1684 mutex_exit(vp->v_interlock);
1685 continue;
1686 }
1687
1688 /*
1689 * We deliberately update inode times here. This will
1690 * prevent a massive queue of updates accumulating, only
1691 * to be handled by a call to unmount.
1692 *
1693 * XXX It would be better to have the syncer trickle these
1694 * out. Adjustment needed to allow registering vnodes for
1695 * sync when the vnode is clean, but the inode dirty. Or
1696 * have ufs itself trickle out inode updates.
1697 *
1698 * If doing a lazy sync, we don't care about metadata or
1699 * data updates, because they are handled by each vnode's
1700 * synclist entry. In this case we are only interested in
1701 * writing back modified inodes.
1702 */
1703 if ((ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_UPDATE |
1704 IN_MODIFY | IN_MODIFIED | IN_ACCESSED)) == 0 &&
1705 (waitfor == MNT_LAZY || (LIST_EMPTY(&vp->v_dirtyblkhd) &&
1706 UVM_OBJ_IS_CLEAN(&vp->v_uobj)))) {
1707 mutex_exit(vp->v_interlock);
1708 continue;
1709 }
1710 if (vp->v_type == VBLK && is_suspending) {
1711 mutex_exit(vp->v_interlock);
1712 continue;
1713 }
1714 vmark(mvp, vp);
1715 mutex_exit(&mntvnode_lock);
1716 error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT);
1717 if (error) {
1718 mutex_enter(&mntvnode_lock);
1719 nvp = vunmark(mvp);
1720 if (error == ENOENT) {
1721 goto loop;
1722 }
1723 continue;
1724 }
1725 if (waitfor == MNT_LAZY) {
1726 error = UFS_WAPBL_BEGIN(vp->v_mount);
1727 if (!error) {
1728 error = ffs_update(vp, NULL, NULL,
1729 UPDATE_CLOSE);
1730 UFS_WAPBL_END(vp->v_mount);
1731 }
1732 } else {
1733 error = VOP_FSYNC(vp, cred, FSYNC_NOLOG |
1734 (waitfor == MNT_WAIT ? FSYNC_WAIT : 0), 0, 0);
1735 }
1736 if (error)
1737 allerror = error;
1738 vput(vp);
1739 mutex_enter(&mntvnode_lock);
1740 nvp = vunmark(mvp);
1741 }
1742 mutex_exit(&mntvnode_lock);
1743 /*
1744 * Force stale file system control information to be flushed.
1745 */
1746 if (waitfor != MNT_LAZY && (ump->um_devvp->v_numoutput > 0 ||
1747 !LIST_EMPTY(&ump->um_devvp->v_dirtyblkhd))) {
1748 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1749 if ((error = VOP_FSYNC(ump->um_devvp, cred,
1750 (waitfor == MNT_WAIT ? FSYNC_WAIT : 0) | FSYNC_NOLOG,
1751 0, 0)) != 0)
1752 allerror = error;
1753 VOP_UNLOCK(ump->um_devvp);
1754 if (allerror == 0 && waitfor == MNT_WAIT && !mp->mnt_wapbl) {
1755 mutex_enter(&mntvnode_lock);
1756 goto loop;
1757 }
1758 }
1759 #if defined(QUOTA) || defined(QUOTA2)
1760 qsync(mp);
1761 #endif
1762 /*
1763 * Write back modified superblock.
1764 */
1765 if (fs->fs_fmod != 0) {
1766 fs->fs_fmod = 0;
1767 fs->fs_time = time_second;
1768 error = UFS_WAPBL_BEGIN(mp);
1769 if (error)
1770 allerror = error;
1771 else {
1772 if ((error = ffs_cgupdate(ump, waitfor)))
1773 allerror = error;
1774 UFS_WAPBL_END(mp);
1775 }
1776 }
1777
1778 #ifdef WAPBL
1779 if (mp->mnt_wapbl) {
1780 error = wapbl_flush(mp->mnt_wapbl, 0);
1781 if (error)
1782 allerror = error;
1783 }
1784 #endif
1785
1786 fstrans_done(mp);
1787 vnfree(mvp);
1788 return (allerror);
1789 }
1790
1791 /*
1792 * Look up a FFS dinode number to find its incore vnode, otherwise read it
1793 * in from disk. If it is in core, wait for the lock bit to clear, then
1794 * return the inode locked. Detection and handling of mount points must be
1795 * done by the calling routine.
1796 */
1797 int
1798 ffs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
1799 {
1800 struct fs *fs;
1801 struct inode *ip;
1802 struct ufsmount *ump;
1803 struct buf *bp;
1804 struct vnode *vp;
1805 dev_t dev;
1806 int error;
1807
1808 ump = VFSTOUFS(mp);
1809 dev = ump->um_dev;
1810
1811 retry:
1812 if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
1813 return (0);
1814
1815 /* Allocate a new vnode/inode. */
1816 error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, NULL, &vp);
1817 if (error) {
1818 *vpp = NULL;
1819 return (error);
1820 }
1821 ip = pool_cache_get(ffs_inode_cache, PR_WAITOK);
1822
1823 /*
1824 * If someone beat us to it, put back the freshly allocated
1825 * vnode/inode pair and retry.
1826 */
1827 mutex_enter(&ufs_hashlock);
1828 if (ufs_ihashget(dev, ino, 0) != NULL) {
1829 mutex_exit(&ufs_hashlock);
1830 ungetnewvnode(vp);
1831 pool_cache_put(ffs_inode_cache, ip);
1832 goto retry;
1833 }
1834
1835 vp->v_vflag |= VV_LOCKSWORK;
1836
1837 /*
1838 * XXX MFS ends up here, too, to allocate an inode. Should we
1839 * XXX create another pool for MFS inodes?
1840 */
1841
1842 memset(ip, 0, sizeof(struct inode));
1843 vp->v_data = ip;
1844 ip->i_vnode = vp;
1845 ip->i_ump = ump;
1846 ip->i_fs = fs = ump->um_fs;
1847 ip->i_dev = dev;
1848 ip->i_number = ino;
1849 #if defined(QUOTA) || defined(QUOTA2)
1850 ufsquota_init(ip);
1851 #endif
1852
1853 /*
1854 * Initialize genfs node, we might proceed to destroy it in
1855 * error branches.
1856 */
1857 genfs_node_init(vp, &ffs_genfsops);
1858
1859 /*
1860 * Put it onto its hash chain and lock it so that other requests for
1861 * this inode will block if they arrive while we are sleeping waiting
1862 * for old data structures to be purged or for the contents of the
1863 * disk portion of this inode to be read.
1864 */
1865
1866 ufs_ihashins(ip);
1867 mutex_exit(&ufs_hashlock);
1868
1869 /* Read in the disk contents for the inode, copy into the inode. */
1870 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1871 (int)fs->fs_bsize, NOCRED, 0, &bp);
1872 if (error) {
1873
1874 /*
1875 * The inode does not contain anything useful, so it would
1876 * be misleading to leave it on its hash chain. With mode
1877 * still zero, it will be unlinked and returned to the free
1878 * list by vput().
1879 */
1880
1881 vput(vp);
1882 brelse(bp, 0);
1883 *vpp = NULL;
1884 return (error);
1885 }
1886 if (ip->i_ump->um_fstype == UFS1)
1887 ip->i_din.ffs1_din = pool_cache_get(ffs_dinode1_cache,
1888 PR_WAITOK);
1889 else
1890 ip->i_din.ffs2_din = pool_cache_get(ffs_dinode2_cache,
1891 PR_WAITOK);
1892 ffs_load_inode(bp, ip, fs, ino);
1893 brelse(bp, 0);
1894
1895 /*
1896 * Initialize the vnode from the inode, check for aliases.
1897 * Note that the underlying vnode may have changed.
1898 */
1899
1900 ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1901
1902 /*
1903 * Finish inode initialization now that aliasing has been resolved.
1904 */
1905
1906 ip->i_devvp = ump->um_devvp;
1907 vref(ip->i_devvp);
1908
1909 /*
1910 * Ensure that uid and gid are correct. This is a temporary
1911 * fix until fsck has been changed to do the update.
1912 */
1913
1914 if (fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */
1915 ip->i_uid = ip->i_ffs1_ouid; /* XXX */
1916 ip->i_gid = ip->i_ffs1_ogid; /* XXX */
1917 } /* XXX */
1918 uvm_vnp_setsize(vp, ip->i_size);
1919 *vpp = vp;
1920 return (0);
1921 }
1922
1923 /*
1924 * File handle to vnode
1925 *
1926 * Have to be really careful about stale file handles:
1927 * - check that the inode number is valid
1928 * - call ffs_vget() to get the locked inode
1929 * - check for an unallocated inode (i_mode == 0)
1930 * - check that the given client host has export rights and return
1931 * those rights via. exflagsp and credanonp
1932 */
1933 int
1934 ffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
1935 {
1936 struct ufid ufh;
1937 struct fs *fs;
1938
1939 if (fhp->fid_len != sizeof(struct ufid))
1940 return EINVAL;
1941
1942 memcpy(&ufh, fhp, sizeof(ufh));
1943 fs = VFSTOUFS(mp)->um_fs;
1944 if (ufh.ufid_ino < ROOTINO ||
1945 ufh.ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1946 return (ESTALE);
1947 return (ufs_fhtovp(mp, &ufh, vpp));
1948 }
1949
1950 /*
1951 * Vnode pointer to File handle
1952 */
1953 /* ARGSUSED */
1954 int
1955 ffs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
1956 {
1957 struct inode *ip;
1958 struct ufid ufh;
1959
1960 if (*fh_size < sizeof(struct ufid)) {
1961 *fh_size = sizeof(struct ufid);
1962 return E2BIG;
1963 }
1964 ip = VTOI(vp);
1965 *fh_size = sizeof(struct ufid);
1966 memset(&ufh, 0, sizeof(ufh));
1967 ufh.ufid_len = sizeof(struct ufid);
1968 ufh.ufid_ino = ip->i_number;
1969 ufh.ufid_gen = ip->i_gen;
1970 memcpy(fhp, &ufh, sizeof(ufh));
1971 return (0);
1972 }
1973
1974 void
1975 ffs_init(void)
1976 {
1977 if (ffs_initcount++ > 0)
1978 return;
1979
1980 ffs_inode_cache = pool_cache_init(sizeof(struct inode), 0, 0, 0,
1981 "ffsino", NULL, IPL_NONE, NULL, NULL, NULL);
1982 ffs_dinode1_cache = pool_cache_init(sizeof(struct ufs1_dinode), 0, 0, 0,
1983 "ffsdino1", NULL, IPL_NONE, NULL, NULL, NULL);
1984 ffs_dinode2_cache = pool_cache_init(sizeof(struct ufs2_dinode), 0, 0, 0,
1985 "ffsdino2", NULL, IPL_NONE, NULL, NULL, NULL);
1986 ufs_init();
1987 }
1988
1989 void
1990 ffs_reinit(void)
1991 {
1992
1993 ufs_reinit();
1994 }
1995
1996 void
1997 ffs_done(void)
1998 {
1999 if (--ffs_initcount > 0)
2000 return;
2001
2002 ufs_done();
2003 pool_cache_destroy(ffs_dinode2_cache);
2004 pool_cache_destroy(ffs_dinode1_cache);
2005 pool_cache_destroy(ffs_inode_cache);
2006 }
2007
2008 /*
2009 * Write a superblock and associated information back to disk.
2010 */
2011 int
2012 ffs_sbupdate(struct ufsmount *mp, int waitfor)
2013 {
2014 struct fs *fs = mp->um_fs;
2015 struct buf *bp;
2016 int error = 0;
2017 u_int32_t saveflag;
2018
2019 error = ffs_getblk(mp->um_devvp,
2020 fs->fs_sblockloc / DEV_BSIZE, FFS_NOBLK,
2021 fs->fs_sbsize, false, &bp);
2022 if (error)
2023 return error;
2024 saveflag = fs->fs_flags & FS_INTERNAL;
2025 fs->fs_flags &= ~FS_INTERNAL;
2026
2027 memcpy(bp->b_data, fs, fs->fs_sbsize);
2028
2029 ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
2030 #ifdef FFS_EI
2031 if (mp->um_flags & UFS_NEEDSWAP)
2032 ffs_sb_swap((struct fs *)bp->b_data, (struct fs *)bp->b_data);
2033 #endif
2034 fs->fs_flags |= saveflag;
2035
2036 if (waitfor == MNT_WAIT)
2037 error = bwrite(bp);
2038 else
2039 bawrite(bp);
2040 return (error);
2041 }
2042
2043 int
2044 ffs_cgupdate(struct ufsmount *mp, int waitfor)
2045 {
2046 struct fs *fs = mp->um_fs;
2047 struct buf *bp;
2048 int blks;
2049 void *space;
2050 int i, size, error = 0, allerror = 0;
2051
2052 allerror = ffs_sbupdate(mp, waitfor);
2053 blks = howmany(fs->fs_cssize, fs->fs_fsize);
2054 space = fs->fs_csp;
2055 for (i = 0; i < blks; i += fs->fs_frag) {
2056 size = fs->fs_bsize;
2057 if (i + fs->fs_frag > blks)
2058 size = (blks - i) * fs->fs_fsize;
2059 error = ffs_getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
2060 FFS_NOBLK, size, false, &bp);
2061 if (error)
2062 break;
2063 #ifdef FFS_EI
2064 if (mp->um_flags & UFS_NEEDSWAP)
2065 ffs_csum_swap((struct csum*)space,
2066 (struct csum*)bp->b_data, size);
2067 else
2068 #endif
2069 memcpy(bp->b_data, space, (u_int)size);
2070 space = (char *)space + size;
2071 if (waitfor == MNT_WAIT)
2072 error = bwrite(bp);
2073 else
2074 bawrite(bp);
2075 }
2076 if (!allerror && error)
2077 allerror = error;
2078 return (allerror);
2079 }
2080
2081 int
2082 ffs_extattrctl(struct mount *mp, int cmd, struct vnode *vp,
2083 int attrnamespace, const char *attrname)
2084 {
2085 #ifdef UFS_EXTATTR
2086 /*
2087 * File-backed extended attributes are only supported on UFS1.
2088 * UFS2 has native extended attributes.
2089 */
2090 if (VFSTOUFS(mp)->um_fstype == UFS1)
2091 return (ufs_extattrctl(mp, cmd, vp, attrnamespace, attrname));
2092 #endif
2093 return (vfs_stdextattrctl(mp, cmd, vp, attrnamespace, attrname));
2094 }
2095
2096 int
2097 ffs_suspendctl(struct mount *mp, int cmd)
2098 {
2099 int error;
2100 struct lwp *l = curlwp;
2101
2102 switch (cmd) {
2103 case SUSPEND_SUSPEND:
2104 if ((error = fstrans_setstate(mp, FSTRANS_SUSPENDING)) != 0)
2105 return error;
2106 error = ffs_sync(mp, MNT_WAIT, l->l_proc->p_cred);
2107 if (error == 0)
2108 error = fstrans_setstate(mp, FSTRANS_SUSPENDED);
2109 #ifdef WAPBL
2110 if (error == 0 && mp->mnt_wapbl)
2111 error = wapbl_flush(mp->mnt_wapbl, 1);
2112 #endif
2113 if (error != 0) {
2114 (void) fstrans_setstate(mp, FSTRANS_NORMAL);
2115 return error;
2116 }
2117 return 0;
2118
2119 case SUSPEND_RESUME:
2120 return fstrans_setstate(mp, FSTRANS_NORMAL);
2121
2122 default:
2123 return EINVAL;
2124 }
2125 }
2126
2127 /*
2128 * Synch vnode for a mounted file system.
2129 */
2130 static int
2131 ffs_vfs_fsync(vnode_t *vp, int flags)
2132 {
2133 int error, i, pflags;
2134 #ifdef WAPBL
2135 struct mount *mp;
2136 #endif
2137
2138 KASSERT(vp->v_type == VBLK);
2139 KASSERT(vp->v_specmountpoint != NULL);
2140
2141 /*
2142 * Flush all dirty data associated with the vnode.
2143 */
2144 pflags = PGO_ALLPAGES | PGO_CLEANIT;
2145 if ((flags & FSYNC_WAIT) != 0)
2146 pflags |= PGO_SYNCIO;
2147 mutex_enter(vp->v_interlock);
2148 error = VOP_PUTPAGES(vp, 0, 0, pflags);
2149 if (error)
2150 return error;
2151
2152 #ifdef WAPBL
2153 mp = vp->v_specmountpoint;
2154 if (mp && mp->mnt_wapbl) {
2155 /*
2156 * Don't bother writing out metadata if the syncer is
2157 * making the request. We will let the sync vnode
2158 * write it out in a single burst through a call to
2159 * VFS_SYNC().
2160 */
2161 if ((flags & (FSYNC_DATAONLY | FSYNC_LAZY | FSYNC_NOLOG)) != 0)
2162 return 0;
2163
2164 /*
2165 * Don't flush the log if the vnode being flushed
2166 * contains no dirty buffers that could be in the log.
2167 */
2168 if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
2169 error = wapbl_flush(mp->mnt_wapbl, 0);
2170 if (error)
2171 return error;
2172 }
2173
2174 if ((flags & FSYNC_WAIT) != 0) {
2175 mutex_enter(vp->v_interlock);
2176 while (vp->v_numoutput)
2177 cv_wait(&vp->v_cv, vp->v_interlock);
2178 mutex_exit(vp->v_interlock);
2179 }
2180
2181 return 0;
2182 }
2183 #endif /* WAPBL */
2184
2185 error = vflushbuf(vp, flags);
2186 if (error == 0 && (flags & FSYNC_CACHE) != 0) {
2187 i = 1;
2188 (void)VOP_IOCTL(vp, DIOCCACHESYNC, &i, FWRITE,
2189 kauth_cred_get());
2190 }
2191
2192 return error;
2193 }
2194