ffs_vfsops.c revision 1.80.2.7 1 1.80.2.7 nathanw /* $NetBSD: ffs_vfsops.c,v 1.80.2.7 2002/04/01 07:49:17 nathanw Exp $ */
2 1.4 cgd
3 1.1 mycroft /*
4 1.1 mycroft * Copyright (c) 1989, 1991, 1993, 1994
5 1.1 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 mycroft *
7 1.1 mycroft * Redistribution and use in source and binary forms, with or without
8 1.1 mycroft * modification, are permitted provided that the following conditions
9 1.1 mycroft * are met:
10 1.1 mycroft * 1. Redistributions of source code must retain the above copyright
11 1.1 mycroft * notice, this list of conditions and the following disclaimer.
12 1.1 mycroft * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 mycroft * notice, this list of conditions and the following disclaimer in the
14 1.1 mycroft * documentation and/or other materials provided with the distribution.
15 1.1 mycroft * 3. All advertising materials mentioning features or use of this software
16 1.1 mycroft * must display the following acknowledgement:
17 1.1 mycroft * This product includes software developed by the University of
18 1.1 mycroft * California, Berkeley and its contributors.
19 1.1 mycroft * 4. Neither the name of the University nor the names of its contributors
20 1.1 mycroft * may be used to endorse or promote products derived from this software
21 1.1 mycroft * without specific prior written permission.
22 1.1 mycroft *
23 1.1 mycroft * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 1.1 mycroft * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 1.1 mycroft * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 1.1 mycroft * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 1.1 mycroft * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 1.1 mycroft * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 1.1 mycroft * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 1.1 mycroft * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 1.1 mycroft * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 1.1 mycroft * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 1.1 mycroft * SUCH DAMAGE.
34 1.1 mycroft *
35 1.33 fvdl * @(#)ffs_vfsops.c 8.31 (Berkeley) 5/20/95
36 1.1 mycroft */
37 1.80.2.5 nathanw
38 1.80.2.5 nathanw #include <sys/cdefs.h>
39 1.80.2.7 nathanw __KERNEL_RCSID(0, "$NetBSD: ffs_vfsops.c,v 1.80.2.7 2002/04/01 07:49:17 nathanw Exp $");
40 1.36 scottr
41 1.80.2.2 nathanw #if defined(_KERNEL_OPT)
42 1.45 thorpej #include "opt_ffs.h"
43 1.36 scottr #include "opt_quota.h"
44 1.41 jonathan #include "opt_compat_netbsd.h"
45 1.66 matt #include "opt_softdep.h"
46 1.37 scottr #endif
47 1.1 mycroft
48 1.1 mycroft #include <sys/param.h>
49 1.1 mycroft #include <sys/systm.h>
50 1.1 mycroft #include <sys/namei.h>
51 1.80.2.1 nathanw #include <sys/lwp.h>
52 1.1 mycroft #include <sys/proc.h>
53 1.1 mycroft #include <sys/kernel.h>
54 1.1 mycroft #include <sys/vnode.h>
55 1.1 mycroft #include <sys/socket.h>
56 1.1 mycroft #include <sys/mount.h>
57 1.1 mycroft #include <sys/buf.h>
58 1.23 thorpej #include <sys/device.h>
59 1.1 mycroft #include <sys/mbuf.h>
60 1.1 mycroft #include <sys/file.h>
61 1.1 mycroft #include <sys/disklabel.h>
62 1.1 mycroft #include <sys/ioctl.h>
63 1.1 mycroft #include <sys/errno.h>
64 1.1 mycroft #include <sys/malloc.h>
65 1.43 thorpej #include <sys/pool.h>
66 1.29 fvdl #include <sys/lock.h>
67 1.33 fvdl #include <sys/sysctl.h>
68 1.1 mycroft
69 1.1 mycroft #include <miscfs/specfs/specdev.h>
70 1.1 mycroft
71 1.1 mycroft #include <ufs/ufs/quota.h>
72 1.1 mycroft #include <ufs/ufs/ufsmount.h>
73 1.1 mycroft #include <ufs/ufs/inode.h>
74 1.25 bouyer #include <ufs/ufs/dir.h>
75 1.1 mycroft #include <ufs/ufs/ufs_extern.h>
76 1.34 bouyer #include <ufs/ufs/ufs_bswap.h>
77 1.1 mycroft
78 1.1 mycroft #include <ufs/ffs/fs.h>
79 1.1 mycroft #include <ufs/ffs/ffs_extern.h>
80 1.1 mycroft
81 1.59 jdolecek /* how many times ffs_init() was called */
82 1.59 jdolecek int ffs_initcount = 0;
83 1.59 jdolecek
84 1.29 fvdl extern struct lock ufs_hashlock;
85 1.29 fvdl
86 1.32 thorpej extern struct vnodeopv_desc ffs_vnodeop_opv_desc;
87 1.32 thorpej extern struct vnodeopv_desc ffs_specop_opv_desc;
88 1.32 thorpej extern struct vnodeopv_desc ffs_fifoop_opv_desc;
89 1.32 thorpej
90 1.79 jdolecek const struct vnodeopv_desc * const ffs_vnodeopv_descs[] = {
91 1.32 thorpej &ffs_vnodeop_opv_desc,
92 1.32 thorpej &ffs_specop_opv_desc,
93 1.32 thorpej &ffs_fifoop_opv_desc,
94 1.32 thorpej NULL,
95 1.32 thorpej };
96 1.32 thorpej
97 1.17 mycroft struct vfsops ffs_vfsops = {
98 1.17 mycroft MOUNT_FFS,
99 1.1 mycroft ffs_mount,
100 1.1 mycroft ufs_start,
101 1.1 mycroft ffs_unmount,
102 1.1 mycroft ufs_root,
103 1.1 mycroft ufs_quotactl,
104 1.1 mycroft ffs_statfs,
105 1.1 mycroft ffs_sync,
106 1.1 mycroft ffs_vget,
107 1.1 mycroft ffs_fhtovp,
108 1.1 mycroft ffs_vptofh,
109 1.1 mycroft ffs_init,
110 1.80.2.4 nathanw ffs_reinit,
111 1.59 jdolecek ffs_done,
112 1.33 fvdl ffs_sysctl,
113 1.23 thorpej ffs_mountroot,
114 1.48 wrstuden ufs_check_export,
115 1.32 thorpej ffs_vnodeopv_descs,
116 1.1 mycroft };
117 1.1 mycroft
118 1.80.2.4 nathanw struct genfs_ops ffs_genfsops = {
119 1.80.2.4 nathanw ffs_gop_size,
120 1.80.2.4 nathanw ffs_gop_alloc,
121 1.80.2.4 nathanw genfs_gop_write,
122 1.80.2.4 nathanw };
123 1.80.2.4 nathanw
124 1.43 thorpej struct pool ffs_inode_pool;
125 1.43 thorpej
126 1.1 mycroft /*
127 1.33 fvdl * Called by main() when ffs is going to be mounted as root.
128 1.1 mycroft */
129 1.1 mycroft
130 1.19 christos int
131 1.1 mycroft ffs_mountroot()
132 1.1 mycroft {
133 1.33 fvdl struct fs *fs;
134 1.33 fvdl struct mount *mp;
135 1.80.2.1 nathanw struct proc *p = curproc->l_proc; /* XXX */
136 1.1 mycroft struct ufsmount *ump;
137 1.1 mycroft int error;
138 1.23 thorpej
139 1.23 thorpej if (root_device->dv_class != DV_DISK)
140 1.23 thorpej return (ENODEV);
141 1.23 thorpej
142 1.1 mycroft /*
143 1.26 mrg * Get vnodes for rootdev.
144 1.1 mycroft */
145 1.26 mrg if (bdevvp(rootdev, &rootvp))
146 1.1 mycroft panic("ffs_mountroot: can't setup bdevvp's");
147 1.1 mycroft
148 1.51 wrstuden if ((error = vfs_rootmountalloc(MOUNT_FFS, "root_device", &mp))) {
149 1.51 wrstuden vrele(rootvp);
150 1.33 fvdl return (error);
151 1.51 wrstuden }
152 1.19 christos if ((error = ffs_mountfs(rootvp, mp, p)) != 0) {
153 1.33 fvdl mp->mnt_op->vfs_refcount--;
154 1.33 fvdl vfs_unbusy(mp);
155 1.1 mycroft free(mp, M_MOUNT);
156 1.51 wrstuden vrele(rootvp);
157 1.1 mycroft return (error);
158 1.1 mycroft }
159 1.33 fvdl simple_lock(&mountlist_slock);
160 1.11 mycroft CIRCLEQ_INSERT_TAIL(&mountlist, mp, mnt_list);
161 1.33 fvdl simple_unlock(&mountlist_slock);
162 1.1 mycroft ump = VFSTOUFS(mp);
163 1.1 mycroft fs = ump->um_fs;
164 1.42 perry memset(fs->fs_fsmnt, 0, sizeof(fs->fs_fsmnt));
165 1.33 fvdl (void)copystr(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN - 1, 0);
166 1.1 mycroft (void)ffs_statfs(mp, &mp->mnt_stat, p);
167 1.33 fvdl vfs_unbusy(mp);
168 1.1 mycroft inittodr(fs->fs_time);
169 1.1 mycroft return (0);
170 1.1 mycroft }
171 1.1 mycroft
172 1.1 mycroft /*
173 1.1 mycroft * VFS Operations.
174 1.1 mycroft *
175 1.1 mycroft * mount system call
176 1.1 mycroft */
177 1.1 mycroft int
178 1.1 mycroft ffs_mount(mp, path, data, ndp, p)
179 1.61 augustss struct mount *mp;
180 1.22 cgd const char *path;
181 1.22 cgd void *data;
182 1.1 mycroft struct nameidata *ndp;
183 1.1 mycroft struct proc *p;
184 1.1 mycroft {
185 1.1 mycroft struct vnode *devvp;
186 1.1 mycroft struct ufs_args args;
187 1.19 christos struct ufsmount *ump = NULL;
188 1.61 augustss struct fs *fs;
189 1.14 mycroft size_t size;
190 1.1 mycroft int error, flags;
191 1.9 mycroft mode_t accessmode;
192 1.1 mycroft
193 1.19 christos error = copyin(data, (caddr_t)&args, sizeof (struct ufs_args));
194 1.19 christos if (error)
195 1.1 mycroft return (error);
196 1.66 matt
197 1.66 matt #if !defined(SOFTDEP)
198 1.67 perseant mp->mnt_flag &= ~MNT_SOFTDEP;
199 1.66 matt #endif
200 1.66 matt
201 1.1 mycroft /*
202 1.1 mycroft * If updating, check whether changing from read-only to
203 1.1 mycroft * read/write; if there is no device name, that's all we do.
204 1.1 mycroft */
205 1.1 mycroft if (mp->mnt_flag & MNT_UPDATE) {
206 1.1 mycroft ump = VFSTOUFS(mp);
207 1.1 mycroft fs = ump->um_fs;
208 1.1 mycroft if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
209 1.1 mycroft flags = WRITECLOSE;
210 1.1 mycroft if (mp->mnt_flag & MNT_FORCE)
211 1.1 mycroft flags |= FORCECLOSE;
212 1.55 fvdl if (mp->mnt_flag & MNT_SOFTDEP)
213 1.55 fvdl error = softdep_flushfiles(mp, flags, p);
214 1.55 fvdl else
215 1.55 fvdl error = ffs_flushfiles(mp, flags, p);
216 1.80.2.6 nathanw if (fs->fs_pendingblocks != 0 ||
217 1.80.2.6 nathanw fs->fs_pendinginodes != 0) {
218 1.80.2.6 nathanw printf("%s: update error: blocks %d files %d\n",
219 1.80.2.6 nathanw fs->fs_fsmnt, fs->fs_pendingblocks,
220 1.80.2.6 nathanw fs->fs_pendinginodes);
221 1.80.2.6 nathanw fs->fs_pendingblocks = 0;
222 1.80.2.6 nathanw fs->fs_pendinginodes = 0;
223 1.80.2.6 nathanw }
224 1.15 mycroft if (error == 0 &&
225 1.15 mycroft ffs_cgupdate(ump, MNT_WAIT) == 0 &&
226 1.15 mycroft fs->fs_clean & FS_WASCLEAN) {
227 1.65 fvdl if (mp->mnt_flag & MNT_SOFTDEP)
228 1.65 fvdl fs->fs_flags &= ~FS_DOSOFTDEP;
229 1.15 mycroft fs->fs_clean = FS_ISCLEAN;
230 1.15 mycroft (void) ffs_sbupdate(ump, MNT_WAIT);
231 1.15 mycroft }
232 1.15 mycroft if (error)
233 1.15 mycroft return (error);
234 1.15 mycroft fs->fs_ronly = 1;
235 1.78 mycroft fs->fs_fmod = 0;
236 1.1 mycroft }
237 1.65 fvdl
238 1.65 fvdl /*
239 1.65 fvdl * Flush soft dependencies if disabling it via an update
240 1.65 fvdl * mount. This may leave some items to be processed,
241 1.65 fvdl * so don't do this yet XXX.
242 1.65 fvdl */
243 1.65 fvdl if ((fs->fs_flags & FS_DOSOFTDEP) &&
244 1.65 fvdl !(mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
245 1.65 fvdl #ifdef notyet
246 1.65 fvdl flags = WRITECLOSE;
247 1.65 fvdl if (mp->mnt_flag & MNT_FORCE)
248 1.65 fvdl flags |= FORCECLOSE;
249 1.65 fvdl error = softdep_flushfiles(mp, flags, p);
250 1.65 fvdl if (error == 0 && ffs_cgupdate(ump, MNT_WAIT) == 0)
251 1.65 fvdl fs->fs_flags &= ~FS_DOSOFTDEP;
252 1.65 fvdl (void) ffs_sbupdate(ump, MNT_WAIT);
253 1.66 matt #elif defined(SOFTDEP)
254 1.65 fvdl mp->mnt_flag |= MNT_SOFTDEP;
255 1.65 fvdl #endif
256 1.65 fvdl }
257 1.65 fvdl
258 1.65 fvdl /*
259 1.65 fvdl * When upgrading to a softdep mount, we must first flush
260 1.65 fvdl * all vnodes. (not done yet -- see above)
261 1.65 fvdl */
262 1.65 fvdl if (!(fs->fs_flags & FS_DOSOFTDEP) &&
263 1.65 fvdl (mp->mnt_flag & MNT_SOFTDEP) && fs->fs_ronly == 0) {
264 1.65 fvdl #ifdef notyet
265 1.65 fvdl flags = WRITECLOSE;
266 1.65 fvdl if (mp->mnt_flag & MNT_FORCE)
267 1.65 fvdl flags |= FORCECLOSE;
268 1.65 fvdl error = ffs_flushfiles(mp, flags, p);
269 1.65 fvdl #else
270 1.65 fvdl mp->mnt_flag &= ~MNT_SOFTDEP;
271 1.65 fvdl #endif
272 1.65 fvdl }
273 1.65 fvdl
274 1.15 mycroft if (mp->mnt_flag & MNT_RELOAD) {
275 1.1 mycroft error = ffs_reload(mp, ndp->ni_cnd.cn_cred, p);
276 1.15 mycroft if (error)
277 1.15 mycroft return (error);
278 1.15 mycroft }
279 1.9 mycroft if (fs->fs_ronly && (mp->mnt_flag & MNT_WANTRDWR)) {
280 1.9 mycroft /*
281 1.9 mycroft * If upgrade to read-write by non-root, then verify
282 1.9 mycroft * that user has necessary permissions on the device.
283 1.9 mycroft */
284 1.55 fvdl devvp = ump->um_devvp;
285 1.9 mycroft if (p->p_ucred->cr_uid != 0) {
286 1.33 fvdl vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
287 1.19 christos error = VOP_ACCESS(devvp, VREAD | VWRITE,
288 1.19 christos p->p_ucred, p);
289 1.33 fvdl VOP_UNLOCK(devvp, 0);
290 1.33 fvdl if (error)
291 1.9 mycroft return (error);
292 1.9 mycroft }
293 1.1 mycroft fs->fs_ronly = 0;
294 1.15 mycroft fs->fs_clean <<= 1;
295 1.15 mycroft fs->fs_fmod = 1;
296 1.55 fvdl if ((fs->fs_flags & FS_DOSOFTDEP)) {
297 1.55 fvdl error = softdep_mount(devvp, mp, fs,
298 1.55 fvdl p->p_ucred);
299 1.55 fvdl if (error)
300 1.55 fvdl return (error);
301 1.65 fvdl }
302 1.9 mycroft }
303 1.1 mycroft if (args.fspec == 0) {
304 1.1 mycroft /*
305 1.1 mycroft * Process export requests.
306 1.1 mycroft */
307 1.1 mycroft return (vfs_export(mp, &ump->um_export, &args.export));
308 1.1 mycroft }
309 1.55 fvdl if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
310 1.55 fvdl (MNT_SOFTDEP | MNT_ASYNC)) {
311 1.55 fvdl printf("%s fs uses soft updates, ignoring async mode\n",
312 1.55 fvdl fs->fs_fsmnt);
313 1.55 fvdl mp->mnt_flag &= ~MNT_ASYNC;
314 1.55 fvdl }
315 1.1 mycroft }
316 1.1 mycroft /*
317 1.1 mycroft * Not an update, or updating the name: look up the name
318 1.1 mycroft * and verify that it refers to a sensible block device.
319 1.1 mycroft */
320 1.1 mycroft NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args.fspec, p);
321 1.19 christos if ((error = namei(ndp)) != 0)
322 1.1 mycroft return (error);
323 1.1 mycroft devvp = ndp->ni_vp;
324 1.1 mycroft
325 1.1 mycroft if (devvp->v_type != VBLK) {
326 1.1 mycroft vrele(devvp);
327 1.1 mycroft return (ENOTBLK);
328 1.1 mycroft }
329 1.1 mycroft if (major(devvp->v_rdev) >= nblkdev) {
330 1.1 mycroft vrele(devvp);
331 1.1 mycroft return (ENXIO);
332 1.1 mycroft }
333 1.9 mycroft /*
334 1.9 mycroft * If mount by non-root, then verify that user has necessary
335 1.9 mycroft * permissions on the device.
336 1.9 mycroft */
337 1.9 mycroft if (p->p_ucred->cr_uid != 0) {
338 1.9 mycroft accessmode = VREAD;
339 1.9 mycroft if ((mp->mnt_flag & MNT_RDONLY) == 0)
340 1.9 mycroft accessmode |= VWRITE;
341 1.33 fvdl vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
342 1.19 christos error = VOP_ACCESS(devvp, accessmode, p->p_ucred, p);
343 1.33 fvdl VOP_UNLOCK(devvp, 0);
344 1.19 christos if (error) {
345 1.33 fvdl vrele(devvp);
346 1.9 mycroft return (error);
347 1.9 mycroft }
348 1.9 mycroft }
349 1.55 fvdl if ((mp->mnt_flag & MNT_UPDATE) == 0) {
350 1.1 mycroft error = ffs_mountfs(devvp, mp, p);
351 1.58 fvdl if (!error) {
352 1.58 fvdl ump = VFSTOUFS(mp);
353 1.58 fvdl fs = ump->um_fs;
354 1.58 fvdl if ((mp->mnt_flag & (MNT_SOFTDEP | MNT_ASYNC)) ==
355 1.58 fvdl (MNT_SOFTDEP | MNT_ASYNC)) {
356 1.58 fvdl printf("%s fs uses soft updates, "
357 1.58 fvdl "ignoring async mode\n",
358 1.58 fvdl fs->fs_fsmnt);
359 1.58 fvdl mp->mnt_flag &= ~MNT_ASYNC;
360 1.58 fvdl }
361 1.55 fvdl }
362 1.55 fvdl }
363 1.1 mycroft else {
364 1.1 mycroft if (devvp != ump->um_devvp)
365 1.1 mycroft error = EINVAL; /* needs translation */
366 1.1 mycroft else
367 1.1 mycroft vrele(devvp);
368 1.1 mycroft }
369 1.1 mycroft if (error) {
370 1.1 mycroft vrele(devvp);
371 1.1 mycroft return (error);
372 1.1 mycroft }
373 1.1 mycroft (void) copyinstr(path, fs->fs_fsmnt, sizeof(fs->fs_fsmnt) - 1, &size);
374 1.42 perry memset(fs->fs_fsmnt + size, 0, sizeof(fs->fs_fsmnt) - size);
375 1.42 perry memcpy(mp->mnt_stat.f_mntonname, fs->fs_fsmnt, MNAMELEN);
376 1.1 mycroft (void) copyinstr(args.fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1,
377 1.1 mycroft &size);
378 1.42 perry memset(mp->mnt_stat.f_mntfromname + size, 0, MNAMELEN - size);
379 1.65 fvdl if (mp->mnt_flag & MNT_SOFTDEP)
380 1.65 fvdl fs->fs_flags |= FS_DOSOFTDEP;
381 1.74 fvdl else
382 1.74 fvdl fs->fs_flags &= ~FS_DOSOFTDEP;
383 1.15 mycroft if (fs->fs_fmod != 0) { /* XXX */
384 1.15 mycroft fs->fs_fmod = 0;
385 1.15 mycroft if (fs->fs_clean & FS_WASCLEAN)
386 1.15 mycroft fs->fs_time = time.tv_sec;
387 1.80.2.6 nathanw else {
388 1.80.2.3 nathanw printf("%s: file system not clean (fs_clean=%x); please fsck(8)\n",
389 1.34 bouyer mp->mnt_stat.f_mntfromname, fs->fs_clean);
390 1.80.2.6 nathanw printf("%s: lost blocks %d files %d\n",
391 1.80.2.6 nathanw mp->mnt_stat.f_mntfromname, fs->fs_pendingblocks,
392 1.80.2.6 nathanw fs->fs_pendinginodes);
393 1.80.2.6 nathanw }
394 1.15 mycroft (void) ffs_cgupdate(ump, MNT_WAIT);
395 1.15 mycroft }
396 1.1 mycroft return (0);
397 1.1 mycroft }
398 1.1 mycroft
399 1.1 mycroft /*
400 1.1 mycroft * Reload all incore data for a filesystem (used after running fsck on
401 1.1 mycroft * the root filesystem and finding things to fix). The filesystem must
402 1.1 mycroft * be mounted read-only.
403 1.1 mycroft *
404 1.1 mycroft * Things to do to update the mount:
405 1.1 mycroft * 1) invalidate all cached meta-data.
406 1.1 mycroft * 2) re-read superblock from disk.
407 1.1 mycroft * 3) re-read summary information from disk.
408 1.1 mycroft * 4) invalidate all inactive vnodes.
409 1.1 mycroft * 5) invalidate all cached file data.
410 1.1 mycroft * 6) re-read inode data for all active vnodes.
411 1.1 mycroft */
412 1.19 christos int
413 1.1 mycroft ffs_reload(mountp, cred, p)
414 1.61 augustss struct mount *mountp;
415 1.1 mycroft struct ucred *cred;
416 1.1 mycroft struct proc *p;
417 1.1 mycroft {
418 1.61 augustss struct vnode *vp, *nvp, *devvp;
419 1.1 mycroft struct inode *ip;
420 1.80.2.4 nathanw void *space;
421 1.1 mycroft struct buf *bp;
422 1.18 cgd struct fs *fs, *newfs;
423 1.1 mycroft struct partinfo dpart;
424 1.1 mycroft int i, blks, size, error;
425 1.18 cgd int32_t *lp;
426 1.44 thorpej caddr_t cp;
427 1.1 mycroft
428 1.1 mycroft if ((mountp->mnt_flag & MNT_RDONLY) == 0)
429 1.1 mycroft return (EINVAL);
430 1.1 mycroft /*
431 1.1 mycroft * Step 1: invalidate all cached meta-data.
432 1.1 mycroft */
433 1.1 mycroft devvp = VFSTOUFS(mountp)->um_devvp;
434 1.55 fvdl vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
435 1.55 fvdl error = vinvalbuf(devvp, 0, cred, p, 0, 0);
436 1.55 fvdl VOP_UNLOCK(devvp, 0);
437 1.55 fvdl if (error)
438 1.1 mycroft panic("ffs_reload: dirty1");
439 1.1 mycroft /*
440 1.1 mycroft * Step 2: re-read superblock from disk.
441 1.1 mycroft */
442 1.1 mycroft if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, NOCRED, p) != 0)
443 1.1 mycroft size = DEV_BSIZE;
444 1.1 mycroft else
445 1.1 mycroft size = dpart.disklab->d_secsize;
446 1.33 fvdl error = bread(devvp, (ufs_daddr_t)(SBOFF / size), SBSIZE, NOCRED, &bp);
447 1.47 bouyer if (error) {
448 1.47 bouyer brelse(bp);
449 1.1 mycroft return (error);
450 1.47 bouyer }
451 1.34 bouyer fs = VFSTOUFS(mountp)->um_fs;
452 1.34 bouyer newfs = malloc(fs->fs_sbsize, M_UFSMNT, M_WAITOK);
453 1.42 perry memcpy(newfs, bp->b_data, fs->fs_sbsize);
454 1.34 bouyer #ifdef FFS_EI
455 1.55 fvdl if (VFSTOUFS(mountp)->um_flags & UFS_NEEDSWAP) {
456 1.80.2.3 nathanw ffs_sb_swap((struct fs*)bp->b_data, newfs);
457 1.55 fvdl fs->fs_flags |= FS_SWAPPED;
458 1.55 fvdl }
459 1.34 bouyer #endif
460 1.18 cgd if (newfs->fs_magic != FS_MAGIC || newfs->fs_bsize > MAXBSIZE ||
461 1.18 cgd newfs->fs_bsize < sizeof(struct fs)) {
462 1.1 mycroft brelse(bp);
463 1.34 bouyer free(newfs, M_UFSMNT);
464 1.1 mycroft return (EIO); /* XXX needs translation */
465 1.1 mycroft }
466 1.18 cgd /*
467 1.18 cgd * Copy pointer fields back into superblock before copying in XXX
468 1.18 cgd * new superblock. These should really be in the ufsmount. XXX
469 1.18 cgd * Note that important parameters (eg fs_ncg) are unchanged.
470 1.18 cgd */
471 1.80.2.4 nathanw newfs->fs_csp = fs->fs_csp;
472 1.18 cgd newfs->fs_maxcluster = fs->fs_maxcluster;
473 1.80.2.4 nathanw newfs->fs_contigdirs = fs->fs_contigdirs;
474 1.76 mycroft newfs->fs_ronly = fs->fs_ronly;
475 1.42 perry memcpy(fs, newfs, (u_int)fs->fs_sbsize);
476 1.1 mycroft if (fs->fs_sbsize < SBSIZE)
477 1.1 mycroft bp->b_flags |= B_INVAL;
478 1.1 mycroft brelse(bp);
479 1.34 bouyer free(newfs, M_UFSMNT);
480 1.3 mycroft mountp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
481 1.1 mycroft ffs_oldfscompat(fs);
482 1.80.2.4 nathanw /* An old fsck may have zeroed these fields, so recheck them. */
483 1.80.2.4 nathanw if (fs->fs_avgfilesize <= 0)
484 1.80.2.4 nathanw fs->fs_avgfilesize = AVFILESIZ;
485 1.80.2.4 nathanw if (fs->fs_avgfpdir <= 0)
486 1.80.2.4 nathanw fs->fs_avgfpdir = AFPDIR;
487 1.80.2.6 nathanw if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
488 1.80.2.6 nathanw fs->fs_pendingblocks = 0;
489 1.80.2.6 nathanw fs->fs_pendinginodes = 0;
490 1.80.2.6 nathanw }
491 1.80.2.4 nathanw
492 1.55 fvdl ffs_statfs(mountp, &mountp->mnt_stat, p);
493 1.1 mycroft /*
494 1.1 mycroft * Step 3: re-read summary information from disk.
495 1.1 mycroft */
496 1.1 mycroft blks = howmany(fs->fs_cssize, fs->fs_fsize);
497 1.80.2.4 nathanw space = fs->fs_csp;
498 1.1 mycroft for (i = 0; i < blks; i += fs->fs_frag) {
499 1.1 mycroft size = fs->fs_bsize;
500 1.1 mycroft if (i + fs->fs_frag > blks)
501 1.1 mycroft size = (blks - i) * fs->fs_fsize;
502 1.19 christos error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
503 1.19 christos NOCRED, &bp);
504 1.47 bouyer if (error) {
505 1.47 bouyer brelse(bp);
506 1.1 mycroft return (error);
507 1.47 bouyer }
508 1.34 bouyer #ifdef FFS_EI
509 1.55 fvdl if (UFS_FSNEEDSWAP(fs))
510 1.80.2.4 nathanw ffs_csum_swap((struct csum *)bp->b_data,
511 1.80.2.4 nathanw (struct csum *)space, size);
512 1.34 bouyer else
513 1.34 bouyer #endif
514 1.80.2.4 nathanw memcpy(space, bp->b_data, (size_t)size);
515 1.80.2.4 nathanw space = (char *)space + size;
516 1.1 mycroft brelse(bp);
517 1.1 mycroft }
518 1.55 fvdl if ((fs->fs_flags & FS_DOSOFTDEP))
519 1.55 fvdl softdep_mount(devvp, mountp, fs, cred);
520 1.18 cgd /*
521 1.18 cgd * We no longer know anything about clusters per cylinder group.
522 1.18 cgd */
523 1.18 cgd if (fs->fs_contigsumsize > 0) {
524 1.18 cgd lp = fs->fs_maxcluster;
525 1.18 cgd for (i = 0; i < fs->fs_ncg; i++)
526 1.18 cgd *lp++ = fs->fs_contigsumsize;
527 1.18 cgd }
528 1.18 cgd
529 1.1 mycroft loop:
530 1.33 fvdl simple_lock(&mntvnode_slock);
531 1.1 mycroft for (vp = mountp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
532 1.33 fvdl if (vp->v_mount != mountp) {
533 1.33 fvdl simple_unlock(&mntvnode_slock);
534 1.33 fvdl goto loop;
535 1.33 fvdl }
536 1.1 mycroft nvp = vp->v_mntvnodes.le_next;
537 1.1 mycroft /*
538 1.1 mycroft * Step 4: invalidate all inactive vnodes.
539 1.1 mycroft */
540 1.33 fvdl if (vrecycle(vp, &mntvnode_slock, p))
541 1.33 fvdl goto loop;
542 1.1 mycroft /*
543 1.1 mycroft * Step 5: invalidate all cached file data.
544 1.1 mycroft */
545 1.33 fvdl simple_lock(&vp->v_interlock);
546 1.33 fvdl simple_unlock(&mntvnode_slock);
547 1.33 fvdl if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK))
548 1.1 mycroft goto loop;
549 1.1 mycroft if (vinvalbuf(vp, 0, cred, p, 0, 0))
550 1.1 mycroft panic("ffs_reload: dirty2");
551 1.1 mycroft /*
552 1.1 mycroft * Step 6: re-read inode data for all active vnodes.
553 1.1 mycroft */
554 1.1 mycroft ip = VTOI(vp);
555 1.19 christos error = bread(devvp, fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
556 1.19 christos (int)fs->fs_bsize, NOCRED, &bp);
557 1.19 christos if (error) {
558 1.47 bouyer brelse(bp);
559 1.1 mycroft vput(vp);
560 1.1 mycroft return (error);
561 1.1 mycroft }
562 1.44 thorpej cp = (caddr_t)bp->b_data +
563 1.44 thorpej (ino_to_fsbo(fs, ip->i_number) * DINODE_SIZE);
564 1.34 bouyer #ifdef FFS_EI
565 1.55 fvdl if (UFS_FSNEEDSWAP(fs))
566 1.44 thorpej ffs_dinode_swap((struct dinode *)cp,
567 1.44 thorpej &ip->i_din.ffs_din);
568 1.34 bouyer else
569 1.34 bouyer #endif
570 1.44 thorpej memcpy(&ip->i_din.ffs_din, cp, DINODE_SIZE);
571 1.55 fvdl ip->i_ffs_effnlink = ip->i_ffs_nlink;
572 1.1 mycroft brelse(bp);
573 1.1 mycroft vput(vp);
574 1.33 fvdl simple_lock(&mntvnode_slock);
575 1.1 mycroft }
576 1.33 fvdl simple_unlock(&mntvnode_slock);
577 1.1 mycroft return (0);
578 1.1 mycroft }
579 1.1 mycroft
580 1.1 mycroft /*
581 1.1 mycroft * Common code for mount and mountroot
582 1.1 mycroft */
583 1.1 mycroft int
584 1.1 mycroft ffs_mountfs(devvp, mp, p)
585 1.61 augustss struct vnode *devvp;
586 1.1 mycroft struct mount *mp;
587 1.1 mycroft struct proc *p;
588 1.1 mycroft {
589 1.34 bouyer struct ufsmount *ump;
590 1.1 mycroft struct buf *bp;
591 1.34 bouyer struct fs *fs;
592 1.9 mycroft dev_t dev;
593 1.1 mycroft struct partinfo dpart;
594 1.80.2.4 nathanw void *space;
595 1.1 mycroft int blks;
596 1.52 drochner int error, i, size, ronly;
597 1.52 drochner #ifdef FFS_EI
598 1.52 drochner int needswap;
599 1.52 drochner #endif
600 1.9 mycroft int32_t *lp;
601 1.9 mycroft struct ucred *cred;
602 1.9 mycroft u_int64_t maxfilesize; /* XXX */
603 1.34 bouyer u_int32_t sbsize;
604 1.1 mycroft
605 1.9 mycroft dev = devvp->v_rdev;
606 1.9 mycroft cred = p ? p->p_ucred : NOCRED;
607 1.1 mycroft /*
608 1.1 mycroft * Disallow multiple mounts of the same device.
609 1.1 mycroft * Disallow mounting of a device that is currently in use
610 1.1 mycroft * (except for root, which might share swap device for miniroot).
611 1.1 mycroft * Flush out any old buffers remaining from a previous use.
612 1.1 mycroft */
613 1.19 christos if ((error = vfs_mountedon(devvp)) != 0)
614 1.1 mycroft return (error);
615 1.1 mycroft if (vcount(devvp) > 1 && devvp != rootvp)
616 1.1 mycroft return (EBUSY);
617 1.55 fvdl vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
618 1.55 fvdl error = vinvalbuf(devvp, V_SAVE, cred, p, 0, 0);
619 1.55 fvdl VOP_UNLOCK(devvp, 0);
620 1.55 fvdl if (error)
621 1.1 mycroft return (error);
622 1.1 mycroft
623 1.1 mycroft ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
624 1.19 christos error = VOP_OPEN(devvp, ronly ? FREAD : FREAD|FWRITE, FSCRED, p);
625 1.19 christos if (error)
626 1.1 mycroft return (error);
627 1.9 mycroft if (VOP_IOCTL(devvp, DIOCGPART, (caddr_t)&dpart, FREAD, cred, p) != 0)
628 1.1 mycroft size = DEV_BSIZE;
629 1.1 mycroft else
630 1.1 mycroft size = dpart.disklab->d_secsize;
631 1.1 mycroft
632 1.1 mycroft bp = NULL;
633 1.1 mycroft ump = NULL;
634 1.33 fvdl error = bread(devvp, (ufs_daddr_t)(SBOFF / size), SBSIZE, cred, &bp);
635 1.19 christos if (error)
636 1.1 mycroft goto out;
637 1.34 bouyer
638 1.34 bouyer fs = (struct fs*)bp->b_data;
639 1.34 bouyer if (fs->fs_magic == FS_MAGIC) {
640 1.34 bouyer sbsize = fs->fs_sbsize;
641 1.34 bouyer #ifdef FFS_EI
642 1.52 drochner needswap = 0;
643 1.34 bouyer } else if (fs->fs_magic == bswap32(FS_MAGIC)) {
644 1.52 drochner sbsize = bswap32(fs->fs_sbsize);
645 1.34 bouyer needswap = 1;
646 1.34 bouyer #endif
647 1.34 bouyer } else {
648 1.34 bouyer error = EINVAL;
649 1.34 bouyer goto out;
650 1.46 bouyer }
651 1.49 bouyer if (sbsize > MAXBSIZE || sbsize < sizeof(struct fs)) {
652 1.46 bouyer error = EINVAL;
653 1.46 bouyer goto out;
654 1.34 bouyer }
655 1.34 bouyer
656 1.34 bouyer fs = malloc((u_long)sbsize, M_UFSMNT, M_WAITOK);
657 1.42 perry memcpy(fs, bp->b_data, sbsize);
658 1.34 bouyer #ifdef FFS_EI
659 1.55 fvdl if (needswap) {
660 1.80.2.3 nathanw ffs_sb_swap((struct fs*)bp->b_data, fs);
661 1.55 fvdl fs->fs_flags |= FS_SWAPPED;
662 1.55 fvdl }
663 1.34 bouyer #endif
664 1.56 drochner ffs_oldfscompat(fs);
665 1.56 drochner
666 1.49 bouyer if (fs->fs_bsize > MAXBSIZE || fs->fs_bsize < sizeof(struct fs)) {
667 1.49 bouyer error = EINVAL;
668 1.49 bouyer goto out;
669 1.49 bouyer }
670 1.46 bouyer /* make sure cylinder group summary area is a reasonable size. */
671 1.46 bouyer if (fs->fs_cgsize == 0 || fs->fs_cpg == 0 ||
672 1.46 bouyer fs->fs_ncg > fs->fs_ncyl / fs->fs_cpg + 1 ||
673 1.46 bouyer fs->fs_cssize >
674 1.46 bouyer fragroundup(fs, fs->fs_ncg * sizeof(struct csum))) {
675 1.1 mycroft error = EINVAL; /* XXX needs translation */
676 1.34 bouyer goto out2;
677 1.1 mycroft }
678 1.80.2.6 nathanw if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
679 1.80.2.6 nathanw fs->fs_pendingblocks = 0;
680 1.80.2.6 nathanw fs->fs_pendinginodes = 0;
681 1.80.2.6 nathanw }
682 1.1 mycroft /* XXX updating 4.2 FFS superblocks trashes rotational layout tables */
683 1.1 mycroft if (fs->fs_postblformat == FS_42POSTBLFMT && !ronly) {
684 1.1 mycroft error = EROFS; /* XXX what should be returned? */
685 1.34 bouyer goto out2;
686 1.1 mycroft }
687 1.56 drochner
688 1.1 mycroft ump = malloc(sizeof *ump, M_UFSMNT, M_WAITOK);
689 1.42 perry memset((caddr_t)ump, 0, sizeof *ump);
690 1.34 bouyer ump->um_fs = fs;
691 1.1 mycroft if (fs->fs_sbsize < SBSIZE)
692 1.1 mycroft bp->b_flags |= B_INVAL;
693 1.1 mycroft brelse(bp);
694 1.1 mycroft bp = NULL;
695 1.80.2.7 nathanw
696 1.80.2.7 nathanw /*
697 1.80.2.7 nathanw * verify that we can access the last block in the fs.
698 1.80.2.7 nathanw */
699 1.80.2.7 nathanw
700 1.80.2.7 nathanw error = bread(devvp, fsbtodb(fs, fs->fs_size - 1), fs->fs_fsize, cred,
701 1.80.2.7 nathanw &bp);
702 1.80.2.7 nathanw if (bp->b_bcount != fs->fs_fsize)
703 1.80.2.7 nathanw error = EINVAL;
704 1.80.2.7 nathanw bp->b_flags |= B_INVAL;
705 1.80.2.7 nathanw if (error)
706 1.80.2.7 nathanw goto out;
707 1.80.2.7 nathanw brelse(bp);
708 1.80.2.7 nathanw bp = NULL;
709 1.80.2.7 nathanw
710 1.1 mycroft fs->fs_ronly = ronly;
711 1.15 mycroft if (ronly == 0) {
712 1.15 mycroft fs->fs_clean <<= 1;
713 1.1 mycroft fs->fs_fmod = 1;
714 1.15 mycroft }
715 1.9 mycroft size = fs->fs_cssize;
716 1.9 mycroft blks = howmany(size, fs->fs_fsize);
717 1.9 mycroft if (fs->fs_contigsumsize > 0)
718 1.9 mycroft size += fs->fs_ncg * sizeof(int32_t);
719 1.80.2.4 nathanw size += fs->fs_ncg * sizeof(*fs->fs_contigdirs);
720 1.80.2.4 nathanw space = malloc((u_long)size, M_UFSMNT, M_WAITOK);
721 1.80.2.4 nathanw fs->fs_csp = space;
722 1.1 mycroft for (i = 0; i < blks; i += fs->fs_frag) {
723 1.1 mycroft size = fs->fs_bsize;
724 1.1 mycroft if (i + fs->fs_frag > blks)
725 1.1 mycroft size = (blks - i) * fs->fs_fsize;
726 1.19 christos error = bread(devvp, fsbtodb(fs, fs->fs_csaddr + i), size,
727 1.19 christos cred, &bp);
728 1.19 christos if (error) {
729 1.80.2.4 nathanw free(fs->fs_csp, M_UFSMNT);
730 1.34 bouyer goto out2;
731 1.1 mycroft }
732 1.34 bouyer #ifdef FFS_EI
733 1.34 bouyer if (needswap)
734 1.80.2.4 nathanw ffs_csum_swap((struct csum *)bp->b_data,
735 1.80.2.4 nathanw (struct csum *)space, size);
736 1.34 bouyer else
737 1.34 bouyer #endif
738 1.42 perry memcpy(space, bp->b_data, (u_int)size);
739 1.34 bouyer
740 1.80.2.4 nathanw space = (char *)space + size;
741 1.1 mycroft brelse(bp);
742 1.1 mycroft bp = NULL;
743 1.1 mycroft }
744 1.9 mycroft if (fs->fs_contigsumsize > 0) {
745 1.80.2.4 nathanw fs->fs_maxcluster = lp = space;
746 1.9 mycroft for (i = 0; i < fs->fs_ncg; i++)
747 1.9 mycroft *lp++ = fs->fs_contigsumsize;
748 1.80.2.4 nathanw space = lp;
749 1.9 mycroft }
750 1.80.2.4 nathanw size = fs->fs_ncg * sizeof(*fs->fs_contigdirs);
751 1.80.2.4 nathanw fs->fs_contigdirs = space;
752 1.80.2.4 nathanw space = (char *)space + size;
753 1.80.2.4 nathanw memset(fs->fs_contigdirs, 0, size);
754 1.80.2.4 nathanw /* Compatibility for old filesystems - XXX */
755 1.80.2.4 nathanw if (fs->fs_avgfilesize <= 0)
756 1.80.2.4 nathanw fs->fs_avgfilesize = AVFILESIZ;
757 1.80.2.4 nathanw if (fs->fs_avgfpdir <= 0)
758 1.80.2.4 nathanw fs->fs_avgfpdir = AFPDIR;
759 1.1 mycroft mp->mnt_data = (qaddr_t)ump;
760 1.1 mycroft mp->mnt_stat.f_fsid.val[0] = (long)dev;
761 1.17 mycroft mp->mnt_stat.f_fsid.val[1] = makefstype(MOUNT_FFS);
762 1.1 mycroft mp->mnt_maxsymlinklen = fs->fs_maxsymlinklen;
763 1.73 chs mp->mnt_fs_bshift = fs->fs_bshift;
764 1.73 chs mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */
765 1.1 mycroft mp->mnt_flag |= MNT_LOCAL;
766 1.34 bouyer #ifdef FFS_EI
767 1.34 bouyer if (needswap)
768 1.34 bouyer ump->um_flags |= UFS_NEEDSWAP;
769 1.34 bouyer #endif
770 1.1 mycroft ump->um_mountp = mp;
771 1.1 mycroft ump->um_dev = dev;
772 1.1 mycroft ump->um_devvp = devvp;
773 1.1 mycroft ump->um_nindir = fs->fs_nindir;
774 1.73 chs ump->um_lognindir = ffs(fs->fs_nindir) - 1;
775 1.1 mycroft ump->um_bptrtodb = fs->fs_fsbtodb;
776 1.1 mycroft ump->um_seqinc = fs->fs_frag;
777 1.1 mycroft for (i = 0; i < MAXQUOTAS; i++)
778 1.1 mycroft ump->um_quotas[i] = NULLVP;
779 1.55 fvdl devvp->v_specmountpoint = mp;
780 1.9 mycroft ump->um_savedmaxfilesize = fs->fs_maxfilesize; /* XXX */
781 1.9 mycroft maxfilesize = (u_int64_t)0x80000000 * fs->fs_bsize - 1; /* XXX */
782 1.9 mycroft if (fs->fs_maxfilesize > maxfilesize) /* XXX */
783 1.9 mycroft fs->fs_maxfilesize = maxfilesize; /* XXX */
784 1.55 fvdl if (ronly == 0 && (fs->fs_flags & FS_DOSOFTDEP)) {
785 1.55 fvdl error = softdep_mount(devvp, mp, fs, cred);
786 1.55 fvdl if (error) {
787 1.80.2.4 nathanw free(fs->fs_csp, M_UFSMNT);
788 1.55 fvdl goto out;
789 1.55 fvdl }
790 1.55 fvdl }
791 1.1 mycroft return (0);
792 1.34 bouyer out2:
793 1.34 bouyer free(fs, M_UFSMNT);
794 1.1 mycroft out:
795 1.55 fvdl devvp->v_specmountpoint = NULL;
796 1.1 mycroft if (bp)
797 1.1 mycroft brelse(bp);
798 1.53 wrstuden vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
799 1.9 mycroft (void)VOP_CLOSE(devvp, ronly ? FREAD : FREAD|FWRITE, cred, p);
800 1.53 wrstuden VOP_UNLOCK(devvp, 0);
801 1.1 mycroft if (ump) {
802 1.1 mycroft free(ump, M_UFSMNT);
803 1.1 mycroft mp->mnt_data = (qaddr_t)0;
804 1.1 mycroft }
805 1.1 mycroft return (error);
806 1.1 mycroft }
807 1.1 mycroft
808 1.1 mycroft /*
809 1.1 mycroft * Sanity checks for old file systems.
810 1.1 mycroft *
811 1.1 mycroft * XXX - goes away some day.
812 1.1 mycroft */
813 1.19 christos int
814 1.1 mycroft ffs_oldfscompat(fs)
815 1.1 mycroft struct fs *fs;
816 1.1 mycroft {
817 1.1 mycroft int i;
818 1.1 mycroft
819 1.1 mycroft fs->fs_npsect = max(fs->fs_npsect, fs->fs_nsect); /* XXX */
820 1.1 mycroft fs->fs_interleave = max(fs->fs_interleave, 1); /* XXX */
821 1.1 mycroft if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
822 1.1 mycroft fs->fs_nrpos = 8; /* XXX */
823 1.1 mycroft if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
824 1.5 mycroft u_int64_t sizepb = fs->fs_bsize; /* XXX */
825 1.1 mycroft /* XXX */
826 1.1 mycroft fs->fs_maxfilesize = fs->fs_bsize * NDADDR - 1; /* XXX */
827 1.1 mycroft for (i = 0; i < NIADDR; i++) { /* XXX */
828 1.1 mycroft sizepb *= NINDIR(fs); /* XXX */
829 1.1 mycroft fs->fs_maxfilesize += sizepb; /* XXX */
830 1.1 mycroft } /* XXX */
831 1.1 mycroft fs->fs_qbmask = ~fs->fs_bmask; /* XXX */
832 1.1 mycroft fs->fs_qfmask = ~fs->fs_fmask; /* XXX */
833 1.1 mycroft } /* XXX */
834 1.1 mycroft return (0);
835 1.1 mycroft }
836 1.1 mycroft
837 1.1 mycroft /*
838 1.1 mycroft * unmount system call
839 1.1 mycroft */
840 1.1 mycroft int
841 1.1 mycroft ffs_unmount(mp, mntflags, p)
842 1.1 mycroft struct mount *mp;
843 1.1 mycroft int mntflags;
844 1.1 mycroft struct proc *p;
845 1.1 mycroft {
846 1.61 augustss struct ufsmount *ump;
847 1.61 augustss struct fs *fs;
848 1.80.2.6 nathanw int error, flags, penderr;
849 1.1 mycroft
850 1.80.2.6 nathanw penderr = 0;
851 1.1 mycroft flags = 0;
852 1.11 mycroft if (mntflags & MNT_FORCE)
853 1.1 mycroft flags |= FORCECLOSE;
854 1.55 fvdl if (mp->mnt_flag & MNT_SOFTDEP) {
855 1.55 fvdl if ((error = softdep_flushfiles(mp, flags, p)) != 0)
856 1.55 fvdl return (error);
857 1.55 fvdl } else {
858 1.55 fvdl if ((error = ffs_flushfiles(mp, flags, p)) != 0)
859 1.55 fvdl return (error);
860 1.55 fvdl }
861 1.1 mycroft ump = VFSTOUFS(mp);
862 1.1 mycroft fs = ump->um_fs;
863 1.80.2.6 nathanw if (fs->fs_pendingblocks != 0 || fs->fs_pendinginodes != 0) {
864 1.80.2.6 nathanw printf("%s: unmount pending error: blocks %d files %d\n",
865 1.80.2.6 nathanw fs->fs_fsmnt, fs->fs_pendingblocks, fs->fs_pendinginodes);
866 1.80.2.6 nathanw fs->fs_pendingblocks = 0;
867 1.80.2.6 nathanw fs->fs_pendinginodes = 0;
868 1.80.2.6 nathanw penderr = 1;
869 1.80.2.6 nathanw }
870 1.15 mycroft if (fs->fs_ronly == 0 &&
871 1.15 mycroft ffs_cgupdate(ump, MNT_WAIT) == 0 &&
872 1.15 mycroft fs->fs_clean & FS_WASCLEAN) {
873 1.80.2.6 nathanw /*
874 1.80.2.6 nathanw * XXXX don't mark fs clean in the case of softdep
875 1.80.2.6 nathanw * pending block errors, until they are fixed.
876 1.80.2.6 nathanw */
877 1.80.2.6 nathanw if (penderr == 0) {
878 1.80.2.6 nathanw if (mp->mnt_flag & MNT_SOFTDEP)
879 1.80.2.6 nathanw fs->fs_flags &= ~FS_DOSOFTDEP;
880 1.80.2.6 nathanw fs->fs_clean = FS_ISCLEAN;
881 1.80.2.6 nathanw }
882 1.15 mycroft (void) ffs_sbupdate(ump, MNT_WAIT);
883 1.15 mycroft }
884 1.54 enami if (ump->um_devvp->v_type != VBAD)
885 1.55 fvdl ump->um_devvp->v_specmountpoint = NULL;
886 1.53 wrstuden vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
887 1.9 mycroft error = VOP_CLOSE(ump->um_devvp, fs->fs_ronly ? FREAD : FREAD|FWRITE,
888 1.1 mycroft NOCRED, p);
889 1.53 wrstuden vput(ump->um_devvp);
890 1.80.2.4 nathanw free(fs->fs_csp, M_UFSMNT);
891 1.1 mycroft free(fs, M_UFSMNT);
892 1.1 mycroft free(ump, M_UFSMNT);
893 1.1 mycroft mp->mnt_data = (qaddr_t)0;
894 1.1 mycroft mp->mnt_flag &= ~MNT_LOCAL;
895 1.1 mycroft return (error);
896 1.1 mycroft }
897 1.1 mycroft
898 1.1 mycroft /*
899 1.1 mycroft * Flush out all the files in a filesystem.
900 1.1 mycroft */
901 1.19 christos int
902 1.1 mycroft ffs_flushfiles(mp, flags, p)
903 1.61 augustss struct mount *mp;
904 1.1 mycroft int flags;
905 1.1 mycroft struct proc *p;
906 1.1 mycroft {
907 1.1 mycroft extern int doforce;
908 1.61 augustss struct ufsmount *ump;
909 1.19 christos int error;
910 1.1 mycroft
911 1.1 mycroft if (!doforce)
912 1.1 mycroft flags &= ~FORCECLOSE;
913 1.1 mycroft ump = VFSTOUFS(mp);
914 1.1 mycroft #ifdef QUOTA
915 1.1 mycroft if (mp->mnt_flag & MNT_QUOTA) {
916 1.19 christos int i;
917 1.19 christos if ((error = vflush(mp, NULLVP, SKIPSYSTEM|flags)) != 0)
918 1.1 mycroft return (error);
919 1.1 mycroft for (i = 0; i < MAXQUOTAS; i++) {
920 1.1 mycroft if (ump->um_quotas[i] == NULLVP)
921 1.1 mycroft continue;
922 1.1 mycroft quotaoff(p, mp, i);
923 1.1 mycroft }
924 1.1 mycroft /*
925 1.1 mycroft * Here we fall through to vflush again to ensure
926 1.1 mycroft * that we have gotten rid of all the system vnodes.
927 1.1 mycroft */
928 1.1 mycroft }
929 1.1 mycroft #endif
930 1.55 fvdl /*
931 1.55 fvdl * Flush all the files.
932 1.55 fvdl */
933 1.1 mycroft error = vflush(mp, NULLVP, flags);
934 1.55 fvdl if (error)
935 1.55 fvdl return (error);
936 1.55 fvdl /*
937 1.55 fvdl * Flush filesystem metadata.
938 1.55 fvdl */
939 1.55 fvdl vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
940 1.71 fvdl error = VOP_FSYNC(ump->um_devvp, p->p_ucred, FSYNC_WAIT, 0, 0, p);
941 1.55 fvdl VOP_UNLOCK(ump->um_devvp, 0);
942 1.1 mycroft return (error);
943 1.1 mycroft }
944 1.1 mycroft
945 1.1 mycroft /*
946 1.1 mycroft * Get file system statistics.
947 1.1 mycroft */
948 1.1 mycroft int
949 1.1 mycroft ffs_statfs(mp, sbp, p)
950 1.1 mycroft struct mount *mp;
951 1.61 augustss struct statfs *sbp;
952 1.1 mycroft struct proc *p;
953 1.1 mycroft {
954 1.61 augustss struct ufsmount *ump;
955 1.61 augustss struct fs *fs;
956 1.1 mycroft
957 1.1 mycroft ump = VFSTOUFS(mp);
958 1.1 mycroft fs = ump->um_fs;
959 1.1 mycroft if (fs->fs_magic != FS_MAGIC)
960 1.1 mycroft panic("ffs_statfs");
961 1.1 mycroft #ifdef COMPAT_09
962 1.1 mycroft sbp->f_type = 1;
963 1.1 mycroft #else
964 1.1 mycroft sbp->f_type = 0;
965 1.1 mycroft #endif
966 1.1 mycroft sbp->f_bsize = fs->fs_fsize;
967 1.1 mycroft sbp->f_iosize = fs->fs_bsize;
968 1.1 mycroft sbp->f_blocks = fs->fs_dsize;
969 1.1 mycroft sbp->f_bfree = fs->fs_cstotal.cs_nbfree * fs->fs_frag +
970 1.80.2.6 nathanw fs->fs_cstotal.cs_nffree + dbtofsb(fs, fs->fs_pendingblocks);
971 1.31 mjacob sbp->f_bavail = (long) (((u_int64_t) fs->fs_dsize * (u_int64_t)
972 1.38 kleink (100 - fs->fs_minfree) / (u_int64_t) 100) -
973 1.80.2.7 nathanw (u_int64_t) (fs->fs_dsize - sbp->f_bfree));
974 1.1 mycroft sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
975 1.80.2.6 nathanw sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
976 1.1 mycroft if (sbp != &mp->mnt_stat) {
977 1.42 perry memcpy(sbp->f_mntonname, mp->mnt_stat.f_mntonname, MNAMELEN);
978 1.42 perry memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname, MNAMELEN);
979 1.1 mycroft }
980 1.12 mycroft strncpy(sbp->f_fstypename, mp->mnt_op->vfs_name, MFSNAMELEN);
981 1.1 mycroft return (0);
982 1.1 mycroft }
983 1.1 mycroft
984 1.1 mycroft /*
985 1.1 mycroft * Go through the disk queues to initiate sandbagged IO;
986 1.1 mycroft * go through the inodes to write those that have been modified;
987 1.1 mycroft * initiate the writing of the super block if it has been modified.
988 1.1 mycroft *
989 1.1 mycroft * Note: we are always called with the filesystem marked `MPBUSY'.
990 1.1 mycroft */
991 1.1 mycroft int
992 1.1 mycroft ffs_sync(mp, waitfor, cred, p)
993 1.1 mycroft struct mount *mp;
994 1.1 mycroft int waitfor;
995 1.1 mycroft struct ucred *cred;
996 1.1 mycroft struct proc *p;
997 1.1 mycroft {
998 1.33 fvdl struct vnode *vp, *nvp;
999 1.33 fvdl struct inode *ip;
1000 1.33 fvdl struct ufsmount *ump = VFSTOUFS(mp);
1001 1.33 fvdl struct fs *fs;
1002 1.1 mycroft int error, allerror = 0;
1003 1.1 mycroft
1004 1.1 mycroft fs = ump->um_fs;
1005 1.33 fvdl if (fs->fs_fmod != 0 && fs->fs_ronly != 0) { /* XXX */
1006 1.33 fvdl printf("fs = %s\n", fs->fs_fsmnt);
1007 1.33 fvdl panic("update: rofs mod");
1008 1.1 mycroft }
1009 1.1 mycroft /*
1010 1.1 mycroft * Write back each (modified) inode.
1011 1.1 mycroft */
1012 1.33 fvdl simple_lock(&mntvnode_slock);
1013 1.1 mycroft loop:
1014 1.64 mycroft for (vp = LIST_FIRST(&mp->mnt_vnodelist); vp != NULL; vp = nvp) {
1015 1.1 mycroft /*
1016 1.1 mycroft * If the vnode that we are about to sync is no longer
1017 1.1 mycroft * associated with this mount point, start over.
1018 1.1 mycroft */
1019 1.1 mycroft if (vp->v_mount != mp)
1020 1.1 mycroft goto loop;
1021 1.33 fvdl simple_lock(&vp->v_interlock);
1022 1.64 mycroft nvp = LIST_NEXT(vp, v_mntvnodes);
1023 1.1 mycroft ip = VTOI(vp);
1024 1.57 fvdl if (vp->v_type == VNON ||
1025 1.57 fvdl ((ip->i_flag &
1026 1.63 mycroft (IN_ACCESS | IN_CHANGE | IN_UPDATE | IN_MODIFIED | IN_ACCESSED)) == 0 &&
1027 1.75 chs LIST_EMPTY(&vp->v_dirtyblkhd) &&
1028 1.80.2.4 nathanw vp->v_uobj.uo_npages == 0))
1029 1.57 fvdl {
1030 1.33 fvdl simple_unlock(&vp->v_interlock);
1031 1.33 fvdl continue;
1032 1.33 fvdl }
1033 1.33 fvdl simple_unlock(&mntvnode_slock);
1034 1.33 fvdl error = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
1035 1.33 fvdl if (error) {
1036 1.33 fvdl simple_lock(&mntvnode_slock);
1037 1.33 fvdl if (error == ENOENT)
1038 1.33 fvdl goto loop;
1039 1.1 mycroft continue;
1040 1.33 fvdl }
1041 1.35 kleink if ((error = VOP_FSYNC(vp, cred,
1042 1.71 fvdl waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, p)) != 0)
1043 1.1 mycroft allerror = error;
1044 1.1 mycroft vput(vp);
1045 1.33 fvdl simple_lock(&mntvnode_slock);
1046 1.1 mycroft }
1047 1.33 fvdl simple_unlock(&mntvnode_slock);
1048 1.1 mycroft /*
1049 1.1 mycroft * Force stale file system control information to be flushed.
1050 1.1 mycroft */
1051 1.55 fvdl if (waitfor != MNT_LAZY) {
1052 1.55 fvdl if (ump->um_mountp->mnt_flag & MNT_SOFTDEP)
1053 1.55 fvdl waitfor = MNT_NOWAIT;
1054 1.55 fvdl vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
1055 1.55 fvdl if ((error = VOP_FSYNC(ump->um_devvp, cred,
1056 1.71 fvdl waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0, p)) != 0)
1057 1.55 fvdl allerror = error;
1058 1.55 fvdl VOP_UNLOCK(ump->um_devvp, 0);
1059 1.55 fvdl }
1060 1.1 mycroft #ifdef QUOTA
1061 1.1 mycroft qsync(mp);
1062 1.1 mycroft #endif
1063 1.33 fvdl /*
1064 1.33 fvdl * Write back modified superblock.
1065 1.33 fvdl */
1066 1.33 fvdl if (fs->fs_fmod != 0) {
1067 1.33 fvdl fs->fs_fmod = 0;
1068 1.33 fvdl fs->fs_time = time.tv_sec;
1069 1.64 mycroft if ((error = ffs_cgupdate(ump, waitfor)))
1070 1.64 mycroft allerror = error;
1071 1.33 fvdl }
1072 1.1 mycroft return (allerror);
1073 1.1 mycroft }
1074 1.1 mycroft
1075 1.1 mycroft /*
1076 1.1 mycroft * Look up a FFS dinode number to find its incore vnode, otherwise read it
1077 1.1 mycroft * in from disk. If it is in core, wait for the lock bit to clear, then
1078 1.1 mycroft * return the inode locked. Detection and handling of mount points must be
1079 1.1 mycroft * done by the calling routine.
1080 1.1 mycroft */
1081 1.1 mycroft int
1082 1.1 mycroft ffs_vget(mp, ino, vpp)
1083 1.1 mycroft struct mount *mp;
1084 1.1 mycroft ino_t ino;
1085 1.1 mycroft struct vnode **vpp;
1086 1.1 mycroft {
1087 1.33 fvdl struct fs *fs;
1088 1.33 fvdl struct inode *ip;
1089 1.1 mycroft struct ufsmount *ump;
1090 1.1 mycroft struct buf *bp;
1091 1.1 mycroft struct vnode *vp;
1092 1.1 mycroft dev_t dev;
1093 1.43 thorpej int error;
1094 1.44 thorpej caddr_t cp;
1095 1.1 mycroft
1096 1.1 mycroft ump = VFSTOUFS(mp);
1097 1.1 mycroft dev = ump->um_dev;
1098 1.68 fvdl
1099 1.68 fvdl if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
1100 1.68 fvdl return (0);
1101 1.1 mycroft
1102 1.1 mycroft /* Allocate a new vnode/inode. */
1103 1.19 christos if ((error = getnewvnode(VT_UFS, mp, ffs_vnodeop_p, &vp)) != 0) {
1104 1.1 mycroft *vpp = NULL;
1105 1.1 mycroft return (error);
1106 1.1 mycroft }
1107 1.68 fvdl
1108 1.68 fvdl /*
1109 1.68 fvdl * If someone beat us to it while sleeping in getnewvnode(),
1110 1.68 fvdl * push back the freshly allocated vnode we don't need, and return.
1111 1.68 fvdl */
1112 1.80.2.4 nathanw
1113 1.68 fvdl do {
1114 1.68 fvdl if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL) {
1115 1.69 fvdl ungetnewvnode(vp);
1116 1.68 fvdl return (0);
1117 1.68 fvdl }
1118 1.68 fvdl } while (lockmgr(&ufs_hashlock, LK_EXCLUSIVE|LK_SLEEPFAIL, 0));
1119 1.68 fvdl
1120 1.43 thorpej /*
1121 1.43 thorpej * XXX MFS ends up here, too, to allocate an inode. Should we
1122 1.43 thorpej * XXX create another pool for MFS inodes?
1123 1.43 thorpej */
1124 1.80.2.4 nathanw
1125 1.43 thorpej ip = pool_get(&ffs_inode_pool, PR_WAITOK);
1126 1.80.2.4 nathanw memset(ip, 0, sizeof(struct inode));
1127 1.1 mycroft vp->v_data = ip;
1128 1.1 mycroft ip->i_vnode = vp;
1129 1.1 mycroft ip->i_fs = fs = ump->um_fs;
1130 1.1 mycroft ip->i_dev = dev;
1131 1.1 mycroft ip->i_number = ino;
1132 1.77 chs LIST_INIT(&ip->i_pcbufhd);
1133 1.1 mycroft #ifdef QUOTA
1134 1.19 christos {
1135 1.19 christos int i;
1136 1.19 christos
1137 1.19 christos for (i = 0; i < MAXQUOTAS; i++)
1138 1.19 christos ip->i_dquot[i] = NODQUOT;
1139 1.19 christos }
1140 1.1 mycroft #endif
1141 1.80.2.4 nathanw
1142 1.1 mycroft /*
1143 1.1 mycroft * Put it onto its hash chain and lock it so that other requests for
1144 1.1 mycroft * this inode will block if they arrive while we are sleeping waiting
1145 1.1 mycroft * for old data structures to be purged or for the contents of the
1146 1.1 mycroft * disk portion of this inode to be read.
1147 1.1 mycroft */
1148 1.80.2.4 nathanw
1149 1.1 mycroft ufs_ihashins(ip);
1150 1.33 fvdl lockmgr(&ufs_hashlock, LK_RELEASE, 0);
1151 1.1 mycroft
1152 1.1 mycroft /* Read in the disk contents for the inode, copy into the inode. */
1153 1.19 christos error = bread(ump->um_devvp, fsbtodb(fs, ino_to_fsba(fs, ino)),
1154 1.19 christos (int)fs->fs_bsize, NOCRED, &bp);
1155 1.19 christos if (error) {
1156 1.80.2.4 nathanw
1157 1.1 mycroft /*
1158 1.1 mycroft * The inode does not contain anything useful, so it would
1159 1.1 mycroft * be misleading to leave it on its hash chain. With mode
1160 1.1 mycroft * still zero, it will be unlinked and returned to the free
1161 1.1 mycroft * list by vput().
1162 1.1 mycroft */
1163 1.80.2.4 nathanw
1164 1.1 mycroft vput(vp);
1165 1.1 mycroft brelse(bp);
1166 1.1 mycroft *vpp = NULL;
1167 1.1 mycroft return (error);
1168 1.1 mycroft }
1169 1.44 thorpej cp = (caddr_t)bp->b_data + (ino_to_fsbo(fs, ino) * DINODE_SIZE);
1170 1.34 bouyer #ifdef FFS_EI
1171 1.55 fvdl if (UFS_FSNEEDSWAP(fs))
1172 1.44 thorpej ffs_dinode_swap((struct dinode *)cp, &ip->i_din.ffs_din);
1173 1.34 bouyer else
1174 1.34 bouyer #endif
1175 1.44 thorpej memcpy(&ip->i_din.ffs_din, cp, DINODE_SIZE);
1176 1.55 fvdl if (DOINGSOFTDEP(vp))
1177 1.55 fvdl softdep_load_inodeblock(ip);
1178 1.55 fvdl else
1179 1.55 fvdl ip->i_ffs_effnlink = ip->i_ffs_nlink;
1180 1.1 mycroft brelse(bp);
1181 1.1 mycroft
1182 1.1 mycroft /*
1183 1.1 mycroft * Initialize the vnode from the inode, check for aliases.
1184 1.1 mycroft * Note that the underlying vnode may have changed.
1185 1.1 mycroft */
1186 1.80.2.4 nathanw
1187 1.80.2.4 nathanw ufs_vinit(mp, ffs_specop_p, ffs_fifoop_p, &vp);
1188 1.80.2.4 nathanw
1189 1.1 mycroft /*
1190 1.1 mycroft * Finish inode initialization now that aliasing has been resolved.
1191 1.1 mycroft */
1192 1.80.2.4 nathanw
1193 1.80.2.4 nathanw genfs_node_init(vp, &ffs_genfsops);
1194 1.1 mycroft ip->i_devvp = ump->um_devvp;
1195 1.1 mycroft VREF(ip->i_devvp);
1196 1.80.2.4 nathanw
1197 1.1 mycroft /*
1198 1.1 mycroft * Ensure that uid and gid are correct. This is a temporary
1199 1.1 mycroft * fix until fsck has been changed to do the update.
1200 1.1 mycroft */
1201 1.80.2.4 nathanw
1202 1.38 kleink if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1203 1.38 kleink ip->i_ffs_uid = ip->i_din.ffs_din.di_ouid; /* XXX */
1204 1.38 kleink ip->i_ffs_gid = ip->i_din.ffs_din.di_ogid; /* XXX */
1205 1.38 kleink } /* XXX */
1206 1.73 chs uvm_vnp_setsize(vp, ip->i_ffs_size);
1207 1.1 mycroft *vpp = vp;
1208 1.1 mycroft return (0);
1209 1.1 mycroft }
1210 1.1 mycroft
1211 1.1 mycroft /*
1212 1.1 mycroft * File handle to vnode
1213 1.1 mycroft *
1214 1.1 mycroft * Have to be really careful about stale file handles:
1215 1.1 mycroft * - check that the inode number is valid
1216 1.1 mycroft * - call ffs_vget() to get the locked inode
1217 1.1 mycroft * - check for an unallocated inode (i_mode == 0)
1218 1.1 mycroft * - check that the given client host has export rights and return
1219 1.1 mycroft * those rights via. exflagsp and credanonp
1220 1.1 mycroft */
1221 1.1 mycroft int
1222 1.48 wrstuden ffs_fhtovp(mp, fhp, vpp)
1223 1.61 augustss struct mount *mp;
1224 1.1 mycroft struct fid *fhp;
1225 1.1 mycroft struct vnode **vpp;
1226 1.1 mycroft {
1227 1.61 augustss struct ufid *ufhp;
1228 1.1 mycroft struct fs *fs;
1229 1.1 mycroft
1230 1.1 mycroft ufhp = (struct ufid *)fhp;
1231 1.1 mycroft fs = VFSTOUFS(mp)->um_fs;
1232 1.1 mycroft if (ufhp->ufid_ino < ROOTINO ||
1233 1.1 mycroft ufhp->ufid_ino >= fs->fs_ncg * fs->fs_ipg)
1234 1.1 mycroft return (ESTALE);
1235 1.48 wrstuden return (ufs_fhtovp(mp, ufhp, vpp));
1236 1.1 mycroft }
1237 1.1 mycroft
1238 1.1 mycroft /*
1239 1.1 mycroft * Vnode pointer to File handle
1240 1.1 mycroft */
1241 1.1 mycroft /* ARGSUSED */
1242 1.19 christos int
1243 1.1 mycroft ffs_vptofh(vp, fhp)
1244 1.1 mycroft struct vnode *vp;
1245 1.1 mycroft struct fid *fhp;
1246 1.1 mycroft {
1247 1.61 augustss struct inode *ip;
1248 1.61 augustss struct ufid *ufhp;
1249 1.1 mycroft
1250 1.1 mycroft ip = VTOI(vp);
1251 1.1 mycroft ufhp = (struct ufid *)fhp;
1252 1.1 mycroft ufhp->ufid_len = sizeof(struct ufid);
1253 1.1 mycroft ufhp->ufid_ino = ip->i_number;
1254 1.25 bouyer ufhp->ufid_gen = ip->i_ffs_gen;
1255 1.1 mycroft return (0);
1256 1.33 fvdl }
1257 1.33 fvdl
1258 1.33 fvdl void
1259 1.33 fvdl ffs_init()
1260 1.33 fvdl {
1261 1.59 jdolecek if (ffs_initcount++ > 0)
1262 1.59 jdolecek return;
1263 1.59 jdolecek
1264 1.55 fvdl softdep_initialize();
1265 1.33 fvdl ufs_init();
1266 1.43 thorpej
1267 1.43 thorpej pool_init(&ffs_inode_pool, sizeof(struct inode), 0, 0, 0, "ffsinopl",
1268 1.80.2.7 nathanw &pool_allocator_nointr);
1269 1.59 jdolecek }
1270 1.59 jdolecek
1271 1.59 jdolecek void
1272 1.80.2.4 nathanw ffs_reinit()
1273 1.80.2.4 nathanw {
1274 1.80.2.4 nathanw softdep_reinitialize();
1275 1.80.2.4 nathanw ufs_reinit();
1276 1.80.2.4 nathanw }
1277 1.80.2.4 nathanw
1278 1.80.2.4 nathanw void
1279 1.59 jdolecek ffs_done()
1280 1.59 jdolecek {
1281 1.59 jdolecek if (--ffs_initcount > 0)
1282 1.59 jdolecek return;
1283 1.59 jdolecek
1284 1.59 jdolecek /* XXX softdep cleanup ? */
1285 1.59 jdolecek ufs_done();
1286 1.59 jdolecek pool_destroy(&ffs_inode_pool);
1287 1.33 fvdl }
1288 1.33 fvdl
1289 1.33 fvdl int
1290 1.33 fvdl ffs_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
1291 1.33 fvdl int *name;
1292 1.33 fvdl u_int namelen;
1293 1.33 fvdl void *oldp;
1294 1.33 fvdl size_t *oldlenp;
1295 1.33 fvdl void *newp;
1296 1.33 fvdl size_t newlen;
1297 1.33 fvdl struct proc *p;
1298 1.33 fvdl {
1299 1.80.2.4 nathanw extern int doasyncfree;
1300 1.62 jdolecek extern int ffs_log_changeopt;
1301 1.33 fvdl
1302 1.33 fvdl /* all sysctl names at this level are terminal */
1303 1.33 fvdl if (namelen != 1)
1304 1.33 fvdl return (ENOTDIR); /* overloaded */
1305 1.33 fvdl
1306 1.33 fvdl switch (name[0]) {
1307 1.33 fvdl case FFS_ASYNCFREE:
1308 1.33 fvdl return (sysctl_int(oldp, oldlenp, newp, newlen, &doasyncfree));
1309 1.62 jdolecek case FFS_LOG_CHANGEOPT:
1310 1.62 jdolecek return (sysctl_int(oldp, oldlenp, newp, newlen,
1311 1.62 jdolecek &ffs_log_changeopt));
1312 1.33 fvdl default:
1313 1.33 fvdl return (EOPNOTSUPP);
1314 1.33 fvdl }
1315 1.33 fvdl /* NOTREACHED */
1316 1.1 mycroft }
1317 1.1 mycroft
1318 1.1 mycroft /*
1319 1.1 mycroft * Write a superblock and associated information back to disk.
1320 1.1 mycroft */
1321 1.1 mycroft int
1322 1.1 mycroft ffs_sbupdate(mp, waitfor)
1323 1.1 mycroft struct ufsmount *mp;
1324 1.1 mycroft int waitfor;
1325 1.1 mycroft {
1326 1.61 augustss struct fs *fs = mp->um_fs;
1327 1.61 augustss struct buf *bp;
1328 1.15 mycroft int i, error = 0;
1329 1.34 bouyer int32_t saved_nrpos = fs->fs_nrpos;
1330 1.34 bouyer int64_t saved_qbmask = fs->fs_qbmask;
1331 1.34 bouyer int64_t saved_qfmask = fs->fs_qfmask;
1332 1.34 bouyer u_int64_t saved_maxfilesize = fs->fs_maxfilesize;
1333 1.55 fvdl u_int8_t saveflag;
1334 1.1 mycroft
1335 1.1 mycroft /* Restore compatibility to old file systems. XXX */
1336 1.1 mycroft if (fs->fs_postblformat == FS_42POSTBLFMT) /* XXX */
1337 1.34 bouyer fs->fs_nrpos = -1; /* XXX */
1338 1.1 mycroft if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
1339 1.5 mycroft int32_t *lp, tmp; /* XXX */
1340 1.1 mycroft /* XXX */
1341 1.38 kleink lp = (int32_t *)&fs->fs_qbmask; /* XXX nuke qfmask too */
1342 1.1 mycroft tmp = lp[4]; /* XXX */
1343 1.1 mycroft for (i = 4; i > 0; i--) /* XXX */
1344 1.1 mycroft lp[i] = lp[i-1]; /* XXX */
1345 1.1 mycroft lp[0] = tmp; /* XXX */
1346 1.1 mycroft } /* XXX */
1347 1.34 bouyer fs->fs_maxfilesize = mp->um_savedmaxfilesize; /* XXX */
1348 1.34 bouyer
1349 1.34 bouyer bp = getblk(mp->um_devvp, SBOFF >> (fs->fs_fshift - fs->fs_fsbtodb),
1350 1.34 bouyer (int)fs->fs_sbsize, 0, 0);
1351 1.55 fvdl saveflag = fs->fs_flags & FS_INTERNAL;
1352 1.55 fvdl fs->fs_flags &= ~FS_INTERNAL;
1353 1.42 perry memcpy(bp->b_data, fs, fs->fs_sbsize);
1354 1.34 bouyer #ifdef FFS_EI
1355 1.34 bouyer if (mp->um_flags & UFS_NEEDSWAP)
1356 1.80.2.3 nathanw ffs_sb_swap(fs, (struct fs*)bp->b_data);
1357 1.34 bouyer #endif
1358 1.34 bouyer
1359 1.55 fvdl fs->fs_flags |= saveflag;
1360 1.34 bouyer fs->fs_nrpos = saved_nrpos; /* XXX */
1361 1.34 bouyer fs->fs_qbmask = saved_qbmask; /* XXX */
1362 1.34 bouyer fs->fs_qfmask = saved_qfmask; /* XXX */
1363 1.34 bouyer fs->fs_maxfilesize = saved_maxfilesize; /* XXX */
1364 1.34 bouyer
1365 1.1 mycroft if (waitfor == MNT_WAIT)
1366 1.1 mycroft error = bwrite(bp);
1367 1.1 mycroft else
1368 1.1 mycroft bawrite(bp);
1369 1.15 mycroft return (error);
1370 1.15 mycroft }
1371 1.15 mycroft
1372 1.15 mycroft int
1373 1.15 mycroft ffs_cgupdate(mp, waitfor)
1374 1.15 mycroft struct ufsmount *mp;
1375 1.15 mycroft int waitfor;
1376 1.15 mycroft {
1377 1.61 augustss struct fs *fs = mp->um_fs;
1378 1.61 augustss struct buf *bp;
1379 1.15 mycroft int blks;
1380 1.80.2.4 nathanw void *space;
1381 1.15 mycroft int i, size, error = 0, allerror = 0;
1382 1.15 mycroft
1383 1.15 mycroft allerror = ffs_sbupdate(mp, waitfor);
1384 1.1 mycroft blks = howmany(fs->fs_cssize, fs->fs_fsize);
1385 1.80.2.4 nathanw space = fs->fs_csp;
1386 1.1 mycroft for (i = 0; i < blks; i += fs->fs_frag) {
1387 1.1 mycroft size = fs->fs_bsize;
1388 1.1 mycroft if (i + fs->fs_frag > blks)
1389 1.1 mycroft size = (blks - i) * fs->fs_fsize;
1390 1.1 mycroft bp = getblk(mp->um_devvp, fsbtodb(fs, fs->fs_csaddr + i),
1391 1.1 mycroft size, 0, 0);
1392 1.34 bouyer #ifdef FFS_EI
1393 1.34 bouyer if (mp->um_flags & UFS_NEEDSWAP)
1394 1.34 bouyer ffs_csum_swap((struct csum*)space,
1395 1.38 kleink (struct csum*)bp->b_data, size);
1396 1.34 bouyer else
1397 1.34 bouyer #endif
1398 1.42 perry memcpy(bp->b_data, space, (u_int)size);
1399 1.80.2.4 nathanw space = (char *)space + size;
1400 1.1 mycroft if (waitfor == MNT_WAIT)
1401 1.1 mycroft error = bwrite(bp);
1402 1.1 mycroft else
1403 1.1 mycroft bawrite(bp);
1404 1.1 mycroft }
1405 1.15 mycroft if (!allerror && error)
1406 1.15 mycroft allerror = error;
1407 1.15 mycroft return (allerror);
1408 1.1 mycroft }
1409