ext2fs_vfsops.c revision 1.178 1 1.178 hannken /* $NetBSD: ext2fs_vfsops.c,v 1.178 2014/03/17 09:30:32 hannken Exp $ */
2 1.1 bouyer
3 1.1 bouyer /*
4 1.1 bouyer * Copyright (c) 1989, 1991, 1993, 1994
5 1.1 bouyer * The Regents of the University of California. All rights reserved.
6 1.1 bouyer *
7 1.1 bouyer * Redistribution and use in source and binary forms, with or without
8 1.1 bouyer * modification, are permitted provided that the following conditions
9 1.1 bouyer * are met:
10 1.1 bouyer * 1. Redistributions of source code must retain the above copyright
11 1.18 christos * notice, this list of conditions and the following disclaimer.
12 1.1 bouyer * 2. Redistributions in binary form must reproduce the above copyright
13 1.18 christos * notice, this list of conditions and the following disclaimer in the
14 1.18 christos * documentation and/or other materials provided with the distribution.
15 1.61 agc * 3. Neither the name of the University nor the names of its contributors
16 1.61 agc * may be used to endorse or promote products derived from this software
17 1.61 agc * without specific prior written permission.
18 1.61 agc *
19 1.61 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 1.61 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 1.61 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 1.61 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 1.61 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 1.61 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 1.61 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 1.61 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 1.61 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 1.61 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 1.61 agc * SUCH DAMAGE.
30 1.61 agc *
31 1.61 agc * @(#)ffs_vfsops.c 8.14 (Berkeley) 11/28/94
32 1.61 agc * Modified for ext2fs by Manuel Bouyer.
33 1.61 agc */
34 1.61 agc
35 1.61 agc /*
36 1.61 agc * Copyright (c) 1997 Manuel Bouyer.
37 1.61 agc *
38 1.61 agc * Redistribution and use in source and binary forms, with or without
39 1.61 agc * modification, are permitted provided that the following conditions
40 1.61 agc * are met:
41 1.61 agc * 1. Redistributions of source code must retain the above copyright
42 1.61 agc * notice, this list of conditions and the following disclaimer.
43 1.61 agc * 2. Redistributions in binary form must reproduce the above copyright
44 1.61 agc * notice, this list of conditions and the following disclaimer in the
45 1.61 agc * documentation and/or other materials provided with the distribution.
46 1.1 bouyer *
47 1.65 bouyer * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
48 1.65 bouyer * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 1.65 bouyer * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
50 1.65 bouyer * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
51 1.65 bouyer * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
52 1.65 bouyer * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
53 1.65 bouyer * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
54 1.65 bouyer * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
55 1.65 bouyer * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
56 1.65 bouyer * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57 1.1 bouyer *
58 1.1 bouyer * @(#)ffs_vfsops.c 8.14 (Berkeley) 11/28/94
59 1.1 bouyer * Modified for ext2fs by Manuel Bouyer.
60 1.1 bouyer */
61 1.48 lukem
62 1.48 lukem #include <sys/cdefs.h>
63 1.178 hannken __KERNEL_RCSID(0, "$NetBSD: ext2fs_vfsops.c,v 1.178 2014/03/17 09:30:32 hannken Exp $");
64 1.15 jonathan
65 1.43 mrg #if defined(_KERNEL_OPT)
66 1.15 jonathan #include "opt_compat_netbsd.h"
67 1.15 jonathan #endif
68 1.13 sommerfe
69 1.1 bouyer #include <sys/param.h>
70 1.1 bouyer #include <sys/systm.h>
71 1.64 atatat #include <sys/sysctl.h>
72 1.1 bouyer #include <sys/namei.h>
73 1.1 bouyer #include <sys/proc.h>
74 1.1 bouyer #include <sys/kernel.h>
75 1.1 bouyer #include <sys/vnode.h>
76 1.1 bouyer #include <sys/socket.h>
77 1.1 bouyer #include <sys/mount.h>
78 1.1 bouyer #include <sys/buf.h>
79 1.1 bouyer #include <sys/device.h>
80 1.1 bouyer #include <sys/mbuf.h>
81 1.1 bouyer #include <sys/file.h>
82 1.1 bouyer #include <sys/disklabel.h>
83 1.1 bouyer #include <sys/ioctl.h>
84 1.1 bouyer #include <sys/errno.h>
85 1.1 bouyer #include <sys/malloc.h>
86 1.17 thorpej #include <sys/pool.h>
87 1.3 bouyer #include <sys/lock.h>
88 1.51 gehenna #include <sys/conf.h>
89 1.97 elad #include <sys/kauth.h>
90 1.135 rumble #include <sys/module.h>
91 1.1 bouyer
92 1.129 dholland #include <miscfs/genfs/genfs.h>
93 1.1 bouyer #include <miscfs/specfs/specdev.h>
94 1.1 bouyer
95 1.1 bouyer #include <ufs/ufs/quota.h>
96 1.1 bouyer #include <ufs/ufs/ufsmount.h>
97 1.1 bouyer #include <ufs/ufs/inode.h>
98 1.1 bouyer #include <ufs/ufs/dir.h>
99 1.1 bouyer #include <ufs/ufs/ufs_extern.h>
100 1.1 bouyer
101 1.1 bouyer #include <ufs/ext2fs/ext2fs.h>
102 1.88 christos #include <ufs/ext2fs/ext2fs_dir.h>
103 1.1 bouyer #include <ufs/ext2fs/ext2fs_extern.h>
104 1.1 bouyer
105 1.139 ad MODULE(MODULE_CLASS_VFS, ext2fs, "ffs");
106 1.135 rumble
107 1.89 xtraeme int ext2fs_sbupdate(struct ufsmount *, int);
108 1.89 xtraeme static int ext2fs_checksb(struct ext2fs *, int);
109 1.7 thorpej
110 1.137 rumble static struct sysctllog *ext2fs_sysctl_log;
111 1.137 rumble
112 1.42 jdolecek extern const struct vnodeopv_desc ext2fs_vnodeop_opv_desc;
113 1.42 jdolecek extern const struct vnodeopv_desc ext2fs_specop_opv_desc;
114 1.42 jdolecek extern const struct vnodeopv_desc ext2fs_fifoop_opv_desc;
115 1.7 thorpej
116 1.42 jdolecek const struct vnodeopv_desc * const ext2fs_vnodeopv_descs[] = {
117 1.7 thorpej &ext2fs_vnodeop_opv_desc,
118 1.7 thorpej &ext2fs_specop_opv_desc,
119 1.7 thorpej &ext2fs_fifoop_opv_desc,
120 1.7 thorpej NULL,
121 1.7 thorpej };
122 1.1 bouyer
123 1.1 bouyer struct vfsops ext2fs_vfsops = {
124 1.1 bouyer MOUNT_EXT2FS,
125 1.113 dsl sizeof (struct ufs_args),
126 1.1 bouyer ext2fs_mount,
127 1.1 bouyer ufs_start,
128 1.1 bouyer ext2fs_unmount,
129 1.1 bouyer ufs_root,
130 1.1 bouyer ufs_quotactl,
131 1.67 christos ext2fs_statvfs,
132 1.1 bouyer ext2fs_sync,
133 1.1 bouyer ext2fs_vget,
134 1.1 bouyer ext2fs_fhtovp,
135 1.1 bouyer ext2fs_vptofh,
136 1.1 bouyer ext2fs_init,
137 1.44 chs ext2fs_reinit,
138 1.34 jdolecek ext2fs_done,
139 1.1 bouyer ext2fs_mountroot,
140 1.72 hannken (int (*)(struct mount *, struct vnode *, struct timespec *)) eopnotsupp,
141 1.78 thorpej vfs_stdextattrctl,
142 1.116 pooka (void *)eopnotsupp, /* vfs_suspendctl */
143 1.129 dholland genfs_renamelock_enter,
144 1.129 dholland genfs_renamelock_exit,
145 1.132 ad (void *)eopnotsupp,
146 1.8 drochner ext2fs_vnodeopv_descs,
147 1.101 christos 0,
148 1.101 christos { NULL, NULL },
149 1.1 bouyer };
150 1.1 bouyer
151 1.86 yamt static const struct genfs_ops ext2fs_genfsops = {
152 1.86 yamt .gop_size = genfs_size,
153 1.86 yamt .gop_alloc = ext2fs_gop_alloc,
154 1.86 yamt .gop_write = genfs_gop_write,
155 1.87 yamt .gop_markupdate = ufs_gop_markupdate,
156 1.45 chs };
157 1.45 chs
158 1.92 yamt static const struct ufs_ops ext2fs_ufsops = {
159 1.92 yamt .uo_itimes = ext2fs_itimes,
160 1.93 yamt .uo_update = ext2fs_update,
161 1.126 ad .uo_vfree = ext2fs_vfree,
162 1.92 yamt };
163 1.92 yamt
164 1.140 mrg /* Fill in the inode uid/gid from ext2 halves. */
165 1.152 pooka void
166 1.140 mrg ext2fs_set_inode_guid(struct inode *ip)
167 1.140 mrg {
168 1.140 mrg
169 1.140 mrg ip->i_gid = ip->i_e2fs_gid;
170 1.140 mrg ip->i_uid = ip->i_e2fs_uid;
171 1.140 mrg if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0) {
172 1.140 mrg ip->i_gid |= ip->i_e2fs_gid_high << 16;
173 1.140 mrg ip->i_uid |= ip->i_e2fs_uid_high << 16;
174 1.140 mrg }
175 1.140 mrg }
176 1.140 mrg
177 1.135 rumble static int
178 1.135 rumble ext2fs_modcmd(modcmd_t cmd, void *arg)
179 1.135 rumble {
180 1.137 rumble int error;
181 1.135 rumble
182 1.135 rumble switch (cmd) {
183 1.135 rumble case MODULE_CMD_INIT:
184 1.137 rumble error = vfs_attach(&ext2fs_vfsops);
185 1.137 rumble if (error != 0)
186 1.137 rumble break;
187 1.137 rumble sysctl_createv(&ext2fs_sysctl_log, 0, NULL, NULL,
188 1.137 rumble CTLFLAG_PERMANENT,
189 1.137 rumble CTLTYPE_NODE, "ext2fs",
190 1.137 rumble SYSCTL_DESCR("Linux EXT2FS file system"),
191 1.137 rumble NULL, 0, NULL, 0,
192 1.137 rumble CTL_VFS, 17, CTL_EOL);
193 1.137 rumble /*
194 1.137 rumble * XXX the "17" above could be dynamic, thereby eliminating
195 1.137 rumble * one more instance of the "number to vfs" mapping problem,
196 1.137 rumble * but "17" is the order as taken from sys/mount.h
197 1.137 rumble */
198 1.137 rumble break;
199 1.135 rumble case MODULE_CMD_FINI:
200 1.137 rumble error = vfs_detach(&ext2fs_vfsops);
201 1.137 rumble if (error != 0)
202 1.137 rumble break;
203 1.137 rumble sysctl_teardown(&ext2fs_sysctl_log);
204 1.137 rumble break;
205 1.135 rumble default:
206 1.137 rumble error = ENOTTY;
207 1.137 rumble break;
208 1.135 rumble }
209 1.137 rumble
210 1.137 rumble return (error);
211 1.135 rumble }
212 1.135 rumble
213 1.68 simonb /*
214 1.68 simonb * XXX Same structure as FFS inodes? Should we share a common pool?
215 1.68 simonb */
216 1.112 pooka struct pool ext2fs_inode_pool;
217 1.112 pooka struct pool ext2fs_dinode_pool;
218 1.17 thorpej
219 1.1 bouyer extern u_long ext2gennumber;
220 1.1 bouyer
221 1.9 fvdl void
222 1.89 xtraeme ext2fs_init(void)
223 1.9 fvdl {
224 1.112 pooka
225 1.70 atatat pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0,
226 1.110 ad "ext2fsinopl", &pool_allocator_nointr, IPL_NONE);
227 1.70 atatat pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0,
228 1.110 ad "ext2dinopl", &pool_allocator_nointr, IPL_NONE);
229 1.19 bouyer ufs_init();
230 1.44 chs }
231 1.44 chs
232 1.44 chs void
233 1.89 xtraeme ext2fs_reinit(void)
234 1.44 chs {
235 1.44 chs ufs_reinit();
236 1.9 fvdl }
237 1.9 fvdl
238 1.34 jdolecek void
239 1.89 xtraeme ext2fs_done(void)
240 1.34 jdolecek {
241 1.112 pooka
242 1.34 jdolecek ufs_done();
243 1.34 jdolecek pool_destroy(&ext2fs_inode_pool);
244 1.70 atatat pool_destroy(&ext2fs_dinode_pool);
245 1.34 jdolecek }
246 1.1 bouyer
247 1.1 bouyer /*
248 1.1 bouyer * Called by main() when ext2fs is going to be mounted as root.
249 1.1 bouyer *
250 1.1 bouyer * Name is updated by mount(8) after booting.
251 1.1 bouyer */
252 1.1 bouyer #define ROOTNAME "root_device"
253 1.1 bouyer
254 1.1 bouyer int
255 1.89 xtraeme ext2fs_mountroot(void)
256 1.1 bouyer {
257 1.1 bouyer extern struct vnode *rootvp;
258 1.9 fvdl struct m_ext2fs *fs;
259 1.9 fvdl struct mount *mp;
260 1.1 bouyer struct ufsmount *ump;
261 1.1 bouyer int error;
262 1.1 bouyer
263 1.95 thorpej if (device_class(root_device) != DV_DISK)
264 1.1 bouyer return (ENODEV);
265 1.83 perry
266 1.27 wrstuden if ((error = vfs_rootmountalloc(MOUNT_EXT2FS, "root_device", &mp))) {
267 1.27 wrstuden vrele(rootvp);
268 1.9 fvdl return (error);
269 1.27 wrstuden }
270 1.9 fvdl
271 1.123 pooka if ((error = ext2fs_mountfs(rootvp, mp)) != 0) {
272 1.133 ad vfs_unbusy(mp, false, NULL);
273 1.134 ad vfs_destroy(mp);
274 1.1 bouyer return (error);
275 1.1 bouyer }
276 1.175 christos mountlist_append(mp);
277 1.1 bouyer ump = VFSTOUFS(mp);
278 1.1 bouyer fs = ump->um_e2fs;
279 1.16 perry memset(fs->e2fs_fsmnt, 0, sizeof(fs->e2fs_fsmnt));
280 1.9 fvdl (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
281 1.31 bouyer sizeof(fs->e2fs_fsmnt) - 1, 0);
282 1.31 bouyer if (fs->e2fs.e2fs_rev > E2FS_REV0) {
283 1.31 bouyer memset(fs->e2fs.e2fs_fsmnt, 0, sizeof(fs->e2fs.e2fs_fsmnt));
284 1.31 bouyer (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
285 1.31 bouyer sizeof(fs->e2fs.e2fs_fsmnt) - 1, 0);
286 1.31 bouyer }
287 1.123 pooka (void)ext2fs_statvfs(mp, &mp->mnt_stat);
288 1.133 ad vfs_unbusy(mp, false, NULL);
289 1.73 pk setrootfstime((time_t)fs->e2fs.e2fs_wtime);
290 1.1 bouyer return (0);
291 1.1 bouyer }
292 1.1 bouyer
293 1.1 bouyer /*
294 1.1 bouyer * VFS Operations.
295 1.1 bouyer *
296 1.1 bouyer * mount system call
297 1.1 bouyer */
298 1.1 bouyer int
299 1.123 pooka ext2fs_mount(struct mount *mp, const char *path, void *data, size_t *data_len)
300 1.1 bouyer {
301 1.123 pooka struct lwp *l = curlwp;
302 1.1 bouyer struct vnode *devvp;
303 1.113 dsl struct ufs_args *args = data;
304 1.1 bouyer struct ufsmount *ump = NULL;
305 1.35 augustss struct m_ext2fs *fs;
306 1.1 bouyer size_t size;
307 1.113 dsl int error = 0, flags, update;
308 1.1 bouyer mode_t accessmode;
309 1.52 christos
310 1.113 dsl if (*data_len < sizeof *args)
311 1.113 dsl return EINVAL;
312 1.113 dsl
313 1.52 christos if (mp->mnt_flag & MNT_GETARGS) {
314 1.52 christos ump = VFSTOUFS(mp);
315 1.52 christos if (ump == NULL)
316 1.52 christos return EIO;
317 1.113 dsl memset(args, 0, sizeof *args);
318 1.113 dsl args->fspec = NULL;
319 1.113 dsl *data_len = sizeof *args;
320 1.113 dsl return 0;
321 1.52 christos }
322 1.80 mycroft
323 1.80 mycroft update = mp->mnt_flag & MNT_UPDATE;
324 1.80 mycroft
325 1.81 mycroft /* Check arguments */
326 1.113 dsl if (args->fspec != NULL) {
327 1.80 mycroft /*
328 1.80 mycroft * Look up the name and verify that it's sane.
329 1.80 mycroft */
330 1.144 dholland error = namei_simple_user(args->fspec,
331 1.144 dholland NSM_FOLLOW_NOEMULROOT, &devvp);
332 1.144 dholland if (error != 0)
333 1.80 mycroft return (error);
334 1.80 mycroft
335 1.80 mycroft if (!update) {
336 1.80 mycroft /*
337 1.80 mycroft * Be sure this is a valid block device
338 1.80 mycroft */
339 1.80 mycroft if (devvp->v_type != VBLK)
340 1.80 mycroft error = ENOTBLK;
341 1.80 mycroft else if (bdevsw_lookup(devvp->v_rdev) == NULL)
342 1.80 mycroft error = ENXIO;
343 1.80 mycroft } else {
344 1.80 mycroft /*
345 1.80 mycroft * Be sure we're still naming the same device
346 1.80 mycroft * used for our initial mount
347 1.80 mycroft */
348 1.81 mycroft ump = VFSTOUFS(mp);
349 1.146 tsutsui if (devvp != ump->um_devvp) {
350 1.146 tsutsui if (devvp->v_rdev != ump->um_devvp->v_rdev)
351 1.146 tsutsui error = EINVAL;
352 1.146 tsutsui else {
353 1.146 tsutsui vrele(devvp);
354 1.146 tsutsui devvp = ump->um_devvp;
355 1.146 tsutsui vref(devvp);
356 1.146 tsutsui }
357 1.146 tsutsui }
358 1.80 mycroft }
359 1.81 mycroft } else {
360 1.81 mycroft if (!update) {
361 1.81 mycroft /* New mounts must have a filename for the device */
362 1.81 mycroft return (EINVAL);
363 1.81 mycroft } else {
364 1.81 mycroft ump = VFSTOUFS(mp);
365 1.81 mycroft devvp = ump->um_devvp;
366 1.81 mycroft vref(devvp);
367 1.81 mycroft }
368 1.80 mycroft }
369 1.80 mycroft
370 1.80 mycroft /*
371 1.80 mycroft * If mount by non-root, then verify that user has necessary
372 1.80 mycroft * permissions on the device.
373 1.143 elad *
374 1.143 elad * Permission to update a mount is checked higher, so here we presume
375 1.143 elad * updating the mount is okay (for example, as far as securelevel goes)
376 1.143 elad * which leaves us with the normal check.
377 1.80 mycroft */
378 1.145 tsutsui if (error == 0) {
379 1.145 tsutsui accessmode = VREAD;
380 1.145 tsutsui if (update ?
381 1.145 tsutsui (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
382 1.145 tsutsui (mp->mnt_flag & MNT_RDONLY) == 0)
383 1.145 tsutsui accessmode |= VWRITE;
384 1.145 tsutsui vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
385 1.163 elad error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
386 1.163 elad KAUTH_REQ_SYSTEM_MOUNT_DEVICE, mp, devvp,
387 1.163 elad KAUTH_ARG(accessmode));
388 1.157 hannken VOP_UNLOCK(devvp);
389 1.145 tsutsui }
390 1.80 mycroft
391 1.80 mycroft if (error) {
392 1.80 mycroft vrele(devvp);
393 1.80 mycroft return (error);
394 1.80 mycroft }
395 1.80 mycroft
396 1.80 mycroft if (!update) {
397 1.85 christos int xflags;
398 1.80 mycroft
399 1.80 mycroft if (mp->mnt_flag & MNT_RDONLY)
400 1.85 christos xflags = FREAD;
401 1.80 mycroft else
402 1.85 christos xflags = FREAD|FWRITE;
403 1.162 hannken vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
404 1.123 pooka error = VOP_OPEN(devvp, xflags, FSCRED);
405 1.162 hannken VOP_UNLOCK(devvp);
406 1.80 mycroft if (error)
407 1.80 mycroft goto fail;
408 1.123 pooka error = ext2fs_mountfs(devvp, mp);
409 1.80 mycroft if (error) {
410 1.80 mycroft vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
411 1.123 pooka (void)VOP_CLOSE(devvp, xflags, NOCRED);
412 1.157 hannken VOP_UNLOCK(devvp);
413 1.80 mycroft goto fail;
414 1.80 mycroft }
415 1.80 mycroft
416 1.1 bouyer ump = VFSTOUFS(mp);
417 1.1 bouyer fs = ump->um_e2fs;
418 1.80 mycroft } else {
419 1.80 mycroft /*
420 1.80 mycroft * Update the mount.
421 1.80 mycroft */
422 1.80 mycroft
423 1.80 mycroft /*
424 1.80 mycroft * The initial mount got a reference on this
425 1.80 mycroft * device, so drop the one obtained via
426 1.80 mycroft * namei(), above.
427 1.80 mycroft */
428 1.80 mycroft vrele(devvp);
429 1.80 mycroft
430 1.81 mycroft ump = VFSTOUFS(mp);
431 1.80 mycroft fs = ump->um_e2fs;
432 1.1 bouyer if (fs->e2fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
433 1.80 mycroft /*
434 1.80 mycroft * Changing from r/w to r/o
435 1.80 mycroft */
436 1.1 bouyer flags = WRITECLOSE;
437 1.1 bouyer if (mp->mnt_flag & MNT_FORCE)
438 1.1 bouyer flags |= FORCECLOSE;
439 1.123 pooka error = ext2fs_flushfiles(mp, flags);
440 1.1 bouyer if (error == 0 &&
441 1.80 mycroft ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
442 1.80 mycroft (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
443 1.1 bouyer fs->e2fs.e2fs_state = E2FS_ISCLEAN;
444 1.1 bouyer (void) ext2fs_sbupdate(ump, MNT_WAIT);
445 1.1 bouyer }
446 1.1 bouyer if (error)
447 1.1 bouyer return (error);
448 1.1 bouyer fs->e2fs_ronly = 1;
449 1.1 bouyer }
450 1.80 mycroft
451 1.1 bouyer if (mp->mnt_flag & MNT_RELOAD) {
452 1.149 tsutsui error = ext2fs_reload(mp, l->l_cred, l);
453 1.1 bouyer if (error)
454 1.1 bouyer return (error);
455 1.1 bouyer }
456 1.80 mycroft
457 1.63 dbj if (fs->e2fs_ronly && (mp->mnt_iflag & IMNT_WANTRDWR)) {
458 1.1 bouyer /*
459 1.80 mycroft * Changing from read-only to read/write
460 1.1 bouyer */
461 1.1 bouyer fs->e2fs_ronly = 0;
462 1.1 bouyer if (fs->e2fs.e2fs_state == E2FS_ISCLEAN)
463 1.1 bouyer fs->e2fs.e2fs_state = 0;
464 1.1 bouyer else
465 1.1 bouyer fs->e2fs.e2fs_state = E2FS_ERRORS;
466 1.1 bouyer fs->e2fs_fmod = 1;
467 1.1 bouyer }
468 1.113 dsl if (args->fspec == NULL)
469 1.147 tsutsui return 0;
470 1.1 bouyer }
471 1.1 bouyer
472 1.113 dsl error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
473 1.114 pooka UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
474 1.57 christos (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs_fsmnt,
475 1.57 christos sizeof(fs->e2fs_fsmnt) - 1, &size);
476 1.16 perry memset(fs->e2fs_fsmnt + size, 0, sizeof(fs->e2fs_fsmnt) - size);
477 1.31 bouyer if (fs->e2fs.e2fs_rev > E2FS_REV0) {
478 1.31 bouyer (void) copystr(mp->mnt_stat.f_mntonname, fs->e2fs.e2fs_fsmnt,
479 1.31 bouyer sizeof(fs->e2fs.e2fs_fsmnt) - 1, &size);
480 1.31 bouyer memset(fs->e2fs.e2fs_fsmnt, 0,
481 1.31 bouyer sizeof(fs->e2fs.e2fs_fsmnt) - size);
482 1.31 bouyer }
483 1.1 bouyer if (fs->e2fs_fmod != 0) { /* XXX */
484 1.1 bouyer fs->e2fs_fmod = 0;
485 1.1 bouyer if (fs->e2fs.e2fs_state == 0)
486 1.98 kardel fs->e2fs.e2fs_wtime = time_second;
487 1.1 bouyer else
488 1.1 bouyer printf("%s: file system not clean; please fsck(8)\n",
489 1.1 bouyer mp->mnt_stat.f_mntfromname);
490 1.1 bouyer (void) ext2fs_cgupdate(ump, MNT_WAIT);
491 1.1 bouyer }
492 1.80 mycroft return (error);
493 1.80 mycroft
494 1.80 mycroft fail:
495 1.80 mycroft vrele(devvp);
496 1.80 mycroft return (error);
497 1.1 bouyer }
498 1.1 bouyer
499 1.1 bouyer /*
500 1.1 bouyer * Reload all incore data for a filesystem (used after running fsck on
501 1.1 bouyer * the root filesystem and finding things to fix). The filesystem must
502 1.1 bouyer * be mounted read-only.
503 1.1 bouyer *
504 1.1 bouyer * Things to do to update the mount:
505 1.1 bouyer * 1) invalidate all cached meta-data.
506 1.1 bouyer * 2) re-read superblock from disk.
507 1.1 bouyer * 3) re-read summary information from disk.
508 1.1 bouyer * 4) invalidate all inactive vnodes.
509 1.1 bouyer * 5) invalidate all cached file data.
510 1.1 bouyer * 6) re-read inode data for all active vnodes.
511 1.1 bouyer */
512 1.1 bouyer int
513 1.149 tsutsui ext2fs_reload(struct mount *mp, kauth_cred_t cred, struct lwp *l)
514 1.1 bouyer {
515 1.177 hannken struct vnode *vp, *devvp;
516 1.1 bouyer struct inode *ip;
517 1.1 bouyer struct buf *bp;
518 1.1 bouyer struct m_ext2fs *fs;
519 1.1 bouyer struct ext2fs *newfs;
520 1.154 mlelstv int i, error;
521 1.109 christos void *cp;
522 1.149 tsutsui struct ufsmount *ump;
523 1.177 hannken struct vnode_iterator *marker;
524 1.1 bouyer
525 1.149 tsutsui if ((mp->mnt_flag & MNT_RDONLY) == 0)
526 1.1 bouyer return (EINVAL);
527 1.126 ad
528 1.149 tsutsui ump = VFSTOUFS(mp);
529 1.1 bouyer /*
530 1.1 bouyer * Step 1: invalidate all cached meta-data.
531 1.1 bouyer */
532 1.149 tsutsui devvp = ump->um_devvp;
533 1.38 jdolecek vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
534 1.94 christos error = vinvalbuf(devvp, 0, cred, l, 0, 0);
535 1.157 hannken VOP_UNLOCK(devvp);
536 1.38 jdolecek if (error)
537 1.1 bouyer panic("ext2fs_reload: dirty1");
538 1.1 bouyer /*
539 1.1 bouyer * Step 2: re-read superblock from disk.
540 1.1 bouyer */
541 1.155 mlelstv error = bread(devvp, SBLOCK, SBSIZE, NOCRED, 0, &bp);
542 1.23 bouyer if (error) {
543 1.1 bouyer return (error);
544 1.23 bouyer }
545 1.1 bouyer newfs = (struct ext2fs *)bp->b_data;
546 1.149 tsutsui error = ext2fs_checksb(newfs, (mp->mnt_flag & MNT_RDONLY) != 0);
547 1.31 bouyer if (error) {
548 1.118 ad brelse(bp, 0);
549 1.31 bouyer return (error);
550 1.1 bouyer }
551 1.1 bouyer
552 1.149 tsutsui fs = ump->um_e2fs;
553 1.83 perry /*
554 1.1 bouyer * copy in new superblock, and compute in-memory values
555 1.1 bouyer */
556 1.4 bouyer e2fs_sbload(newfs, &fs->e2fs);
557 1.23 bouyer fs->e2fs_ncg =
558 1.23 bouyer howmany(fs->e2fs.e2fs_bcount - fs->e2fs.e2fs_first_dblock,
559 1.23 bouyer fs->e2fs.e2fs_bpg);
560 1.155 mlelstv fs->e2fs_fsbtodb = fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT;
561 1.122 tsutsui fs->e2fs_bsize = MINBSIZE << fs->e2fs.e2fs_log_bsize;
562 1.1 bouyer fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;
563 1.1 bouyer fs->e2fs_qbmask = fs->e2fs_bsize - 1;
564 1.1 bouyer fs->e2fs_bmask = ~fs->e2fs_qbmask;
565 1.122 tsutsui fs->e2fs_ngdb =
566 1.122 tsutsui howmany(fs->e2fs_ncg, fs->e2fs_bsize / sizeof(struct ext2_gd));
567 1.142 christos fs->e2fs_ipb = fs->e2fs_bsize / EXT2_DINODE_SIZE(fs);
568 1.122 tsutsui fs->e2fs_itpg = fs->e2fs.e2fs_ipg / fs->e2fs_ipb;
569 1.148 tsutsui brelse(bp, 0);
570 1.1 bouyer
571 1.1 bouyer /*
572 1.1 bouyer * Step 3: re-read summary information from disk.
573 1.1 bouyer */
574 1.1 bouyer
575 1.122 tsutsui for (i = 0; i < fs->e2fs_ngdb; i++) {
576 1.23 bouyer error = bread(devvp ,
577 1.171 dholland EXT2_FSBTODB(fs, fs->e2fs.e2fs_first_dblock +
578 1.124 tsutsui 1 /* superblock */ + i),
579 1.136 hannken fs->e2fs_bsize, NOCRED, 0, &bp);
580 1.23 bouyer if (error) {
581 1.1 bouyer return (error);
582 1.23 bouyer }
583 1.122 tsutsui e2fs_cgload((struct ext2_gd *)bp->b_data,
584 1.122 tsutsui &fs->e2fs_gd[i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
585 1.23 bouyer fs->e2fs_bsize);
586 1.118 ad brelse(bp, 0);
587 1.1 bouyer }
588 1.83 perry
589 1.177 hannken vfs_vnode_iterator_init(mp, &marker);
590 1.177 hannken while (vfs_vnode_iterator_next(marker, &vp)) {
591 1.1 bouyer /*
592 1.1 bouyer * Step 4: invalidate all inactive vnodes.
593 1.1 bouyer */
594 1.177 hannken if (vrecycle(vp))
595 1.177 hannken continue;
596 1.1 bouyer /*
597 1.1 bouyer * Step 5: invalidate all cached file data.
598 1.1 bouyer */
599 1.177 hannken if (vn_lock(vp, LK_EXCLUSIVE)) {
600 1.177 hannken vrele(vp);
601 1.177 hannken continue;
602 1.126 ad }
603 1.94 christos if (vinvalbuf(vp, 0, cred, l, 0, 0))
604 1.1 bouyer panic("ext2fs_reload: dirty2");
605 1.1 bouyer /*
606 1.1 bouyer * Step 6: re-read inode data for all active vnodes.
607 1.1 bouyer */
608 1.1 bouyer ip = VTOI(vp);
609 1.171 dholland error = bread(devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ip->i_number)),
610 1.136 hannken (int)fs->e2fs_bsize, NOCRED, 0, &bp);
611 1.1 bouyer if (error) {
612 1.1 bouyer vput(vp);
613 1.126 ad break;
614 1.1 bouyer }
615 1.109 christos cp = (char *)bp->b_data +
616 1.142 christos (ino_to_fsbo(fs, ip->i_number) * EXT2_DINODE_SIZE(fs));
617 1.55 fvdl e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din);
618 1.140 mrg ext2fs_set_inode_guid(ip);
619 1.118 ad brelse(bp, 0);
620 1.1 bouyer vput(vp);
621 1.1 bouyer }
622 1.177 hannken vfs_vnode_iterator_destroy(marker);
623 1.126 ad return (error);
624 1.1 bouyer }
625 1.1 bouyer
626 1.1 bouyer /*
627 1.1 bouyer * Common code for mount and mountroot
628 1.1 bouyer */
629 1.1 bouyer int
630 1.123 pooka ext2fs_mountfs(struct vnode *devvp, struct mount *mp)
631 1.1 bouyer {
632 1.123 pooka struct lwp *l = curlwp;
633 1.35 augustss struct ufsmount *ump;
634 1.1 bouyer struct buf *bp;
635 1.35 augustss struct ext2fs *fs;
636 1.35 augustss struct m_ext2fs *m_fs;
637 1.1 bouyer dev_t dev;
638 1.154 mlelstv int error, i, ronly;
639 1.97 elad kauth_cred_t cred;
640 1.1 bouyer
641 1.1 bouyer dev = devvp->v_rdev;
642 1.100 ad cred = l ? l->l_cred : NOCRED;
643 1.80 mycroft
644 1.80 mycroft /* Flush out any old buffers remaining from a previous use. */
645 1.38 jdolecek vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
646 1.94 christos error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
647 1.157 hannken VOP_UNLOCK(devvp);
648 1.38 jdolecek if (error)
649 1.1 bouyer return (error);
650 1.1 bouyer
651 1.1 bouyer ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
652 1.1 bouyer
653 1.1 bouyer bp = NULL;
654 1.1 bouyer ump = NULL;
655 1.1 bouyer
656 1.1 bouyer #ifdef DEBUG_EXT2
657 1.159 jakllsch printf("ext2 sb size: %zu\n", sizeof(struct ext2fs));
658 1.1 bouyer #endif
659 1.155 mlelstv error = bread(devvp, SBLOCK, SBSIZE, cred, 0, &bp);
660 1.1 bouyer if (error)
661 1.1 bouyer goto out;
662 1.1 bouyer fs = (struct ext2fs *)bp->b_data;
663 1.31 bouyer error = ext2fs_checksb(fs, ronly);
664 1.31 bouyer if (error)
665 1.1 bouyer goto out;
666 1.164 rmind ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
667 1.55 fvdl ump->um_fstype = UFS1;
668 1.92 yamt ump->um_ops = &ext2fs_ufsops;
669 1.164 rmind ump->um_e2fs = kmem_zalloc(sizeof(struct m_ext2fs), KM_SLEEP);
670 1.122 tsutsui e2fs_sbload((struct ext2fs *)bp->b_data, &ump->um_e2fs->e2fs);
671 1.118 ad brelse(bp, 0);
672 1.1 bouyer bp = NULL;
673 1.1 bouyer m_fs = ump->um_e2fs;
674 1.1 bouyer m_fs->e2fs_ronly = ronly;
675 1.142 christos
676 1.142 christos #ifdef DEBUG_EXT2
677 1.159 jakllsch printf("ext2 ino size %zu\n", EXT2_DINODE_SIZE(m_fs));
678 1.142 christos #endif
679 1.1 bouyer if (ronly == 0) {
680 1.1 bouyer if (m_fs->e2fs.e2fs_state == E2FS_ISCLEAN)
681 1.1 bouyer m_fs->e2fs.e2fs_state = 0;
682 1.1 bouyer else
683 1.1 bouyer m_fs->e2fs.e2fs_state = E2FS_ERRORS;
684 1.1 bouyer m_fs->e2fs_fmod = 1;
685 1.1 bouyer }
686 1.1 bouyer
687 1.1 bouyer /* compute dynamic sb infos */
688 1.1 bouyer m_fs->e2fs_ncg =
689 1.122 tsutsui howmany(m_fs->e2fs.e2fs_bcount - m_fs->e2fs.e2fs_first_dblock,
690 1.122 tsutsui m_fs->e2fs.e2fs_bpg);
691 1.155 mlelstv m_fs->e2fs_fsbtodb = m_fs->e2fs.e2fs_log_bsize + LOG_MINBSIZE - DEV_BSHIFT;
692 1.122 tsutsui m_fs->e2fs_bsize = MINBSIZE << m_fs->e2fs.e2fs_log_bsize;
693 1.1 bouyer m_fs->e2fs_bshift = LOG_MINBSIZE + m_fs->e2fs.e2fs_log_bsize;
694 1.1 bouyer m_fs->e2fs_qbmask = m_fs->e2fs_bsize - 1;
695 1.1 bouyer m_fs->e2fs_bmask = ~m_fs->e2fs_qbmask;
696 1.122 tsutsui m_fs->e2fs_ngdb =
697 1.122 tsutsui howmany(m_fs->e2fs_ncg, m_fs->e2fs_bsize / sizeof(struct ext2_gd));
698 1.142 christos m_fs->e2fs_ipb = m_fs->e2fs_bsize / EXT2_DINODE_SIZE(m_fs);
699 1.122 tsutsui m_fs->e2fs_itpg = m_fs->e2fs.e2fs_ipg / m_fs->e2fs_ipb;
700 1.1 bouyer
701 1.164 rmind m_fs->e2fs_gd = kmem_alloc(m_fs->e2fs_ngdb * m_fs->e2fs_bsize, KM_SLEEP);
702 1.122 tsutsui for (i = 0; i < m_fs->e2fs_ngdb; i++) {
703 1.23 bouyer error = bread(devvp ,
704 1.171 dholland EXT2_FSBTODB(m_fs, m_fs->e2fs.e2fs_first_dblock +
705 1.124 tsutsui 1 /* superblock */ + i),
706 1.136 hannken m_fs->e2fs_bsize, NOCRED, 0, &bp);
707 1.1 bouyer if (error) {
708 1.164 rmind kmem_free(m_fs->e2fs_gd,
709 1.164 rmind m_fs->e2fs_ngdb * m_fs->e2fs_bsize);
710 1.1 bouyer goto out;
711 1.1 bouyer }
712 1.122 tsutsui e2fs_cgload((struct ext2_gd *)bp->b_data,
713 1.23 bouyer &m_fs->e2fs_gd[
714 1.23 bouyer i * m_fs->e2fs_bsize / sizeof(struct ext2_gd)],
715 1.23 bouyer m_fs->e2fs_bsize);
716 1.118 ad brelse(bp, 0);
717 1.1 bouyer bp = NULL;
718 1.1 bouyer }
719 1.1 bouyer
720 1.50 soren mp->mnt_data = ump;
721 1.67 christos mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
722 1.67 christos mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_EXT2FS);
723 1.67 christos mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
724 1.88 christos mp->mnt_stat.f_namemax = EXT2FS_MAXNAMLEN;
725 1.1 bouyer mp->mnt_flag |= MNT_LOCAL;
726 1.40 chs mp->mnt_dev_bshift = DEV_BSHIFT; /* XXX */
727 1.40 chs mp->mnt_fs_bshift = m_fs->e2fs_bshift;
728 1.75 mycroft mp->mnt_iflag |= IMNT_DTYPE;
729 1.11 bouyer ump->um_flags = 0;
730 1.1 bouyer ump->um_mountp = mp;
731 1.1 bouyer ump->um_dev = dev;
732 1.1 bouyer ump->um_devvp = devvp;
733 1.170 dholland ump->um_nindir = EXT2_NINDIR(m_fs);
734 1.170 dholland ump->um_lognindir = ffs(EXT2_NINDIR(m_fs)) - 1;
735 1.1 bouyer ump->um_bptrtodb = m_fs->e2fs_fsbtodb;
736 1.1 bouyer ump->um_seqinc = 1; /* no frags */
737 1.75 mycroft ump->um_maxsymlinklen = EXT2_MAXSYMLINKLEN;
738 1.75 mycroft ump->um_dirblksiz = m_fs->e2fs_bsize;
739 1.122 tsutsui ump->um_maxfilesize = ((uint64_t)0x80000000 * m_fs->e2fs_bsize - 1);
740 1.173 hannken spec_node_setmountedfs(devvp, mp);
741 1.1 bouyer return (0);
742 1.40 chs
743 1.1 bouyer out:
744 1.168 hannken if (bp != NULL)
745 1.168 hannken brelse(bp, 0);
746 1.1 bouyer if (ump) {
747 1.164 rmind kmem_free(ump->um_e2fs, sizeof(struct m_ext2fs));
748 1.164 rmind kmem_free(ump, sizeof(*ump));
749 1.50 soren mp->mnt_data = NULL;
750 1.1 bouyer }
751 1.1 bouyer return (error);
752 1.1 bouyer }
753 1.1 bouyer
754 1.1 bouyer /*
755 1.1 bouyer * unmount system call
756 1.1 bouyer */
757 1.1 bouyer int
758 1.123 pooka ext2fs_unmount(struct mount *mp, int mntflags)
759 1.1 bouyer {
760 1.35 augustss struct ufsmount *ump;
761 1.35 augustss struct m_ext2fs *fs;
762 1.1 bouyer int error, flags;
763 1.1 bouyer
764 1.1 bouyer flags = 0;
765 1.1 bouyer if (mntflags & MNT_FORCE)
766 1.1 bouyer flags |= FORCECLOSE;
767 1.123 pooka if ((error = ext2fs_flushfiles(mp, flags)) != 0)
768 1.1 bouyer return (error);
769 1.1 bouyer ump = VFSTOUFS(mp);
770 1.1 bouyer fs = ump->um_e2fs;
771 1.1 bouyer if (fs->e2fs_ronly == 0 &&
772 1.1 bouyer ext2fs_cgupdate(ump, MNT_WAIT) == 0 &&
773 1.1 bouyer (fs->e2fs.e2fs_state & E2FS_ERRORS) == 0) {
774 1.1 bouyer fs->e2fs.e2fs_state = E2FS_ISCLEAN;
775 1.1 bouyer (void) ext2fs_sbupdate(ump, MNT_WAIT);
776 1.1 bouyer }
777 1.29 enami if (ump->um_devvp->v_type != VBAD)
778 1.173 hannken spec_node_setmountedfs(ump->um_devvp, NULL);
779 1.28 wrstuden vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
780 1.1 bouyer error = VOP_CLOSE(ump->um_devvp, fs->e2fs_ronly ? FREAD : FREAD|FWRITE,
781 1.123 pooka NOCRED);
782 1.28 wrstuden vput(ump->um_devvp);
783 1.164 rmind kmem_free(fs->e2fs_gd, fs->e2fs_ngdb * fs->e2fs_bsize);
784 1.164 rmind kmem_free(fs, sizeof(*fs));
785 1.164 rmind kmem_free(ump, sizeof(*ump));
786 1.50 soren mp->mnt_data = NULL;
787 1.1 bouyer mp->mnt_flag &= ~MNT_LOCAL;
788 1.1 bouyer return (error);
789 1.1 bouyer }
790 1.1 bouyer
791 1.1 bouyer /*
792 1.1 bouyer * Flush out all the files in a filesystem.
793 1.1 bouyer */
794 1.1 bouyer int
795 1.123 pooka ext2fs_flushfiles(struct mount *mp, int flags)
796 1.1 bouyer {
797 1.1 bouyer extern int doforce;
798 1.1 bouyer int error;
799 1.1 bouyer
800 1.1 bouyer if (!doforce)
801 1.1 bouyer flags &= ~FORCECLOSE;
802 1.1 bouyer error = vflush(mp, NULLVP, flags);
803 1.1 bouyer return (error);
804 1.1 bouyer }
805 1.1 bouyer
806 1.1 bouyer /*
807 1.1 bouyer * Get file system statistics.
808 1.1 bouyer */
809 1.1 bouyer int
810 1.123 pooka ext2fs_statvfs(struct mount *mp, struct statvfs *sbp)
811 1.1 bouyer {
812 1.35 augustss struct ufsmount *ump;
813 1.35 augustss struct m_ext2fs *fs;
814 1.122 tsutsui uint32_t overhead, overhead_per_group, ngdb;
815 1.32 bouyer int i, ngroups;
816 1.1 bouyer
817 1.1 bouyer ump = VFSTOUFS(mp);
818 1.1 bouyer fs = ump->um_e2fs;
819 1.1 bouyer if (fs->e2fs.e2fs_magic != E2FS_MAGIC)
820 1.67 christos panic("ext2fs_statvfs");
821 1.1 bouyer
822 1.1 bouyer /*
823 1.1 bouyer * Compute the overhead (FS structures)
824 1.1 bouyer */
825 1.122 tsutsui overhead_per_group =
826 1.122 tsutsui 1 /* block bitmap */ +
827 1.122 tsutsui 1 /* inode bitmap */ +
828 1.122 tsutsui fs->e2fs_itpg;
829 1.1 bouyer overhead = fs->e2fs.e2fs_first_dblock +
830 1.122 tsutsui fs->e2fs_ncg * overhead_per_group;
831 1.32 bouyer if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
832 1.32 bouyer fs->e2fs.e2fs_features_rocompat & EXT2F_ROCOMPAT_SPARSESUPER) {
833 1.32 bouyer for (i = 0, ngroups = 0; i < fs->e2fs_ncg; i++) {
834 1.32 bouyer if (cg_has_sb(i))
835 1.32 bouyer ngroups++;
836 1.32 bouyer }
837 1.32 bouyer } else {
838 1.32 bouyer ngroups = fs->e2fs_ncg;
839 1.32 bouyer }
840 1.121 tsutsui ngdb = fs->e2fs_ngdb;
841 1.121 tsutsui if (fs->e2fs.e2fs_rev > E2FS_REV0 &&
842 1.121 tsutsui fs->e2fs.e2fs_features_compat & EXT2F_COMPAT_RESIZE)
843 1.121 tsutsui ngdb += fs->e2fs.e2fs_reserved_ngdb;
844 1.122 tsutsui overhead += ngroups * (1 /* superblock */ + ngdb);
845 1.1 bouyer
846 1.1 bouyer sbp->f_bsize = fs->e2fs_bsize;
847 1.122 tsutsui sbp->f_frsize = MINBSIZE << fs->e2fs.e2fs_fsize;
848 1.1 bouyer sbp->f_iosize = fs->e2fs_bsize;
849 1.1 bouyer sbp->f_blocks = fs->e2fs.e2fs_bcount - overhead;
850 1.1 bouyer sbp->f_bfree = fs->e2fs.e2fs_fbcount;
851 1.67 christos sbp->f_bresvd = fs->e2fs.e2fs_rbcount;
852 1.67 christos if (sbp->f_bfree > sbp->f_bresvd)
853 1.67 christos sbp->f_bavail = sbp->f_bfree - sbp->f_bresvd;
854 1.67 christos else
855 1.67 christos sbp->f_bavail = 0;
856 1.1 bouyer sbp->f_files = fs->e2fs.e2fs_icount;
857 1.1 bouyer sbp->f_ffree = fs->e2fs.e2fs_ficount;
858 1.67 christos sbp->f_favail = fs->e2fs.e2fs_ficount;
859 1.67 christos sbp->f_fresvd = 0;
860 1.67 christos copy_statvfs_info(sbp, mp);
861 1.1 bouyer return (0);
862 1.1 bouyer }
863 1.1 bouyer
864 1.1 bouyer /*
865 1.1 bouyer * Go through the disk queues to initiate sandbagged IO;
866 1.1 bouyer * go through the inodes to write those that have been modified;
867 1.1 bouyer * initiate the writing of the super block if it has been modified.
868 1.1 bouyer *
869 1.1 bouyer * Note: we are always called with the filesystem marked `MPBUSY'.
870 1.1 bouyer */
871 1.1 bouyer int
872 1.123 pooka ext2fs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
873 1.1 bouyer {
874 1.178 hannken struct vnode *vp;
875 1.9 fvdl struct inode *ip;
876 1.9 fvdl struct ufsmount *ump = VFSTOUFS(mp);
877 1.9 fvdl struct m_ext2fs *fs;
878 1.178 hannken struct vnode_iterator *marker;
879 1.1 bouyer int error, allerror = 0;
880 1.1 bouyer
881 1.1 bouyer fs = ump->um_e2fs;
882 1.36 mycroft if (fs->e2fs_fmod != 0 && fs->e2fs_ronly != 0) { /* XXX */
883 1.9 fvdl printf("fs = %s\n", fs->e2fs_fsmnt);
884 1.9 fvdl panic("update: rofs mod");
885 1.1 bouyer }
886 1.126 ad
887 1.1 bouyer /*
888 1.1 bouyer * Write back each (modified) inode.
889 1.1 bouyer */
890 1.178 hannken vfs_vnode_iterator_init(mp, &marker);
891 1.178 hannken while (vfs_vnode_iterator_next(marker, &vp)) {
892 1.178 hannken error = vn_lock(vp, LK_EXCLUSIVE);
893 1.178 hannken if (error) {
894 1.178 hannken vrele(vp);
895 1.126 ad continue;
896 1.178 hannken }
897 1.1 bouyer ip = VTOI(vp);
898 1.178 hannken /*
899 1.178 hannken * Skip the vnode/inode if inaccessible.
900 1.178 hannken */
901 1.178 hannken if (ip == NULL || vp->v_type == VNON) {
902 1.178 hannken vput(vp);
903 1.178 hannken continue;
904 1.178 hannken }
905 1.178 hannken
906 1.178 hannken if (((ip->i_flag &
907 1.74 mycroft (IN_CHANGE | IN_UPDATE | IN_MODIFIED)) == 0 &&
908 1.41 chs LIST_EMPTY(&vp->v_dirtyblkhd) &&
909 1.178 hannken UVM_OBJ_IS_CLEAN(&vp->v_uobj))) {
910 1.178 hannken vput(vp);
911 1.21 bouyer continue;
912 1.9 fvdl }
913 1.74 mycroft if (vp->v_type == VREG && waitfor == MNT_LAZY)
914 1.93 yamt error = ext2fs_update(vp, NULL, NULL, 0);
915 1.74 mycroft else
916 1.74 mycroft error = VOP_FSYNC(vp, cred,
917 1.123 pooka waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0);
918 1.74 mycroft if (error)
919 1.1 bouyer allerror = error;
920 1.22 bouyer vput(vp);
921 1.1 bouyer }
922 1.178 hannken vfs_vnode_iterator_destroy(marker);
923 1.1 bouyer /*
924 1.1 bouyer * Force stale file system control information to be flushed.
925 1.1 bouyer */
926 1.36 mycroft if (waitfor != MNT_LAZY) {
927 1.36 mycroft vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
928 1.36 mycroft if ((error = VOP_FSYNC(ump->um_devvp, cred,
929 1.123 pooka waitfor == MNT_WAIT ? FSYNC_WAIT : 0, 0, 0)) != 0)
930 1.36 mycroft allerror = error;
931 1.157 hannken VOP_UNLOCK(ump->um_devvp);
932 1.36 mycroft }
933 1.9 fvdl /*
934 1.9 fvdl * Write back modified superblock.
935 1.9 fvdl */
936 1.9 fvdl if (fs->e2fs_fmod != 0) {
937 1.9 fvdl fs->e2fs_fmod = 0;
938 1.98 kardel fs->e2fs.e2fs_wtime = time_second;
939 1.9 fvdl if ((error = ext2fs_cgupdate(ump, waitfor)))
940 1.9 fvdl allerror = error;
941 1.9 fvdl }
942 1.1 bouyer return (allerror);
943 1.1 bouyer }
944 1.1 bouyer
945 1.1 bouyer /*
946 1.1 bouyer * Look up a EXT2FS dinode number to find its incore vnode, otherwise read it
947 1.1 bouyer * in from disk. If it is in core, wait for the lock bit to clear, then
948 1.1 bouyer * return the inode locked. Detection and handling of mount points must be
949 1.1 bouyer * done by the calling routine.
950 1.1 bouyer */
951 1.1 bouyer int
952 1.89 xtraeme ext2fs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
953 1.1 bouyer {
954 1.9 fvdl struct m_ext2fs *fs;
955 1.9 fvdl struct inode *ip;
956 1.1 bouyer struct ufsmount *ump;
957 1.1 bouyer struct buf *bp;
958 1.1 bouyer struct vnode *vp;
959 1.1 bouyer dev_t dev;
960 1.1 bouyer int error;
961 1.109 christos void *cp;
962 1.1 bouyer
963 1.1 bouyer ump = VFSTOUFS(mp);
964 1.1 bouyer dev = ump->um_dev;
965 1.120 ad retry:
966 1.59 thorpej if ((*vpp = ufs_ihashget(dev, ino, LK_EXCLUSIVE)) != NULL)
967 1.37 fvdl return (0);
968 1.1 bouyer
969 1.1 bouyer /* Allocate a new vnode/inode. */
970 1.160 rmind error = getnewvnode(VT_EXT2FS, mp, ext2fs_vnodeop_p, NULL, &vp);
971 1.160 rmind if (error) {
972 1.1 bouyer *vpp = NULL;
973 1.1 bouyer return (error);
974 1.1 bouyer }
975 1.108 ad ip = pool_get(&ext2fs_inode_pool, PR_WAITOK);
976 1.37 fvdl
977 1.108 ad mutex_enter(&ufs_hashlock);
978 1.120 ad if ((*vpp = ufs_ihashget(dev, ino, 0)) != NULL) {
979 1.108 ad mutex_exit(&ufs_hashlock);
980 1.108 ad ungetnewvnode(vp);
981 1.108 ad pool_put(&ext2fs_inode_pool, ip);
982 1.120 ad goto retry;
983 1.108 ad }
984 1.37 fvdl
985 1.119 ad vp->v_vflag |= VV_LOCKSWORK;
986 1.76 thorpej
987 1.45 chs memset(ip, 0, sizeof(struct inode));
988 1.1 bouyer vp->v_data = ip;
989 1.1 bouyer ip->i_vnode = vp;
990 1.55 fvdl ip->i_ump = ump;
991 1.1 bouyer ip->i_e2fs = fs = ump->um_e2fs;
992 1.1 bouyer ip->i_dev = dev;
993 1.1 bouyer ip->i_number = ino;
994 1.1 bouyer ip->i_e2fs_last_lblk = 0;
995 1.1 bouyer ip->i_e2fs_last_blk = 0;
996 1.131 ad genfs_node_init(vp, &ext2fs_genfsops);
997 1.1 bouyer
998 1.1 bouyer /*
999 1.1 bouyer * Put it onto its hash chain and lock it so that other requests for
1000 1.1 bouyer * this inode will block if they arrive while we are sleeping waiting
1001 1.1 bouyer * for old data structures to be purged or for the contents of the
1002 1.1 bouyer * disk portion of this inode to be read.
1003 1.1 bouyer */
1004 1.45 chs
1005 1.1 bouyer ufs_ihashins(ip);
1006 1.108 ad mutex_exit(&ufs_hashlock);
1007 1.1 bouyer
1008 1.1 bouyer /* Read in the disk contents for the inode, copy into the inode. */
1009 1.171 dholland error = bread(ump->um_devvp, EXT2_FSBTODB(fs, ino_to_fsba(fs, ino)),
1010 1.136 hannken (int)fs->e2fs_bsize, NOCRED, 0, &bp);
1011 1.1 bouyer if (error) {
1012 1.45 chs
1013 1.1 bouyer /*
1014 1.1 bouyer * The inode does not contain anything useful, so it would
1015 1.1 bouyer * be misleading to leave it on its hash chain. With mode
1016 1.1 bouyer * still zero, it will be unlinked and returned to the free
1017 1.1 bouyer * list by vput().
1018 1.1 bouyer */
1019 1.45 chs
1020 1.1 bouyer vput(vp);
1021 1.1 bouyer *vpp = NULL;
1022 1.1 bouyer return (error);
1023 1.1 bouyer }
1024 1.142 christos cp = (char *)bp->b_data + (ino_to_fsbo(fs, ino) * EXT2_DINODE_SIZE(fs));
1025 1.56 fvdl ip->i_din.e2fs_din = pool_get(&ext2fs_dinode_pool, PR_WAITOK);
1026 1.55 fvdl e2fs_iload((struct ext2fs_dinode *)cp, ip->i_din.e2fs_din);
1027 1.140 mrg ext2fs_set_inode_guid(ip);
1028 1.118 ad brelse(bp, 0);
1029 1.1 bouyer
1030 1.5 bouyer /* If the inode was deleted, reset all fields */
1031 1.5 bouyer if (ip->i_e2fs_dtime != 0) {
1032 1.167 jakllsch ip->i_e2fs_mode = 0;
1033 1.82 ws (void)ext2fs_setsize(ip, 0);
1034 1.167 jakllsch (void)ext2fs_setnblock(ip, 0);
1035 1.16 perry memset(ip->i_e2fs_blocks, 0, sizeof(ip->i_e2fs_blocks));
1036 1.5 bouyer }
1037 1.5 bouyer
1038 1.1 bouyer /*
1039 1.1 bouyer * Initialize the vnode from the inode, check for aliases.
1040 1.1 bouyer */
1041 1.45 chs
1042 1.14 sommerfe error = ext2fs_vinit(mp, ext2fs_specop_p, ext2fs_fifoop_p, &vp);
1043 1.1 bouyer if (error) {
1044 1.1 bouyer vput(vp);
1045 1.1 bouyer *vpp = NULL;
1046 1.1 bouyer return (error);
1047 1.1 bouyer }
1048 1.1 bouyer /*
1049 1.1 bouyer * Finish inode initialization now that aliasing has been resolved.
1050 1.1 bouyer */
1051 1.45 chs
1052 1.1 bouyer ip->i_devvp = ump->um_devvp;
1053 1.153 pooka vref(ip->i_devvp);
1054 1.45 chs
1055 1.1 bouyer /*
1056 1.1 bouyer * Set up a generation number for this inode if it does not
1057 1.1 bouyer * already have one. This should only happen on old filesystems.
1058 1.1 bouyer */
1059 1.45 chs
1060 1.1 bouyer if (ip->i_e2fs_gen == 0) {
1061 1.98 kardel if (++ext2gennumber < (u_long)time_second)
1062 1.98 kardel ext2gennumber = time_second;
1063 1.1 bouyer ip->i_e2fs_gen = ext2gennumber;
1064 1.1 bouyer if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
1065 1.1 bouyer ip->i_flag |= IN_MODIFIED;
1066 1.1 bouyer }
1067 1.111 yamt uvm_vnp_setsize(vp, ext2fs_size(ip));
1068 1.1 bouyer *vpp = vp;
1069 1.1 bouyer return (0);
1070 1.1 bouyer }
1071 1.1 bouyer
1072 1.1 bouyer /*
1073 1.1 bouyer * File handle to vnode
1074 1.1 bouyer *
1075 1.1 bouyer * Have to be really careful about stale file handles:
1076 1.1 bouyer * - check that the inode number is valid
1077 1.1 bouyer * - call ext2fs_vget() to get the locked inode
1078 1.1 bouyer * - check for an unallocated inode (i_mode == 0)
1079 1.1 bouyer */
1080 1.1 bouyer int
1081 1.89 xtraeme ext2fs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
1082 1.1 bouyer {
1083 1.35 augustss struct inode *ip;
1084 1.24 wrstuden struct vnode *nvp;
1085 1.24 wrstuden int error;
1086 1.99 martin struct ufid ufh;
1087 1.1 bouyer struct m_ext2fs *fs;
1088 1.1 bouyer
1089 1.99 martin if (fhp->fid_len != sizeof(struct ufid))
1090 1.99 martin return EINVAL;
1091 1.99 martin
1092 1.99 martin memcpy(&ufh, fhp, sizeof(struct ufid));
1093 1.1 bouyer fs = VFSTOUFS(mp)->um_e2fs;
1094 1.99 martin if ((ufh.ufid_ino < EXT2_FIRSTINO && ufh.ufid_ino != EXT2_ROOTINO) ||
1095 1.99 martin ufh.ufid_ino >= fs->e2fs_ncg * fs->e2fs.e2fs_ipg)
1096 1.1 bouyer return (ESTALE);
1097 1.24 wrstuden
1098 1.99 martin if ((error = VFS_VGET(mp, ufh.ufid_ino, &nvp)) != 0) {
1099 1.24 wrstuden *vpp = NULLVP;
1100 1.24 wrstuden return (error);
1101 1.24 wrstuden }
1102 1.24 wrstuden ip = VTOI(nvp);
1103 1.83 perry if (ip->i_e2fs_mode == 0 || ip->i_e2fs_dtime != 0 ||
1104 1.99 martin ip->i_e2fs_gen != ufh.ufid_gen) {
1105 1.24 wrstuden vput(nvp);
1106 1.24 wrstuden *vpp = NULLVP;
1107 1.24 wrstuden return (ESTALE);
1108 1.24 wrstuden }
1109 1.24 wrstuden *vpp = nvp;
1110 1.24 wrstuden return (0);
1111 1.1 bouyer }
1112 1.1 bouyer
1113 1.1 bouyer /*
1114 1.1 bouyer * Vnode pointer to File handle
1115 1.1 bouyer */
1116 1.1 bouyer /* ARGSUSED */
1117 1.1 bouyer int
1118 1.99 martin ext2fs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
1119 1.1 bouyer {
1120 1.35 augustss struct inode *ip;
1121 1.99 martin struct ufid ufh;
1122 1.99 martin
1123 1.99 martin if (*fh_size < sizeof(struct ufid)) {
1124 1.99 martin *fh_size = sizeof(struct ufid);
1125 1.99 martin return E2BIG;
1126 1.99 martin }
1127 1.99 martin *fh_size = sizeof(struct ufid);
1128 1.1 bouyer
1129 1.1 bouyer ip = VTOI(vp);
1130 1.99 martin memset(&ufh, 0, sizeof(ufh));
1131 1.99 martin ufh.ufid_len = sizeof(struct ufid);
1132 1.99 martin ufh.ufid_ino = ip->i_number;
1133 1.99 martin ufh.ufid_gen = ip->i_e2fs_gen;
1134 1.99 martin memcpy(fhp, &ufh, sizeof(ufh));
1135 1.1 bouyer return (0);
1136 1.9 fvdl }
1137 1.9 fvdl
1138 1.1 bouyer /*
1139 1.1 bouyer * Write a superblock and associated information back to disk.
1140 1.1 bouyer */
1141 1.1 bouyer int
1142 1.89 xtraeme ext2fs_sbupdate(struct ufsmount *mp, int waitfor)
1143 1.1 bouyer {
1144 1.35 augustss struct m_ext2fs *fs = mp->um_e2fs;
1145 1.35 augustss struct buf *bp;
1146 1.1 bouyer int error = 0;
1147 1.1 bouyer
1148 1.1 bouyer bp = getblk(mp->um_devvp, SBLOCK, SBSIZE, 0, 0);
1149 1.4 bouyer e2fs_sbsave(&fs->e2fs, (struct ext2fs*)bp->b_data);
1150 1.1 bouyer if (waitfor == MNT_WAIT)
1151 1.1 bouyer error = bwrite(bp);
1152 1.1 bouyer else
1153 1.1 bouyer bawrite(bp);
1154 1.1 bouyer return (error);
1155 1.1 bouyer }
1156 1.1 bouyer
1157 1.1 bouyer int
1158 1.89 xtraeme ext2fs_cgupdate(struct ufsmount *mp, int waitfor)
1159 1.1 bouyer {
1160 1.35 augustss struct m_ext2fs *fs = mp->um_e2fs;
1161 1.35 augustss struct buf *bp;
1162 1.1 bouyer int i, error = 0, allerror = 0;
1163 1.1 bouyer
1164 1.1 bouyer allerror = ext2fs_sbupdate(mp, waitfor);
1165 1.1 bouyer for (i = 0; i < fs->e2fs_ngdb; i++) {
1166 1.171 dholland bp = getblk(mp->um_devvp, EXT2_FSBTODB(fs,
1167 1.124 tsutsui fs->e2fs.e2fs_first_dblock +
1168 1.124 tsutsui 1 /* superblock */ + i), fs->e2fs_bsize, 0, 0);
1169 1.122 tsutsui e2fs_cgsave(&fs->e2fs_gd[
1170 1.122 tsutsui i * fs->e2fs_bsize / sizeof(struct ext2_gd)],
1171 1.122 tsutsui (struct ext2_gd *)bp->b_data, fs->e2fs_bsize);
1172 1.1 bouyer if (waitfor == MNT_WAIT)
1173 1.1 bouyer error = bwrite(bp);
1174 1.1 bouyer else
1175 1.1 bouyer bawrite(bp);
1176 1.1 bouyer }
1177 1.1 bouyer
1178 1.1 bouyer if (!allerror && error)
1179 1.1 bouyer allerror = error;
1180 1.1 bouyer return (allerror);
1181 1.31 bouyer }
1182 1.31 bouyer
1183 1.31 bouyer static int
1184 1.89 xtraeme ext2fs_checksb(struct ext2fs *fs, int ronly)
1185 1.31 bouyer {
1186 1.165 chs uint32_t u32;
1187 1.122 tsutsui
1188 1.31 bouyer if (fs2h16(fs->e2fs_magic) != E2FS_MAGIC) {
1189 1.80 mycroft return (EINVAL); /* XXX needs translation */
1190 1.31 bouyer }
1191 1.31 bouyer if (fs2h32(fs->e2fs_rev) > E2FS_REV1) {
1192 1.31 bouyer #ifdef DIAGNOSTIC
1193 1.165 chs printf("ext2fs: unsupported revision number: %x\n",
1194 1.122 tsutsui fs2h32(fs->e2fs_rev));
1195 1.31 bouyer #endif
1196 1.80 mycroft return (EINVAL); /* XXX needs translation */
1197 1.31 bouyer }
1198 1.31 bouyer if (fs2h32(fs->e2fs_log_bsize) > 2) { /* block size = 1024|2048|4096 */
1199 1.31 bouyer #ifdef DIAGNOSTIC
1200 1.165 chs printf("ext2fs: bad block size: %d "
1201 1.122 tsutsui "(expected <= 2 for ext2 fs)\n",
1202 1.122 tsutsui fs2h32(fs->e2fs_log_bsize));
1203 1.31 bouyer #endif
1204 1.80 mycroft return (EINVAL); /* XXX needs translation */
1205 1.31 bouyer }
1206 1.31 bouyer if (fs2h32(fs->e2fs_rev) > E2FS_REV0) {
1207 1.166 christos char buf[256];
1208 1.142 christos if (fs2h32(fs->e2fs_first_ino) != EXT2_FIRSTINO) {
1209 1.165 chs printf("ext2fs: unsupported first inode position\n");
1210 1.33 bouyer return (EINVAL); /* XXX needs translation */
1211 1.33 bouyer }
1212 1.165 chs u32 = fs2h32(fs->e2fs_features_incompat) & ~EXT2F_INCOMPAT_SUPP;
1213 1.165 chs if (u32) {
1214 1.166 christos snprintb(buf, sizeof(buf), EXT2F_INCOMPAT_BITS, u32);
1215 1.166 christos printf("ext2fs: unsupported incompat features: %s\n",
1216 1.166 christos buf);
1217 1.166 christos return EINVAL; /* XXX needs translation */
1218 1.31 bouyer }
1219 1.165 chs u32 = fs2h32(fs->e2fs_features_rocompat) & ~EXT2F_ROCOMPAT_SUPP;
1220 1.165 chs if (!ronly && u32) {
1221 1.166 christos snprintb(buf, sizeof(buf), EXT2F_ROCOMPAT_BITS, u32);
1222 1.166 christos printf("ext2fs: unsupported ro-incompat features: %s\n",
1223 1.166 christos buf);
1224 1.166 christos return EROFS; /* XXX needs translation */
1225 1.31 bouyer }
1226 1.31 bouyer }
1227 1.31 bouyer return (0);
1228 1.1 bouyer }
1229