1/*
2 * Copyright (c) 1989, 1991, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95
34 */
35
36#include <sys/cdefs.h>
|
37__FBSDID("$FreeBSD: head/sys/ufs/ffs/ffs_vfsops.c 121847 2003-11-01 05:51:54Z kan $");
|
| 37__FBSDID("$FreeBSD: head/sys/ufs/ffs/ffs_vfsops.c 121874 2003-11-02 04:52:53Z kan $"); |
38
39#include "opt_mac.h"
40#include "opt_quota.h"
41#include "opt_ufs.h"
42
43#include <sys/param.h>
44#include <sys/systm.h>
45#include <sys/namei.h>
46#include <sys/proc.h>
47#include <sys/kernel.h>
48#include <sys/mac.h>
49#include <sys/vnode.h>
50#include <sys/mount.h>
51#include <sys/bio.h>
52#include <sys/buf.h>
53#include <sys/conf.h>
54#include <sys/fcntl.h>
55#include <sys/disk.h>
56#include <sys/malloc.h>
57#include <sys/mutex.h>
58
59#include <ufs/ufs/extattr.h>
60#include <ufs/ufs/quota.h>
61#include <ufs/ufs/ufsmount.h>
62#include <ufs/ufs/inode.h>
63#include <ufs/ufs/ufs_extern.h>
64
65#include <ufs/ffs/fs.h>
66#include <ufs/ffs/ffs_extern.h>
67
68#include <vm/vm.h>
69#include <vm/uma.h>
70#include <vm/vm_page.h>
71
72uma_zone_t uma_inode, uma_ufs1, uma_ufs2;
73
74static int ffs_sbupdate(struct ufsmount *, int);
75 int ffs_reload(struct mount *,struct ucred *,struct thread *);
76static int ffs_mountfs(struct vnode *, struct mount *, struct thread *);
77static void ffs_oldfscompat_read(struct fs *, struct ufsmount *,
78 ufs2_daddr_t);
79static void ffs_oldfscompat_write(struct fs *, struct ufsmount *);
80static void ffs_ifree(struct ufsmount *ump, struct inode *ip);
81static vfs_init_t ffs_init;
82static vfs_uninit_t ffs_uninit;
83static vfs_extattrctl_t ffs_extattrctl;
84
85static struct vfsops ufs_vfsops = {
86 .vfs_extattrctl = ffs_extattrctl,
87 .vfs_fhtovp = ffs_fhtovp,
88 .vfs_init = ffs_init,
89 .vfs_mount = ffs_mount,
90 .vfs_quotactl = ufs_quotactl,
91 .vfs_root = ufs_root,
92 .vfs_start = ufs_start,
93 .vfs_statfs = ffs_statfs,
94 .vfs_sync = ffs_sync,
95 .vfs_uninit = ffs_uninit,
96 .vfs_unmount = ffs_unmount,
97 .vfs_vget = ffs_vget,
98 .vfs_vptofh = ffs_vptofh,
99};
100
101VFS_SET(ufs_vfsops, ufs, 0);
102
103/*
104 * ffs_mount
105 *
106 * Called when mounting local physical media
107 *
108 * PARAMETERS:
109 * mountroot
110 * mp mount point structure
111 * path NULL (flag for root mount!!!)
112 * data <unused>
113 * ndp <unused>
114 * p process (user credentials check [statfs])
115 *
116 * mount
117 * mp mount point structure
118 * path path to mount point
119 * data pointer to argument struct in user space
120 * ndp mount point namei() return (used for
121 * credentials on reload), reused to look
122 * up block device.
123 * p process (user credentials check)
124 *
125 * RETURNS: 0 Success
126 * !0 error number (errno.h)
127 *
128 * LOCK STATE:
129 *
130 * ENTRY
131 * mount point is locked
132 * EXIT
133 * mount point is locked
134 *
135 * NOTES:
136 * A NULL path can be used for a flag since the mount
137 * system call will fail with EFAULT in copyinstr in
138 * namei() if it is a genuine NULL from the user.
139 */
140int
141ffs_mount(mp, path, data, ndp, td)
142 struct mount *mp; /* mount struct pointer*/
143 char *path; /* path to mount point*/
144 caddr_t data; /* arguments to FS specific mount*/
145 struct nameidata *ndp; /* mount point credentials*/
146 struct thread *td; /* process requesting mount*/
147{
148 size_t size;
149 struct vnode *devvp;
150 struct ufs_args args;
151 struct ufsmount *ump = 0;
152 struct fs *fs;
153 int error, flags;
154 mode_t accessmode;
155
156 if (uma_inode == NULL) {
157 uma_inode = uma_zcreate("FFS inode",
158 sizeof(struct inode), NULL, NULL, NULL, NULL,
159 UMA_ALIGN_PTR, 0);
160 uma_ufs1 = uma_zcreate("FFS1 dinode",
161 sizeof(struct ufs1_dinode), NULL, NULL, NULL, NULL,
162 UMA_ALIGN_PTR, 0);
163 uma_ufs2 = uma_zcreate("FFS2 dinode",
164 sizeof(struct ufs2_dinode), NULL, NULL, NULL, NULL,
165 UMA_ALIGN_PTR, 0);
166 }
167 /*
168 * Use NULL path to indicate we are mounting the root filesystem.
169 */
170 if (path == NULL) {
171 if ((error = bdevvp(rootdev, &rootvp))) {
172 printf("ffs_mountroot: can't find rootvp\n");
173 return (error);
174 }
175
176 if ((error = ffs_mountfs(rootvp, mp, td)) != 0)
177 return (error);
178 (void)VFS_STATFS(mp, &mp->mnt_stat, td);
179 return (0);
180 }
181
182 /*
183 * Mounting non-root filesystem or updating a filesystem
184 */
185 if ((error = copyin(data, (caddr_t)&args, sizeof(struct ufs_args)))!= 0)
186 return (error);
187
188 /*
189 * If updating, check whether changing from read-only to
190 * read/write; if there is no device name, that's all we do.
191 */
192 if (mp->mnt_flag & MNT_UPDATE) {
193 ump = VFSTOUFS(mp);
194 fs = ump->um_fs;
195 devvp = ump->um_devvp;
196 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
197 if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
198 return (error);
199 /*
200 * Flush any dirty data.
201 */
202 if ((error = VFS_SYNC(mp, MNT_WAIT,
203 td->td_ucred, td)) != 0) {
204 vn_finished_write(mp);
205 return (error);
206 }
207 /*
208 * Check for and optionally get rid of files open
209 * for writing.
210 */
211 flags = WRITECLOSE;
212 if (mp->mnt_flag & MNT_FORCE)
213 flags |= FORCECLOSE;
214 if (mp->mnt_flag & MNT_SOFTDEP) {
215 error = softdep_flushfiles(mp, flags, td);
216 } else {
217 error = ffs_flushfiles(mp, flags, td);
218 }
219 if (error) {
220 vn_finished_write(mp);
221 return (error);
222 }
223 if (fs->fs_pendingblocks != 0 ||
224 fs->fs_pendinginodes != 0) {
225 printf("%s: %s: blocks %jd files %d\n",
226 fs->fs_fsmnt, "update error",
227 (intmax_t)fs->fs_pendingblocks,
228 fs->fs_pendinginodes);
229 fs->fs_pendingblocks = 0;
230 fs->fs_pendinginodes = 0;
231 }
232 fs->fs_ronly = 1;
233 if ((fs->fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) == 0)
234 fs->fs_clean = 1;
235 if ((error = ffs_sbupdate(ump, MNT_WAIT)) != 0) {
236 fs->fs_ronly = 0;
237 fs->fs_clean = 0;
238 vn_finished_write(mp);
239 return (error);
240 }
241 vn_finished_write(mp);
242 }
243 if ((mp->mnt_flag & MNT_RELOAD) &&
244 (error = ffs_reload(mp, ndp->ni_cnd.cn_cred, td)) != 0)
245 return (error);
246 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
247 /*
248 * If upgrade to read-write by non-root, then verify
249 * that user has necessary permissions on the device.
250 */
251 if (suser(td)) {
252 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
253 if ((error = VOP_ACCESS(devvp, VREAD | VWRITE,
254 td->td_ucred, td)) != 0) {
255 VOP_UNLOCK(devvp, 0, td);
256 return (error);
257 }
258 VOP_UNLOCK(devvp, 0, td);
259 }
260 fs->fs_flags &= ~FS_UNCLEAN;
261 if (fs->fs_clean == 0) {
262 fs->fs_flags |= FS_UNCLEAN;
263 if ((mp->mnt_flag & MNT_FORCE) ||
264 ((fs->fs_flags & FS_NEEDSFSCK) == 0 &&
265 (fs->fs_flags & FS_DOSOFTDEP))) {
266 printf("WARNING: %s was not %s\n",
267 fs->fs_fsmnt, "properly dismounted");
268 } else {
269 printf(
270"WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
271 fs->fs_fsmnt);
272 return (EPERM);
273 }
274 }
275 if ((error = vn_start_write(NULL, &mp, V_WAIT)) != 0)
276 return (error);
277 fs->fs_ronly = 0;
278 fs->fs_clean = 0;
279 if ((error = ffs_sbupdate(ump, MNT_WAIT)) != 0) {
280 vn_finished_write(mp);
281 return (error);
282 }
283 /* check to see if we need to start softdep */
284 if ((fs->fs_flags & FS_DOSOFTDEP) &&
285 (error = softdep_mount(devvp, mp, fs, td->td_ucred))){
286 vn_finished_write(mp);
287 return (error);
288 }
289 if (fs->fs_snapinum[0] != 0)
290 ffs_snapshot_mount(mp);
291 vn_finished_write(mp);
292 }
293 /*
294 * Soft updates is incompatible with "async",
295 * so if we are doing softupdates stop the user
296 * from setting the async flag in an update.
297 * Softdep_mount() clears it in an initial mount
298 * or ro->rw remount.
299 */
300 if (mp->mnt_flag & MNT_SOFTDEP)
301 mp->mnt_flag &= ~MNT_ASYNC;
302 /*
303 * If not updating name, process export requests.
304 */
305 if (args.fspec == 0)
306 return (vfs_export(mp, &args.export));
307 /*
308 * If this is a snapshot request, take the snapshot.
309 */
310 if (mp->mnt_flag & MNT_SNAPSHOT)
311 return (ffs_snapshot(mp, args.fspec));
312 }
313
314 /*
315 * Not an update, or updating the name: look up the name
316 * and verify that it refers to a sensible block device.
317 */
318 NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, td);
319 if ((error = namei(ndp)) != 0)
320 return (error);
321 NDFREE(ndp, NDF_ONLY_PNBUF);
322 devvp = ndp->ni_vp;
323 if (!vn_isdisk(devvp, &error)) {
324 vrele(devvp);
325 return (error);
326 }
327
328 /*
329 * If mount by non-root, then verify that user has necessary
330 * permissions on the device.
331 */
332 if (suser(td)) {
333 accessmode = VREAD;
334 if ((mp->mnt_flag & MNT_RDONLY) == 0)
335 accessmode |= VWRITE;
336 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
337 if ((error = VOP_ACCESS(devvp, accessmode, td->td_ucred, td))!= 0){
338 vput(devvp);
339 return (error);
340 }
341 VOP_UNLOCK(devvp, 0, td);
342 }
343
344 if (mp->mnt_flag & MNT_UPDATE) {
345 /*
346 * Update only
347 *
348 * If it's not the same vnode, or at least the same device
349 * then it's not correct.
350 */
351
352 if (devvp != ump->um_devvp &&
353 devvp->v_rdev != ump->um_devvp->v_rdev)
354 error = EINVAL; /* needs translation */
355 vrele(devvp);
356 if (error)
357 return (error);
358 } else {
359 /*
360 * New mount
361 *
362 * We need the name for the mount point (also used for
363 * "last mounted on") copied in. If an error occurs,
364 * the mount point is discarded by the upper level code.
365 * Note that vfs_mount() populates f_mntonname for us.
366 */
367 if ((error = ffs_mountfs(devvp, mp, td)) != 0) {
368 vrele(devvp);
369 return (error);
370 }
371 }
372 /*
373 * Save "mounted from" device name info for mount point (NULL pad).
374 */
375 copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &size);
376 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
377 /*
378 * Initialize filesystem stat information in mount struct.
379 */
380 (void)VFS_STATFS(mp, &mp->mnt_stat, td);
381 return (0);
382}
383
384/*
385 * Reload all incore data for a filesystem (used after running fsck on
386 * the root filesystem and finding things to fix). The filesystem must
387 * be mounted read-only.
388 *
389 * Things to do to update the mount:
390 * 1) invalidate all cached meta-data.
391 * 2) re-read superblock from disk.
392 * 3) re-read summary information from disk.
393 * 4) invalidate all inactive vnodes.
394 * 5) invalidate all cached file data.
395 * 6) re-read inode data for all active vnodes.
396 */
397int
398ffs_reload(mp, cred, td)
399 struct mount *mp;
400 struct ucred *cred;
401 struct thread *td;
402{
403 struct vnode *vp, *nvp, *devvp;
404 struct inode *ip;
405 void *space;
406 struct buf *bp;
407 struct fs *fs, *newfs;
408 ufs2_daddr_t sblockloc;
409 int i, blks, size, error;
410 int32_t *lp;
411
412 if ((mp->mnt_flag & MNT_RDONLY) == 0)
413 return (EINVAL);
414 /*
415 * Step 1: invalidate all cached meta-data.
416 */
417 devvp = VFSTOUFS(mp)->um_devvp;
418 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
419 error = vinvalbuf(devvp, 0, cred, td, 0, 0);
420 VOP_UNLOCK(devvp, 0, td);
421 if (error)
422 panic("ffs_reload: dirty1");
423
424 /*
425 * Only VMIO the backing device if the backing device is a real
426 * block device.
427 */
428 if (vn_isdisk(devvp, NULL)) {
429 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
430 vfs_object_create(devvp, td, td->td_ucred);
431 VOP_UNLOCK(devvp, 0, td);
432 }
433
434 /*
435 * Step 2: re-read superblock from disk.
436 */
437 fs = VFSTOUFS(mp)->um_fs;
438 if ((error = bread(devvp, btodb(fs->fs_sblockloc), fs->fs_sbsize,
439 NOCRED, &bp)) != 0)
440 return (error);
441 newfs = (struct fs *)bp->b_data;
442 if ((newfs->fs_magic != FS_UFS1_MAGIC &&
443 newfs->fs_magic != FS_UFS2_MAGIC) ||
444 newfs->fs_bsize > MAXBSIZE ||
445 newfs->fs_bsize < sizeof(struct fs)) {
446 brelse(bp);
447 return (EIO); /* XXX needs translation */
448 }
449 /*
450 * Copy pointer fields back into superblock before copying in XXX
451 * new superblock. These should really be in the ufsmount. XXX
452 * Note that important parameters (eg fs_ncg) are unchanged.
453 */
454 newfs->fs_csp = fs->fs_csp;
455 newfs->fs_maxcluster = fs->fs_maxcluster;
456 newfs->fs_contigdirs = fs->fs_contigdirs;
457 newfs->fs_active = fs->fs_active;
458 sblockloc = fs->fs_sblockloc;
459 bcopy(newfs, fs, (u_int)fs->fs_sbsize);
460 brelse(bp);
461 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
462 ffs_oldfscompat_read(fs, VFSTOUFS(mp), sblockloc);
463 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
464 printf("%s: reload pending error: blocks %jd files %d\n",
465 fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
466 fs->fs_pendinginodes);
467 fs->fs_pendingblocks = 0;
468 fs->fs_pendinginodes = 0;
469 }
470
471 /*
472 * Step 3: re-read summary information from disk.
473 */
474 blks = howmany(fs->fs_cssize, fs->fs_fsize);
475 space = fs->fs_csp;
476 for (i = 0; i < blks; i += fs->fs_frag) {
477 size = fs->fs_bsize;
478 if (i + fs->fs_frag > blks)
479 size = (blks - i) * fs->fs_fsize;
480 error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
481 NOCRED, &bp);
482 if (error)
483 return (error);
484 bcopy(bp->b_data, space, (u_int)size);
485 space = (char *)space + size;
486 brelse(bp);
487 }
488 /*
489 * We no longer know anything about clusters per cylinder group.
490 */
491 if (fs->fs_contigsumsize > 0) {
492 lp = fs->fs_maxcluster;
493 for (i = 0; i < fs->fs_ncg; i++)
494 *lp++ = fs->fs_contigsumsize;
495 }
496
497loop:
498 mtx_lock(&mntvnode_mtx);
499 for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
500 if (vp->v_mount != mp) {
501 mtx_unlock(&mntvnode_mtx);
502 goto loop;
503 }
504 nvp = TAILQ_NEXT(vp, v_nmntvnodes);
505 VI_LOCK(vp);
506 if (vp->v_iflag & VI_XLOCK) {
507 VI_UNLOCK(vp);
508 continue;
509 }
510 mtx_unlock(&mntvnode_mtx);
511 /*
512 * Step 4: invalidate all inactive vnodes.
513 */
514 if (vp->v_usecount == 0) {
515 vgonel(vp, td);
516 goto loop;
517 }
518 /*
519 * Step 5: invalidate all cached file data.
520 */
521 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
522 goto loop;
523 }
524 if (vinvalbuf(vp, 0, cred, td, 0, 0))
525 panic("ffs_reload: dirty2");
526 /*
527 * Step 6: re-read inode data for all active vnodes.
528 */
529 ip = VTOI(vp);
530 error =
531 bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
532 (int)fs->fs_bsize, NOCRED, &bp);
533 if (error) {
534 vput(vp);
535 return (error);
536 }
537 ffs_load_inode(bp, ip, fs, ip->i_number);
538 ip->i_effnlink = ip->i_nlink;
539 brelse(bp);
|
540 vput(vp);
|
540 VOP_UNLOCK(vp, 0, td);
541 vrele(vp); |
542 mtx_lock(&mntvnode_mtx);
543 }
544 mtx_unlock(&mntvnode_mtx);
545 return (0);
546}
547
548/*
549 * Possible superblock locations ordered from most to least likely.
550 */
551static int sblock_try[] = SBLOCKSEARCH;
552
553/*
554 * Common code for mount and mountroot
555 */
556static int
557ffs_mountfs(devvp, mp, td)
558 struct vnode *devvp;
559 struct mount *mp;
560 struct thread *td;
561{
562 struct ufsmount *ump;
563 struct buf *bp;
564 struct fs *fs;
565 dev_t dev;
566 void *space;
567 ufs2_daddr_t sblockloc;
568 int error, i, blks, size, ronly;
569 int32_t *lp;
570 struct ucred *cred;
571 size_t strsize;
572 int ncount;
573
574 dev = devvp->v_rdev;
575 cred = td ? td->td_ucred : NOCRED;
576 /*
577 * Disallow multiple mounts of the same device.
578 * Disallow mounting of a device that is currently in use
579 * (except for root, which might share swap device for miniroot).
580 * Flush out any old buffers remaining from a previous use.
581 */
582 error = vfs_mountedon(devvp);
583 if (error)
584 return (error);
585 ncount = vcount(devvp);
586
587 if (ncount > 1 && devvp != rootvp)
588 return (EBUSY);
589 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
590 error = vinvalbuf(devvp, V_SAVE, cred, td, 0, 0);
591 VOP_UNLOCK(devvp, 0, td);
592 if (error)
593 return (error);
594
595 /*
596 * Only VMIO the backing device if the backing device is a real
597 * block device.
598 * Note that it is optional that the backing device be VMIOed. This
599 * increases the opportunity for metadata caching.
600 */
601 if (vn_isdisk(devvp, NULL)) {
602 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
603 vfs_object_create(devvp, td, cred);
604 VOP_UNLOCK(devvp, 0, td);
605 }
606
607 ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
608 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY, td);
609 /*
610 * XXX: We don't re-VOP_OPEN in FREAD|FWRITE mode if the filesystem
611 * XXX: is subsequently remounted, so open it FREAD|FWRITE from the
612 * XXX: start to avoid getting trashed later on.
613 */
614#ifdef notyet
615 error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, td, -1);
616#else
617 error = VOP_OPEN(devvp, FREAD|FWRITE, FSCRED, td, -1);
618#endif
619 VOP_UNLOCK(devvp, 0, td);
620 if (error)
621 return (error);
622 if (devvp->v_rdev->si_iosize_max != 0)
623 mp->mnt_iosize_max = devvp->v_rdev->si_iosize_max;
624 if (mp->mnt_iosize_max > MAXPHYS)
625 mp->mnt_iosize_max = MAXPHYS;
626
627 bp = NULL;
628 ump = NULL;
629 fs = NULL;
630 sblockloc = 0;
631 /*
632 * Try reading the superblock in each of its possible locations.
633 */
634 for (i = 0; sblock_try[i] != -1; i++) {
635 if ((error = bread(devvp, sblock_try[i] / DEV_BSIZE, SBLOCKSIZE,
636 cred, &bp)) != 0)
637 goto out;
638 fs = (struct fs *)bp->b_data;
639 sblockloc = sblock_try[i];
640 if ((fs->fs_magic == FS_UFS1_MAGIC ||
641 (fs->fs_magic == FS_UFS2_MAGIC &&
642 (fs->fs_sblockloc == sblockloc ||
643 (fs->fs_old_flags & FS_FLAGS_UPDATED) == 0))) &&
644 fs->fs_bsize <= MAXBSIZE &&
645 fs->fs_bsize >= sizeof(struct fs))
646 break;
647 brelse(bp);
648 bp = NULL;
649 }
650 if (sblock_try[i] == -1) {
651 error = EINVAL; /* XXX needs translation */
652 goto out;
653 }
654 fs->fs_fmod = 0;
655 fs->fs_flags &= ~FS_INDEXDIRS; /* no support for directory indicies */
656 fs->fs_flags &= ~FS_UNCLEAN;
657 if (fs->fs_clean == 0) {
658 fs->fs_flags |= FS_UNCLEAN;
659 if (ronly || (mp->mnt_flag & MNT_FORCE) ||
660 ((fs->fs_flags & FS_NEEDSFSCK) == 0 &&
661 (fs->fs_flags & FS_DOSOFTDEP))) {
662 printf(
663"WARNING: %s was not properly dismounted\n",
664 fs->fs_fsmnt);
665 } else {
666 printf(
667"WARNING: R/W mount of %s denied. Filesystem is not clean - run fsck\n",
668 fs->fs_fsmnt);
669 error = EPERM;
670 goto out;
671 }
672 if ((fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) &&
673 (mp->mnt_flag & MNT_FORCE)) {
674 printf("%s: lost blocks %jd files %d\n", fs->fs_fsmnt,
675 (intmax_t)fs->fs_pendingblocks,
676 fs->fs_pendinginodes);
677 fs->fs_pendingblocks = 0;
678 fs->fs_pendinginodes = 0;
679 }
680 }
681 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
682 printf("%s: mount pending error: blocks %jd files %d\n",
683 fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
684 fs->fs_pendinginodes);
685 fs->fs_pendingblocks = 0;
686 fs->fs_pendinginodes = 0;
687 }
688 ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK | M_ZERO);
689 ump->um_fs = malloc((u_long)fs->fs_sbsize, M_UFSMNT,
690 M_WAITOK);
691 if (fs->fs_magic == FS_UFS1_MAGIC) {
692 ump->um_fstype = UFS1;
693 ump->um_balloc = ffs_balloc_ufs1;
694 } else {
695 ump->um_fstype = UFS2;
696 ump->um_balloc = ffs_balloc_ufs2;
697 }
698 ump->um_blkatoff = ffs_blkatoff;
699 ump->um_truncate = ffs_truncate;
700 ump->um_update = ffs_update;
701 ump->um_valloc = ffs_valloc;
702 ump->um_vfree = ffs_vfree;
703 ump->um_ifree = ffs_ifree;
704 bcopy(bp->b_data, ump->um_fs, (u_int)fs->fs_sbsize);
705 if (fs->fs_sbsize < SBLOCKSIZE)
706 bp->b_flags |= B_INVAL | B_NOCACHE;
707 brelse(bp);
708 bp = NULL;
709 fs = ump->um_fs;
710 ffs_oldfscompat_read(fs, ump, sblockloc);
711 fs->fs_ronly = ronly;
712 size = fs->fs_cssize;
713 blks = howmany(size, fs->fs_fsize);
714 if (fs->fs_contigsumsize > 0)
715 size += fs->fs_ncg * sizeof(int32_t);
716 size += fs->fs_ncg * sizeof(u_int8_t);
717 space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
718 fs->fs_csp = space;
719 for (i = 0; i < blks; i += fs->fs_frag) {
720 size = fs->fs_bsize;
721 if (i + fs->fs_frag > blks)
722 size = (blks - i) * fs->fs_fsize;
723 if ((error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
724 cred, &bp)) != 0) {
725 free(fs->fs_csp, M_UFSMNT);
726 goto out;
727 }
728 bcopy(bp->b_data, space, (u_int)size);
729 space = (char *)space + size;
730 brelse(bp);
731 bp = NULL;
732 }
733 if (fs->fs_contigsumsize > 0) {
734 fs->fs_maxcluster = lp = space;
735 for (i = 0; i < fs->fs_ncg; i++)
736 *lp++ = fs->fs_contigsumsize;
737 space = lp;
738 }
739 size = fs->fs_ncg * sizeof(u_int8_t);
740 fs->fs_contigdirs = (u_int8_t *)space;
741 bzero(fs->fs_contigdirs, size);
742 fs->fs_active = NULL;
743 mp->mnt_data = (qaddr_t)ump;
744 mp->mnt_stat.f_fsid.val[0] = fs->fs_id[0];
745 mp->mnt_stat.f_fsid.val[1] = fs->fs_id[1];
746 if (fs->fs_id[0] == 0 || fs->fs_id[1] == 0 ||
747 vfs_getvfs(&mp->mnt_stat.f_fsid))
748 vfs_getnewfsid(mp);
749 mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
750 mp->mnt_flag |= MNT_LOCAL;
751 if ((fs->fs_flags & FS_MULTILABEL) != 0)
752#ifdef MAC
753 mp->mnt_flag |= MNT_MULTILABEL;
754#else
755 printf(
756"WARNING: %s: multilabel flag on fs but no MAC support\n",
757 fs->fs_fsmnt);
758#endif
759 if ((fs->fs_flags & FS_ACLS) != 0)
760#ifdef UFS_ACL
761 mp->mnt_flag |= MNT_ACLS;
762#else
763 printf(
764"WARNING: %s: ACLs flag on fs but no ACLs support\n",
765 fs->fs_fsmnt);
766#endif
767 ump->um_mountp = mp;
768 ump->um_dev = dev;
769 ump->um_devvp = devvp;
770 ump->um_nindir = fs->fs_nindir;
771 ump->um_bptrtodb = fs->fs_fsbtodb;
772 ump->um_seqinc = fs->fs_frag;
773 for (i = 0; i < MAXQUOTAS; i++)
774 ump->um_quotas[i] = NULLVP;
775#ifdef UFS_EXTATTR
776 ufs_extattr_uepm_init(&ump->um_extattr);
777#endif
778 devvp->v_rdev->si_mountpoint = mp;
779
780 /*
781 * Set FS local "last mounted on" information (NULL pad)
782 */
783 copystr( mp->mnt_stat.f_mntonname, /* mount point*/
784 fs->fs_fsmnt, /* copy area*/
785 sizeof(fs->fs_fsmnt) - 1, /* max size*/
786 &strsize); /* real size*/
787 bzero( fs->fs_fsmnt + strsize, sizeof(fs->fs_fsmnt) - strsize);
788
789 if( mp->mnt_flag & MNT_ROOTFS) {
790 /*
791 * Root mount; update timestamp in mount structure.
792 * this will be used by the common root mount code
793 * to update the system clock.
794 */
795 mp->mnt_time = fs->fs_time;
796 }
797
798 if (ronly == 0) {
799 if ((fs->fs_flags & FS_DOSOFTDEP) &&
800 (error = softdep_mount(devvp, mp, fs, cred)) != 0) {
801 free(fs->fs_csp, M_UFSMNT);
802 goto out;
803 }
804 if (fs->fs_snapinum[0] != 0)
805 ffs_snapshot_mount(mp);
806 fs->fs_fmod = 1;
807 fs->fs_clean = 0;
808 (void) ffs_sbupdate(ump, MNT_WAIT);
809 }
810#ifdef UFS_EXTATTR
811#ifdef UFS_EXTATTR_AUTOSTART
812 /*
813 *
814 * Auto-starting does the following:
815 * - check for /.attribute in the fs, and extattr_start if so
816 * - for each file in .attribute, enable that file with
817 * an attribute of the same name.
818 * Not clear how to report errors -- probably eat them.
819 * This would all happen while the filesystem was busy/not
820 * available, so would effectively be "atomic".
821 */
822 (void) ufs_extattr_autostart(mp, td);
823#endif /* !UFS_EXTATTR_AUTOSTART */
824#endif /* !UFS_EXTATTR */
825 return (0);
826out:
827 devvp->v_rdev->si_mountpoint = NULL;
828 if (bp)
829 brelse(bp);
830 /* XXX: see comment above VOP_OPEN */
831#ifdef notyet
832 (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, td);
833#else
834 (void)VOP_CLOSE(devvp, FREAD|FWRITE, cred, td);
835#endif
836 if (ump) {
837 free(ump->um_fs, M_UFSMNT);
838 free(ump, M_UFSMNT);
839 mp->mnt_data = (qaddr_t)0;
840 }
841 return (error);
842}
843
844#include <sys/sysctl.h>
845int bigcgs = 0;
846SYSCTL_INT(_debug, OID_AUTO, bigcgs, CTLFLAG_RW, &bigcgs, 0, "");
847
848/*
849 * Sanity checks for loading old filesystem superblocks.
850 * See ffs_oldfscompat_write below for unwound actions.
851 *
852 * XXX - Parts get retired eventually.
853 * Unfortunately new bits get added.
854 */
855static void
856ffs_oldfscompat_read(fs, ump, sblockloc)
857 struct fs *fs;
858 struct ufsmount *ump;
859 ufs2_daddr_t sblockloc;
860{
861 off_t maxfilesize;
862
863 /*
864 * If not yet done, update fs_flags location and value of fs_sblockloc.
865 */
866 if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) {
867 fs->fs_flags = fs->fs_old_flags;
868 fs->fs_old_flags |= FS_FLAGS_UPDATED;
869 fs->fs_sblockloc = sblockloc;
870 }
871 /*
872 * If not yet done, update UFS1 superblock with new wider fields.
873 */
874 if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_maxbsize != fs->fs_bsize) {
875 fs->fs_maxbsize = fs->fs_bsize;
876 fs->fs_time = fs->fs_old_time;
877 fs->fs_size = fs->fs_old_size;
878 fs->fs_dsize = fs->fs_old_dsize;
879 fs->fs_csaddr = fs->fs_old_csaddr;
880 fs->fs_cstotal.cs_ndir = fs->fs_old_cstotal.cs_ndir;
881 fs->fs_cstotal.cs_nbfree = fs->fs_old_cstotal.cs_nbfree;
882 fs->fs_cstotal.cs_nifree = fs->fs_old_cstotal.cs_nifree;
883 fs->fs_cstotal.cs_nffree = fs->fs_old_cstotal.cs_nffree;
884 }
885 if (fs->fs_magic == FS_UFS1_MAGIC &&
886 fs->fs_old_inodefmt < FS_44INODEFMT) {
887 fs->fs_maxfilesize = (u_quad_t) 1LL << 39;
888 fs->fs_qbmask = ~fs->fs_bmask;
889 fs->fs_qfmask = ~fs->fs_fmask;
890 }
891 if (fs->fs_magic == FS_UFS1_MAGIC) {
892 ump->um_savedmaxfilesize = fs->fs_maxfilesize;
893 maxfilesize = (u_int64_t)0x40000000 * fs->fs_bsize - 1;
894 if (fs->fs_maxfilesize > maxfilesize)
895 fs->fs_maxfilesize = maxfilesize;
896 }
897 /* Compatibility for old filesystems */
898 if (fs->fs_avgfilesize <= 0)
899 fs->fs_avgfilesize = AVFILESIZ;
900 if (fs->fs_avgfpdir <= 0)
901 fs->fs_avgfpdir = AFPDIR;
902 if (bigcgs) {
903 fs->fs_save_cgsize = fs->fs_cgsize;
904 fs->fs_cgsize = fs->fs_bsize;
905 }
906}
907
908/*
909 * Unwinding superblock updates for old filesystems.
910 * See ffs_oldfscompat_read above for details.
911 *
912 * XXX - Parts get retired eventually.
913 * Unfortunately new bits get added.
914 */
915static void
916ffs_oldfscompat_write(fs, ump)
917 struct fs *fs;
918 struct ufsmount *ump;
919{
920
921 /*
922 * Copy back UFS2 updated fields that UFS1 inspects.
923 */
924 if (fs->fs_magic == FS_UFS1_MAGIC) {
925 fs->fs_old_time = fs->fs_time;
926 fs->fs_old_cstotal.cs_ndir = fs->fs_cstotal.cs_ndir;
927 fs->fs_old_cstotal.cs_nbfree = fs->fs_cstotal.cs_nbfree;
928 fs->fs_old_cstotal.cs_nifree = fs->fs_cstotal.cs_nifree;
929 fs->fs_old_cstotal.cs_nffree = fs->fs_cstotal.cs_nffree;
930 fs->fs_maxfilesize = ump->um_savedmaxfilesize;
931 }
932 if (bigcgs) {
933 fs->fs_cgsize = fs->fs_save_cgsize;
934 fs->fs_save_cgsize = 0;
935 }
936}
937
938/*
939 * unmount system call
940 */
941int
942ffs_unmount(mp, mntflags, td)
943 struct mount *mp;
944 int mntflags;
945 struct thread *td;
946{
947 struct ufsmount *ump = VFSTOUFS(mp);
948 struct fs *fs;
949 int error, flags;
950
951 flags = 0;
952 if (mntflags & MNT_FORCE) {
953 flags |= FORCECLOSE;
954 }
955#ifdef UFS_EXTATTR
956 if ((error = ufs_extattr_stop(mp, td))) {
957 if (error != EOPNOTSUPP)
958 printf("ffs_unmount: ufs_extattr_stop returned %d\n",
959 error);
960 } else {
961 ufs_extattr_uepm_destroy(&ump->um_extattr);
962 }
963#endif
964 if (mp->mnt_flag & MNT_SOFTDEP) {
965 if ((error = softdep_flushfiles(mp, flags, td)) != 0)
966 return (error);
967 } else {
968 if ((error = ffs_flushfiles(mp, flags, td)) != 0)
969 return (error);
970 }
971 fs = ump->um_fs;
972 if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
973 printf("%s: unmount pending error: blocks %jd files %d\n",
974 fs->fs_fsmnt, (intmax_t)fs->fs_pendingblocks,
975 fs->fs_pendinginodes);
976 fs->fs_pendingblocks = 0;
977 fs->fs_pendinginodes = 0;
978 }
979 if (fs->fs_ronly == 0) {
980 fs->fs_clean = fs->fs_flags & (FS_UNCLEAN|FS_NEEDSFSCK) ? 0 : 1;
981 error = ffs_sbupdate(ump, MNT_WAIT);
982 if (error) {
983 fs->fs_clean = 0;
984 return (error);
985 }
986 }
987 ump->um_devvp->v_rdev->si_mountpoint = NULL;
988
989 vinvalbuf(ump->um_devvp, V_SAVE, NOCRED, td, 0, 0);
990 /* XXX: see comment above VOP_OPEN */
991#ifdef notyet
992 error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
993 NOCRED, td);
994#else
995 error = VOP_CLOSE(ump->um_devvp, FREAD|FWRITE, NOCRED, td);
996#endif
997
998 vrele(ump->um_devvp);
999
1000 free(fs->fs_csp, M_UFSMNT);
1001 free(fs, M_UFSMNT);
1002 free(ump, M_UFSMNT);
1003 mp->mnt_data = (qaddr_t)0;
1004 mp->mnt_flag &= ~MNT_LOCAL;
1005 return (error);
1006}
1007
1008/*
1009 * Flush out all the files in a filesystem.
1010 */
1011int
1012ffs_flushfiles(mp, flags, td)
1013 struct mount *mp;
1014 int flags;
1015 struct thread *td;
1016{
1017 struct ufsmount *ump;
1018 int error;
1019
1020 ump = VFSTOUFS(mp);
1021#ifdef QUOTA
1022 if (mp->mnt_flag & MNT_QUOTA) {
1023 int i;
1024 error = vflush(mp, 0, SKIPSYSTEM|flags);
1025 if (error)
1026 return (error);
1027 for (i = 0; i < MAXQUOTAS; i++) {
1028 if (ump->um_quotas[i] == NULLVP)
1029 continue;
1030 quotaoff(td, mp, i);
1031 }
1032 /*
1033 * Here we fall through to vflush again to ensure
1034 * that we have gotten rid of all the system vnodes.
1035 */
1036 }
1037#endif
1038 ASSERT_VOP_LOCKED(ump->um_devvp, "ffs_flushfiles");
1039 if (ump->um_devvp->v_vflag & VV_COPYONWRITE) {
1040 if ((error = vflush(mp, 0, SKIPSYSTEM | flags)) != 0)
1041 return (error);
1042 ffs_snapshot_unmount(mp);
1043 /*
1044 * Here we fall through to vflush again to ensure
1045 * that we have gotten rid of all the system vnodes.
1046 */
1047 }
1048 /*
1049 * Flush all the files.
1050 */
1051 if ((error = vflush(mp, 0, flags)) != 0)
1052 return (error);
1053 /*
1054 * Flush filesystem metadata.
1055 */
1056 vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY, td);
1057 error = VOP_FSYNC(ump->um_devvp, td->td_ucred, MNT_WAIT, td);
1058 VOP_UNLOCK(ump->um_devvp, 0, td);
1059 return (error);
1060}
1061
1062/*
1063 * Get filesystem statistics.
1064 */
1065int
1066ffs_statfs(mp, sbp, td)
1067 struct mount *mp;
1068 struct statfs *sbp;
1069 struct thread *td;
1070{
1071 struct ufsmount *ump;
1072 struct fs *fs;
1073
1074 ump = VFSTOUFS(mp);
1075 fs = ump->um_fs;
1076 if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)
1077 panic("ffs_statfs");
1078 sbp->f_bsize = fs->fs_fsize;
1079 sbp->f_iosize = fs->fs_bsize;
1080 sbp->f_blocks = fs->fs_dsize;
1081 sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
1082 fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
1083 sbp->f_bavail = freespace(fs, fs->fs_minfree) +
1084 dbtofsb(fs, fs->fs_pendingblocks);
1085 sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
1086 sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
1087 if (sbp != &mp->mnt_stat) {
1088 sbp->f_type = mp->mnt_vfc->vfc_typenum;
1089 bcopy((caddr_t)mp->mnt_stat.f_mntonname,
1090 (caddr_t)&sbp->f_mntonname[0], MNAMELEN);
1091 bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
1092 (caddr_t)&sbp->f_mntfromname[0], MNAMELEN);
1093 }
1094 return (0);
1095}
1096
1097/*
1098 * Go through the disk queues to initiate sandbagged IO;
1099 * go through the inodes to write those that have been modified;
1100 * initiate the writing of the super block if it has been modified.
1101 *
1102 * Note: we are always called with the filesystem marked `MPBUSY'.
1103 */
1104int
1105ffs_sync(mp, waitfor, cred, td)
1106 struct mount *mp;
1107 int waitfor;
1108 struct ucred *cred;
1109 struct thread *td;
1110{
1111 struct vnode *nvp, *vp, *devvp;
1112 struct inode *ip;
1113 struct ufsmount *ump = VFSTOUFS(mp);
1114 struct fs *fs;
1115 int error, count, wait, lockreq, allerror = 0;
1116
1117 fs = ump->um_fs;
1118 if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
1119 printf("fs = %s\n", fs->fs_fsmnt);
1120 panic("ffs_sync: rofs mod");
1121 }
1122 /*
1123 * Write back each (modified) inode.
1124 */
1125 wait = 0;
1126 lockreq = LK_EXCLUSIVE | LK_NOWAIT;
1127 if (waitfor == MNT_WAIT) {
1128 wait = 1;
1129 lockreq = LK_EXCLUSIVE;
1130 }
1131 lockreq |= LK_INTERLOCK;
1132 mtx_lock(&mntvnode_mtx);
1133loop:
1134 for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist); vp != NULL; vp = nvp) {
1135 /*
1136 * If the vnode that we are about to sync is no longer
1137 * associated with this mount point, start over.
1138 */
1139 if (vp->v_mount != mp)
1140 goto loop;
1141
1142 /*
1143 * Depend on the mntvnode_slock to keep things stable enough
1144 * for a quick test. Since there might be hundreds of
1145 * thousands of vnodes, we cannot afford even a subroutine
1146 * call unless there's a good chance that we have work to do.
1147 */
1148 nvp = TAILQ_NEXT(vp, v_nmntvnodes);
1149 VI_LOCK(vp);
1150 if (vp->v_iflag & VI_XLOCK) {
1151 VI_UNLOCK(vp);
1152 continue;
1153 }
1154 ip = VTOI(vp);
1155 if (vp->v_type == VNON || ((ip->i_flag &
1156 (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0 &&
1157 TAILQ_EMPTY(&vp->v_dirtyblkhd))) {
1158 VI_UNLOCK(vp);
1159 continue;
1160 }
1161 mtx_unlock(&mntvnode_mtx);
1162 if ((error = vget(vp, lockreq, td)) != 0) {
1163 mtx_lock(&mntvnode_mtx);
1164 if (error == ENOENT)
1165 goto loop;
1166 continue;
1167 }
1168 if ((error = VOP_FSYNC(vp, cred, waitfor, td)) != 0)
1169 allerror = error;
|
1169 vput(vp);
|
1170 VOP_UNLOCK(vp, 0, td);
1171 vrele(vp); |
1172 mtx_lock(&mntvnode_mtx);
1173 if (TAILQ_NEXT(vp, v_nmntvnodes) != nvp)
1174 goto loop;
1175 }
1176 mtx_unlock(&mntvnode_mtx);
1177 /*
1178 * Force stale filesystem control information to be flushed.
1179 */
1180 if (waitfor == MNT_WAIT) {
1181 if ((error = softdep_flushworklist(ump->um_mountp, &count, td)))
1182 allerror = error;
1183 /* Flushed work items may create new vnodes to clean */
1184 if (allerror == 0 && count) {
1185 mtx_lock(&mntvnode_mtx);
1186 goto loop;
1187 }
1188 }
1189#ifdef QUOTA
1190 qsync(mp);
1191#endif
1192 devvp = ump->um_devvp;
1193 VI_LOCK(devvp);
1194 if (waitfor != MNT_LAZY &&
1195 (devvp->v_numoutput > 0 || TAILQ_FIRST(&devvp->v_dirtyblkhd))) {
1196 vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK, td);
1197 if ((error = VOP_FSYNC(devvp, cred, waitfor, td)) != 0)
1198 allerror = error;
1199 VOP_UNLOCK(devvp, 0, td);
1200 if (allerror == 0 && waitfor == MNT_WAIT) {
1201 mtx_lock(&mntvnode_mtx);
1202 goto loop;
1203 }
1204 } else
1205 VI_UNLOCK(devvp);
1206 /*
1207 * Write back modified superblock.
1208 */
1209 if (fs->fs_fmod != 0 && (error = ffs_sbupdate(ump, waitfor)) != 0)
1210 allerror = error;
1211 return (allerror);
1212}
1213
1214int
1215ffs_vget(mp, ino, flags, vpp)
1216 struct mount *mp;
1217 ino_t ino;
1218 int flags;
1219 struct vnode **vpp;
1220{
1221 struct thread *td = curthread; /* XXX */
1222 struct fs *fs;
1223 struct inode *ip;
1224 struct ufsmount *ump;
1225 struct buf *bp;
1226 struct vnode *vp;
1227 dev_t dev;
1228 int error;
1229
1230 ump = VFSTOUFS(mp);
1231 dev = ump->um_dev;
1232
1233 /*
1234 * We do not lock vnode creation as it is believed to be too
1235 * expensive for such rare case as simultaneous creation of vnode
1236 * for same ino by different processes. We just allow them to race
1237 * and check later to decide who wins. Let the race begin!
1238 */
1239 if ((error = ufs_ihashget(dev, ino, flags, vpp)) != 0)
1240 return (error);
1241 if (*vpp != NULL)
1242 return (0);
1243
1244 /*
1245 * If this MALLOC() is performed after the getnewvnode()
1246 * it might block, leaving a vnode with a NULL v_data to be
1247 * found by ffs_sync() if a sync happens to fire right then,
1248 * which will cause a panic because ffs_sync() blindly
1249 * dereferences vp->v_data (as well it should).
1250 */
1251 ip = uma_zalloc(uma_inode, M_WAITOK);
1252
1253 /* Allocate a new vnode/inode. */
1254 error = getnewvnode("ufs", mp, ffs_vnodeop_p, &vp);
1255 if (error) {
1256 *vpp = NULL;
1257 uma_zfree(uma_inode, ip);
1258 return (error);
1259 }
1260 bzero((caddr_t)ip, sizeof(struct inode));
1261 /*
1262 * FFS supports recursive locking.
1263 */
1264 vp->v_vnlock->lk_flags |= LK_CANRECURSE;
1265 vp->v_data = ip;
1266 ip->i_vnode = vp;
1267 ip->i_ump = ump;
1268 ip->i_fs = fs = ump->um_fs;
1269 ip->i_dev = dev;
1270 ip->i_number = ino;
1271#ifdef QUOTA
1272 {
1273 int i;
1274 for (i = 0; i < MAXQUOTAS; i++)
1275 ip->i_dquot[i] = NODQUOT;
1276 }
1277#endif
1278 /*
1279 * Exclusively lock the vnode before adding to hash. Note, that we
1280 * must not release nor downgrade the lock (despite flags argument
1281 * says) till it is fully initialized.
1282 */
1283 lockmgr(vp->v_vnlock, LK_EXCLUSIVE, (struct mtx *)0, td);
1284
1285 /*
1286 * Atomicaly (in terms of ufs_hash operations) check the hash for
1287 * duplicate of vnode being created and add it to the hash. If a
1288 * duplicate vnode was found, it will be vget()ed from hash for us.
1289 */
1290 if ((error = ufs_ihashins(ip, flags, vpp)) != 0) {
1291 vput(vp);
1292 *vpp = NULL;
1293 return (error);
1294 }
1295
1296 /* We lost the race, then throw away our vnode and return existing */
1297 if (*vpp != NULL) {
1298 vput(vp);
1299 return (0);
1300 }
1301
1302 /* Read in the disk contents for the inode, copy into the inode. */
1303 error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1304 (int)fs->fs_bsize, NOCRED, &bp);
1305 if (error) {
1306 /*
1307 * The inode does not contain anything useful, so it would
1308 * be misleading to leave it on its hash chain. With mode
1309 * still zero, it will be unlinked and returned to the free
1310 * list by vput().
1311 */
1312 brelse(bp);
1313 vput(vp);
1314 *vpp = NULL;
1315 return (error);
1316 }
1317 if (ip->i_ump->um_fstype == UFS1)
1318 ip->i_din1 = uma_zalloc(uma_ufs1, M_WAITOK);
1319 else
1320 ip->i_din2 = uma_zalloc(uma_ufs2, M_WAITOK);
1321 ffs_load_inode(bp, ip, fs, ino);
1322 if (DOINGSOFTDEP(vp))
1323 softdep_load_inodeblock(ip);
1324 else
1325 ip->i_effnlink = ip->i_nlink;
1326 bqrelse(bp);
1327
1328 /*
1329 * Initialize the vnode from the inode, check for aliases.
1330 * Note that the underlying vnode may have changed.
1331 */
1332 error = ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1333 if (error) {
1334 vput(vp);
1335 *vpp = NULL;
1336 return (error);
1337 }
1338 /*
1339 * Finish inode initialization.
1340 */
1341 VREF(ip->i_devvp);
1342 /*
1343 * Set up a generation number for this inode if it does not
1344 * already have one. This should only happen on old filesystems.
1345 */
1346 if (ip->i_gen == 0) {
1347 ip->i_gen = arc4random() / 2 + 1;
1348 if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
1349 ip->i_flag |= IN_MODIFIED;
1350 DIP(ip, i_gen) = ip->i_gen;
1351 }
1352 }
1353 /*
1354 * Ensure that uid and gid are correct. This is a temporary
1355 * fix until fsck has been changed to do the update.
1356 */
1357 if (fs->fs_magic == FS_UFS1_MAGIC && /* XXX */
1358 fs->fs_old_inodefmt < FS_44INODEFMT) { /* XXX */
1359 ip->i_uid = ip->i_din1->di_ouid; /* XXX */
1360 ip->i_gid = ip->i_din1->di_ogid; /* XXX */
1361 } /* XXX */
1362
1363#ifdef MAC
1364 if ((mp->mnt_flag & MNT_MULTILABEL) && ip->i_mode) {
1365 /*
1366 * If this vnode is already allocated, and we're running
1367 * multi-label, attempt to perform a label association
1368 * from the extended attributes on the inode.
1369 */
1370 error = mac_associate_vnode_extattr(mp, vp);
1371 if (error) {
1372 /* ufs_inactive will release ip->i_devvp ref. */
1373 vput(vp);
1374 *vpp = NULL;
1375 return (error);
1376 }
1377 }
1378#endif
1379
1380 *vpp = vp;
1381 return (0);
1382}
1383
1384/*
1385 * File handle to vnode
1386 *
1387 * Have to be really careful about stale file handles:
1388 * - check that the inode number is valid
1389 * - call ffs_vget() to get the locked inode
1390 * - check for an unallocated inode (i_mode == 0)
1391 * - check that the given client host has export rights and return
1392 * those rights via. exflagsp and credanonp
1393 */
1394int
1395ffs_fhtovp(mp, fhp, vpp)
1396 struct mount *mp;
1397 struct fid *fhp;
1398 struct vnode **vpp;
1399{
1400 struct ufid *ufhp;
1401 struct fs *fs;
1402
1403 ufhp = (struct ufid *)fhp;
1404 fs = VFSTOUFS(mp)->um_fs;
1405 if (ufhp->ufid_ino < ROOTINO ||
1406 ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1407 return (ESTALE);
1408 return (ufs_fhtovp(mp, ufhp, vpp));
1409}
1410
1411/*
1412 * Vnode pointer to File handle
1413 */
1414/* ARGSUSED */
1415int
1416ffs_vptofh(vp, fhp)
1417 struct vnode *vp;
1418 struct fid *fhp;
1419{
1420 struct inode *ip;
1421 struct ufid *ufhp;
1422
1423 ip = VTOI(vp);
1424 ufhp = (struct ufid *)fhp;
1425 ufhp->ufid_len = sizeof(struct ufid);
1426 ufhp->ufid_ino = ip->i_number;
1427 ufhp->ufid_gen = ip->i_gen;
1428 return (0);
1429}
1430
1431/*
1432 * Initialize the filesystem.
1433 */
1434static int
1435ffs_init(vfsp)
1436 struct vfsconf *vfsp;
1437{
1438
1439 softdep_initialize();
1440 return (ufs_init(vfsp));
1441}
1442
1443/*
1444 * Undo the work of ffs_init().
1445 */
1446static int
1447ffs_uninit(vfsp)
1448 struct vfsconf *vfsp;
1449{
1450 int ret;
1451
1452 ret = ufs_uninit(vfsp);
1453 softdep_uninitialize();
1454 return (ret);
1455}
1456
1457/*
1458 * Write a superblock and associated information back to disk.
1459 */
1460static int
1461ffs_sbupdate(mp, waitfor)
1462 struct ufsmount *mp;
1463 int waitfor;
1464{
1465 struct fs *fs = mp->um_fs;
1466 struct buf *bp;
1467 int blks;
1468 void *space;
1469 int i, size, error, allerror = 0;
1470
1471 if (fs->fs_ronly == 1 &&
1472 (mp->um_mountp->mnt_flag & (MNT_RDONLY | MNT_UPDATE)) !=
1473 (MNT_RDONLY | MNT_UPDATE))
1474 panic("ffs_sbupdate: write read-only filesystem");
1475 /*
1476 * First write back the summary information.
1477 */
1478 blks = howmany(fs->fs_cssize, fs->fs_fsize);
1479 space = fs->fs_csp;
1480 for (i = 0; i < blks; i += fs->fs_frag) {
1481 size = fs->fs_bsize;
1482 if (i + fs->fs_frag > blks)
1483 size = (blks - i) * fs->fs_fsize;
1484 bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1485 size, 0, 0, 0);
1486 bcopy(space, bp->b_data, (u_int)size);
1487 space = (char *)space + size;
1488 if (waitfor != MNT_WAIT)
1489 bawrite(bp);
1490 else if ((error = bwrite(bp)) != 0)
1491 allerror = error;
1492 }
1493 /*
1494 * Now write back the superblock itself. If any errors occurred
1495 * up to this point, then fail so that the superblock avoids
1496 * being written out as clean.
1497 */
1498 if (allerror)
1499 return (allerror);
1500 if (fs->fs_magic == FS_UFS1_MAGIC && fs->fs_sblockloc != SBLOCK_UFS1 &&
1501 (fs->fs_flags & FS_FLAGS_UPDATED) == 0) {
1502 printf("%s: correcting fs_sblockloc from %jd to %d\n",
1503 fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS1);
1504 fs->fs_sblockloc = SBLOCK_UFS1;
1505 }
1506 if (fs->fs_magic == FS_UFS2_MAGIC && fs->fs_sblockloc != SBLOCK_UFS2 &&
1507 (fs->fs_flags & FS_FLAGS_UPDATED) == 0) {
1508 printf("%s: correcting fs_sblockloc from %jd to %d\n",
1509 fs->fs_fsmnt, fs->fs_sblockloc, SBLOCK_UFS2);
1510 fs->fs_sblockloc = SBLOCK_UFS2;
1511 }
1512 bp = getblk(mp->um_devvp, btodb(fs->fs_sblockloc), (int)fs->fs_sbsize,
1513 0, 0, 0);
1514 fs->fs_fmod = 0;
1515 fs->fs_time = time_second;
1516 bcopy((caddr_t)fs, bp->b_data, (u_int)fs->fs_sbsize);
1517 ffs_oldfscompat_write((struct fs *)bp->b_data, mp);
1518 if (waitfor != MNT_WAIT)
1519 bawrite(bp);
1520 else if ((error = bwrite(bp)) != 0)
1521 allerror = error;
1522 return (allerror);
1523}
1524
1525static int
1526ffs_extattrctl(struct mount *mp, int cmd, struct vnode *filename_vp,
1527 int attrnamespace, const char *attrname, struct thread *td)
1528{
1529
1530#ifdef UFS_EXTATTR
1531 return (ufs_extattrctl(mp, cmd, filename_vp, attrnamespace,
1532 attrname, td));
1533#else
1534 return (vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace,
1535 attrname, td));
1536#endif
1537}
1538
1539static void
1540ffs_ifree(struct ufsmount *ump, struct inode *ip)
1541{
1542
1543 if (ump->um_fstype == UFS1 && ip->i_din1 != NULL)
1544 uma_zfree(uma_ufs1, ip->i_din1);
1545 else if (ip->i_din2 != NULL)
1546 uma_zfree(uma_ufs2, ip->i_din2);
1547 uma_zfree(uma_inode, ip);
1548}
|