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