blob: 8fcc4ccc5c791224e0d9325a5ad0557390a14d71 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scotta805bad2006-06-19 08:40:27 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "xfs.h"
Dave Chinner70a9883c2013-10-23 10:36:05 +110020#include "xfs_shared.h"
Dave Chinner6ca1c902013-08-12 20:49:26 +100021#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110022#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_sb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_mount.h"
Dave Chinner57062782013-10-15 09:17:51 +110026#include "xfs_da_format.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110028#include "xfs_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_bmap.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110030#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_error.h"
Christoph Hellwig9909c4a2007-10-11 18:11:14 +100032#include "xfs_fsops.h"
Dave Chinner239880e2013-10-23 10:50:10 +110033#include "xfs_trans.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_buf_item.h"
Dave Chinner239880e2013-10-23 10:50:10 +110035#include "xfs_log.h"
David Chinnera67d7c52007-11-23 16:29:32 +110036#include "xfs_log_priv.h"
Christoph Hellwig9f8868f2008-07-18 17:11:46 +100037#include "xfs_da_btree.h"
Dave Chinner2b9ab5a2013-08-12 20:49:37 +100038#include "xfs_dir2.h"
Christoph Hellwig9f8868f2008-07-18 17:11:46 +100039#include "xfs_extfree_item.h"
40#include "xfs_mru_cache.h"
41#include "xfs_inode_item.h"
Dave Chinner6d8b79c2012-10-08 21:56:09 +110042#include "xfs_icache.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000043#include "xfs_trace.h"
Dave Chinner3ebe7d22013-06-27 16:04:53 +100044#include "xfs_icreate_item.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110045#include "xfs_filestream.h"
46#include "xfs_quota.h"
Brian Foster65b65732014-09-09 11:52:42 +100047#include "xfs_sysfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49#include <linux/namei.h>
50#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090051#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/mount.h>
Christoph Hellwig0829c362005-09-02 16:58:49 +100053#include <linux/mempool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#include <linux/writeback.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100055#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080056#include <linux/freezer.h>
Christoph Hellwig62a877e2008-07-18 17:12:36 +100057#include <linux/parser.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Alexey Dobriyanb87221d2009-09-21 17:01:09 -070059static const struct super_operations xfs_super_operations;
David Chinner7989cb82007-02-10 18:34:56 +110060static kmem_zone_t *xfs_ioend_zone;
Christoph Hellwig0829c362005-09-02 16:58:49 +100061mempool_t *xfs_ioend_pool;
Brian Foster65b65732014-09-09 11:52:42 +100062
Dave Chinnere3aed1a2014-09-29 10:46:08 +100063static struct kset *xfs_kset; /* top-level xfs sysfs dir */
Brian Foster65b65732014-09-09 11:52:42 +100064#ifdef DEBUG
65static struct xfs_kobj xfs_dbg_kobj; /* global debug sysfs attrs */
66#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
David Chinnera67d7c52007-11-23 16:29:32 +110068#define MNTOPT_LOGBUFS "logbufs" /* number of XFS log buffers */
69#define MNTOPT_LOGBSIZE "logbsize" /* size of XFS log buffers */
70#define MNTOPT_LOGDEV "logdev" /* log device */
71#define MNTOPT_RTDEV "rtdev" /* realtime I/O device */
72#define MNTOPT_BIOSIZE "biosize" /* log2 of preferred buffered io size */
73#define MNTOPT_WSYNC "wsync" /* safe-mode nfs compatible mount */
David Chinnera67d7c52007-11-23 16:29:32 +110074#define MNTOPT_NOALIGN "noalign" /* turn off stripe alignment */
75#define MNTOPT_SWALLOC "swalloc" /* turn on stripe width allocation */
76#define MNTOPT_SUNIT "sunit" /* data volume stripe unit */
77#define MNTOPT_SWIDTH "swidth" /* data volume stripe width */
78#define MNTOPT_NOUUID "nouuid" /* ignore filesystem UUID */
79#define MNTOPT_MTPT "mtpt" /* filesystem mount point */
80#define MNTOPT_GRPID "grpid" /* group-ID from parent directory */
81#define MNTOPT_NOGRPID "nogrpid" /* group-ID from current process */
82#define MNTOPT_BSDGROUPS "bsdgroups" /* group-ID from parent directory */
83#define MNTOPT_SYSVGROUPS "sysvgroups" /* group-ID from current process */
84#define MNTOPT_ALLOCSIZE "allocsize" /* preferred allocation size */
85#define MNTOPT_NORECOVERY "norecovery" /* don't run XFS recovery */
86#define MNTOPT_BARRIER "barrier" /* use writer barriers for log write and
87 * unwritten extent conversion */
88#define MNTOPT_NOBARRIER "nobarrier" /* .. disable */
David Chinnera67d7c52007-11-23 16:29:32 +110089#define MNTOPT_64BITINODE "inode64" /* inodes can be allocated anywhere */
Carlos Maiolino08bf5402012-09-20 10:32:37 -030090#define MNTOPT_32BITINODE "inode32" /* inode allocation limited to
91 * XFS_MAXINUMBER_32 */
David Chinnera67d7c52007-11-23 16:29:32 +110092#define MNTOPT_IKEEP "ikeep" /* do not free empty inode clusters */
93#define MNTOPT_NOIKEEP "noikeep" /* free empty inode clusters */
94#define MNTOPT_LARGEIO "largeio" /* report large I/O sizes in stat() */
95#define MNTOPT_NOLARGEIO "nolargeio" /* do not report large I/O sizes
96 * in stat(). */
97#define MNTOPT_ATTR2 "attr2" /* do use attr2 attribute format */
98#define MNTOPT_NOATTR2 "noattr2" /* do not use attr2 attribute format */
99#define MNTOPT_FILESTREAM "filestreams" /* use filestreams allocator */
100#define MNTOPT_QUOTA "quota" /* disk quotas (user) */
101#define MNTOPT_NOQUOTA "noquota" /* no quotas */
102#define MNTOPT_USRQUOTA "usrquota" /* user quota enabled */
103#define MNTOPT_GRPQUOTA "grpquota" /* group quota enabled */
104#define MNTOPT_PRJQUOTA "prjquota" /* project quota enabled */
105#define MNTOPT_UQUOTA "uquota" /* user quota (IRIX variant) */
106#define MNTOPT_GQUOTA "gquota" /* group quota (IRIX variant) */
107#define MNTOPT_PQUOTA "pquota" /* project quota (IRIX variant) */
108#define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
109#define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
110#define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
111#define MNTOPT_QUOTANOENF "qnoenforce" /* same as uqnoenforce */
Christoph Hellwige84661a2011-05-20 13:45:32 +0000112#define MNTOPT_DELAYLOG "delaylog" /* Delayed logging enabled */
113#define MNTOPT_NODELAYLOG "nodelaylog" /* Delayed logging disabled */
114#define MNTOPT_DISCARD "discard" /* Discard unused blocks */
115#define MNTOPT_NODISCARD "nodiscard" /* Do not discard unused blocks */
David Chinnera67d7c52007-11-23 16:29:32 +1100116
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000117/*
118 * Table driven mount option parser.
119 *
120 * Currently only used for remount, but it will be used for mount
121 * in the future, too.
122 */
123enum {
Carlos Maiolino2ea03922012-09-20 10:32:41 -0300124 Opt_barrier,
125 Opt_nobarrier,
126 Opt_inode64,
127 Opt_inode32,
128 Opt_err
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000129};
130
Steven Whitehousea447c092008-10-13 10:46:57 +0100131static const match_table_t tokens = {
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000132 {Opt_barrier, "barrier"},
133 {Opt_nobarrier, "nobarrier"},
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -0300134 {Opt_inode64, "inode64"},
Carlos Maiolino2ea03922012-09-20 10:32:41 -0300135 {Opt_inode32, "inode32"},
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000136 {Opt_err, NULL}
137};
138
139
David Chinnera67d7c52007-11-23 16:29:32 +1100140STATIC unsigned long
Abhijit Pawara17164e2013-01-09 19:34:42 +0530141suffix_kstrtoint(char *s, unsigned int base, int *res)
David Chinnera67d7c52007-11-23 16:29:32 +1100142{
Abhijit Pawara17164e2013-01-09 19:34:42 +0530143 int last, shift_left_factor = 0, _res;
David Chinnera67d7c52007-11-23 16:29:32 +1100144 char *value = s;
145
146 last = strlen(value) - 1;
147 if (value[last] == 'K' || value[last] == 'k') {
148 shift_left_factor = 10;
149 value[last] = '\0';
150 }
151 if (value[last] == 'M' || value[last] == 'm') {
152 shift_left_factor = 20;
153 value[last] = '\0';
154 }
155 if (value[last] == 'G' || value[last] == 'g') {
156 shift_left_factor = 30;
157 value[last] = '\0';
158 }
159
Abhijit Pawara17164e2013-01-09 19:34:42 +0530160 if (kstrtoint(s, base, &_res))
161 return -EINVAL;
162 *res = _res << shift_left_factor;
163 return 0;
David Chinnera67d7c52007-11-23 16:29:32 +1100164}
165
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100166/*
167 * This function fills in xfs_mount_t fields based on mount args.
168 * Note: the superblock has _not_ yet been read in.
169 *
170 * Note that this function leaks the various device name allocations on
171 * failure. The caller takes care of them.
172 */
David Chinnera67d7c52007-11-23 16:29:32 +1100173STATIC int
174xfs_parseargs(
175 struct xfs_mount *mp,
Christoph Hellwig288699f2010-06-23 18:11:15 +1000176 char *options)
David Chinnera67d7c52007-11-23 16:29:32 +1100177{
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100178 struct super_block *sb = mp->m_super;
Abhijit Pawara17164e2013-01-09 19:34:42 +0530179 char *this_char, *value;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100180 int dsunit = 0;
181 int dswidth = 0;
182 int iosize = 0;
Christoph Hellwiga5687782009-02-09 08:37:39 +0100183 __uint8_t iosizelog = 0;
David Chinnera67d7c52007-11-23 16:29:32 +1100184
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100185 /*
Dave Chinner4f107002011-03-07 10:00:35 +1100186 * set up the mount name first so all the errors will refer to the
187 * correct device.
188 */
189 mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
190 if (!mp->m_fsname)
Dave Chinner24513372014-06-25 14:58:08 +1000191 return -ENOMEM;
Dave Chinner4f107002011-03-07 10:00:35 +1100192 mp->m_fsname_len = strlen(mp->m_fsname) + 1;
193
194 /*
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100195 * Copy binary VFS mount flags we are interested in.
196 */
197 if (sb->s_flags & MS_RDONLY)
198 mp->m_flags |= XFS_MOUNT_RDONLY;
199 if (sb->s_flags & MS_DIRSYNC)
200 mp->m_flags |= XFS_MOUNT_DIRSYNC;
201 if (sb->s_flags & MS_SYNCHRONOUS)
202 mp->m_flags |= XFS_MOUNT_WSYNC;
203
204 /*
205 * Set some default flags that could be cleared by the mount option
206 * parsing.
207 */
208 mp->m_flags |= XFS_MOUNT_BARRIER;
209 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100210
211 /*
212 * These can be overridden by the mount option parsing.
213 */
214 mp->m_logbufs = -1;
215 mp->m_logbsize = -1;
David Chinnera67d7c52007-11-23 16:29:32 +1100216
217 if (!options)
218 goto done;
219
David Chinnera67d7c52007-11-23 16:29:32 +1100220 while ((this_char = strsep(&options, ",")) != NULL) {
221 if (!*this_char)
222 continue;
223 if ((value = strchr(this_char, '=')) != NULL)
224 *value++ = 0;
225
226 if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
227 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100228 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100229 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000230 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100231 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530232 if (kstrtoint(value, 10, &mp->m_logbufs))
Dave Chinner24513372014-06-25 14:58:08 +1000233 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100234 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
235 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100236 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100237 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000238 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100239 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530240 if (suffix_kstrtoint(value, 10, &mp->m_logbsize))
Dave Chinner24513372014-06-25 14:58:08 +1000241 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100242 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
243 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100244 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100245 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000246 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100247 }
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100248 mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
249 if (!mp->m_logname)
Dave Chinner24513372014-06-25 14:58:08 +1000250 return -ENOMEM;
David Chinnera67d7c52007-11-23 16:29:32 +1100251 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100252 xfs_warn(mp, "%s option not allowed on this system",
Christoph Hellwig288699f2010-06-23 18:11:15 +1000253 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000254 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100255 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
256 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100257 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100258 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000259 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100260 }
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100261 mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
262 if (!mp->m_rtname)
Dave Chinner24513372014-06-25 14:58:08 +1000263 return -ENOMEM;
David Chinnera67d7c52007-11-23 16:29:32 +1100264 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
265 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100266 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100267 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000268 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100269 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530270 if (kstrtoint(value, 10, &iosize))
Dave Chinner24513372014-06-25 14:58:08 +1000271 return -EINVAL;
Christoph Hellwig1ec79442008-10-30 17:55:08 +1100272 iosizelog = ffs(iosize) - 1;
David Chinnera67d7c52007-11-23 16:29:32 +1100273 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
274 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100275 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100276 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000277 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100278 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530279 if (suffix_kstrtoint(value, 10, &iosize))
Dave Chinner24513372014-06-25 14:58:08 +1000280 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100281 iosizelog = ffs(iosize) - 1;
David Chinnera67d7c52007-11-23 16:29:32 +1100282 } else if (!strcmp(this_char, MNTOPT_GRPID) ||
283 !strcmp(this_char, MNTOPT_BSDGROUPS)) {
284 mp->m_flags |= XFS_MOUNT_GRPID;
285 } else if (!strcmp(this_char, MNTOPT_NOGRPID) ||
286 !strcmp(this_char, MNTOPT_SYSVGROUPS)) {
287 mp->m_flags &= ~XFS_MOUNT_GRPID;
288 } else if (!strcmp(this_char, MNTOPT_WSYNC)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100289 mp->m_flags |= XFS_MOUNT_WSYNC;
David Chinnera67d7c52007-11-23 16:29:32 +1100290 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100291 mp->m_flags |= XFS_MOUNT_NORECOVERY;
David Chinnera67d7c52007-11-23 16:29:32 +1100292 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100293 mp->m_flags |= XFS_MOUNT_NOALIGN;
David Chinnera67d7c52007-11-23 16:29:32 +1100294 } else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100295 mp->m_flags |= XFS_MOUNT_SWALLOC;
David Chinnera67d7c52007-11-23 16:29:32 +1100296 } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
297 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100298 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100299 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000300 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100301 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530302 if (kstrtoint(value, 10, &dsunit))
Dave Chinner24513372014-06-25 14:58:08 +1000303 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100304 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
305 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100306 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100307 this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000308 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100309 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530310 if (kstrtoint(value, 10, &dswidth))
Dave Chinner24513372014-06-25 14:58:08 +1000311 return -EINVAL;
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300312 } else if (!strcmp(this_char, MNTOPT_32BITINODE)) {
313 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
David Chinnera67d7c52007-11-23 16:29:32 +1100314 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100315 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
David Chinnera67d7c52007-11-23 16:29:32 +1100316 } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100317 mp->m_flags |= XFS_MOUNT_NOUUID;
David Chinnera67d7c52007-11-23 16:29:32 +1100318 } else if (!strcmp(this_char, MNTOPT_BARRIER)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100319 mp->m_flags |= XFS_MOUNT_BARRIER;
David Chinnera67d7c52007-11-23 16:29:32 +1100320 } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100321 mp->m_flags &= ~XFS_MOUNT_BARRIER;
David Chinnera67d7c52007-11-23 16:29:32 +1100322 } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100323 mp->m_flags |= XFS_MOUNT_IKEEP;
David Chinnera67d7c52007-11-23 16:29:32 +1100324 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100325 mp->m_flags &= ~XFS_MOUNT_IKEEP;
David Chinnera67d7c52007-11-23 16:29:32 +1100326 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100327 mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
David Chinnera67d7c52007-11-23 16:29:32 +1100328 } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100329 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
David Chinnera67d7c52007-11-23 16:29:32 +1100330 } else if (!strcmp(this_char, MNTOPT_ATTR2)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100331 mp->m_flags |= XFS_MOUNT_ATTR2;
David Chinnera67d7c52007-11-23 16:29:32 +1100332 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100333 mp->m_flags &= ~XFS_MOUNT_ATTR2;
334 mp->m_flags |= XFS_MOUNT_NOATTR2;
David Chinnera67d7c52007-11-23 16:29:32 +1100335 } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100336 mp->m_flags |= XFS_MOUNT_FILESTREAMS;
David Chinnera67d7c52007-11-23 16:29:32 +1100337 } else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
Chandra Seetharaman4177af32012-01-23 17:31:43 +0000338 mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
339 mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
340 mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
David Chinnera67d7c52007-11-23 16:29:32 +1100341 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
342 !strcmp(this_char, MNTOPT_UQUOTA) ||
343 !strcmp(this_char, MNTOPT_USRQUOTA)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100344 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
345 XFS_UQUOTA_ENFD);
David Chinnera67d7c52007-11-23 16:29:32 +1100346 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
347 !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100348 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
349 mp->m_qflags &= ~XFS_UQUOTA_ENFD;
David Chinnera67d7c52007-11-23 16:29:32 +1100350 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
351 !strcmp(this_char, MNTOPT_PRJQUOTA)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100352 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500353 XFS_PQUOTA_ENFD);
David Chinnera67d7c52007-11-23 16:29:32 +1100354 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100355 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500356 mp->m_qflags &= ~XFS_PQUOTA_ENFD;
David Chinnera67d7c52007-11-23 16:29:32 +1100357 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
358 !strcmp(this_char, MNTOPT_GRPQUOTA)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100359 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500360 XFS_GQUOTA_ENFD);
David Chinnera67d7c52007-11-23 16:29:32 +1100361 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100362 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500363 mp->m_qflags &= ~XFS_GQUOTA_ENFD;
Dave Chinner71e330b2010-05-21 14:37:18 +1000364 } else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
Christoph Hellwig242d6212011-08-24 05:57:51 +0000365 xfs_warn(mp,
Christoph Hellwig93b8a582011-12-06 21:58:07 +0000366 "delaylog is the default now, option is deprecated.");
367 } else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
368 xfs_warn(mp,
369 "nodelaylog support has been removed, option is deprecated.");
Christoph Hellwige84661a2011-05-20 13:45:32 +0000370 } else if (!strcmp(this_char, MNTOPT_DISCARD)) {
371 mp->m_flags |= XFS_MOUNT_DISCARD;
372 } else if (!strcmp(this_char, MNTOPT_NODISCARD)) {
373 mp->m_flags &= ~XFS_MOUNT_DISCARD;
David Chinnera67d7c52007-11-23 16:29:32 +1100374 } else if (!strcmp(this_char, "ihashsize")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100375 xfs_warn(mp,
376 "ihashsize no longer used, option is deprecated.");
David Chinnera67d7c52007-11-23 16:29:32 +1100377 } else if (!strcmp(this_char, "osyncisdsync")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100378 xfs_warn(mp,
379 "osyncisdsync has no effect, option is deprecated.");
Christoph Hellwiga64afb02010-07-20 17:50:52 +1000380 } else if (!strcmp(this_char, "osyncisosync")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100381 xfs_warn(mp,
382 "osyncisosync has no effect, option is deprecated.");
David Chinnera67d7c52007-11-23 16:29:32 +1100383 } else if (!strcmp(this_char, "irixsgid")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100384 xfs_warn(mp,
385 "irixsgid is now a sysctl(2) variable, option is deprecated.");
David Chinnera67d7c52007-11-23 16:29:32 +1100386 } else {
Dave Chinner4f107002011-03-07 10:00:35 +1100387 xfs_warn(mp, "unknown mount option [%s].", this_char);
Dave Chinner24513372014-06-25 14:58:08 +1000388 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100389 }
390 }
391
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100392 /*
393 * no recovery flag requires a read-only mount
394 */
395 if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
396 !(mp->m_flags & XFS_MOUNT_RDONLY)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100397 xfs_warn(mp, "no-recovery mounts must be read-only.");
Dave Chinner24513372014-06-25 14:58:08 +1000398 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100399 }
400
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100401 if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100402 xfs_warn(mp,
403 "sunit and swidth options incompatible with the noalign option");
Dave Chinner24513372014-06-25 14:58:08 +1000404 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100405 }
406
Christoph Hellwig7d095252009-06-08 15:33:32 +0200407#ifndef CONFIG_XFS_QUOTA
408 if (XFS_IS_QUOTA_RUNNING(mp)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100409 xfs_warn(mp, "quota support not available in this kernel.");
Dave Chinner24513372014-06-25 14:58:08 +1000410 return -EINVAL;
Christoph Hellwig7d095252009-06-08 15:33:32 +0200411 }
412#endif
413
David Chinnera67d7c52007-11-23 16:29:32 +1100414 if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100415 xfs_warn(mp, "sunit and swidth must be specified together");
Dave Chinner24513372014-06-25 14:58:08 +1000416 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100417 }
418
419 if (dsunit && (dswidth % dsunit != 0)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100420 xfs_warn(mp,
421 "stripe width (%d) must be a multiple of the stripe unit (%d)",
David Chinnera67d7c52007-11-23 16:29:32 +1100422 dswidth, dsunit);
Dave Chinner24513372014-06-25 14:58:08 +1000423 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100424 }
425
David Chinnera67d7c52007-11-23 16:29:32 +1100426done:
Jie Liu39a45d82013-05-02 19:27:47 +0800427 if (dsunit && !(mp->m_flags & XFS_MOUNT_NOALIGN)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100428 /*
429 * At this point the superblock has not been read
430 * in, therefore we do not know the block size.
431 * Before the mount call ends we will convert
432 * these to FSBs.
433 */
Jie Liu39a45d82013-05-02 19:27:47 +0800434 mp->m_dalign = dsunit;
435 mp->m_swidth = dswidth;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100436 }
437
438 if (mp->m_logbufs != -1 &&
439 mp->m_logbufs != 0 &&
440 (mp->m_logbufs < XLOG_MIN_ICLOGS ||
441 mp->m_logbufs > XLOG_MAX_ICLOGS)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100442 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100443 mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
Dave Chinner24513372014-06-25 14:58:08 +1000444 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100445 }
446 if (mp->m_logbsize != -1 &&
447 mp->m_logbsize != 0 &&
448 (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
449 mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
450 !is_power_of_2(mp->m_logbsize))) {
Dave Chinner4f107002011-03-07 10:00:35 +1100451 xfs_warn(mp,
452 "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100453 mp->m_logbsize);
Dave Chinner24513372014-06-25 14:58:08 +1000454 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100455 }
456
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100457 if (iosizelog) {
458 if (iosizelog > XFS_MAX_IO_LOG ||
459 iosizelog < XFS_MIN_IO_LOG) {
Dave Chinner4f107002011-03-07 10:00:35 +1100460 xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100461 iosizelog, XFS_MIN_IO_LOG,
462 XFS_MAX_IO_LOG);
Dave Chinner24513372014-06-25 14:58:08 +1000463 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100464 }
465
466 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
467 mp->m_readio_log = iosizelog;
468 mp->m_writeio_log = iosizelog;
469 }
470
David Chinnera67d7c52007-11-23 16:29:32 +1100471 return 0;
472}
473
474struct proc_xfs_info {
475 int flag;
476 char *str;
477};
478
479STATIC int
480xfs_showargs(
481 struct xfs_mount *mp,
482 struct seq_file *m)
483{
484 static struct proc_xfs_info xfs_info_set[] = {
485 /* the few simple ones we can get from the mount struct */
Josef Jeff Sipek1bd960e2008-02-29 13:58:40 +1100486 { XFS_MOUNT_IKEEP, "," MNTOPT_IKEEP },
David Chinnera67d7c52007-11-23 16:29:32 +1100487 { XFS_MOUNT_WSYNC, "," MNTOPT_WSYNC },
David Chinnera67d7c52007-11-23 16:29:32 +1100488 { XFS_MOUNT_NOALIGN, "," MNTOPT_NOALIGN },
489 { XFS_MOUNT_SWALLOC, "," MNTOPT_SWALLOC },
490 { XFS_MOUNT_NOUUID, "," MNTOPT_NOUUID },
491 { XFS_MOUNT_NORECOVERY, "," MNTOPT_NORECOVERY },
David Chinnera67d7c52007-11-23 16:29:32 +1100492 { XFS_MOUNT_ATTR2, "," MNTOPT_ATTR2 },
493 { XFS_MOUNT_FILESTREAMS, "," MNTOPT_FILESTREAM },
David Chinnera67d7c52007-11-23 16:29:32 +1100494 { XFS_MOUNT_GRPID, "," MNTOPT_GRPID },
Christoph Hellwige84661a2011-05-20 13:45:32 +0000495 { XFS_MOUNT_DISCARD, "," MNTOPT_DISCARD },
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300496 { XFS_MOUNT_SMALL_INUMS, "," MNTOPT_32BITINODE },
David Chinnera67d7c52007-11-23 16:29:32 +1100497 { 0, NULL }
498 };
499 static struct proc_xfs_info xfs_info_unset[] = {
500 /* the few simple ones we can get from the mount struct */
David Chinnera67d7c52007-11-23 16:29:32 +1100501 { XFS_MOUNT_COMPAT_IOSIZE, "," MNTOPT_LARGEIO },
502 { XFS_MOUNT_BARRIER, "," MNTOPT_NOBARRIER },
503 { XFS_MOUNT_SMALL_INUMS, "," MNTOPT_64BITINODE },
504 { 0, NULL }
505 };
506 struct proc_xfs_info *xfs_infop;
507
508 for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
509 if (mp->m_flags & xfs_infop->flag)
510 seq_puts(m, xfs_infop->str);
511 }
512 for (xfs_infop = xfs_info_unset; xfs_infop->flag; xfs_infop++) {
513 if (!(mp->m_flags & xfs_infop->flag))
514 seq_puts(m, xfs_infop->str);
515 }
516
517 if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
518 seq_printf(m, "," MNTOPT_ALLOCSIZE "=%dk",
519 (int)(1 << mp->m_writeio_log) >> 10);
520
521 if (mp->m_logbufs > 0)
522 seq_printf(m, "," MNTOPT_LOGBUFS "=%d", mp->m_logbufs);
523 if (mp->m_logbsize > 0)
524 seq_printf(m, "," MNTOPT_LOGBSIZE "=%dk", mp->m_logbsize >> 10);
525
526 if (mp->m_logname)
527 seq_printf(m, "," MNTOPT_LOGDEV "=%s", mp->m_logname);
528 if (mp->m_rtname)
529 seq_printf(m, "," MNTOPT_RTDEV "=%s", mp->m_rtname);
530
531 if (mp->m_dalign > 0)
532 seq_printf(m, "," MNTOPT_SUNIT "=%d",
533 (int)XFS_FSB_TO_BB(mp, mp->m_dalign));
534 if (mp->m_swidth > 0)
535 seq_printf(m, "," MNTOPT_SWIDTH "=%d",
536 (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
537
538 if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
539 seq_puts(m, "," MNTOPT_USRQUOTA);
540 else if (mp->m_qflags & XFS_UQUOTA_ACCT)
541 seq_puts(m, "," MNTOPT_UQUOTANOENF);
542
Alex Elder988abe42009-09-02 17:02:24 -0500543 if (mp->m_qflags & XFS_PQUOTA_ACCT) {
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500544 if (mp->m_qflags & XFS_PQUOTA_ENFD)
Alex Elder988abe42009-09-02 17:02:24 -0500545 seq_puts(m, "," MNTOPT_PRJQUOTA);
546 else
547 seq_puts(m, "," MNTOPT_PQUOTANOENF);
Chandra Seetharamand892d582013-07-19 17:36:02 -0500548 }
549 if (mp->m_qflags & XFS_GQUOTA_ACCT) {
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500550 if (mp->m_qflags & XFS_GQUOTA_ENFD)
Alex Elder988abe42009-09-02 17:02:24 -0500551 seq_puts(m, "," MNTOPT_GRPQUOTA);
552 else
553 seq_puts(m, "," MNTOPT_GQUOTANOENF);
554 }
David Chinnera67d7c52007-11-23 16:29:32 +1100555
556 if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
557 seq_puts(m, "," MNTOPT_NOQUOTA);
558
559 return 0;
560}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561__uint64_t
562xfs_max_file_offset(
563 unsigned int blockshift)
564{
565 unsigned int pagefactor = 1;
566 unsigned int bitshift = BITS_PER_LONG - 1;
567
568 /* Figure out maximum filesize, on Linux this can depend on
569 * the filesystem blocksize (on 32 bit platforms).
Christoph Hellwigebdec242010-10-06 10:47:23 +0200570 * __block_write_begin does this in an [unsigned] long...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 * page->index << (PAGE_CACHE_SHIFT - bbits)
572 * So, for page sized blocks (4K on 32 bit platforms),
573 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
574 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
575 * but for smaller blocksizes it is less (bbits = log2 bsize).
576 * Note1: get_block_t takes a long (implicit cast from above)
577 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
578 * can optionally convert the [unsigned] long from above into
579 * an [unsigned] long long.
580 */
581
582#if BITS_PER_LONG == 32
Bartlomiej Zolnierkiewicz90c699a2009-06-19 08:08:50 +0200583# if defined(CONFIG_LBDAF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 ASSERT(sizeof(sector_t) == 8);
585 pagefactor = PAGE_CACHE_SIZE;
586 bitshift = BITS_PER_LONG;
587# else
588 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
589# endif
590#endif
591
592 return (((__uint64_t)pagefactor) << bitshift) - 1;
593}
594
Eric Sandeen9de67c32014-07-24 20:51:54 +1000595/*
596 * xfs_set_inode32() and xfs_set_inode64() are passed an agcount
597 * because in the growfs case, mp->m_sb.sb_agcount is not updated
598 * yet to the potentially higher ag count.
599 */
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300600xfs_agnumber_t
Eric Sandeen9de67c32014-07-24 20:51:54 +1000601xfs_set_inode32(struct xfs_mount *mp, xfs_agnumber_t agcount)
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300602{
603 xfs_agnumber_t index = 0;
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300604 xfs_agnumber_t maxagi = 0;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300605 xfs_sb_t *sbp = &mp->m_sb;
606 xfs_agnumber_t max_metadata;
Eric Sandeen54aa61f2014-07-24 20:53:10 +1000607 xfs_agino_t agino;
608 xfs_ino_t ino;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300609 xfs_perag_t *pag;
610
611 /* Calculate how much should be reserved for inodes to meet
612 * the max inode percentage.
613 */
614 if (mp->m_maxicount) {
615 __uint64_t icount;
616
617 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
618 do_div(icount, 100);
619 icount += sbp->sb_agblocks - 1;
620 do_div(icount, sbp->sb_agblocks);
621 max_metadata = icount;
622 } else {
Eric Sandeen9de67c32014-07-24 20:51:54 +1000623 max_metadata = agcount;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300624 }
625
Eric Sandeen54aa61f2014-07-24 20:53:10 +1000626 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
627
Eric Sandeen9de67c32014-07-24 20:51:54 +1000628 for (index = 0; index < agcount; index++) {
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300629 ino = XFS_AGINO_TO_INO(mp, index, agino);
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300630
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300631 if (ino > XFS_MAXINUMBER_32) {
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300632 pag = xfs_perag_get(mp, index);
633 pag->pagi_inodeok = 0;
634 pag->pagf_metadata = 0;
635 xfs_perag_put(pag);
636 continue;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300637 }
638
639 pag = xfs_perag_get(mp, index);
640 pag->pagi_inodeok = 1;
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300641 maxagi++;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300642 if (index < max_metadata)
643 pag->pagf_metadata = 1;
644 xfs_perag_put(pag);
645 }
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300646 mp->m_flags |= (XFS_MOUNT_32BITINODES |
647 XFS_MOUNT_SMALL_INUMS);
648
649 return maxagi;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300650}
651
652xfs_agnumber_t
Eric Sandeen9de67c32014-07-24 20:51:54 +1000653xfs_set_inode64(struct xfs_mount *mp, xfs_agnumber_t agcount)
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300654{
655 xfs_agnumber_t index = 0;
656
Eric Sandeen9de67c32014-07-24 20:51:54 +1000657 for (index = 0; index < agcount; index++) {
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300658 struct xfs_perag *pag;
659
660 pag = xfs_perag_get(mp, index);
661 pag->pagi_inodeok = 1;
662 pag->pagf_metadata = 0;
663 xfs_perag_put(pag);
664 }
665
666 /* There is no need for lock protection on m_flags,
667 * the rw_semaphore of the VFS superblock is locked
668 * during mount/umount/remount operations, so this is
669 * enough to avoid concurency on the m_flags field
670 */
671 mp->m_flags &= ~(XFS_MOUNT_32BITINODES |
672 XFS_MOUNT_SMALL_INUMS);
673 return index;
674}
675
Hannes Eder3180e662009-03-04 19:34:10 +0100676STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677xfs_blkdev_get(
678 xfs_mount_t *mp,
679 const char *name,
680 struct block_device **bdevp)
681{
682 int error = 0;
683
Tejun Heod4d77622010-11-13 11:55:18 +0100684 *bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
685 mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (IS_ERR(*bdevp)) {
687 error = PTR_ERR(*bdevp);
Eric Sandeen77af5742014-12-24 09:47:27 +1100688 xfs_warn(mp, "Invalid device [%s], error=%d", name, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 }
690
Dave Chinner24513372014-06-25 14:58:08 +1000691 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
Hannes Eder3180e662009-03-04 19:34:10 +0100694STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695xfs_blkdev_put(
696 struct block_device *bdev)
697{
698 if (bdev)
Tejun Heoe525fd82010-11-13 11:55:17 +0100699 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100702void
703xfs_blkdev_issue_flush(
704 xfs_buftarg_t *buftarg)
705{
Shaohua Li7582df52012-04-24 21:23:46 +0800706 blkdev_issue_flush(buftarg->bt_bdev, GFP_NOFS, NULL);
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100707}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000709STATIC void
710xfs_close_devices(
711 struct xfs_mount *mp)
712{
713 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000714 struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
Christoph Hellwigb7963132009-03-03 14:48:37 -0500715 xfs_free_buftarg(mp, mp->m_logdev_targp);
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000716 xfs_blkdev_put(logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000717 }
718 if (mp->m_rtdev_targp) {
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000719 struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
Christoph Hellwigb7963132009-03-03 14:48:37 -0500720 xfs_free_buftarg(mp, mp->m_rtdev_targp);
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000721 xfs_blkdev_put(rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000722 }
Christoph Hellwigb7963132009-03-03 14:48:37 -0500723 xfs_free_buftarg(mp, mp->m_ddev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000724}
725
726/*
727 * The file system configurations are:
728 * (1) device (partition) with data and internal log
729 * (2) logical volume with data and log subvolumes.
730 * (3) logical volume with data, log, and realtime subvolumes.
731 *
732 * We only have to handle opening the log and realtime volumes here if
733 * they are present. The data subvolume has already been opened by
734 * get_sb_bdev() and is stored in sb->s_bdev.
735 */
736STATIC int
737xfs_open_devices(
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100738 struct xfs_mount *mp)
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000739{
740 struct block_device *ddev = mp->m_super->s_bdev;
741 struct block_device *logdev = NULL, *rtdev = NULL;
742 int error;
743
744 /*
745 * Open real time and log devices - order is important.
746 */
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100747 if (mp->m_logname) {
748 error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000749 if (error)
750 goto out;
751 }
752
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100753 if (mp->m_rtname) {
754 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000755 if (error)
756 goto out_close_logdev;
757
758 if (rtdev == ddev || rtdev == logdev) {
Dave Chinner4f107002011-03-07 10:00:35 +1100759 xfs_warn(mp,
760 "Cannot mount filesystem with identical rtdev and ddev/logdev.");
Dave Chinner24513372014-06-25 14:58:08 +1000761 error = -EINVAL;
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000762 goto out_close_rtdev;
763 }
764 }
765
766 /*
767 * Setup xfs_mount buffer target pointers
768 */
Dave Chinner24513372014-06-25 14:58:08 +1000769 error = -ENOMEM;
Eric Sandeen34dcefd2014-04-14 19:01:00 +1000770 mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000771 if (!mp->m_ddev_targp)
772 goto out_close_rtdev;
773
774 if (rtdev) {
Eric Sandeen34dcefd2014-04-14 19:01:00 +1000775 mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000776 if (!mp->m_rtdev_targp)
777 goto out_free_ddev_targ;
778 }
779
780 if (logdev && logdev != ddev) {
Eric Sandeen34dcefd2014-04-14 19:01:00 +1000781 mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000782 if (!mp->m_logdev_targp)
783 goto out_free_rtdev_targ;
784 } else {
785 mp->m_logdev_targp = mp->m_ddev_targp;
786 }
787
788 return 0;
789
790 out_free_rtdev_targ:
791 if (mp->m_rtdev_targp)
Christoph Hellwigb7963132009-03-03 14:48:37 -0500792 xfs_free_buftarg(mp, mp->m_rtdev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000793 out_free_ddev_targ:
Christoph Hellwigb7963132009-03-03 14:48:37 -0500794 xfs_free_buftarg(mp, mp->m_ddev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000795 out_close_rtdev:
Markus Elfringd2a5e3c2014-12-01 08:24:20 +1100796 xfs_blkdev_put(rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000797 out_close_logdev:
798 if (logdev && logdev != ddev)
799 xfs_blkdev_put(logdev);
800 out:
801 return error;
802}
803
Christoph Hellwige34b5622008-05-20 15:10:36 +1000804/*
805 * Setup xfs_mount buffer target pointers based on superblock
806 */
807STATIC int
808xfs_setup_devices(
809 struct xfs_mount *mp)
810{
811 int error;
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000812
Eric Sandeena96c4152014-04-14 19:00:29 +1000813 error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize);
Christoph Hellwige34b5622008-05-20 15:10:36 +1000814 if (error)
815 return error;
816
817 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
818 unsigned int log_sector_size = BBSIZE;
819
820 if (xfs_sb_version_hassector(&mp->m_sb))
821 log_sector_size = mp->m_sb.sb_logsectsize;
822 error = xfs_setsize_buftarg(mp->m_logdev_targp,
Christoph Hellwige34b5622008-05-20 15:10:36 +1000823 log_sector_size);
824 if (error)
825 return error;
826 }
827 if (mp->m_rtdev_targp) {
828 error = xfs_setsize_buftarg(mp->m_rtdev_targp,
Christoph Hellwige34b5622008-05-20 15:10:36 +1000829 mp->m_sb.sb_sectsize);
830 if (error)
831 return error;
832 }
833
834 return 0;
835}
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000836
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000837STATIC int
838xfs_init_mount_workqueues(
839 struct xfs_mount *mp)
840{
Brian Foster78c931b2014-11-28 13:59:58 +1100841 mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s",
Brian Fosterb29c70f2014-12-04 09:43:17 +1100842 WQ_MEM_RECLAIM|WQ_FREEZABLE, 1, mp->m_fsname);
Brian Foster78c931b2014-11-28 13:59:58 +1100843 if (!mp->m_buf_workqueue)
844 goto out;
845
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000846 mp->m_data_workqueue = alloc_workqueue("xfs-data/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000847 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000848 if (!mp->m_data_workqueue)
Brian Foster78c931b2014-11-28 13:59:58 +1100849 goto out_destroy_buf;
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000850
851 mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000852 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000853 if (!mp->m_unwritten_workqueue)
854 goto out_destroy_data_iodone_queue;
855
Dave Chinner4c2d5422012-04-23 17:54:32 +1000856 mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000857 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000858 if (!mp->m_cil_workqueue)
859 goto out_destroy_unwritten;
Dave Chinner58896082012-10-08 21:56:05 +1100860
861 mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000862 WQ_FREEZABLE, 0, mp->m_fsname);
Dave Chinner58896082012-10-08 21:56:05 +1100863 if (!mp->m_reclaim_workqueue)
864 goto out_destroy_cil;
865
866 mp->m_log_workqueue = alloc_workqueue("xfs-log/%s",
Brian Fosterb29c70f2014-12-04 09:43:17 +1100867 WQ_FREEZABLE|WQ_HIGHPRI, 0, mp->m_fsname);
Dave Chinner58896082012-10-08 21:56:05 +1100868 if (!mp->m_log_workqueue)
869 goto out_destroy_reclaim;
870
Brian Foster579b62f2012-11-06 09:50:47 -0500871 mp->m_eofblocks_workqueue = alloc_workqueue("xfs-eofblocks/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000872 WQ_FREEZABLE, 0, mp->m_fsname);
Brian Foster579b62f2012-11-06 09:50:47 -0500873 if (!mp->m_eofblocks_workqueue)
874 goto out_destroy_log;
875
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000876 return 0;
877
Brian Foster579b62f2012-11-06 09:50:47 -0500878out_destroy_log:
879 destroy_workqueue(mp->m_log_workqueue);
Dave Chinner58896082012-10-08 21:56:05 +1100880out_destroy_reclaim:
881 destroy_workqueue(mp->m_reclaim_workqueue);
882out_destroy_cil:
883 destroy_workqueue(mp->m_cil_workqueue);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000884out_destroy_unwritten:
885 destroy_workqueue(mp->m_unwritten_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000886out_destroy_data_iodone_queue:
887 destroy_workqueue(mp->m_data_workqueue);
Brian Foster78c931b2014-11-28 13:59:58 +1100888out_destroy_buf:
889 destroy_workqueue(mp->m_buf_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000890out:
891 return -ENOMEM;
892}
893
894STATIC void
895xfs_destroy_mount_workqueues(
896 struct xfs_mount *mp)
897{
Brian Foster579b62f2012-11-06 09:50:47 -0500898 destroy_workqueue(mp->m_eofblocks_workqueue);
Dave Chinner58896082012-10-08 21:56:05 +1100899 destroy_workqueue(mp->m_log_workqueue);
900 destroy_workqueue(mp->m_reclaim_workqueue);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000901 destroy_workqueue(mp->m_cil_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000902 destroy_workqueue(mp->m_data_workqueue);
903 destroy_workqueue(mp->m_unwritten_workqueue);
Brian Foster78c931b2014-11-28 13:59:58 +1100904 destroy_workqueue(mp->m_buf_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000905}
906
Dave Chinner9aa05002012-10-08 21:56:04 +1100907/*
908 * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK
909 * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting
910 * for IO to complete so that we effectively throttle multiple callers to the
911 * rate at which IO is completing.
912 */
913void
914xfs_flush_inodes(
915 struct xfs_mount *mp)
916{
917 struct super_block *sb = mp->m_super;
918
919 if (down_read_trylock(&sb->s_umount)) {
Jan Kara0dc83bd2014-02-21 11:19:04 +0100920 sync_inodes_sb(sb);
Dave Chinner9aa05002012-10-08 21:56:04 +1100921 up_read(&sb->s_umount);
922 }
923}
924
David Chinnerbf904242008-10-30 17:36:14 +1100925/* Catch misguided souls that try to use this interface on XFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926STATIC struct inode *
Nathan Scotta50cd262006-03-14 14:06:18 +1100927xfs_fs_alloc_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 struct super_block *sb)
929{
David Chinnerbf904242008-10-30 17:36:14 +1100930 BUG();
Lachlan McIlroy493dca62008-10-30 17:36:52 +1100931 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932}
933
David Chinnerbf904242008-10-30 17:36:14 +1100934/*
David Chinner99fa8cb2008-10-30 17:36:40 +1100935 * Now that the generic code is guaranteed not to be accessing
936 * the linux inode, we can reclaim the inode.
David Chinnerbf904242008-10-30 17:36:14 +1100937 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100939xfs_fs_destroy_inode(
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000940 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941{
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000942 struct xfs_inode *ip = XFS_I(inode);
943
Christoph Hellwigcca28fb2010-06-24 11:57:09 +1000944 trace_xfs_destroy_inode(ip);
David Chinner99fa8cb2008-10-30 17:36:40 +1100945
946 XFS_STATS_INC(vn_reclaim);
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000947
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000948 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
949
950 /*
951 * We should never get here with one of the reclaim flags already set.
952 */
953 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
954 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM));
955
956 /*
Dave Chinner57817c62010-01-10 23:51:47 +0000957 * We always use background reclaim here because even if the
958 * inode is clean, it still may be under IO and hence we have
959 * to take the flush lock. The background reclaim path handles
960 * this more efficiently than we can here, so simply let background
961 * reclaim tear down all inodes.
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000962 */
Dave Chinner57817c62010-01-10 23:51:47 +0000963 xfs_inode_set_reclaim_tag(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964}
965
David Chinner07c8f672008-10-30 16:11:59 +1100966/*
967 * Slab object creation initialisation for the XFS inode.
968 * This covers only the idempotent fields in the XFS inode;
969 * all other fields need to be initialised on allocation
Uwe Kleine-Königb5950762010-11-01 15:38:34 -0400970 * from the slab. This avoids the need to repeatedly initialise
David Chinner07c8f672008-10-30 16:11:59 +1100971 * fields in the xfs inode that left in the initialise state
972 * when freeing the inode.
973 */
David Chinnerbf904242008-10-30 17:36:14 +1100974STATIC void
975xfs_fs_inode_init_once(
David Chinner07c8f672008-10-30 16:11:59 +1100976 void *inode)
977{
978 struct xfs_inode *ip = inode;
979
980 memset(ip, 0, sizeof(struct xfs_inode));
David Chinnerbf904242008-10-30 17:36:14 +1100981
982 /* vfs inode */
983 inode_init_once(VFS_I(ip));
984
985 /* xfs inode */
David Chinner07c8f672008-10-30 16:11:59 +1100986 atomic_set(&ip->i_pincount, 0);
987 spin_lock_init(&ip->i_flags_lock);
David Chinner07c8f672008-10-30 16:11:59 +1100988
989 mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
990 "xfsino", ip->i_ino);
David Chinner07c8f672008-10-30 16:11:59 +1100991}
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993STATIC void
Al Virob57922d2010-06-07 14:34:48 -0400994xfs_fs_evict_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 struct inode *inode)
996{
Christoph Hellwig1543d792007-08-29 11:46:47 +1000997 xfs_inode_t *ip = XFS_I(inode);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000998
Christoph Hellwig4f59af72012-07-04 11:13:33 -0400999 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
1000
Al Virob57922d2010-06-07 14:34:48 -04001001 trace_xfs_evict_inode(ip);
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001002
Johannes Weiner91b0abe2014-04-03 14:47:49 -07001003 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +02001004 clear_inode(inode);
David Chinner99fa8cb2008-10-30 17:36:40 +11001005 XFS_STATS_INC(vn_rele);
1006 XFS_STATS_INC(vn_remove);
Christoph Hellwig56d433e2005-09-05 08:23:54 +10001007
David Chinner99fa8cb2008-10-30 17:36:40 +11001008 xfs_inactive(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009}
1010
Dave Chinner5132ba82012-03-22 05:15:10 +00001011/*
1012 * We do an unlocked check for XFS_IDONTCACHE here because we are already
1013 * serialised against cache hits here via the inode->i_lock and igrab() in
1014 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
1015 * racing with us, and it avoids needing to grab a spinlock here for every inode
1016 * we drop the final reference on.
1017 */
1018STATIC int
1019xfs_fs_drop_inode(
1020 struct inode *inode)
1021{
1022 struct xfs_inode *ip = XFS_I(inode);
1023
1024 return generic_drop_inode(inode) || (ip->i_flags & XFS_IDONTCACHE);
1025}
1026
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027STATIC void
Christoph Hellwiga7381592008-08-13 16:04:05 +10001028xfs_free_fsname(
1029 struct xfs_mount *mp)
1030{
1031 kfree(mp->m_fsname);
1032 kfree(mp->m_rtname);
1033 kfree(mp->m_logname);
1034}
1035
1036STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +11001037xfs_fs_put_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 struct super_block *sb)
1039{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001040 struct xfs_mount *mp = XFS_M(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
Dave Chinner7e185302012-10-08 21:56:00 +11001042 xfs_filestream_unmount(mp);
1043 xfs_unmountfs(mp);
1044
Christoph Hellwig62033002008-08-13 16:50:21 +10001045 xfs_freesb(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001046 xfs_icsb_destroy_counters(mp);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001047 xfs_destroy_mount_workqueues(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001048 xfs_close_devices(mp);
Christoph Hellwiga7381592008-08-13 16:04:05 +10001049 xfs_free_fsname(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001050 kfree(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051}
1052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053STATIC int
Christoph Hellwig69961a22009-10-06 20:29:28 +00001054xfs_fs_sync_fs(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 struct super_block *sb,
1056 int wait)
1057{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001058 struct xfs_mount *mp = XFS_M(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
Lachlan McIlroye893bff2007-10-12 11:13:35 +10001060 /*
Christoph Hellwig34625c62011-12-06 21:58:12 +00001061 * Doing anything during the async pass would be counterproductive.
Lachlan McIlroye893bff2007-10-12 11:13:35 +10001062 */
Christoph Hellwig34625c62011-12-06 21:58:12 +00001063 if (!wait)
Christoph Hellwig69961a22009-10-06 20:29:28 +00001064 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Dave Chinner34061f52012-10-08 21:56:06 +11001066 xfs_log_force(mp, XFS_LOG_SYNC);
Christoph Hellwig69961a22009-10-06 20:29:28 +00001067 if (laptop_mode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 /*
1069 * The disk must be active because we're syncing.
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001070 * We schedule log work now (now that the disk is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 * active) instead of later (when it might not be).
1072 */
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001073 flush_delayed_work(&mp->m_log->l_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075
Christoph Hellwig69961a22009-10-06 20:29:28 +00001076 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077}
1078
1079STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001080xfs_fs_statfs(
David Howells726c3342006-06-23 02:02:58 -07001081 struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 struct kstatfs *statp)
1083{
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001084 struct xfs_mount *mp = XFS_M(dentry->d_sb);
1085 xfs_sb_t *sbp = &mp->m_sb;
Christoph Hellwig7d095252009-06-08 15:33:32 +02001086 struct xfs_inode *ip = XFS_I(dentry->d_inode);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001087 __uint64_t fakeinos, id;
1088 xfs_extlen_t lsize;
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001089 __int64_t ffree;
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001090
1091 statp->f_type = XFS_SB_MAGIC;
1092 statp->f_namelen = MAXNAMELEN - 1;
1093
1094 id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
1095 statp->f_fsid.val[0] = (u32)id;
1096 statp->f_fsid.val[1] = (u32)(id >> 32);
1097
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001098 xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001099
1100 spin_lock(&mp->m_sb_lock);
1101 statp->f_bsize = sbp->sb_blocksize;
1102 lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
1103 statp->f_blocks = sbp->sb_dblocks - lsize;
1104 statp->f_bfree = statp->f_bavail =
1105 sbp->sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
1106 fakeinos = statp->f_bfree << sbp->sb_inopblog;
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001107 statp->f_files =
1108 MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
1109 if (mp->m_maxicount)
Christoph Hellwiga19d9f82009-03-29 09:51:08 +02001110 statp->f_files = min_t(typeof(statp->f_files),
1111 statp->f_files,
1112 mp->m_maxicount);
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001113
Eric Sandeen01f98822015-02-06 09:53:02 +11001114 /* If sb_icount overshot maxicount, report actual allocation */
1115 statp->f_files = max_t(typeof(statp->f_files),
1116 statp->f_files,
1117 sbp->sb_icount);
1118
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001119 /* make sure statp->f_ffree does not underflow */
1120 ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
1121 statp->f_ffree = max_t(__int64_t, ffree, 0);
1122
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001123 spin_unlock(&mp->m_sb_lock);
1124
Jie Liuda5bf952012-04-12 03:59:57 +00001125 if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
Chandra Seetharaman83e782e2013-06-27 17:25:10 -05001126 ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
1127 (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
Christoph Hellwig7d095252009-06-08 15:33:32 +02001128 xfs_qm_statvfs(ip, statp);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001129 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130}
1131
Eric Sandeend5db0f92010-02-05 22:59:53 +00001132STATIC void
1133xfs_save_resvblks(struct xfs_mount *mp)
1134{
1135 __uint64_t resblks = 0;
1136
1137 mp->m_resblks_save = mp->m_resblks;
1138 xfs_reserve_blocks(mp, &resblks, NULL);
1139}
1140
1141STATIC void
1142xfs_restore_resvblks(struct xfs_mount *mp)
1143{
1144 __uint64_t resblks;
1145
1146 if (mp->m_resblks_save) {
1147 resblks = mp->m_resblks_save;
1148 mp->m_resblks_save = 0;
1149 } else
1150 resblks = xfs_default_resblks(mp);
1151
1152 xfs_reserve_blocks(mp, &resblks, NULL);
1153}
1154
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001155/*
1156 * Trigger writeback of all the dirty metadata in the file system.
1157 *
1158 * This ensures that the metadata is written to their location on disk rather
1159 * than just existing in transactions in the log. This means after a quiesce
Dave Chinnerc75921a2012-10-08 21:56:08 +11001160 * there is no log replay required to write the inodes to disk - this is the
1161 * primary difference between a sync and a quiesce.
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001162 *
Dave Chinnerc75921a2012-10-08 21:56:08 +11001163 * Note: xfs_log_quiesce() stops background log work - the callers must ensure
1164 * it is started again when appropriate.
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001165 */
Dave Chinner632b89e2013-10-29 22:11:58 +11001166static void
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001167xfs_quiesce_attr(
1168 struct xfs_mount *mp)
1169{
1170 int error = 0;
1171
1172 /* wait for all modifications to complete */
1173 while (atomic_read(&mp->m_active_trans) > 0)
1174 delay(100);
1175
1176 /* force the log to unpin objects from the now complete transactions */
1177 xfs_log_force(mp, XFS_LOG_SYNC);
1178
1179 /* reclaim inodes to do any IO before the freeze completes */
1180 xfs_reclaim_inodes(mp, 0);
1181 xfs_reclaim_inodes(mp, SYNC_WAIT);
1182
Dave Chinnerc75921a2012-10-08 21:56:08 +11001183 /* Push the superblock and write an unmount record */
1184 error = xfs_log_sbcount(mp);
1185 if (error)
1186 xfs_warn(mp, "xfs_attr_quiesce: failed to log sb changes. "
1187 "Frozen image may not be consistent.");
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001188 /*
1189 * Just warn here till VFS can correctly support
1190 * read-only remount without racing.
1191 */
1192 WARN_ON(atomic_read(&mp->m_active_trans) != 0);
1193
Dave Chinnerc75921a2012-10-08 21:56:08 +11001194 xfs_log_quiesce(mp);
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001195}
1196
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001198xfs_fs_remount(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 struct super_block *sb,
1200 int *flags,
1201 char *options)
1202{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001203 struct xfs_mount *mp = XFS_M(sb);
Eric Sandeen9de67c32014-07-24 20:51:54 +10001204 xfs_sb_t *sbp = &mp->m_sb;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001205 substring_t args[MAX_OPT_ARGS];
1206 char *p;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001207 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
Theodore Ts'o02b99842014-03-13 10:14:33 -04001209 sync_filesystem(sb);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001210 while ((p = strsep(&options, ",")) != NULL) {
1211 int token;
Christoph Hellwigbdd907b2008-05-20 15:10:44 +10001212
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001213 if (!*p)
1214 continue;
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001215
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001216 token = match_token(p, tokens, args);
1217 switch (token) {
1218 case Opt_barrier:
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001219 mp->m_flags |= XFS_MOUNT_BARRIER;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001220 break;
1221 case Opt_nobarrier:
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001222 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001223 break;
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -03001224 case Opt_inode64:
Eric Sandeen9de67c32014-07-24 20:51:54 +10001225 mp->m_maxagi = xfs_set_inode64(mp, sbp->sb_agcount);
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -03001226 break;
Carlos Maiolino2ea03922012-09-20 10:32:41 -03001227 case Opt_inode32:
Eric Sandeen9de67c32014-07-24 20:51:54 +10001228 mp->m_maxagi = xfs_set_inode32(mp, sbp->sb_agcount);
Carlos Maiolino2ea03922012-09-20 10:32:41 -03001229 break;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001230 default:
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001231 /*
1232 * Logically we would return an error here to prevent
1233 * users from believing they might have changed
1234 * mount options using remount which can't be changed.
1235 *
1236 * But unfortunately mount(8) adds all options from
1237 * mtab and fstab to the mount arguments in some cases
1238 * so we can't blindly reject options, but have to
1239 * check for each specified option if it actually
1240 * differs from the currently set option and only
1241 * reject it if that's the case.
1242 *
1243 * Until that is implemented we return success for
1244 * every remount request, and silently ignore all
1245 * options that we can't actually change.
1246 */
1247#if 0
Dave Chinner4f107002011-03-07 10:00:35 +11001248 xfs_info(mp,
Eric Sandeen08e96e12013-10-11 20:59:05 -05001249 "mount option \"%s\" not supported for remount", p);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001250 return -EINVAL;
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001251#else
Christoph Hellwig6c5e51d2008-10-12 14:30:44 +02001252 break;
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001253#endif
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001254 }
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001255 }
1256
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001257 /* ro -> rw */
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001258 if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
1259 mp->m_flags &= ~XFS_MOUNT_RDONLY;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001260
1261 /*
1262 * If this is the first remount to writeable state we
1263 * might have some superblock changes to update.
1264 */
Dave Chinner61e63ec2015-01-22 09:10:31 +11001265 if (mp->m_update_sb) {
1266 error = xfs_sync_sb(mp, false);
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001267 if (error) {
Dave Chinner4f107002011-03-07 10:00:35 +11001268 xfs_warn(mp, "failed to write sb changes");
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001269 return error;
1270 }
Dave Chinner61e63ec2015-01-22 09:10:31 +11001271 mp->m_update_sb = false;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001272 }
Dave Chinnercbe132a2010-01-26 15:08:49 +11001273
1274 /*
1275 * Fill out the reserve pool if it is empty. Use the stashed
1276 * value if it is non-zero, otherwise go with the default.
1277 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001278 xfs_restore_resvblks(mp);
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001279 xfs_log_work_queue(mp);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001280 }
1281
1282 /* rw -> ro */
1283 if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
Dave Chinnercbe132a2010-01-26 15:08:49 +11001284 /*
Dave Chinner34061f52012-10-08 21:56:06 +11001285 * Before we sync the metadata, we need to free up the reserve
1286 * block pool so that the used block count in the superblock on
1287 * disk is correct at the end of the remount. Stash the current
1288 * reserve pool size so that if we get remounted rw, we can
1289 * return it to the same size.
Dave Chinnercbe132a2010-01-26 15:08:49 +11001290 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001291 xfs_save_resvblks(mp);
David Chinner76bf1052008-10-30 17:16:21 +11001292 xfs_quiesce_attr(mp);
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001293 mp->m_flags |= XFS_MOUNT_RDONLY;
1294 }
1295
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001296 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297}
1298
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001299/*
1300 * Second stage of a freeze. The data is already frozen so we only
Dave Chinner61e63ec2015-01-22 09:10:31 +11001301 * need to take care of the metadata. Once that's done sync the superblock
1302 * to the log to dirty it in case of a crash while frozen. This ensures that we
1303 * will recover the unlinked inode lists on the next mount.
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001304 */
Takashi Satoc4be0c12009-01-09 16:40:58 -08001305STATIC int
1306xfs_fs_freeze(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 struct super_block *sb)
1308{
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001309 struct xfs_mount *mp = XFS_M(sb);
1310
Eric Sandeend5db0f92010-02-05 22:59:53 +00001311 xfs_save_resvblks(mp);
David Chinner76bf1052008-10-30 17:16:21 +11001312 xfs_quiesce_attr(mp);
Dave Chinner61e63ec2015-01-22 09:10:31 +11001313 return xfs_sync_sb(mp, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314}
1315
1316STATIC int
Eric Sandeend5db0f92010-02-05 22:59:53 +00001317xfs_fs_unfreeze(
1318 struct super_block *sb)
1319{
1320 struct xfs_mount *mp = XFS_M(sb);
1321
1322 xfs_restore_resvblks(mp);
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001323 xfs_log_work_queue(mp);
Eric Sandeend5db0f92010-02-05 22:59:53 +00001324 return 0;
1325}
1326
1327STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001328xfs_fs_show_options(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 struct seq_file *m,
Al Viro34c80b12011-12-08 21:32:45 -05001330 struct dentry *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331{
Dave Chinner24513372014-06-25 14:58:08 +10001332 return xfs_showargs(XFS_M(root->d_sb), m);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333}
1334
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001335/*
1336 * This function fills in xfs_mount_t fields based on mount args.
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001337 * Note: the superblock _has_ now been read in.
1338 */
1339STATIC int
1340xfs_finish_flags(
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001341 struct xfs_mount *mp)
1342{
1343 int ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
1344
Frederik Schwarzer025dfda2008-10-16 19:02:37 +02001345 /* Fail a mount where the logbuf is smaller than the log stripe */
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001346 if (xfs_sb_version_haslogv2(&mp->m_sb)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001347 if (mp->m_logbsize <= 0 &&
1348 mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001349 mp->m_logbsize = mp->m_sb.sb_logsunit;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001350 } else if (mp->m_logbsize > 0 &&
1351 mp->m_logbsize < mp->m_sb.sb_logsunit) {
Dave Chinner4f107002011-03-07 10:00:35 +11001352 xfs_warn(mp,
1353 "logbuf size must be greater than or equal to log stripe size");
Dave Chinner24513372014-06-25 14:58:08 +10001354 return -EINVAL;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001355 }
1356 } else {
1357 /* Fail a mount if the logbuf is larger than 32K */
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001358 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
Dave Chinner4f107002011-03-07 10:00:35 +11001359 xfs_warn(mp,
1360 "logbuf size for version 1 logs must be 16K or 32K");
Dave Chinner24513372014-06-25 14:58:08 +10001361 return -EINVAL;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001362 }
1363 }
1364
1365 /*
Dave Chinnerd3eaace2013-06-05 12:09:09 +10001366 * V5 filesystems always use attr2 format for attributes.
1367 */
1368 if (xfs_sb_version_hascrc(&mp->m_sb) &&
1369 (mp->m_flags & XFS_MOUNT_NOATTR2)) {
1370 xfs_warn(mp,
1371"Cannot mount a V5 filesystem as %s. %s is always enabled for V5 filesystems.",
1372 MNTOPT_NOATTR2, MNTOPT_ATTR2);
Dave Chinner24513372014-06-25 14:58:08 +10001373 return -EINVAL;
Dave Chinnerd3eaace2013-06-05 12:09:09 +10001374 }
1375
1376 /*
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001377 * mkfs'ed attr2 will turn on attr2 mount unless explicitly
1378 * told by noattr2 to turn it off
1379 */
1380 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001381 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001382 mp->m_flags |= XFS_MOUNT_ATTR2;
1383
1384 /*
1385 * prohibit r/w mounts of read-only filesystems
1386 */
1387 if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
Dave Chinner4f107002011-03-07 10:00:35 +11001388 xfs_warn(mp,
1389 "cannot mount a read-only filesystem as read-write");
Dave Chinner24513372014-06-25 14:58:08 +10001390 return -EROFS;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001391 }
1392
Chandra Seetharamand892d582013-07-19 17:36:02 -05001393 if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
1394 (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE)) &&
1395 !xfs_sb_version_has_pquotino(&mp->m_sb)) {
1396 xfs_warn(mp,
1397 "Super block does not support project and group quota together");
Dave Chinner24513372014-06-25 14:58:08 +10001398 return -EINVAL;
Chandra Seetharamand892d582013-07-19 17:36:02 -05001399 }
1400
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001401 return 0;
1402}
1403
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001405xfs_fs_fill_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 struct super_block *sb,
1407 void *data,
1408 int silent)
1409{
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001410 struct inode *root;
Christoph Hellwig745f6912007-08-30 17:20:39 +10001411 struct xfs_mount *mp = NULL;
Dave Chinner24513372014-06-25 14:58:08 +10001412 int flags = 0, error = -ENOMEM;
Christoph Hellwigbdd907b2008-05-20 15:10:44 +10001413
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001414 mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
1415 if (!mp)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001416 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001418 spin_lock_init(&mp->m_sb_lock);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001419 mutex_init(&mp->m_growlock);
1420 atomic_set(&mp->m_active_trans, 0);
Dave Chinner7e185302012-10-08 21:56:00 +11001421 INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker);
Brian Foster579b62f2012-11-06 09:50:47 -05001422 INIT_DELAYED_WORK(&mp->m_eofblocks_work, xfs_eofblocks_worker);
Dave Chinnere3aed1a2014-09-29 10:46:08 +10001423 mp->m_kobj.kobject.kset = xfs_kset;
Christoph Hellwig74394492007-08-30 17:21:22 +10001424
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001425 mp->m_super = sb;
1426 sb->s_fs_info = mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
Christoph Hellwig288699f2010-06-23 18:11:15 +10001428 error = xfs_parseargs(mp, (char *)data);
Christoph Hellwig745f6912007-08-30 17:20:39 +10001429 if (error)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001430 goto out_free_fsname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
1432 sb_min_blocksize(sb, BBSIZE);
Lachlan McIlroy0ec58512008-06-23 13:23:01 +10001433 sb->s_xattr = xfs_xattr_handlers;
Nathan Scotta50cd262006-03-14 14:06:18 +11001434 sb->s_export_op = &xfs_export_operations;
Christoph Hellwigfcafb712009-02-09 08:47:34 +01001435#ifdef CONFIG_XFS_QUOTA
Nathan Scotta50cd262006-03-14 14:06:18 +11001436 sb->s_qcop = &xfs_quotactl_operations;
Jan Kara17ef4fd2014-09-30 22:35:33 +02001437 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
Christoph Hellwigfcafb712009-02-09 08:47:34 +01001438#endif
Nathan Scotta50cd262006-03-14 14:06:18 +11001439 sb->s_op = &xfs_super_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001441 if (silent)
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001442 flags |= XFS_MFSI_QUIET;
1443
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001444 error = xfs_open_devices(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001445 if (error)
Christoph Hellwig288699f2010-06-23 18:11:15 +10001446 goto out_free_fsname;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001447
Dave Chinner24513372014-06-25 14:58:08 +10001448 error = xfs_init_mount_workqueues(mp);
Christoph Hellwig61ba35d2010-09-30 02:25:54 +00001449 if (error)
1450 goto out_close_devices;
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001451
Dave Chinner24513372014-06-25 14:58:08 +10001452 error = xfs_icsb_init_counters(mp);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001453 if (error)
1454 goto out_destroy_workqueues;
1455
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001456 error = xfs_readsb(mp, flags);
1457 if (error)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001458 goto out_destroy_counters;
1459
1460 error = xfs_finish_flags(mp);
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001461 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001462 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001463
Christoph Hellwige34b5622008-05-20 15:10:36 +10001464 error = xfs_setup_devices(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001465 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001466 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001467
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001468 error = xfs_filestream_mount(mp);
1469 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001470 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001471
Dave Chinner704b2902011-03-26 09:14:57 +11001472 /*
1473 * we must configure the block size in the superblock before we run the
1474 * full mount process as the mount process can lookup and cache inodes.
Dave Chinner704b2902011-03-26 09:14:57 +11001475 */
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001476 sb->s_magic = XFS_SB_MAGIC;
1477 sb->s_blocksize = mp->m_sb.sb_blocksize;
1478 sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
Al Viro8de52772012-02-06 12:45:27 -05001480 sb->s_max_links = XFS_MAXLINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 sb->s_time_gran = 1;
1482 set_posix_acl_flag(sb);
1483
Dave Chinnerdc037ad2013-06-27 16:04:59 +10001484 /* version 5 superblocks support inode version counters. */
1485 if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5)
1486 sb->s_flags |= MS_I_VERSION;
1487
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001488 error = xfs_mountfs(mp);
Christoph Hellwig2bcf6e92011-07-13 13:43:48 +02001489 if (error)
Dave Chinner7e185302012-10-08 21:56:00 +11001490 goto out_filestream_unmount;
Dave Chinner704b2902011-03-26 09:14:57 +11001491
David Chinner01651642008-08-13 15:45:15 +10001492 root = igrab(VFS_I(mp->m_rootip));
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001493 if (!root) {
Dave Chinner24513372014-06-25 14:58:08 +10001494 error = -ENOENT;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001495 goto out_unmount;
Christoph Hellwigcbc89dc2008-02-05 12:14:01 +11001496 }
Al Viro48fde702012-01-08 22:15:13 -05001497 sb->s_root = d_make_root(root);
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001498 if (!sb->s_root) {
Dave Chinner24513372014-06-25 14:58:08 +10001499 error = -ENOMEM;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001500 goto out_unmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 }
Christoph Hellwig74394492007-08-30 17:21:22 +10001502
Dave Chinner7e185302012-10-08 21:56:00 +11001503 return 0;
1504
1505 out_filestream_unmount:
Christoph Hellwig120226c2008-05-20 15:11:11 +10001506 xfs_filestream_unmount(mp);
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001507 out_free_sb:
1508 xfs_freesb(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001509 out_destroy_counters:
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001510 xfs_icsb_destroy_counters(mp);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001511out_destroy_workqueues:
1512 xfs_destroy_mount_workqueues(mp);
Christoph Hellwig61ba35d2010-09-30 02:25:54 +00001513 out_close_devices:
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001514 xfs_close_devices(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001515 out_free_fsname:
1516 xfs_free_fsname(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001517 kfree(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001518 out:
Dave Chinner24513372014-06-25 14:58:08 +10001519 return error;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001520
Christoph Hellwig2bcf6e92011-07-13 13:43:48 +02001521 out_unmount:
Christoph Hellwige48ad312008-05-20 11:30:52 +10001522 xfs_filestream_unmount(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001523 xfs_unmountfs(mp);
Christoph Hellwig62033002008-08-13 16:50:21 +10001524 goto out_free_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525}
1526
Al Viro152a0832010-07-25 00:46:55 +04001527STATIC struct dentry *
1528xfs_fs_mount(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 struct file_system_type *fs_type,
1530 int flags,
1531 const char *dev_name,
Al Viro152a0832010-07-25 00:46:55 +04001532 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533{
Al Viro152a0832010-07-25 00:46:55 +04001534 return mount_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535}
1536
Dave Chinner0a234c62013-08-28 10:17:57 +10001537static long
Dave Chinner8daaa832011-07-08 14:14:46 +10001538xfs_fs_nr_cached_objects(
Dave Chinner9b17c622013-08-28 10:18:05 +10001539 struct super_block *sb,
Vladimir Davydov4101b622015-02-12 14:58:51 -08001540 struct shrink_control *sc)
Dave Chinner8daaa832011-07-08 14:14:46 +10001541{
1542 return xfs_reclaim_inodes_count(XFS_M(sb));
1543}
1544
Dave Chinner0a234c62013-08-28 10:17:57 +10001545static long
Dave Chinner8daaa832011-07-08 14:14:46 +10001546xfs_fs_free_cached_objects(
1547 struct super_block *sb,
Vladimir Davydov4101b622015-02-12 14:58:51 -08001548 struct shrink_control *sc)
Dave Chinner8daaa832011-07-08 14:14:46 +10001549{
Vladimir Davydov4101b622015-02-12 14:58:51 -08001550 return xfs_reclaim_inodes_nr(XFS_M(sb), sc->nr_to_scan);
Dave Chinner8daaa832011-07-08 14:14:46 +10001551}
1552
Alexey Dobriyanb87221d2009-09-21 17:01:09 -07001553static const struct super_operations xfs_super_operations = {
Nathan Scotta50cd262006-03-14 14:06:18 +11001554 .alloc_inode = xfs_fs_alloc_inode,
1555 .destroy_inode = xfs_fs_destroy_inode,
Al Virob57922d2010-06-07 14:34:48 -04001556 .evict_inode = xfs_fs_evict_inode,
Dave Chinner5132ba82012-03-22 05:15:10 +00001557 .drop_inode = xfs_fs_drop_inode,
Nathan Scotta50cd262006-03-14 14:06:18 +11001558 .put_super = xfs_fs_put_super,
Christoph Hellwig69961a22009-10-06 20:29:28 +00001559 .sync_fs = xfs_fs_sync_fs,
Takashi Satoc4be0c12009-01-09 16:40:58 -08001560 .freeze_fs = xfs_fs_freeze,
Eric Sandeend5db0f92010-02-05 22:59:53 +00001561 .unfreeze_fs = xfs_fs_unfreeze,
Nathan Scotta50cd262006-03-14 14:06:18 +11001562 .statfs = xfs_fs_statfs,
1563 .remount_fs = xfs_fs_remount,
1564 .show_options = xfs_fs_show_options,
Dave Chinner8daaa832011-07-08 14:14:46 +10001565 .nr_cached_objects = xfs_fs_nr_cached_objects,
1566 .free_cached_objects = xfs_fs_free_cached_objects,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567};
1568
Andrew Morton5085b602007-02-20 13:57:47 -08001569static struct file_system_type xfs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 .owner = THIS_MODULE,
1571 .name = "xfs",
Al Viro152a0832010-07-25 00:46:55 +04001572 .mount = xfs_fs_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 .kill_sb = kill_block_super,
1574 .fs_flags = FS_REQUIRES_DEV,
1575};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08001576MODULE_ALIAS_FS("xfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001578STATIC int __init
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001579xfs_init_zones(void)
1580{
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001581
1582 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
1583 if (!xfs_ioend_zone)
David Chinnerbf904242008-10-30 17:36:14 +11001584 goto out;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001585
1586 xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
1587 xfs_ioend_zone);
1588 if (!xfs_ioend_pool)
1589 goto out_destroy_ioend_zone;
1590
1591 xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
1592 "xfs_log_ticket");
1593 if (!xfs_log_ticket_zone)
1594 goto out_destroy_ioend_pool;
1595
1596 xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
1597 "xfs_bmap_free_item");
1598 if (!xfs_bmap_free_item_zone)
1599 goto out_destroy_log_ticket_zone;
David Chinnerbf904242008-10-30 17:36:14 +11001600
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001601 xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
1602 "xfs_btree_cur");
1603 if (!xfs_btree_cur_zone)
1604 goto out_destroy_bmap_free_item_zone;
1605
1606 xfs_da_state_zone = kmem_zone_init(sizeof(xfs_da_state_t),
1607 "xfs_da_state");
1608 if (!xfs_da_state_zone)
1609 goto out_destroy_btree_cur_zone;
1610
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001611 xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
1612 if (!xfs_ifork_zone)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001613 goto out_destroy_da_state_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001614
1615 xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
1616 if (!xfs_trans_zone)
1617 goto out_destroy_ifork_zone;
1618
Christoph Hellwige98c4142010-06-23 18:11:15 +10001619 xfs_log_item_desc_zone =
1620 kmem_zone_init(sizeof(struct xfs_log_item_desc),
1621 "xfs_log_item_desc");
1622 if (!xfs_log_item_desc_zone)
1623 goto out_destroy_trans_zone;
1624
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001625 /*
1626 * The size of the zone allocated buf log item is the maximum
1627 * size possible under XFS. This wastes a little bit of memory,
1628 * but it is much faster.
1629 */
Dave Chinner77c1a082012-06-22 18:50:07 +10001630 xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
1631 "xfs_buf_item");
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001632 if (!xfs_buf_item_zone)
Christoph Hellwige98c4142010-06-23 18:11:15 +10001633 goto out_destroy_log_item_desc_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001634
1635 xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
1636 ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
1637 sizeof(xfs_extent_t))), "xfs_efd_item");
1638 if (!xfs_efd_zone)
1639 goto out_destroy_buf_item_zone;
1640
1641 xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
1642 ((XFS_EFI_MAX_FAST_EXTENTS - 1) *
1643 sizeof(xfs_extent_t))), "xfs_efi_item");
1644 if (!xfs_efi_zone)
1645 goto out_destroy_efd_zone;
1646
1647 xfs_inode_zone =
1648 kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
David Chinnerbf904242008-10-30 17:36:14 +11001649 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD,
1650 xfs_fs_inode_init_once);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001651 if (!xfs_inode_zone)
1652 goto out_destroy_efi_zone;
1653
1654 xfs_ili_zone =
1655 kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili",
1656 KM_ZONE_SPREAD, NULL);
1657 if (!xfs_ili_zone)
1658 goto out_destroy_inode_zone;
Dave Chinner3ebe7d22013-06-27 16:04:53 +10001659 xfs_icreate_zone = kmem_zone_init(sizeof(struct xfs_icreate_item),
1660 "xfs_icr");
1661 if (!xfs_icreate_zone)
1662 goto out_destroy_ili_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001663
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001664 return 0;
1665
Dave Chinner3ebe7d22013-06-27 16:04:53 +10001666 out_destroy_ili_zone:
1667 kmem_zone_destroy(xfs_ili_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001668 out_destroy_inode_zone:
1669 kmem_zone_destroy(xfs_inode_zone);
1670 out_destroy_efi_zone:
1671 kmem_zone_destroy(xfs_efi_zone);
1672 out_destroy_efd_zone:
1673 kmem_zone_destroy(xfs_efd_zone);
1674 out_destroy_buf_item_zone:
1675 kmem_zone_destroy(xfs_buf_item_zone);
Christoph Hellwige98c4142010-06-23 18:11:15 +10001676 out_destroy_log_item_desc_zone:
1677 kmem_zone_destroy(xfs_log_item_desc_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001678 out_destroy_trans_zone:
1679 kmem_zone_destroy(xfs_trans_zone);
1680 out_destroy_ifork_zone:
1681 kmem_zone_destroy(xfs_ifork_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001682 out_destroy_da_state_zone:
1683 kmem_zone_destroy(xfs_da_state_zone);
1684 out_destroy_btree_cur_zone:
1685 kmem_zone_destroy(xfs_btree_cur_zone);
1686 out_destroy_bmap_free_item_zone:
1687 kmem_zone_destroy(xfs_bmap_free_item_zone);
1688 out_destroy_log_ticket_zone:
1689 kmem_zone_destroy(xfs_log_ticket_zone);
1690 out_destroy_ioend_pool:
1691 mempool_destroy(xfs_ioend_pool);
1692 out_destroy_ioend_zone:
1693 kmem_zone_destroy(xfs_ioend_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001694 out:
1695 return -ENOMEM;
1696}
1697
1698STATIC void
1699xfs_destroy_zones(void)
1700{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001701 /*
1702 * Make sure all delayed rcu free are flushed before we
1703 * destroy caches.
1704 */
1705 rcu_barrier();
Dave Chinner3ebe7d22013-06-27 16:04:53 +10001706 kmem_zone_destroy(xfs_icreate_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001707 kmem_zone_destroy(xfs_ili_zone);
1708 kmem_zone_destroy(xfs_inode_zone);
1709 kmem_zone_destroy(xfs_efi_zone);
1710 kmem_zone_destroy(xfs_efd_zone);
1711 kmem_zone_destroy(xfs_buf_item_zone);
Christoph Hellwige98c4142010-06-23 18:11:15 +10001712 kmem_zone_destroy(xfs_log_item_desc_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001713 kmem_zone_destroy(xfs_trans_zone);
1714 kmem_zone_destroy(xfs_ifork_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001715 kmem_zone_destroy(xfs_da_state_zone);
1716 kmem_zone_destroy(xfs_btree_cur_zone);
1717 kmem_zone_destroy(xfs_bmap_free_item_zone);
1718 kmem_zone_destroy(xfs_log_ticket_zone);
1719 mempool_destroy(xfs_ioend_pool);
1720 kmem_zone_destroy(xfs_ioend_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001721
1722}
1723
1724STATIC int __init
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001725xfs_init_workqueues(void)
1726{
1727 /*
Dave Chinnerc999a222012-03-22 05:15:07 +00001728 * The allocation workqueue can be used in memory reclaim situations
1729 * (writepage path), and parallelism is only limited by the number of
1730 * AGs in all the filesystems mounted. Hence use the default large
1731 * max_active value for this workqueue.
1732 */
Brian Foster8018ec02014-09-09 11:44:46 +10001733 xfs_alloc_wq = alloc_workqueue("xfsalloc",
1734 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0);
Dave Chinnerc999a222012-03-22 05:15:07 +00001735 if (!xfs_alloc_wq)
Dave Chinner58896082012-10-08 21:56:05 +11001736 return -ENOMEM;
Dave Chinnerc999a222012-03-22 05:15:07 +00001737
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001738 return 0;
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001739}
1740
Luck, Tony39411f82011-04-11 12:06:12 -07001741STATIC void
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001742xfs_destroy_workqueues(void)
1743{
Dave Chinnerc999a222012-03-22 05:15:07 +00001744 destroy_workqueue(xfs_alloc_wq);
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001745}
1746
1747STATIC int __init
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001748init_xfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749{
1750 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
Christoph Hellwig65795912008-11-28 14:23:33 +11001752 printk(KERN_INFO XFS_VERSION_STRING " with "
1753 XFS_BUILD_OPTIONS " enabled\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001755 xfs_dir_startup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
Nathan Scott87582802006-03-14 13:18:19 +11001757 error = xfs_init_zones();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001758 if (error)
1759 goto out;
1760
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001761 error = xfs_init_workqueues();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001762 if (error)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001763 goto out_destroy_zones;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001764
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001765 error = xfs_mru_cache_init();
1766 if (error)
1767 goto out_destroy_wq;
1768
Nathan Scottce8e9222006-01-11 15:39:08 +11001769 error = xfs_buf_init();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001770 if (error)
Christoph Hellwig1919add2014-04-23 07:11:51 +10001771 goto out_mru_cache_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001773 error = xfs_init_procfs();
1774 if (error)
1775 goto out_buf_terminate;
1776
1777 error = xfs_sysctl_register();
1778 if (error)
1779 goto out_cleanup_procfs;
1780
Brian Foster3d871222014-07-15 07:41:37 +10001781 xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj);
1782 if (!xfs_kset) {
1783 error = -ENOMEM;
1784 goto out_sysctl_unregister;;
1785 }
1786
Brian Foster65b65732014-09-09 11:52:42 +10001787#ifdef DEBUG
1788 xfs_dbg_kobj.kobject.kset = xfs_kset;
1789 error = xfs_sysfs_init(&xfs_dbg_kobj, &xfs_dbg_ktype, NULL, "debug");
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001790 if (error)
Brian Foster3d871222014-07-15 07:41:37 +10001791 goto out_kset_unregister;
Brian Foster65b65732014-09-09 11:52:42 +10001792#endif
1793
1794 error = xfs_qm_init();
1795 if (error)
1796 goto out_remove_kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
1798 error = register_filesystem(&xfs_fs_type);
1799 if (error)
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001800 goto out_qm_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 return 0;
1802
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001803 out_qm_exit:
1804 xfs_qm_exit();
Brian Foster65b65732014-09-09 11:52:42 +10001805 out_remove_kobj:
1806#ifdef DEBUG
1807 xfs_sysfs_del(&xfs_dbg_kobj);
Brian Foster3d871222014-07-15 07:41:37 +10001808 out_kset_unregister:
Brian Foster65b65732014-09-09 11:52:42 +10001809#endif
Brian Foster3d871222014-07-15 07:41:37 +10001810 kset_unregister(xfs_kset);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001811 out_sysctl_unregister:
1812 xfs_sysctl_unregister();
1813 out_cleanup_procfs:
1814 xfs_cleanup_procfs();
1815 out_buf_terminate:
Nathan Scottce8e9222006-01-11 15:39:08 +11001816 xfs_buf_terminate();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001817 out_mru_cache_uninit:
1818 xfs_mru_cache_uninit();
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001819 out_destroy_wq:
1820 xfs_destroy_workqueues();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001821 out_destroy_zones:
Nathan Scott87582802006-03-14 13:18:19 +11001822 xfs_destroy_zones();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001823 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 return error;
1825}
1826
1827STATIC void __exit
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001828exit_xfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829{
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001830 xfs_qm_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 unregister_filesystem(&xfs_fs_type);
Brian Foster65b65732014-09-09 11:52:42 +10001832#ifdef DEBUG
1833 xfs_sysfs_del(&xfs_dbg_kobj);
1834#endif
Brian Foster3d871222014-07-15 07:41:37 +10001835 kset_unregister(xfs_kset);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001836 xfs_sysctl_unregister();
1837 xfs_cleanup_procfs();
Nathan Scottce8e9222006-01-11 15:39:08 +11001838 xfs_buf_terminate();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001839 xfs_mru_cache_uninit();
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001840 xfs_destroy_workqueues();
Nathan Scott87582802006-03-14 13:18:19 +11001841 xfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842}
1843
1844module_init(init_xfs_fs);
1845module_exit(exit_xfs_fs);
1846
1847MODULE_AUTHOR("Silicon Graphics, Inc.");
1848MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1849MODULE_LICENSE("GPL");