X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=libxfs%2Finit.c;h=537b73bd96de971094887d5499825cca4494182d;hb=4e5fe12368f9d8670d9516ab8e02827980775e5c;hp=212cb1eff50e14cd553a3e2905fa52ebfcfb6749;hpb=cb5b3ef418024ed0ba6485c4eb6b5108c0480c0a;p=thirdparty%2Fxfsprogs-dev.git diff --git a/libxfs/init.c b/libxfs/init.c index 212cb1eff..537b73bd9 100644 --- a/libxfs/init.c +++ b/libxfs/init.c @@ -1,43 +1,41 @@ +// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2000-2005 Silicon Graphics, Inc. * All Rights Reserved. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it would be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include #include #include "init.h" -#define findrawpath(x) x -#define findblockpath(x) x +#include "libxfs_priv.h" +#include "xfs_fs.h" +#include "xfs_shared.h" +#include "xfs_format.h" +#include "xfs_log_format.h" +#include "xfs_trans_resv.h" +#include "xfs_mount.h" +#include "xfs_defer.h" +#include "xfs_inode_buf.h" +#include "xfs_inode_fork.h" +#include "xfs_inode.h" +#include "xfs_trans.h" +#include "xfs_rmap_btree.h" +#include "xfs_refcount_btree.h" + +#include "libxfs.h" /* for now */ char *progname = "libxfs"; /* default, changed by each tool */ -struct cache *libxfs_icache; /* global inode cache */ -int libxfs_ihash_size; /* #buckets in icache */ - struct cache *libxfs_bcache; /* global buffer cache */ int libxfs_bhash_size; /* #buckets in bcache */ -static void manage_zones(int); /* setup global zones */ +int use_xfs_buf_lock; /* global flag: use xfs_buf_t locks for MT */ /* * dev_map - map open devices to fd. */ #define MAX_DEVS 10 /* arbitary maximum */ -int nextfakedev = -1; /* device number to give to next fake device */ +static int nextfakedev = -1; /* device number to give to next fake device */ static struct dev_to_fd { dev_t dev; int fd; @@ -54,15 +52,17 @@ static struct dev_to_fd { static int check_isactive(char *name, char *block, int fatal) { - struct stat64 st; + struct stat st; - if (stat64(block, &st) < 0) + if (stat(block, &st) < 0) return 0; if ((st.st_mode & S_IFMT) != S_IFBLK) return 0; if (platform_check_ismounted(name, block, &st, 0) == 0) return 0; - return platform_check_iswritable(name, block, &st, fatal); + if (platform_check_iswritable(name, block, &st)) + return fatal ? 1 : 0; + return 0; } /* libxfs_device_to_fd: @@ -92,29 +92,42 @@ libxfs_device_open(char *path, int creat, int xflags, int setblksize) { dev_t dev; int fd, d, flags; - int readonly, excl; - struct stat64 statb; + int readonly, dio, excl; + struct stat statb; readonly = (xflags & LIBXFS_ISREADONLY); excl = (xflags & LIBXFS_EXCLUSIVELY) && !creat; + dio = (xflags & LIBXFS_DIRECT) && !creat && platform_direct_blockdev(); +retry: flags = (readonly ? O_RDONLY : O_RDWR) | \ (creat ? (O_CREAT|O_TRUNC) : 0) | \ + (dio ? O_DIRECT : 0) | \ (excl ? O_EXCL : 0); + if ((fd = open(path, flags, 0666)) < 0) { + if (errno == EINVAL && --dio == 0) + goto retry; fprintf(stderr, _("%s: cannot open %s: %s\n"), progname, path, strerror(errno)); exit(1); } - if (fstat64(fd, &statb) < 0) { + if (fstat(fd, &statb) < 0) { fprintf(stderr, _("%s: cannot stat %s: %s\n"), progname, path, strerror(errno)); exit(1); } if (!readonly && setblksize && (statb.st_mode & S_IFMT) == S_IFBLK) { - platform_set_blocksize(fd, path, 512); + if (setblksize == 1) + /* use the default blocksize */ + (void)platform_set_blocksize(fd, path, statb.st_rdev, XFS_MIN_SECTORSIZE, 0); + else { + /* given an explicit blocksize to use */ + if (platform_set_blocksize(fd, path, statb.st_rdev, setblksize, 1)) + exit(1); + } } /* @@ -175,19 +188,19 @@ check_open(char *path, int flags, char **rawfile, char **blockfile) int readonly = (flags & LIBXFS_ISREADONLY); int inactive = (flags & LIBXFS_ISINACTIVE); int dangerously = (flags & LIBXFS_DANGEROUSLY); - struct stat64 stbuf; + struct stat stbuf; - if (stat64(path, &stbuf) < 0) { + if (stat(path, &stbuf) < 0) { perror(path); return 0; } - if (!(*rawfile = findrawpath(path))) { + if (!(*rawfile = platform_findrawpath(path))) { fprintf(stderr, _("%s: " "can't find a character device matching %s\n"), progname, path); return 0; } - if (!(*blockfile = findblockpath(path))) { + if (!(*blockfile = platform_findblockpath(path))) { fprintf(stderr, _("%s: " "can't find a block device matching %s\n"), progname, path); @@ -195,13 +208,56 @@ check_open(char *path, int flags, char **rawfile, char **blockfile) } if (!readonly && !inactive && platform_check_ismounted(path, *blockfile, NULL, 1)) return 0; - + if (inactive && check_isactive(path, *blockfile, ((readonly|dangerously)?1:0))) return 0; return 1; } +/* + * Initialize/destroy all of the zone allocators we use. + */ +static void +init_zones(void) +{ + /* initialise zone allocation */ + xfs_buf_zone = kmem_zone_init(sizeof(struct xfs_buf), "xfs_buffer"); + xfs_inode_zone = kmem_zone_init(sizeof(struct xfs_inode), "xfs_inode"); + xfs_ifork_zone = kmem_zone_init(sizeof(struct xfs_ifork), "xfs_ifork"); + xfs_ili_zone = kmem_zone_init( + sizeof(struct xfs_inode_log_item),"xfs_inode_log_item"); + xfs_buf_item_zone = kmem_zone_init( + sizeof(struct xfs_buf_log_item), "xfs_buf_log_item"); + xfs_da_state_zone = kmem_zone_init( + sizeof(struct xfs_da_state), "xfs_da_state"); + xfs_btree_cur_zone = kmem_zone_init( + sizeof(struct xfs_btree_cur), "xfs_btree_cur"); + xfs_bmap_free_item_zone = kmem_zone_init( + sizeof(struct xfs_extent_free_item), + "xfs_bmap_free_item"); + xfs_trans_zone = kmem_zone_init( + sizeof(struct xfs_trans), "xfs_trans"); +} + +static int +destroy_zones(void) +{ + int leaked = 0; + + leaked += kmem_zone_destroy(xfs_buf_zone); + leaked += kmem_zone_destroy(xfs_ili_zone); + leaked += kmem_zone_destroy(xfs_inode_zone); + leaked += kmem_zone_destroy(xfs_ifork_zone); + leaked += kmem_zone_destroy(xfs_buf_item_zone); + leaked += kmem_zone_destroy(xfs_da_state_zone); + leaked += kmem_zone_destroy(xfs_btree_cur_zone); + leaked += kmem_zone_destroy(xfs_bmap_free_item_zone); + leaked += kmem_zone_destroy(xfs_trans_zone); + + return leaked; +} + /* * libxfs initialization. * Caller gets a 0 on failure (and we print a message), 1 on success. @@ -210,13 +266,11 @@ int libxfs_init(libxfs_init_t *a) { char *blockfile; - char curdir[MAXPATHLEN]; char *dname; char dpath[25]; int fd; char *logname; char logpath[25]; - int needcd; char *rawfile; char *rtname; char rtpath[25]; @@ -229,100 +283,28 @@ libxfs_init(libxfs_init_t *a) rtname = a->rtname; a->dfd = a->logfd = a->rtfd = -1; a->ddev = a->logdev = a->rtdev = 0; - a->dbsize = a->lbsize = a->rtbsize = 0; - a->dsize = a->logBBsize = a->logBBstart = a->rtsize = 0; + a->dsize = a->lbsize = a->rtbsize = 0; + a->dbsize = a->logBBsize = a->logBBstart = a->rtsize = 0; - (void)getcwd(curdir,MAXPATHLEN); - needcd = 0; fd = -1; - flags = a->isreadonly; + flags = (a->isreadonly | a->isdirect); + + radix_tree_init(); if (a->volname) { if(!check_open(a->volname,flags,&rawfile,&blockfile)) goto done; - needcd = 1; fd = open(rawfile, O_RDONLY); -#ifdef HAVE_VOLUME_MANAGER - xlv_getdev_t getdev; - if (ioctl(fd, DIOCGETVOLDEV, &getdev) < 0) -#else - if (1) -#endif - { - if (a->notvolok) { - dname = a->dname = a->volname; - a->volname = NULL; - goto voldone; - } - fprintf(stderr, _("%s: " - "%s is not a volume device name\n"), - progname, a->volname); - if (a->notvolmsg) - fprintf(stderr, a->notvolmsg, a->volname); - goto done; - } -#ifdef HAVE_VOLUME_MANAGER - if (getdev.data_subvol_dev && dname) { - fprintf(stderr, _("%s: " - "%s has a data subvolume, cannot specify %s\n"), - progname, a->volname, dname); - goto done; - } - if (getdev.log_subvol_dev && logname) { - fprintf(stderr, _("%s: " - "%s has a log subvolume, cannot specify %s\n"), - progname, a->volname, logname); - goto done; - } - if (getdev.rt_subvol_dev && rtname) { - fprintf(stderr, _("%s: %s has a realtime subvolume, " - "cannot specify %s\n"), - progname, a->volname, rtname); - goto done; - } - if (!dname && getdev.data_subvol_dev) { - strcpy(dpath, "/tmp/libxfsdXXXXXX"); - (void)mktemp(dpath); - if (mknod(dpath, S_IFCHR | 0600, - getdev.data_subvol_dev) < 0) { - fprintf(stderr, _("%s: mknod failed: %s\n"), - progname, strerror(errno)); - goto done; - } - dname = dpath; - } - if (!logname && getdev.log_subvol_dev) { - strcpy(logpath, "/tmp/libxfslXXXXXX"); - (void)mktemp(logpath); - if (mknod(logpath, S_IFCHR | 0600, - getdev.log_subvol_dev) < 0) { - fprintf(stderr, _("%s: mknod failed: %s\n"), - progname, strerror(errno)); - goto done; - } - logname = logpath; - } - if (!rtname && getdev.rt_subvol_dev) { - strcpy(rtpath, "/tmp/libxfsrXXXXXX"); - (void)mktemp(rtpath); - if (mknod(rtpath, S_IFCHR | 0600, - getdev.rt_subvol_dev) < 0) { - fprintf(stderr, _("%s: mknod failed: %s\n"), - progname, strerror(errno)); - goto done; - } - rtname = rtpath; - } -#endif + dname = a->dname = a->volname; + a->volname = NULL; } -voldone: if (dname) { - if (dname[0] != '/' && needcd) - chdir(curdir); if (a->disfile) { a->ddev= libxfs_device_open(dname, a->dcreat, flags, a->setblksize); a->dfd = libxfs_device_to_fd(a->ddev); + platform_findsizes(dname, a->dfd, &a->dsize, + &a->dbsize); } else { if (!check_open(dname, flags, &rawfile, &blockfile)) goto done; @@ -330,18 +312,17 @@ voldone: a->dcreat, flags, a->setblksize); a->dfd = libxfs_device_to_fd(a->ddev); platform_findsizes(rawfile, a->dfd, - &a->dsize, &a->dbsize); + &a->dsize, &a->dbsize); } - needcd = 1; } else a->dsize = 0; if (logname) { - if (logname[0] != '/' && needcd) - chdir(curdir); if (a->lisfile) { a->logdev = libxfs_device_open(logname, a->lcreat, flags, a->setblksize); a->logfd = libxfs_device_to_fd(a->logdev); + platform_findsizes(dname, a->logfd, &a->logBBsize, + &a->lbsize); } else { if (!check_open(logname, flags, &rawfile, &blockfile)) goto done; @@ -349,18 +330,17 @@ voldone: a->lcreat, flags, a->setblksize); a->logfd = libxfs_device_to_fd(a->logdev); platform_findsizes(rawfile, a->logfd, - &a->logBBsize, &a->lbsize); + &a->logBBsize, &a->lbsize); } - needcd = 1; } else a->logBBsize = 0; if (rtname) { - if (rtname[0] != '/' && needcd) - chdir(curdir); if (a->risfile) { a->rtdev = libxfs_device_open(rtname, a->rcreat, flags, a->setblksize); a->rtfd = libxfs_device_to_fd(a->rtdev); + platform_findsizes(dname, a->rtfd, &a->rtsize, + &a->rtbsize); } else { if (!check_open(rtname, flags, &rawfile, &blockfile)) goto done; @@ -368,9 +348,8 @@ voldone: a->rcreat, flags, a->setblksize); a->rtfd = libxfs_device_to_fd(a->rtdev); platform_findsizes(rawfile, a->rtfd, - &a->rtsize, &a->rtbsize); + &a->rtsize, &a->rtbsize); } - needcd = 1; } else a->rtsize = 0; if (a->dsize < 0) { @@ -388,15 +367,13 @@ voldone: progname); goto done; } - if (needcd) - chdir(curdir); - if (!libxfs_ihash_size) - libxfs_ihash_size = LIBXFS_IHASHSIZE(sbp); - libxfs_icache = cache_init(libxfs_ihash_size, &libxfs_icache_operations); if (!libxfs_bhash_size) libxfs_bhash_size = LIBXFS_BHASHSIZE(sbp); - libxfs_bcache = cache_init(libxfs_bhash_size, &libxfs_bcache_operations); - manage_zones(0); + libxfs_bcache = cache_init(a->bcache_flags, libxfs_bhash_size, + &libxfs_bcache_operations); + use_xfs_buf_lock = a->usebuflock; + xfs_dir_startup(); + init_zones(); rval = 1; done: if (dpath[0]) @@ -417,86 +394,6 @@ done: } -/* - * Initialize/destroy all of the zone allocators we use. - */ -static void -manage_zones(int release) -{ - extern xfs_zone_t *xfs_buf_zone; - extern xfs_zone_t *xfs_ili_zone; - extern xfs_zone_t *xfs_inode_zone; - extern xfs_zone_t *xfs_ifork_zone; - extern xfs_zone_t *xfs_dabuf_zone; - extern xfs_zone_t *xfs_buf_item_zone; - extern xfs_zone_t *xfs_da_state_zone; - extern xfs_zone_t *xfs_btree_cur_zone; - extern xfs_zone_t *xfs_bmap_free_item_zone; - extern void xfs_dir_startup(); - - if (release) { /* free zone allocation */ - libxfs_free(xfs_buf_zone); - libxfs_free(xfs_inode_zone); - libxfs_free(xfs_ifork_zone); - libxfs_free(xfs_dabuf_zone); - libxfs_free(xfs_buf_item_zone); - libxfs_free(xfs_da_state_zone); - libxfs_free(xfs_btree_cur_zone); - libxfs_free(xfs_bmap_free_item_zone); - return; - } - /* otherwise initialise zone allocation */ - xfs_buf_zone = libxfs_zone_init(sizeof(xfs_buf_t), "xfs_buffer"); - xfs_inode_zone = libxfs_zone_init(sizeof(xfs_inode_t), "xfs_inode"); - xfs_ifork_zone = libxfs_zone_init(sizeof(xfs_ifork_t), "xfs_ifork"); - xfs_dabuf_zone = libxfs_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf"); - xfs_ili_zone = libxfs_zone_init( - sizeof(xfs_inode_log_item_t), "xfs_inode_log_item"); - xfs_buf_item_zone = libxfs_zone_init( - sizeof(xfs_buf_log_item_t), "xfs_buf_log_item"); - xfs_da_state_zone = libxfs_zone_init( - sizeof(xfs_da_state_t), "xfs_da_state"); - xfs_btree_cur_zone = libxfs_zone_init( - sizeof(xfs_btree_cur_t), "xfs_btree_cur"); - xfs_bmap_free_item_zone = libxfs_zone_init( - sizeof(xfs_bmap_free_item_t), "xfs_bmap_free_item"); - xfs_dir_startup(); -} - -/* - * Get the bitmap and summary inodes into the mount structure - * at mount time. - */ -static int -rtmount_inodes(xfs_mount_t *mp) -{ - int error; - xfs_sb_t *sbp; - - sbp = &mp->m_sb; - if (sbp->sb_rbmino == NULLFSINO) - return 0; - error = libxfs_iget(mp, NULL, sbp->sb_rbmino, 0, &mp->m_rbmip, 0); - if (error) { - fprintf(stderr, - _("%s: cannot read realtime bitmap inode (%d)\n"), - progname, error); - return error; - } - ASSERT(mp->m_rbmip != NULL); - ASSERT(sbp->sb_rsumino != NULLFSINO); - error = libxfs_iget(mp, NULL, sbp->sb_rsumino, 0, &mp->m_rsumip, 0); - if (error) { - libxfs_iput(mp->m_rbmip, 0); - fprintf(stderr, - _("%s: cannot read realtime summary inode (%d)\n"), - progname, error); - return error; - } - ASSERT(mp->m_rsumip != NULL); - return 0; -} - /* * Initialize realtime fields in the mount structure. */ @@ -512,7 +409,7 @@ rtmount_init( sbp = &mp->m_sb; if (sbp->sb_rblocks == 0) return 0; - if (mp->m_rtdev == 0 && !(flags & LIBXFS_MOUNT_DEBUGGER)) { + if (mp->m_rtdev_targp->dev == 0 && !(flags & LIBXFS_MOUNT_DEBUGGER)) { fprintf(stderr, _("%s: filesystem has a realtime subvolume\n"), progname); return -1; @@ -541,7 +438,7 @@ rtmount_init( return -1; } bp = libxfs_readbuf(mp->m_rtdev, - d - XFS_FSB_TO_BB(mp, 1), XFS_FSB_TO_BB(mp, 1), 0); + d - XFS_FSB_TO_BB(mp, 1), XFS_FSB_TO_BB(mp, 1), 0, NULL); if (bp == NULL) { fprintf(stderr, _("%s: realtime size check failed\n"), progname); @@ -551,6 +448,177 @@ rtmount_init( return 0; } +static int +libxfs_initialize_perag( + xfs_mount_t *mp, + xfs_agnumber_t agcount, + xfs_agnumber_t *maxagi) +{ + xfs_agnumber_t index, max_metadata; + xfs_agnumber_t first_initialised = 0; + xfs_perag_t *pag; + xfs_agino_t agino; + xfs_ino_t ino; + xfs_sb_t *sbp = &mp->m_sb; + int error = -ENOMEM; + + /* + * Walk the current per-ag tree so we don't try to initialise AGs + * that already exist (growfs case). Allocate and insert all the + * AGs we don't find ready for initialisation. + */ + for (index = 0; index < agcount; index++) { + pag = xfs_perag_get(mp, index); + if (pag) { + xfs_perag_put(pag); + continue; + } + if (!first_initialised) + first_initialised = index; + + pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL); + if (!pag) + goto out_unwind; + pag->pag_agno = index; + pag->pag_mount = mp; + + if (radix_tree_insert(&mp->m_perag_tree, index, pag)) { + error = -EEXIST; + goto out_unwind; + } + } + + /* + * If we mount with the inode64 option, or no inode overflows + * the legacy 32-bit address space clear the inode32 option. + */ + agino = XFS_AGB_TO_AGINO(mp, sbp->sb_agblocks - 1); + ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); + + if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32) + mp->m_flags |= XFS_MOUNT_32BITINODES; + else + mp->m_flags &= ~XFS_MOUNT_32BITINODES; + + if (mp->m_flags & XFS_MOUNT_32BITINODES) { + /* + * Calculate how much should be reserved for inodes to meet + * the max inode percentage. + */ + if (M_IGEO(mp)->maxicount) { + uint64_t icount; + + icount = sbp->sb_dblocks * sbp->sb_imax_pct; + do_div(icount, 100); + icount += sbp->sb_agblocks - 1; + do_div(icount, sbp->sb_agblocks); + max_metadata = icount; + } else { + max_metadata = agcount; + } + + for (index = 0; index < agcount; index++) { + ino = XFS_AGINO_TO_INO(mp, index, agino); + if (ino > XFS_MAXINUMBER_32) { + index++; + break; + } + + pag = xfs_perag_get(mp, index); + pag->pagi_inodeok = 1; + if (index < max_metadata) + pag->pagf_metadata = 1; + xfs_perag_put(pag); + } + } else { + for (index = 0; index < agcount; index++) { + pag = xfs_perag_get(mp, index); + pag->pagi_inodeok = 1; + xfs_perag_put(pag); + } + } + + if (maxagi) + *maxagi = index; + + mp->m_ag_prealloc_blocks = xfs_prealloc_blocks(mp); + return 0; + +out_unwind: + kmem_free(pag); + for (; index > first_initialised; index--) { + pag = radix_tree_delete(&mp->m_perag_tree, index); + kmem_free(pag); + } + return error; +} + +static struct xfs_buftarg * +libxfs_buftarg_alloc( + struct xfs_mount *mp, + dev_t dev) +{ + struct xfs_buftarg *btp; + + btp = malloc(sizeof(*btp)); + if (!btp) { + fprintf(stderr, _("%s: buftarg init failed\n"), + progname); + exit(1); + } + btp->bt_mount = mp; + btp->dev = dev; + return btp; +} + +void +libxfs_buftarg_init( + struct xfs_mount *mp, + dev_t dev, + dev_t logdev, + dev_t rtdev) +{ + if (mp->m_ddev_targp) { + /* should already have all buftargs initialised */ + if (mp->m_ddev_targp->dev != dev || + mp->m_ddev_targp->bt_mount != mp) { + fprintf(stderr, + _("%s: bad buftarg reinit, ddev\n"), + progname); + exit(1); + } + if (!logdev || logdev == dev) { + if (mp->m_logdev_targp != mp->m_ddev_targp) { + fprintf(stderr, + _("%s: bad buftarg reinit, ldev mismatch\n"), + progname); + exit(1); + } + } else if (mp->m_logdev_targp->dev != logdev || + mp->m_logdev_targp->bt_mount != mp) { + fprintf(stderr, + _("%s: bad buftarg reinit, logdev\n"), + progname); + exit(1); + } + if (rtdev && (mp->m_rtdev_targp->dev != rtdev || + mp->m_rtdev_targp->bt_mount != mp)) { + fprintf(stderr, + _("%s: bad buftarg reinit, rtdev\n"), + progname); + exit(1); + } + return; + } + + mp->m_ddev_targp = libxfs_buftarg_alloc(mp, dev); + if (!logdev || logdev == dev) + mp->m_logdev_targp = mp->m_ddev_targp; + else + mp->m_logdev_targp = libxfs_buftarg_alloc(mp, logdev); + mp->m_rtdev_targp = libxfs_buftarg_alloc(mp, rtdev); +} + /* * Mount structure initialization, provides a filled-in xfs_mount_t * such that the numerous XFS_* macros can be used. If dev is zero, @@ -568,61 +636,32 @@ libxfs_mount( xfs_daddr_t d; xfs_buf_t *bp; xfs_sb_t *sbp; - size_t size; int error; - mp->m_dev = dev; - mp->m_rtdev = rtdev; - mp->m_logdev = logdev; + libxfs_buftarg_init(mp, dev, logdev, rtdev); + + mp->m_finobt_nores = true; mp->m_flags = (LIBXFS_MOUNT_32BITINODES|LIBXFS_MOUNT_32BITINOOPT); mp->m_sb = *sb; + INIT_RADIX_TREE(&mp->m_perag_tree, GFP_KERNEL); sbp = &(mp->m_sb); - libxfs_mount_common(mp, sb); - - libxfs_alloc_compute_maxlevels(mp); - libxfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); - libxfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); - libxfs_ialloc_compute_maxlevels(mp); - - if (sbp->sb_imax_pct) { - /* Make sure the maximum inode count is a multiple of the - * units we allocate inodes in. - */ - mp->m_maxicount = (sbp->sb_dblocks * sbp->sb_imax_pct) / 100; - mp->m_maxicount = ((mp->m_maxicount / mp->m_ialloc_blks) * - mp->m_ialloc_blks) << sbp->sb_inopblog; - } else - mp->m_maxicount = 0; - - mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE; + xfs_sb_mount_common(mp, sb); /* * Set whether we're using stripe alignment. */ - if (XFS_SB_VERSION_HASDALIGN(&mp->m_sb)) { + if (xfs_sb_version_hasdalign(&mp->m_sb)) { mp->m_dalign = sbp->sb_unit; mp->m_swidth = sbp->sb_width; } - /* - * Set whether we're using inode alignment. - */ - if (XFS_SB_VERSION_HASALIGN(&mp->m_sb) && - mp->m_sb.sb_inoalignmt >= - XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) - mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1; - else - mp->m_inoalign_mask = 0; - /* - * If we are using stripe alignment, check whether - * the stripe unit is a multiple of the inode alignment - */ - if ( mp->m_dalign - && mp->m_inoalign_mask && !(mp->m_dalign & mp->m_inoalign_mask)) - mp->m_sinoalign = mp->m_dalign; - else - mp->m_sinoalign = 0; + xfs_alloc_compute_maxlevels(mp); + xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); + xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); + xfs_ialloc_setup_geometry(mp); + xfs_rmapbt_compute_maxlevels(mp); + xfs_refcountbt_compute_maxlevels(mp); /* * Check that the data (and log if separate) are an ok size. @@ -634,44 +673,71 @@ libxfs_mount( return NULL; } - /* Initialize the appropriate directory manager */ - if (XFS_SB_VERSION_HASDIRV2(sbp)) - libxfs_dir2_mount(mp); - else - libxfs_dir_mount(mp); + /* + * We automatically convert v1 inodes to v2 inodes now, so if + * the NLINK bit is not set we can't operate on the filesystem. + */ + if (!(sbp->sb_versionnum & XFS_SB_VERSION_NLINKBIT)) { + + fprintf(stderr, _( + "%s: V1 inodes unsupported. Please try an older xfsprogs.\n"), + progname); + exit(1); + } + + /* Check for supported directory formats */ + if (!(sbp->sb_versionnum & XFS_SB_VERSION_DIRV2BIT)) { + + fprintf(stderr, _( + "%s: V1 directories unsupported. Please try an older xfsprogs.\n"), + progname); + exit(1); + } + + /* check for unsupported other features */ + if (!xfs_sb_good_version(sbp)) { + fprintf(stderr, _( + "%s: Unsupported features detected. Please try a newer xfsprogs.\n"), + progname); + exit(1); + } + + xfs_da_mount(mp); - /* Initialize cached values for the attribute manager */ - mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100; + if (xfs_sb_version_hasattr2(&mp->m_sb)) + mp->m_flags |= LIBXFS_MOUNT_ATTR2; /* Initialize the precomputed transaction reservations values */ - libxfs_trans_init(mp); + xfs_trans_init(mp); if (dev == 0) /* maxtrres, we have no device so leave now */ return mp; bp = libxfs_readbuf(mp->m_dev, d - XFS_FSS_TO_BB(mp, 1), XFS_FSS_TO_BB(mp, 1), - !(flags & LIBXFS_MOUNT_DEBUGGER)); + !(flags & LIBXFS_MOUNT_DEBUGGER), NULL); if (!bp) { fprintf(stderr, _("%s: data size check failed\n"), progname); if (!(flags & LIBXFS_MOUNT_DEBUGGER)) return NULL; - } - libxfs_putbuf(bp); + } else + libxfs_putbuf(bp); - if (mp->m_logdev && mp->m_logdev != mp->m_dev) { + if (mp->m_logdev_targp->dev && + mp->m_logdev_targp->dev != mp->m_ddev_targp->dev) { d = (xfs_daddr_t) XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); if ( (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) || - (!(bp = libxfs_readbuf(mp->m_logdev, + (!(bp = libxfs_readbuf(mp->m_logdev_targp, d - XFS_FSB_TO_BB(mp, 1), XFS_FSB_TO_BB(mp, 1), - !(flags & LIBXFS_MOUNT_DEBUGGER)))) ) { + !(flags & LIBXFS_MOUNT_DEBUGGER), NULL))) ) { fprintf(stderr, _("%s: log size checks failed\n"), progname); if (!(flags & LIBXFS_MOUNT_DEBUGGER)) return NULL; } - libxfs_putbuf(bp); + if (bp) + libxfs_putbuf(bp); } /* Initialize realtime fields in the mount structure */ @@ -681,34 +747,36 @@ libxfs_mount( return NULL; } - /* Allocate and initialize the per-ag data */ - size = sbp->sb_agcount * sizeof(xfs_perag_t); - if (size && (mp->m_perag = calloc(size, 1)) == NULL) { - fprintf(stderr, _("%s: failed to alloc %ld bytes: %s\n"), - progname, (long)size, strerror(errno)); - exit(1); - } - - mp->m_maxagi = libxfs_initialize_perag(mp, sbp->sb_agcount); - /* - * mkfs calls mount before the root inode is allocated. + * libxfs_initialize_perag will allocate a perag structure for each ag. + * If agcount is corrupted and insanely high, this will OOM the box. + * If the agount seems (arbitrarily) high, try to read what would be + * the last AG, and if that fails for a relatively high agcount, just + * read the first one and let the user know to check the geometry. */ - if ((flags & LIBXFS_MOUNT_ROOTINOS) && sbp->sb_rootino != NULLFSINO) { - error = libxfs_iget(mp, NULL, sbp->sb_rootino, 0, - &mp->m_rootip, 0); - if (error) { - fprintf(stderr, _("%s: cannot read root inode (%d)\n"), - progname, error); + if (sbp->sb_agcount > 1000000) { + bp = libxfs_readbuf(mp->m_dev, + XFS_AG_DADDR(mp, sbp->sb_agcount - 1, 0), 1, + !(flags & LIBXFS_MOUNT_DEBUGGER), NULL); + if (bp->b_error) { + fprintf(stderr, _("%s: read of AG %u failed\n"), + progname, sbp->sb_agcount); if (!(flags & LIBXFS_MOUNT_DEBUGGER)) return NULL; + fprintf(stderr, _("%s: limiting reads to AG 0\n"), + progname); + sbp->sb_agcount = 1; } - ASSERT(mp->m_rootip != NULL); + libxfs_putbuf(bp); } - if ((flags & LIBXFS_MOUNT_ROOTINOS) && rtmount_inodes(mp)) { - libxfs_iput(mp->m_rootip, 0); - return NULL; + + error = libxfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi); + if (error) { + fprintf(stderr, _("%s: perag init failed\n"), + progname); + exit(1); } + return mp; } @@ -716,9 +784,9 @@ void libxfs_rtmount_destroy(xfs_mount_t *mp) { if (mp->m_rsumip) - libxfs_iput(mp->m_rsumip, 0); + libxfs_irele(mp->m_rsumip); if (mp->m_rbmip) - libxfs_iput(mp->m_rbmip, 0); + libxfs_irele(mp->m_rbmip); mp->m_rsumip = mp->m_rbmip = NULL; } @@ -728,18 +796,25 @@ libxfs_rtmount_destroy(xfs_mount_t *mp) void libxfs_umount(xfs_mount_t *mp) { + struct xfs_perag *pag; + int agno; + libxfs_rtmount_destroy(mp); - libxfs_icache_purge(); libxfs_bcache_purge(); - if (mp->m_perag) { - int agno; - for (agno = 0; agno < mp->m_maxagi; agno++) { - if (mp->m_perag[agno].pagb_list) - free(mp->m_perag[agno].pagb_list); - } - free(mp->m_perag); + for (agno = 0; agno < mp->m_maxagi; agno++) { + pag = radix_tree_delete(&mp->m_perag_tree, agno); + kmem_free(pag); } + + kmem_free(mp->m_attr_geo); + kmem_free(mp->m_dir_geo); + + kmem_free(mp->m_rtdev_targp); + if (mp->m_logdev_targp != mp->m_ddev_targp) + kmem_free(mp->m_logdev_targp); + kmem_free(mp->m_ddev_targp); + } /* @@ -748,9 +823,21 @@ libxfs_umount(xfs_mount_t *mp) void libxfs_destroy(void) { - manage_zones(1); - cache_destroy(libxfs_icache); + int leaked; + + /* Free everything from the buffer cache before freeing buffer zone */ + libxfs_bcache_purge(); + libxfs_bcache_free(); cache_destroy(libxfs_bcache); + leaked = destroy_zones(); + if (getenv("LIBXFS_LEAK_CHECK") && leaked) + exit(1); +} + +int +libxfs_device_alignment(void) +{ + return platform_align_blockdev(); } void @@ -759,16 +846,9 @@ libxfs_report(FILE *fp) time_t t; char *c; - cache_report(fp, "libxfs_icache", libxfs_icache); cache_report(fp, "libxfs_bcache", libxfs_bcache); t = time(NULL); c = asctime(localtime(&t)); fprintf(fp, "%s", c); } - -char * -libxfs_findrawpath(char *path) -{ - return platform_findrawpath(path); -}